# ============
OPTION(SALOME_BUILD_TESTS "Build SALOME tests" ON)
OPTION(SALOME_BUILD_DOC "Generate SALOME SMESH documentation" ON)
-
+
# Advanced options:
OPTION(SALOME_BUILD_GUI "Enable GUI" ON)
OPTION(SALOME_SMESH_USE_CGNS "Enable import/export to CGNS format" OFF)
IF(EXISTS ${GUI_ROOT_DIR})
FIND_PACKAGE(SalomeGUI)
SALOME_GUI_WITH_CORBA() #check whether GUI built with CORBA
- SALOME_GUI_MODE(SALOME_USE_VTKVIEWER SALOME_USE_SALOMEOBJECT
+ SALOME_GUI_MODE(SALOME_USE_VTKVIEWER SALOME_USE_SALOMEOBJECT
OPTIONAL SALOME_USE_PLOT2DVIEWER SALOME_USE_PYCONSOLE)
##
## Prerequisites From GUI:
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
##
# VTK is obligatiry for the SMESH
FIND_PACKAGE(SalomeVTK REQUIRED)
-FIND_PACKAGE(SalomeOpenCASCADE REQUIRED)
+FIND_PACKAGE(SalomeOpenCASCADE REQUIRED)
IF(SALOME_SMESH_USE_CGNS)
FIND_PACKAGE(SalomeCGNS)
MESSAGE(STATUS "Build MEFISTO2D mesher using Fortran to C generator")
ELSE(${F2C_FOUND})
MESSAGE(FATAL "Fortran to C generator is not found: MEFISTO2D mesher cannot be compiled! Please define F2C_ROOT_DIR !")
- ENDIF(${F2C_FOUND})
+ ENDIF(${F2C_FOUND})
ENDIF(WIN32)
+
+SET (SALOME_SMESH_DISABLE_MG_ADAPT OFF)
+IF(WIN32)
+ # On Windows temporarily disable MG_ADAPT
+ SET (SALOME_SMESH_DISABLE_MG_ADAPT ON)
+ENDIF()
+IF(SALOME_SMESH_DISABLE_MG_ADAPT)
+ ADD_DEFINITIONS(-DDISABLE_MG_ADAPT)
+ENDIF()
+
IF(SALOME_SMESH_ENABLE_MEFISTO)
SET(MEFISTO2D_NAME "MEFISTO_2D")
ELSE(SALOME_SMESH_ENABLE_MEFISTO)
SET(SALOME_INSTALL_LIBS "${SALOME_INSTALL_LIBS}" CACHE PATH "Install path: SALOME libs")
SET(SALOME_INSTALL_IDLS "${SALOME_INSTALL_IDLS}" CACHE PATH "Install path: SALOME IDL files")
SET(SALOME_INSTALL_HEADERS "${SALOME_INSTALL_HEADERS}" CACHE PATH "Install path: SALOME headers")
-SET(SALOME_INSTALL_SCRIPT_SCRIPTS "${SALOME_INSTALL_SCRIPT_SCRIPTS}" CACHE PATH
+SET(SALOME_INSTALL_SCRIPT_SCRIPTS "${SALOME_INSTALL_SCRIPT_SCRIPTS}" CACHE PATH
"Install path: SALOME scripts")
-SET(SALOME_INSTALL_SCRIPT_DATA "${SALOME_INSTALL_SCRIPT_DATA}" CACHE PATH
+SET(SALOME_INSTALL_SCRIPT_DATA "${SALOME_INSTALL_SCRIPT_DATA}" CACHE PATH
"Install path: SALOME script data")
-SET(SALOME_INSTALL_SCRIPT_PYTHON "${SALOME_INSTALL_SCRIPT_PYTHON}" CACHE PATH
+SET(SALOME_INSTALL_SCRIPT_PYTHON "${SALOME_INSTALL_SCRIPT_PYTHON}" CACHE PATH
"Install path: SALOME Python scripts")
-SET(SALOME_INSTALL_APPLISKEL_SCRIPTS "${SALOME_INSTALL_APPLISKEL_SCRIPTS}" CACHE PATH
+SET(SALOME_INSTALL_APPLISKEL_SCRIPTS "${SALOME_INSTALL_APPLISKEL_SCRIPTS}" CACHE PATH
"Install path: SALOME application skeleton - scripts")
-SET(SALOME_INSTALL_APPLISKEL_PYTHON "${SALOME_INSTALL_APPLISKEL_PYTHON}" CACHE PATH
+SET(SALOME_INSTALL_APPLISKEL_PYTHON "${SALOME_INSTALL_APPLISKEL_PYTHON}" CACHE PATH
"Install path: SALOME application skeleton - Python")
SET(SALOME_INSTALL_PYTHON "${SALOME_INSTALL_PYTHON}" CACHE PATH "Install path: SALOME Python stuff")
-SET(SALOME_INSTALL_PYTHON_SHARED "${SALOME_INSTALL_PYTHON_SHARED}" CACHE PATH
+SET(SALOME_INSTALL_PYTHON_SHARED "${SALOME_INSTALL_PYTHON_SHARED}" CACHE PATH
"Install path: SALOME Python shared modules")
-SET(SALOME_INSTALL_CMAKE_LOCAL "${SALOME_INSTALL_CMAKE_LOCAL}" CACHE PATH
- "Install path: local SALOME CMake files")
+SET(SALOME_INSTALL_CMAKE_LOCAL "${SALOME_INSTALL_CMAKE_LOCAL}" CACHE PATH
+ "Install path: local SALOME CMake files")
SET(SALOME_INSTALL_AMCONFIG_LOCAL "${SALOME_INSTALL_AMCONFIG_LOCAL}" CACHE PATH
"Install path: local SALOME config files (obsolete, to be removed)")
SET(SALOME_INSTALL_RES "${SALOME_INSTALL_RES}" CACHE PATH "Install path: SALOME resources")
SET(SALOME_INSTALL_DOC "${SALOME_INSTALL_DOC}" CACHE PATH "Install path: SALOME documentation")
# Specific to SMESH:
-SET(SALOME_SMESH_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/smesh" CACHE PATH
+SET(SALOME_SMESH_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/smesh" CACHE PATH
"Install path: SALOME SMESH specific data")
-SET(SALOME_SMESH_INSTALL_PLUGINS share/salome/plugins/smesh CACHE PATH
+SET(SALOME_SMESH_INSTALL_PLUGINS share/salome/plugins/smesh CACHE PATH
"Install path: SALOME SMESH plugins")
-
+
MARK_AS_ADVANCED(SALOME_INSTALL_BINS SALOME_INSTALL_LIBS SALOME_INSTALL_IDLS SALOME_INSTALL_HEADERS)
MARK_AS_ADVANCED(SALOME_INSTALL_SCRIPT_SCRIPTS SALOME_INSTALL_SCRIPT_DATA SALOME_INSTALL_SCRIPT_PYTHON)
MARK_AS_ADVANCED(SALOME_INSTALL_APPLISKEL_SCRIPTS SALOME_INSTALL_APPLISKEL_PYTHON SALOME_INSTALL_CMAKE_LOCAL SALOME_INSTALL_RES)
SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_BINS}
${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_PYTHON}
${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_PYTHON_SHARED})
-SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_LIBS})
+SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_LIBS})
-# Sources
+# Sources
# ========
ADD_SUBDIRECTORY(idl)
# List of targets in this project we want to make visible to the rest of the world.
# They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup"
-SET(_${PROJECT_NAME}_exposed_targets
+SET(_${PROJECT_NAME}_exposed_targets
SMESHControls MeshDriver MeshDriverDAT MeshDriverGMF MeshDriverMED
MeshDriverSTL MeshDriverUNV MEDWrapper
SMDS SMESHimpl SMESHEngine SMESHClient SMESHDS
IF(SALOME_SMESH_ENABLE_MEFISTO)
LIST(APPEND _${PROJECT_NAME}_exposed_targets
- MEFISTO2D)
+ MEFISTO2D)
ENDIF(SALOME_SMESH_ENABLE_MEFISTO)
IF(SALOME_BUILD_GUI)
ENDIF(SALOME_BUILD_GUI)
IF(SALOME_SMESH_USE_CGNS)
- LIST(APPEND _${PROJECT_NAME}_exposed_targets
+ LIST(APPEND _${PROJECT_NAME}_exposed_targets
MeshDriverCGNS
)
ENDIF(SALOME_SMESH_USE_CGNS)
SET(MEDFILE_ROOT_DIR "${MEDFILE_ROOT_DIR}")
SET(CGNS_ROOT_DIR "${CGNS_ROOT_DIR}")
SET(TBB_ROOT_DIR "${TBB_ROOT_DIR}")
-
+
SET(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include")
# Build variables that will be expanded when configuring Salome<MODULE>Config.cmake:
DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}")
# Install the export set for use with the install-tree
-INSTALL(EXPORT ${PROJECT_NAME}TargetGroup DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}"
+INSTALL(EXPORT ${PROJECT_NAME}TargetGroup DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}"
FILE ${PROJECT_NAME}Targets.cmake)
SET(SALOME_SMESH_USE_CGNS @SALOME_SMESH_USE_CGNS@)
SET(SALOME_SMESH_USE_TBB @SALOME_SMESH_USE_TBB@)
SET(SALOME_SMESH_ENABLE_MEFISTO @SALOME_SMESH_ENABLE_MEFISTO@)
+SET(SALOME_SMESH_DISABLE_MG_ADAPT @SALOME_SMESH_DISABLE_MG_ADAPT@)
+IF(SALOME_SMESH_DISABLE_MG_ADAPT)
+ LIST(APPEND SMESH_DEFINITIONS "-DDISABLE_MG_ADAPT")
+ENDIF()
IF(NOT WIN32)
LIST(APPEND SMESH_DEFINITIONS "-DENABLE_MEFISTO")
ENDIF(NOT WIN32)
DESTINATION ${TEST_INSTALL_DIRECTORY}
RENAME CTestTestfile.cmake)
INSTALL(FILES tests.set DESTINATION ${TEST_INSTALL_DIRECTORY})
+INSTALL(DIRECTORY MGAdapt_med_files DESTINATION ${TEST_INSTALL_DIRECTORY})
--- /dev/null
+#!/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)
radial_prism_3d_algo.py
test_smeshplugin_mg_tetra_parallele.py
test_smeshplugins.py
+ MGAdaptTests_without_session.py
)
SET(GOOD_TESTS
--- /dev/null
+.. _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`.
* :ref:`creating meshes <about_meshes_page>` in different ways:
- * by meshing geometrical models previously created or imported by the Geometry component;
+ * by meshing geometrical models previously created or imported by the Geometry component;
* bottom-up, using :ref:`mesh edition <modifying_meshes_page>`, especially :ref:`extrusion <extrusion_page>` and :ref:`revolution <revolution_page>`;
- * by generation of the 3D mesh from the 2D mesh not based on the geometry (:ref:`imported <importing_exporting_meshes_page>` for example);
-
+ * by generation of the 3D mesh from the 2D mesh not based on the geometry (:ref:`imported <importing_exporting_meshes_page>` for example);
+
* :ref:`importing and exporting meshes <importing_exporting_meshes_page>` in various formats;
-* :ref:`modifying meshes <modifying_meshes_page>` with a vast array of dedicated operations;
+* :ref:`modifying meshes <modifying_meshes_page>` with a vast array of dedicated operations;
* :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.
Mesh module preferences are described in the :ref:`mesh_preferences_page` section of SALOME Mesh Help.
.. image:: ../images/image7.jpg
- :align: center
+ :align: center
.. centered::
Example of MESH module usage for engineering tasks
grouping_elements
about_filters
about_quality_controls
+ adaptation
measurements
viewing_meshes_overview
smeshpy_interface
- tools
+ tools
mesh_preferences
using_notebook_smesh_page
As soon as a mesh is created, it is possible to manage it via its own
methods, described in class :class:`smeshBuilder.Mesh` documentation.
-Class :class:`smeshstudytools.SMeshStudyTools` provides several methods to manipulate mesh objects in Salome study.
+Class :class:`smeshstudytools.SMeshStudyTools` provides several methods to manipulate mesh objects in Salome study.
A usual workflow to generate a mesh on geometry is following:
maxArea = mefisto.LocalLength( 100. )
netgen.SetMaxSize( 20. )
netgen.SetFineness( smeshBuilder.VeryCoarse )
-
+
#. :ref:`Compute the mesh <compute_anchor>` (generate mesh nodes and elements):
.. code-block:: python
mesh.Compute()
An easiest way to start with Python scripting is to do something in
-GUI and then to get a corresponding Python script via
+GUI and then to get a corresponding Python script via
**File > Dump Study** menu item. Don't forget that you can get
all methods of any object in hand (e.g. a mesh group or a hypothesis)
by calling *dir()* Python built-in function.
tui_transforming_meshes
tui_viewing_meshes
tui_quality_controls
+ tui_adaptation
tui_measurements
tui_work_on_objects_from_gui
tui_notebook_smesh
--- /dev/null
+.. _tui_adaptation_page:
+
+**********
+Adaptation
+**********
+
+.. _tui_mg_adapt:
+
+MG_Adapt
+========
+
+.. literalinclude:: ../../../examples/MGAdaptTests_without_session.py
+ :language: python
+
+:download:`Download this script <../../../examples/MGAdaptTests_without_session.py>`
+
+
+**See Also** the GUI :ref:`adaptation_page`.
SMESH_Pattern.idl
SMESH_MeshEditor.idl
SMESH_Measurements.idl
+ MG_ADAPT.idl
)
SET(_idl_include_dirs
--- /dev/null
+// Copyright (C) 2020-2021 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
+//
+
+#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
+{
+ 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
+ {
+ 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);
+ SMESH::string_array getCustomOptionValuesStrVec();
+ SMESH::string_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
interface FilterManager;
interface SMESH_Pattern;
interface Measurements;
+ interface MG_ADAPT;
+ interface MG_ADAPT_OBJECT;
/*!
* Tags definition
in GEOM::GEOM_Object theGeom,
in double theTolerance );
-
+ MG_ADAPT CreateMG_ADAPT();
+ MG_ADAPT_OBJECT Adaptation(in string adaptType);
+ MG_ADAPT CreateAdaptationHypothesis();
};
};
SET(SMESH_RESOURCES_FILES
ModuleMesh.png
+ adapt_mg_adapt.png
advanced_mesh_info.png
bare_border_face.png
bare_border_volume.png
<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"/>
<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"/>
# CGNS
##
IF(SALOME_SMESH_USE_CGNS)
- SET(SUBDIRS_CGNS
+ SET(SUBDIRS_CGNS
DriverCGNS
)
ENDIF(SALOME_SMESH_USE_CGNS)
# GUI
##
IF(SALOME_BUILD_GUI)
- SET(SUBDIRS_GUI OBJECT
- SMESHFiltersSelection
- SMESHGUI
+ SET(SUBDIRS_GUI OBJECT
+ SMESHFiltersSelection
+ SMESHGUI
PluginUtils
SMESH_SWIG_WITHIHM
StdMeshersGUI
${PROJECT_SOURCE_DIR}/src/SMDS
${PROJECT_SOURCE_DIR}/src/SMESHDS
${PROJECT_SOURCE_DIR}/src/SMESHUtils
+ ${MEDCOUPLING_INCLUDE_DIRS}
)
# additional preprocessor / compiler flags
MeshDriverUNV
MeshDriverGMF
${DriverCGNS_LIB}
+ ${MEDCoupling_medloader}
)
# --- headers ---
SMESH_MesherHelper.hxx
SMESH_ProxyMesh.hxx
SMESH_SMESH.hxx
+ MG_ADAPT.hxx
)
# --- sources ---
SMESH_HypoFilter.cxx
SMESH_ProxyMesh.cxx
SMESH_MesherHelper.cxx
+ MG_ADAPT.cxx
)
# --- rules ---
ADD_LIBRARY(SMESHimpl ${SMESHimpl_SOURCES})
IF(WIN32)
- TARGET_COMPILE_OPTIONS(SMESHimpl PRIVATE /bigobj)
+ TARGET_COMPILE_OPTIONS(SMESHimpl PRIVATE /bigobj)
+ ADD_DEFINITIONS(-DNOMINMAX)
ENDIF(WIN32)
TARGET_LINK_LIBRARIES(SMESHimpl ${_link_LIBRARIES} )
--- /dev/null
+// Copyright (C) 2020-2021 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.hxx"
+
+#include "SMESH_File.hxx"
+#include "SMESH_Comment.hxx"
+
+#include <MEDFileData.hxx>
+#include <MEDFileField.hxx>
+#include <MEDFileMesh.hxx>
+#include <MeshFormatReader.hxx>
+#include <MeshFormatWriter.hxx>
+
+#include <Utils_SALOME_Exception.hxx>
+#include <Basics_Utils.hxx>
+
+#ifndef WIN32
+#include <unistd.h> // getpid()
+#else
+#include <process.h>
+#endif
+#include <fcntl.h>
+#include <array>
+#include <memory> // unique_ptr
+
+typedef SMESH_Comment ToComment;
+
+using namespace MG_ADAPT;
+static std::string removeFile(std::string fileName, int& notOk)
+{
+ std::string errStr;
+ notOk = std::remove(fileName.c_str());
+ if (notOk) errStr = ToComment("\n error while removing file : ") << fileName;
+ else errStr = ToComment("\n file : ") << fileName << " succesfully deleted! \n ";
+
+ return errStr;
+}
+std::string MG_ADAPT::remove_extension(const std::string& filename) {
+ size_t lastdot = filename.find_last_of(".");
+ if (lastdot == std::string::npos) return filename;
+ return filename.substr(0, lastdot);
+}
+namespace
+{
+
+ bool isFileExist( const std::string& fName )
+ {
+ return SMESH_File( fName ).exists();
+ }
+
+// =======================================================================
+med_idt openMedFile(const std::string aFile)
+// =======================================================================
+// renvoie le medId associe au fichier Med apres ouverture
+{
+ med_idt medIdt = MEDfileOpen(aFile.c_str(),MED_ACC_RDONLY);
+ if (medIdt <0)
+ {
+ THROW_SALOME_EXCEPTION("\nThe med file " << aFile << " cannot be opened.\n");
+ }
+ return medIdt;
+}
+
+
+// =======================================================================
+void getTimeStepInfos(std::string aFile, med_int& numdt, med_int& numit, std::string fieldName)
+// =======================================================================
+{
+// Il faut voir si plusieurs maillages
+
+ herr_t erreur = 0 ;
+ med_idt medIdt ;
+
+
+ // Ouverture du fichier
+ //~SCRUTE(aFile.toStdString());
+ medIdt = openMedFile(aFile);
+ if ( medIdt < 0 ) return ;
+ // Lecture du nombre de champs
+ med_int ncha = MEDnField(medIdt) ;
+ if (ncha < 1 )
+ {
+ //~addMessage( ToComment(" error: there is no field in ") << aFile, /*fatal=*/true );
+ return;
+ }
+ // Lecture des caracteristiques du champs
+
+ // Lecture du type du champ, des noms des composantes et du nom de l'unite
+ char nomcha [MED_NAME_SIZE+1];
+ strcpy(nomcha, fieldName.c_str());
+// Lecture du nombre de composantes
+ med_int ncomp = MEDfieldnComponentByName(medIdt, nomcha);
+ char meshname[MED_NAME_SIZE+1];
+ char * comp = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
+ char * unit = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
+ char dtunit[MED_SNAME_SIZE+1];
+ med_bool local;
+ med_field_type typcha;
+ med_int nbofcstp;
+ erreur = MEDfieldInfoByName (medIdt, nomcha, meshname,&local,&typcha,comp,unit,dtunit, &nbofcstp);
+ free(comp);
+ free(unit);
+ if ( erreur < 0 )
+ {
+ //~addMessage( ToComment(" error: error while reading field ") << nomcha << " in file " << aFile , /*fatal=*/true );
+ return;
+ }
+
+ med_float dt;
+ med_int tmp_numdt, tmp_numit;
+
+ //~med_int step = data->myUseLastTimeStep ? nbofcstp : data->myTimeStep+1;
+ //~myPrint("step ", step);
+ erreur = MEDfieldComputingStepInfo ( medIdt, nomcha, 1, &numdt, &numit, &dt );
+ for( int step = 1; step <= nbofcstp; step++ )
+ {
+ erreur = MEDfieldComputingStepInfo ( medIdt, nomcha, step, &tmp_numdt, &tmp_numit, &dt );
+ if(tmp_numdt > numdt)
+ {
+ numdt = tmp_numdt;
+ numit = tmp_numit;
+ }
+ }
+ if ( erreur < 0 )
+ {
+ //~addMessage( ToComment(" error: error while reading field ") << nomcha << "step (numdt, numit) = " <<"("<< numdt<< ", "
+ //numit<< ")" <<" in file " << aFile , /*fatal=*/true );
+ return;
+ }
+
+ // Fermeture du fichier
+ if ( medIdt > 0 ) MEDfileClose(medIdt);
+
+}
+
+struct GET_DEFAULT // struct used to get default value from GetOptionValue()
+{
+ bool isDefault;
+ operator bool* () {
+ return &isDefault;
+ }
+};
+
+class outFileStream : public std::ofstream{
+public:
+ ~outFileStream(){close();} //to close file at dtor
+};
+}
+
+//----------------------------------------------------------------------------------------
+MgAdapt::MgAdapt()
+{
+ data = new MgAdaptHypothesisData();
+ data->myInMeshName = "";
+ data->fromMedFile = defaultFromMedFile();
+ data->myFileInDir = defaultWorkingDirectory();
+ data->myMeshFileIn = "";
+ data->myFileOutDir = defaultWorkingDirectory();
+ data->myOutMeshName = "";
+ data->myMeshFileOut = "";
+ data->myMeshOutMed = defaultMeshOutMed();
+ data->myPublish = defaultPublish();
+ data->myUseLocalMap = defaultUseLocalMap();
+ data->myUseBackgroundMap = defaultUseBackgroundMap();
+ data->myFileSizeMapDir = defaultWorkingDirectory();
+ data->myMeshFileBackground = "";
+ data->myUseConstantValue = defaultUseConstantValue();
+ data->myConstantValue = 0.0;
+ data->myFieldName = "";
+ data->myUseNoTimeStep = defaultUseNoTimeStep();
+ data->myUseLastTimeStep = defaultUseLastTimeStep();
+ data->myUseChosenTimeStep = defaultUseChosenTimeStep();
+ data->myTimeStep = -2;
+ data->myRank = -2;
+ data->myWorkingDir = defaultWorkingDirectory();
+ data->myLogFile = defaultLogFile();
+ data->myVerboseLevel = defaultVerboseLevel();
+ data->myPrintLogInFile = defaultPrintLogInFile();
+ data->myKeepFiles = defaultKeepFiles();
+ data->myRemoveLogOnSuccess = defaultRemoveLogOnSuccess();
+
+ buildModel();
+ setAll();
+}
+MgAdapt::MgAdapt(MgAdaptHypothesisData* myData)
+{
+ data = new MgAdaptHypothesisData();
+ setData(myData);
+ buildModel();
+}
+
+MgAdapt::MgAdapt( const MgAdapt& copy)
+{
+ data = new MgAdaptHypothesisData();
+ MgAdaptHypothesisData *copyData = copy.getData();
+ copyMgAdaptHypothesisData(copyData);
+ setAll();
+
+ this->_option2value = copy._option2value;
+ this->_customOption2value = copy._customOption2value;
+ this->_defaultOptionValues = copy._defaultOptionValues;
+ this->_doubleOptions = copy._doubleOptions;
+ this->_charOptions = copy._charOptions;
+ this->_boolOptions = copy._boolOptions;
+}
+
+//-----------------------------------------------------------------------------------------
+MgAdapt::~MgAdapt()
+{
+ delete data;
+}
+void MgAdapt::buildModel()
+{
+
+ const char* boolOptionNames[] = { "compute_ridges", // yes
+ "" // mark of end
+ };
+ // const char* intOptionNames[] = { "max_number_of_errors_printed", // 1
+ // "max_number_of_threads", // 4
+ // "" // mark of end
+ // };
+ const char* doubleOptionNames[] = { "max_memory", // 0
+ "" // mark of end
+ };
+ const char* charOptionNames[] = { "components", // "yes"
+ "adaptation", // both
+ "" // mark of end
+ };
+
+ int i = 0;
+ while (boolOptionNames[i][0])
+ {
+ _boolOptions.insert( boolOptionNames[i] );
+ _option2value[boolOptionNames[i++]].clear();
+ }
+ // i = 0;
+ // while (intOptionNames[i][0])
+ // _option2value[intOptionNames[i++]].clear();
+
+ i = 0;
+ while (doubleOptionNames[i][0]) {
+ _doubleOptions.insert(doubleOptionNames[i]);
+ _option2value[doubleOptionNames[i++]].clear();
+ }
+ i = 0;
+ while (charOptionNames[i][0]) {
+ _charOptions.insert(charOptionNames[i]);
+ _option2value[charOptionNames[i++]].clear();
+ }
+
+ // default values to be used while MG-Adapt
+
+ _defaultOptionValues["adaptation" ] = "both";
+ _defaultOptionValues["components" ] = "outside components";
+ _defaultOptionValues["compute_ridges"] = "yes";
+ _defaultOptionValues["max_memory" ] = ToComment(defaultMaximumMemory());
+}
+
+//=============================================================================
+TOptionValues MgAdapt::getOptionValues() const
+{
+ TOptionValues vals;
+ TOptionValues::const_iterator op_val = _option2value.begin();
+ for ( ; op_val != _option2value.end(); ++op_val )
+ vals.insert( make_pair( op_val->first, getOptionValue( op_val->first, GET_DEFAULT() )));
+
+ return vals;
+}
+
+std::vector <std::string> MgAdapt::getOptionValuesStrVec() const
+{
+ std::vector <std::string> vals;
+ TOptionValues::const_iterator op_val = _option2value.begin();
+ for ( ; op_val != _option2value.end(); ++op_val )
+ vals.push_back(op_val->first+":"+getOptionValue( op_val->first, GET_DEFAULT() ));
+
+ return vals;
+}
+
+std::vector <std::string> MgAdapt::getCustomOptionValuesStrVec() const
+{
+ std::vector <std::string> vals;
+ TOptionValues::const_iterator op_val;
+ for ( op_val = _customOption2value.begin(); op_val != _customOption2value.end(); ++op_val )
+ {
+ vals.push_back(op_val->first+":"+getOptionValue( op_val->first, GET_DEFAULT() ));
+ }
+ return vals;
+}
+const TOptionValues& MgAdapt::getCustomOptionValues() const
+{
+ return _customOption2value;
+}
+void MgAdapt::setData(MgAdaptHypothesisData* myData)
+{
+ copyMgAdaptHypothesisData(myData);
+ setAll();
+}
+MgAdaptHypothesisData* MgAdapt::getData() const
+{
+ return data;
+}
+void MgAdapt::setMedFileIn(std::string fileName)
+{
+ if ( isFileExist(fileName) )
+ {
+ medFileIn = fileName;
+
+ if (medFileOut == "") // default MED file Out
+ medFileOut = remove_extension( fileName )+ ".adapt.med";
+ }
+ else
+ {
+ THROW_SALOME_EXCEPTION("\nThe file "<< fileName <<" does not exist.\n");
+ }
+}
+
+std::string MgAdapt::getMedFileIn()
+{
+ return medFileIn;
+}
+
+void MgAdapt::setMedFileOut(std::string fileOut)
+{
+ medFileOut = fileOut;
+}
+std::string MgAdapt::getMedFileOut()
+{
+ return medFileOut;
+}
+void MgAdapt::setMeshOutMed(bool mybool)
+{
+ meshOutMed = mybool;
+}
+bool MgAdapt::getMeshOutMed()
+{
+ return meshOutMed;
+}
+void MgAdapt::setPublish(bool mybool)
+{
+ publish = mybool;
+}
+bool MgAdapt::getPublish()
+{
+ return publish;
+}
+void MgAdapt::setFieldName(std::string myFieldName)
+{
+ fieldName = myFieldName;
+}
+std::string MgAdapt::getFieldName()
+{
+ return fieldName;
+}
+void MgAdapt::setTimeStep(int time)
+{
+ timeStep = time;
+}
+int MgAdapt::getTimeStep() const
+{
+ return timeStep;
+}
+
+void MgAdapt::setRankTimeStep(int time, int myRank)
+{
+ timeStep = time;
+ rank = myRank;
+}
+
+int MgAdapt::getRank()
+{
+ return rank;
+}
+void MgAdapt::setTimeStepRankLast()
+{
+ myUseLastTimeStep = true;
+ myUseChosenTimeStep = false;
+ myUseNoTimeStep = false;
+ //~med_int aRank, tmst;
+ //~std::string fieldFile = useBackgroundMap ? sizeMapFile : medFileIn;
+ //~getTimeStepInfos(fieldFile, tmst, aRank);
+ //~setRankTimeStep((int) tmst, (int) aRank);
+}
+void MgAdapt::setNoTimeStep()
+{
+ myUseLastTimeStep = false;
+ myUseChosenTimeStep = false;
+ myUseNoTimeStep = true;
+ //~int aRank = (int)MED_NO_IT;
+ //~int tmst = (int)MED_NO_DT ;
+ //~setRankTimeStep(tmst, aRank);
+}
+void MgAdapt::setChosenTimeStepRank()
+{
+ myUseLastTimeStep = false;
+ myUseChosenTimeStep = true;
+ myUseNoTimeStep = false;
+ //~int aRank = (int)MED_NO_IT;
+ //~int tmst = (int)MED_NO_DT ;
+ //~setRankTimeStep(tmst, aRank);
+}
+void MgAdapt::setUseLocalMap(bool myLocal)
+{
+ useLocalMap = myLocal;
+}
+
+bool MgAdapt::getUseLocalMap()
+{
+ return useLocalMap;
+}
+
+void MgAdapt::setUseBackgroundMap(bool bckg)
+{
+ useBackgroundMap = bckg;
+}
+
+bool MgAdapt::getUseBackgroundMap()
+{
+ return useBackgroundMap;
+}
+
+void MgAdapt::setUseConstantValue(bool cnst)
+{
+ useConstantValue = cnst;
+}
+bool MgAdapt::getUseConstantValue()
+{
+ return useConstantValue;
+}
+void MgAdapt::setLogFile(std::string myLogFile)
+{
+ logFile = myLogFile;
+}
+std::string MgAdapt::getLogFile()
+{
+ return logFile;
+}
+void MgAdapt::setVerbosityLevel(int verboLevel)
+{
+ verbosityLevel = verboLevel;
+}
+int MgAdapt::getVerbosityLevel()
+{
+ return verbosityLevel;
+}
+void MgAdapt::setRemoveOnSuccess(bool rmons)
+{
+ removeOnSuccess = rmons;
+}
+bool MgAdapt::getRemoveOnSuccess()
+{
+ return removeOnSuccess;
+}
+void MgAdapt::setSizeMapFile(std::string mapFile)
+{
+ if ( mapFile == "" || isFileExist(mapFile) )
+ {
+ sizeMapFile = mapFile;
+ }
+ else
+ {
+ THROW_SALOME_EXCEPTION("\nThe file "<< mapFile <<" does not exist.\n");
+ }
+}
+std::string MgAdapt::getSizeMapFile()
+{
+ return sizeMapFile;
+}
+
+void MgAdapt::setMeshName(std::string name)
+{
+ meshName = name;
+}
+std::string MgAdapt::getMeshName()
+{
+ return meshName;
+}
+void MgAdapt::setMeshNameOut(std::string name)
+{
+ meshNameOut = name;
+}
+std::string MgAdapt::getMeshNameOut()
+{
+ return meshNameOut;
+}
+void MgAdapt::setFromMedFile(bool mybool)
+{
+ fromMedFile = mybool;
+}
+bool MgAdapt::isFromMedFile()
+{
+ return fromMedFile;
+}
+void MgAdapt::setConstantValue(double cnst)
+{
+ constantValue = cnst;
+}
+double MgAdapt::getConstantValue() const
+{
+ return constantValue;
+}
+
+void MgAdapt::setWorkingDir(std::string dir)
+{
+ workingDir = dir;
+}
+std::string MgAdapt::getWorkingDir() const
+{
+ return workingDir;
+}
+void MgAdapt::setKeepWorkingFiles(bool mybool)
+{
+ toKeepWorkingFiles = mybool;
+}
+bool MgAdapt::getKeepWorkingFiles()
+{
+ return toKeepWorkingFiles;
+}
+void MgAdapt::setPrintLogInFile(bool print)
+{
+ printLogInFile = print;
+}
+bool MgAdapt::getPrintLogInFile()
+{
+ return printLogInFile;
+}
+
+bool MgAdapt::setAll()
+{
+
+ setFromMedFile(data->fromMedFile);
+ std::string file;
+ checkDirPath(data->myFileInDir);
+ file = data->myFileInDir+data->myMeshFileIn;
+ setMedFileIn(file);
+ setMeshName(data->myInMeshName);
+ setMeshNameOut(data->myOutMeshName);
+ checkDirPath(data->myFileOutDir);
+ std::string out = data->myFileOutDir+data->myMeshFileOut;
+ setMedFileOut(out);
+ setPublish(data->myPublish);
+ setMeshOutMed(data->myMeshOutMed);
+ setUseLocalMap(data->myUseLocalMap);
+ setUseBackgroundMap(data->myUseBackgroundMap);
+ setUseConstantValue(data->myUseConstantValue);
+
+ std::string mapfile;
+ if (useBackgroundMap)
+ {
+ checkDirPath(data->myFileSizeMapDir);
+ mapfile = data->myFileSizeMapDir+data->myMeshFileBackground;
+ setFieldName(data->myFieldName);
+ }
+ else if (useConstantValue)
+ {
+ setConstantValue(data->myConstantValue);
+ }
+ else
+ {
+ mapfile ="";
+ setConstantValue(0.0);
+ setFieldName(data->myFieldName);
+ }
+
+ setSizeMapFile(mapfile);
+ if (data->myUseNoTimeStep)
+ setNoTimeStep();
+ else if (data->myUseLastTimeStep)
+ setTimeStepRankLast();
+ else
+ {
+ setChosenTimeStepRank();
+ setRankTimeStep(data->myTimeStep, data->myRank);
+ }
+ /* Advanced options */
+ setWorkingDir(data->myWorkingDir);
+ checkDirPath(data->myWorkingDir);
+ setLogFile(data->myWorkingDir+defaultLogFile());
+ setVerbosityLevel(data->myVerboseLevel);
+ setRemoveOnSuccess(data->myRemoveLogOnSuccess);
+ setPrintLogInFile(data->myPrintLogInFile);
+ setKeepWorkingFiles(data->myKeepFiles);
+
+ return true;
+}
+
+void MgAdapt::checkDirPath(std::string& dirPath)
+{
+ const char lastChar = *dirPath.rbegin();
+#ifdef WIN32
+ if(lastChar != '\\') dirPath+='\\';
+#else
+ if(lastChar != '/') dirPath+='/';
+#endif
+}
+//=============================================================================
+void MgAdapt::setOptionValue(const std::string& optionName,
+ const std::string& optionValue)
+{
+// INFOS("setOptionValue");
+// std::cout << "optionName: " << optionName << ", optionValue: " << optionValue << std::endl;
+ TOptionValues::iterator op_val = _option2value.find(optionName);
+ if (op_val == _option2value.end())
+ {
+ op_val = _customOption2value.find( optionName );
+ _customOption2value[ optionName ] = optionValue;
+ return;
+ }
+
+ if (op_val->second != optionValue)
+ {
+ std::string lowerOptionValue = toLowerStr(optionValue);
+ const char* ptr = lowerOptionValue.c_str();
+ // strip white spaces
+ while (ptr[0] == ' ')
+ ptr++;
+ size_t i = strlen(ptr);
+ while (i != 0 && ptr[i - 1] == ' ')
+ i--;
+ // check value type
+ bool typeOk = true;
+ std::string typeName;
+ if (i == 0)
+ {
+ // empty string
+ }
+ else if (_charOptions.count(optionName))
+ {
+ // do not check strings
+ }
+ else if (_doubleOptions.count(optionName))
+ {
+ // check if value is double
+ toDbl(ptr, &typeOk);
+ typeName = "real";
+ }
+ else if (_boolOptions.count(optionName))
+ {
+ // check if value is bool
+ toBool(ptr, &typeOk);
+ typeName = "bool";
+ }
+ else
+ {
+ // check if value is int
+ toInt(ptr, &typeOk);
+ typeName = "integer";
+ }
+ if ( typeOk ) // check some specific values ?
+ {
+ }
+ if ( !typeOk )
+ {
+ std::string msg = "Advanced option '" + optionName + "' = '" + optionValue + "' but must be " + typeName;
+ throw std::invalid_argument(msg);
+ }
+ std::string value( ptr, i );
+// std::cout << "==> value: " << value << std::endl;
+ if ( _defaultOptionValues[ optionName ] == value ) value.clear();
+
+// std::cout << "==> value: " << value << std::endl;
+ op_val->second = value;
+ }
+}
+//=============================================================================
+//! Return option value. If isDefault provided, it can be a default value,
+// then *isDefault == true. If isDefault is not provided, the value will be
+// empty if it equals a default one.
+std::string MgAdapt::getOptionValue(const std::string& optionName, bool* isDefault) const
+{
+// INFOS("getOptionValue");
+// std::cout << "optionName: " << optionName << ", isDefault: " << isDefault << std::endl;
+ TOptionValues::const_iterator op_val = _option2value.find(optionName);
+ if (op_val == _option2value.end())
+ {
+ op_val = _customOption2value.find(optionName);
+ if (op_val == _customOption2value.end())
+ {
+ std::string msg = "Unknown MG-Adapt option: <" + optionName + ">";
+ throw std::invalid_argument(msg);
+ }
+ }
+ std::string val = op_val->second;
+ if ( isDefault ) *isDefault = ( val.empty() );
+
+ if ( val.empty() && isDefault )
+ {
+ op_val = _defaultOptionValues.find( optionName );
+ if (op_val != _defaultOptionValues.end()) val = op_val->second;
+ }
+// std::cout << "==> val: " << val << std::endl;
+
+ return val;
+}
+//================================================================================
+/*!
+ * \brief Converts a string to a real value
+ */
+//================================================================================
+
+double MgAdapt::toDbl(const std::string& str, bool* isOk )
+{
+ if ( str.empty() ) throw std::invalid_argument("Empty value provided");
+
+ char * endPtr;
+ double val = strtod(&str[0], &endPtr);
+ bool ok = (&str[0] != endPtr);
+
+ if ( isOk ) *isOk = ok;
+
+ if ( !ok )
+ {
+ std::string msg = "Not a real value:'" + str + "'";
+ throw std::invalid_argument(msg);
+ }
+ return val;
+}
+//================================================================================
+/*!
+ * \brief Converts a string to a lower
+ */
+//================================================================================
+std::string MgAdapt::toLowerStr(const std::string& str)
+{
+ std::string s = str;
+ for ( size_t i = 0; i <= s.size(); ++i )
+ s[i] = (char) tolower( s[i] );
+ return s;
+}
+//================================================================================
+/*!
+ * \brief Converts a string to a bool
+ */
+//================================================================================
+
+bool MgAdapt::toBool(const std::string& str, bool* isOk )
+{
+ std::string s = str;
+ if ( isOk ) *isOk = true;
+
+ for ( size_t i = 0; i <= s.size(); ++i )
+ s[i] = (char) tolower( s[i] );
+
+ if ( s == "1" || s == "true" || s == "active" || s == "yes" )
+ return true;
+
+ if ( s == "0" || s == "false" || s == "inactive" || s == "no" )
+ return false;
+
+ if ( isOk )
+ *isOk = false;
+ else
+ {
+ std::string msg = "Not a Boolean value:'" + str + "'";
+ throw std::invalid_argument(msg);
+ }
+ return false;
+}
+//================================================================================
+/*!
+ * \brief Converts a string to a integer value
+ */
+//================================================================================
+
+int MgAdapt::toInt(const std::string& str, bool* isOk )
+{
+ if ( str.empty() ) throw std::invalid_argument("Empty value provided");
+
+ char * endPtr;
+ int val = (int)strtol( &str[0], &endPtr, 10);
+ bool ok = (&str[0] != endPtr);
+
+ if ( isOk ) *isOk = ok;
+
+ if ( !ok )
+ {
+ std::string msg = "Not an integer value:'" + str + "'";
+ throw std::invalid_argument(msg);
+ }
+ return val;
+}
+//=============================================================================
+bool MgAdapt::hasOptionDefined( const std::string& optionName ) const
+{
+ bool isDefault = false;
+ try
+ {
+ getOptionValue( optionName, &isDefault );
+ }
+ catch ( std::invalid_argument )
+ {
+ return false;
+ }
+ return !isDefault;
+}
+//================================================================================
+/*!
+ * \brief Return command to run MG-Adapt mesher excluding file prefix (-f)
+ */
+//================================================================================
+
+std::string MgAdapt::getCommandToRun(MgAdapt* hyp)
+{
+ return hyp ? hyp->getCommandToRun() : ToComment("error with hypothesis!");
+}
+
+int MgAdapt::compute(std::string& errStr)
+{
+ std::string cmd = getCommandToRun();
+// std::cout << cmd << std::endl;
+
+ int err = 0;
+ execCmd( cmd.c_str(), err ); // run
+
+ if ( err )
+ {
+ errStr = ToComment("system(mg-adapt.exe ...) command failed with error: ") << strerror( errno );
+ }
+ else if ( !isFileExist( meshFormatOutputMesh ))
+ {
+ errStr = ToComment(" failed to find file ") << meshFormatOutputMesh
+ << " output from MG-Adapt run";
+ }
+ else
+ {
+ convertMeshFile(meshFormatOutputMesh, solFormatOutput);
+ }
+ if (!err) cleanUp();
+ return err;
+}
+
+void MgAdapt::execCmd( const char* cmd, int& err)
+{
+ err = 1;
+ std::array <char, 128> buffer;
+ std::streambuf* buf;
+ outFileStream fileStream;
+ if (printLogInFile)
+ {
+ fileStream.open(logFile);
+ buf = fileStream.rdbuf();
+ }
+ else
+ {
+ buf = std::cout.rdbuf();
+ }
+ std::ostream logStream(buf);
+
+
+#if defined(WIN32)
+#if defined(UNICODE)
+ const wchar_t * aCmd = Kernel_Utils::utf8_decode(cmd);
+ std::unique_ptr <FILE, decltype(&_pclose)> pipe(_wpopen(aCmd, O_RDONLY), _pclose );
+#else
+ std::unique_ptr <FILE, decltype(&_pclose)> pipe(_popen(cmd, "r"), _pclose );
+#endif
+#else
+ std::unique_ptr <FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose );
+#endif
+
+ if(!pipe)
+ {
+ throw std::runtime_error("popen() failed!");
+ }
+ while(fgets(buffer.data(), buffer.size(), pipe.get()) !=nullptr )
+ {
+ logStream<<buffer.data() ;
+ }
+ err = 0;
+}
+/*
+ * to delete tmp files .mesh, .sol and if needed
+ * the log file
+ *
+ */
+void MgAdapt::cleanUp()
+{
+ int notOk;
+ std::string errStr;
+ if(toKeepWorkingFiles)
+ return;
+ if(removeOnSuccess && printLogInFile)
+ tmpFilesToBeDeleted.push_back(logFile);
+
+ std::vector< std::string>::iterator it = tmpFilesToBeDeleted.begin();
+ for (; it!=tmpFilesToBeDeleted.end(); ++it)
+ {
+ errStr=removeFile(*it, notOk);
+ if (notOk)
+ {
+ appendMsgToLogFile(errStr);
+ }
+
+ }
+}
+
+void MgAdapt::appendMsgToLogFile(std::string& msg)
+{
+ std::ofstream logStream;
+ logStream.open(logFile, std::ofstream::out | std::ofstream::app);
+ logStream<< msg;
+ logStream.close();
+}
+//================================================================================
+/*!
+ * \brief Return command to run MG-Tetra mesher excluding file prefix (-f)
+ */
+//================================================================================
+
+std::string MgAdapt::getCommandToRun()
+{
+ /*
+ || return system command with args and options
+ ||
+ */
+ std::string errStr;
+ std::string cmd = getExeName();
+ std::string meshIn(""), sizeMapIn(""), solFileIn("");
+ updateTimeStepRank();
+ convertMedFile(meshIn, solFileIn, sizeMapIn);
+ if (!isFileExist(meshIn) || !isFileExist(solFileIn))
+ {
+ errStr = ToComment(" failed to find .mesh or .sol file from converter ")<< strerror( errno );
+ return errStr;
+ }
+ tmpFilesToBeDeleted.push_back(meshIn);
+ tmpFilesToBeDeleted.push_back(solFileIn);
+ if(useBackgroundMap && !isFileExist(sizeMapIn))
+ {
+ errStr = ToComment(" failed to find .mesh size map file from converter ")<< strerror( errno );
+ return errStr;
+ }
+
+ cmd+= " --in "+ meshIn;
+ meshFormatOutputMesh = getFileName()+".mesh";
+ tmpFilesToBeDeleted.push_back(meshFormatOutputMesh);
+ cmd+= " --out "+ meshFormatOutputMesh;
+ if (useLocalMap || useConstantValue) cmd+= " --sizemap "+ solFileIn;
+ else // (useBackgroundMap)
+ {
+ cmd+= " --background_mesh "+ sizeMapIn ;
+ cmd+= " --background_sizemap "+ solFileIn;
+ tmpFilesToBeDeleted.push_back(sizeMapIn);
+ }
+ //~else
+ //~{
+ //~// constant value TODO
+ //~}
+ // Check coherence between mesh dimension and option fo adaptation
+ checkDimensionOptionAdaptation();
+
+// sizemap file is written only if level is higher than 3
+ if ( verbosityLevel > 3)
+ {
+ std::string solFileOut = getFileName()+".sol";
+ cmd+= " --write_sizemap "+ solFileOut;
+ solFormatOutput.push_back(solFileOut);
+ tmpFilesToBeDeleted.push_back(solFileOut);
+ }
+
+ std::string option, value;
+ bool isDefault;
+ const TOptionValues* options[] = { &_option2value, &_customOption2value };
+ for ( int iOp = 0; iOp < 2; ++iOp )
+ {
+ TOptionValues::const_iterator o2v = options[iOp]->begin();
+ for ( ; o2v != options[iOp]->end(); ++o2v )
+ {
+ option = o2v->first;
+ value = getOptionValue( option, &isDefault );
+
+ if ( isDefault )
+ continue;
+ if ( value.empty() )//value == NoValue() )
+ {
+ if ( _defaultOptionValues.count( option ))
+ continue; // non-custom option with no value
+ //value.clear();
+ }
+ if ( strncmp( "no", option.c_str(), 2 ) == 0 ) // options w/o values: --no_*
+ {
+ if ( !value.empty() && toBool( value ) == false )
+ continue;
+ value.clear();
+ }
+ if ( option[0] != '-' )
+ cmd += " --";
+ else
+ cmd += " ";
+// std::cout << "--- option: '" << option << ", value: '" << value <<"'"<< std::endl;
+ cmd += option + " " + value;
+ }
+ }
+
+ // Verbosity Level
+ if (verbosityLevel != defaultVerboseLevel())
+ {
+ cmd+= " --verbose "+ ToComment(verbosityLevel);
+ }
+ //~}
+//~cmd+= " >"
+#ifdef WIN32
+ cmd += " < NUL";
+#endif
+// std::cout << "--- cmd :"<< std::endl;
+// std::cout << cmd << std::endl;
+
+ return cmd;
+}
+
+//=======================================================================
+//function : defaultMaximumMemory
+//=======================================================================
+
+#if defined(WIN32)
+#include <windows.h>
+#elif !defined(__APPLE__)
+#include <sys/sysinfo.h>
+#endif
+
+double MgAdapt::defaultMaximumMemory()
+{
+#if defined(WIN32)
+ // See http://msdn.microsoft.com/en-us/library/aa366589.aspx
+ MEMORYSTATUSEX statex;
+ statex.dwLength = sizeof (statex);
+ long err = GlobalMemoryStatusEx (&statex);
+ if (err != 0)
+ {
+ double totMB = (double)statex.ullAvailPhys / 1024. / 1024.;
+ return (double)( 0.7 * totMB );
+ }
+#elif !defined(__APPLE__)
+ struct sysinfo si;
+ long err = sysinfo( &si );
+ if ( err == 0 )
+ {
+ long ramMB = si.totalram * si.mem_unit / 1024 / 1024;
+ return ( 0.7 * double( ramMB ));
+ }
+#endif
+ return 1024;
+}
+
+//=======================================================================
+//function : defaultWorkingDirectory
+//=======================================================================
+
+std::string MgAdapt::defaultWorkingDirectory()
+{
+ std::string aTmpDir;
+
+ char *Tmp_dir = getenv("SALOME_TMP_DIR");
+ if(Tmp_dir != NULL)
+ {
+ aTmpDir = Tmp_dir;
+ }
+ else {
+#ifdef WIN32
+ aTmpDir = "C:\\";
+#else
+ aTmpDir = "/tmp/";
+#endif
+ }
+ return aTmpDir;
+}
+//================================================================================
+/*!
+ * \brief Return a unique file name
+ */
+//================================================================================
+
+std::string MgAdapt::getFileName() const
+{
+ std::string aTmpDir = workingDir;
+ const char lastChar = *aTmpDir.rbegin();
+#ifdef WIN32
+ if(lastChar != '\\') aTmpDir+='\\';
+#else
+ if(lastChar != '/') aTmpDir+='/';
+#endif
+
+ SMESH_Comment aGenericName( aTmpDir );
+ aGenericName << "MgAdapt_";
+#ifndef WIN32
+ aGenericName << getpid();
+#else
+aGenericName << _getpid();
+#endif
+ aGenericName << "_";
+ aGenericName << std::abs((int)(long) aGenericName.data());
+
+ return aGenericName;
+}
+//=======================================================================
+//function : defaultLogFile
+//=======================================================================
+
+std::string MgAdapt::defaultLogFile()
+{
+ std::string alogFile("MG_ADAPT.log");
+ return alogFile;
+}
+//=======================================================================
+//function : defaultUseConstantValue
+//=======================================================================
+
+bool MgAdapt::defaultUseConstantValue()
+{
+ return false;
+}
+//=======================================================================
+//function : defaultUseNoTimeStep
+//=======================================================================
+
+bool MgAdapt::defaultUseNoTimeStep()
+{
+ return true;
+}
+//=======================================================================
+//function : defaultRemoveLogOnSuccess
+//=======================================================================
+
+bool MgAdapt::defaultRemoveLogOnSuccess()
+{
+ return true;
+}
+//=======================================================================
+//function : defaultPrintLogInFile
+//=======================================================================
+
+bool MgAdapt::defaultPrintLogInFile()
+{
+ return false;
+}
+//=======================================================================
+//function : defaultUseChosenTimeStep
+//=======================================================================
+
+bool MgAdapt::defaultUseChosenTimeStep()
+{
+ return false;
+}
+//=======================================================================
+//function : UseLastTimeStep
+//=======================================================================
+
+bool MgAdapt::defaultUseLastTimeStep()
+{
+ return false;
+}
+//=======================================================================
+//function : defaultUseBackgroundMap
+//=======================================================================
+
+bool MgAdapt::defaultUseBackgroundMap()
+{
+ return false;
+}
+//=======================================================================
+//function : defaultKeepFiles
+//=======================================================================
+
+bool MgAdapt::defaultKeepFiles()
+{
+ return false;
+}
+//=======================================================================
+//function : defaultUseLocalMap
+//=======================================================================
+
+bool MgAdapt::defaultUseLocalMap()
+{
+ return true;
+}
+//=======================================================================
+//function : defaultPublish
+//=======================================================================
+
+bool MgAdapt::defaultPublish()
+{
+ return false;
+}
+//=======================================================================
+//function : defaultMeshOutMed
+//=======================================================================
+
+bool MgAdapt::defaultMeshOutMed()
+{
+ return true;
+}
+//=======================================================================
+//function : defaultFromMedFile
+//=======================================================================
+
+bool MgAdapt::defaultFromMedFile()
+{
+ return true;
+}
+//=======================================================================
+//function : defaultVerboseLevel
+//=======================================================================
+
+int MgAdapt::defaultVerboseLevel()
+{
+ return 3;
+}
+std::string MgAdapt::getExeName()
+{
+ return "mg-adapt.exe";
+}
+void MgAdapt::copyMgAdaptHypothesisData( const MgAdaptHypothesisData* from)
+{
+ data->myFileInDir = from->myFileInDir;
+ data->myMeshFileIn = from->myMeshFileIn;
+ data->myMeshFileBackground = from->myMeshFileBackground;
+ data->myOutMeshName = from->myOutMeshName;
+ data->myMeshFileOut = from->myMeshFileOut;
+ data->myFileOutDir = from->myFileOutDir;
+ data->myFileSizeMapDir = from->myFileSizeMapDir;
+ data->myFieldName = from->myFieldName;
+ data->fromMedFile = from->fromMedFile;
+ data->myPublish = from->myPublish;
+ data->myMeshOutMed = from->myMeshOutMed;
+ data->myUseLocalMap = from->myUseLocalMap;
+ data->myUseBackgroundMap = from->myUseBackgroundMap;
+ data->myUseConstantValue = from->myUseConstantValue;
+ data->myConstantValue = from->myConstantValue;
+ data->myTimeStep = from->myTimeStep;
+ data->myRank = from->myRank;
+ data->myUseNoTimeStep = from->myUseNoTimeStep;
+ data->myUseLastTimeStep = from->myUseLastTimeStep;
+ data->myUseChosenTimeStep = from->myUseChosenTimeStep;
+ data->myWorkingDir = from->myWorkingDir;
+ data->myLogFile = from->myLogFile;
+ data->myPrintLogInFile = from->myPrintLogInFile;
+ data->myKeepFiles = from->myKeepFiles;
+ data->myRemoveLogOnSuccess = from->myRemoveLogOnSuccess;
+ data->myVerboseLevel = from->myVerboseLevel;
+}
+
+std::vector<std::string> MgAdapt::getListFieldsNames(std::string fileIn)
+{
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> mfd = MEDCoupling::MEDFileData::New(fileIn);
+ std::vector<std::string> listFieldsNames(mfd->getFields()->getFieldsNames());
+ return listFieldsNames ;
+}
+
+void MgAdapt::checkDimensionOptionAdaptation()
+{
+ // Quand le maillage est 3D, tout est possible
+ // Quand le maillage est 2D, il faut 'surface' sauf si carte de fonds 3D
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> mfd = MEDCoupling::MEDFileData::New(medFileIn);
+ int meshdim = mfd->getMeshes()->getMeshAtPos(0)->getMeshDimension() ;
+// std::cout << "meshdim = " << meshdim << std::endl;
+
+ if ( meshdim == 2 )
+ {
+ std::string optionName = "adaptation";
+ std::string optionValue = getOptionValue(optionName);
+// std::cout << "optionValue = '" << optionValue <<"'"<< std::endl;
+ bool a_tester = false ;
+ // carte locale ou constante : impératif d'avoir "surface"
+ if ( useLocalMap || useConstantValue) a_tester = true ;
+ // carte de fond : impératif d'avoir "surface" si le fonds est aussi 2D
+ else
+ {
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> mfdbg = MEDCoupling::MEDFileData::New(sizeMapFile);
+ int meshdimbg = mfdbg->getMeshes()->getMeshAtPos(0)->getMeshDimension() ;
+// std::cout << "meshdimbg = " << meshdimbg << std::endl;
+ if ( meshdimbg == 2 ) a_tester = true ;
+ }
+ if ( a_tester )
+ {
+ if ( optionValue == "" ) setOptionValue (optionName, "surface");
+ else
+ {
+ if ( optionValue != "surface" )
+ {
+ THROW_SALOME_EXCEPTION("Mesh dimension is 2; the option should be 'surface'"
+ " instead of '" << optionValue << "'.");
+ }
+ }
+ }
+ }
+}
+
+void MgAdapt::checkFieldName(std::string fileIn)
+{
+ bool ret = false ;
+ std::vector<std::string> listFieldsNames = getListFieldsNames(fileIn);
+ std::size_t jaux(listFieldsNames.size());
+ for(std::size_t j=0;j<jaux;j++)
+ {
+ if ( fieldName == listFieldsNames[j] )
+ {
+ ret = true ;
+ break ;
+ }
+ }
+ if ( ! ret )
+ {
+ std::cout << "Available field names:" << std::endl;
+ for(std::size_t j=0;j<jaux;j++)
+ { std::cout << listFieldsNames[j] << std::endl;}
+ THROW_SALOME_EXCEPTION( "Field " << fieldName << " is not found.");
+ }
+}
+
+void MgAdapt::checkTimeStepRank(std::string fileIn)
+{
+ bool ret = false ;
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> mfd = MEDCoupling::MEDFileData::New(fileIn);
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS> fts( mfd->getFields()->getFieldWithName(fieldName) );
+ std::vector<double> timevalue;
+ std::vector< std::pair<int,int> > timesteprank = fts->getTimeSteps(timevalue);
+ std::size_t jaux(timesteprank.size());
+ for(std::size_t j=0;j<jaux;j++)
+ {
+ if ( ( timeStep == timesteprank[j].first ) & ( rank == timesteprank[j].second ) )
+ {
+ ret = true ;
+ break ;
+ }
+ }
+ if ( ! ret )
+ {
+ std::cout << "Available (Time step, Rank):" << std::endl;
+ for(std::size_t j=0;j<jaux;j++)
+ { std::cout << "(Time step = " << timesteprank[j].first << ", Rank = " << timesteprank[j].second << ")" << std::endl;}
+ THROW_SALOME_EXCEPTION("(Time step = " << timeStep << ", Rank = " << rank << ") is not found.");
+ }
+}
+
+void MgAdapt::convertMedFile(std::string& meshFormatMeshFileName, std::string& solFormatFieldFileName, std::string& meshFormatsizeMapFile)
+{
+ std::vector<std::string> fieldFileNames;
+ MEDCoupling::MeshFormatWriter writer;
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> mfd = MEDCoupling::MEDFileData::New(medFileIn);
+ MEDCoupling::MEDFileMeshes* meshes = mfd->getMeshes();
+ MEDCoupling::MEDFileMesh* fileMesh = meshes->getMeshAtPos(0); // ok only one mesh in file!
+ if (meshNameOut =="")
+ meshNameOut = fileMesh->getName();
+ storeGroupsAndFams(fileMesh);
+
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> fields = MEDCoupling::MEDFileFields::New();
+ solFormatFieldFileName = getFileName();
+ solFormatFieldFileName+=".sol";
+ fieldFileNames.push_back(solFormatFieldFileName);
+
+ if (useBackgroundMap)
+ {
+ checkFieldName(sizeMapFile) ;
+ checkTimeStepRank(sizeMapFile) ;
+ meshFormatsizeMapFile = getFileName();
+ meshFormatsizeMapFile += ".mesh";
+ buildBackGroundMeshAndSolFiles(fieldFileNames, meshFormatsizeMapFile);
+ }
+ else if(useLocalMap)
+ {
+ checkFieldName(medFileIn) ;
+ checkTimeStepRank(medFileIn) ;
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS> fts( mfd->getFields()->getFieldWithName(fieldName) );
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeField1TS> f = fts->getTimeStep(timeStep, rank);
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFieldMultiTS> tmFts = MEDCoupling::MEDFileFieldMultiTS::New();
+ tmFts->pushBackTimeStep(f);
+
+ fields->pushField(tmFts);
+
+ writer.setFieldFileNames( fieldFileNames);
+ }
+ else
+ {
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingMesh> mesh = fileMesh->getMeshAtLevel(1); // nodes mesh
+ MEDCoupling::MCAuto<MEDCoupling::MEDCouplingUMesh> umesh = mesh->buildUnstructured(); // nodes mesh
+ int dim = umesh->getSpaceDimension();
+ int version = sizeof(double) < 8 ? 1 : 2;
+ mcIdType nbNodes = umesh->getNumberOfNodes();
+ buildConstantSizeMapSolFile(solFormatFieldFileName, dim, version, nbNodes);
+ }
+
+ mfd->setFields( fields );
+ meshFormatMeshFileName = getFileName();
+ meshFormatMeshFileName+=".mesh";
+ writer.setMeshFileName(meshFormatMeshFileName);
+ writer.setMEDFileDS( mfd);
+ writer.write();
+
+}
+
+void MgAdapt::convertMeshFile(std::string& meshFormatIn, std::vector< std::string>& solFieldFileNames) const
+{
+ MEDCoupling::MeshFormatReader reader(meshFormatIn, solFieldFileNames);
+
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> mfd = reader.loadInMedFileDS();
+ // write MED
+ MEDCoupling::MEDFileMeshes* meshes = mfd->getMeshes();
+ MEDCoupling::MEDFileMesh* fileMesh = meshes->getMeshAtPos(0); // ok only one mesh in file!
+ fileMesh->setName(meshNameOut);
+ restoreGroupsAndFams(fileMesh);
+ mfd->write(medFileOut, 2);
+}
+
+void MgAdapt::storeGroupsAndFams(MEDCoupling::MEDFileMesh* fileMesh)
+{
+ storefams(fileMesh);
+ storeGroups(fileMesh);
+}
+
+void MgAdapt::restoreGroupsAndFams(MEDCoupling::MEDFileMesh* fileMesh) const
+{
+ restorefams(fileMesh);
+ restoreGroups(fileMesh);
+}
+void MgAdapt::storeGroups(MEDCoupling::MEDFileMesh* fileMesh)
+{
+ std::map<std::string, std::vector<std::string> > grpFams = fileMesh->getGroupInfo();
+ std::map<std::string, std::vector<std::string> >::iterator g2ff = grpFams.begin();
+
+ for ( ; g2ff != grpFams.end(); ++g2ff )
+ {
+ std::string groupName = g2ff->first;
+ std::vector<std::string> famNames = g2ff->second;
+
+ if ( famNames.empty() ) continue;
+ std::vector< int> famListId;
+ for ( size_t i = 0; i < famNames.size(); ++i )
+ {
+ famListId.push_back( FromIdType<int>( fileMesh->getFamilyId( famNames[i].c_str() )));
+ }
+ group grp(groupName, famListId, famNames);
+ groupVec.push_back(grp);
+ }
+}
+
+void MgAdapt::storefams(MEDCoupling::MEDFileMesh* fileMesh)
+{
+ std::map<std::string, mcIdType> grpFams = fileMesh->getFamilyInfo();
+ std::map<std::string, mcIdType >::iterator f = grpFams.begin();
+
+ for ( ; f != grpFams.end(); ++f )
+ {
+ if(!f->second) continue; // FAMILLE_ZERO
+ family fs(f->first, FromIdType<int>( f->second ));
+ famVec.push_back(fs);
+ }
+
+}
+
+void MgAdapt::restorefams(MEDCoupling::MEDFileMesh* fileMesh) const
+{
+ std::vector<family>::const_iterator fIt = famVec.begin();
+
+ for (; fIt!=famVec.end(); ++fIt)
+ {
+ try //
+ {
+ std::string givenFamNameFromMeshGemConverter = fileMesh->getFamilyNameGivenId( std::abs(fIt->_famId) );
+ fileMesh->changeFamilyId(std::abs(fIt->_famId), fIt->_famId);
+ fileMesh->changeFamilyName(givenFamNameFromMeshGemConverter, fIt->_famName);
+ }
+ catch (const std::exception& e)
+ {
+ std::cerr<<e.what();
+ }
+ }
+}
+
+void MgAdapt::restoreGroups(MEDCoupling::MEDFileMesh* fileMesh) const
+{
+ std::map<std::string, std::vector<std::string> > info;
+ std::vector <group>::const_iterator grpFams = groupVec.begin();
+
+ for (; grpFams!=groupVec.end(); ++grpFams)
+ {
+ info.insert(std::pair <std::string, std::vector<std::string> > (grpFams->_name, grpFams->_famNames) );
+ }
+
+ fileMesh->setGroupInfo(info);
+}
+
+void MgAdapt::buildConstantSizeMapSolFile(const std::string& solFormatFieldFileName, const int dim, const int version, const size_t nbNodes) const
+{
+ MeshFormat::Localizer loc;
+ MeshFormat::MeshFormatParser writer;
+ int fileId = writer.GmfOpenMesh( solFormatFieldFileName.c_str(), GmfWrite, version, dim);
+ int typTab[] = {GmfSca};
+ writer.GmfSetKwd(fileId, MeshFormat::GmfSolAtVertices, (int)nbNodes, 1, typTab);
+ for (size_t i = 0; i<nbNodes; i++)
+ {
+ double valTab[1] = {constantValue};
+ writer.GmfSetLin( fileId, MeshFormat::GmfSolAtVertices, valTab);
+ }
+ writer.GmfCloseMesh(fileId);
+}
+
+void MgAdapt::buildBackGroundMeshAndSolFiles(const std::vector<std::string>& fieldFileNames, const std::string& meshFormatsizeMapFile) const
+{
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileData> tmpMfd = MEDCoupling::MEDFileData::New(sizeMapFile);
+ MEDCoupling::MEDFileFields* tmpFields = tmpMfd->getFields();
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS> fts( tmpFields->getFieldWithName(fieldName) );
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFieldMultiTS> fts1 = MEDCoupling::DynamicCastSafe<MEDCoupling::MEDFileAnyTypeFieldMultiTS,MEDCoupling::MEDFileFieldMultiTS>(fts);
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeField1TS> f = fts1->getTimeStep(timeStep, rank);
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFieldMultiTS> tmFts = MEDCoupling::MEDFileFieldMultiTS::New();
+ tmFts->pushBackTimeStep(f);
+
+ MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> tmp_fields = MEDCoupling::MEDFileFields::New();
+ tmp_fields->pushField(tmFts);
+
+ tmpMfd->setFields( tmp_fields );
+ MEDCoupling::MeshFormatWriter tmpWriter;
+ tmpWriter.setMeshFileName(meshFormatsizeMapFile);
+ tmpWriter.setFieldFileNames( fieldFileNames);
+ tmpWriter.setMEDFileDS(tmpMfd);
+ tmpWriter.write();
+}
+
+MgAdapt::Status MgAdapt::addMessage(const std::string& msg,
+ const bool isFatal/*=false*/)
+{
+ if ( isFatal )
+ _myErrorMessages.clear(); // warnings are useless if a fatal error encounters
+
+ _myErrorMessages.push_back( msg );
+
+//~MESSAGE(msg);
+#ifdef _DEBUG_
+ std::cout << msg << std::endl;
+#endif
+ return ( _myStatus = isFatal ? MgAdapt::DRS_FAIL : MgAdapt::DRS_WARN_SKIP_ELEM );
+}
+
+void MgAdapt::updateTimeStepRank()
+{
+
+ med_int arank;
+ med_int tmst;
+ if (myUseNoTimeStep)
+ {
+ arank = MED_NO_IT;
+ tmst = MED_NO_DT ;
+ setRankTimeStep((int)tmst, (int)arank);
+ }
+ else if (myUseLastTimeStep)
+ {
+ std::string fieldFile = useBackgroundMap ? sizeMapFile : medFileIn;
+ getTimeStepInfos(fieldFile, tmst, arank, fieldName);
+ setRankTimeStep((int)tmst, (int)arank);
+ }
+}
--- /dev/null
+// Copyright (C) 2020-2021 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
+//
+
+#ifndef MG_ADAPT_HXX
+#define MG_ADAPT_HXX
+
+#include <string>
+#include <map>
+#include <vector>
+#include <set>
+
+#include "SMESH_SMESH.hxx"
+
+namespace MEDCoupling
+{
+ class MEDFileMesh;
+}
+
+namespace MG_ADAPT
+{
+typedef std::map< std::string, std::string > TOptionValues;
+typedef std::set< std::string > TOptionNames;
+
+std::string remove_extension(const std::string& filename);
+
+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 SMESH_EXPORT 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);
+ std::string getOptionValue(const std::string& optionName,
+ bool* isDefault=0) const;
+ 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);
+ static bool toBool(const std::string&, bool* isOk = 0);
+ static int toInt(const std::string&, bool* isOk = 0 );
+ 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();
+
+ 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<int> _famListId;
+ std::vector<std::string> _famNames;
+ group(std::string name, std::vector<int> famListId, std::vector<std::string> famNames)
+ :_name(name), _famListId( famListId ), _famNames( famNames ) {}
+ };
+
+ struct family
+ {
+ std::string _famName;
+ int _famId;
+ family(std::string famName, int 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 size_t nbNodes) const;
+ void buildBackGroundMeshAndSolFiles(const std::vector<std::string>& fieldFileNames, const std::string& meshFormatsizeMapFile) const;
+ Status addMessage(const std::string& msg, const bool isFatal = false);
+ 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) ;
+
+};
+
+} // namespace MG_ADAPT
+
+#endif // MG_ADAPT_HXX
SMESHGUI_SplitBiQuad.h
SMESHGUI_IdPreview.h
SMESHGUI_PreVisualObj.h
+ SMESHGUI_MG_ADAPTDRIVER.h
+ SMESHGUI_MgAdaptDlg.h
)
# header files / no moc processing
SMESHGUI_SplitBiQuad.cxx
SMESHGUI_PreVisualObj.cxx
SMESHGUI_IdPreview.cxx
+ SMESHGUI_MG_ADAPTDRIVER.cxx
+ SMESHGUI_MgAdaptDlg.cxx
)
# sources / to compile
SMESH_msg_en.ts
SMESH_msg_fr.ts
SMESH_msg_ja.ts
-)
+)
# --- rules ---
#include "SMESHGUI_GroupUtils.h"
#include "SMESHGUI_Hypotheses.h"
#include "SMESHGUI_HypothesesUtils.h"
+#include "SMESHGUI_MG_ADAPTDRIVER.h"
#include "SMESHGUI_Make2DFrom3DOp.h"
#include "SMESHGUI_MakeNodeAtPointDlg.h"
#include "SMESHGUI_Measurements.h"
#include <vtkRenderer.h>
// SALOME KERNEL includes
+#include <Basics_Utils.hxx>
#include <SALOMEDSClient_ClientFactory.hxx>
#include <SALOMEDSClient_IParameters.hxx>
#include <SALOMEDSClient_SComponent.hxx>
#include <SALOMEDSClient_StudyBuilder.hxx>
-#include <SALOMEDS_Study.hxx>
#include <SALOMEDS_SObject.hxx>
-#include "utilities.h"
+#include <SALOMEDS_Study.hxx>
+#include <SALOME_GenericObj_wrap.hxx>
#include <SALOME_LifeCycleCORBA.hxx>
+#include <utilities.h>
// OCCT includes
#include <Standard_ErrorHandler.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_DoubleMap.hxx>
-#include <Basics_Utils.hxx>
-
// Below macro, when uncommented, switches on simplified (more performant) algorithm
// of auto-color picking up
#define SIMPLE_AUTOCOLOR
int objectCount = 0;
QString aNameList;
QString aParentComponent = QString::null;
-
+
for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
{
Handle(SALOME_InteractiveObject) anIO = anIt.Value();
if ( anIO.IsNull() ) continue;
-
+
QString father = "unknown", name;
_PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
}
break;
}
+ // Adaptation - begin
+#ifndef DISABLE_MG_ADAPT
+ case SMESHOp::OpMGAdapt:
+ {
+ if ( isStudyLocked() )
+ break;
+ EmitSignalDeactivateDialog();
+
+ SALOME::GenericObj_wrap< SMESH::MG_ADAPT > model = GetSMESHGen()->CreateMG_ADAPT();
+ bool isCreation = false;
+ ( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
+ break;
+ }
+#endif
+ // Adaptation - end
case SMESHOp::OpSplitBiQuadratic:
case SMESHOp::OpConvertMeshToQuadratic:
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
+ // Adaptation - begin
+#ifndef DISABLE_MG_ADAPT
+ createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
+#endif
+ // 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" );
meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
+#ifndef DISABLE_MG_ADAPT
+ adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
+#endif
measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
+ // Adaptation - begin
+#ifndef DISABLE_MG_ADAPT
+ createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
+#endif
+ // Adaptation - end
+
createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
createMenu( SMESHOp::OpAngle, measureId, -1 );
connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
// ----- create toolbars --------------
- 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" ) );
-
+ int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
createTool( SMESHOp::OpCreateMesh, meshTb );
createTool( SMESHOp::OpCreateSubMesh, meshTb );
createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
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 );
- createTool( SMESHOp::OpMeshInformation, info );
- //createTool( SMESHOp::OpStdInfo, meshTb );
- //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
- createTool( SMESHOp::OpFindElementByPoint, info );
-
+ int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
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 );
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 );
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 );
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 );
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 );
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 );
createTool( SMESHOp::OpSmoothing, modifyTb );
createTool( SMESHOp::OpPatternMapping, modifyTb );
+ // Adaptation - begin
+#ifndef DISABLE_MG_ADAPT
+ int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
+ createTool( SMESHOp::OpMGAdapt, adaptTb );
+#endif
+ // 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();
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
+#ifndef DISABLE_MG_ADAPT
+ popupMgr()->insert( separator(), -1, 0 );
+ createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
+ popupMgr()->insert( separator(), -1, 0 );
+#endif
+ // Adaptation - end
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
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();
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();
-
+
app->infoPanel()->addLabel(lab, gb);
-
+
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");
-
+
app->infoPanel()->addLabel(lab, gb);
// << Help Panel
setPreferenceProperty( dispgroup, "columns", 2 );
addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
-
+
int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
QStringList modes;
modes.append( tr("MEN_WIRE") );
setPreferenceProperty( coloringType, "indexes", indices );
addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
+ // Adaptation - begin
+#ifndef DISABLE_MG_ADAPT
+ // 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 );
+#endif
+ // Adaptation - end
}
void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
--- /dev/null
+// Copyright (C) 2020-2021 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 "SMESHGUI_MG_ADAPTDRIVER.h"
+
+#include "SMESHGUI.h"
+#include "SMESHGUI_VTKUtils.h"
+#include "SMESHGUI_MeshUtils.h"
+#include "SMESH_TryCatch.hxx"
+
+#include <LightApp_SelectionMgr.h>
+#include <SUIT_Application.h>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_Session.h>
+#include <SVTK_ViewWindow.h>
+#include <SalomeApp_Application.h>
+
+#include <QLineEdit>
+#include <QRadioButton>
+#include <QKeyEvent>
+
+// SALOME KERNEL includes
+
+const int SPACING = 6; // layout spacing
+const int MARGIN = 9; // layout margin
+
+// 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;
+// }
+
+
+SMESHGUI_MG_ADAPTDRIVER::SMESHGUI_MG_ADAPTDRIVER( SMESHGUI* theModule, SMESH::MG_ADAPT_ptr myModel, bool isCreation )
+ : SMESHGUI_MgAdaptDlg((SalomeApp_Module*)theModule, myModel, SMESHGUI::desktop(), isCreation),
+ mySMESHGUI( theModule ),
+ myIsApplyAndClose( false )
+{
+
+ //resMgr = mySMESHGUI->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( false );
+ 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;
+
+ SMESH::SMESH_IDSource_var sSelectedObj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
+ if ( sSelectedObj->_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()
+{
+ 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;
+}
+
+// macro used to initialize errStr by exception description
+// returned by SMESH_CATCH( SMESH::returnError )
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT errStr =
+
+#undef SMY_OWN_CATCH
+#define SMY_OWN_CATCH catch ( SALOME::SALOME_Exception & e ) { errStr = e.details.text; }
+
+bool SMESHGUI_MG_ADAPTDRIVER::execute()
+{
+ int err = 1;
+ std::string errStr;
+ SMESH_TRY;
+ {
+ getModel()->compute();
+ err = 0;
+ errStr = SMESH::toStdStr( getModel()->getErrMsg() );
+ }
+ SMESH_CATCH( SMESH::returnError );
+
+ std::string msg = " ok";
+ if ( !errStr.empty() || err != 0 )
+ {
+ msg = "Not ok \n" + errStr + "\n";
+ std::cerr << msg;
+ err = 1;
+ }
+ return err == 0;
+}
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT
+
+//=================================================================================
+// 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 : isValid
+// purpose :
+//=================================================================================
+
+bool SMESHGUI_MG_ADAPTDRIVER::isValid()
+{
+ bool ok = true;
+ return ok;
+}
+
+bool SMESHGUI_MG_ADAPTDRIVER::createMeshInObjectBrowser()
+{
+ QString filename( SMESH::toQStr( 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->_is_nil() ) {
+ QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
+ QObject::tr("Could not retrieve SMESH_Gen_ptr") );
+ return false;
+ }
+ 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 (isEnabled())
+ // {
+ // mySMESHGUI->ResetState();
+ // mySMESHGUI->SetActiveDialogBox(0);
+ // setEnabled( false );
+ // }
+}
+
+//=================================================================================
+// 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();
+}
--- /dev/null
+// Copyright (C) 2020-2021 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
+//
+
+#ifndef SMESHGUI_MG_ADAPTDRIVER_H
+#define SMESHGUI_MG_ADAPTDRIVER_H
+
+#include "SMESH_SMESHGUI.hxx"
+
+// model
+#include "SMESHGUI_MgAdaptDlg.h"
+
+// IDL includes
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Mesh)
+#include CORBA_SERVER_HEADER(MG_ADAPT)
+
+class SMESHGUI;
+class LightApp_SelectionMgr;
+//class MgAdapt;
+
+// 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 ;
+ LightApp_SelectionMgr* selectionMgr();
+ SMESH::SMESH_Mesh_var myMesh ;
+ bool myIsApplyAndClose;
+
+ void enterEvent( QEvent* ); /* mouse enter the QWidget */
+ void keyPressEvent( QKeyEvent* );
+
+ bool isValid();
+ bool createMeshInObjectBrowser();
+ void setIsApplyAndClose( const bool theFlag );
+ bool isApplyAndClose() const;
+ bool execute();
+
+
+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();
+};
+
+#endif // SMESHGUI_MG_ADAPTDRIVER_H
--- /dev/null
+// Copyright (C) 2020-2021 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 "SMESHGUI_MgAdaptDlg.h"
+
+#include "MED_Factory.hxx"
+
+#include <SalomeApp_Tools.h>
+#include <SalomeApp_Module.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
+#include <SUIT_FileDlg.h>
+
+#include <QApplication>
+#include <QButtonGroup>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDoubleSpinBox>
+#include <QFileDialog>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QHeaderView>
+#include <QItemDelegate>
+#include <QKeyEvent>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QSpacerItem>
+#include <QSpinBox>
+#include <QString>
+#include <QTabWidget>
+#include <QTreeWidget>
+#include <QTreeWidgetItem>
+#include <QVBoxLayout>
+
+const int SPACING = 6; // layout spacing
+const int MARGIN = 9; // layout margin
+
+namespace
+{
+
+ // ======================================================
+ QString lireNomDimMaillage(QString aFile, int& meshdim)
+ // ========================================================
+ {
+ QString nomMaillage = QString::null ;
+
+ try {
+ while ( true )
+ {
+
+ MED::PWrapper aMed = MED::CrWrapperR( aFile.toUtf8().data() );
+ MED::TInt numberOfMeshes = aMed->GetNbMeshes();
+
+ if (numberOfMeshes == 0 )
+ {
+ QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
+ QObject::tr("MG_ADAPT_MED_FILE_2") );
+ break ;
+ }
+ if (numberOfMeshes > 1 )
+ {
+ QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
+ QObject::tr("MG_ADAPT_MED_FILE_3") );
+ break ;
+ }
+
+ MED::PMeshInfo aMeshInfo = aMed->GetPMeshInfo( 1 );
+ nomMaillage = aMeshInfo->GetName().c_str();
+ meshdim = (int) aMeshInfo->GetDim();
+
+ break ;
+ }
+ }
+ catch ( const SALOME::SALOME_Exception & S_ex )
+ {
+ SalomeApp_Tools::QtCatchCorbaException(S_ex);
+ }
+
+ return nomMaillage;
+ }
+
+ // =======================================================================
+ std::map<QString, int> GetListeChamps(QString aFile, bool errorMessage=true)
+ // =======================================================================
+ {
+ // Il faut voir si plusieurs maillages
+
+ std::map<QString, int> ListeChamp ;
+
+ try
+ {
+ while ( true )
+ {
+ MED::PWrapper aMed = MED::CrWrapperR( aFile.toUtf8().data() );
+ MED::TInt jaux = aMed->GetNbFields();
+ if (jaux < 1 )
+ {
+ if(errorMessage)
+ {
+ QMessageBox::critical( 0, QObject::tr("_ERROR"),
+ QObject::tr("HOM_MED_FILE_5") );
+ }
+ break ;
+ }
+ // nbofcstp inutile pour le moment
+ MED::PMeshInfo aMeshInfo = aMed->GetPMeshInfo( 1 );
+ int nbofcstp = 1;
+ for( MED::TInt j=0;j<jaux;j++)
+ {
+ MED::PFieldInfo aFiledInfo = aMed->GetPFieldInfo( aMeshInfo, j + 1 );
+ ListeChamp.insert({ QString( aFiledInfo->GetName().c_str()), nbofcstp });
+ }
+ break ;
+ }
+ }
+ catch ( const SALOME::SALOME_Exception & S_ex )
+ {
+ SalomeApp_Tools::QtCatchCorbaException(S_ex);
+ }
+
+ return ListeChamp;
+ }
+
+ // =======================================================================
+ std::string remove_extension(const std::string& filename)
+ // =======================================================================
+ {
+ size_t lastdot = filename.find_last_of(".");
+ if (lastdot == std::string::npos) return filename;
+ return filename.substr(0, lastdot);
+ }
+}
+
+//=================================================================================
+// function : SMESHGUI_MgAdaptDlg()
+// purpose :
+//=================================================================================
+SMESHGUI_MgAdaptDlg::SMESHGUI_MgAdaptDlg( SalomeApp_Module* theModule, SMESH::MG_ADAPT_ptr myModel, QWidget* parent, bool isCreation )
+ : QDialog(parent), mySMESHGUI( theModule )
+{
+ //~model = new MgAdapt(*myModel);
+ model = SMESH::MG_ADAPT::_duplicate(myModel);
+ model->Register();
+ myData = model->getData();
+ buildDlg();
+ if (!isCreation) readParamsFromHypo();
+}
+
+void SMESHGUI_MgAdaptDlg::buildDlg()
+{
+ setModal( false );
+ setAttribute( Qt::WA_DeleteOnClose, true );
+ setWindowTitle( tr( "ADAPT_PREF_MG_ADAPT" ) );
+ setSizeGripEnabled( true );
+
+ myTabWidget = new QTabWidget( this );
+
+ // Arguments
+
+ myArgs = new SMESHGUI_MgAdaptArguments( myTabWidget );
+ SMESH::string_array_var str = model->getOptionValuesStrVec();
+ SMESH::string_array_var str2 = model->getCustomOptionValuesStrVec();
+ std::vector<std::string> s;
+ for (CORBA::ULong i = 0; i< str->length(); i++) s.push_back( str[i].in());
+ for (CORBA::ULong j = str->length(); j< str2->length(); j++) s.push_back(str[ j - str->length() ].in() );
+ //~str.insert( str.end(), str2.begin(), str2.end() );
+
+ myAdvOpt = new MgAdaptAdvWidget(myTabWidget, &s);
+
+ /*int argsTab =*/ myTabWidget->addTab( myArgs, tr( "Args" ) );
+ /*int advTab =*/ myTabWidget->addTab( myAdvOpt, tr( "ADVOP" ) );
+
+ myAdvOpt->workingDirectoryLabel ->setText (tr( "WORKING_DIR" ));
+ myAdvOpt->workingDirectoryPushButton ->setText (tr( "SELECT_DIR" ));
+ myAdvOpt->keepWorkingFilesCheck ->setText (tr( "KEEP_WORKING_FILES" ));
+ myAdvOpt->verboseLevelLabel ->setText (tr( "VERBOSE_LEVEL" ));
+ myAdvOpt->removeLogOnSuccessCheck ->setText (tr( "REMOVE_LOG_ON_SUCCESS" ));
+ myAdvOpt->logInFileCheck ->setText (tr( "LOG_IN_FILE" ));
+ myAdvOpt->logGroupBox ->setTitle(tr( "LOG_GROUP_TITLE" ));
+
+ // buttons
+ QPushButton* buttonOk = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), this);
+ buttonOk->setAutoDefault(false);
+ QPushButton* buttonApply = new QPushButton(tr("SMESH_BUT_APPLY"), this);
+ buttonApply->setAutoDefault(false);
+ QPushButton* buttonCancel = new QPushButton( tr( "SMESH_BUT_CANCEL" ), this );
+ buttonCancel->setAutoDefault( false );
+ QPushButton* buttonHelp = new QPushButton( tr( "SMESH_BUT_HELP" ), this );
+ buttonHelp->setAutoDefault( false );
+
+ QHBoxLayout* btnLayout = new QHBoxLayout;
+ btnLayout->setSpacing( SPACING );
+ btnLayout->setMargin( 0 );
+ btnLayout->addWidget( buttonOk );
+ btnLayout->addStretch( 10 );
+ btnLayout->addWidget( buttonApply );
+ btnLayout->addStretch( 10 );
+ btnLayout->addWidget( buttonCancel );
+ btnLayout->addStretch( 10 );
+ btnLayout->addWidget( buttonHelp );
+
+ QVBoxLayout* l = new QVBoxLayout ( this );
+ l->setMargin( MARGIN );
+ l->setSpacing( SPACING );
+ l->addWidget( myTabWidget );
+ l->addStretch();
+ l->addLayout( btnLayout );
+
+ connect( buttonOk, SIGNAL(pressed()), this, SLOT(PushOnOK()));
+ connect( buttonApply, SIGNAL(pressed()), this, SLOT(PushOnApply()));
+ connect( buttonCancel, SIGNAL(pressed()), this, SLOT(close()));
+ connect( buttonHelp, SIGNAL(pressed()), this, SLOT(PushOnHelp()));
+
+ connect( myArgs, SIGNAL(meshDimSignal(ADAPTATION_MODE)), myAdvOpt, SLOT( onMeshDimChanged(ADAPTATION_MODE)) );
+}
+
+
+//=================================================================================
+// function : ~SMESHGUI_MgAdaptDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_MgAdaptDlg::~SMESHGUI_MgAdaptDlg()
+{
+ //~delete model;
+}
+
+//~void SMESHGUI_MgAdaptDlg::setModel(MgAdapt* mg)
+//~{
+ //~model = mg;
+//~}
+SMESH::MG_ADAPT_ptr SMESHGUI_MgAdaptDlg::getModel() const
+{
+ return model;
+}
+/*!
+\brief Perform clean-up actions on the dialog box closing.
+*/
+bool SMESHGUI_MgAdaptDlg::PushOnApply()
+{
+ bool ret = readParamsFromWidgets();
+ return ret;
+}
+void SMESHGUI_MgAdaptDlg::PushOnOK()
+{
+ bool ret = PushOnApply();
+ if ( ret ) reject();
+}
+void SMESHGUI_MgAdaptDlg::reject()
+{
+ QDialog::reject();
+}
+bool SMESHGUI_MgAdaptDlg::readParamsFromHypo( ) const
+{
+ bool ret = true;
+ myArgs->aMedfile->setChecked(myData->fromMedFile) ;
+ if (myData->fromMedFile)
+ {
+
+ myArgs->myFileInDir = myData->myFileInDir;
+ myArgs->selectMedFileLineEdit->setText(QString(myData->myMeshFileIn)) ;
+ // myData->myInMeshName = // TODO
+
+ }
+ else
+ {
+ myArgs->aBrowserObject->setText(QString(myData->myInMeshName));
+ //~ myArgs->myFileInDir =""; // TODO
+ //~ myArgs->selectMedFileLineEdit->setText(); // TODO
+ }
+ myArgs->meshNameLineEdit->setText(QString(myData->myOutMeshName));
+ myArgs->medFileCheckBox->setChecked(myData->myMeshOutMed);
+
+ if(myData->myMeshOutMed)
+ {
+ myArgs->myFileOutDir = QString(myData->myFileOutDir);
+ myArgs->selectOutMedFileLineEdit->setText(myData->myMeshFileOut.in());
+ }
+ else
+ {
+ myArgs->myFileOutDir = ""; //TODO
+ }
+
+ myArgs->publishOut->setChecked(myData->myPublish);
+
+ myArgs->localButton->setChecked(myData->myUseLocalMap);
+ myArgs->backgroundButton->setChecked(myData->myUseBackgroundMap);
+ myArgs->constantButton->setChecked(myData->myUseConstantValue);
+
+ if (myData->myUseConstantValue)
+ {
+ myArgs->dvalue->setValue(myData->myConstantValue);
+ }
+ else
+ {
+ myArgs->dvalue->setValue(0.0);
+ }
+
+ if (myData->myUseBackgroundMap)
+ {
+
+ myArgs->myFileSizeMapDir = QString(myData->myFileSizeMapDir) ;
+ myArgs->selectMedFileBackgroundLineEdit->setText(QString(myData->myMeshFileBackground));
+ }
+ else
+ {
+ myArgs->myFileSizeMapDir = ""; //TODO
+ myArgs->selectMedFileBackgroundLineEdit->setText(""); //TODO
+ }
+
+ myArgs->fieldNameCmb->setCurrentText(QString(myData->myFieldName));
+ myArgs->noTimeStep->setChecked(myData->myUseNoTimeStep);
+ myArgs->lastTimeStep->setChecked( myData->myUseLastTimeStep);
+ myArgs->chosenTimeStep->setChecked(myData->myUseChosenTimeStep);
+ if (myData->myUseChosenTimeStep)
+ {
+ myArgs->rankSpinBox->setValue(myData->myRank);
+ myArgs->timeStep->setValue(myData->myTimeStep);
+ }
+
+ myAdvOpt->workingDirectoryLineEdit->setText(QString(myData->myWorkingDir));
+ myAdvOpt->logInFileCheck->setChecked(myData->myPrintLogInFile);
+
+ myAdvOpt->verboseLevelSpin->setValue(myData->myVerboseLevel);
+ myAdvOpt->removeLogOnSuccessCheck->setChecked(myData->myRemoveLogOnSuccess);
+ myAdvOpt->keepWorkingFilesCheck->setChecked(myData->myKeepFiles);
+
+ return ret;
+
+}
+
+bool SMESHGUI_MgAdaptDlg::readParamsFromWidgets()
+{
+ bool ret = true ;
+ SMESH::MgAdaptHypothesisData data, *aData = &data;
+ while ( ret )
+ {
+ // 1. Fichier du maillage de départ
+ aData->fromMedFile = myArgs->aMedfile->isChecked();
+ if (aData->fromMedFile)
+ {
+ aData->myFileInDir = CORBA::string_dup(myArgs->myFileInDir.toUtf8().data());
+ aData->myMeshFileIn = CORBA::string_dup(myArgs->selectMedFileLineEdit->text().toUtf8().data());
+ // aData->myInMeshName = // TODO
+ }
+ else // TODO browser
+ {
+ QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
+ QObject::tr("MG_ADAPT_MED_FILE_4") );
+ ret = false ;
+ break ;
+ // aData->myInMeshName = CORBA::string_dup(myArgs->aBrowserObject->text().toStdString().c_str());
+ // aData->myFileInDir = CORBA::string_dup(myAdvOpt->workingDirectoryLineEdit->text().toStdString().c_str());
+ //
+ // TCollection_AsciiString aGenericName = (char*)aData->myFileInDir;
+ // TCollection_AsciiString aGenericName2 = "MgAdapt_";
+ // aGenericName2 += getpid();
+ // aGenericName2 += "_";
+ // aGenericName2 += Abs((Standard_Integer)(long) aGenericName.ToCString());
+ // aGenericName2 += ".med";
+ // aGenericName+=aGenericName2;
+ // emit myArgs->toExportMED(aGenericName.ToCString());
+ // aData->myMeshFileIn = aGenericName2.ToCString();
+ }
+ // 2. Fichier du maillage de sortie
+ aData->myOutMeshName = CORBA::string_dup(myArgs->meshNameLineEdit->text().toStdString().c_str());
+ aData->myMeshOutMed = myArgs->medFileCheckBox->isChecked();
+ if(aData->myMeshOutMed)
+ {
+ aData->myFileOutDir = CORBA::string_dup(myArgs->myFileOutDir.toUtf8().data());
+ aData->myMeshFileOut = CORBA::string_dup(myArgs->selectOutMedFileLineEdit->text().toUtf8().data());
+ }
+ else
+ {
+ aData->myMeshFileOut = "";
+ }
+ aData->myPublish = myArgs->publishOut->isChecked();
+
+ // 3. Type de carte de tailles
+ aData->myUseLocalMap = myArgs->localButton->isChecked();
+ aData->myUseBackgroundMap = myArgs->backgroundButton->isChecked();
+ aData->myUseConstantValue = myArgs->constantButton->isChecked();
+ // 3.1. Constante
+ if (aData->myUseConstantValue)
+ {
+ aData->myConstantValue = myArgs->dvalue->value();
+ }
+ else
+ {
+ aData->myConstantValue = 0.0;
+ }
+ // 3.2. Arrière-plan
+ if (aData->myUseBackgroundMap)
+ {
+ aData->myFileSizeMapDir = CORBA::string_dup(myArgs->myFileSizeMapDir.toUtf8().data());
+ aData->myMeshFileBackground = CORBA::string_dup(myArgs->selectMedFileBackgroundLineEdit->text().toUtf8().data());
+ }
+ else
+ {
+ aData->myMeshFileBackground = "";
+ }
+
+ // 4. Le champ
+ if ( ! aData->myUseConstantValue )
+ {
+ if ( strlen(myArgs->fieldNameCmb->currentText().toStdString().c_str()) == 0 )
+ {
+ QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
+ QObject::tr("MG_ADAPT_MED_FILE_5") );
+ ret = false ;
+ break ;
+ }
+ {
+ aData->myFieldName = CORBA::string_dup(myArgs->fieldNameCmb->currentText().toStdString().c_str());
+ aData->myUseNoTimeStep = myArgs->noTimeStep->isChecked();
+ aData->myUseLastTimeStep = myArgs->lastTimeStep->isChecked();
+ aData->myUseChosenTimeStep = myArgs->chosenTimeStep->isChecked();
+ if (aData->myUseChosenTimeStep)
+ {
+ aData->myRank = myArgs->rankSpinBox->value();
+ aData->myTimeStep = myArgs->timeStep->value();
+ }
+ }
+ }
+
+ // 5. Options avancées
+ aData->myWorkingDir = CORBA::string_dup(myAdvOpt->workingDirectoryLineEdit->text().toStdString().c_str());
+ aData->myPrintLogInFile = myAdvOpt->logInFileCheck->isChecked();
+ aData->myVerboseLevel = myAdvOpt->verboseLevelSpin->value();
+ aData->myRemoveLogOnSuccess = myAdvOpt->removeLogOnSuccessCheck->isChecked();
+ aData->myKeepFiles = myAdvOpt->keepWorkingFilesCheck->isChecked();
+ model->setData(*aData);
+
+ QString msg;
+ checkParams(msg);
+ break ;
+ }
+
+ return ret;
+}
+bool SMESHGUI_MgAdaptDlg::storeParamsToHypo( const SMESH::MgAdaptHypothesisData& ) const
+{
+ return true;
+}
+/*!
+ \brief Show help page
+*/
+void SMESHGUI_MgAdaptDlg::PushOnHelp()
+{
+// QString aHelpFile;
+ // if ( myTabWidget->currentIndex() == MinDistance ) {
+ // aHelpFile = "measurements.html#min-distance-anchor";
+ // } else if ( myTabWidget->currentIndex() == BoundingBox ) {
+ // aHelpFile = "measurements.html#bounding-box-anchor";
+ // } else if ( myTabWidget->currentWidget() == myAngle ) {
+ // aHelpFile = "measurements.html#angle-anchor";
+ // } else {
+ // aHelpFile = "measurements.html#basic-properties-anchor";
+ // }
+
+// SMESH::ShowHelpFile( aHelpFile );
+}
+bool SMESHGUI_MgAdaptDlg::checkParams(QString& msg)
+{
+ if ( !QFileInfo( myAdvOpt->workingDirectoryLineEdit->text().trimmed() ).isWritable() )
+ {
+ SUIT_MessageBox::warning( this,
+ tr( "SMESH_WRN_WARNING" ),
+ tr( "NO_PERMISSION" ) );
+ return false;
+ }
+
+
+ myAdvOpt->myOptionTable->setFocus();
+ QApplication::instance()->processEvents();
+
+ QString name, value;
+ bool isDefault, ok = true;
+ int iRow = 0, nbRows = myAdvOpt->myOptionTable->topLevelItemCount();
+ for ( ; iRow < nbRows; ++iRow )
+ {
+ QTreeWidgetItem* row = myAdvOpt->myOptionTable->topLevelItem( iRow );
+ myAdvOpt->GetOptionAndValue( row, name, value, isDefault );
+
+ if ( name.simplified().isEmpty() )
+ continue; // invalid custom option
+
+ if ( isDefault ) // not selected option
+ value.clear();
+
+ try
+ {
+ model->setOptionValue( name.toLatin1().constData(), value.toLatin1().constData() );
+ }
+ catch ( const SALOME::SALOME_Exception& ex )
+ {
+ msg = ex.details.text.in();
+ ok = false;
+ break;
+ }
+ }
+
+ return ok;
+}
+
+//=================================================================================
+// function : SMESHGUI_MgAdaptArguments()
+// purpose :
+//=================================================================================
+SMESHGUI_MgAdaptArguments::SMESHGUI_MgAdaptArguments( QWidget* parent )
+ :QWidget(parent)
+{
+
+ if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
+ {
+ myFileInDir = QDir::currentPath();
+ myFileOutDir = QDir::currentPath();
+ myFileSizeMapDir = QDir::currentPath();
+ }
+ else
+ {
+ myFileInDir = SUIT_FileDlg::getLastVisitedPath();
+ myFileOutDir = SUIT_FileDlg::getLastVisitedPath();
+ myFileSizeMapDir = SUIT_FileDlg::getLastVisitedPath();
+ }
+
+ meshDim = 0;
+ meshDimBG = 0;
+ // Mesh in
+ aMeshIn = new QGroupBox( tr( "MeshIn" ), this );
+ aMedfile = new QRadioButton( tr( "MEDFile" ), aMeshIn );
+ aBrowser = new QRadioButton( tr( "Browser" ), aMeshIn );
+ aBrowserObject = new QLineEdit( aMeshIn );
+ selectMedFilebutton = new QPushButton("...", aMeshIn);
+ selectMedFileLineEdit = new QLineEdit( aMeshIn );
+
+ meshIn = new QGridLayout( aMeshIn );
+
+ meshIn->setMargin( MARGIN );
+ meshIn->setSpacing( SPACING );
+ meshIn->addWidget( aMedfile, 0, 0, 1,1 );
+ meshIn->addWidget( aBrowser, 0, 1,1,1);
+ meshIn->addWidget( aBrowserObject, 0, 2, 1, 1 );
+ meshIn->addWidget( selectMedFilebutton, 1, 0,1, 1);
+ meshIn->addWidget( selectMedFileLineEdit, 1, 1, 1, 1 );
+ hspacer = new QSpacerItem(188, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+
+ meshInGroup = new QButtonGroup( this );
+ meshInGroup->addButton( aMedfile, 0 );
+ meshInGroup->addButton( aBrowser, 1 );
+
+ //Mesh out
+
+ aMeshOut = new QGroupBox( tr( "MeshOut" ), this );
+ meshName = new QLabel(tr("MeshName"), aMeshOut);
+ secondHspacer = new QSpacerItem(100, 30);
+ meshNameLineEdit = new QLineEdit(aMeshOut) ;
+ medFileCheckBox = new QCheckBox(tr("MEDFile"), aMeshOut);
+ selectOutMedFilebutton = new QPushButton("...", aMeshOut);
+ thirdHspacer = new QSpacerItem(188, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+ selectOutMedFileLineEdit = new QLineEdit(aMeshOut) ;
+ publishOut = new QCheckBox(tr("Publish_MG_ADAPT"), aMeshOut);
+
+ meshOut = new QGridLayout( aMeshOut );
+
+ meshOut->setMargin( MARGIN );
+ meshOut->setSpacing( SPACING );
+ meshOut->addWidget( meshName, 0, 0, 1,1 );
+ meshOut->addItem( secondHspacer, 0, 1, 1, 1 );
+ meshOut->addWidget( meshNameLineEdit, 0, 2,1,1);
+ meshOut->addWidget( medFileCheckBox, 1, 0,1,1 );
+ meshOut->addWidget( selectOutMedFilebutton, 1, 1,1,1 );
+ meshOut->addWidget( selectOutMedFileLineEdit, 1, 2,1,1);
+ meshOut->addWidget( publishOut, 2, 0,1,1 );
+
+ //size map definition
+
+ sizeMapDefinition = new QGroupBox(tr("SIZE_MAP_DEF"), this);
+ localButton = new QRadioButton(tr("LOCAL_MG_ADAPT"), sizeMapDefinition);
+ backgroundButton = new QRadioButton(tr("BACKGRND_MG_ADAPT"), sizeMapDefinition);
+ constantButton = new QRadioButton(tr("CNST_MG_ADAPT"), sizeMapDefinition);
+ medFileBackground = new QLabel(tr("MED_FILE_BCKG"), sizeMapDefinition);
+ selectMedFileBackgroundbutton = new QPushButton("...", sizeMapDefinition);
+ selectMedFileBackgroundLineEdit = new QLineEdit(sizeMapDefinition);
+ valueLabel = new QLabel(tr("VALUE_MG_ADAPT"), sizeMapDefinition);
+ dvalue = new QDoubleSpinBox(sizeMapDefinition);
+ sizeMapDefGroup = new QButtonGroup( this );
+ sizeMapDefGroup->addButton( localButton, 0 );
+ sizeMapDefGroup->addButton( backgroundButton, 1 );
+ sizeMapDefGroup->addButton( constantButton, 2 );
+
+ sizeMapDefGroupLayout = new QGridLayout(sizeMapDefinition);
+ sizeMapDefGroupLayout->addWidget(localButton, 0,0);
+ sizeMapDefGroupLayout->addWidget(backgroundButton, 0,1);
+ sizeMapDefGroupLayout->addWidget(constantButton, 0,2);
+ sizeMapDefGroupLayout->addWidget(medFileBackground, 1,0);
+ sizeMapDefGroupLayout->addWidget(selectMedFileBackgroundbutton, 1,1);
+ sizeMapDefGroupLayout->addWidget(selectMedFileBackgroundLineEdit, 1,2);
+ sizeMapDefGroupLayout->addWidget(valueLabel, 2,0);
+ sizeMapDefGroupLayout->addWidget(dvalue, 2,1);
+
+ // size Map field
+ sizeMapField = new QGroupBox(tr("SIZE_MAP_FIELD"), this);
+ fieldName = new QLabel(tr("MG_ADAPT_FIELD_NAME"), sizeMapField);
+ fieldNameCmb = new QComboBox(sizeMapField);
+ noTimeStep = new QRadioButton(tr("MG_ADAPT_NO_T_ST"), sizeMapField);
+ lastTimeStep = new QRadioButton(tr("MG_ADAPT_L_ST"), sizeMapField);
+ chosenTimeStep = new QRadioButton(tr("MG_ADAPT_CH_ST"), sizeMapField);
+ timeStepLabel = new QLabel(tr("MG_ADAPT_TSTP"), sizeMapField);
+ timeStep = new QSpinBox(sizeMapField);
+ timeStep->setMinimum(-1);
+ rankLabel = new QLabel(tr("MG_ADAPT_RANK"), sizeMapField);
+ rankSpinBox = new QSpinBox(sizeMapField);
+ rankSpinBox->setMinimum(-1);
+
+ timeStepGroup = new QButtonGroup(this);
+ timeStepGroup->addButton(noTimeStep, 0);
+ timeStepGroup->addButton(lastTimeStep, 1);
+ timeStepGroup->addButton(chosenTimeStep, 2);
+
+ sizeMapFieldGroupLayout = new QGridLayout(sizeMapField);
+
+ sizeMapFieldGroupLayout->addWidget(fieldName, 0,0);
+ sizeMapFieldGroupLayout->addWidget(fieldNameCmb, 0,1);
+ sizeMapFieldGroupLayout->addWidget(noTimeStep, 1,0);
+ sizeMapFieldGroupLayout->addWidget(lastTimeStep, 1,1);
+ sizeMapFieldGroupLayout->addWidget(chosenTimeStep, 1,2);
+ sizeMapFieldGroupLayout->addWidget(timeStepLabel, 2,0);
+ sizeMapFieldGroupLayout->addWidget(timeStep, 2,1);
+ sizeMapFieldGroupLayout->addWidget(rankLabel, 2,2);
+ sizeMapFieldGroupLayout->addWidget(rankSpinBox, 2,3);
+
+ QGridLayout* argumentsLayout = new QGridLayout( this );
+ argumentsLayout->setMargin( MARGIN );
+ argumentsLayout->setSpacing( SPACING );
+
+ argumentsLayout->addWidget( aMeshIn, 0, 0, 1, 3 );
+ argumentsLayout->addWidget( aMeshOut, 1, 0, 1, 3 );
+ argumentsLayout->addWidget( sizeMapDefinition, 2, 0, 1, 3 );
+ argumentsLayout->addWidget( sizeMapField, 3, 0, 1, 3 );
+ argumentsLayout->setColumnStretch( 1, 5 );
+ argumentsLayout->setRowStretch( 4, 5 );
+
+ // Initial state
+ setMode( Mesh, Local);
+ medFileCheckBox->setChecked(true);
+ visibleTimeStepRankLabel (false);
+
+ // Connections
+ connect( meshInGroup, SIGNAL( buttonClicked( int ) ), this, SLOT( modeChanged( int ) ) );
+ connect( sizeMapDefGroup, SIGNAL( buttonClicked( int ) ), this, SLOT( sizeMapDefChanged( int ) ) );
+ connect( selectMedFilebutton, SIGNAL( pressed( ) ), this, SLOT( onSelectMedFilebuttonClicked( ) ) );
+ connect( medFileCheckBox, SIGNAL (stateChanged(int)), this, SLOT(onMedFileCheckBox(int) ) );
+ connect( publishOut, SIGNAL (stateChanged(int)), this, SLOT(onPublishOut(int) ) );
+ connect( selectOutMedFilebutton, SIGNAL( pressed()), this, SLOT(onSelectOutMedFilebutton()));
+ connect( selectMedFileBackgroundbutton, SIGNAL(pressed()), this, SLOT(onSelectMedFileBackgroundbutton()) );
+ connect( timeStepGroup, SIGNAL( buttonClicked( int ) ), this, SLOT( timeStepGroupChanged( int ) ) );
+ emit updateSelection();
+}
+
+//=================================================================================
+// function : ~SMESHGUI_MgAdaptArguments()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_MgAdaptArguments::~SMESHGUI_MgAdaptArguments()
+{
+}
+
+void SMESHGUI_MgAdaptArguments::onNoTimeStep(bool disableOther)
+{
+ noTimeStep->setChecked(true);
+
+ visibleTimeStepRankLabel (false);
+ rankSpinBox->setValue(-2);
+ timeStep->setValue(-2);
+
+ lastTimeStep->setDisabled(disableOther);
+ chosenTimeStep->setDisabled(disableOther);
+}
+void SMESHGUI_MgAdaptArguments::onLastTimeStep(bool disableOther)
+{
+ lastTimeStep->setChecked(true);
+
+ visibleTimeStepRankLabel (false);
+ rankSpinBox->setValue(-1);
+ timeStep->setValue(-1);
+ noTimeStep->setDisabled(disableOther);
+}
+void SMESHGUI_MgAdaptArguments::onChosenTimeStep(bool /*disableOther*/, int vmax)
+{
+ chosenTimeStep->setChecked(true);
+
+ visibleTimeStepRankLabel (true);
+ rankSpinBox->setValue(-1);
+ timeStep->setValue(-1);
+ if (vmax) timeStep->setMaximum(vmax);
+}
+
+void SMESHGUI_MgAdaptArguments::visibleTimeStepRankLabel(bool visible)
+{
+ rankLabel->setVisible(visible);
+ rankSpinBox->setVisible(visible);
+
+ timeStepLabel->setVisible(visible);
+ timeStep->setVisible(visible);
+}
+
+void SMESHGUI_MgAdaptArguments::onSelectOutMedFilebutton()
+{
+
+ QString filtre = QString("Med") ;
+ filtre += QString(" files (*.") + QString("med") + QString(");;");
+ QString fileName = QFileDialog::getSaveFileName(this, tr("SAVE_MED"), QString(""), filtre);
+ QFileInfo myFileInfo(fileName);
+ selectOutMedFileLineEdit->setText(myFileInfo.fileName());
+ myFileOutDir = myFileInfo.path();
+
+}
+void SMESHGUI_MgAdaptArguments::onSelectMedFileBackgroundbutton()
+{
+ QString fileName0 = selectMedFileBackgroundbutton->text().trimmed();
+
+ QString fileName = getMedFileName(false);
+ if (fileName != QString::null)
+ {
+ myFieldList = GetListeChamps(fileName);
+ if (myFieldList.empty())
+ {
+ fileName = fileName0;
+ fieldNameCmb->clear();
+ }
+ else
+ {
+ // fill field name Combobox
+ fieldNameCmb->clear();
+ std::map<QString, int>::const_iterator it;
+ for ( it=myFieldList.begin() ; it != myFieldList.end(); it++)
+ {
+ fieldNameCmb->insertItem(0,QString(it->first));
+ int typeStepInField = it->second > 2 ? 2 : it->second ;
+ timeStepGroupChanged(typeStepInField, false);
+ }
+ // Dimension du maillage de fonds
+ lireNomDimMaillage( fileName, meshDimBG );
+ valueAdaptation ();
+ }
+ }
+ else
+ {
+ fileName = fileName0;
+ fieldNameCmb->clear();
+ }
+
+ QFileInfo myFileInfo(fileName);
+ myFileSizeMapDir = myFileInfo.path();
+ selectMedFileBackgroundLineEdit->setText(myFileInfo.fileName());
+
+}
+void SMESHGUI_MgAdaptArguments::onMedFileCheckBox(int state)
+{
+ if (state == Qt::Checked)
+ {
+ selectOutMedFilebutton->show();
+ selectOutMedFileLineEdit->show();
+ selectOutMedFilebutton->setEnabled(true);
+ selectOutMedFileLineEdit->setEnabled(true);
+ }
+ else
+ {
+ selectOutMedFilebutton->setEnabled(false);
+ selectOutMedFileLineEdit->setEnabled(false);
+ publishOut->setChecked(true);
+ }
+}
+void SMESHGUI_MgAdaptArguments::onPublishOut(int state)
+{
+ if (state == Qt::Unchecked)
+ {
+ medFileCheckBox->setChecked(true);
+ }
+}
+
+void SMESHGUI_MgAdaptArguments::onSelectMedFilebuttonClicked()
+{
+ // bool keep = false;
+ QString fileName0 = selectMedFileLineEdit->text().trimmed();
+
+ QString fileName = getMedFileName(false);
+ if(fileName != QString::null)
+ {
+ QString aMeshName = lireNomDimMaillage(fileName.trimmed(), meshDim);
+ if (aMeshName.isEmpty() )
+ {
+ QMessageBox::critical( 0, QObject::tr("MG_ADAPT_ERROR"),
+ QObject::tr("MG_ADAPT_MED_FILE_2") );
+ fileName = fileName0;
+ }
+ else
+ {
+ meshNameLineEdit->setText(aMeshName);
+ valueAdaptation ();
+// ADAPTATION_MODE aMode = meshDim == 3 ? ADAPTATION_MODE::BOTH : ADAPTATION_MODE::SURFACE; // and when dimesh 3 without 2D mesh?
+// emit meshDimSignal(aMode);
+ }
+ }
+ else
+ {
+ return;
+ }
+
+ QFileInfo myFileInfo(fileName);
+ myFileInDir = myFileInfo.path();
+ myFileOutDir = myFileInfo.path();
+ selectMedFileLineEdit->setText(myFileInfo.fileName());
+ QString outF = fileName == QString::null ? myFileInfo.fileName() :
+ QString( remove_extension(myFileInfo.fileName().toStdString() ).c_str() )+ QString(".adapt.med");
+ selectOutMedFileLineEdit->setText(outF);
+ onLocalSelected(myFileInfo.filePath());
+
+}
+
+void SMESHGUI_MgAdaptArguments::valueAdaptation()
+{
+ ADAPTATION_MODE aMode ;
+ if ( meshDimBG < 3 )
+ {
+ aMode = meshDim == 3 ? ADAPTATION_MODE::BOTH : ADAPTATION_MODE::SURFACE;
+ }
+ else
+ {
+ aMode = ADAPTATION_MODE::BOTH;
+ }
+ emit meshDimSignal(aMode);
+}
+
+void SMESHGUI_MgAdaptArguments::onLocalSelected(QString filePath)
+{
+ myFieldList = GetListeChamps(filePath, false);
+ if (myFieldList.empty())
+ {
+ if (localButton->isChecked())
+ {
+ fieldNameCmb->clear();
+ }
+ }
+ else
+ {
+ // fill field name Combobox
+ fieldNameCmb->clear();
+ std::map<QString, int>::const_iterator it;
+ for ( it = myFieldList.begin() ; it != myFieldList.end(); it++)
+ {
+ fieldNameCmb->insertItem(0,QString(it->first));
+ // Je ne comprends pas le rapport entre pas de temps et apparition d'un nouveau champ... GN
+ int typeStepInField = it->second > 2 ? 2 : it->second ;
+// std::cout << "SMESHGUI_MgAdaptArguments::onLocalSelected typeStepInField : " << typeStepInField << std::endl;
+ timeStepGroupChanged(typeStepInField, false);
+ }
+ }
+}
+// =======================================================================
+// Gestion les boutons qui permettent de
+// 1) retourne le nom d'un fichier par une fenetre de dialogue si aucun
+// objet est selectionne dans l arbre d etude
+// 2) retourne le nom du fichier asocie a l objet
+// selectionne dans l arbre d etude
+// =======================================================================
+QString SMESHGUI_MgAdaptArguments::getMedFileName(bool /*avertir*/)
+{
+
+ QString aFile = QString::null;
+ QString filtre = QString("Med") ;
+ filtre += QString(" files (*.") + QString("med") + QString(");;");
+ aFile = SUIT_FileDlg::getOpenFileName(0, QObject::tr("MG_ADAPT_SELECT_FILE_0"), QString(""), filtre );
+
+ return aFile;
+
+}
+void SMESHGUI_MgAdaptArguments::setMode(const Mode theMode, const SIZEMAP theSizeMap )
+{
+ QRadioButton* aButton = qobject_cast<QRadioButton*>( meshInGroup->button( theMode ) );
+ QRadioButton* bButton = qobject_cast<QRadioButton*>( sizeMapDefGroup->button( theSizeMap ) );
+ if ( aButton )
+ {
+ aButton->setChecked( true );
+ modeChanged( theMode );
+ }
+ if ( bButton )
+ {
+ bButton->setChecked( true );
+ sizeMapDefChanged( theSizeMap );
+ }
+}
+
+void SMESHGUI_MgAdaptArguments::modeChanged( int theMode )
+{
+ clear();
+ if(theMode == Mesh)
+ {
+ aBrowserObject->hide();
+ selectMedFileLineEdit->show();
+ selectMedFilebutton->show();
+ localButton->setEnabled(true);
+ }
+ else
+ {
+ selectMedFileLineEdit->hide();
+ selectMedFilebutton->hide();
+ localButton->setEnabled(false);
+ aBrowserObject->show();
+ sizeMapDefChanged(Background);
+ emit updateSelection();
+ }
+}
+
+void SMESHGUI_MgAdaptArguments::sizeMapDefChanged( int theSizeMap )
+{
+ fieldNameCmb->clear();
+ if(theSizeMap == Local)
+ {
+ localButton->setEnabled(true);
+ localButton->setChecked(true);
+ medFileBackground->hide();
+ selectMedFileBackgroundbutton->hide();
+ selectMedFileBackgroundLineEdit->hide();
+ selectMedFileBackgroundLineEdit->clear();
+ valueLabel->hide();
+ dvalue->hide();
+
+ sizeMapField->setEnabled(true);
+ if (!selectMedFileLineEdit->text().isEmpty())
+ {
+ QFileInfo myFileInfo(QDir(myFileInDir), selectMedFileLineEdit->text());
+ onLocalSelected(myFileInfo.filePath());
+ }
+ }
+ else if (theSizeMap == Background)
+ {
+ medFileBackground->show();
+ backgroundButton->setChecked(true);
+ selectMedFileBackgroundbutton->show();
+ selectMedFileBackgroundLineEdit->show();
+ valueLabel->hide();
+ dvalue->hide();
+ sizeMapField->setEnabled(true);
+ }
+ else
+ {
+ medFileBackground->hide();
+ constantButton->setChecked(true);
+ selectMedFileBackgroundbutton->hide();
+ selectMedFileBackgroundLineEdit->clear();
+ selectMedFileBackgroundLineEdit->hide();
+ valueLabel->show();
+ dvalue->show();
+ sizeMapField->setEnabled(false);
+ }
+ meshDimBG = 0;
+ valueAdaptation();
+}
+void SMESHGUI_MgAdaptArguments::timeStepGroupChanged(int timeStepType, bool disableOther, int vmax)
+{
+ switch (timeStepType)
+ {
+ case 0 :
+ onNoTimeStep(disableOther);
+ break;
+ case 1 :
+ onLastTimeStep(disableOther);
+ break;
+ case 2 :
+ onChosenTimeStep(disableOther, vmax);
+ default:
+ break;
+ }
+}
+
+void SMESHGUI_MgAdaptArguments::clear()
+{
+ selectMedFileLineEdit->clear();
+ aBrowserObject->clear();
+
+ meshNameLineEdit->clear();
+ selectOutMedFileLineEdit->clear();
+}
+// med_int SMESHGUI_MgAdaptArguments::getMeshDim() const
+// {
+// return meshDim;
+// }
+QWidget* ItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &o, const QModelIndex &index) const
+{
+ bool editable = index.data( EDITABLE_ROLE ).toInt();
+ return editable ? QItemDelegate::createEditor( parent, o, index ) : 0;
+}
+
+//////////////////////////////////////////
+// MgAdaptAdvWidget
+//////////////////////////////////////////
+
+MgAdaptAdvWidget::MgAdaptAdvWidget( QWidget* parent, std::vector <std::string>* options, Qt::WindowFlags f )
+ : QWidget( parent, f ), myOptions(options)
+{
+ setupWidget();
+ myOptionTable->header()->setSectionResizeMode( QHeaderView::ResizeToContents );
+ myOptionTable->setItemDelegate( new ItemDelegate( myOptionTable ) );
+
+ for ( size_t i = 0, nb = myOptions->size(); i < nb; ++i )
+ {
+ AddOption( (*myOptions)[i].c_str() );
+ }
+
+ connect( myOptionTable, SIGNAL( itemChanged(QTreeWidgetItem *, int)), SLOT( itemChanged(QTreeWidgetItem *, int )));
+ connect( addBtn, SIGNAL(clicked()), this, SLOT( onAddOption() ) );
+ connect(workingDirectoryPushButton, SIGNAL(pressed()), this, SLOT(_onWorkingDirectoryPushButton()));
+}
+
+MgAdaptAdvWidget::~MgAdaptAdvWidget()
+{
+}
+
+void MgAdaptAdvWidget::AddOption( const char* option, bool isCustom )
+{
+ QString name, value;
+ bool isDefault = false;
+ if ( option )
+ {
+ QStringList name_value_type = QString(option).split( ":", QString::KeepEmptyParts );
+ if ( name_value_type.size() > 0 )
+ name = name_value_type[0];
+ if ( name_value_type.size() > 1 )
+ value = name_value_type[1];
+ if ( name_value_type.size() > 2 )
+ isDefault = !name_value_type[2].toInt();
+ }
+ QTreeWidget* table = myOptionTable;
+ //table->setExpanded( true );
+
+ QTreeWidgetItem* row;
+ if (optionTreeWidgetItem.size())
+ {
+ std::map<QString, QTreeWidgetItem *>::iterator it = optionTreeWidgetItem.find(name);
+ if(it != optionTreeWidgetItem.end()) return; // option exist
+ else
+ {
+ row = getNewQTreeWidgetItem(table, option, name, isCustom);
+ }
+ }
+ else
+ {
+ row = getNewQTreeWidgetItem(table, option, name, isCustom);
+ }
+ row->setText( 0, tr( name.toLatin1().constData() ));
+ row->setText( 1, tr( value.toLatin1().constData() ));
+ row->setCheckState( 0, isDefault ? Qt::Unchecked : Qt::Checked);
+ row->setData( NAME_COL, PARAM_NAME, name );
+
+ if ( isCustom )
+ {
+ myOptionTable->scrollToItem( row );
+ myOptionTable->setCurrentItem( row );
+ myOptionTable->editItem( row, NAME_COL );
+ }
+}
+
+QTreeWidgetItem* MgAdaptAdvWidget::getNewQTreeWidgetItem(QTreeWidget* table, const char* option, QString& name, bool isCustom)
+{
+ QTreeWidgetItem* row = new QTreeWidgetItem( table );
+ row->setData( NAME_COL, EDITABLE_ROLE, int( isCustom && !option ));
+ row->setFlags( row->flags() | Qt::ItemIsEditable );
+ optionTreeWidgetItem.insert(std::pair <QString, QTreeWidgetItem*> (name, row));
+
+ return row;
+}
+
+void MgAdaptAdvWidget::onAddOption()
+{
+ AddOption( NULL, true );
+}
+void MgAdaptAdvWidget::GetOptionAndValue( QTreeWidgetItem * tblRow,
+ QString& option,
+ QString& value,
+ bool& isDefault)
+{
+ option = tblRow->data( NAME_COL, PARAM_NAME ).toString();
+ value = tblRow->text( VALUE_COL );
+ isDefault = ! tblRow->checkState( NAME_COL );
+
+}
+
+void MgAdaptAdvWidget::itemChanged(QTreeWidgetItem* tblRow, int column)
+{
+ if ( tblRow )
+ {
+ myOptionTable->blockSignals( true );
+
+ tblRow->setData( VALUE_COL, EDITABLE_ROLE, int( tblRow->checkState( NAME_COL )));
+
+ int c = tblRow->checkState( NAME_COL ) ? 0 : 150;
+ tblRow->setForeground( VALUE_COL, QBrush( QColor( c, c, c )));
+
+ if ( column == NAME_COL && tblRow->data( NAME_COL, EDITABLE_ROLE ).toInt() ) // custom table
+ {
+ tblRow->setData( NAME_COL, PARAM_NAME, tblRow->text( NAME_COL ));
+ }
+
+ myOptionTable->blockSignals( false );
+ }
+}
+void MgAdaptAdvWidget::setupWidget()
+{
+ if (this->objectName().isEmpty())
+ this->setObjectName(QString(tr("MG-ADAPT-ADV")));
+ this->resize(337, 369);
+ gridLayout_4 = new QGridLayout(this);
+ gridLayout_4->setObjectName(QString("gridLayout_4"));
+ myOptionTable = new MgAdaptAdvWidgetTreeWidget(this);
+ QFont font;
+ font.setBold(false);
+ font.setWeight(50);
+ QTreeWidgetItem *__qtreewidgetitem = new QTreeWidgetItem();
+ __qtreewidgetitem->setFont(1, font);
+ __qtreewidgetitem->setFont(0, font);
+ __qtreewidgetitem->setText(1, tr("OPTION_VALUE_COLUMN"));
+ __qtreewidgetitem->setText(0, tr("OPTION_NAME_COLUMN"));
+ myOptionTable->setHeaderItem(__qtreewidgetitem);
+ myOptionTable->setObjectName(QString("myOptionTable"));
+ myOptionTable->setEditTriggers(QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed);
+ myOptionTable->setTabKeyNavigation(true);
+
+ gridLayout_4->addWidget(myOptionTable, 0, 0, 1, 2);
+
+ addBtn = new QPushButton(this);
+ addBtn->setText(QApplication::translate("SMESH_AdvOptionsWdg", "ADD_OPTION_BTN", Q_NULLPTR));
+ addBtn->setObjectName(QString("addBtn"));
+
+ gridLayout_4->addWidget(addBtn, 1, 0, 1, 1);
+
+ horizontalSpacer = new QSpacerItem(188, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+
+ gridLayout_4->addItem(horizontalSpacer, 1, 1, 1, 1);
+
+ logGroupBox = new QGroupBox(this);
+ logGroupBox->setObjectName(QString("logGroupBox"));
+ gridLayout_2 = new QGridLayout(logGroupBox);
+ gridLayout_2->setObjectName(QString("gridLayout_2"));
+ gridLayout = new QGridLayout();
+ gridLayout->setObjectName(QString("gridLayout"));
+ workingDirectoryLabel = new QLabel(logGroupBox);
+ workingDirectoryLabel->setObjectName(QString("workingDirectoryLabel"));
+
+ gridLayout->addWidget(workingDirectoryLabel, 0, 0, 1, 1);
+
+ workingDirectoryLineEdit = new QLineEdit(logGroupBox);
+ workingDirectoryLineEdit->setObjectName(QString("workingDirectoryLineEdit"));
+
+ gridLayout->addWidget(workingDirectoryLineEdit, 0, 1, 1, 1);
+
+ workingDirectoryPushButton = new QPushButton(logGroupBox);
+ workingDirectoryPushButton->setObjectName(QString("workingDirectoryPushButton"));
+
+ gridLayout->addWidget(workingDirectoryPushButton, 0, 2, 1, 1);
+
+ verboseLevelLabel = new QLabel(logGroupBox);
+ verboseLevelLabel->setObjectName(QString("verboseLevelLabel"));
+
+ gridLayout->addWidget(verboseLevelLabel, 1, 0, 1, 1);
+
+ verboseLevelSpin = new QSpinBox(logGroupBox);
+ verboseLevelSpin->setObjectName(QString("verboseLevelSpin"));
+
+ gridLayout->addWidget(verboseLevelSpin, 1, 1, 1, 1);
+
+
+ gridLayout_2->addLayout(gridLayout, 0, 0, 1, 1);
+
+ horizontalLayout = new QHBoxLayout();
+ horizontalLayout->setObjectName(QString("horizontalLayout"));
+ logInFileCheck = new QCheckBox(logGroupBox);
+ logInFileCheck->setObjectName(QString("logInFileCheck"));
+ logInFileCheck->setChecked(true);
+
+ horizontalLayout->addWidget(logInFileCheck);
+
+ removeLogOnSuccessCheck = new QCheckBox(logGroupBox);
+ removeLogOnSuccessCheck->setObjectName(QString("removeLogOnSuccessCheck"));
+ removeLogOnSuccessCheck->setChecked(true);
+
+ horizontalLayout->addWidget(removeLogOnSuccessCheck);
+
+
+ gridLayout_2->addLayout(horizontalLayout, 1, 0, 1, 1);
+
+ keepWorkingFilesCheck = new QCheckBox(logGroupBox);
+ keepWorkingFilesCheck->setObjectName(QString("keepWorkingFilesCheck"));
+ keepWorkingFilesCheck->setAutoExclusive(false);
+
+ gridLayout_2->addWidget(keepWorkingFilesCheck, 2, 0, 1, 1);
+
+
+ gridLayout_4->addWidget(logGroupBox, 3, 0, 1, 2);
+
+}
+void MgAdaptAdvWidget::_onWorkingDirectoryPushButton()
+{
+ QString aDirName=QFileDialog::getExistingDirectory ();
+ if (!(aDirName.isEmpty()))workingDirectoryLineEdit->setText(aDirName);
+}
+void MgAdaptAdvWidget::onMeshDimChanged(ADAPTATION_MODE aMode)
+{
+/* default adaptation mode
+ * assume that if meshDim == 2 and no 3D backgrounmesh-->adaptation surface
+ * if meshDim == 3 and if there is not 2D mesh -->VOLUME
+ * else BOTH
+ */
+
+ QString adaptation("adaptation"), value;
+ switch(aMode)
+ {
+ case ADAPTATION_MODE::SURFACE:
+ {
+ value ="surface";
+ setOptionValue(adaptation, value);
+ break;
+ }
+ case ADAPTATION_MODE::BOTH :
+ {
+ value = "both";
+ setOptionValue(adaptation, value);
+ break;
+ }
+ case ADAPTATION_MODE::VOLUME :
+ {
+ value = "volume";
+ setOptionValue(adaptation, value);
+ break;
+ }
+ }
+}
+void MgAdaptAdvWidget::setOptionValue(QString& option, QString& value)
+{
+ std::map<QString, QTreeWidgetItem *>::iterator it = optionTreeWidgetItem.find(option);
+ if (it != optionTreeWidgetItem.end())
+ {
+ it->second->setText( 0, tr( option.toLatin1().constData() ));
+ it->second->setText( 1, tr( value.toLatin1().constData() ));
+ it->second->setCheckState( 0, Qt::Checked );
+ it->second->setData( NAME_COL, PARAM_NAME, option );
+ myOptionTable->editItem( it->second, NAME_COL );
+ }
+}
+namespace
+{
+bool isEditable( const QModelIndex& index )
+{
+ return index.isValid() &&
+ index.flags() & Qt::ItemIsEditable &&
+ index.flags() & Qt::ItemIsEnabled &&
+ ( !index.data( Qt::UserRole + 1 ).isValid() || index.data( Qt::UserRole + 1 ).toInt() != 0 );
+}
+}
+
+MgAdaptAdvWidgetTreeWidget::MgAdaptAdvWidgetTreeWidget( QWidget* parent )
+ : QTreeWidget( parent )
+{
+}
+
+QModelIndex MgAdaptAdvWidgetTreeWidget::moveCursor( CursorAction action, Qt::KeyboardModifiers modifiers )
+{
+ QModelIndex current = currentIndex();
+ int column = current.column();
+ if ( action == MoveNext )
+ {
+ if ( column < columnCount()-1 )
+ {
+ QModelIndex next = current.sibling( current.row(), column+1 );
+ if ( isEditable( next ) ) return next;
+ }
+ else
+ {
+ QModelIndex next = current.sibling( current.row()+1, 0 );
+ if ( isEditable( next ) ) return next;
+ }
+ }
+ else if ( action == MovePrevious )
+ {
+ if ( column == 0 ) {
+ QModelIndex next = current.sibling( current.row()-1, columnCount()-1 );
+ if ( isEditable( next ) ) return next;
+ }
+ else {
+ QModelIndex next = current.sibling( current.row(), column-1 );
+ if ( isEditable( next ) ) return next;
+ }
+ }
+ return QTreeWidget::moveCursor( action, modifiers );
+}
+
+void MgAdaptAdvWidgetTreeWidget::keyPressEvent( QKeyEvent* e )
+{
+ switch ( e->key() )
+ {
+ case Qt::Key_F2:
+ {
+ QModelIndex index = currentIndex();
+ if ( !isEditable( index ) ) {
+ for ( int i = 0; i < columnCount(); i++ ) {
+ QModelIndex sibling = index.sibling( index.row(), i );
+ if ( isEditable( sibling ) ) {
+ if ( !edit( sibling, EditKeyPressed, e ) ) e->ignore();
+ }
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ QTreeWidget::keyPressEvent( e );
+}
--- /dev/null
+// Copyright (C) 2020-2021 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
+//
+
+#ifndef MG_ADAPTGUI_HXX
+#define MG_ADAPTGUI_HXX
+
+// Qt includes
+#include <QDialog>
+#include <QTreeWidget>
+#include <QItemDelegate>
+
+#include <map>
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(MG_ADAPT)
+#include <SALOME_GenericObj_wrap.hxx>
+
+class SalomeApp_Module;
+
+class QButtonGroup;
+class QLineEdit;
+class QGroupBox;
+class QRadioButton;
+class QLabel;
+class QCheckBox;
+class QGridLayout;
+class QTabWidget;
+class QDoubleSpinBox;
+class QSpacerItem;
+class QSpinBox;
+class QTreeWidgetItem;
+class QHBoxLayout;
+class QComboBox;
+
+class SMESHGUI_MgAdaptArguments;
+class MgAdaptAdvWidgetTreeWidget;
+class MgAdaptAdvWidget;
+
+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;
+ QTabWidget* myTabWidget;
+
+ SMESH::MgAdaptHypothesisData_var myData;
+ SALOME::GenericObj_wrap< SMESH::MG_ADAPT > 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);
+ int meshDim;
+ 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
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
if ( findTriangles(aNode1,aNode2,tria1,tria2) )
{
- newIndices.push_back( aNode1->GetID() );
- newIndices.push_back( aNode2->GetID() );
-
+ newIndices.push_back( aNode1->GetID() );
+ newIndices.push_back( aNode2->GetID() );
+
myOkBtn->setEnabled(true);
myApplyBtn->setEnabled(true);
}
if(SMDS_Mesh* aMesh = aVisualObj->GetMesh())
{
const SMDS_MeshElement* tria[2];
-
- bool valid = false;
+
+ bool valid = false;
SVTK_IndexedMapOfIds anIds;
mySelector->GetCompositeIndex(anIO,anIds);
if( anIds.Extent() == 1 && anIds(1).size() == 2 ) {
- anId1 = anIds(1)[0];
- anId2 = anIds(1)[1];
- valid = true;
+ anId1 = anIds(1)[0];
+ anId2 = anIds(1)[1];
+ valid = true;
}
-
+
if( valid &&
findTriangles( aMesh->FindNode( anId1 ), aMesh->FindNode( anId2 ), tria[0],tria[1] ) )
{
QString aText = QString("%1-%2").arg(anId1).arg(anId2);
myEdge->setText(aText);
-
+
myOkBtn->setEnabled(true);
myApplyBtn->setEnabled(true);
}
<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>
<message>
<source>ICON_MEASURE_AREA</source>
<translation>mesh_measure_area.png</translation>
- </message>
+ </message>
<message>
<source>ICON_MEASURE_VOLUME</source>
<translation>mesh_measure_volume.png</translation>
<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>
<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>
<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>
<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>
<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>
<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>
<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>
<message>
<source>FULL_RECOMPUTE_QUESTION</source>
<translation>
-The mesh has been edited since a last total re-compute
-that may prevent successful computation.
+The mesh has been edited since a last total re-compute
+that may prevent successful computation.
Do you wish to re-compute the mesh totally to discard the modifications?
</translation>
</message>
<message>
<source>GEOMETRY_OBJECT_IS_NOT_DEFINED_MESH</source>
<translation>Geometry object is not defined.
-Do you want to create an empty mesh
+Do you want to create an empty mesh
without algorithms and hypotheses? </translation>
</message>
<message>
<message>
<source>CONCURRENT_SUBMESH_APPEARS</source>
<translation>
-The assigned algorithm has the same priority as one assigned to an
+The assigned algorithm has the same priority as one assigned to an
adjacent sub-mesh, hence it's undefined which algorithm to use for
meshing boundary shared by two sub-meshes. Would you like to set
the order of sub-mesh computation? </translation>
<message>
<source>SUBSHAPES_NOT_FOUND_MSG</source>
<translation>
-Some sub-shapes not found in the new geometry. They are listed
+Some sub-shapes not found in the new geometry. They are listed
below along with dependent mesh objects that are marked with
red in the Object Browser.</translation>
</message>
<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>
</message>
<message>
<source>MEN_EDIT</source>
- <translation>Edition</translation>
+ <translation>Editer</translation>
</message>
<message>
<source>MEN_EDIT_GROUP</source>
<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>
<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>
<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>
<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>
<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>
SMESH_MeshPartDS.hxx
SMESH.hxx
SMESH_Component_Generator.hxx
+ MG_ADAPT_i.hxx
)
# --- sources ---
SMESH_Measurements_i.cxx
SMESH_PreMeshInfo.cxx
SMESH_Component_Generator.cxx
+ MG_ADAPT_i.cxx
)
# --- rules ---
--- /dev/null
+// Copyright (C) 2020-2021 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 "MG_ADAPT.hxx"
+#include "SMESH_File.hxx"
+#include "SMESH_Gen_i.hxx"
+#include "SMESH_PythonDump.hxx"
+#include "SMESH_TryCatch.hxx"
+
+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_Gen_i::CreateMG_ADAPT
+ *
+ * Create measurement instance
+ */
+//=============================================================================
+
+SMESH::MG_ADAPT_ptr SMESH_Gen_i::CreateMG_ADAPT()
+{
+#ifndef DISABLE_MG_ADAPT
+ SMESH::MG_ADAPT_i* aMGadapt = new SMESH::MG_ADAPT_i();
+ SMESH::MG_ADAPT_var anObj = aMGadapt->_this();
+ return anObj._retn();
+#else
+ return SMESH::MG_ADAPT_ptr();
+#endif
+}
+SMESH::MG_ADAPT_ptr SMESH_Gen_i::CreateAdaptationHypothesis()
+{
+#ifndef DISABLE_MG_ADAPT
+ SMESH::MG_ADAPT_i* aMGadapt = new SMESH::MG_ADAPT_i();
+ SMESH::MG_ADAPT_var anObj = aMGadapt->_this();
+ return anObj._retn();
+#else
+ return SMESH::MG_ADAPT_ptr();
+#endif
+}
+SMESH::MG_ADAPT_OBJECT_ptr SMESH_Gen_i::Adaptation( const char* adaptationType)
+{
+#ifndef DISABLE_MG_ADAPT
+ 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();
+ }
+#endif
+ return SMESH::MG_ADAPT_OBJECT_ptr();
+}
+//=============================================================================
+/*!
+ * standard constructor
+ */
+//=============================================================================
+MG_ADAPT_i::MG_ADAPT_i(): SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
+{
+ myMgAdapt = new ::MG_ADAPT::MgAdapt();
+}
+
+//=============================================================================
+/*!
+ * standard destructor
+ */
+//=============================================================================
+MG_ADAPT_i::~MG_ADAPT_i()
+{
+ delete myMgAdapt;
+}
+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()
+{
+ return 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());
+}
+
+// macro used to initialize excStr by exception description
+// returned by SMESH_CATCH( SMESH::returnError )
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT excStr =
+
+void MG_ADAPT_i::compute()
+{
+ SMESH::TPythonDump noDumpSoFar;
+
+ errStr = "";
+ std::string excStr;
+ SMESH_TRY;
+
+ myMgAdapt->compute(errStr);
+
+ SMESH_CATCH( SMESH::returnError );
+
+ SMESH_Comment errMsg;
+ if ( !excStr.empty() )
+ {
+ errMsg << "Exception thrown on MG_ADAPT_i::compute invocation with error message \""
+ << errStr << "\" with exception \"" << excStr << "\"";
+ }
+ else if ( !errStr.empty() )
+ {
+ errMsg << "MG_ADAPT_i::compute invocation returned error message \"" << errStr << "\"";
+ }
+ if ( !errMsg.empty() )
+ {
+ THROW_SALOME_CORBA_EXCEPTION( errMsg.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);
+ }
+}
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT
+
+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)
+{
+ SMESH_TRY;
+ myMgAdapt->setOptionValue(optionName, optionValue);
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
+char* MG_ADAPT_i::getOptionValue(const char* optionName,
+ bool& isDefault)
+{
+ SMESH_TRY;
+ return CORBA::string_dup(myMgAdapt->getOptionValue(optionName, &isDefault).c_str());
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return 0;
+}
+SMESH::string_array* MG_ADAPT_i::getCustomOptionValuesStrVec()
+{
+ SMESH::string_array_var result = new SMESH::string_array();
+ std::vector <std::string> vals = myMgAdapt->getCustomOptionValuesStrVec();
+ result->length((CORBA::ULong) vals.size()) ;
+ for (CORBA::ULong i = 0; i<vals.size(); i++) result[i] = CORBA::string_dup(vals[i].c_str());
+ return result._retn();
+}
+SMESH::string_array* MG_ADAPT_i::getOptionValuesStrVec()
+{
+
+ SMESH::string_array_var result = new SMESH::string_array();
+ std::vector <std::string> vals = myMgAdapt->getOptionValuesStrVec();
+ result->length((CORBA::ULong) vals.size());
+ for (CORBA::ULong 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);
+ hypothesis->Register();
+}
+CORBA::Long MG_ADAPT_OBJECT_i::Compute(bool publish)
+{
+ SMESH::TPythonDump noDumpSoFar;
+
+ 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()
+{
+ SMESH::TPythonDump noDumpSoFar;
+
+ bool ret = false; // 1 ok , 0 nook
+ if ( !( ret = SMESH_File( medFileIn ).exists()))
+ {
+ if(!myMesh->_is_nil())
+ {
+ bool toOverwrite = true;
+ bool toFindOutDim = true;
+ medFileIn = (CORBA::String_var( hypothesis->getFileName() )).in();
+ medFileIn+= ".med";
+ myMesh->ExportMED(medFileIn.c_str(), false, -1, toOverwrite, toFindOutDim);
+ hypothesis->setMedFileIn(medFileIn.c_str());
+ ret = true;
+ }
+ }
+
+ return ret;
+}
--- /dev/null
+// Copyright (C) 2020-2021 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
+//
+
+#ifndef MG_ADAPT_I_HXX
+#define MG_ADAPT_I_HXX
+
+#include "SMESH.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(MG_ADAPT)
+#include "SALOME_GenericObj_i.hh"
+#include <SALOME_GenericObj_wrap.hxx>
+
+#include <string>
+
+namespace MG_ADAPT
+{
+ class MgAdaptHypothesisData;
+ 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();
+ virtual ~MG_ADAPT_i();
+ 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);
+ char* getOptionValue(const char* optionName,
+ bool& isDefault);
+ SMESH::string_array* getCustomOptionValuesStrVec() ;
+ SMESH::string_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;
+
+};
+
+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_var myMesh;
+SALOME::GenericObj_wrap<SMESH::MG_ADAPT> hypothesis;
+};
+
+}
+
+#endif // MG_ADAPT_I_HXX
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
// *****************************************
for ( int i = 1; i <= idMap.Extent(); i++ ) {
myResult.push_back( std::make_pair( (int)idMap(i)[0], (int)idMap(i)[1]) );
- }
+ }
}
};