gnu/packages/simulation.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2017, 2018 Paul Garlick <pgarlick@tourbillion-technology.com>
   3 ;;;
   4 ;;; This file is part of GNU Guix.
   5 ;;;
   6 ;;; GNU Guix is free software; you can redistribute it and/or modify it
   7 ;;; under the terms of the GNU General Public License as published by
   8 ;;; the Free Software Foundation; either version 3 of the License, or (at
   9 ;;; your option) any later version.
  10 ;;;
  11 ;;; GNU Guix is distributed in the hope that it will be useful, but
  12 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ;;; GNU General Public License for more details.
  15 ;;;
  16 ;;; You should have received a copy of the GNU General Public License
  17 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 (define-module (gnu packages simulation)
  20   #:use-module (gnu packages)
  21   #:use-module (gnu packages algebra)
  22   #:use-module (gnu packages base)
  23   #:use-module (gnu packages bash)
  24   #:use-module (gnu packages bison)
  25   #:use-module (gnu packages boost)
  26   #:use-module (gnu packages check)
  27   #:use-module (gnu packages cmake)
  28   #:use-module (gnu packages compression)
  29   #:use-module (gnu packages flex)
  30   #:use-module (gnu packages gettext)
  31   #:use-module (gnu packages gcc)
  32   #:use-module (gnu packages gl)
  33   #:use-module (gnu packages graphics)
  34   #:use-module (gnu packages gtk)
  35   #:use-module (gnu packages linux)
  36   #:use-module (gnu packages m4)
  37   #:use-module (gnu packages maths)
  38   #:use-module (gnu packages mpi)
  39   #:use-module (gnu packages multiprecision)
  40   #:use-module (gnu packages ncurses)
  41   #:use-module (gnu packages pkg-config)
  42   #:use-module (gnu packages python)
  43   #:use-module (gnu packages readline)
  44   #:use-module (gnu packages tls)
  45   #:use-module (gnu packages version-control)
  46   #:use-module (gnu packages xml)
  47   #:use-module (gnu packages xorg)
  48   #:use-module (guix download)
  49   #:use-module (guix build utils)
  50   #:use-module (guix build-system cmake)
  51   #:use-module (guix build-system gnu)
  52   #:use-module (guix build-system python)
  53   #:use-module ((guix licenses) #:prefix license:)
  54   #:use-module (guix packages)
  55   #:use-module (guix utils)
  56   #:use-module (ice-9 ftw)
  57   #:use-module (ice-9 regex)
  58   #:use-module (srfi srfi-1))
  59
  60 (define-public openfoam
  61   (package
  62     (name "openfoam")
  63     (version "4.1")
  64     (source
  65      (origin
  66        (method url-fetch)
  67        (uri (string-append
  68              "http://dl.openfoam.org/source/"
  69              (string-map (lambda (x) (if (eq? x #\.) #\- x)) version)))
  70        (file-name (string-append name "-" version ".tar.gz"))
  71        (sha256
  72         (base32 "0cgxh4h2hf50qbvvdg5miwc2nympb0nrv3md96vb3gbs9vk8vq9d"))
  73        (patches (search-patches "openfoam-4.1-cleanup.patch"))
  74        (modules '((guix build utils)))
  75        (snippet
  76         '(begin
  77            ;; Include <sys/sysmacros.h>, which is where glibc >= 2.28 provides
  78            ;; 'major' and 'minor'.
  79            (substitute* "src/OSspecific/POSIX/fileStat.C"
  80              (("#include <unistd\\.h>")
  81               "#include <unistd.h>\n#include <sys/sysmacros.h>\n"))
  82            #t))))
  83     (build-system gnu-build-system)
  84     (inputs
  85      `(("boost" ,boost)
  86        ("cgal" ,cgal)
  87        ("flex" ,flex)
  88        ("git" ,git)
  89        ("gmp" ,gmp)
  90        ("libxt" ,libxt)
  91        ("metis" ,metis)
  92        ("mpfr" ,mpfr)
  93        ("ncurses" ,ncurses)
  94        ("readline" ,readline)
  95        ("scotch" ,pt-scotch32)
  96        ("zlib" ,zlib)))
  97     (native-inputs
  98      `(("bison" ,bison)))
  99     (propagated-inputs
 100      `(("gzip" ,gzip)
 101        ("gnuplot" ,gnuplot)
 102        ("openmpi" ,openmpi)))
 103     (outputs '("debug"                  ;~60MB
 104                "out"))
 105     (arguments
 106      `( ;; Executable files and shared libraries are located in the 'platforms'
 107        ;; subdirectory.
 108        #:strip-directories (list (string-append
 109                                   "lib/OpenFOAM-" ,version
 110                                   "/platforms/linux64GccDPInt32Opt/bin")
 111                                  (string-append
 112                                   "lib/OpenFOAM-" ,version
 113                                   "/platforms/linux64GccDPInt32Opt/lib"))
 114        #:tests? #f                                ; no tests to run
 115
 116        #:modules ((ice-9 ftw)
 117                   (ice-9 regex)
 118                   (guix build gnu-build-system)
 119                   (guix build utils))
 120
 121        #:phases (modify-phases %standard-phases
 122                   (add-after 'unpack 'rename-build-directory
 123                     (lambda _
 124                       (chdir "..")
 125                       ;; Use 'OpenFOAM-version' convention to match the file
 126                       ;; name expectations in the build phase.
 127                       (let ((unpack-dir (string-append
 128                                          (getcwd) "/"
 129                                          (list-ref (scandir (getcwd) (lambda (name)
 130                                                                        (string-match "^OpenFOAM" name))) 0)))
 131                             (build-dir (string-append
 132                                         (getcwd) "/OpenFOAM-" ,version)))
 133                         (rename-file unpack-dir build-dir) ; rename build directory
 134                         (chdir (basename build-dir))) ; move to build directory
 135                       #t))
 136                   (delete 'configure)             ; no configure phase
 137                   (replace 'build
 138                     (lambda _
 139                       (let ((libraries '("boost" "cgal" "gmp" "metis" "mpfr" "scotch")))
 140                         ;; set variables to define store paths
 141                         (for-each (lambda (library)
 142                                     (setenv (string-append
 143                                              (string-upcase library) "_ROOT")
 144                                             (assoc-ref %build-inputs library))) libraries))
 145                       ;; set variables to define package versions
 146                       (setenv "SCOTCHVERSION" ,(package-version scotch))
 147                       (setenv "METISVERSION" ,(package-version metis))
 148                       ;; set variable to pass extra 'rpath' arguments to linker
 149                       (setenv "LDFLAGS"
 150                               (string-append
 151                                "-Wl,"
 152                                "-rpath=" %output "/lib/OpenFOAM-" ,version
 153                                "/platforms/linux64GccDPInt32Opt/lib,"
 154                                "-rpath=" %output "/lib/OpenFOAM-" ,version
 155                                "/platforms/linux64GccDPInt32Opt/lib/dummy"))
 156                       ;; compile OpenFOAM libraries and applications
 157                       (zero? (system (format #f
 158                                              "source ./etc/bashrc && ./Allwmake -j~a"
 159                                              (parallel-job-count))))))
 160                   (add-after 'build 'update-configuration-files
 161                     (lambda _
 162                       ;; record store paths and package versions in
 163                       ;; configuration files
 164                       (substitute* "etc/config.sh/CGAL"
 165                         (("$BOOST_ROOT") (getenv "BOOST_ROOT")))
 166                       (substitute* "etc/config.sh/CGAL"
 167                         (("$CGAL_ROOT") (getenv "CGAL_ROOT")))
 168                       (substitute* "etc/config.sh/metis"
 169                         (("$METIS_ROOT") (getenv "METIS_ROOT")))
 170                       (substitute* "etc/config.sh/metis"
 171                         (("$METISVERSION") (getenv "METISVERSION")))
 172                       (substitute* "etc/config.sh/scotch"
 173                         (("$SCOTCH_ROOT") (getenv "SCOTCH_ROOT")))
 174                       (substitute* "etc/config.sh/scotch"
 175                         (("$SCOTCHVERSION") (getenv "SCOTCHVERSION")))
 176                       (substitute* "etc/config.sh/settings"
 177                         (("$GMP_ROOT") (getenv "GMP_ROOT")))
 178                       (substitute* "etc/config.sh/settings"
 179                         (("$MPFR_ROOT") (getenv "MPFR_ROOT")))
 180                       ;; reset lockDir variable to refer to write-enabled
 181                       ;; directory
 182                       (substitute* "wmake/wmake"
 183                         (("        lockDir=.*$")
 184                          "        lockDir=$HOME/.$WM_PROJECT/.wmake\n"))
 185                       (substitute* "wmake/wmakeScheduler"
 186                         (("lockDir=.*$")
 187                          "lockDir=$HOME/.$WM_PROJECT/.wmake\n"))
 188                       (substitute* "wmake/wmakeSchedulerUptime"
 189                         (("lockDir=.*$")
 190                          "lockDir=$HOME/.$WM_PROJECT/.wmake\n"))
 191                       #t))
 192                   (add-after 'build 'cleanup
 193                     ;; Avoid unncessary, voluminous object and dep files.
 194                     (lambda _
 195                       (delete-file-recursively
 196                        "platforms/linux64GccDPInt32Opt/src")
 197                       (delete-file-recursively
 198                        "platforms/linux64GccDPInt32OptSYSTEMOPENMPI")
 199                       (for-each delete-file (find-files "." "\\.o$"))
 200                       #t))
 201                   (replace 'install
 202                     (lambda _
 203                       ;; use 'OpenFOAM-version' convention
 204                       (let ((install-dir (string-append
 205                                           %output "/lib/OpenFOAM-" ,version)))
 206                         (mkdir-p install-dir)     ; create install directory
 207                         ;; move contents of build directory to install directory
 208                         (copy-recursively "." install-dir))))
 209                   (add-after 'install 'add-symbolic-link
 210                     (lambda _
 211                       ;; add symbolic link for standard 'bin' directory
 212                       (symlink
 213                        (string-append "./lib/OpenFOAM-" ,version
 214                                       "/platforms/linux64GccDPInt32Opt/bin")
 215                        (string-append %output "/bin"))
 216                       #t)))))
 217     ;; Note:
 218     ;;  Tutorial files are installed read-only in /gnu/store.
 219     ;;  To allow write permissions on files copied from the store a
 220     ;;  'chmod' step is needed before running the applications.  For
 221     ;;  example, from a user's login:
 222     ;;  $ source $GUIX_PROFILE/lib/OpenFOAM-4.1/etc/bashrc
 223     ;;  $ mkdir -p $FOAM_RUN
 224     ;;  $ cd $FOAM_RUN
 225     ;;  $ cp -r $FOAM_TUTORIALS/incompressible/simpleFoam/pitzDaily .
 226     ;;  $ cd pitzDaily
 227     ;;  $ chmod -R u+w .
 228     ;;  $ blockMesh
 229     (synopsis "Framework for numerical simulation of fluid flow")
 230     (description "OpenFOAM provides a set of solvers and methods for tackling
 231 problems in the field of Computational Fluid Dynamics (CFD).  It is written in
 232 C++.  Governing equations such as the Navier-Stokes equations can be solved in
 233 integral form.  Physical processes such as phase change, droplet transport and
 234 chemical reaction can be modelled.  Numerical methods are included to deal with
 235 sharp gradients, such as those encountered in flows with shock waves and flows
 236 with gas/liquid interfaces.  Large problems may be split into smaller, connected
 237 problems for efficient solution on parallel systems.")
 238     (license license:gpl3+)
 239     (home-page "https://openfoam.org")))
 240
 241 (define-public python-fenics-dijitso
 242   (package
 243     (name "python-fenics-dijitso")
 244     (version "2018.1.0")
 245     (source
 246       (origin
 247         (method url-fetch)
 248         (uri (pypi-uri "fenics-dijitso" version))
 249         (sha256
 250           (base32
 251             "1qax2f52qsjbd1h5lk5i5shp448qlakxabjjybrfc1w823p0yql9"))))
 252     (build-system python-build-system)
 253     (inputs
 254      `(("openmpi" ,openmpi)
 255        ("python-numpy" ,python-numpy)))
 256     (native-inputs
 257      `(("python-pytest-cov" ,python-pytest-cov)))
 258     (propagated-inputs
 259      `(("python-mpi4py" ,python-mpi4py)))
 260     (arguments
 261      `(#:phases
 262        (modify-phases %standard-phases
 263          (add-after 'build 'mpi-setup
 264            ,%openmpi-setup)
 265          (replace 'check
 266            (lambda _
 267              (setenv "HOME" "/tmp")
 268              (setenv "PYTHONPATH"
 269                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 270              (with-directory-excursion "test"
 271                (invoke "./runtests.sh"))
 272              #t)))))
 273     (home-page "https://bitbucket.org/fenics-project/dijitso/")
 274     (synopsis "Distributed just-in-time building of shared libraries")
 275     (description
 276       "Dijitso provides a core component of the @code{FEniCS} framework,
 277 namely the just-in-time compilation of C++ code that is generated from
 278 Python modules.  It is called from within a C++ library, using ctypes
 279 to import the dynamic shared library directly.
 280
 281 As long as the compiled code can provide a simple factory function to
 282 a class implementing a predefined C++ interface, there is no limit to
 283 the complexity of that interface.  Parallel support depends on the
 284 @code{mpi4py} interface.")
 285     (license license:lgpl3+)))
 286
 287 (define-public python-fenics-ufl
 288   (package
 289     (name "python-fenics-ufl")
 290     (version "2018.1.0")
 291     (source
 292       (origin
 293         (method url-fetch)
 294         (uri (pypi-uri "fenics-ufl" version))
 295         (sha256
 296           (base32
 297             "1fq8yc86s1s3c8c0b1rc2vf265q0hrkzg57100fg1nghcz0p4vla"))))
 298     (build-system python-build-system)
 299     (inputs
 300      `(("python-numpy" ,python-numpy)))
 301     (native-inputs
 302      `(("python-pytest" ,python-pytest)))
 303     (arguments
 304      '(#:phases
 305        (modify-phases %standard-phases
 306          (replace 'check
 307            (lambda _
 308              (setenv "PYTHONPATH"
 309                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 310              (with-directory-excursion "test"
 311                (invoke "py.test"))
 312              #t)))))
 313     (home-page "https://bitbucket.org/fenics-project/ufl/")
 314     (synopsis "Unified language for form-compilers")
 315     (description "The Unified Form Language (UFL) is a domain specific
 316 language for declaration of finite element discretizations of
 317 variational forms.  More precisely, it defines a flexible interface
 318 for choosing finite element spaces and defining expressions for weak
 319 forms in a notation close to mathematical notation.
 320
 321 UFL is part of the FEniCS Project.")
 322     (license license:lgpl3+)))
 323
 324 (define-public python-fenics-fiat
 325   (package
 326     (name "python-fenics-fiat")
 327     (version "2018.1.0")
 328     (source
 329       (origin
 330         (method url-fetch)
 331         (uri (pypi-uri "fenics-fiat" version))
 332         (sha256
 333           (base32
 334             "0fmjd93r6bwf6xs8csw86qzphrnr66xwv7f372w59gmq8mg6rljc"))))
 335     (build-system python-build-system)
 336     (native-inputs
 337      `(("python-pytest" ,python-pytest)))
 338     (propagated-inputs
 339      `(("python-numpy" ,python-numpy)
 340        ("python-sympy" ,python-sympy)))
 341     (arguments
 342      '(#:phases
 343        (modify-phases %standard-phases
 344          (replace 'check
 345            (lambda _
 346              (setenv "PYTHONPATH"
 347                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 348              (with-directory-excursion "test"
 349                (invoke "py.test" "unit/"))
 350              #t)))))
 351     (home-page "https://bitbucket.org/fenics-project/fiat/")
 352     (synopsis "Tabulation of finite element function spaces")
 353     (description
 354       "The FInite element Automatic Tabulator (FIAT) supports
 355 generation of arbitrary order instances of the Lagrange elements on
 356 lines, triangles, and tetrahedra.  It is also capable of generating
 357 arbitrary order instances of Jacobi-type quadrature rules on the same
 358 element shapes.  Further, H(div) and H(curl) conforming finite element
 359 spaces such as the families of Raviart-Thomas, Brezzi-Douglas-Marini
 360 and Nedelec are supported on triangles and tetrahedra.  Upcoming
 361 versions will also support Hermite and nonconforming elements.
 362
 363 FIAT is part of the FEniCS Project.")
 364     (license license:lgpl3+)))
 365
 366 (define-public python-fenics-ffc
 367   (package
 368     (name "python-fenics-ffc")
 369     (version "2018.1.0")
 370     (source
 371       (origin
 372         (method url-fetch)
 373         (uri (pypi-uri "fenics-ffc" version))
 374         (sha256
 375           (base32
 376             "1b2ia5vlkw298x7rf0k2p3ihlpwkwgc98p3s6sbpds3hqmfrzdz9"))))
 377     (build-system python-build-system)
 378     (native-inputs
 379      `(("python-pytest" ,python-pytest)))
 380     (propagated-inputs
 381      `(("python-fenics-dijitso" ,python-fenics-dijitso)
 382        ("python-fenics-fiat" ,python-fenics-fiat)
 383        ("python-fenics-ufl" ,python-fenics-ufl)))
 384     (arguments
 385      '(#:phases
 386        (modify-phases %standard-phases
 387          (replace 'check
 388            (lambda _
 389              (setenv "HOME" (getcwd))
 390              (setenv "PYTHONPATH"
 391                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 392              (with-directory-excursion "test"
 393                ;; FIXME: the tests in subdirectory
 394                ;; 'unit/ufc/finite_element' require the ffc_factory
 395                ;; extension module.  This module, located in the 'libs'
 396                ;; subdirectory, needs to be built and made accessible
 397                ;; prior to running the tests.
 398                (invoke "py.test" "unit/" "--ignore=unit/ufc/")
 399                (with-directory-excursion "uflacs"
 400                  (invoke "py.test" "unit/")))
 401              #t)))))
 402     (home-page "https://bitbucket.org/fenics-project/ffc/")
 403     (synopsis "Compiler for finite element variational forms")
 404     (description "The FEniCS Form Compiler (FFC) is a compiler for
 405 finite element variational forms.  From a high-level description of
 406 the form, it generates efficient low-level C++ code that can be used
 407 to assemble the corresponding discrete operator (tensor).  In
 408 particular, a bilinear form may be assembled into a matrix and a
 409 linear form may be assembled into a vector.  FFC may be used either
 410 from the command line (by invoking the @code{ffc} command) or as a
 411 Python module (@code{import ffc}).
 412
 413 FFC is part of the FEniCS Project.")
 414     ;; There are two files released with a public domain licence;
 415     ;; ufc.h and ufc_geometry.h, in subdirectory 'ffc/backends/ufc'.
 416     (license (list license:public-domain license:lgpl3+))))
 417
 418 (define-public fenics-dolfin
 419   (package
 420     (name "fenics-dolfin")
 421     (version "2018.1.0.post1")
 422     (source
 423       (origin
 424         (method url-fetch)
 425         (uri (string-append
 426               "https://bitbucket.org/fenics-project/dolfin/get/"
 427               version ".tar.gz"))
 428         (file-name (string-append name "-" version ".tar.gz"))
 429         (sha256
 430           (base32
 431            "12zkk8j3xsg6l8p0ggwsl03084vlcivw4h99b7z9kndg7k89b3ya"))
 432         (modules '((guix build utils)))
 433         (snippet
 434          '(begin
 435             ;; Make sure we don't use the bundled test framework.
 436             (delete-file-recursively "test/unit/cpp/catch")
 437             (substitute* "test/unit/cpp/main.cpp"
 438               ;; Use standard search paths for 'catch' header file.
 439               (("#include.*")
 440                "#include <catch.hpp>\n"))
 441             (substitute* "test/unit/cpp/CMakeLists.txt"
 442               ;; Add extra include directories required by the unit tests.
 443               (("(^target_link_libraries.*)" line)
 444                (string-append line "\n"
 445                               "target_include_directories("
 446                               "unittests PRIVATE "
 447                               "${DOLFIN_SOURCE_DIR} "
 448                               "${DOLFIN_SOURCE_DIR}/dolfin "
 449                               "${DOLFIN_BINARY_DIR})\n"))
 450               (("(^set\\(CATCH_INCLUDE_DIR ).*(/catch\\))" _ front back)
 451                (string-append front
 452                               "$ENV{CATCH_DIR}"
 453                               "/include" back "\n")))
 454             (substitute* "demo/CMakeLists.txt"
 455               ;; Add extra include directories required by the demo tests.
 456               (("(^#find_package.*)" line)
 457                (string-append line "\n"
 458                               "include_directories("
 459                               "${DOLFIN_SOURCE_DIR} "
 460                               "${DOLFIN_SOURCE_DIR}/dolfin "
 461                               "${DOLFIN_BINARY_DIR})\n")))
 462             #t))))
 463     (build-system cmake-build-system)
 464     (inputs
 465      `(("blas" ,openblas)
 466        ("boost" ,boost)
 467        ("eigen" ,eigen)
 468        ("hdf5" ,hdf5-parallel-openmpi)
 469        ("lapack" ,lapack)
 470        ("libxml2" ,libxml2)
 471        ("openmpi" ,openmpi)
 472        ("python" ,python-3)
 473        ("scotch" ,pt-scotch32)
 474        ("suitesparse" ,suitesparse)
 475        ("sundials" ,sundials-openmpi)
 476        ("zlib" ,zlib)))
 477     (native-inputs
 478      `(("catch" ,catch-framework2)
 479        ("pkg-config" ,pkg-config)))
 480     (propagated-inputs
 481      `(("ffc" ,python-fenics-ffc)
 482        ("petsc" ,petsc-openmpi)
 483        ("slepc" ,slepc-openmpi)))
 484     (arguments
 485      `(#:configure-flags
 486        `("-DDOLFIN_ENABLE_DOCS:BOOL=OFF"
 487          "-DDOLFIN_ENABLE_HDF5:BOOL=ON"
 488          "-DDOLFIN_ENABLE_MPI:BOOL=ON"
 489          "-DDOLFIN_ENABLE_PARMETIS:BOOL=OFF"
 490          "-DDOLFIN_ENABLE_SCOTCH:BOOL=ON"
 491          "-DDOLFIN_ENABLE_SUNDIALS:BOOL=ON"
 492          "-DDOLFIN_ENABLE_TRILINOS:BOOL=OFF")
 493        #:phases
 494        (modify-phases %standard-phases
 495          (add-after 'patch-usr-bin-file 'mpi-setup
 496            ,%openmpi-setup)
 497          (add-after 'patch-source-shebangs 'set-paths
 498            (lambda _
 499              ;; Define paths to store locations.
 500              (setenv "BLAS_DIR" (assoc-ref %build-inputs "blas"))
 501              (setenv "CATCH_DIR" (assoc-ref %build-inputs "catch"))
 502              (setenv "LAPACK_DIR" (assoc-ref %build-inputs "lapack"))
 503              (setenv "PETSC_DIR" (assoc-ref %build-inputs "petsc"))
 504              (setenv "SLEPC_DIR" (assoc-ref %build-inputs "slepc"))
 505              (setenv "SCOTCH_DIR" (assoc-ref %build-inputs "scotch"))
 506              (setenv "SUNDIALS_DIR" (assoc-ref %build-inputs "sundials"))
 507              (setenv "UMFPACK_DIR" (assoc-ref %build-inputs "suitesparse"))
 508              #t))
 509          (add-before 'check 'pre-check
 510            (lambda _
 511              ;; The Dolfin repository uses git-lfs, whereby web links are
 512              ;; substituted for large files.  Guix does not currently support
 513              ;; git-lfs, so only the links are downloaded.  The tests that
 514              ;; require the absent meshes cannot run and are skipped.
 515              ;;
 516              ;; Two other serial tests fail and are skipped.
 517              ;; i) demo_stokes-iterative_serial,
 518              ;;   The MPI_Comm_rank() function was called before MPI_INIT was
 519              ;;   invoked
 520              ;; ii) demo_multimesh-stokes_serial:
 521              ;;   Warning: Found no facets matching domain for boundary
 522              ;;   condition.
 523              ;;
 524              ;; One mpi test fails and is skipped.
 525              ;; i) demo_stokes-iterative_mpi:
 526              ;;   The MPI_Comm_rank() function was called before MPI_INIT was
 527              ;;   invoked
 528              (call-with-output-file "CTestCustom.cmake"
 529                (lambda (port)
 530                  (display
 531                    (string-append
 532                     "set(CTEST_CUSTOM_TESTS_IGNORE "
 533                     "demo_bcs_serial "
 534                     "demo_bcs_mpi "
 535                     "demo_eigenvalue_serial "
 536                     "demo_eigenvalue_mpi "
 537                     "demo_navier-stokes_serial "
 538                     "demo_navier-stokes_mpi "
 539                     "demo_stokes-taylor-hood_serial "
 540                     "demo_stokes-taylor-hood_mpi "
 541                     "demo_subdomains_serial "
 542                     "demo_advection-diffusion_serial "
 543                     "demo_advection-diffusion_mpi "
 544                     "demo_auto-adaptive-navier-stokes_serial "
 545                     "demo_contact-vi-snes_serial "
 546                     "demo_contact-vi-snes_mpi "
 547                     "demo_contact-vi-tao_serial "
 548                     "demo_contact-vi-tao_mpi "
 549                     "demo_curl-curl_serial "
 550                     "demo_curl-curl_mpi "
 551                     "demo_dg-advection-diffusion_serial "
 552                     "demo_dg-advection-diffusion_mpi "
 553                     "demo_elasticity_serial "
 554                     "demo_elasticity_mpi "
 555                     "demo_elastodynamics_serial "
 556                     "demo_elastodynamics_mpi "
 557                     "demo_lift-drag_serial "
 558                     "demo_lift-drag_mpi "
 559                     "demo_mesh-quality_serial "
 560                     "demo_mesh-quality_mpi "
 561                     "demo_multimesh-stokes_serial "
 562                     "demo_stokes-iterative_serial "
 563                     "demo_stokes-iterative_mpi "
 564                     ")\n") port)))
 565              #t))
 566          (replace 'check
 567            (lambda _
 568              (and (invoke "make" "unittests")
 569                   (invoke "make" "demos")
 570                   (invoke "ctest" "-R" "unittests")
 571                   (invoke "ctest" "-R" "demo" "-R" "serial")
 572                   (invoke "ctest" "-R" "demo" "-R" "mpi")))))))
 573     (home-page "https://bitbucket.org/fenics-project/dolfin/")
 574     (synopsis "Problem solving environment for differential equations")
 575     (description
 576       "DOLFIN is a computational framework for finding numerical
 577 solutions to problems described by differential equations.  Numerical
 578 models in DOLFIN are constructed using general families of finite
 579 elements.  Data structures are provided for discretizing the governing
 580 system on a computational mesh.  A compact syntax, similar to
 581 mathematical notation, is made available for defining function spaces
 582 and expressing variational forms.  Interfaces to specialized matrix
 583 solvers are provided for solving the resultant linear systems.
 584
 585 @code{fenics-dolfin} is part of the FEniCS project.  It is the C++
 586 user interface to the FEniCS core components and external libraries.")
 587     ;; The source code for the DOLFIN C++ library is licensed under the
 588     ;; GNU Lesser General Public License, version 3 or later, with the
 589     ;; following exceptions:
 590     ;;
 591     ;; public-domain: dolfin/geometry/predicates.cpp
 592     ;;                dolfin/geometry/predicates.h
 593     ;;
 594     ;; zlib:          dolfin/io/base64.cpp
 595     ;;                dolfin/io/base64.h
 596     ;;
 597     ;; expat:         dolfin/io/pugiconfig.hpp
 598     ;;                dolfin/io/pugixml.cpp
 599     ;;                dolfin/io/pugixml.hpp
 600     (license (list license:public-domain
 601                    license:zlib
 602                    license:expat
 603                    license:lgpl3+))))
 604
 605 (define-public fenics
 606   (package (inherit fenics-dolfin)
 607     (name "fenics")
 608     (build-system python-build-system)
 609     (inputs
 610      `(("pybind11" ,pybind11)
 611        ("python-matplotlib" ,python-matplotlib)
 612        ,@(alist-delete "python" (package-inputs fenics-dolfin))))
 613     (native-inputs
 614      `(("cmake" ,cmake)
 615        ("ply" ,python-ply)
 616        ("pytest" ,python-pytest)
 617        ("python-decorator" ,python-decorator)
 618        ("python-pkgconfig" ,python-pkgconfig)
 619        ,@(package-native-inputs fenics-dolfin)))
 620     (propagated-inputs
 621      `(("dolfin" ,fenics-dolfin)
 622        ("petsc4py" ,python-petsc4py)
 623        ("slepc4py" ,python-slepc4py)))
 624     (arguments
 625      `(#:phases
 626        (modify-phases %standard-phases
 627          (add-after 'patch-source-shebangs 'set-paths
 628            (lambda _
 629              ;; Define paths to store locations.
 630              (setenv "PYBIND11_DIR" (assoc-ref %build-inputs "pybind11"))
 631              ;; Move to python sub-directory.
 632              (chdir "python")
 633              #t))
 634          (add-after 'build 'mpi-setup
 635            ,%openmpi-setup)
 636          (add-before 'check 'pre-check
 637            (lambda _
 638              ;; Exclude tests that require meshes supplied by git-lfs.
 639              (substitute* "demo/test.py"
 640                (("(.*stem !.*)" line)
 641                 (string-append
 642                  line "\n"
 643                  "excludeList = [\n"
 644                  "'multimesh-quadrature', \n"
 645                  "'multimesh-marking', \n"
 646                  "'mixed-poisson-sphere', \n"
 647                  "'mesh-quality', \n"
 648                  "'lift-drag', \n"
 649                  "'elastodynamics', \n"
 650                  "'dg-advection-diffusion', \n"
 651                  "'curl-curl', \n"
 652                  "'contact-vi-tao', \n"
 653                  "'contact-vi-snes', \n"
 654                  "'collision-detection', \n"
 655                  "'buckling-tao', \n"
 656                  "'auto-adaptive-navier-stokes', \n"
 657                  "'advection-diffusion', \n"
 658                  "'subdomains', \n"
 659                  "'stokes-taylor-hood', \n"
 660                  "'stokes-mini', \n"
 661                  "'navier-stokes', \n"
 662                  "'eigenvalue']\n"
 663                  "demos = ["
 664                  "d for d in demos if d[0].stem not in "
 665                  "excludeList]\n")))
 666              (setenv "HOME" (getcwd))
 667              (setenv "PYTHONPATH"
 668                      (string-append
 669                       (getcwd) "/build/lib.linux-x86_64-"
 670                       ,(version-major+minor (package-version python)) ":"
 671                       (getenv "PYTHONPATH")))
 672              ;; Restrict OpenBLAS to MPI-only in preference to MPI+OpenMP.
 673              (setenv "OPENBLAS_NUM_THREADS" "1")
 674              #t))
 675          (replace 'check
 676            (lambda _
 677              (with-directory-excursion "test"
 678                ;; Note: The test test_snes_set_from_options() in the file
 679                ;; unit/nls/test_PETScSNES_solver.py fails and is ignored.
 680                (and (invoke "py.test" "unit" "--ignore"
 681                             "unit/nls/test_PETScSNES_solver.py")
 682                     (invoke "mpirun" "-np" "3" "python" "-B" "-m"
 683                             "pytest" "unit" "--ignore"
 684                             "unit/nls/test_PETScSNES_solver.py")))
 685              (with-directory-excursion "demo"
 686                ;; Check demos.
 687                (invoke "python" "generate-demo-files.py")
 688                (and (invoke "python" "-m" "pytest" "-v" "test.py")
 689                     (invoke "python" "-m" "pytest" "-v" "test.py"
 690                             "--mpiexec=mpiexec" "--num-proc=3")))
 691              #t))
 692          (add-after 'install 'install-demo-files
 693            (lambda* (#:key outputs #:allow-other-keys)
 694              (let* ((demos (string-append
 695                             (assoc-ref outputs "out")
 696                             "/share/python-dolfin/demo")))
 697                (mkdir-p demos)
 698                (with-directory-excursion "demo"
 699                  (for-each (lambda (file)
 700                              (let* ((dir (dirname file))
 701                                     (tgt-dir (string-append demos "/" dir)))
 702                                (unless (equal? "." dir)
 703                                  (mkdir-p tgt-dir)
 704                                  (install-file file tgt-dir))))
 705                            (find-files "." ".*\\.(py|gz|xdmf)$"))))
 706              #t)))))
 707     (home-page "https://fenicsproject.org/")
 708     (synopsis "High-level environment for solving differential equations")
 709     (description
 710       "@code{fenics} is a computing platform for solving general classes of
 711 problems that involve differential equations.  @code{fenics} facilitates
 712 access to efficient methods for dealing with ordinary differential
 713 equations (ODEs) and partial differential equations (PDEs).  Systems of
 714 equations such as these are commonly encountered in areas of engineering,
 715 mathematics and the physical sciences.  It is particularly well-suited to
 716 problems that can be solved using the Finite Element Method (FEM).
 717
 718 @code{fenics} is the top level of the set of packages that are developed
 719 within the FEniCS project.  It provides the python user interface to the
 720 FEniCS core components and external libraries.")
 721     (license license:lgpl3+)))