--- /dev/null
+.svn
+.yamm
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8 FATAL_ERROR)
+PROJECT(SalomeHYDROSOLVER CXX)
+
+# Ensure a proper linker behavior:
+CMAKE_POLICY(SET CMP0003 NEW)
+
+# Versioning
+# ===========
+# Project name, upper case
+STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
+
+SET(${PROJECT_NAME_UC}_MAJOR_VERSION 0)
+SET(${PROJECT_NAME_UC}_MINOR_VERSION 1)
+SET(${PROJECT_NAME_UC}_VERSION
+ ${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION})
+SET(${PROJECT_NAME_UC}_VERSION_DEV 1)
+
+# Find KERNEL
+# ===========
+SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR} CACHE PATH "Path to the Salome KERNEL")
+IF(EXISTS ${KERNEL_ROOT_DIR})
+ LIST(APPEND CMAKE_MODULE_PATH "${KERNEL_ROOT_DIR}/salome_adm/cmake_files")
+ INCLUDE(SalomeMacros)
+ FIND_PACKAGE(SalomeKERNEL REQUIRED)
+ELSE(EXISTS ${KERNEL_ROOT_DIR})
+ MESSAGE(FATAL_ERROR "We absolutely need a Salome KERNEL, please define KERNEL_ROOT_DIR")
+ENDIF(EXISTS ${KERNEL_ROOT_DIR})
+
+# Platform setup
+# ==============
+INCLUDE(SalomeSetupPlatform) # From KERNEL
+# Always build libraries as shared objects:
+SET(BUILD_SHARED_LIBS TRUE)
+# Local macros:
+LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/adm_local/cmake_files")
+
+# User options
+# ============
+OPTION(SALOME_BUILD_DOC "Generate SALOME HYDROSOLVER documentation" ON)
+#OPTION(SALOME_BUILD_TESTS "Build SALOME tests" ON) #for use in the future
+
+#IF(SALOME_BUILD_TESTS)
+# ENABLE_TESTING()
+#ENDIF()
+
+##
+## From KERNEL:
+##
+FIND_PACKAGE(SalomePythonInterp REQUIRED)
+FIND_PACKAGE(SalomePythonLibs REQUIRED)
+FIND_PACKAGE(SalomeOmniORB REQUIRED)
+FIND_PACKAGE(SalomeOmniORBPy REQUIRED)
+FIND_PACKAGE(SalomeSWIG REQUIRED)
+
+# Med and Hdf5 are second order dependencies (deps for Telemac) but since Telemac libraries
+# are not linked against them, we need to include them here for the Telemac wrapper
+FIND_PACKAGE(SalomeMEDFile REQUIRED)
+FIND_PACKAGE(SalomeHDF5 REQUIRED)
+
+IF(SALOME_BUILD_DOC)
+ FIND_PACKAGE(SalomeSphinx REQUIRED)
+ENDIF()
+
+# Find GUI
+# ===========
+SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR} CACHE PATH "Path to the Salome GUI")
+IF(EXISTS ${GUI_ROOT_DIR})
+ LIST(APPEND CMAKE_MODULE_PATH "${GUI_ROOT_DIR}/adm_local/cmake_files")
+ FIND_PACKAGE(SalomeGUI REQUIRED)
+ ADD_DEFINITIONS(${GUI_DEFINITIONS})
+ INCLUDE_DIRECTORIES(${GUI_INCLUDE_DIRS})
+ELSE(EXISTS ${GUI_ROOT_DIR})
+ MESSAGE(FATAL_ERROR "We absolutely need a Salome GUI, please define GUI_ROOT_DIR")
+ENDIF(EXISTS ${GUI_ROOT_DIR})
+
+##
+## From GUI:
+##
+FIND_PACKAGE(SalomePyQt4 REQUIRED)
+
+##
+## HYDROSOLVER specifics
+##
+
+FIND_PACKAGE(SalomeMascaret REQUIRED)
+FIND_PACKAGE(SalomeTelemac REQUIRED)
+
+# Directories
+# (default values taken from KERNEL)
+# ===========
+SET(SALOME_INSTALL_BINS "${SALOME_INSTALL_BINS}" CACHE PATH "Install path: SALOME binaries")
+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
+ "Install path: SALOME scripts")
+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
+ "Install path: SALOME Python scripts")
+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
+ "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
+ "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_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")
+
+# HYDROSOLVER specific:
+SET(SALOME_HYDROSOLVER_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/hydrosolver" CACHE PATH "Install path: SALOME HYDROSOLVER specific data")
+SET(SALOME_HYDROSOLVER_INSTALL_DOC "${SALOME_INSTALL_DOC}/gui/HYDROSOLVER" CACHE PATH "Install path: SALOME HYDROSOLVER doc")
+
+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)
+MARK_AS_ADVANCED(SALOME_INSTALL_PYTHON SALOME_INSTALL_PYTHON_SHARED)
+MARK_AS_ADVANCED(SALOME_INSTALL_AMCONFIG_LOCAL SALOME_INSTALL_DOC)
+MARK_AS_ADVANCED(SALOME_HYDROSOLVER_INSTALL_RES_DATA SALOME_HYDROSOLVER_INSTALL_DOC)
+
+# Accumulate environment variables for HYDROSOLVER module
+SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_BINS})
+SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_LIBS})
+
+# Sources
+# ========
+
+ADD_SUBDIRECTORY(adm_local)
+ADD_SUBDIRECTORY(resources)
+ADD_SUBDIRECTORY(src)
+ADD_SUBDIRECTORY(idl)
+IF(SALOME_BUILD_DOC)
+ ADD_SUBDIRECTORY(doc)
+ENDIF()
+
+# Configuration export
+# (here only the level 1 prerequisites are exposed)
+# ====================
+INCLUDE(CMakePackageConfigHelpers)
+
+# 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
+ SalomeIDLHYDROSOLVER
+)
+
+# Add all targets to the build-tree export set
+EXPORT(TARGETS ${_${PROJECT_NAME}_exposed_targets}
+ FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
+
+# Create the configuration files:
+# - in the build tree:
+
+# Ensure the variables are always defined for the configure:
+SET(GUI_ROOT_DIR "${GUI_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:
+# SALOME_CONFIGURE_PREPARE() #For use in the future
+
+CONFIGURE_PACKAGE_CONFIG_FILE(${PROJECT_NAME}Config.cmake.in
+ ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+ INSTALL_DESTINATION "${SALOME_INSTALL_CMAKE_LOCAL}"
+ PATH_VARS CONF_INCLUDE_DIRS SALOME_INSTALL_CMAKE_LOCAL CMAKE_INSTALL_PREFIX
+ GUI_ROOT_DIR)
+
+WRITE_BASIC_PACKAGE_VERSION_FILE(${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+ VERSION ${${PROJECT_NAME_UC}_VERSION}
+ COMPATIBILITY AnyNewerVersion)
+
+# Install the CMake configuration files:
+INSTALL(FILES
+ "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+ "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.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}"
+ FILE ${PROJECT_NAME}Targets.cmake)
--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
--- /dev/null
+# - Config file for the @PROJECT_NAME@ package
+# It defines the following variables.
+# Specific to the package @PROJECT_NAME@ itself:
+# @PROJECT_NAME_UC@_ROOT_DIR_EXP - the root path of the installation providing this CMake file
+#
+
+###############################################################
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+###############################################################
+
+### Initialisation performed by CONFIGURE_PACKAGE_CONFIG_FILE:
+@PACKAGE_INIT@
+
+# Load the dependencies for the libraries of @PROJECT_NAME@
+# (contains definitions for IMPORTED targets). This is only
+# imported if we are not built as a subproject (in this case targets are already there)
+IF(NOT TARGET SalomeIDLHYDROSOLVER AND NOT @PROJECT_NAME@_BINARY_DIR)
+ INCLUDE("@PACKAGE_SALOME_INSTALL_CMAKE_LOCAL@/@PROJECT_NAME@Targets.cmake")
+ENDIF()
+
+# Package root dir:
+SET_AND_CHECK(HYDROSOLVER_ROOT_DIR_EXP "@PACKAGE_CMAKE_INSTALL_PREFIX@")
+
+# Include directories
+SET_AND_CHECK(HYDROSOLVER_INCLUDE_DIRS "${HYDROSOLVER_ROOT_DIR_EXP}/@SALOME_INSTALL_HEADERS@")
+SET(HYDROSOLVER_INCLUDE_DIRS "${HYDROSOLVER_INCLUDE_DIRS};@_SalomeHYDROSOLVER_EXTRA_HEADERS@")
+SET(HYDROSOLVER_DEFINITIONS "@GUI_DEFINITIONS@")
+
+# Package specific environment variables
+@_SalomeHYDROSOLVER_EXTRA_ENV_FULL@
+
+#### Now the specificities
+
+# Options exported by the package:
+SET(SALOME_HYDROSOLVER_BUILD_DOC @SALOME_BUILD_DOC@)
+#SET(SALOME_HYDROSOLVER_BUILD_TESTS @SALOME_BUILD_TESTS@)
+SET(SALOME_LIGHT_ONLY @SALOME_LIGHT_ONLY@)
+
+# Level 1 prerequisites:
+SET_AND_CHECK(GUI_ROOT_DIR_EXP "@PACKAGE_GUI_ROOT_DIR@")
+
+# For all prerequisites, load the corresponding targets if the package was used
+# in CONFIG mode. This ensures dependent projects link correctly
+# without having to set LD_LIBRARY_PATH:
+SET(_PREREQ @_PREREQ_LIST@)
+SET(_PREREQ_CONFIG_DIR @_PREREQ_DIR_LIST@)
+SET(_PREREQ_COMPONENTS "@_PREREQ_COMPO_LIST@")
+LIST(LENGTH _PREREQ_CONFIG_DIR _list_len)
+IF(NOT _list_len EQUAL 0)
+ # Another CMake stupidity - FOREACH(... RANGE r) generates r+1 numbers ...
+ MATH(EXPR _range "${_list_len}-1")
+ FOREACH(_p RANGE ${_range})
+ LIST(GET _PREREQ ${_p} _pkg )
+ LIST(GET _PREREQ_CONFIG_DIR ${_p} _pkg_dir)
+ LIST(GET _PREREQ_COMPONENTS ${_p} _pkg_compo)
+ MESSAGE(STATUS "===> Reloading targets from ${_pkg} ...")
+ IF(NOT _pkg_compo)
+ FIND_PACKAGE(${_pkg} REQUIRED NO_MODULE
+ PATHS "${_pkg_dir}"
+ NO_DEFAULT_PATH)
+ ELSE()
+ STRING(REPLACE "," ";" _compo_lst "${_pkg_compo}")
+ MESSAGE(STATUS "===> (components: ${_pkg_compo})")
+ FIND_PACKAGE(${_pkg} REQUIRED NO_MODULE
+ COMPONENTS ${_compo_lst}
+ PATHS "${_pkg_dir}"
+ NO_DEFAULT_PATH)
+ ENDIF()
+ ENDFOREACH()
+ENDIF()
+
+# Installation directories
+SET(SALOME_INSTALL_BINS "@SALOME_INSTALL_BINS@")
+SET(SALOME_INSTALL_LIBS "@SALOME_INSTALL_LIBS@")
+SET(SALOME_INSTALL_HEADERS "@SALOME_INSTALL_HEADERS@")
+SET(SALOME_INSTALL_SCRIPT_SCRIPTS "@SALOME_INSTALL_SCRIPT_SCRIPTS@")
+SET(SALOME_INSTALL_SCRIPT_DATA "@SALOME_INSTALL_SCRIPT_DATA@")
+SET(SALOME_INSTALL_SCRIPT_PYTHON "@SALOME_INSTALL_SCRIPT_PYTHON@")
+SET(SALOME_INSTALL_APPLISKEL_SCRIPTS "@SALOME_INSTALL_APPLISKEL_SCRIPTS@")
+SET(SALOME_INSTALL_APPLISKEL_PYTHON "@SALOME_INSTALL_APPLISKEL_PYTHON@")
+SET(SALOME_INSTALL_CMAKE_LOCAL "@SALOME_INSTALL_CMAKE_LOCAL@")
+SET(SALOME_INSTALL_PYTHON "@SALOME_INSTALL_PYTHON@")
+SET(SALOME_INSTALL_PYTHON_SHARED "@SALOME_INSTALL_PYTHON_SHARED@")
+SET(SALOME_INSTALL_RES "@SALOME_INSTALL_RES@")
+SET(SALOME_INSTALL_DOC "@SALOME_INSTALL_DOC@")
+SET(SALOME_INSTALL_AMCONFIG_LOCAL "@SALOME_INSTALL_AMCONFIG_LOCAL@")
+
+# Include GUI targets if they were not already loaded:
+IF(NOT (TARGET Event))
+ INCLUDE("${GUI_ROOT_DIR_EXP}/${SALOME_INSTALL_CMAKE_LOCAL}/SalomeGUITargets.cmake")
+ENDIF()
+
+# Exposed HYDROSOLVER targets:
+SET(HYDROSOLVER_SalomeIDLHYDROSOLVER SalomeIDLHYDROSOLVER)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(cmake_files)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# ===============================================================
+# Files to be installed
+# ===============================================================
+
+# These files are data, module or lib files
+SET(_adm_data
+ FindMascaret.cmake
+ FindSalomeMascaret.cmake
+ FindTelemac.cmake
+ FindSalomeTelemac.cmake
+)
+INSTALL(FILES ${_adm_data} DESTINATION ${SALOME_INSTALL_CMAKE_LOCAL})
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+FIND_LIBRARY(MASCARET_LIBRARIES mascaret)
+FIND_PATH(MASCARET_INCLUDE_DIR apimascaret.h)
+
+# Handle the standard arguments of the find_package() command:
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Mascaret REQUIRED_VARS MASCARET_LIBRARIES MASCARET_INCLUDE_DIR)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# Mascaret detection for Salome
+#
+# !! Please read the generic detection procedure in SalomeMacros.cmake !!
+#
+SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(Mascaret MASCARET_ROOT_DIR 0)
+MARK_AS_ADVANCED(MASCARET_LIBRARIES MASCARET_INCLUDE_DIR)
+
+IF(Mascaret_FOUND OR MASCARET_FOUND)
+ SALOME_ACCUMULATE_HEADERS(MASCARET_INCLUDE_DIR)
+ SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH ${MASCARET_LIBRARIES})
+ENDIF()
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# Telemac detection for Salome
+#
+# !! Please read the generic detection procedure in SalomeMacros.cmake !!
+#
+SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(Telemac TELEMAC_ROOT_DIR 0)
+MARK_AS_ADVANCED(TELEMAC_LIBRARY_api_telemac2d
+ TELEMAC_LIBRARY_bief
+ TELEMAC_LIBRARY_damocles
+ TELEMAC_LIBRARY_parallel
+ TELEMAC_LIBRARY_sisyphe
+ TELEMAC_LIBRARY_special
+ TELEMAC_LIBRARY_telemac2d
+ TELEMAC_LIBRARY_tomawac
+ TELEMAC_LIBRARIES
+ TELEMAC_INCLUDE_DIR
+ TELEMAC_API_SRC_DIR)
+
+IF(Telemac_FOUND OR TELEMAC_FOUND)
+ SALOME_ACCUMULATE_HEADERS(TELEMAC_INCLUDE_DIR)
+ SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH ${TELEMAC_LIBRARIES})
+ENDIF()
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+FIND_LIBRARY(TELEMAC_LIBRARY_api_telemac2d api_telemac2d
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_bief bief
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_damocles damocles
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_parallel parallel
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_sisyphe sisyphe
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_special special
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_telemac2d telemac2d
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_tomawac tomawac
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+# FIND_LIBRARY(TELEMAC_LIBRARY_gretel gretel
+# PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+# FIND_LIBRARY(TELEMAC_LIBRARY_partel partel
+# PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+FIND_LIBRARY(TELEMAC_LIBRARY_hermes hermes
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/lib)
+IF(NOT EXISTS ${TELEMAC_LIBRARY_hermes})
+ MESSAGE("Warning: ${TELEMAC_LIBRARY_hermes} does not exist")
+ SET(TELEMAC_LIBRARY_hermes "")
+ENDIF()
+FIND_PATH(TELEMAC_INCLUDE_DIR interface_telemac2d.mod
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/include)
+FIND_PATH(TELEMAC_API_SRC_DIR api_interface_t2d.f90
+ PATHS ${TELEMAC_ROOT_DIR}/wrap_api/src)
+
+# The order of the libraries is important for the API wrapper compilation
+SET(TELEMAC_LIBRARIES ${TELEMAC_LIBRARY_api_telemac2d}
+ ${TELEMAC_LIBRARY_gretel}
+ ${TELEMAC_LIBRARY_partel}
+ ${TELEMAC_LIBRARY_telemac2d}
+ ${TELEMAC_LIBRARY_sisyphe}
+ ${TELEMAC_LIBRARY_tomawac}
+ ${TELEMAC_LIBRARY_bief}
+ ${TELEMAC_LIBRARY_hermes}
+ ${TELEMAC_LIBRARY_parallel}
+ ${TELEMAC_LIBRARY_damocles}
+ ${TELEMAC_LIBRARY_special}
+ )
+
+# Handle the standard arguments of the find_package() command:
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Telemac REQUIRED_VARS TELEMAC_LIBRARY_api_telemac2d
+ TELEMAC_LIBRARY_bief
+ TELEMAC_LIBRARY_damocles
+ TELEMAC_LIBRARY_parallel
+ TELEMAC_LIBRARY_sisyphe
+ TELEMAC_LIBRARY_special
+ TELEMAC_LIBRARY_telemac2d
+ TELEMAC_LIBRARY_tomawac
+# TELEMAC_LIBRARY_gretel
+# TELEMAC_LIBRARY_partel
+ #TELEMAC_LIBRARY_hermes # Optional
+ TELEMAC_INCLUDE_DIR
+ TELEMAC_API_SRC_DIR)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+SET(RSTFILES
+ index.rst
+ basic.rst
+ advanced.rst
+)
+
+SET(SPHINXOPTS )
+SET(SOURCEDIR ${CMAKE_CURRENT_SOURCE_DIR})
+SET(PAPEROPT_a4 -D latex_paper_size=a4)
+SET(ALLSPHINXOPTS -d doctrees ${PAPEROPT_a4} ${SPHINXOPTS} ${SOURCEDIR})
+
+# install user's documentation
+
+SALOME_CONFIGURE_FILE(conf.py.in conf.py)
+
+SET(HTML_ROOT_FILE html/index.html)
+
+ADD_CUSTOM_COMMAND(OUTPUT ${HTML_ROOT_FILE}
+ COMMAND ${CMAKE_COMMAND} -E make_directory html
+ COMMAND ${CMAKE_COMMAND} -E make_directory doctrees
+ COMMAND ${SPHINX_EXECUTABLE} -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
+ DEPENDS ${RSTFILES}
+)
+
+ADD_CUSTOM_TARGET(BUILD_HTML ALL DEPENDS ${HTML_ROOT_FILE})
+
+INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
+ DESTINATION ${SALOME_HYDROSOLVER_INSTALL_DOC}
+ PATTERN ".buildinfo" EXCLUDE
+)
--- /dev/null
+../../resources/HYDRO.png
\ No newline at end of file
--- /dev/null
+../../resources/create_case1d.png
\ No newline at end of file
--- /dev/null
+../../resources/create_case2d.png
\ No newline at end of file
--- /dev/null
+../../resources/create_case_couplage.png
\ No newline at end of file
--- /dev/null
+../../resources/create_case_pytel.png
\ No newline at end of file
--- /dev/null
+..
+ Copyright (C) 2012-2013 EDF
+
+ This file is part of SALOME HYDRO module.
+
+ SALOME HYDRO module is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SALOME HYDRO module 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+
+####################
+Advanced usage guide
+####################
+
+Code coupling
+=============
+
+.. |run_coupling_button| image:: /_static/create_case_couplage.png
+ :align: middle
+
+Salome-Hydro offers a service to run coupled Mascaret - Telemac2D cases. First,
+you need to create a Mascaret case and a Telemac2D API case. Then, to set up
+the coupling, click on the button |run_coupling_button|. A new dialog appears
+(the *Eficas* interface) that let you choose the Mascaret and Telemac2D cases,
+an output file for the coupling log and another one in CSV format for graph
+generation. You must also specify a file to describe the coupling itself. This
+file must be a Python file declaring several variables. Here is an example of
+such a file::
+
+ # Time data
+ # Note that Telemac2D API can't use those values for now, so T2D case must be adapted manually
+ starttime = 0.0
+ endtime = 270300.0
+ timestep = 10.0
+
+ # Tolerances for convergence iterations
+ eps_Q = 1.0
+ eps_Z = 0.01
+
+ # Maximum number of convergence iterations
+ maxiter = 5
+
+ # Border descriptions
+ upstream_border_mascaret = {"code": "MASCARET",
+ "position": "upstream",
+ "section_id": 40,
+ "loi_id": 2}
+
+ upstream_border_telemac = {"code": "TELEMAC2D",
+ "position": "downstream",
+ "points_id": (1, 30), # First point included, last point excluded
+ "border_id": 1}
+
+ downstream_border_telemac = {"code": "TELEMAC2D",
+ "position": "upstream",
+ "points_id": (139, 154), # First point included, last point excluded
+ "border_id": 3}
+
+ downstream_border_mascaret = {"code": "MASCARET",
+ "position": "downstream",
+ "section_id": 41,
+ "loi_id": 3}
+
+ barrage_border_telemac = {"code": "TELEMAC2D",
+ "position": "upstream",
+ "points_id": (82, 101), # First point included, last point excluded
+ "border_id": 2}
+
+ source_mascaret = {"code": "MASCARET",
+ "position": "downstream",
+ "section_id": 1,
+ "loi_id": 1}
+
+ aval_mascaret = {"code": "MASCARET",
+ "position": "upstream",
+ "section_id": 79,
+ "loi_id": 4}
+
+ borders = [{"name": "amont",
+ "model1": upstream_border_mascaret,
+ "model2": upstream_border_telemac},
+ {"name": "ecluse",
+ "model1": downstream_border_telemac,
+ "model2": downstream_border_mascaret},
+ {"name": "barrage",
+ "model1": barrage_border_telemac,
+ "model2": None},
+ {"name": "source",
+ "model1": source_mascaret,
+ "model2": None},
+ {"name": "aval",
+ "model1": aval_mascaret,
+ "model2": None}]
+
+In this file, the coupling points (borders) are described by their two adjacent
+models, represented by a Python dictionary. In this description, the parameter
+"code" indicates which code is used on this side of the border (MASCARET or
+TELEMAC2D). The parameter "position" indicates if it is on the upstream or
+downstream side of the border.
+
+The parameter "section_id" for MASCARET indicates the section identifiant of the
+coupled point. The parameter "loi_id" for MASCARET indicates the identifiant of
+the law used to set values on that point.
+
+The parameter "points_id" for TELEMAC2D indicates the first and last point of
+the border. The parameter "border_id" identifies the liquid boundary.
+
+When all the desired files are selected, save this coupling description file. It
+will appear in Salome object browser. Right-click on the item in the object
+browser and select "Open schema in YACS" in the popup menu. YACS interface will
+open and show the coupling schema. You can then launch the schema execution
+directly in YACS (see YACS documentation for more information about launching
+or editing the schema directly).
+
+**Note**: In case of a crash or errors, check your */tmp* directory to find log
+files.
--- /dev/null
+..
+ Copyright (C) 2012-2013 EDF
+
+ This file is part of SALOME HYDRO module.
+
+ SALOME HYDRO module is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SALOME HYDRO module 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+
+############
+Simple Usage
+############
+
+Running a Telemac case
+======================
+
+.. |run_pytel_button| image:: /_static/create_case_pytel.png
+ :align: middle
+
+To run a Telemac case from Salome-Hydro, activate HydroSolver module and click
+on the button |run_pytel_button|. A new dialog appears (the *Eficas* interface)
+that let you choose the case file, dictionary, geometry file, etc. When all the
+desired files are selected, save this case description file. It will appear in
+Salome object browser. Right-click on the item in the object browser and select
+"Compute case" in the popup menu. Telemac will start the computation and the
+execution log will be shown in a terminal.
+
+**Note**: In case of a crash or errors, check your */tmp* directory to find log
+files.
+
+**Warning**: If you use the *Universal* distribution of Salome-Hydro on a
+platform that does not include gfortran 4.4.5 or a compatible version, you will
+not be able to use a user fortran file with your Telemac case.
+
+Running a Telemac 2D case with the API
+======================================
+
+.. |create_t2d_api_button| image:: /_static/create_case2d.png
+ :align: middle
+
+To run a Telemac 2D case through the TELEMAC2D API from Salome-Hydro, activate
+HydroSolver module and click on the button |create_t2d_api_button|. A new
+dialog appears that let you choose the case file, dictionary, geometry file,
+etc. When all the desired files are selected, save this case description file.
+It will appear in Salome object browser. Right-click on the item in the object
+browser and select "Compute case" in the popup menu. Telemac will start the
+computation.
+
+**Note**: Nothing is shown in the interface for now with this service. Check
+your */tmp* directory to find log files.
+
+**Warning**: If you use the *Universal* distribution of Salome-Hydro on a
+platform that does not include gfortran 4.4.5 or a compatible version, you will
+not be able to use a user fortran file with your Telemac 2D case.
+
+**Warning**: Due to a remaining bug, it is mandatory with this service to have a
+*CONFIG* file in the same directory as the case file, containing the
+declarations for *LU* and *LNG* variables.
+
+Running a Mascaret case
+=======================
+
+.. |create_mascaret_button| image:: /_static/create_case1d.png
+ :align: middle
+
+To run a Mascaret case from Salome-Hydro, activate HydroSolver module and click
+on the button |create_mascaret_button|. A new dialog appears that let you
+choose the case file, dictionary, geometry file, etc. You can also add several
+output variables with the parameter "VARIABLE_SORTIE". The name ("NOM") is
+free, but the Mascaret variable ("VARIABLE_MASCARET") must use a specific
+syntax inspired by Mascaret API. This syntax is
+*Type.NomVar.SubVar(idx1, idx2, idx3)*, where *Type* is "Etat" or "Modele",
+*NomVar* and *SubVar* are variables names (*SubVar* is not necessary for all
+variables), and *idxX* are indexes if the variable is an array. For instance,
+*Etat.Z(1,0,0)* is the water heigth on the first section of the model.
+
+When all the desired files are selected, save this case description file. It
+will appear in Salome object browser. Right-click on the item in the object
+browser and select "Compute case" in the popup menu. Mascaret will start the
+computation of the case. Unfortunately, Mascaret logs are not available yet
+through Mascaret API, so the only output available is the value of the
+specified output variables.
+
+**Note**: In case of a crash or errors, check your */tmp* directory to find log
+files.
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+
+# HYDROSOLVER module documentation build configuration file, created by
+# sphinx-quickstart.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.append(os.path.abspath('.'))
+
+# -- General configuration -----------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+#extensions = ['sphinx.ext.extlinks']
+
+# Add any paths that contain templates here, relative to this directory.
+#templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'HydroSolver module'
+copyright = u'2012-2013, EDF'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '@SALOMEHYDROSOLVER_VERSION@'
+# The full version, including alpha/beta/rc tags.
+release = '@SALOMEHYDROSOLVER_VERSION@'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of documents that shouldn't be included in the build.
+#unused_docs = []
+
+# List of directories, relative to source directory, that shouldn't be searched
+# for source files.
+#exclude_trees = ['_build']
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. Major themes that come with
+# Sphinx are currently 'default' and 'sphinxdoc'.
+html_theme = 'default'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further. For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents. If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar. Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_use_modindex = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it. The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = ''
+
+# Output file base name for HTML help builder.
+#htmlhelp_basename = 'HYDROSOLVERmoduledoc'
+
+
+# -- Options for LaTeX output --------------------------------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+#latex_font_size = '10pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+#latex_documents = [
+# ('index', 'HYDROSOLVERmodule.tex', u'HYDROSOLVER module Documentation',
+# u'EDF R&D', 'manual'),
+#]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_use_modindex = True
--- /dev/null
+..
+ Copyright (C) 2012-2013 EDF
+
+ This file is part of SALOME HYDRO module.
+
+ SALOME HYDRO module is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SALOME HYDRO module 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+HydroSolver module documentation
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+.. |hydrosolver_module_button| image:: /_static/HYDRO.png
+ :align: middle
+ :width: 16pt
+ :height: 16pt
+
+This documentation covers the usage of HydroSolver module in Salome. This module
+aims at providing services for the usage of Telemac and Mascaret codes. To
+activate this module, click on the |hydrosolver_module_button| button in the
+toolbar or select "HydroSolver" item in the "SALOME" menu. The first part of
+this guide addresses simple use cases (how to run the codes from Salome-Hydro
+platform) while the second part presents more advanced topics (code coupling).
+
+.. toctree::
+ :maxdepth: 2
+
+ basic.rst
+ advanced.rst
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+INCLUDE(UseOmniORB) # Provided by KERNEL
+
+INCLUDE_DIRECTORIES(
+ ${OMNIORB_INCLUDE_DIR}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${KERNEL_INCLUDE_DIRS}
+)
+
+SET(SalomeIDLHYDROSOLVER_IDLSOURCES
+ HYDROSOLVER.idl
+)
+
+SET(_idl_include_dirs
+ ${KERNEL_ROOT_DIR}/idl/salome
+)
+
+SET(_idl_link_flags
+ ${KERNEL_SalomeIDLKernel}
+)
+
+OMNIORB_ADD_MODULE(SalomeIDLHYDROSOLVER "${SalomeIDLHYDROSOLVER_IDLSOURCES}" "${_idl_include_dirs}" "${_idl_link_flags}")
+INSTALL(TARGETS SalomeIDLHYDROSOLVER EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
--- /dev/null
+// Copyright (C) 2012-2013 EDF
+//
+// This file is part of SALOME HYDRO module.
+//
+// SALOME HYDRO module is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// SALOME HYDRO module 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef _HYDROSOLVER_IDL_
+#define _HYDROSOLVER_IDL_
+
+#include "DSC_Engines.idl"
+#include "SALOMEDS.idl"
+#include "SALOME_Exception.idl"
+#include "SALOME_Component.idl"
+#include "SALOME_Comm.idl"
+#include "SALOME_Parametric.idl"
+
+
+
+module HYDROSOLVER_ORB
+{
+ struct MascaretFile {
+ string fileName;
+ string fileType;
+ };
+
+ typedef sequence<MascaretFile> MascaretFileList;
+
+ typedef sequence<string> stringvec;
+ typedef sequence<double> dblevec;
+
+ interface MASCARET: Engines::Superv_Component
+ {
+ /**
+ * @brief Execute a computation of a complete Mascaret case.
+ *
+ * The Compute method realizes the computation with the files specified in input. The
+ * variables outputVars are extracted in output and returned in outputValues.
+ *
+ * @param fileList the list of Mascaret files describing the case to compute
+ * @param ligFile the file containing the initial water line
+ * @param outputVars the list of the output variables to extract
+ * @param outputValues the extracted values
+ */
+ void Compute(in MascaretFileList fileList, in string ligFile,
+ in stringvec outputVars, out dblevec outputValues)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Initialize the component with the Mascaret case.
+ *
+ * The Init method prepares the component for a series of computation with
+ * the method Exec or ExecStep. It extracts the deterministic data from Salome study and
+ * stores this data along with the lists of input and output variables to
+ * identify them in future calls to Exec.
+ *
+ * @param studyID the identifier of the study containing the deterministic data
+ * @param detCaseEntry the identifier of the deterministic case within the study
+ */
+ void Init(in long studyID, in SALOMEDS::ID detCaseEntry)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Execute a computation with a given sample of variables.
+ *
+ * The Exec method realizes the computation with the probabilistic variables
+ * described in paramInput and the deterministic variables set previously with
+ * the Init method. The result is put in paramOutput in the order specified by
+ * paramInput.outputVarList.
+ *
+ * @param paramInput a structure describing the probabilistic variables and the order
+ * of the output variables.
+ * @param paramOutput a structure containing the result of the computation
+ */
+ void Exec(in SALOME_TYPES::ParametricInput paramInput,
+ out SALOME_TYPES::ParametricOutput paramOutput)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Initialize the border(s) for coupling
+ *
+ * @param borders structure describing the borders
+ */
+ void InitBorders(in Engines::fileBlock borders)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Compute a single time step
+ *
+ * @param timeData the data describing the time step to execute
+ * @param inputData the state data coming from the coupled code
+ * @param outputData the data to send to the coupled code
+ */
+ void ExecStep(in Engines::fileBlock timeData,
+ in Engines::fileBlock inputData,
+ out Engines::fileBlock outputData)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Cleanup everything that was previously set
+ *
+ * The Finalize method is in charge of cleaning everything that what set hitherto.
+ * It may be empty.
+ */
+ void Finalize()
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Old coupling method with datastream.
+ */
+ void ExecCoupling(in stringvec inputVarList, in stringvec outputVarList)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Old method to log values from datastream coupling.
+ */
+ void Log(in long studyID, in stringvec inputVarList)
+ raises (SALOME::SALOME_Exception);
+
+ };
+
+ interface TELEMAC2D: Engines::Superv_Component
+ {
+ /**
+ * @brief Execute a computation of a complete Telemac2D case.
+ *
+ * The Compute method realizes the computation of the case specified in input.
+ *
+ * @param studyID the identifier of the study containing Telemac2D case data
+ * @param caseEntry the identifier of the Telemac2D case within the study
+ */
+ void Compute(in long studyID, in SALOMEDS::ID caseEntry)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Initialize the component with the Telemac2D case.
+ *
+ * The Init method prepares the component for a series of computation with
+ * the method Exec or ExecStep. It extracts the deterministic data from Salome study and
+ * stores this data along with the lists of input and output variables to
+ * identify them in future calls to Exec.
+ *
+ * @param studyID the identifier of the study containing Telemac2D case data
+ * @param caseEntry the identifier of the Telemac2D case within the study
+ */
+ void Init(in long studyID, in SALOMEDS::ID detCaseEntry)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Execute a computation with a given sample of variables.
+ *
+ * The Exec method realizes the computation with the probabilistic variables
+ * described in paramInput and the deterministic variables set previously with
+ * the Init method. The result is put in paramOutput in the order specified by
+ * paramInput.outputVarList.
+ *
+ * @param paramInput a structure describing the probabilistic variables and the order
+ * of the output variables.
+ * @param paramOutput a structure containing the result of the computation
+ */
+ void Exec(in SALOME_TYPES::ParametricInput paramInput,
+ out SALOME_TYPES::ParametricOutput paramOutput)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Initialize the border(s) for coupling
+ *
+ * @param borders structure describing the borders
+ */
+ void InitBorders(in Engines::fileBlock borders)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Compute a single time step
+ *
+ * @param timeData the data describing the time step to execute
+ * @param inputData the state data coming from the coupled code
+ * @param outputData the data to send to the coupled code
+ */
+ void ExecStep(in Engines::fileBlock timeData,
+ in Engines::fileBlock inputData,
+ out Engines::fileBlock outputData)
+ raises (SALOME::SALOME_Exception);
+
+ /**
+ * @brief Cleanup everything that was previously set
+ *
+ * The Finalize method is in charge of cleaning everything that what set hitherto.
+ * It may be empty.
+ */
+ void Finalize()
+ raises (SALOME::SALOME_Exception);
+
+ };
+
+ interface HYDROSOLVER: Engines::EngineComponent, SALOMEDS::Driver
+ {
+
+ };
+
+};
+
+#endif
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+SET(HYDROSOLVER_RESOURCES_FILES
+ HYDROSOLVERCatalog.xml
+ icon_variables.png
+ HYDRO.png
+ HYDRO_small.png
+ case1d.png
+ case2d.png
+ case_couplage.png
+ create_case1d.png
+ create_case2d.png
+ create_case_couplage.png
+ log.png
+ create_case_pytel.png
+ case_pytel.png
+ define_boundary_conditions.png
+)
+
+INSTALL(FILES ${HYDROSOLVER_RESOURCES_FILES} DESTINATION ${SALOME_HYDROSOLVER_INSTALL_RES_DATA})
+
+MESSAGE(STATUS "Creation of ${CMAKE_CURRENT_BINARY_DIR}/SalomeApp.xml")
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/SalomeApp.xml.in ${CMAKE_CURRENT_BINARY_DIR}/SalomeApp.xml @ONLY)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/SalomeApp.xml DESTINATION ${SALOME_HYDROSOLVER_INSTALL_RES_DATA})
--- /dev/null
+<?xml version='1.0' encoding='us-ascii' ?>
+<!--
+ Copyright (C) 2012-2013 EDF
+
+ This file is part of SALOME HYDRO module.
+
+ SALOME HYDRO module is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SALOME HYDRO module 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+-->
+
+<!-- XML component catalog -->
+<begin-catalog>
+
+<!-- Path prefix information -->
+
+<path-prefix-list>
+</path-prefix-list>
+
+<!-- Commonly used types -->
+<type-list>
+ <struct name="HYDROSOLVER_ORB/MascaretFile">
+ <member type="string" name="fileName"></member>
+ <member type="string" name="fileType"></member>
+ </struct>
+ <sequence content="HYDROSOLVER_ORB/MascaretFile" name="HYDROSOLVER_ORB/MascaretFileList"></sequence>
+ <sequence content="string" name="HYDROSOLVER_ORB/stringvec"></sequence>
+ <sequence content="double" name="HYDROSOLVER_ORB/dblevec"></sequence>
+ <objref name="pyobj" id="python:obj:1.0"/>
+</type-list>
+
+<!-- Component list -->
+<component-list>
+
+ <component>
+ <!-- Component identification -->
+ <component-name>MASCARET</component-name>
+ <component-username>MASCARET</component-username>
+ <component-type>Data</component-type>
+ <component-author>EDF-RD</component-author>
+ <component-version>1.0</component-version>
+ <component-comment></component-comment>
+ <component-multistudy>0</component-multistudy>
+ <component-impltype>SO</component-impltype>
+ <component-implname></component-implname>
+ <component-interface-list>
+ <component-interface-name>MASCARET</component-interface-name>
+ <component-interface-comment></component-interface-comment>
+ <component-service-list>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Compute</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>fileList</inParameter-name>
+ <inParameter-type>HYDROSOLVER_ORB/MascaretFileList</inParameter-type>
+ <inParameter-comment>unknown</inParameter-comment>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>ligFile</inParameter-name>
+ <inParameter-type>string</inParameter-type>
+ <inParameter-comment>unknown</inParameter-comment>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>outputVars</inParameter-name>
+ <inParameter-type>HYDROSOLVER_ORB/stringvec</inParameter-type>
+ <inParameter-comment>unknown</inParameter-comment>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+ <outParameter>
+ <outParameter-name>outputValues</outParameter-name>
+ <outParameter-type>HYDROSOLVER_ORB/dblevec</outParameter-type>
+ <outParameter-comment>unknown</outParameter-comment>
+ </outParameter>
+ </outParameter-list>
+ <DataStream-list>
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Init</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>studyID</inParameter-name>
+ <inParameter-type>long</inParameter-type>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>detCaseEntry</inParameter-name>
+ <inParameter-type>string</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+
+ </outParameter-list>
+ <DataStream-list>
+
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Exec</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>paramInput</inParameter-name>
+ <inParameter-type>SALOME_TYPES/ParametricInput</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+ <outParameter>
+ <outParameter-name>paramOutput</outParameter-name>
+ <outParameter-type>SALOME_TYPES/ParametricOutput</outParameter-type>
+ </outParameter>
+ </outParameter-list>
+ <DataStream-list>
+
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>InitBorders</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>borders</inParameter-name>
+ <inParameter-type>pyobj</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>ExecStep</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>timeData</inParameter-name>
+ <inParameter-type>pyobj</inParameter-type>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>inputData</inParameter-name>
+ <inParameter-type>pyobj</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+ <outParameter>
+ <outParameter-name>outputData</outParameter-name>
+ <outParameter-type>pyobj</outParameter-type>
+ </outParameter>
+ </outParameter-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Finalize</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+
+ </inParameter-list>
+ <outParameter-list>
+
+ </outParameter-list>
+ <DataStream-list>
+
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>ExecCoupling</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>inputVarList</inParameter-name>
+ <inParameter-type>HYDROSOLVER_ORB/stringvec</inParameter-type>
+ <inParameter-comment>unknown</inParameter-comment>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>outputVarList</inParameter-name>
+ <inParameter-type>HYDROSOLVER_ORB/stringvec</inParameter-type>
+ <inParameter-comment>unknown</inParameter-comment>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+
+ </outParameter-list>
+ <DataStream-list>
+ <inParameter>
+ <inParameter-name>inputValues</inParameter-name>
+ <inParameter-type>CALCIUM_double</inParameter-type>
+ <inParameter-dependency>T</inParameter-dependency>
+ </inParameter>
+ <outParameter>
+ <outParameter-name>outputValues</outParameter-name>
+ <outParameter-type>CALCIUM_double</outParameter-type>
+ <outParameter-dependency>T</outParameter-dependency>
+ </outParameter>
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Log</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>studyID</inParameter-name>
+ <inParameter-type>long</inParameter-type>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>inputVarList</inParameter-name>
+ <inParameter-type>HYDROSOLVER_ORB/stringvec</inParameter-type>
+ <inParameter-comment>unknown</inParameter-comment>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+
+ </outParameter-list>
+ <DataStream-list>
+ <inParameter>
+ <inParameter-name>inputValues</inParameter-name>
+ <inParameter-type>CALCIUM_double</inParameter-type>
+ <inParameter-dependency>S</inParameter-dependency>
+ </inParameter>
+ </DataStream-list>
+ </component-service>
+ </component-service-list>
+ </component-interface-list>
+ </component>
+
+ <component>
+ <!-- Component identification -->
+ <component-name>TELEMAC2D</component-name>
+ <component-username>TELEMAC2D</component-username>
+ <component-type>Data</component-type>
+ <component-author>EDF-RD</component-author>
+ <component-version>1.0</component-version>
+ <component-comment></component-comment>
+ <component-multistudy>0</component-multistudy>
+ <component-impltype>SO</component-impltype>
+ <component-implname></component-implname>
+ <component-interface-list>
+ <component-interface-name>TELEMAC2D</component-interface-name>
+ <component-interface-comment></component-interface-comment>
+ <component-service-list>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Compute</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>studyID</inParameter-name>
+ <inParameter-type>long</inParameter-type>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>detCaseEntry</inParameter-name>
+ <inParameter-type>string</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+ </outParameter-list>
+ <DataStream-list>
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Init</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>studyID</inParameter-name>
+ <inParameter-type>long</inParameter-type>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>detCaseEntry</inParameter-name>
+ <inParameter-type>string</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+
+ </outParameter-list>
+ <DataStream-list>
+
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Exec</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>paramInput</inParameter-name>
+ <inParameter-type>SALOME_TYPES/ParametricInput</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+ <outParameter>
+ <outParameter-name>paramOutput</outParameter-name>
+ <outParameter-type>SALOME_TYPES/ParametricOutput</outParameter-type>
+ </outParameter>
+ </outParameter-list>
+ <DataStream-list>
+
+ </DataStream-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>InitBorders</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>borders</inParameter-name>
+ <inParameter-type>pyobj</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>ExecStep</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+ <inParameter>
+ <inParameter-name>timeData</inParameter-name>
+ <inParameter-type>pyobj</inParameter-type>
+ </inParameter>
+ <inParameter>
+ <inParameter-name>inputData</inParameter-name>
+ <inParameter-type>pyobj</inParameter-type>
+ </inParameter>
+ </inParameter-list>
+ <outParameter-list>
+ <outParameter>
+ <outParameter-name>outputData</outParameter-name>
+ <outParameter-type>pyobj</outParameter-type>
+ </outParameter>
+ </outParameter-list>
+ </component-service>
+ <component-service>
+ <!-- service-identification -->
+ <service-name>Finalize</service-name>
+ <service-author>EDF-RD</service-author>
+ <service-version>1.0</service-version>
+ <service-comment></service-comment>
+ <service-by-default>0</service-by-default>
+ <!-- service-connexion -->
+ <inParameter-list>
+
+ </inParameter-list>
+ <outParameter-list>
+
+ </outParameter-list>
+ <DataStream-list>
+
+ </DataStream-list>
+ </component-service>
+ </component-service-list>
+ </component-interface-list>
+ </component>
+
+ <component>
+ <!-- Component identification -->
+ <component-name>HYDROSOLVER</component-name>
+ <component-username>HYDROSOLVER</component-username>
+ <component-type>Data</component-type>
+ <component-author>EDF-RD</component-author>
+ <component-version>1.0</component-version>
+ <component-comment></component-comment>
+ <component-multistudy>0</component-multistudy>
+ <component-impltype>SO</component-impltype>
+ <component-implname></component-implname>
+ <component-interface-list>
+ <component-interface-name>HYDROSOLVER</component-interface-name>
+ <component-interface-comment></component-interface-comment>
+ <component-service-list>
+
+ </component-service-list>
+ </component-interface-list>
+ </component>
+</component-list>
+</begin-catalog>
--- /dev/null
+<!--
+ Copyright (C) 2012-2013 EDF
+
+ This file is part of SALOME HYDRO module.
+
+ SALOME HYDRO module is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SALOME HYDRO module 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+-->
+<document>
+ <section name="HYDROSOLVER">
+ <!-- Major module parameters -->
+ <parameter name="name" value="HydroSolver"/>
+ <parameter name="icon" value="HYDRO.png"/>
+ <parameter name="library" value="SalomePyQtGUI"/>
+ <parameter name="documentation" value="hydrosolver_help"/>
+ <parameter name="version" value="@SALOMEHYDROSOLVER_VERSION@"/>
+ </section>
+ <section name="resources">
+ <!-- Module resources -->
+ <parameter name="HYDROSOLVER" value="%HYDROSOLVER_ROOT_DIR%/share/salome/resources/hydrosolver"/>
+ </section>
+ <section name="hydrosolver_help">
+ <parameter name="sub_menu" value="%1 module"/>
+ <parameter name="User's Guide" value="%HYDROSOLVER_ROOT_DIR%/share/doc/salome/gui/hydrosolver/index.html"/>
+ </section>
+</document>
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(HYDRO)
+ADD_SUBDIRECTORY(HYDROGUI)
+ADD_SUBDIRECTORY(salome_hydro)
+ADD_SUBDIRECTORY(mascaret_wrapper)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- scripts ---
+
+# scripts / static
+SET(_bin_SCRIPTS
+ HYDROSOLVER.py
+ MASCARET.py
+ TELEMAC2D.py
+)
+
+# --- rules ---
+SALOME_INSTALL_SCRIPTS("${_bin_SCRIPTS}" ${SALOME_INSTALL_SCRIPT_PYTHON})
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import HYDROSOLVER_ORB__POA
+import SALOME_ComponentPy
+import SALOME_DriverPy
+
+
+class HYDROSOLVER(HYDROSOLVER_ORB__POA.HYDROSOLVER,
+ SALOME_ComponentPy.SALOME_ComponentPy_i,
+ SALOME_DriverPy.SALOME_DriverPy_i):
+
+ """
+ Pour etre un composant SALOME cette classe Python
+ doit avoir le nom du composant et heriter de la
+ classe HYDROSOLVER issue de la compilation de l'idl
+ par omniidl et de la classe SALOME_ComponentPy_i
+ qui porte les services generaux d'un composant SALOME
+ """
+ def __init__ ( self, orb, poa, contID, containerName, instanceName,
+ interfaceName ):
+ SALOME_ComponentPy.SALOME_ComponentPy_i.__init__(self, orb, poa,
+ contID, containerName, instanceName, interfaceName, 0)
+ SALOME_DriverPy.SALOME_DriverPy_i.__init__(self, interfaceName)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import logging
+import threading
+import inspect
+import traceback
+import cPickle
+
+import salome
+import HYDROSOLVER_ORB__POA
+import SALOME_ComponentPy
+import SALOME
+import calcium
+import dsccalcium
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("MASCARET", color = termcolor.BLUE)
+logger.setLevel(logging.DEBUG)
+
+from salome.kernel.parametric.compo_utils import \
+ create_input_dict, create_normal_parametric_output, create_error_parametric_output
+
+from salome.hydro.mascaret import Mascaret, MascaretFile
+from salome.hydro.study import HydroStudyEditor
+
+def mascaretFileListCorbaToCpp(file_list_corba):
+ file_list_cpp = []
+ for file_corba in file_list_corba:
+ file_cpp = MascaretFile()
+ file_cpp.fileName = file_corba.fileName
+ file_cpp.fileType = file_corba.fileType
+ file_list_cpp.append(file_cpp)
+ return file_list_cpp
+
+
+class MascaretVariable:
+
+ def __init__(self, inst, varstr):
+ self.inst = inst
+ par1 = varstr.find("(")
+ par2 = varstr.find(")")
+ self.varname = varstr[:par1]
+ ranges_str = varstr[par1+1:par2].split(",")
+ if len(ranges_str) != 3:
+ raise Exception('Invalid variable "%s"' % varstr)
+ self.ranges = []
+ self.valid_for_output = True
+ for currange in ranges_str:
+ limits = currange.split("-")
+ if len(limits) != 1 and len(limits) != 2:
+ raise Exception('Invalid variable "%s"' % varstr)
+ limit_inf = int(limits[0])
+ if len(limits) == 2:
+ limit_sup = int(limits[1])
+ else:
+ limit_sup = limit_inf
+ newrange = range(limit_inf, limit_sup + 1)
+ if len(newrange) > 1:
+ self.valid_for_output = False
+ self.ranges.append(newrange)
+
+ def get_value(self):
+ if not self.valid_for_output:
+ raise Exception('Variable "%s" is not valid as an output variable' % self.varname)
+ logger.debug("Getting value: getDouble(%s, %d, %d, %d)" %
+ (self.varname, self.ranges[0][0], self.ranges[1][0], self.ranges[2][0]))
+ return self.inst.getDouble(self.varname, self.ranges[0][0], self.ranges[1][0], self.ranges[2][0])
+
+ def set_value(self, value):
+ for x in self.ranges[0]:
+ for y in self.ranges[1]:
+ for z in self.ranges[2]:
+ logger.debug("Setting value: setDouble(%s, %d, %d, %d, %f)" %
+ (self.varname, x, y, z, value))
+ self.inst.setDouble(self.varname, x, y, z, value)
+
+################################################
+
+class MASCARET(HYDROSOLVER_ORB__POA.MASCARET, dsccalcium.PyDSCComponent):
+
+ lock = threading.Lock()
+
+ """
+ Pour etre un composant SALOME cette classe Python
+ doit avoir le nom du composant et heriter de la
+ classe HYDRO_ORB__POA.MASCARET issue de la compilation de l'idl
+ par omniidl et de la classe SALOME_ComponentPy_i
+ qui porte les services generaux d'un composant SALOME
+ """
+ def __init__ ( self, orb, poa, contID, containerName, instanceName,
+ interfaceName ):
+ logger.info("__init__: " + containerName + ' ; ' + instanceName)
+ dsccalcium.PyDSCComponent.__init__(self, orb, poa,contID,
+ containerName,instanceName,interfaceName)
+ self.file_list = None
+ self.lig_file = None
+ self.inst = None
+ self.last_start_time = None
+ self.state_id = None
+ self.initial_state_id = None
+ self.input_var_map = None
+ self.output_var_map = None
+
+ def init_service(self,service):
+ if service == "ExecCoupling":
+ # initialization CALCIUM ports IN
+ calcium.create_calcium_port(self.proxy, "inputValues", "CALCIUM_double", "IN", "T")
+ # initialization CALCIUM ports OUT
+ calcium.create_calcium_port(self.proxy, "outputValues", "CALCIUM_double", "OUT", "T")
+ elif service == "Log":
+ # initialization CALCIUM ports IN
+ calcium.create_calcium_port(self.proxy, "inputValues", "CALCIUM_double", "IN", "T")
+ return service in ("Compute", "Init", "Exec", "Finalize", "ExecCoupling", "Log")
+
+ def _raiseSalomeError(self):
+ message = "Error in component %s running in container %s." % (self._instanceName, self._containerName)
+ logger.exception(message)
+ message += " " + traceback.format_exc()
+ exc = SALOME.ExceptionStruct(SALOME.INTERNAL_ERROR, message,
+ inspect.stack()[1][1], inspect.stack()[1][2])
+ raise SALOME.SALOME_Exception(exc)
+
+ def Compute(self, fileList, ligFile, outputVars):
+ try:
+ self.beginService("MASCARET.Compute")
+
+ # Initialize
+ inst = Mascaret()
+ inst.importModel(mascaretFileListCorbaToCpp(fileList))
+ inst.initState(ligFile)
+
+ # Compute
+ inst.compute()
+
+ # Get the output values
+ output_values = [MascaretVariable(inst, var).get_value() for var in outputVars]
+
+ self.endService("MASCARET.Compute")
+ return output_values
+ except:
+ self._raiseSalomeError()
+
+ def Init(self, studyId, detCaseEntry):
+ try:
+ self.beginService("MASCARET.Init")
+ MASCARET.lock.acquire()
+ salome.salome_init()
+ MASCARET.lock.release()
+
+ ed = HydroStudyEditor(studyId)
+ sobj = ed.editor.study.FindObjectID(detCaseEntry)
+ (file_list_corba, self.lig_file, input_vars, output_vars) = ed.get_mascaret_params_from_case(sobj)
+
+ self.file_list = mascaretFileListCorbaToCpp(file_list_corba)
+
+ # Initialize Mascaret instance
+ self.inst = Mascaret()
+ #self.inst.setPrinting(True)
+ self.inst.importModel(self.file_list)
+ self.inst.initState(self.lig_file)
+
+ # Create variable mappings
+ self.input_var_map = {}
+ for input_var in input_vars:
+ name = input_var["NOM"]
+ if not self.input_var_map.has_key(name):
+ self.input_var_map[name] = []
+ self.input_var_map[name] += [MascaretVariable(self.inst, input_var["VARIABLE_MASCARET"])]
+
+ self.output_var_map = {}
+ for output_var in output_vars:
+ masc_output_var = MascaretVariable(self.inst, output_var["VARIABLE_MASCARET"])
+ self.output_var_map[output_var["NOM"]] = masc_output_var
+
+ self.endService("MASCARET.Init")
+ except:
+ self._raiseSalomeError()
+
+ def Exec(self, paramInput):
+ try:
+ self.beginService("MASCARET.Exec")
+
+ if self.initial_state_id is not None:
+ self.inst.restoreState(self.initial_state_id)
+ self.initial_state_id = self.inst.saveState()
+
+ logger.debug("inputVarList: %s" % paramInput.inputVarList)
+ logger.debug("outputVarList: %s" % paramInput.outputVarList)
+ logger.debug("inputValues: %s" % paramInput.inputValues)
+
+ input_dict = create_input_dict({}, paramInput)
+ logger.debug("input_dict = %s" % input_dict)
+
+ for (key, value) in input_dict.iteritems():
+ for masc_var in self.input_var_map[key]:
+ masc_var.set_value(value)
+
+ # Compute
+ self.inst.compute()
+
+ # Get the output values
+ output_dict = {}
+ for output_var in paramInput.outputVarList:
+ output_dict[output_var] = self.output_var_map[output_var].get_value()
+
+ param_output = create_normal_parametric_output(output_dict, paramInput)
+ logger.debug("outputValues: %s" % param_output.outputValues)
+ self.endService("MASCARET.Exec")
+ return param_output
+ except:
+ self._raiseSalomeError()
+
+ def InitBorders(self, bordersPickled):
+ """
+ This method initializes the border(s) for coupling
+ """
+ try:
+ self.beginService("MASCARET.InitBorders")
+ borders = cPickle.loads(bordersPickled)
+ self.borders = {}
+ for border in borders:
+ if border["model1"] is not None and border["model1"]["code"] == "MASCARET":
+ self.borders[border["name"]] = border["model1"]
+ elif border["model2"] is not None and border["model2"]["code"] == "MASCARET":
+ self.borders[border["name"]] = border["model2"]
+ self.endService("MASCARET.InitBorders")
+ except:
+ self._raiseSalomeError()
+
+ def setData(self, inputData):
+ if inputData is not None:
+ for (name, desc) in self.borders.iteritems():
+ if name in inputData:
+ if desc["position"] == "upstream":
+ if self.froude[name] < 1.0:
+ Z = inputData[name]["Z"]
+ self.inst.setDouble("Modele.Lois.Cote", desc["loi_id"], 1, 0, Z)
+ self.inst.setDouble("Modele.Lois.Cote", desc["loi_id"], 2, 0, Z)
+ else:
+ Q = inputData[name]["Q"]
+ self.inst.setDouble("Modele.Lois.Debit", desc["loi_id"], 1, 0, Q)
+ self.inst.setDouble("Modele.Lois.Debit", desc["loi_id"], 2, 0, Q)
+ if self.froude[name] >= 1.0:
+ Z = inputData[name]["Z"]
+ self.inst.setDouble("Modele.Lois.Cote", desc["loi_id"], 1, 0, Z)
+ self.inst.setDouble("Modele.Lois.Cote", desc["loi_id"], 2, 0, Z)
+
+ def ExecStep(self, timeDataPickled, inputDataPickled):
+ """
+ This method computes a single time step
+ """
+ try:
+ self.beginService("MASCARET.ExecStep")
+ timeData = cPickle.loads(timeDataPickled)
+ inputData = cPickle.loads(inputDataPickled)
+
+ if self.last_start_time is not None:
+ self.inst.restoreState(self.state_id)
+ # If it's a new time step, we perform a last iteration with
+ # the last time step to restore the state properly
+ if self.last_start_time != timeData["start_time"]:
+ self.setData(inputData)
+ self.inst.compute(self.last_start_time, timeData["start_time"], timeData["time_step"])
+
+ self.last_start_time = timeData["start_time"]
+ self.state_id = self.inst.saveState()
+
+ self.setData(inputData)
+
+ # Computation
+ self.inst.compute(timeData["start_time"], timeData["end_time"], timeData["time_step"])
+
+ # Get the output values
+ outputData = {}
+ self.froude = {}
+ for (name, desc) in self.borders.iteritems():
+ Z = self.inst.getDouble("Etat.Z", desc["section_id"], 0, 0)
+ Q1 = self.inst.getDouble("Etat.Q1", desc["section_id"], 0, 0)
+ S1 = self.inst.getDouble("Etat.S1", desc["section_id"], 0, 0)
+ V = Q1/S1
+ #V = self.inst.getDouble("Etat.V1", desc["section_id"], 0, 0)
+ Q = self.inst.getDouble("Etat.Q", desc["section_id"], 0, 0)
+ Froude = self.inst.getDouble("Etat.Froude", desc["section_id"], 0, 0)
+ outputData[name] = {"Z": Z, "V": V, "Froude": Froude, "Q": Q}
+ self.froude[name] = Froude
+ outputDataPickled = cPickle.dumps(outputData, -1)
+
+ self.endService("MASCARET.ExecStep")
+ return outputDataPickled
+ except:
+ self._raiseSalomeError()
+
+ def Finalize(self):
+ try:
+ self.beginService("MASCARET.Finalize")
+ self.file_list = None
+ self.lig_file = None
+ self.inst = None
+ self.last_start_time = None
+ self.state_id = None
+ self.input_var_map = None
+ self.output_var_map = None
+ self.endService("MASCARET.Finalize")
+ except:
+ self._raiseSalomeError()
+
+ def ExecCoupling(self, inputVarList, outputVarList):
+ try:
+ self.beginService("MASCARET.ExecCoupling")
+ component = self.proxy
+
+ # Get time data from model
+ start_time = self.inst.getDouble("Modele.TempsInitial", 0, 0, 0)
+ end_time = self.inst.getDouble("Modele.TempsMaximum", 0, 0, 0)
+ time_step = self.inst.getDouble("Modele.DT", 0, 0, 0)
+
+ # Time loop
+ current_time = start_time
+ calcium.cp_cd(component)
+ while current_time < end_time:
+ # Send data
+ if len(outputVarList) > 0:
+ output_values = []
+ for output_var in outputVarList:
+ masc_var = self.output_var_map[output_var]
+ value = self.inst.getDouble(*split_var(masc_var))
+ output_values += [value]
+ info = calcium.cp_edb(component, calcium.CP_TEMPS, current_time, 0, "outputValues",
+ len(outputVarList), output_values)
+ logger.debug("Instance %s sent %s" % (self._instanceName, zip(outputVarList, output_values)))
+ if info != 0:
+ raise Exception("Error in calcium.cp_edb, code = %d" % info)
+
+ # Receive data
+ input_values = calcium.doubleArray(len(inputVarList))
+ if len(inputVarList) > 0:
+ (info, t, ii, n) = calcium.cp_ldb(component, calcium.CP_TEMPS,
+ current_time, current_time + 1e-6,
+ 0, "inputValues", len(inputVarList), input_values)
+ if info != 0:
+ raise Exception("Error in calcium.cp_ldb, code = %d" % info)
+ if n != len(inputVarList):
+ raise Exception("Wrong number of input values: %d instead of %d" % (n, len(inputVarList)))
+ logger.debug("Instance %s received %s" % (self._instanceName, zip(inputVarList, input_values)))
+
+ # Update model with received data
+ for (var, value) in zip(inputVarList, input_values):
+ for masc_var in self.input_var_map[var]:
+ self.inst.setDouble(*(split_var(masc_var) + (value,)))
+
+ # Compute
+ end_step_time = current_time + time_step
+ self.inst.compute(current_time, end_step_time, time_step)
+ current_time = end_step_time
+
+ calcium.cp_fin(component, calcium.CP_ARRET)
+ self.endService("MASCARET.ExecCoupling")
+ except:
+ self._raiseSalomeError()
+
+ def Log(self, studyId, inputVarList):
+ """
+ This method is not used anymore. It was used in the context of the calcium coupling test.
+ """
+ try:
+ self.beginService("MASCARET.Log")
+ if len(inputVarList) > 0:
+ log = {}
+ for var in inputVarList:
+ log[var] = ""
+ component = self.proxy
+ finished = False
+ calcium.cp_cd(component)
+ while not finished:
+ # Receive data
+ input_values = calcium.doubleArray(len(inputVarList))
+ (info, t, ii, n) = calcium.cp_ldb(component, calcium.CP_SEQUENTIEL,
+ 0, 0, 0, "inputValues", len(inputVarList), input_values)
+ if info == 33:
+ finished = True
+ elif info != 0:
+ raise Exception("Error in calcium.cp_ldb, code = %d" % info)
+ elif n != len(inputVarList):
+ raise Exception("Wrong number of input values: %d instead of %d" % (n, len(inputVarList)))
+ else:
+ logger.debug("Instance %s received %s" % (self._instanceName, zip(inputVarList, input_values)))
+ for (var, value) in zip(inputVarList, input_values):
+ log[var] += "t = %f, %s = %f\n" % (t, var, value)
+ calcium.cp_fin(component, calcium.CP_ARRET)
+ ed = HydroStudyEditor(studyId)
+ for var in inputVarList:
+ ed.add_coupling_log(var, log[var])
+ self.endService("MASCARET.Log")
+ except:
+ self._raiseSalomeError()
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import sys
+import os
+import logging
+import threading
+import inspect
+import traceback
+import cPickle
+import math
+import types
+
+import salome
+import HYDROSOLVER_ORB__POA
+import SALOME_ComponentPy
+import SALOME
+import calcium
+import dsccalcium
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("TELEMAC2D", color = termcolor.BLUE)
+logger.setLevel(logging.DEBUG)
+
+from salome.kernel.parametric.compo_utils import \
+ create_input_dict, create_normal_parametric_output, create_error_parametric_output
+
+from salome.hydro.telemac2d import Telemac2D
+from salome.hydro.telemac2d.polygon import get_list_points_in_polygon
+from salome.hydro.study import jdc_to_dict, get_jdc_dict_var_as_tuple, HydroStudyEditor
+
+################################################
+
+class TELEMAC2D(HYDROSOLVER_ORB__POA.TELEMAC2D, dsccalcium.PyDSCComponent):
+
+ lock = threading.Lock()
+
+ """
+ Pour etre un composant SALOME cette classe Python
+ doit avoir le nom du composant et heriter de la
+ classe HYDRO_ORB__POA.MASCARET issue de la compilation de l'idl
+ par omniidl et de la classe SALOME_ComponentPy_i
+ qui porte les services generaux d'un composant SALOME
+ """
+ def __init__ ( self, orb, poa, contID, containerName, instanceName,
+ interfaceName ):
+ logger.info("__init__: " + containerName + ' ; ' + instanceName)
+ dsccalcium.PyDSCComponent.__init__(self, orb, poa,contID,
+ containerName,instanceName,interfaceName)
+ self.t2d = None
+ self.last_start_time = None
+ self.saved_state = None
+
+ def init_service(self,service):
+ return service in ("Compute",)
+
+ def _raiseSalomeError(self):
+ message = "Error in component %s running in container %s." % (self._instanceName, self._containerName)
+ logger.exception(message)
+ message += " " + traceback.format_exc()
+ exc = SALOME.ExceptionStruct(SALOME.INTERNAL_ERROR, message,
+ inspect.stack()[1][1], inspect.stack()[1][2])
+ raise SALOME.SALOME_Exception(exc)
+
+ def Init(self, studyId, detCaseEntry):
+ try:
+ self.beginService("TELEMAC2D.Init")
+ self.jdc_dict = self.get_jdc_dict_from_case(studyId, detCaseEntry)
+
+ # Ugly hack to check if we are in OpenTURNS context or Mascaret coupling context
+ if "VARIABLE_ENTREE" in self.jdc_dict:
+ # Create variable mappings for OpenTURNS
+ self.input_var_map = {}
+ for input_var in get_jdc_dict_var_as_tuple(self.jdc_dict, "VARIABLE_ENTREE"):
+ name = input_var["NOM"]
+ if not self.input_var_map.has_key(name):
+ self.input_var_map[name] = []
+ self.input_var_map[name] += [Telemac2DInputVariable(input_var["VARIABLE_MODELE_T2D"])]
+
+ self.output_var_map = {}
+ for output_var in get_jdc_dict_var_as_tuple(self.jdc_dict, "VARIABLE_SORTIE"):
+ t2d_output_var = Telemac2DOutputVariable(output_var["VARIABLE_T2D"])
+ self.output_var_map[output_var["NOM"]] = t2d_output_var
+
+ else:
+ # Initialize before launching the coupling with Mascaret
+ self.init_t2d_from_jdc_dict(self.jdc_dict)
+
+ self.endService("TELEMAC2D.Init")
+ except:
+ self._raiseSalomeError()
+
+ def get_jdc_dict_from_case(self, study_id, case_entry):
+ TELEMAC2D.lock.acquire()
+ salome.salome_init()
+ TELEMAC2D.lock.release()
+
+ # Get filenames from the case in Salome study
+ ed = HydroStudyEditor(study_id)
+ sobj = ed.editor.study.FindObjectID(case_entry)
+ jdcpath = sobj.GetComment()
+ with open(jdcpath) as jdcfile:
+ jdc = jdcfile.read()
+ return jdc_to_dict(jdc, ["TELEMAC2D", "_F"])
+
+ def init_t2d_from_jdc_dict(self, jdc_dict):
+ steering_filename = jdc_dict["FICHIER_CAS"]
+ user_fortran = jdc_dict.get("FICHIER_FORTRAN_UTILISATEUR")
+ dico_filename = jdc_dict.get("FICHIER_DICO")
+ geo_filename = jdc_dict.get("FICHIER_GEOMETRIE")
+ bc_filename = jdc_dict.get("FICHIER_CONDITIONS_LIMITES")
+ result_filename = jdc_dict.get("RESULTAT")
+
+ logger.debug("Initializing Telemac2D API")
+ self.t2d = Telemac2D(user_fortran)
+ logger.debug("Telemac2D API initialization OK")
+ os.chdir(os.path.dirname(steering_filename))
+ self.t2d.run_read_case_t2d(steering_filename, dico_filename)
+ if bc_filename is not None:
+ self.t2d.set_string('MODEL.BCFILE', bc_filename)
+ if geo_filename is not None:
+ self.t2d.set_string('MODEL.GEOMETRYFILE', geo_filename)
+ if result_filename is not None:
+ self.t2d.set_string('MODEL.RESULTFILE', result_filename)
+ ierr = self.t2d.api.run_allocation_t2d(self.t2d.id)
+ if ierr != 0:
+ raise Exception('Error in run_allocation_t2d:', ierr)
+ ierr = self.t2d.api.run_init_t2d(self.t2d.id)
+ if ierr != 0:
+ raise Exception('Error in run_init_t2d:', ierr)
+
+ def Exec(self, paramInput):
+ try:
+ self.beginService("TELEMAC2D.Exec")
+
+ # Save / restore state
+ # Not used yet because time can not be reset
+ #if self.saved_state is None:
+ # self.saved_state = self.t2d.save_state()
+ #else:
+ # self.t2d.restore_state(self.saved_state)
+
+ # Get id and execution mode
+ id = ""
+ exec_mode = ""
+ for parameter in paramInput.specificParameters:
+ if parameter.name == "id":
+ id = parameter.value
+ if parameter.name == "executionMode":
+ exec_mode = parameter.value
+ logger.debug("ID: %s" % id)
+ logger.debug("Execution mode: %s" % exec_mode)
+
+ # Append id to result file name
+ result_filename = self.jdc_dict.get("RESULTAT") or "r2d.slf"
+ (result_filename_wo_ext, ext) = os.path.splitext(result_filename)
+ current_jdc_dict = self.jdc_dict.copy()
+ current_jdc_dict["RESULTAT"] = "%s_%s%s" % (result_filename_wo_ext, id, ext)
+
+ # Reload model
+ self.init_t2d_from_jdc_dict(current_jdc_dict)
+
+ # Set the input values
+ logger.debug("inputVarList: %s" % paramInput.inputVarList)
+ logger.debug("outputVarList: %s" % paramInput.outputVarList)
+ logger.debug("inputValues: %s" % paramInput.inputValues)
+
+ input_dict = create_input_dict({}, paramInput)
+ logger.debug("input_dict = %s" % input_dict)
+
+ for (key, value) in input_dict.iteritems():
+ for t2d_var in self.input_var_map[key]:
+ t2d_var.set_value(self.t2d, value)
+
+ # Compute
+ self.t2d.run_all_timesteps()
+
+ # Get the output values
+ output_dict = {}
+ for output_var in paramInput.outputVarList:
+ output_dict[output_var] = self.output_var_map[output_var].get_value(self.t2d)
+
+ param_output = create_normal_parametric_output(output_dict, paramInput)
+ logger.debug("outputValues: %s" % param_output.outputValues)
+
+ # Finalize T2D
+ self.t2d.finalize()
+ self.t2d = None
+
+ self.endService("TELEMAC2D.Exec")
+ return param_output
+ except:
+ self._raiseSalomeError()
+
+ def InitBorders(self, bordersPickled):
+ """
+ This method initializes the border(s) for coupling
+ """
+ try:
+ self.beginService("TELEMAC2D.InitBorders")
+ borders = cPickle.loads(bordersPickled)
+ self.borders = {}
+ for border in borders:
+ if border["model1"] is not None and border["model1"]["code"] == "TELEMAC2D":
+ self.borders[border["name"]] = border["model1"]
+ elif border["model2"] is not None and border["model2"]["code"] == "TELEMAC2D":
+ self.borders[border["name"]] = border["model2"]
+ self.endService("TELEMAC2D.InitBorders")
+ except:
+ self._raiseSalomeError()
+
+ def ExecStep(self, timeDataPickled, inputDataPickled):
+ """
+ This method computes a single time step
+ """
+ try:
+ self.beginService("TELEMAC2D.ExecStep")
+ timeData = cPickle.loads(timeDataPickled)
+ inputData = cPickle.loads(inputDataPickled)
+
+ if timeData["start_time"] == self.last_start_time:
+ # Convergence iteration, restore saved state
+ self.t2d.restore_state(self.saved_state)
+ else:
+ # First iteration of a time step, save state
+ self.saved_state = self.t2d.save_state(self.saved_state)
+
+ self.last_start_time = timeData["start_time"]
+
+ if inputData is not None:
+ for (name, desc) in self.borders.iteritems():
+ if name in inputData:
+ z = None
+ v = None
+ q = None
+ if desc["position"] == "upstream":
+ if inputData[name]["Froude"] < 1.0: # Fluvial
+ z = inputData[name]["Z"]
+ else:
+ v = inputData[name]["V"]
+ q = inputData[name]["Q"]
+ if inputData[name]["Froude"] > 1.0: # Torrential
+ z = inputData[name]["Z"]
+ self.set_z_on_border(desc, z)
+ #self.set_v_on_border(desc, v)
+ self.set_q_on_border(desc, q)
+
+ # Compute
+ # TODO: Use time values from coupling
+ ierr = self.t2d.api.run_timestep_t2d(self.t2d.id)
+ if ierr != 0:
+ raise Exception('Error in run_timestep_t2d:', ierr)
+
+ # Get the output values
+ outputData = {}
+ for (name, desc) in self.borders.iteritems():
+ outputData[name] = {}
+ (outputData[name]["Z"], idx) = self.get_z_on_border(desc)
+ if idx is None:
+ outputData[name]["V"] = 0.0
+ else:
+ (outputData[name]["V"], froude) = self.get_v_at_point(idx)
+ outputData[name]["Q"] = self.get_q_on_border(desc)
+ outputDataPickled = cPickle.dumps(outputData, -1)
+
+ self.endService("TELEMAC2D.ExecStep")
+ return outputDataPickled
+ except:
+ self._raiseSalomeError()
+
+ def get_z_on_border(self, border):
+ """
+ Find the water elevation (i.e. water height + bottom elevation) on a border.
+ Return a tuple (water_elevation, index_of_model_point_with_min_water_elevation).
+ If we use method 2 (compute mean water elevation), index is set to None.
+ """
+ # Method 1: Get point with minimum elevation
+ """
+ idx = -1
+ bor_idx = -1
+ z_min = sys.float_info.max
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ nbor_k = self.t2d.get_integer('MODEL.NBOR', k)
+ h_k = self.t2d.get_double('MODEL.WATERDEPTH', nbor_k)
+ z_bottom_k = self.t2d.get_double('MODEL.BOTTOMELEVATION', nbor_k)
+ z_k = h_k + z_bottom_k
+ logger.debug("extract z for border point %d, h:%f, zf:%f, z:%f" % (k, h_k, z_bottom_k, z_k))
+ if (z_k < z_min):
+ z_min = z_k
+ bor_idx = k
+ idx = nbor_k
+ k = self.t2d.get_integer('MODEL.KP1BOR', k)
+ logger.debug("min z for border %d with method 1 is %f at border point %d (model point %d)" %
+ (border["border_id"], z_min, bor_idx, idx))
+ z = z_min
+ """
+ # Method 2: Compute mean elevation, ignoring dry zones (method from PALM coupling)
+ z_mean = sys.float_info.max
+ for i in range(10):
+ h_tot = 0.0
+ l_tot = 0.0
+ zf_min = sys.float_info.max
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ knext = self.t2d.get_integer('MODEL.KP1BOR', k)
+ nbor_k = self.t2d.get_integer('MODEL.NBOR', k)
+ nbor_knext = self.t2d.get_integer('MODEL.NBOR', knext)
+ zf1 = self.t2d.get_double('MODEL.BOTTOMELEVATION', nbor_k)
+ zf2 = self.t2d.get_double('MODEL.BOTTOMELEVATION', nbor_knext)
+ zf_min = min(zf_min, zf1)
+ h1 = self.t2d.get_double('MODEL.WATERDEPTH', nbor_k)
+ h2 = self.t2d.get_double('MODEL.WATERDEPTH', nbor_knext)
+ z1 = h1 + zf1
+ z2 = h2 + zf2
+ x1 = self.t2d.get_double('MODEL.X', nbor_k)
+ x2 = self.t2d.get_double('MODEL.X', nbor_knext)
+ y1 = self.t2d.get_double('MODEL.Y', nbor_k)
+ y2 = self.t2d.get_double('MODEL.Y', nbor_knext)
+ l = math.sqrt((x1-x2)**2 + (y1-y2)**2)
+ if zf1 <= z_mean and zf2 <= z_mean:
+ h_tot += (z1+z2) * 0.5 * l
+ l_tot += l
+ k = knext
+
+ new_z_mean = h_tot / l_tot
+ delta = abs(z_mean - new_z_mean)
+ z_mean = new_z_mean
+ if delta < 1.0e-6:
+ break
+
+ logger.debug("mean z for border %d with method 2 is %f" % (border["border_id"], z_mean))
+ z = z_mean
+ idx = None
+
+ return (z, idx)
+
+ def get_v_at_point(self, idx):
+ """
+ Find the water velocity at the model point idx.
+ Return a tuple (velocity, froude number)
+ """
+ u_i = self.t2d.get_double('MODEL.VELOCITYU', idx)
+ v_i = self.t2d.get_double('MODEL.VELOCITYV', idx)
+ h_i = self.t2d.get_double('MODEL.WATERDEPTH', idx)
+ v = math.sqrt(u_i**2 + v_i**2)
+ ##### TODO: Remove that and find the real error
+ if h_i <= 0.0:
+ print 'Error: water depth is negative or zero on point', idx
+ #raise Exception('Null water depth value')
+ h_i = 0.01
+ froude = v / (h_i * 9.81)
+ return (v, froude)
+
+ def get_q_on_border(self, border):
+ """
+ Find the flow on a border.
+ The returned value is positive if the flow goes in the natural direction
+ according to the borders description (from upstream to downstream).
+ """
+ # Method 1: Integrate the flow on the whole border
+ """
+ q = 0.0
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ knext = self.t2d.get_integer('MODEL.KP1BOR', k)
+ nbor_k = self.t2d.get_integer('MODEL.NBOR', k)
+ nbor_knext = self.t2d.get_integer('MODEL.NBOR', knext)
+ h_i = self.t2d.get_double('MODEL.WATERDEPTH', nbor_k)
+ h_i2 = self.t2d.get_double('MODEL.WATERDEPTH', nbor_knext)
+ h2d1 = 0.5 * (h_i + h_i2)
+ if (h2d1 > 0.0):
+ u_i = self.t2d.get_double('MODEL.VELOCITYU', nbor_k)
+ u_i2 = self.t2d.get_double('MODEL.VELOCITYU', nbor_knext)
+ v_i = self.t2d.get_double('MODEL.VELOCITYV', nbor_k)
+ v_i2 = self.t2d.get_double('MODEL.VELOCITYV', nbor_knext)
+ v2d1 = 0.5 * (math.sqrt(u_i**2+v_i**2) + math.sqrt(u_i2**2+v_i2**2))
+ x2d1 = self.t2d.get_double('MODEL.X', nbor_k)
+ x2d2 = self.t2d.get_double('MODEL.X', nbor_knext)
+ y2d1 = self.t2d.get_double('MODEL.Y', nbor_k)
+ y2d2 = self.t2d.get_double('MODEL.Y', nbor_knext)
+ q += v2d1 * h2d1 * math.sqrt((x2d1-x2d2)**2 + (y2d1-y2d2)**2)
+ k = knext
+ logger.debug("flow for border %d with method 1 is %f" % (border["border_id"], q))
+
+ # Method 2: Get the flow from Telemac model
+ q = self.t2d.get_double('MODEL.FLUX_BOUNDARIES', border["border_id"])
+ if border["position"] == "downstream":
+ q = -q
+ logger.debug("flow for border %d with method 2 is %f" % (border["border_id"], q))
+ """
+
+ # Method 3: Method from PALM coupling
+ q = 0.0
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ knext = self.t2d.get_integer('MODEL.KP1BOR', k)
+ nbor_k = self.t2d.get_integer('MODEL.NBOR', k)
+ nbor_knext = self.t2d.get_integer('MODEL.NBOR', knext)
+ h_i = self.t2d.get_double('MODEL.WATERDEPTH', nbor_k)
+ h_i2 = self.t2d.get_double('MODEL.WATERDEPTH', nbor_knext)
+ u_i = self.t2d.get_double('MODEL.VELOCITYU', nbor_k)
+ u_i2 = self.t2d.get_double('MODEL.VELOCITYU', nbor_knext)
+ v_i = self.t2d.get_double('MODEL.VELOCITYV', nbor_k)
+ v_i2 = self.t2d.get_double('MODEL.VELOCITYV', nbor_knext)
+ x2d1 = self.t2d.get_double('MODEL.X', nbor_k)
+ x2d2 = self.t2d.get_double('MODEL.X', nbor_knext)
+ y2d1 = self.t2d.get_double('MODEL.Y', nbor_k)
+ y2d2 = self.t2d.get_double('MODEL.Y', nbor_knext)
+ NX=y2d1-y2d2
+ NY=x2d2-x2d1
+ UN1=u_i*NX+v_i*NY
+ UN2=u_i2*NX+v_i2*NY
+ q += ((h_i+h_i2)*(UN1+UN2)+h_i2*UN2+h_i*UN1)/6.0
+ k = knext
+ if border["position"] == "upstream":
+ q = -q
+ logger.debug("flow for border %d with method 3 is %f" % (border["border_id"], q))
+
+ return q
+
+ def set_z_on_border(self, border, z):
+ """
+ Set the water elevation (i.e. water height + bottom elevation) on a border.
+ If z is None, then the water elevation for this border is free (not imposed).
+ """
+ # Method 1: Impose water elevation point by point
+ """
+ # Deactivate water level imposition in bord.f (requires a patch in bord.f)
+ self.t2d.set_double('MODEL.COTE', -1.0, border["border_id"])
+
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ if z is None:
+ self.t2d.set_integer('MODEL.LIHBOR', 4, k) # Free elevation on that border
+ else:
+ self.t2d.set_integer('MODEL.LIHBOR', 5, k) # Imposed elevation on that border
+ nbor_k = self.t2d.get_integer('MODEL.NBOR', k)
+ bottom_elevation = self.t2d.get_double('MODEL.BOTTOMELEVATION', nbor_k)
+ hbor_k = max(0.0, z - bottom_elevation)
+ self.t2d.set_double('MODEL.HBOR', hbor_k, k)
+ logger.debug("set z for border point %d, h:%f, zf:%f, z:%f" % (k, hbor_k, bottom_elevation, z))
+ k = self.t2d.get_integer('MODEL.KP1BOR', k)
+ """
+
+ # Method 2: Just tell Telemac what is the imposed elevation for the border
+ if z is not None:
+ self.t2d.set_double('MODEL.COTE', z, border["border_id"])
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ if z is None:
+ self.t2d.set_integer('MODEL.LIHBOR', 4, k) # Free elevation on that border
+ else:
+ self.t2d.set_integer('MODEL.LIHBOR', 5, k) # Imposed elevation on that border
+ k = self.t2d.get_integer('MODEL.KP1BOR', k)
+
+ def set_v_on_border(self, border, v):
+ """
+ Set the water velocity on a border.
+ If v is None, then the water velocity for this border is free (not imposed).
+ """
+ # This method works only if the water level imposition is deactivated in bord.f
+ # (requires a patch in bord.f)
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ if v is None:
+ self.t2d.set_integer('MODEL.LIUBOR', 4, k) # Free velocity on that border
+ self.t2d.set_integer('MODEL.LIVBOR', 4, k)
+ else:
+ self.t2d.set_integer('MODEL.LIUBOR', 6, k) # Imposed velocity on that border
+ self.t2d.set_integer('MODEL.LIVBOR', 6, k)
+ xnebor_k = self.t2d.get_double('MODEL.XNEBOR', k)
+ ubor_k = -xnebor_k * v
+ ynebor_k = self.t2d.get_double('MODEL.YNEBOR', k)
+ vbor_k = -ynebor_k * v
+ self.t2d.set_double('MODEL.UBOR', ubor_k, k)
+ self.t2d.set_double('MODEL.VBOR', vbor_k, k)
+ k = self.t2d.get_integer('MODEL.KP1BOR', k)
+
+ def set_q_on_border(self, border, q):
+ """
+ Set the water flow on a border.
+ If q is None, then the water flow for this border is free (not imposed).
+ """
+ if q is not None:
+ self.t2d.set_double('MODEL.DEBIT', q, border["border_id"])
+ logger.debug("flow for border %d is set to %f" % (border["border_id"], q))
+ (first, after_last) = border["points_id"]
+ k = first
+ while k != after_last:
+ if q is None:
+ self.t2d.set_integer('MODEL.LIUBOR', 4, k) # Free velocity on that border
+ self.t2d.set_integer('MODEL.LIVBOR', 4, k)
+ else:
+ self.t2d.set_integer('MODEL.LIUBOR', 5, k) # Imposed discharge on that border
+ self.t2d.set_integer('MODEL.LIVBOR', 5, k)
+ k = self.t2d.get_integer('MODEL.KP1BOR', k)
+
+ def Finalize(self):
+ try:
+ self.beginService("TELEMAC2D.Finalize")
+ if self.t2d:
+ self.t2d.finalize()
+ self.t2d = None
+ self.endService("TELEMAC2D.Finalize")
+ except:
+ self._raiseSalomeError()
+
+ def Compute(self, studyId, caseEntry):
+ try:
+ self.beginService("TELEMAC2D.Compute")
+
+ jdc_dict = self.get_jdc_dict_from_case(studyId, caseEntry)
+ self.init_t2d_from_jdc_dict(jdc_dict)
+
+ # Compute
+ self.t2d.run_all_timesteps()
+
+ # Cleanup
+ self.t2d.finalize()
+
+ self.endService("TELEMAC2D.Compute")
+ except:
+ self._raiseSalomeError()
+
+
+class Telemac2DOutputVariable:
+
+ def __init__(self, varstr):
+ par1 = varstr.find("(")
+ par2 = varstr.find(")")
+ self.varname = varstr[:par1]
+ self.idx = int(varstr[par1+1:par2])
+
+ def get_value(self, inst):
+ return inst.get_double(self.varname, self.idx)
+
+
+class Telemac2DInputVariable:
+
+ def __init__(self, vardict):
+ self.varname = vardict["NOM_VARIABLE_MODELE"]
+ def_area_dict = vardict["ZONE_DE_DEFINITION"]
+ self.idx = def_area_dict.get("INDICE")
+ self.polygon = def_area_dict.get("POLYGONE")
+ self.points_in_polygon_list = None
+
+ def set_value(self, inst, value):
+ if self.idx is not None:
+ inst.set_double(self.varname, value, self.idx)
+ elif self.polygon is not None:
+ if self.points_in_polygon_list is None:
+ self.points_in_polygon_list = get_list_points_in_polygon(inst, self.polygon)
+ for idx in self.points_in_polygon_list:
+ inst.set_double(self.varname, value, idx)
+ else:
+ raise Exception("Invalid area definition for input variable {0}".format(self.varname))
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- Python files ---
+
+SET(PYFILES
+ HYDROSOLVERGUI.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON})
+
+# The file TextDisplayDialog.ui is not compiled here because it is not used anymore.
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import sys
+import os
+import traceback
+import logging
+
+from PyQt4 import QtCore, QtGui
+
+import salome
+import SALOME
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+from salome.kernel.studyedit import getStudyEditor
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("HYDROGUI", color = termcolor.BLUE)
+#logger.setLevel(logging.ERROR)
+
+import HYDROSOLVER_ORB
+from salome.hydro.gui_utils import HSGUIException, wait_cursor, get_and_check_selected_file_path
+import salome.hydro.study as hydro_study
+from salome.hydro.mascaret.eficas.appli import EficasForMascaretAppli
+from salome.hydro.telemac2d.eficas.appli import EficasForTelemac2DAppli
+from salome.hydro.coupling1d2d.eficas.appli import EficasForCoupling1D2DAppli
+import salome.hydro.pytel.gui as pytel_gui
+from salome.hydro.boundary_conditions.eficas.appli import EficasForBoundaryConditionsAppli
+
+################################################
+# GUI context class
+# Used to store actions, menus, toolbars, etc...
+################################################
+
+class GUIcontext:
+ # menus/toolbars/actions IDs
+ HYDRO_MENU_ID = 90
+ CREATE_MASCARET_CASE_ID = 941
+ RUN_MASCARET_ID = 942
+ EDIT_MASCARET_CASE_ID = 943
+ SHOW_LOG_ID = 944
+ CREATE_TELEMAC2D_CASE_ID = 945
+ RUN_TELEMAC2D_ID = 946
+ EDIT_TELEMAC2D_CASE_ID = 947
+ CREATE_COUPLING1D2D_CASE_ID = 948
+ EDIT_COUPLING1D2D_CASE_ID = 949
+ OPEN_SCHEMA_IN_YACS_ID = 950
+ CREATE_PYTEL_CASE_ID = 951
+ RUN_PYTEL_ID = 952
+ EDIT_PYTEL_CASE_ID = 953
+ GENERATE_JOB = 954
+ DEFINE_BOUNDARY_CONDITIONS_ID = 955
+
+ def __init__( self ):
+ # create top-level menu
+ mid = sgPyQt.createMenu( "Hydro", -1, GUIcontext.HYDRO_MENU_ID, sgPyQt.defaultMenuGroup() )
+ # create toolbar
+ tid = sgPyQt.createTool( "Hydro" )
+ # create actions and fill menu and toolbar with actions
+ a = sgPyQt.createAction( GUIcontext.DEFINE_BOUNDARY_CONDITIONS_ID,
+ "Define boundary conditions", "Define boundary conditions",
+ "Define the boundary conditions for Telemac",
+ "define_boundary_conditions.png" )
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ a = sgPyQt.createSeparator()
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ a = sgPyQt.createAction( GUIcontext.CREATE_MASCARET_CASE_ID,
+ "Create Mascaret case", "Create Mascaret case",
+ "Create a new Mascaret case", "create_case1d.png" )
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ a = sgPyQt.createAction( GUIcontext.CREATE_TELEMAC2D_CASE_ID,
+ "Create Telemac2D case", "Create Telemac2D case",
+ "Create a new Telemac2D case", "create_case2d.png" )
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ a = sgPyQt.createAction( GUIcontext.CREATE_COUPLING1D2D_CASE_ID,
+ "Create 1D / 2D coupling", "Create 1D / 2D coupling",
+ "Create a new 1D / 2D coupling", "create_case_couplage.png" )
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ a = sgPyQt.createSeparator()
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ a = sgPyQt.createAction( GUIcontext.CREATE_PYTEL_CASE_ID,
+ "Create case for Pytel execution", "Create case for Pytel execution",
+ "Create a new case for Pytel execution", "create_case_pytel.png" )
+ sgPyQt.createMenu( a, mid )
+ sgPyQt.createTool( a, tid )
+
+ # the following action are used in context popup
+ sgPyQt.createAction( GUIcontext.RUN_MASCARET_ID, "Compute case", "Compute case",
+ "Run Mascaret solver to compute the case" )
+ sgPyQt.createAction( GUIcontext.EDIT_MASCARET_CASE_ID, "Edit case", "Edit case",
+ "Edit the selected Mascaret case" )
+ sgPyQt.createAction( GUIcontext.SHOW_LOG_ID, "Show log", "Show log",
+ "Show the log for the selected variable" )
+
+ sgPyQt.createAction( GUIcontext.RUN_TELEMAC2D_ID, "Compute case", "Compute case",
+ "Run Telemac2D solver to compute the case" )
+ sgPyQt.createAction( GUIcontext.EDIT_TELEMAC2D_CASE_ID, "Edit case", "Edit case",
+ "Edit the selected Telemac2D case" )
+
+ sgPyQt.createAction( GUIcontext.EDIT_COUPLING1D2D_CASE_ID, "Edit coupling", "Edit coupling",
+ "Edit the selected 1D / 2D coupling" )
+ sgPyQt.createAction( GUIcontext.OPEN_SCHEMA_IN_YACS_ID, "Open schema in YACS", "Open schema in YACS",
+ "Open the selected 1D / 2D coupling schema in YACS" )
+
+ sgPyQt.createAction( GUIcontext.RUN_PYTEL_ID, "Compute case", "Compute case",
+ "Run Pytel launcher to compute the case" )
+ sgPyQt.createAction( GUIcontext.EDIT_PYTEL_CASE_ID, "Edit case", "Edit case",
+ "Edit the selected Pytel case" )
+ sgPyQt.createAction( GUIcontext.GENERATE_JOB, "Generate batch job", "Generate batch job",
+ "Generate a batch job to run the selected case")
+
+################################################
+# Global variables
+################################################
+
+# study-to-context map
+__study2context__ = {}
+# current context
+__current_context__ = None
+# object counter
+__objectid__ = 0
+
+################################################
+# Internal methods
+################################################
+
+###
+# get active study ID
+###
+def _getStudyId():
+ return sgPyQt.getStudyId()
+
+###
+# get active study
+###
+def _getStudy():
+ studyId = _getStudyId()
+ study = getStudyManager().GetStudyByID( studyId )
+ return study
+
+###
+# returns True if object has children
+###
+def _hasChildren( sobj ):
+ if sobj:
+ study = _getStudy()
+ iter = study.NewChildIterator( sobj )
+ while iter.More():
+ name = iter.Value().GetName()
+ if name:
+ return True
+ iter.Next()
+ pass
+ pass
+ return False
+
+###
+# get current GUI context
+###
+def _getContext():
+ global __current_context__
+ return __current_context__
+
+###
+# set and return current GUI context
+# study ID is passed as parameter
+###
+def _setContext( studyID ):
+ global __study2context__, __current_context__
+ if not __study2context__.has_key(studyID):
+ __study2context__[studyID] = GUIcontext()
+ pass
+ __current_context__ = __study2context__[studyID]
+ return __current_context__
+
+###
+# increment object counter in the map
+###
+def _incObjToMap( m, id ):
+ if id not in m: m[id] = 0
+ m[id] += 1
+ pass
+
+################################################
+# Callback functions
+################################################
+
+# called when module is activated
+# returns True if activating is successfull and False otherwise
+def activate():
+ ctx = _setContext( _getStudyId() )
+ return True
+
+# called when module is deactivated
+def deactivate():
+ pass
+
+# called when active study is changed
+# active study ID is passed as parameter
+def activeStudyChanged( studyID ):
+ ctx = _setContext( _getStudyId() )
+ pass
+
+# called when popup menu is invoked
+# popup menu and menu context are passed as parameters
+def createPopupMenu(popup, context):
+ ed = getStudyEditor()
+ _setContext(ed.studyId)
+ if salome.sg.SelectedCount() == 1:
+ # one object is selected
+ sobj = ed.study.FindObjectID(salome.sg.getSelected(0))
+ selectedType = ed.getTypeId(sobj)
+ if selectedType == hydro_study.MASCARET_CASE_TYPE_ID:
+ popup.addAction(sgPyQt.action(GUIcontext.EDIT_MASCARET_CASE_ID))
+ popup.addAction(sgPyQt.action(GUIcontext.RUN_MASCARET_ID))
+ elif selectedType == hydro_study.TELEMAC2D_CASE_TYPE_ID:
+ popup.addAction(sgPyQt.action(GUIcontext.EDIT_TELEMAC2D_CASE_ID))
+ popup.addAction(sgPyQt.action(GUIcontext.RUN_TELEMAC2D_ID))
+ elif selectedType == hydro_study.COUPLING1D2D_CASE_TYPE_ID:
+ popup.addAction(sgPyQt.action(GUIcontext.EDIT_COUPLING1D2D_CASE_ID))
+ popup.addAction(sgPyQt.action(GUIcontext.OPEN_SCHEMA_IN_YACS_ID))
+ elif selectedType == hydro_study.LOG_TYPE_ID:
+ popup.addAction(sgPyQt.action(GUIcontext.SHOW_LOG_ID))
+ elif selectedType == hydro_study.PYTEL_CASE_TYPE_ID:
+ popup.addAction(sgPyQt.action(GUIcontext.EDIT_PYTEL_CASE_ID))
+ popup.addAction(sgPyQt.action(GUIcontext.RUN_PYTEL_ID))
+ popup.addAction(sgPyQt.action(GUIcontext.GENERATE_JOB))
+
+# called when GUI action is activated
+# action ID is passed as parameter
+def OnGUIEvent( commandID ):
+ try:
+ dict_command[commandID]()
+ except HSGUIException, exc:
+ QtGui.QMessageBox.critical(sgPyQt.getDesktop(),
+ QtGui.QApplication.translate("OnGUIEvent", "Error"),
+ unicode(exc))
+ except:
+ logger.exception("Unhandled exception caught in HYDROSOLVER GUI")
+ msg = QtGui.QApplication.translate("OnGUIEvent",
+ "Unhandled error happened in HYDROSOLVER module. Please report a bug on "
+ '<a href="https://forge-pleiade.der.edf.fr/projects/salome-rex/issues">SALOME bugtracker</a>, '
+ 'category "HYDROSOLVER", describing how you got there and including the following traceback:')
+ msgBox = QtGui.QMessageBox(QtGui.QMessageBox.Critical,
+ QtGui.QApplication.translate("OnGUIEvent", "Error"),
+ msg,
+ parent = sgPyQt.getDesktop())
+ msgBox.setDetailedText(traceback.format_exc())
+ msgBox.exec_()
+
+################################################
+# GUI actions implementation
+################################################
+
+# --------------------------------------------------------------------------------------- #
+# Dialog box for text display (deprecated, it was only used in the calcium coupling test) #
+# --------------------------------------------------------------------------------------- #
+"""
+from TextDisplayDialog import Ui_TextDisplayDialog
+
+class MyTextDisplayDialog(Ui_TextDisplayDialog, QtGui.QDialog):
+
+ def __init__(self, parent = None, modal = 0):
+ QtGui.QDialog.__init__(self, parent)
+ Ui_TextDisplayDialog.__init__(self)
+ self.setupUi(self)
+ self.connect(self.closeButton, QtCore.SIGNAL("clicked()"), self.close)
+
+ def set_log(self, log):
+ self.contentTextEdit.setPlainText(log)
+ self.setWindowTitle("Coupling log")
+"""
+
+###
+# Open Eficas for Mascaret to create a new case
+###
+def create_mascaret_case():
+ EficasForMascaretAppli()
+
+###
+# Open Eficas for Mascaret to edit the selected case
+###
+def edit_mascaret_case():
+ EficasForMascaretAppli(get_and_check_selected_file_path())
+
+# Run Mascaret on selected case
+def run_mascaret():
+ try:
+ with wait_cursor:
+ ed = hydro_study.HydroStudyEditor()
+ sobj = ed.editor.study.FindObjectID(salome.sg.getSelected(0))
+ (file_list, lig_file, input_vars, output_vars) = ed.get_mascaret_params_from_case(sobj)
+ var_names = [var["NOM"].strip() for var in output_vars]
+ mascaret_vars = [var["VARIABLE_MASCARET"].strip() for var in output_vars]
+ engine = salome.lcc.FindOrLoadComponent("FactoryServer", "MASCARET")
+ logger.debug("Calling MASCARET.Compute(%s, %s, %s)" %
+ (file_list, lig_file, mascaret_vars))
+ output_values = engine.Compute(file_list, lig_file, mascaret_vars)
+ ed.add_results_to_mascaret_case(sobj, var_names, output_values)
+ salome.sg.updateObjBrowser( 0 )
+ except SALOME.SALOME_Exception, exc:
+ salome.sg.updateObjBrowser( 0 )
+ msg = unicode(QtGui.QApplication.translate("run_mascaret",
+ "An error happened while trying to run Mascaret:"))
+ msg += "\n" + exc.details.text
+ raise HSGUIException(msg)
+
+# Display selected log (deprecated, it was only used in the calcium coupling test)
+def show_log():
+ ed = hydro_study.HydroStudyEditor()
+ sobj = ed.editor.study.FindObjectID(salome.sg.getSelected(0))
+ if sobj is not None:
+ (found, attr) = getStudyEditor().builder.FindAttribute(
+ sobj, "AttributeParameter")
+ log = attr.GetString("log")
+ dialog = MyTextDisplayDialog(sgPyQt.getDesktop())
+ dialog.set_log(log)
+ dialog.show()
+
+###
+# Open Eficas for Telemac2D to create a new case
+###
+def create_telemac2d_case():
+ EficasForTelemac2DAppli()
+
+###
+# Open Eficas for Telemac2D to edit the selected case
+###
+def edit_telemac2d_case():
+ EficasForTelemac2DAppli(get_and_check_selected_file_path())
+
+# Run Telemac2D on selected case
+def run_telemac2d():
+ engine = None
+ try:
+ with wait_cursor:
+ ed = hydro_study.HydroStudyEditor()
+ entry = salome.sg.getSelected(0)
+ engine = salome.lcc.FindOrLoadComponent("Telemac2DContainer", "TELEMAC2D")
+ engine.Compute(ed.editor.studyId, entry)
+ # Stop container after execution so that we can use another fortran user file in the next run
+ engine.GetContainerRef().Shutdown()
+ except SALOME.SALOME_Exception, exc:
+ if engine is not None:
+ engine.GetContainerRef().Shutdown()
+ msg = unicode(QtGui.QApplication.translate("run_telemac2d",
+ "An error happened while trying to run Telemac2D:"))
+ msg += "\n" + exc.details.text
+ raise HSGUIException(msg)
+ except Exception, exc:
+ logger.exception("An error happened in the computation (Telemac2D probably crashed).")
+ try:
+ engine.GetContainerRef().Shutdown()
+ except:
+ pass
+ msg = unicode(QtGui.QApplication.translate("run_telemac2d",
+ "An error happened in the computation (Telemac2D probably crashed, "
+ "see logs and listing files for more details):"))
+ msg += "\n" + unicode(exc)
+ raise HSGUIException(msg)
+
+###
+# Open Eficas for 1D / 2D Coupling to create a new coupling case
+###
+def create_coupling1d2d_case():
+ EficasForCoupling1D2DAppli()
+
+###
+# Open Eficas for 1D / 2D Coupling to edit the selected coupling case
+###
+def edit_coupling1d2d_case():
+ EficasForCoupling1D2DAppli(get_and_check_selected_file_path())
+
+def open_schema_in_yacs():
+ ed = getStudyEditor()
+ sobj = ed.study.FindObjectID(salome.sg.getSelected(0))
+ filename = sobj.GetComment()
+ if filename.endswith(".comm"):
+ filename = filename[:-5] + ".xml"
+ if not os.path.isfile(filename):
+ raise HSGUIException(QtGui.QApplication.translate("open_schema_in_yacs",
+ "Schema file %1 does not exist").arg(filename))
+ yg = salome.ImportComponentGUI("YACS")
+ yg.loadSchema(filename)
+
+###
+# Open Eficas for boundary conditions definition
+###
+def define_boundary_conditions():
+ EficasForBoundaryConditionsAppli()
+
+###
+# Commands dictionary
+###
+dict_command = {
+ GUIcontext.CREATE_MASCARET_CASE_ID: create_mascaret_case,
+ GUIcontext.RUN_MASCARET_ID: run_mascaret,
+ GUIcontext.EDIT_MASCARET_CASE_ID: edit_mascaret_case,
+ GUIcontext.SHOW_LOG_ID: show_log,
+ GUIcontext.CREATE_TELEMAC2D_CASE_ID: create_telemac2d_case,
+ GUIcontext.RUN_TELEMAC2D_ID: run_telemac2d,
+ GUIcontext.EDIT_TELEMAC2D_CASE_ID: edit_telemac2d_case,
+ GUIcontext.CREATE_COUPLING1D2D_CASE_ID: create_coupling1d2d_case,
+ GUIcontext.EDIT_COUPLING1D2D_CASE_ID: edit_coupling1d2d_case,
+ GUIcontext.OPEN_SCHEMA_IN_YACS_ID: open_schema_in_yacs,
+ GUIcontext.CREATE_PYTEL_CASE_ID: pytel_gui.create_case,
+ GUIcontext.RUN_PYTEL_ID: pytel_gui.run_selected_case,
+ GUIcontext.EDIT_PYTEL_CASE_ID: pytel_gui.edit_selected_case,
+ GUIcontext.GENERATE_JOB: pytel_gui.generate_job_for_selected_case,
+ GUIcontext.DEFINE_BOUNDARY_CONDITIONS_ID: define_boundary_conditions,
+ }
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>TextDisplayDialog</class>
+ <widget class="QDialog" name="TextDisplayDialog">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>780</width>
+ <height>560</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>Text Display</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="QPlainTextEdit" name="contentTextEdit">
+ <property name="lineWrapMode">
+ <enum>QPlainTextEdit::NoWrap</enum>
+ </property>
+ <property name="readOnly">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <spacer name="horizontalSpacer">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="closeButton">
+ <property name="text">
+ <string>Close</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+INCLUDE(${SWIG_USE_FILE})
+
+# --- options ---
+
+# additional include directories
+INCLUDE_DIRECTORIES(
+ ${PYTHON_INCLUDE_DIRS}
+ ${MASCARET_INCLUDE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# swig flags
+SET_SOURCE_FILES_PROPERTIES(mascaret_swig.i PROPERTIES
+ CPLUSPLUS ON
+ SWIG_DEFINITIONS "-shadow")
+
+# additional preprocessor / compiler flags
+ADD_DEFINITIONS(
+ ${PYTHON_DEFINITIONS}
+ )
+
+# libraries to link to
+SET(_link_LIBRARIES
+ ${PYTHON_LIBRARIES}
+ ${MASCARET_LIBRARIES}
+ )
+
+# --- sources ---
+SET(mascaret_SOURCES
+ Mascaret.cxx
+ )
+# --- headers ---
+SET(mascaret_HEADERS
+ Mascaret.hxx
+ )
+
+# --- scripts ---
+# scripts / swig wrappings
+SET(_swig_SCRIPTS
+ ${CMAKE_CURRENT_BINARY_DIR}/mascaret_swig.py
+)
+
+# --- rules ---
+SWIG_ADD_MODULE(mascaret_swig python mascaret_swig.i ${mascaret_SOURCES})
+SWIG_LINK_LIBRARIES(mascaret_swig "${_link_LIBRARIES}")
+
+SET(mypkgpythondir ${SALOME_INSTALL_PYTHON}/salome/hydro/mascaret)
+
+INSTALL(TARGETS ${SWIG_MODULE_mascaret_swig_REAL_NAME} DESTINATION ${mypkgpythondir})
+SALOME_INSTALL_SCRIPTS("${_swig_SCRIPTS}" ${mypkgpythondir})
--- /dev/null
+// Copyright (C) 2012-2013 EDF
+//
+// This file is part of SALOME HYDRO module.
+//
+// SALOME HYDRO module is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// SALOME HYDRO module 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+#include <cstdlib>
+#include <cstring>
+#include <map>
+#include <sstream>
+
+extern "C"
+{
+#include <apimascaret.h>
+}
+
+#include "Mascaret.hxx"
+
+using namespace std;
+
+namespace SalomeHydro
+{
+
+char * createPChar(const string & str)
+{
+ char * data = new char[str.size() + 1];
+ strcpy(data, str.c_str());
+ return data;
+}
+
+
+class CString
+{
+public:
+
+ CString(const string & str)
+ {
+ _data = createPChar(str);
+ }
+
+ virtual ~CString()
+ {
+ delete[] _data;
+ }
+
+ operator char *()
+ {
+ return _data;
+ }
+
+private:
+ char * _data;
+};
+
+
+MascaretException::MascaretException(const std::string & msg)
+ : runtime_error(msg)
+{
+}
+
+MascaretException::~MascaretException() throw()
+{
+}
+
+const char * MascaretException::__str__() const
+{
+ return what();
+}
+
+Mascaret::Mascaret()
+ : _id(-1),
+ _printing(false)
+{
+ // Initialize model
+ int res = C_CREATE_MASCARET(&_id);
+ testMascaretResult(res, "C_CREATE_MASCARET");
+}
+
+
+Mascaret::~Mascaret()
+{
+ // Delete the model
+ int res = C_DELETE_MASCARET(_id);
+ testMascaretResult(res, "C_DELETE_MASCARET");
+}
+
+
+void Mascaret::testMascaretResult(int res, const string & functionName)
+{
+ if (res != 0)
+ {
+ char * mascErrorMsg;
+ C_GET_ERREUR_MASCARET(_id, &mascErrorMsg);
+ ostringstream msg;
+ msg << "Mascaret error:" << endl;
+ msg << " Function: " << functionName << endl;
+ msg << " Message: " << mascErrorMsg;
+ free(mascErrorMsg);
+ throw MascaretException(msg.str());
+ }
+}
+
+
+bool Mascaret::isPrinting()
+{
+ return _printing;
+}
+
+
+void Mascaret::setPrinting(bool printing)
+{
+ _printing = printing;
+}
+
+
+void Mascaret::importModel(const MascaretFileList & fileList)
+{
+ // Create arrays of C strings fileArray and typeArray
+ char** fileArray = new char*[fileList.size()];
+ char** typeArray = new char*[fileList.size()];
+ for (int i=0 ; i<fileList.size() ; i++)
+ {
+ fileArray[i] = createPChar(fileList[i].fileName);
+ typeArray[i] = createPChar(fileList[i].fileType);
+ }
+
+ // Import model
+ int res = C_IMPORT_MODELE_MASCARET(_id, fileArray, typeArray, fileList.size(), _printing);
+ testMascaretResult(res, "C_IMPORT_MODELE_MASCARET");
+
+ // Free arrays of C strings
+ for (int i=0 ; i<fileList.size() ; i++)
+ {
+ delete[] fileArray[i];
+ delete[] typeArray[i];
+ }
+ delete[] fileArray;
+ delete[] typeArray;
+}
+
+
+void Mascaret::initState(const string & ligFileName)
+{
+ int res = C_INIT_ETAT_MASCARET(_id, CString(ligFileName), _printing);
+ testMascaretResult(res, "C_INIT_ETAT_MASCARET");
+}
+
+
+void Mascaret::compute(double startTime, double endTime, double timeStep)
+{
+ int res = C_CALCUL_MASCARET(_id, startTime, endTime, timeStep, _printing);
+ testMascaretResult(res, "C_CALCUL_MASCARET");
+}
+
+
+void Mascaret::compute()
+{
+ // Read startTime, endTime and timeStep from model
+ double startTime = getDouble("Modele.TempsInitial", 0, 0, 0);
+ double endTime = getDouble("Modele.TempsMaximum", 0, 0, 0);
+ double timeStep = getDouble("Modele.DT", 0, 0, 0);
+
+ // Calculation
+ compute(startTime, endTime, timeStep);
+}
+
+
+int Mascaret::getInt(const string & varName, int index1, int index2, int index3)
+{
+ int retVal;
+ int res = C_GET_INT_MASCARET(_id, CString(varName), index1, index2, index3, &retVal);
+ testMascaretResult(res, "C_GET_INT_MASCARET");
+ return retVal;
+}
+
+
+double Mascaret::getDouble(const string & varName, int index1, int index2, int index3)
+{
+ double retVal;
+ int res = C_GET_DOUBLE_MASCARET(_id, CString(varName), index1, index2, index3, &retVal);
+ testMascaretResult(res, "C_GET_DOUBLE_MASCARET");
+ return retVal;
+}
+
+
+void Mascaret::setInt(const std::string & varName, int index1, int index2, int index3, int value)
+{
+ int res = C_SET_INT_MASCARET(_id, CString(varName), index1, index2, index3, value);
+ testMascaretResult(res, "C_SET_INT_MASCARET");
+}
+
+
+void Mascaret::setDouble(const std::string & varName, int index1, int index2, int index3, double value)
+{
+ int res = C_SET_DOUBLE_MASCARET(_id, CString(varName), index1, index2, index3, value);
+ testMascaretResult(res, "C_SET_DOUBLE_MASCARET");
+}
+
+int Mascaret::saveState()
+{
+ int stateId;
+ int res = C_SAVE_ETAT_MASCARET(_id, &stateId);
+ testMascaretResult(res, "C_SAVE_ETAT_MASCARET");
+ return stateId;
+ return 0;
+}
+
+void Mascaret::restoreState(int stateId)
+{
+ int res = C_SET_ETAT_MASCARET(_id, stateId);
+ testMascaretResult(res, "C_SET_ETAT_MASCARET");
+}
+
+}
--- /dev/null
+// Copyright (C) 2012-2013 EDF
+//
+// This file is part of SALOME HYDRO module.
+//
+// SALOME HYDRO module is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// SALOME HYDRO module 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef MASCARET_HXX_
+#define MASCARET_HXX_
+
+#include <stdexcept>
+#include <vector>
+
+namespace SalomeHydro
+{
+
+typedef struct MascaretFile
+{
+ std::string fileName;
+ std::string fileType;
+} MascaretFile;
+
+typedef std::vector<MascaretFile> MascaretFileList;
+
+class MascaretException: public std::runtime_error
+{
+public:
+
+ MascaretException(const std::string & msg);
+ virtual ~MascaretException() throw();
+
+ const char * __str__() const;
+
+};
+
+class Mascaret
+{
+public:
+
+ // Constructor and destructor
+ Mascaret();
+ virtual ~Mascaret();
+
+ // Get and set printing flag
+ bool isPrinting();
+ void setPrinting(bool printing);
+
+ // Model initialization
+ void importModel(const MascaretFileList & fileList);
+ void initState(const std::string & ligFileName);
+
+ // Save / restore state
+ int saveState();
+ void restoreState(int stateId);
+
+ // Computation
+ void compute(double startTime, double endTime, double timeStep);
+ void compute();
+
+ // Model and state edition
+ int getInt(const std::string & varName, int index1, int index2, int index3);
+ double getDouble(const std::string & varName, int index1, int index2, int index3);
+ void setInt(const std::string & varName, int index1, int index2, int index3, int value);
+ void setDouble(const std::string & varName, int index1, int index2, int index3, double value);
+
+protected:
+
+ void testMascaretResult(int res, const std::string & functionName);
+
+ int _id;
+ bool _printing;
+
+};
+
+}
+
+#endif /* MASCARET_HXX_ */
--- /dev/null
+// Copyright (C) 2012-2013 EDF
+//
+// This file is part of SALOME HYDRO module.
+//
+// SALOME HYDRO module is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// SALOME HYDRO module 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+%module mascaret_swig
+
+%include std_string.i
+
+%include std_vector.i
+
+%{
+#include "Mascaret.hxx"
+%}
+
+// Instantiate template used by Mascaret
+%template(MascaretFileVector) std::vector<SalomeHydro::MascaretFile>;
+
+// Exception handling
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::Mascaret();
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::~Mascaret();
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::importModel(const MascaretFileList & fileList);
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::initState(const std::string & ligFileName);
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::compute(double startTime, double endTime, double timeStep);
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::compute();
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::getInt(const std::string & varName, int index1, int index2, int index3);
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::getDouble(const std::string & varName, int index1, int index2, int index3);
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::setInt(const std::string & varName, int index1, int index2, int index3, int value);
+%catches(SalomeHydro::MascaretException, ...) SalomeHydro::Mascaret::setDouble(const std::string & varName, int index1, int index2, int index3, double value);
+
+%include "Mascaret.hxx"
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(mascaret)
+ADD_SUBDIRECTORY(telemac2d)
+ADD_SUBDIRECTORY(pytel)
+ADD_SUBDIRECTORY(coupling1d2d)
+ADD_SUBDIRECTORY(boundary_conditions)
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ study.py
+ gui_utils.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(eficas)
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/boundary_conditions)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ configuration_boundary_conditions.py
+ prefs_boundary_conditions.py
+ prefs.py
+ boundary_conditions_cata.py
+ appli.py
+ generator_boundary_conditions.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/boundary_conditions/eficas)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+
+import eficasSalome
+
+class EficasForBoundaryConditionsAppli(eficasSalome.MyEficas):
+ """
+ This class launches Eficas with "boundary_conditions" catalog.
+ """
+ def __init__(self, fichier = None, version = None):
+ self.codedir = os.path.dirname(__file__)
+ sys.path[:0] = [self.codedir]
+ eficasSalome.MyEficas.__init__(self, sgPyQt.getDesktop(), "boundary_conditions",
+ fichier, version = version)
+
+ def addJdcInSalome(self, jdcPath):
+ """
+ Those files are not added in Salome study tree for now.
+ """
+ pass
+
+ def closeEvent(self, event):
+ while self.codedir in sys.path:
+ sys.path.remove(self.codedir)
+ eficasSalome.MyEficas.closeEvent(self, event)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+from Accas import *
+
+class grma(GEOM):
+ """
+ Class used to define the group on which the boundary condition is defined.
+ Method __convert__ is redefined to skip the test on the string length.
+ """
+ def __convert__(cls, valeur):
+ if isinstance(valeur, (str, unicode)):
+ return valeur.strip()
+ raise ValueError(_('A string is expected'))
+
+ __convert__ = classmethod(__convert__)
+
+
+JdC = JDC_CATA(regles = (AU_MOINS_UN('BOUNDARY_CONDITION',)),
+ )
+
+BOUNDARY_CONDITION = PROC(
+ nom = "BOUNDARY_CONDITION", op = None,
+ fr = u"Définition d'une condition limite pour Telemac2D",
+ ang = u"Definition of a boundary condition for Telemac2D",
+
+ GROUP = SIMP(statut = "o", typ = grma,
+ fr = u"Groupe sur lequel la condition limite est définie",
+ ang = u"Group on which the boundary condition is defined",
+ ),
+ LIHBOR = SIMP(statut = "o", typ = "I",
+ fr = u"Type de condition limite pour la hauteur d'eau",
+ ang = u"Boundary condition type for the water height",
+ ),
+ LIUBOR = SIMP(statut = "o", typ = "I",
+ fr = u"Type de condition limite pour la composante U de la vitesse",
+ ang = u"Boundary condition type for the U component of the water velocity",
+ ),
+ LIVBOR = SIMP(statut = "o", typ = "I",
+ fr = u"Type de condition limite pour la composante V de la vitesse",
+ ang = u"Boundary condition type for the V component of the water velocity",
+ ),
+)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+
+from Editeur.catadesc import CatalogDescription
+from InterfaceQT4.configuration import CONFIG_BASE
+
+class CONFIG(CONFIG_BASE):
+
+ def __init__(self, appli, repIni):
+ """
+ This class stores the configuration parameters for Eficas
+ """
+ CONFIG_BASE.__init__(self, appli, repIni)
+
+ # Configuration parameters
+ self.savedir = os.getenv("HOME")
+ self.catalogues = (CatalogDescription("boundary_conditions",
+ os.path.join(repIni, "boundary_conditions_cata.py"),
+ file_format = "boundary_conditions"),)
+ self.lang = 'fr'
+ self.generator_module = "generator_boundary_conditions"
+
+ def save_params(self):
+ pass
+
+def make_config(appli, rep):
+ return CONFIG(appli, rep)
+
+def make_config_style(appli, rep):
+ return None
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+from generator.generator_python import PythonGenerator
+
+def entryPoint():
+ return {'name': 'boundary_conditions',
+ 'factory': BoundaryConditionsGenerator}
+
+class BoundaryConditionsGenerator(PythonGenerator):
+ """
+ This generator creates files containing associations between groups and
+ boundary conditions (.bcd files, for Boundary Conditions Definition).
+ Those files contain one line per group, each line containing four fields
+ separated by spaces: LIHBOR LIUBOR LIVBOR GROUP.
+ LIHBOR, LIUBOR and LIVBOR are integer values, GROUP is a string (the name of
+ the group).
+
+ Example:
+
+
+ """
+
+ def gener(self, obj, format = 'brut', config = None):
+ self.group_list = []
+ self.text = PythonGenerator.gener(self, obj, format)
+ return self.text
+
+ def generPROC_ETAPE(self, obj):
+ group_dict = {}
+ for keyword in obj.mc_liste:
+ group_dict[keyword.nom] = keyword.valeur
+ self.group_list.append(group_dict)
+ return PythonGenerator.generPROC_ETAPE(self, obj)
+
+ def writeDefault(self, basefilename):
+ output_filename = os.path.splitext(basefilename)[0] + ".bcd"
+ f = open(output_filename, 'w')
+ f.write("%d\n" % len(self.group_list))
+ for group_dict in self.group_list:
+ f.write("%(LIHBOR)d %(LIUBOR)d %(LIVBOR)d %(GROUP)s\n" % group_dict)
+ f.close()
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+code = "boundary_conditions"
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+
+repIni = os.path.dirname(__file__)
+INSTALLDIR = os.getenv("EFICAS_ROOT")
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(eficas)
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/coupling1d2d)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ configuration_coupling1d2d.py
+ prefs_coupling1d2d.py
+ prefs.py
+ coupling1d2d_cata.py
+ appli.py
+ generator_coupling1d2d.py
+)
+
+# --- Data files ---
+
+SET(DATAFILES
+ coupling1d2d_template_schema.xml
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/coupling1d2d/eficas)
+INSTALL(FILES ${DATAFILES} DESTINATION ${SALOME_INSTALL_PYTHON}/salome/hydro/coupling1d2d/eficas)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+import re
+
+from PyQt4.QtGui import QMessageBox
+
+import salome
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("salome.hydro.coupling1d2d.eficas.appli",
+ color = termcolor.GREEN_FG)
+
+import eficasSalome
+
+from salome.hydro.study import HydroStudyEditor
+
+class SalomeEntry:
+
+ enable_salome_selection = True
+ help_message = u"Une entrée de l'arbre d'étude de Salome est attendue"
+
+ def __init__(self, entryStr):
+ self._entry = entryStr
+
+ @staticmethod
+ def __convert__(entryStr):
+ return SalomeEntry(entryStr)
+
+ @staticmethod
+ def get_selected_value(selected_entry, study_editor):
+ sobj = study_editor.study.FindObjectID(selected_entry)
+ name = sobj.GetName()
+ return "%s (%s)" % (name, selected_entry)
+
+class EficasForCoupling1D2DAppli(eficasSalome.MyEficas):
+ """
+ This class launches Eficas and adds entries for the created files in
+ HYDRO component in the study tree. The messages in this class are in
+ french because they are displayed in Eficas interface.
+
+ :type fichier: string
+ :param fichier: path of an Eficas file to open
+
+ """
+ def __init__(self, fichier = None, version = None):
+ self.ed = HydroStudyEditor()
+ self.codedir = os.path.dirname(__file__)
+ sys.path[:0] = [self.codedir]
+ eficasSalome.MyEficas.__init__(self, sgPyQt.getDesktop(), "coupling1d2d",
+ fichier, version = version)
+ sgPyQt.createView("Eficas Coupling 1D/2D", self)
+
+ def selectGroupFromSalome(self, kwType = None, editor=None):
+ """
+ Select an entry from Salome object browser
+ """
+ nbEntries = salome.sg.SelectedCount()
+ if nbEntries < 1:
+ msg = u"Veuillez sélectionner une entrée de l'arbre d'étude de Salome"
+ QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), self.tr(msg))
+ return [], msg
+ elif nbEntries > 1:
+ msg = u"Une seule entrée doit être sélectionnée dans l'arbre d'étude de Salome"
+ QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), self.tr(msg))
+ return [], msg
+ else:
+ try:
+ value = kwType.get_selected_value(salome.sg.getSelected(0), self.ed.editor)
+ msg = u"L'entrée de l'arbre d'étude de Salome a été sélectionnée"
+ return [value], msg
+ except Exception, e:
+ QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), self.tr(unicode(e)))
+ return [], unicode(e)
+
+ def addJdcInSalome(self, jdcPath):
+ """
+ Add the newly created file in Salome study
+ """
+ try:
+ self.ed.find_or_create_coupling1d2d_case(jdcPath)
+ except Exception, exc:
+ msgError = "Can't add file to Salome study tree"
+ logger.exception(msgError)
+ QMessageBox.warning(self, self.tr("Warning"),
+ self.tr("%s. Reason:\n%s\n\nSee logs for more details." % (msgError, exc)))
+ salome.sg.updateObjBrowser(0)
+
+ def closeEvent(self, event):
+ while self.codedir in sys.path:
+ sys.path.remove(self.codedir)
+ eficasSalome.MyEficas.closeEvent(self, event)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+
+from Editeur.catadesc import CatalogDescription
+from InterfaceQT4.configuration import CONFIG_BASE
+
+class CONFIG(CONFIG_BASE):
+
+ def __init__(self, appli, repIni):
+ """
+ This class stores the configuration parameters for Eficas
+ """
+ CONFIG_BASE.__init__(self, appli, repIni)
+
+ # Configuration parameters
+ self.savedir = os.getenv("HOME")
+ self.catalogues = (CatalogDescription("coupling1d2d",
+ os.path.join(repIni, "coupling1d2d_cata.py"),
+ file_format = "coupling1d2d"),)
+ self.lang = 'fr'
+
+ self.generator_module = "generator_coupling1d2d"
+
+ def save_params(self):
+ pass
+
+ def get_template_file(self):
+ return os.path.join(self.repIni, "coupling1d2d_template_schema.xml")
+
+ def get_extension(self):
+ return ".xml"
+
+def make_config(appli, rep):
+ return CONFIG(appli, rep)
+
+def make_config_style(appli, rep):
+ return None
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+from salome.hydro.coupling1d2d.eficas.appli import SalomeEntry
+from Accas import *
+
+JdC = JDC_CATA(regles = (UN_PARMI('COUPLAGE1D2D',)),
+ )
+
+COUPLAGE1D2D = PROC(
+ nom = "COUPLAGE1D2D", op = None,
+ fr = u"Définition d'un couplage Mascaret / Telemac2D",
+ ang = u"Definition of a Mascaret / Telemac2D coupling",
+ CAS_MASCARET = SIMP(statut = "o", typ = SalomeEntry,
+ fr = u"Entrée Salome contenant le cas d'étude Mascaret",
+ ang = u"Salome entry containing Mascaret study case"),
+ CAS_TELEMAC2D = SIMP(statut = "o", typ = SalomeEntry,
+ fr = u"Entrée Salome contenant le cas d'étude Telemac2D",
+ ang = u"Salome entry containing Telemac2D study case"),
+ FICHIER_COUPLAGE = SIMP(statut = "o", typ = ('Fichier', 'Fichiers Python (*.py);;Tous les fichiers (*)',),
+ fr = u"Fichier de description du couplage",
+ ang = u"Coupling description file"),
+ FICHIER_LOG = SIMP(statut = "o", typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = "Fichier de log",
+ ang = u"Log file"),
+ FICHIER_GRAPHIQUE = SIMP(statut = "o",
+ typ = ('Fichier', 'Fichiers CSV (*.csv);;Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de données pour la génération du graphique",
+ ang = u"Data file for the graphics generation"),
+)
--- /dev/null
+<?xml version='1.0' encoding='iso-8859-1' ?>
+<proc name="newSchema_1">
+ <property name="DefaultStudyID" value="1"/>
+ <type name="string" kind="string"/>
+ <struct name="Engines/dataref">
+ <member name="ref" type="string"/>
+ </struct>
+ <type name="bool" kind="bool"/>
+ <sequence name="boolvec" content="bool"/>
+ <type name="double" kind="double"/>
+ <sequence name="dblevec" content="double"/>
+ <objref name="file" id="file"/>
+ <type name="int" kind="int"/>
+ <sequence name="intvec" content="int"/>
+ <struct name="stringpair">
+ <member name="name" type="string"/>
+ <member name="value" type="string"/>
+ </struct>
+ <sequence name="propvec" content="stringpair"/>
+ <objref name="pyobj" id="python:obj:1.0"/>
+ <sequence name="seqboolvec" content="boolvec"/>
+ <sequence name="seqdblevec" content="dblevec"/>
+ <sequence name="seqintvec" content="intvec"/>
+ <sequence name="stringvec" content="string"/>
+ <sequence name="seqstringvec" content="stringvec"/>
+ <container name="DefaultContainer">
+ <property name="container_name" value="FactoryServer"/>
+ <property name="name" value="localhost"/>
+ </container>
+ <container name="mascaret_container">
+ <property name="container_name" value=""/>
+ <property name="name" value="localhost"/>
+ </container>
+ <container name="telemac_container">
+ <property name="name" value="localhost"/>
+ </container>
+ <while name="TimeLoop">
+ <bloc name="TimeBloc">
+ <inline name="TimeController">
+ <script><code><![CDATA[time += timestep
+cont = (time + timestep/2 < endtime) # Add half timestep to avoid rounding issues
+timeData = {}
+timeData["start_time"] = time
+timeData["end_time"] = time + timestep
+timeData["time_step"] = timestep
+
+if cont:
+ log.write("time: %f\n" % timeData["end_time"])
+else:
+ log.close()
+ graph.close()
+]]></code></script>
+ <inport name="time" type="double"/>
+ <inport name="endtime" type="double"/>
+ <inport name="timestep" type="double"/>
+ <inport name="log" type="pyobj"/>
+ <inport name="graph" type="pyobj"/>
+ <outport name="cont" type="bool"/>
+ <outport name="time" type="double"/>
+ <outport name="timeData" type="pyobj"/>
+ </inline>
+ <while name="ConvergenceLoop">
+ <bloc name="ConvergenceBloc">
+ <inline name="ConvergenceController">
+ <script><code><![CDATA[telborders = set(telemacData.keys())
+mascborders = set(mascData.keys())
+border_names = telborders | mascborders
+
+if iter == 1:
+ log.write("ITER ")
+ for name in border_names:
+ if name in mascData:
+ nbvar = len(mascData[name])
+ formatlen = nbvar * 10 - 5
+ log.write("MASC %-*s" % (formatlen, name))
+ if name in telemacData:
+ nbvar = len(telemacData[name])
+ formatlen = nbvar * 10 - 5
+ log.write("T2D %-*s" % (formatlen, name))
+ log.write("\n")
+ log.write("ITER ")
+ for name in border_names:
+ if name in mascData:
+ keys = sorted(mascData[name].iterkeys())
+ for key in keys:
+ log.write("%9s " % key)
+ if name in telemacData:
+ keys = sorted(telemacData[name].iterkeys())
+ for key in keys:
+ log.write("%9s " % key)
+ log.write("\n")
+
+log.write("%4d " % iter)
+for name in border_names:
+ if name in mascData:
+ keys = sorted(mascData[name].iterkeys())
+ for key in keys:
+ log.write("%9.3f " % mascData[name][key])
+ if name in telemacData:
+ keys = sorted(telemacData[name].iterkeys())
+ for key in keys:
+ log.write("%9.3f " % telemacData[name][key])
+log.write("\n")
+log.flush()
+
+convergence = True
+for name in border_names:
+ if name in mascData and name in telemacData:
+ if abs(mascData[name]["Z"] - telemacData[name]["Z"]) > Z_tol:
+ convergence = False
+ if abs(mascData[name]["Q"] - telemacData[name]["Q"]) > Q_tol:
+ convergence = False
+
+cont = True
+if convergence:
+ log.write("Convergence reached\n")
+ cont = False
+
+iter += 1
+if iter > maxiter:
+ log.write("Max iterations reached\n")
+ cont = False
+
+if not cont:
+ iter = 1
+
+ if timeData["start_time"] == 0.0:
+ graph.write("Time,")
+ for name in border_names:
+ if name in mascData:
+ keys = sorted(mascData[name].iterkeys())
+ for key in keys:
+ graph.write("MASC %s %s," % (name, key))
+ if name in telemacData:
+ keys = sorted(telemacData[name].iterkeys())
+ for key in keys:
+ graph.write("T2D %s %s," % (name, key))
+ graph.write("\n")
+
+ graph.write("%f," % timeData["end_time"])
+ for name in border_names:
+ if name in mascData:
+ keys = sorted(mascData[name].iterkeys())
+ for key in keys:
+ graph.write("%f," % mascData[name][key])
+ if name in telemacData:
+ keys = sorted(telemacData[name].iterkeys())
+ for key in keys:
+ graph.write("%f," % telemacData[name][key])
+ graph.write("\n")
+ graph.flush()
+]]></code></script>
+ <inport name="mascData" type="pyobj"/>
+ <inport name="telemacData" type="pyobj"/>
+ <inport name="Z_tol" type="double"/>
+ <inport name="Q_tol" type="double"/>
+ <inport name="iter" type="int"/>
+ <inport name="borders" type="pyobj"/>
+ <inport name="log" type="pyobj"/>
+ <inport name="maxiter" type="int"/>
+ <inport name="timeData" type="pyobj"/>
+ <inport name="graph" type="pyobj"/>
+ <outport name="cont" type="bool"/>
+ <outport name="iter" type="int"/>
+ <outport name="timeData" type="pyobj"/>
+ <outport name="mascData" type="pyobj"/>
+ <outport name="telemacData" type="pyobj"/>
+ </inline>
+ <service name="MascExecStep">
+ <component>MASCARET</component>
+ <load container="mascaret_container"/>
+ <method>ExecStep</method>
+ <inport name="timeData" type="pyobj"/>
+ <inport name="inputData" type="pyobj"/>
+ <outport name="outputData" type="pyobj"/>
+ </service>
+ <service name="TelExecStep">
+ <component>TELEMAC2D</component>
+ <load container="telemac_container"/>
+ <method>ExecStep</method>
+ <inport name="timeData" type="pyobj"/>
+ <inport name="inputData" type="pyobj"/>
+ <outport name="outputData" type="pyobj"/>
+ </service>
+ <control> <fromnode>MascExecStep</fromnode> <tonode>ConvergenceController</tonode> </control>
+ <control> <fromnode>MascExecStep</fromnode> <tonode>TelExecStep</tonode> </control>
+ <control> <fromnode>TelExecStep</fromnode> <tonode>ConvergenceController</tonode> </control>
+ <datalink control="false">
+ <fromnode>ConvergenceController</fromnode> <fromport>timeData</fromport>
+ <tonode>MascExecStep</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>ConvergenceController</fromnode> <fromport>timeData</fromport>
+ <tonode>TelExecStep</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>ConvergenceController</fromnode> <fromport>telemacData</fromport>
+ <tonode>MascExecStep</tonode> <toport>inputData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>MascExecStep</fromnode> <fromport>outputData</fromport>
+ <tonode>ConvergenceController</tonode> <toport>mascData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>MascExecStep</fromnode> <fromport>outputData</fromport>
+ <tonode>TelExecStep</tonode> <toport>inputData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>TelExecStep</fromnode> <fromport>outputData</fromport>
+ <tonode>ConvergenceController</tonode> <toport>telemacData</toport>
+ </datalink>
+ </bloc>
+ <datalink control="false">
+ <fromnode>ConvergenceBloc.ConvergenceController</fromnode> <fromport>iter</fromport>
+ <tonode>ConvergenceBloc.ConvergenceController</tonode> <toport>iter</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>ConvergenceBloc.ConvergenceController</fromnode> <fromport>timeData</fromport>
+ <tonode>ConvergenceBloc.ConvergenceController</tonode> <toport>timeData</toport>
+ </datalink>
+ </while>
+ <control> <fromnode>ConvergenceLoop</fromnode> <tonode>TimeController</tonode> </control>
+ <datalink control="false">
+ <fromnode>TimeController</fromnode> <fromport>cont</fromport>
+ <tonode>ConvergenceLoop</tonode> <toport>condition</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>TimeController</fromnode> <fromport>timeData</fromport>
+ <tonode>ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>TimeController</fromnode> <fromport>timeData</fromport>
+ <tonode>ConvergenceLoop.ConvergenceBloc.MascExecStep</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>TimeController</fromnode> <fromport>timeData</fromport>
+ <tonode>ConvergenceLoop.ConvergenceBloc.TelExecStep</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>ConvergenceLoop.ConvergenceBloc.ConvergenceController</fromnode> <fromport>cont</fromport>
+ <tonode>ConvergenceLoop</tonode> <toport>condition</toport>
+ </datalink>
+ </bloc>
+ <datalink control="false">
+ <fromnode>TimeBloc.TimeController</fromnode> <fromport>time</fromport>
+ <tonode>TimeBloc.TimeController</tonode> <toport>time</toport>
+ </datalink>
+ </while>
+ <service name="InitMascaret">
+ <node>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.MascExecStep</node>
+ <method>Init</method>
+ <inport name="studyID" type="int"/>
+ <inport name="detCaseEntry" type="string"/>
+ </service>
+ <inline name="InitCoupling">
+ <script><code><![CDATA[execfile(couplingFile)
+
+timeData = {}
+timeData["start_time"] = starttime
+timeData["end_time"] = starttime + timestep
+timeData["time_step"] = timestep
+timeData["save_state_flag"] = True
+
+log = open(logFile, "w")
+graph = open(graphFile, "w")
+]]></code></script>
+ <inport name="couplingFile" type="string"/>
+ <inport name="logFile" type="string"/>
+ <inport name="graphFile" type="string"/>
+ <outport name="starttime" type="double"/>
+ <outport name="endtime" type="double"/>
+ <outport name="timestep" type="double"/>
+ <outport name="eps_Z" type="double"/>
+ <outport name="eps_Q" type="double"/>
+ <outport name="borders" type="pyobj"/>
+ <outport name="timeData" type="pyobj"/>
+ <outport name="log" type="pyobj"/>
+ <outport name="maxiter" type="int"/>
+ <outport name="graph" type="pyobj"/>
+ </inline>
+ <service name="FinalizeMascaret">
+ <node>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.MascExecStep</node>
+ <method>Finalize</method>
+ </service>
+ <service name="InitTelemac">
+ <node>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.TelExecStep</node>
+ <method>Init</method>
+ <inport name="studyID" type="int"/>
+ <inport name="detCaseEntry" type="string"/>
+ </service>
+ <service name="FinalizeTelemac">
+ <node>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.TelExecStep</node>
+ <method>Finalize</method>
+ </service>
+ <service name="InitMascBorders">
+ <node>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.MascExecStep</node>
+ <method>InitBorders</method>
+ <inport name="borders" type="pyobj"/>
+ </service>
+ <service name="InitTelBorders">
+ <node>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.TelExecStep</node>
+ <method>InitBorders</method>
+ <inport name="borders" type="pyobj"/>
+ </service>
+ <control> <fromnode>TimeLoop</fromnode> <tonode>FinalizeMascaret</tonode> </control>
+ <control> <fromnode>TimeLoop</fromnode> <tonode>FinalizeTelemac</tonode> </control>
+ <control> <fromnode>InitMascaret</fromnode> <tonode>TimeLoop</tonode> </control>
+ <control> <fromnode>InitCoupling</fromnode> <tonode>TimeLoop</tonode> </control>
+ <control> <fromnode>InitCoupling</fromnode> <tonode>InitMascBorders</tonode> </control>
+ <control> <fromnode>InitCoupling</fromnode> <tonode>InitTelBorders</tonode> </control>
+ <control> <fromnode>InitTelemac</fromnode> <tonode>TimeLoop</tonode> </control>
+ <control> <fromnode>InitTelemac</fromnode> <tonode>InitTelBorders</tonode> </control>
+ <control> <fromnode>InitMascBorders</fromnode> <tonode>TimeLoop</tonode> </control>
+ <control> <fromnode>InitTelBorders</fromnode> <tonode>TimeLoop</tonode> </control>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>starttime</fromport>
+ <tonode>TimeLoop.TimeBloc.TimeController</tonode> <toport>time</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>endtime</fromport>
+ <tonode>TimeLoop.TimeBloc.TimeController</tonode> <toport>endtime</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>timestep</fromport>
+ <tonode>TimeLoop.TimeBloc.TimeController</tonode> <toport>timestep</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>eps_Z</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>Z_tol</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>eps_Q</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>Q_tol</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>borders</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>borders</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>borders</fromport>
+ <tonode>InitMascBorders</tonode> <toport>borders</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>borders</fromport>
+ <tonode>InitTelBorders</tonode> <toport>borders</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>timeData</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>timeData</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.MascExecStep</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>timeData</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.TelExecStep</tonode> <toport>timeData</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>log</fromport>
+ <tonode>TimeLoop.TimeBloc.TimeController</tonode> <toport>log</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>log</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>log</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>maxiter</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>maxiter</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>graph</fromport>
+ <tonode>TimeLoop.TimeBloc.TimeController</tonode> <toport>graph</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>InitCoupling</fromnode> <fromport>graph</fromport>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode> <toport>graph</toport>
+ </datalink>
+ <datalink control="false">
+ <fromnode>TimeLoop.TimeBloc.TimeController</fromnode> <fromport>cont</fromport>
+ <tonode>TimeLoop</tonode> <toport>condition</toport>
+ </datalink>
+ <parameter>
+ <tonode>InitMascaret</tonode><toport>studyID</toport>
+ <value><int>1</int></value>
+ </parameter>
+ <parameter>
+ <tonode>InitMascaret</tonode><toport>detCaseEntry</toport>
+ <value><string>%parse_entry(CAS_MASCARET)%</string></value>
+ </parameter>
+ <parameter>
+ <tonode>InitCoupling</tonode><toport>couplingFile</toport>
+ <value><string>%FICHIER_COUPLAGE%</string></value>
+ </parameter>
+ <parameter>
+ <tonode>InitCoupling</tonode><toport>logFile</toport>
+ <value><string>%FICHIER_LOG%</string></value>
+ </parameter>
+ <parameter>
+ <tonode>InitCoupling</tonode><toport>graphFile</toport>
+ <value><string>%FICHIER_GRAPHIQUE%</string></value>
+ </parameter>
+ <parameter>
+ <tonode>TimeLoop</tonode><toport>condition</toport>
+ <value><boolean>true</boolean></value>
+ </parameter>
+ <parameter>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop</tonode><toport>condition</toport>
+ <value><boolean>true</boolean></value>
+ </parameter>
+ <parameter>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController</tonode><toport>iter</toport>
+ <value><int>1</int></value>
+ </parameter>
+ <parameter>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.MascExecStep</tonode><toport>inputData</toport>
+ <value><objref>N.</objref></value>
+ </parameter>
+ <parameter>
+ <tonode>TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.TelExecStep</tonode><toport>inputData</toport>
+ <value><objref>N.</objref></value>
+ </parameter>
+ <parameter>
+ <tonode>InitTelemac</tonode><toport>studyID</toport>
+ <value><int>1</int></value>
+ </parameter>
+ <parameter>
+ <tonode>InitTelemac</tonode><toport>detCaseEntry</toport>
+ <value><string>%parse_entry(CAS_TELEMAC2D)%</string></value>
+ </parameter>
+ <presentation name="InitMascaret" x="166" y="32" width="158" height="90" expanded="1" expx="166" expy="32" expWidth="158" expHeight="90" shownState="0"/>
+ <presentation name="TimeLoop" x="450.5" y="32" width="760" height="764.5" expanded="1" expx="450.5" expy="32" expWidth="760" expHeight="764.5" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc" x="4" y="60" width="752" height="700.5" expanded="1" expx="4" expy="60" expWidth="752" expHeight="700.5" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc.TimeController" x="590" y="56" width="158" height="171" expanded="1" expx="590" expy="56" expWidth="158" expHeight="171" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.ConvergenceController" x="330.5" y="32" width="158" height="306" expanded="1" expx="330.5" expy="32" expWidth="158" expHeight="306" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc.ConvergenceLoop" x="4" y="291.5" width="503" height="405" expanded="1" expx="4" expy="291.5" expWidth="503" expHeight="405" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc" x="6.5" y="59" width="492.5" height="342" expanded="1" expx="6.5" expy="59" expWidth="492.5" expHeight="342" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.MascExecStep" x="42" y="32" width="158" height="90" expanded="1" expx="42" expy="32" expWidth="158" expHeight="90" shownState="0"/>
+ <presentation name="InitCoupling" x="3.5" y="355.5" width="158" height="306" expanded="1" expx="3.5" expy="355.5" expWidth="158" expHeight="306" shownState="0"/>
+ <presentation name="TimeLoop.TimeBloc.ConvergenceLoop.ConvergenceBloc.TelExecStep" x="86" y="168.5" width="158" height="90" expanded="1" expx="86" expy="168.5" expWidth="158" expHeight="90" shownState="0"/>
+ <presentation name="FinalizeMascaret" x="1308" y="32" width="158" height="36" expanded="1" expx="1308" expy="32" expWidth="158" expHeight="36" shownState="0"/>
+ <presentation name="InitTelemac" x="4" y="138.5" width="158" height="90" expanded="1" expx="4" expy="138.5" expWidth="158" expHeight="90" shownState="0"/>
+ <presentation name="FinalizeTelemac" x="1308" y="89" width="158" height="36" expanded="1" expx="1308" expy="89" expWidth="158" expHeight="36" shownState="0"/>
+ <presentation name="InitMascBorders" x="184" y="273.5" width="158" height="63" expanded="1" expx="184" expy="273.5" expWidth="158" expHeight="63" shownState="0"/>
+ <presentation name="InitTelBorders" x="185" y="169" width="158" height="63" expanded="1" expx="185" expy="169" expWidth="158" expHeight="63" shownState="0"/>
+ <presentation name="__ROOT__" x="0" y="0" width="1470" height="800.5" expanded="1" expx="0" expy="0" expWidth="1470" expHeight="800.5" shownState="0"/>
+</proc>
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import re
+
+from generator.generator_file_from_template import FileFromTemplateGenerator
+
+def entryPoint():
+ return {'name': 'coupling1d2d',
+ 'factory' : Coupling1D2DGenerator}
+
+class Coupling1D2DGenerator(FileFromTemplateGenerator):
+ """
+ This generator is mostly identical to FileFromTemplateGenerator, but it
+ can also perform replacements using functions. The syntax for this kind
+ of replacement is %func(KEYWORD)%. The replacement method will call
+ the function "func" that must be defined in this class with the parameter
+ KEYWORD. The available function is parse_entry.
+ """
+
+ def generate_output_from_template(self):
+ """
+ Generate the output by replacing the keywords and the functions in the
+ template.
+ """
+ FileFromTemplateGenerator.generate_output_from_template(self)
+ self.output_text = self.replace_functions(self.output_text)
+
+ def replace_functions(self, template_string):
+ """
+ Replace the functions in the template string.
+ """
+ result = template_string
+ pattern = "%(.*)\((.*)\)%"
+ matchObj = re.search(pattern, result)
+ while matchObj:
+ (whole_string, func_name, param_keyword) = matchObj.group(0, 1, 2)
+ param_value = self.kw_dict[param_keyword]
+ func = eval(func_name)
+ value = func(param_value)
+ result = result.replace(whole_string, value)
+ matchObj = re.search(pattern, result)
+ return result
+
+def parse_entry(selected_value):
+ """
+ Find entry if selected_value is something like "name (entry)"
+ """
+ entry = selected_value
+ match = re.search("\((.*)\)$", entry)
+ if match is not None:
+ entry = match.group(1)
+ return entry
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+code = "coupling1d2d"
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+
+repIni = os.path.dirname(__file__)
+INSTALLDIR = os.getenv("EFICAS_ROOT")
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+from PyQt4 import QtCore, QtGui
+
+import salome
+from salome.kernel.studyedit import getStudyEditor
+
+
+class HSGUIException(Exception):
+ """
+ Exception class used to display user-friendly messages in a dialog box for
+ standard errors (missing files, etc.).
+ """
+ pass
+
+
+class OverrideCursorCM:
+ """
+ This class is a context manager that can be used to set an override cursor
+ in a QT application and automatically restore the base cursor
+ """
+ def __init__(self, cursor):
+ self.cursor = cursor
+
+ def __enter__(self):
+ QtGui.QApplication.setOverrideCursor(self.cursor)
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ QtGui.QApplication.restoreOverrideCursor()
+
+wait_cursor = OverrideCursorCM(QtGui.QCursor(QtCore.Qt.WaitCursor))
+
+
+def get_and_check_selected_file_path():
+ """
+ Get the first selected item in the object browser, check that its "Comment"
+ attribute contains a valid file path, and return this file path.
+ """
+ ed = getStudyEditor()
+ sobj = ed.study.FindObjectID(salome.sg.getSelected(0))
+ filepath = sobj.GetComment()
+ if not os.path.isfile(filepath):
+ raise HSGUIException(QtGui.QApplication.translate("get_and_check_selected_file_path",
+ "File %1 does not exist").arg(filepath))
+ return filepath
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(eficas)
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/mascaret)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import mascaret_swig
+
+Mascaret = mascaret_swig.Mascaret
+MascaretFile = mascaret_swig.MascaretFile
+MascaretException = mascaret_swig.MascaretException
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ appli.py
+ configuration_mascaret.py
+ prefs_mascaret.py
+ prefs.py
+ mascaret_V7_cata.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/mascaret/eficas)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+import re
+
+from PyQt4.QtGui import QMessageBox
+
+import salome
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("salome.hydro.mascaret.eficas.appli",
+ color = termcolor.GREEN_FG)
+
+import eficasSalome
+
+from salome.hydro.study import HydroStudyEditor
+
+class EficasForMascaretAppli(eficasSalome.MyEficas):
+ """
+ This class launches Eficas and adds entries for the created files in
+ MASCARET component in the study tree. The messages in this class are in
+ french because they are displayed in Eficas interface.
+
+ :type fichier: string
+ :param fichier: path of an Eficas file to open
+
+ """
+ def __init__(self, fichier = None, version = None):
+ self.ed = HydroStudyEditor()
+ self.codedir = os.path.dirname(__file__)
+ sys.path[:0] = [self.codedir]
+ eficasSalome.MyEficas.__init__(self, sgPyQt.getDesktop(),
+ "mascaret",
+ fichier, version = version)
+ sgPyQt.createView("Eficas Mascaret", self)
+
+ def addJdcInSalome(self, jdcPath):
+ """
+ Add the newly created file in Salome study
+ """
+ try:
+ self.ed.find_or_create_mascaret_case(jdcPath)
+ except Exception, exc:
+ msgError = "Can't add file to Salome study tree"
+ logger.exception(msgError)
+ QMessageBox.warning(self, self.tr("Warning"),
+ self.tr("%s. Reason:\n%s\n\nSee logs for "
+ "more details." % (msgError, exc)))
+ salome.sg.updateObjBrowser(0)
+
+ def closeEvent(self, event):
+ while self.codedir in sys.path:
+ sys.path.remove(self.codedir)
+ eficasSalome.MyEficas.closeEvent(self, event)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+
+from Editeur.catadesc import CatalogDescription
+from InterfaceQT4.configuration import CONFIG_BASE
+
+class CONFIG(CONFIG_BASE):
+
+ def __init__(self, appli, repIni):
+ """
+ This class stores the configuration parameters for Eficas
+ """
+ CONFIG_BASE.__init__(self, appli, repIni)
+
+ # Configuration parameters
+ self.savedir = os.getenv("HOME")
+ self.catalogues = (CatalogDescription("mascaret_V7",
+ os.path.join(repIni, "mascaret_V7_cata.py")),)
+ self.lang = 'fr'
+
+ def save_params(self):
+ pass
+
+def make_config(appli, rep):
+ return CONFIG(appli, rep)
+
+def make_config_style(appli, rep):
+ return None
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+from Accas import *
+
+JdC = JDC_CATA(regles = (UN_PARMI('MASCARET',)),
+ )
+
+MASCARET = PROC(
+ nom = "MASCARET", op = None,
+ fr = u"Définition d'un cas d'étude Mascaret",
+ ang = u"Definition of a Mascaret study case",
+ FICHIER_DICO = SIMP(statut = "o", typ = 'Fichier',
+ fr = u"Fichier Dictionnaire",
+ ang = u"Dictionary file"),
+ FICHIER_MOT_CLE = SIMP(statut = "o",
+ typ = ('Fichier', 'Fichiers CAS (*.cas);;Tous les fichiers (*)',),
+ fr = u"Fichier Mot Clé",
+ ang = u"Keyword file"),
+ FICHIER_GEOMETRIE = SIMP(statut = "f",
+ typ = ('Fichier', 'Fichiers GEO (*.geo);;Tous les fichiers (*)',),
+ fr = u"Fichier de géométrie",
+ ang = u"Geometry file"),
+ FICHIER_LOI = FACT(statut = 'f', max = '**',
+ NOM = SIMP(statut = "o",
+ typ = ('Fichier', 'Fichiers LOI (*.loi);;Tous les fichiers (*)',),
+ fr = u"Fichier de lois",
+ ang = u"Laws file"),
+ ),
+ FICHIER_ABAQUES = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)',),
+ fr = u"Fichier abaques",
+ ang = u"Abacus file"),
+ FICHIER_CASIER = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)',),
+ fr = u"Fichier casier",
+ ang = u"Compartment file"),
+ FICHIER_DAMOCLE = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)',),
+ fr = u"Fichier damocle",
+ ang = u"Damocle file"),
+ FICHIER_LIG = SIMP(statut = "o",
+ typ = ('Fichier', 'Fichiers LIG (*.lig);;Tous les fichiers (*)',),
+ fr = u"Fichier LIG",
+ ang = u"LIG file"),
+ LISTING = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de listing",
+ ang = u"Listing file"),
+ LISTING_CASIER = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de listing casier",
+ ang = u"Compartment listing file"),
+ LISTING_LIAISON = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de listing liaison",
+ ang = u"Link listing file"),
+ RESULTAT = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de résultat",
+ ang = u"Result file"),
+ RESULTAT_CASIER = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de résultat casier",
+ ang = u"Compartment result file"),
+ RESULTAT_LIAISON = SIMP(statut = "f",
+ typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de résultat liaison",
+ ang = u"Link result file"),
+ VARIABLE_SORTIE = FACT(statut = 'f', max = '**',
+ fr = u"Variable de sortie du calcul",
+ ang = u"Computation output variable",
+ NOM = SIMP(statut = "o", typ = 'TXM',
+ fr = u"Nom de la variable",
+ ang = u"Variable name"),
+ VARIABLE_MASCARET = SIMP(statut = "o", typ = 'TXM',
+ fr = u'Variable Mascaret (ex : "Etat.Z(1,0,0)")',
+ ang = u'Mascaret variable (ex : "Etat.Z(1,0,0)")'),
+ ),
+ VARIABLE_ENTREE = FACT(statut = 'f', max = '**',
+ fr = u"Variable d'entrée du calcul",
+ ang = u"Computation input variable",
+ NOM = SIMP(statut = "o", typ = 'TXM',
+ fr = u"Nom de la variable",
+ ang = u"Variable name"),
+ VARIABLE_MASCARET = SIMP(statut = "o", typ = 'TXM',
+ fr = u'Variable Mascaret (ex : "Modele.Lois.Debit(1,1-2,0)")',
+ ang = u'Mascaret variable (ex : "Modele.Lois.Debit(1,1-2,0)")'),
+ ),
+)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+code = "mascaret"
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+
+repIni = os.path.dirname(__file__)
+INSTALLDIR = os.getenv("EFICAS_ROOT")
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(eficas)
+
+INCLUDE(UsePyQt4)
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ genjob.py
+ genjobwindow.py
+ launcher.py
+ gui.py
+)
+
+# uic files / to be processed by pyuic
+SET(UIFILES
+ genjobwindow.ui
+)
+
+# --- rules ---
+
+# scripts / pyuic wrappings
+PYQT4_WRAP_UIC(PYUICFILES ${UIFILES})
+
+SET(ALLPYFILES ${PYFILES} ${PYUICFILES})
+
+SALOME_INSTALL_SCRIPTS("${ALLPYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/pytel)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ configuration_pytel.py
+ prefs_pytel.py
+ prefs.py
+ pytel_cata.py
+ appli.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/pytel/eficas)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+
+from PyQt4.QtGui import QMessageBox
+
+import salome
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("salome.hydro.pytel.eficas.appli",
+ color = termcolor.GREEN_FG)
+
+import eficasSalome
+
+from salome.hydro.study import HydroStudyEditor
+
+class EficasForPytelAppli(eficasSalome.MyEficas):
+ """
+ This class launches Eficas and adds entries for the created files in
+ HYDRO component in the study tree.
+
+ :type fichier: string
+ :param fichier: path of an Eficas file to open
+
+ """
+ def __init__(self, fichier = None, version = None):
+ self.ed = HydroStudyEditor()
+ self.codedir = os.path.dirname(__file__)
+ sys.path[:0] = [self.codedir]
+ eficasSalome.MyEficas.__init__(self, sgPyQt.getDesktop(), "pytel",
+ fichier, version = version)
+ sgPyQt.createView("Eficas Pytel", self)
+
+ def addJdcInSalome(self, jdcPath):
+ """
+ Add the newly created file in Salome study
+ """
+ try:
+ self.ed.find_or_create_pytel_case(jdcPath)
+ except Exception, exc:
+ msgError = "Can't add file to Salome study tree"
+ logger.exception(msgError)
+ QMessageBox.warning(self, self.tr("Warning"),
+ self.tr("%s. Reason:\n%s\n\nSee logs for more details." % (msgError, exc)))
+ salome.sg.updateObjBrowser(0)
+
+ def closeEvent(self, event):
+ while self.codedir in sys.path:
+ sys.path.remove(self.codedir)
+ eficasSalome.MyEficas.closeEvent(self, event)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+
+from Editeur.catadesc import CatalogDescription
+from InterfaceQT4.configuration import CONFIG_BASE
+
+class CONFIG(CONFIG_BASE):
+
+ def __init__(self, appli, repIni):
+ """
+ This class stores the configuration parameters for Eficas
+ """
+ CONFIG_BASE.__init__(self, appli, repIni)
+
+ # Configuration parameters
+ self.savedir = os.getenv("HOME")
+ self.catalogues = (CatalogDescription("pytel", os.path.join(repIni, "pytel_cata.py")),)
+ self.lang = 'fr'
+
+ def save_params(self):
+ pass
+
+def make_config(appli, rep):
+ return CONFIG(appli, rep)
+
+def make_config_style(appli, rep):
+ return None
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+code = "pytel"
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+
+repIni = os.path.dirname(__file__)
+INSTALLDIR = os.getenv("EFICAS_ROOT")
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+from Accas import *
+
+codelist = ("artemis", "estel3d", "postel3d", "sisyphe", "stbtel", "telemac2d", "telemac3d", "tomawac")
+
+JdC = JDC_CATA(regles = (UN_PARMI('PYTEL',)),
+ )
+PYTEL = PROC(
+ nom = "PYTEL", op = None,
+ fr = u"Définition d'un cas pour le lanceur Pytel",
+ ang = u"Definition of a case for the Pytel launcher",
+ CODE = SIMP(statut = "o", typ = "TXM", into = codelist, defaut = "telemac2d",
+ fr = u"Code à exécuter",
+ ang = u"Code to run"),
+ FICHIER_CAS = SIMP(statut = "o", typ = 'Fichier',
+ fr = u"Fichier de description du cas",
+ ang = u"Case description file"),
+ REPERTOIRE_TRAVAIL = SIMP(statut = "f", typ = 'Repertoire',
+ fr = u"Répertoire de travail",
+ ang = u"Working directory"),
+ ENTREE_MED = FACT(statut = 'f', max = 1,
+ FICHIER_MED = SIMP(statut = "o",
+ typ = ('Fichier', 'Fichiers MED (*.med)',),
+ fr = u"Fichier de maillage d'entrée au format MED",
+ ang = u"Input mesh file in MED format"),
+ FICHIER_BCD = SIMP(statut = "o",
+ typ = ('Fichier', 'Fichiers BCD (*.bcd)',),
+ fr = u"Fichier de définition des conditions limites au format BCD",
+ ang = u"Boundary conditions definition file in BCD format"),
+ ),
+ SORTIE_MED = SIMP(statut = "f",
+ typ = ('Fichier', 'Fichiers MED (*.med)', "Sauvegarde"),
+ fr = u"Fichier de sortie au format MED",
+ ang = u"Output file in MED format"),
+)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import tempfile
+from datetime import datetime
+import glob
+
+import salome
+
+convertion_script_template = """
+converter.py %(input_file)s -b %(log_file)s -o %(output_file)s
+"""
+
+job_script_template = """#!/bin/sh
+
+. %(env_file)s
+runcode.py %(code)s %(cas)s --ncsize %(nbcore)d
+"""
+
+def generate_job(pytel_params, resource, telemac_root_dir, telemac_env_file,
+ nbcore, input_data_dir, result_dir):
+ """
+ Create a Launcher job using the parameters specified by the user.
+ """
+ # Generate job script
+ basename = os.path.basename(pytel_params["FICHIER_CAS"])
+ job_script = job_script_template % {"env_file": telemac_env_file,
+ "code": pytel_params["CODE"],
+ "cas": basename,
+ "nbcore": nbcore}
+
+
+ (fd, job_script_file) = tempfile.mkstemp(prefix = "job_" + basename + "_", suffix = ".sh")
+ os.close(fd)
+ f = open(job_script_file, "w")
+ f.write(job_script)
+ f.close()
+
+ # Define job parameters
+ job_params = salome.JobParameters()
+ job_params.job_name = basename
+ job_params.job_type = "command"
+ job_params.job_file = job_script_file
+ input_files = glob.glob(os.path.join(input_data_dir, "*")) + [pytel_params["FICHIER_CAS"]]
+ input_files = list(set(input_files)) # Remove duplicates
+ job_params.in_files = input_files
+ job_params.out_files = []
+ job_params.result_directory = result_dir
+
+ # Define resource parameters
+ job_params.resource_required = salome.ResourceParameters()
+ job_params.resource_required.name = resource
+ job_params.resource_required.nb_proc = nbcore
+
+ # Generate name for the working directory
+ res_manager = salome.naming_service.Resolve("/ResourcesManager")
+ res_definition = res_manager.GetResourceDefinition(resource)
+ res_work_dir = res_definition.working_directory
+ if res_work_dir != "":
+ timestr = datetime.now().ctime()
+ timestr = timestr.replace('/', '_')
+ timestr = timestr.replace('-', '_')
+ timestr = timestr.replace(':', '_')
+ timestr = timestr.replace(' ', '_')
+ work_dir = res_work_dir + "/" + job_params.job_name + "_" + timestr
+ job_params.work_directory = work_dir
+
+ # Create Launcher job
+ launcher = salome.naming_service.Resolve('/SalomeLauncher')
+ launcher.createJob(job_params)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+from PyQt4 import QtGui, QtCore
+
+import salome
+from salome.hydro.pytel.genjob import generate_job
+from genjobwindow_ui import Ui_GenJobDialog
+
+
+class GenJobDialog(QtGui.QDialog, Ui_GenJobDialog):
+
+ def __init__(self, parent, pytel_params):
+ QtGui.QDialog.__init__(self, parent)
+ self.setupUi(self)
+ self.connect(self.dialogButtonBox, QtCore.SIGNAL("accepted()"), self.validate)
+ self.connect(self.dialogButtonBox, QtCore.SIGNAL("rejected()"), self.close)
+ self.connect(self.chooseInputDataDirectoryButton, QtCore.SIGNAL("clicked()"), self.choose_input_dir)
+ self.connect(self.chooseResultDirectoryButton, QtCore.SIGNAL("clicked()"), self.choose_result_dir)
+ self.telemacRootDirLE.setText("/home/projets-bgq/systel/V6P2")
+ self.telemacEnvFileLE.setText("/home/projets-bgq/systel/V6P2/config/pysource.zumbrota.xlf14.sh")
+ casedir = os.path.dirname(pytel_params["FICHIER_CAS"])
+ self.inputDataDirectoryLE.setText(casedir)
+ self.resultDirectoryLE.setText(casedir)
+
+ # Populate resource combo box
+ res_manager = salome.naming_service.Resolve("/ResourcesManager")
+ res_params = salome.ResourceParameters()
+ res_list = res_manager.GetFittingResources(res_params)
+ self.resourceCB.addItems(res_list)
+
+ self.pytel_params = pytel_params
+
+ def choose_input_dir(self):
+ directory = QtGui.QFileDialog.getExistingDirectory(self,
+ directory = self.inputDataDirectoryLE.text(),
+ options = QtGui.QFileDialog.ShowDirsOnly)
+ if not directory.isNull():
+ self.inputDataDirectoryLE.setText(directory)
+
+ def choose_result_dir(self):
+ directory = QtGui.QFileDialog.getExistingDirectory(self,
+ directory = self.resultDirectoryLE.text(),
+ options = QtGui.QFileDialog.ShowDirsOnly)
+ if not directory.isNull():
+ self.resultDirectoryLE.setText(directory)
+
+ def validate(self):
+ generate_job(self.pytel_params,
+ str(self.resourceCB.currentText()),
+ str(self.telemacRootDirLE.text()),
+ str(self.telemacEnvFileLE.text()),
+ self.nbCoreSB.value(),
+ str(self.inputDataDirectoryLE.text()),
+ str(self.resultDirectoryLE.text()))
+ self.close()
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>GenJobDialog</class>
+ <widget class="QDialog" name="GenJobDialog">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>636</width>
+ <height>280</height>
+ </rect>
+ </property>
+ <property name="windowTitle">
+ <string>Generate Job</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <layout class="QFormLayout" name="formLayout">
+ <item row="0" column="0">
+ <widget class="QLabel" name="label_3">
+ <property name="text">
+ <string>Resource</string>
+ </property>
+ </widget>
+ </item>
+ <item row="0" column="1">
+ <widget class="QComboBox" name="resourceCB"/>
+ </item>
+ <item row="1" column="0">
+ <widget class="QLabel" name="label">
+ <property name="text">
+ <string>Telemac remote root directory</string>
+ </property>
+ </widget>
+ </item>
+ <item row="1" column="1">
+ <widget class="QLineEdit" name="telemacRootDirLE"/>
+ </item>
+ <item row="2" column="0">
+ <widget class="QLabel" name="label_6">
+ <property name="text">
+ <string>Telemac environment file</string>
+ </property>
+ </widget>
+ </item>
+ <item row="2" column="1">
+ <widget class="QLineEdit" name="telemacEnvFileLE"/>
+ </item>
+ <item row="3" column="0">
+ <widget class="QLabel" name="label_7">
+ <property name="text">
+ <string>Number of cores</string>
+ </property>
+ </widget>
+ </item>
+ <item row="3" column="1">
+ <widget class="QSpinBox" name="nbCoreSB">
+ <property name="minimum">
+ <number>1</number>
+ </property>
+ <property name="maximum">
+ <number>100000</number>
+ </property>
+ </widget>
+ </item>
+ <item row="4" column="0">
+ <widget class="QLabel" name="label_5">
+ <property name="text">
+ <string>Input data directory</string>
+ </property>
+ </widget>
+ </item>
+ <item row="4" column="1">
+ <layout class="QHBoxLayout" name="horizontalLayout_4">
+ <item>
+ <widget class="QLineEdit" name="inputDataDirectoryLE">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="chooseInputDataDirectoryButton">
+ <property name="text">
+ <string>...</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item row="5" column="0">
+ <widget class="QLabel" name="label_2">
+ <property name="text">
+ <string>Result directory</string>
+ </property>
+ </widget>
+ </item>
+ <item row="5" column="1">
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <item>
+ <widget class="QLineEdit" name="resultDirectoryLE">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="chooseResultDirectoryButton">
+ <property name="text">
+ <string>...</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="verticalSpacer">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>43</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <spacer name="horizontalSpacer">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QDialogButtonBox" name="dialogButtonBox">
+ <property name="standardButtons">
+ <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+
+from salome.hydro.gui_utils import get_and_check_selected_file_path
+from salome.hydro.study import jdc_to_dict
+
+from salome.hydro.pytel.eficas.appli import EficasForPytelAppli
+from launcher import run_pytel
+from genjobwindow import GenJobDialog
+
+
+def create_case():
+ EficasForPytelAppli()
+
+def edit_selected_case():
+ EficasForPytelAppli(get_and_check_selected_file_path())
+
+def get_params_from_selected_case():
+ """
+ Get the parameters dict from the selected case in Salome study
+ """
+ jdcpath = get_and_check_selected_file_path()
+ with open(jdcpath) as jdcfile:
+ jdc = jdcfile.read()
+ param_dict = jdc_to_dict(jdc, ["PYTEL", "_F"])
+ return param_dict
+
+def run_selected_case():
+ param_dict = get_params_from_selected_case()
+ run_pytel(param_dict)
+
+def generate_job_for_selected_case():
+ param_dict = get_params_from_selected_case()
+ dialog = GenJobDialog(sgPyQt.getDesktop(), param_dict)
+ dialog.exec_()
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import subprocess
+import tempfile
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("salome.hydro.pytel.launcher", color = termcolor.BLUE)
+#logger.setLevel(logging.ERROR)
+
+def run_pytel(param_dict):
+ """
+ Run the Python Telemac launching script (pytel), eventually preceded and
+ followed by data conversion scripts.
+ """
+ interm_files = [] # Intermediate files that can eventually be deleted in the end
+
+ # Get and eventually create working directory
+ if "REPERTOIRE_TRAVAIL" in param_dict:
+ wrkdir = param_dict["REPERTOIRE_TRAVAIL"]
+ if not os.path.exists(wrkdir):
+ os.makedirs(wrkdir)
+ else:
+ wrkdir = tempfile.mkdtemp(prefix = "tel-")
+ interm_files += [wrkdir]
+
+ # Read original steering file
+ steering_filepath = param_dict["FICHIER_CAS"]
+ steering_file_dir = os.path.dirname(steering_filepath)
+ with open(steering_filepath) as f:
+ orig_steering = f.read()
+ orig_steering_lines = orig_steering.split("\n")
+
+ cmd = "set -x ; "
+
+ # Run the code itself
+ code = param_dict["CODE"]
+ cmd += "$TELEMAC_DIR/scripts/python27/runcode.py -w %s -r $TELEMAC_DIR %s %s" % \
+ (wrkdir, code, steering_filepath)
+ cmd += " ; rc=$?"
+
+ # Cleanup intermediate files if the computation was successful
+ cmd += " ; if test $rc -eq 0; then rm -rf %s ; fi" % " ".join(interm_files)
+
+ cmd += ' ; echo "return code is $rc"'
+
+ # Launch the command
+ logger.debug("Running the following command in xterm: %s" % cmd)
+ args = ["xterm", "-T", "Execution of Telemac", "-geo", "80x60", "-hold", "-l", "-e", cmd]
+ if param_dict.has_key('batchExec'):
+ if param_dict['batchExec'] == True:
+ args = ["xterm", "-T", "Execution of Telemac", "-geo", "80x60", "+hold", "-l", "-e", cmd]
+ subprocess.Popen(args, cwd = wrkdir)
+
+def check_file_or_create_link(filepath, dirpath, interm_file_list = None):
+ """
+ This utility function checks if the file *filepath* is in directory *dirpath*.
+ If not, it creates a link with a unique name in *dirpath* to the file *filepath*
+ and it prepends the link path to the list *interm_file_list* if it is not None.
+ It returns the name of the link if a link was created, or the name of the file
+ *filepath* otherwise.
+ """
+ filename = os.path.basename(filepath)
+ if not os.path.samefile(dirpath, os.path.dirname(filepath)):
+ name_wo_ext, ext = os.path.splitext(filename)
+ linkpath = tempfile.mktemp(dir = dirpath, prefix = name_wo_ext + "_", suffix = ext)
+ os.symlink(filepath, linkpath)
+ filename = os.path.basename(linkpath)
+ if interm_file_list is not None:
+ interm_file_list[:0] = [linkpath]
+ return filename
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import types
+
+from salome.kernel.studyedit import getStudyEditor
+from salome.kernel.parametric import study_exchange_vars
+
+import HYDROSOLVER_ORB
+
+# module constants
+MODULE_NAME = "HYDROSOLVER"
+
+COMPONENT_NAME = "HydroSolver"
+COMPONENT_ICON = "HYDRO_small.png"
+
+MASCARET_FILE_TYPE = "MASCARET_EFICAS_FILE"
+MASCARET_ICON = "case1d.png"
+MASCARET_CASE_TYPE_ID = 1
+
+VARS_ICON = "icon_variables.png"
+
+LOG_ICON = "log.png"
+LOG_TYPE_ID = 2
+
+TELEMAC2D_FILE_TYPE = "TELEMAC2D_EFICAS_FILE"
+TELEMAC2D_ICON = "case2d.png"
+TELEMAC2D_CASE_TYPE_ID = 3
+
+COUPLING1D2D_FILE_TYPE = "COUPLING1D2D_EFICAS_FILE"
+COUPLING1D2D_ICON = "case_couplage.png"
+COUPLING1D2D_CASE_TYPE_ID = 4
+
+PYTEL_FILE_TYPE = "PYTEL_EFICAS_FILE"
+PYTEL_ICON = "case_pytel.png"
+PYTEL_CASE_TYPE_ID = 5
+
+# Dictionary used to map Eficas parameters to Mascaret file types
+mascaretFileTypeDict = {"FICHIER_ABAQUES" : "abaques",
+ "FICHIER_DICO" : "dico",
+ "FICHIER_CASIER" : "casier",
+ "FICHIER_GEOMETRIE" : "geo",
+ "FICHIER_LOI" : "loi",
+ "FICHIER_MOT_CLE" : "cas",
+ "LISTING" : "listing",
+ "FICHIER_DAMOCLE" : "damocle",
+ "RESULTAT" : "res",
+ "LISTING_CASIER" : "listing_casier",
+ "LISTING_LIAISON" : "listing_liaison",
+ "RESULTAT_CASIER" : "res_casier",
+ "RESULTAT_LIAISON" : "res_liaison"
+ }
+
+def jdc_to_dict(jdc, command_list):
+ """
+ This tricky function transforms a JdC with a single command into a
+ dictionary that can be used more easily from a Python context (thanks to
+ M. Courtois and G. Boulant).
+ """
+ context = {}
+ for command in command_list:
+ context[command] = _args_to_dict
+ exec "parameters = " + jdc.strip() in context
+ return context['parameters']
+
+def _args_to_dict(**kwargs):
+ return kwargs
+
+def get_jdc_dict_var_as_tuple(jdc_dict, varname):
+ if not jdc_dict.has_key(varname):
+ return tuple()
+ elif not isinstance(jdc_dict[varname], types.TupleType):
+ return (jdc_dict[varname],)
+ else:
+ return jdc_dict[varname]
+
+class HydroStudyEditor:
+ """
+ This class provides utility methods to edit the component "Hydro" in
+ the study. The parameter `studyId` defines the ID of the study to edit. If
+ it is :const:`None`, the edited study will be the current study.
+ """
+ def __init__(self, studyId = None):
+ self.editor = getStudyEditor(studyId)
+ self.hydroComp = None
+
+ def find_or_create_hydro_component(self):
+ """
+ Find the component "Hydro" or create it if none is found
+ :return: the SComponent found or created.
+ """
+ if self.hydroComp is None:
+ self.hydroComp = self.editor.findOrCreateComponent(MODULE_NAME,
+ COMPONENT_NAME,
+ COMPONENT_ICON)
+ return self.hydroComp
+
+ def find_or_create_mascaret_case(self, filePath):
+ self.find_or_create_hydro_component()
+ itemName = os.path.splitext(os.path.basename(filePath))[0]
+ sobj = self.editor.findOrCreateItem(self.hydroComp,
+ name = itemName,
+ fileType = MASCARET_FILE_TYPE,
+ fileName = filePath,
+ icon = MASCARET_ICON,
+ comment = str(filePath),
+ typeId = MASCARET_CASE_TYPE_ID)
+ # Create "Variables" item
+ (file_list, lig_file, input_vars, output_vars) = self.get_mascaret_params_from_case(sobj)
+ input_varname_list = [var["NOM"].strip() for var in input_vars]
+ # Remove duplicates
+ input_varname_list = list(set(input_varname_list))
+ input_var_list = [study_exchange_vars.Variable(varname) for varname in input_varname_list]
+ output_var_list = [study_exchange_vars.Variable(var["NOM"].strip()) for var in output_vars]
+ exchange_vars = study_exchange_vars.ExchangeVariables(input_var_list, output_var_list)
+ study_exchange_vars.createSObjectForExchangeVariables(sobj, exchange_vars, icon = VARS_ICON)
+
+ def get_mascaret_params_from_case(self, sobj):
+ jdcpath = sobj.GetComment()
+ with open(jdcpath) as jdcfile:
+ jdc = jdcfile.read()
+ params = jdc_to_dict(jdc, ["MASCARET", "_F"])
+ input_vars = get_jdc_dict_var_as_tuple(params, "VARIABLE_ENTREE")
+ output_vars = get_jdc_dict_var_as_tuple(params, "VARIABLE_SORTIE")
+ file_list = []
+ for (key, value) in params.iteritems():
+ if key == "FICHIER_LOI":
+ file_list += [HYDROSOLVER_ORB.MascaretFile(f["NOM"], mascaretFileTypeDict[key]) for f in value]
+ elif key != "FICHIER_LIG" and key != "VARIABLE_SORTIE" and key != "VARIABLE_ENTREE":
+ file_list.append(HYDROSOLVER_ORB.MascaretFile(value, mascaretFileTypeDict[key]))
+ return (file_list, params["FICHIER_LIG"], input_vars, output_vars)
+
+ def add_results_to_mascaret_case(self, sobj, output_variables, output_values):
+ results = self.editor.createItem(sobj, "Results")
+ for (var, value) in zip(output_variables, output_values):
+ self.editor.createItem(results, var, comment = unicode(value))
+
+ def add_coupling_log(self, varname, log):
+ self.find_or_create_hydro_component()
+ sObj = self.editor.createItem(self.hydroComp,
+ name = varname,
+ icon = LOG_ICON,
+ typeId = LOG_TYPE_ID)
+ attr = self.editor.builder.FindOrCreateAttribute(sObj,
+ "AttributeParameter")
+ attr.SetString("log", log)
+
+ def find_or_create_telemac2d_case(self, filePath):
+ self.find_or_create_hydro_component()
+ itemName = os.path.splitext(os.path.basename(filePath))[0]
+ sobj = self.editor.findOrCreateItem(self.hydroComp,
+ name = itemName,
+ fileType = TELEMAC2D_FILE_TYPE,
+ fileName = filePath,
+ icon = TELEMAC2D_ICON,
+ comment = str(filePath),
+ typeId = TELEMAC2D_CASE_TYPE_ID)
+ # Create "Variables" item
+ with open(filePath) as jdcfile:
+ jdc = jdcfile.read()
+ params = jdc_to_dict(jdc, ["TELEMAC2D", "_F"])
+ input_vars = get_jdc_dict_var_as_tuple(params, "VARIABLE_ENTREE")
+ output_vars = get_jdc_dict_var_as_tuple(params, "VARIABLE_SORTIE")
+ input_varname_list = [var["NOM"].strip() for var in input_vars]
+ # Remove duplicates
+ input_varname_list = list(set(input_varname_list))
+ input_var_list = [study_exchange_vars.Variable(varname) for varname in input_varname_list]
+ output_var_list = [study_exchange_vars.Variable(var["NOM"].strip()) for var in output_vars]
+ exchange_vars = study_exchange_vars.ExchangeVariables(input_var_list, output_var_list)
+ study_exchange_vars.createSObjectForExchangeVariables(sobj, exchange_vars, icon = VARS_ICON)
+
+ def find_or_create_coupling1d2d_case(self, filePath):
+ self.find_or_create_hydro_component()
+ itemName = os.path.splitext(os.path.basename(filePath))[0]
+ sobj = self.editor.findOrCreateItem(self.hydroComp,
+ name = itemName,
+ fileType = COUPLING1D2D_FILE_TYPE,
+ fileName = filePath,
+ icon = COUPLING1D2D_ICON,
+ comment = str(filePath),
+ typeId = COUPLING1D2D_CASE_TYPE_ID)
+
+ def find_or_create_pytel_case(self, filePath):
+ self.find_or_create_hydro_component()
+ itemName = os.path.splitext(os.path.basename(filePath))[0]
+ sobj = self.editor.findOrCreateItem(self.hydroComp,
+ name = itemName,
+ fileType = PYTEL_FILE_TYPE,
+ fileName = filePath,
+ icon = PYTEL_ICON,
+ comment = str(filePath),
+ typeId = PYTEL_CASE_TYPE_ID)
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+ADD_SUBDIRECTORY(eficas)
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ polygon.py
+)
+
+SET(INSTALL_DIR ${SALOME_INSTALL_PYTHON}/salome/hydro/telemac2d)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${INSTALL_DIR})
+
+# This macro is used to transform the list of libraries against which the
+# module is linked into a list of linker flags (-L and -l). If we just use the
+# list of libraries in the linker command, the full path of the libraries is
+# registered in the module dependencies, so it doesn't work when the installation
+# is moved.
+MACRO(LIB_LIST_TO_LINKER_FLAGS LINKER_FLAGS_VAR LIB_LIST)
+ SET(${LINKER_FLAGS_VAR})
+ FOREACH(LIB ${LIB_LIST})
+ GET_FILENAME_COMPONENT(DIRNAME ${LIB} PATH)
+ # Get the library filename without the shortest extension. We can't use
+ # command GET_FILENAME_COMPONENT with option NAME_WE because it returns
+ # the filename without the longest extension. For example, we need to get
+ # "libpython2.7" from "libpython2.7.so" and not "libpython2".
+ GET_FILENAME_COMPONENT(LIBFILENAME ${LIB} NAME)
+ STRING(FIND ${LIBFILENAME} "." DOTPOS REVERSE)
+ STRING(SUBSTRING ${LIBFILENAME} 0 ${DOTPOS} FILENAME_WO_EXT)
+ STRING(SUBSTRING ${FILENAME_WO_EXT} 3 -1 LIBNAME)
+ LIST(APPEND ${LINKER_FLAGS_VAR} "-L${DIRNAME}" "-l${LIBNAME}")
+ ENDFOREACH(LIB ${LIB_LIST})
+ENDMACRO(LIB_LIST_TO_LINKER_FLAGS)
+
+LIB_LIST_TO_LINKER_FLAGS(LINKER_FLAGS "${TELEMAC_LIBRARIES};${HDF5_hdf5_LIBRARY};${MEDFILE_LIBRARIES};${PYTHON_LIBRARY}")
+
+# Python wrapping for Telemac2D created with f2py
+SET(T2D_WRAP_API_LIB _apit2d.so)
+SET(T2D_WRAP_API_PYF_FILE apit2d.pyf)
+SET(T2D_WRAP_API_SRC_FILES ${TELEMAC_API_SRC_DIR}/api_handle_var_t2d.f90
+ ${TELEMAC_API_SRC_DIR}/api_interface_t2d.f90
+ ${TELEMAC_API_SRC_DIR}/api_handle_error_t2d.f90)
+
+# This sed string is used to add necessary definitions to the pyf file
+SET(SEDSTRING "s:python module _apit2d ! in:python module _apit2d ! in\\nusercode '''const int nb_var_t2d=100\\;\\n''':")
+
+ADD_CUSTOM_COMMAND(OUTPUT ${T2D_WRAP_API_LIB}
+ COMMAND f2py -c ${T2D_WRAP_API_PYF_FILE} -I${TELEMAC_INCLUDE_DIR} ${LINKER_FLAGS}
+ MAIN_DEPENDENCY ${T2D_WRAP_API_PYF_FILE}
+ )
+
+ADD_CUSTOM_COMMAND(OUTPUT ${T2D_WRAP_API_PYF_FILE}
+ COMMAND f2py -h ${T2D_WRAP_API_PYF_FILE} -m _apit2d ${T2D_WRAP_API_SRC_FILES}
+ skip: get_boolean_t2d_d get_double_t2d_d get_integer_t2d_d get_string_t2d_d get_var_size_t2d_d
+ set_boolean_t2d_d set_double_t2d_d set_integer_t2d_d set_string_t2d_d :
+ COMMAND sed -i -e \"${SEDSTRING}\" ${T2D_WRAP_API_PYF_FILE}
+ MAIN_DEPENDENCY ${T2D_WRAP_API_SRC_FILES}
+ )
+
+ADD_CUSTOM_TARGET(BUILD_T2D_WRAP_API_LIB ALL DEPENDS ${T2D_WRAP_API_LIB})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${T2D_WRAP_API_LIB} DESTINATION ${INSTALL_DIR})
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import sys
+import os
+import tempfile
+from ctypes import cdll
+
+
+class Telemac2D(object):
+
+ _instanciated = False
+ _api_module = None
+
+ def __new__(cls, *args, **kwargs):
+ if cls._instanciated:
+ raise Exception("Telemac2D instance already exists")
+ instance = super(Telemac2D, cls).__new__(cls, *args, **kwargs)
+ cls._instanciated = True
+ return instance
+
+ def __init__(self, user_fortran = None):
+ self.user_fortran_lib = None
+ self.user_fortran_lib_path = None
+ # User Fortran MUST be loaded before apit2d importation
+ if user_fortran is not None:
+ self._load_user_fortran(user_fortran)
+ if Telemac2D._api_module is None:
+ import salome.hydro.telemac2d._apit2d
+ Telemac2D._api_module = sys.modules["salome.hydro.telemac2d._apit2d"]
+ else:
+ reload(Telemac2D._api_module)
+ self.api = Telemac2D._api_module.api_interface_t2d
+ self.errapi = Telemac2D._api_module.api_handle_error_t2d
+ self.id, ierr = self.api.run_set_config_t2d(6, 2)
+ self.handle_error("run_set_config_t2d", ierr)
+
+ def __del__(self):
+ # No way to cleanly unload user fortran lib, so I don't know if it's possible
+ # to reload and use another one in the same process (to be tested)
+ if self.user_fortran_lib_path is not None:
+ os.remove(self.user_fortran_lib_path)
+ Telemac2D._instanciated = False
+
+ def _load_user_fortran(self, fortran_filename):
+ basename = os.path.basename(fortran_filename)
+ root = os.path.splitext(basename)[0]
+ (fd, self.user_fortran_lib_path) = tempfile.mkstemp(prefix = root + "_", suffix = ".so")
+ os.close(fd)
+ python_version = "%d.%d" % (sys.version_info[0], sys.version_info[1])
+ t2d_ld_flags = "-L${TELEMAC_DIR}/wrap_api/lib -lapi_telemac2d -ltelemac2d -lsisyphe -ltomawac "
+ #t2d_ld_flags += "-lbief -lparallel -lpartel -lgretel -lhermes -ldamocles -lspecial "
+ t2d_ld_flags += "-lbief -lparallel -lhermes -ldamocles -lspecial "
+ t2d_ld_flags += "-L${MED3HOME}/lib -L${HDF5HOME}/lib -lhdf5 -lmed"
+ command = "gfortran %s -shared -o %s -L${PYTHONHOME}/lib -lpython%s %s -I${TELEMAC_DIR}/wrap_api/include -fPIC" % \
+ (fortran_filename, self.user_fortran_lib_path, python_version, t2d_ld_flags)
+ ret = os.system(command)
+ if ret != 0:
+ raise Exception("Cannot compile user fortran file %s" % fortran_filename)
+ self.user_fortran_lib = cdll.LoadLibrary(self.user_fortran_lib_path)
+
+ def handle_error(self, funcname, ierr):
+ if ierr != 0:
+ raise Exception('Error in function %s:\n Error code: %d\n Error message: %s' %
+ (funcname, ierr, self.errapi.err_mess.tostring().strip()))
+
+ def run_read_case_t2d(self, steering_filename, dico_filename = None):
+ if dico_filename is None:
+ dico_filename = os.path.join(os.getenv("TELEMAC_DIR"), "sources", "telemac2d", "telemac2d.dico")
+ if not os.path.isfile(steering_filename):
+ raise Exception("Steering file {0} does not exist".format(steering_filename))
+ if not os.path.isfile(dico_filename):
+ raise Exception("Dictionary file {0} does not exist".format(dico_filename))
+ ierr = self.api.run_read_case_t2d(self.id, steering_filename, dico_filename)
+ self.handle_error("run_read_case_t2d", ierr)
+
+ def get_double(self, varname, *args):
+ args = list(args) + [0] * (3 - len(args)) # Fill last parameters with 0
+ value, ierr = self.api.get_double_t2d(self.id, varname, *args)
+ self.handle_error("get_double_t2d", ierr)
+ return value
+
+ def set_double(self, varname, value, *args):
+ args = list(args) + [0] * (3 - len(args)) # Fill last parameters with 0
+ ierr = self.api.set_double_t2d(self.id, varname, value, *args)
+ self.handle_error("set_double_t2d", ierr)
+
+ def get_integer(self, varname, *args):
+ args = list(args) + [0] * (3 - len(args)) # Fill last parameters with 0
+ value, ierr = self.api.get_integer_t2d(self.id, varname, *args)
+ self.handle_error("get_integer_t2d", ierr)
+ return value
+
+ def set_integer(self, varname, value, *args):
+ args = list(args) + [0] * (3 - len(args)) # Fill last parameters with 0
+ ierr = self.api.set_integer_t2d(self.id, varname, value, *args)
+ self.handle_error("set_integer_t2d", ierr)
+
+ def get_string(self, varname):
+ value, ierr = self.api.get_string_t2d(self.id, varname, 144)
+ self.handle_error("get_string_t2d", ierr)
+ return value.tostring().strip()
+
+ def set_string(self, varname, value):
+ padded_value = value + " " * (144 - len(value)) # Pad with spaces
+ ierr = self.api.set_string_t2d(self.id, varname, padded_value, 144)
+ self.handle_error("set_string_t2d", ierr)
+
+ def run_all_timesteps(self):
+ ntimesteps = self.get_integer("MODEL.NTIMESTEPS")
+ for i in xrange(ntimesteps):
+ ierr = self.api.run_timestep_t2d(self.id)
+ self.handle_error("run_timestep_t2d", ierr)
+
+ def finalize(self):
+ ierr = self.api.run_finalize_t2d(self.id)
+ self.handle_error("run_finalize_t2d", ierr)
+
+ def save_state(self, state = None):
+ nbpoints = self.get_integer('MODEL.NPOIN')
+ if state is None:
+ state = Telemac2DState(nbpoints)
+ elif state.nbpoints != nbpoints:
+ raise Exception("Allocated state size (%d) is different from the size "
+ "of Telemac2D state (%d)" % (state.nbpoints, nbpoints))
+ for i in xrange(nbpoints):
+ #state.h[i] = self.get_double('MODEL.WATERDEPTH', i+1)
+ #state.u[i] = self.get_double('MODEL.VELOCITYU' , i+1)
+ #state.v[i] = self.get_double('MODEL.VELOCITYV' , i+1)
+ # The following lines are an optimization of the previous ones,
+ # to be replaced by a proper array copy
+ state.h[i] = self.api.get_double_t2d(self.id, 'MODEL.WATERDEPTH', i+1, 0, 0)[0]
+ state.u[i] = self.api.get_double_t2d(self.id, 'MODEL.VELOCITYU' , i+1, 0, 0)[0]
+ state.v[i] = self.api.get_double_t2d(self.id, 'MODEL.VELOCITYV' , i+1, 0, 0)[0]
+ return state
+
+ def restore_state(self, state):
+ nbpoints = self.get_integer('MODEL.NPOIN')
+ if state.nbpoints != nbpoints:
+ raise Exception("Allocated state size (%d) is different from the size "
+ "of Telemac2D state (%d)" % (state.nbpoints, nbpoints))
+ for i in xrange(nbpoints):
+ #self.set_double('MODEL.WATERDEPTH', state.h[i], i+1)
+ #self.set_double('MODEL.VELOCITYU' , state.u[i], i+1)
+ #self.set_double('MODEL.VELOCITYV' , state.v[i], i+1)
+ # The following lines are an optimization of the previous ones,
+ # to be replaced by a proper array copy
+ self.api.set_double_t2d(self.id, 'MODEL.WATERDEPTH', state.h[i], i+1, 0, 0)
+ self.api.set_double_t2d(self.id, 'MODEL.VELOCITYU' , state.u[i], i+1, 0, 0)
+ self.api.set_double_t2d(self.id, 'MODEL.VELOCITYV' , state.v[i], i+1, 0, 0)
+
+
+class Telemac2DState:
+ def __init__(self, nbpoints):
+ self.nbpoints = nbpoints
+ self.h = [0.0] * nbpoints
+ self.u = [0.0] * nbpoints
+ self.v = [0.0] * nbpoints
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+# --- Python files ---
+
+SET(PYFILES
+ __init__.py
+ configuration_telemac2d.py
+ prefs_telemac2d.py
+ prefs.py
+ telemac2d_V6_cata.py
+ appli.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${PYFILES}" ${SALOME_INSTALL_PYTHON}/salome/hydro/telemac2d/eficas)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+import re
+
+from PyQt4.QtGui import QMessageBox
+
+import salome
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+
+from salome.kernel.logger import Logger
+from salome.kernel import termcolor
+logger = Logger("salome.hydro.telemac2d.eficas.appli",
+ color = termcolor.GREEN_FG)
+
+import eficasSalome
+
+from salome.hydro.study import HydroStudyEditor
+
+class EficasForTelemac2DAppli(eficasSalome.MyEficas):
+ """
+ This class launches Eficas and adds entries for the created files in
+ HYDRO component in the study tree. The messages in this class are in
+ french because they are displayed in Eficas interface.
+
+ :type fichier: string
+ :param fichier: path of an Eficas file to open
+
+ """
+ def __init__(self, fichier = None, version = None):
+ self.ed = HydroStudyEditor()
+ self.codedir = os.path.dirname(__file__)
+ sys.path[:0] = [self.codedir]
+ eficasSalome.MyEficas.__init__(self, sgPyQt.getDesktop(),
+ "telemac2d",
+ fichier, version = version)
+ sgPyQt.createView("Eficas Telemac2D", self)
+
+ def addJdcInSalome(self, jdcPath):
+ """
+ Add the newly created file in Salome study
+ """
+ try:
+ self.ed.find_or_create_telemac2d_case(jdcPath)
+ except Exception, exc:
+ msgError = "Can't add file to Salome study tree"
+ logger.exception(msgError)
+ QMessageBox.warning(self, self.tr("Warning"),
+ self.tr("%s. Reason:\n%s\n\nSee logs for "
+ "more details." % (msgError, exc)))
+ salome.sg.updateObjBrowser(0)
+
+ def closeEvent(self, event):
+ while self.codedir in sys.path:
+ sys.path.remove(self.codedir)
+ eficasSalome.MyEficas.closeEvent(self, event)
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+
+from Editeur.catadesc import CatalogDescription
+from InterfaceQT4.configuration import CONFIG_BASE
+
+class CONFIG(CONFIG_BASE):
+
+ def __init__(self, appli, repIni):
+ """
+ This class stores the configuration parameters for Eficas
+ """
+ CONFIG_BASE.__init__(self, appli, repIni)
+
+ # Configuration parameters
+ self.savedir = os.getenv("HOME")
+ self.catalogues = (CatalogDescription("telemac2d_V6",
+ os.path.join(repIni, "telemac2d_V6_cata.py")),)
+ self.lang = 'fr'
+
+ def save_params(self):
+ pass
+
+def make_config(appli, rep):
+ return CONFIG(appli, rep)
+
+def make_config_style(appli, rep):
+ return None
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+code = "telemac2d"
--- /dev/null
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import sys
+
+repIni = os.path.dirname(__file__)
+INSTALLDIR = os.getenv("EFICAS_ROOT")
--- /dev/null
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2013 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import types
+from Accas import *
+
+class Tuple:
+ def __init__(self,ntuple):
+ self.ntuple=ntuple
+
+ def __convert__(self,valeur):
+ if type(valeur) == types.StringType:
+ return None
+ if len(valeur) != self.ntuple:
+ return None
+ return valeur
+
+ def info(self):
+ return "Tuple de %s elements" % self.ntuple
+
+ __repr__=info
+ __str__=info
+
+JdC = JDC_CATA(regles = (UN_PARMI('TELEMAC2D',)),
+ )
+
+TELEMAC2D = PROC(
+ nom = "TELEMAC2D", op = None,
+ fr = u"Définition d'un cas d'étude Telemac2D",
+ ang = u"Definition of a Telemac2D study case",
+ FICHIER_CAS = SIMP(statut = "o", typ = 'Fichier',
+ fr = u"Fichier de description du cas",
+ ang = u"Case description file"),
+ FICHIER_GEOMETRIE = SIMP(statut = "f", typ = 'Fichier',
+ fr = u"Fichier de géométrie",
+ ang = u"Geometry file"),
+ FICHIER_CONDITIONS_LIMITES = SIMP(statut = "f", typ = 'Fichier',
+ fr = u"Fichier de conditions limites",
+ ang = u"Boundary conditions file"),
+ FICHIER_DICO = SIMP(statut = "f", typ = 'Fichier',
+ fr = "Fichier Dico",
+ ang = u"Dictionary file"),
+ FICHIER_FORTRAN_UTILISATEUR = SIMP(statut = "f", typ = 'Fichier',
+ fr = "Fichier Fortran utilisateur",
+ ang = u"Fortran user file"),
+ RESULTAT = SIMP(statut = "f", typ = ('Fichier', 'Tous les fichiers (*)', "Sauvegarde"),
+ fr = u"Fichier de résultat",
+ ang = u"Result file"),
+ VARIABLE_SORTIE = FACT(statut = 'f', max = '**',
+ fr = u"Variable de sortie du calcul",
+ ang = u"Computation output variable",
+ NOM = SIMP(statut = "o", typ = 'TXM',
+ fr = u"Nom de la variable",
+ ang = u"Variable name"),
+ VARIABLE_T2D = SIMP(statut = "o", typ = 'TXM',
+ fr = u'Variable Telemac2D (ex : "MODEL.VELOCITYU(2443)")',
+ ang = u'Telemac2D variable (ex : "MODEL.VELOCITYU(2443)")'),
+ ),
+ VARIABLE_ENTREE = FACT(statut = 'f', max = '**',
+ fr = u"Variable d'entrée du calcul",
+ ang = u"Computation input variable",
+ NOM = SIMP(statut = "o", typ = 'TXM',
+ fr = u"Nom de la variable",
+ ang = u"Variable name"),
+ VARIABLE_MODELE_T2D = FACT(statut = "o",
+ fr = u'Variable du modèle Telemac2D',
+ ang = u'Telemac2D model variable',
+ NOM_VARIABLE_MODELE = SIMP(statut = "o", typ = 'TXM',
+ fr = u'Nom de la variable du modèle (ex: "MODEL.DEBIT")',
+ ang = u'Model variable name (ex: "MODEL.DEBIT")'),
+ ZONE_DE_DEFINITION = FACT(statut = "o",
+ ang = u'Variable definition area',
+ fr = u'Zone de définition de la variable',
+ regles = (UN_PARMI('INDICE', 'POLYGONE')),
+ INDICE = SIMP(statut = "f", typ = "I",
+ ang = "Index of the point / border",
+ fr = u"Indice du point ou de la frontière",
+ ),
+ POLYGONE = SIMP(statut = "f",
+ typ = Tuple(2),
+ max = '**',
+ fr = u"Liste des sommets (coordonnées X,Y) du "
+ u"polygone définissant le contour de la zone",
+ ang = "List of points (X,Y coordinates) of the "
+ "polygon defining the border of the area",
+ validators = VerifTypeTuple(('R', 'R')),
+ ),
+ ),
+ ),
+ ),
+)
--- /dev/null
+# Copyright (C) 2012-2015 EDF
+#
+# This file is part of SALOME HYDRO module.
+#
+# SALOME HYDRO module is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SALOME HYDRO module 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SALOME HYDRO module. If not, see <http://www.gnu.org/licenses/>.
+
+import math
+from itertools import izip,cycle
+
+EPS = 10**-9
+
+def is_in_polygon(x,y,poly):
+ """
+ Returns True if the point (x,y) is in the polygon poly
+ Warning the polygon must be distinct (no indentical points)
+ """
+ angle = -1.0
+ while True:
+ angle += 1.0
+ if(angle > 360.0):
+ # Special case of a point on the contour
+ return True
+ a = math.cos(angle*math.pi/180.0)
+ b = math.sin(angle*math.pi/180.0)
+ nsect = 0
+ # Loop on all the segment of the polygon
+ # TODO: Pythonize that loop
+ n = len(poly)
+ next_angle = False
+ for i in range(0,n):
+ xdep,ydep = poly[i]
+ # next element
+ xarr,yarr = poly[(i+1) % n]
+ # Case the point is on the polygon
+ if (abs(x-xdep)<EPS) and (abs(y-ydep)<EPS):
+ nsect = 1
+ break
+ det = a*(ydep-yarr) - b*(xdep-xarr)
+ if abs(det) < EPS:
+ next_angle = True
+ break
+
+ mu = ( (xdep-x)*(ydep-yarr)-(ydep-y)*(xdep-xarr) ) / det
+ llambda = ( a *(ydep-y )- b *(xdep-x ) ) / det
+ # if the intersection point is a vertex, increases the angle
+ # otherwise the point would be counted twice instead of just once
+ if ((abs(x+a*mu-xdep) <= EPS and abs(y+b*mu-ydep) <= EPS) or\
+ (abs(x+a*mu-xarr) <= EPS and abs(y+b*mu-yarr) <= EPS)):
+ next_angle = True
+ break
+ if(mu >= -EPS and llambda >= -EPS and llambda <= (1.0+EPS)):
+ nsect += 1
+ # If
+ if not next_angle:
+ break
+
+ return (nsect % 2) == 1
+
+def get_list_points_in_polygon(t2d_inst, poly):
+ """
+ Returns the list of points from the mesh that are in the polygon poly
+
+ t2d_inst : is the Telemac2D instance
+ poly : is a list of (x,y) coordiantes defining the polygon
+ """
+ # Get the number of point in the mesh
+ npoin = t2d_inst.get_integer('MODEL.NPOIN')
+ point_in_polygon = []
+
+ # Loop on all mesh points
+ for i in range(1, npoin + 1):
+ # Get the cooridnates of point i
+ x = t2d_inst.get_double('MODEL.X', i)
+ y = t2d_inst.get_double('MODEL.Y', i)
+ # If point is in polygon add it to the list of points
+ if is_in_polygon(x,y,poly):
+ point_in_polygon.append(i)
+ return point_in_polygon
+
+if __name__ == "__main__":
+ l = [(0.0,0.0),(0.0,1.0),(1.0,2.0),(2.0,2.0),(2.0,0.0)]
+ print is_in_polygon(1.0,1.0,l),True
+ print is_in_polygon(0.0,0.0,l),True
+ print is_in_polygon(-1.0,1.0,l),False
+ print is_in_polygon(2.0,0.0,l),True
