gnu/packages/simulation.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2017, 2018, 2019, 2020 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 python-xyz)
  44   #:use-module (gnu packages readline)
  45   #:use-module (gnu packages tls)
  46   #:use-module (gnu packages version-control)
  47   #:use-module (gnu packages xml)
  48   #:use-module (gnu packages xorg)
  49   #:use-module (guix download)
  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 "2019.1.0")
 245     (source
 246       (origin
 247         (method url-fetch)
 248         (uri (pypi-uri "fenics-dijitso" version))
 249         (sha256
 250           (base32
 251             "0lhqsq8ypdak0ahr2jnyvg07yrqp6wicjxi6k56zx24wp3qg60sc"))))
 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                ;; Disable parallel tests to avoid race condition.  See
 272                ;; https://github.com/pytest-dev/pytest-cov/issues/237.
 273                (substitute* "runtests.sh"
 274                  (("for p in 1 4 8 16; do")
 275                   "for p in 1; do"))
 276                (invoke "./runtests.sh"))
 277              #t)))))
 278     (home-page "https://bitbucket.org/fenics-project/dijitso/")
 279     (synopsis "Distributed just-in-time building of shared libraries")
 280     (description
 281       "Dijitso provides a core component of the @code{FEniCS} framework,
 282 namely the just-in-time compilation of C++ code that is generated from
 283 Python modules.  It is called from within a C++ library, using ctypes
 284 to import the dynamic shared library directly.
 285
 286 As long as the compiled code can provide a simple factory function to
 287 a class implementing a predefined C++ interface, there is no limit to
 288 the complexity of that interface.  Parallel support depends on the
 289 @code{mpi4py} interface.")
 290     (license license:lgpl3+)))
 291
 292 (define-public python-fenics-ufl
 293   (package
 294     (name "python-fenics-ufl")
 295     (version "2019.1.0")
 296     (source
 297       (origin
 298         (method url-fetch)
 299         (uri (pypi-uri "fenics-ufl" version))
 300         (sha256
 301           (base32
 302             "10dz8x3lm68x2w3kkqcjask38h0zkhhak26jdbkppr8g9y8wny7p"))))
 303     (build-system python-build-system)
 304     (inputs
 305      `(("python-numpy" ,python-numpy)))
 306     (native-inputs
 307      `(("python-pytest" ,python-pytest)))
 308     (arguments
 309      '(#:phases
 310        (modify-phases %standard-phases
 311          (replace 'check
 312            (lambda _
 313              (setenv "PYTHONPATH"
 314                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 315              (with-directory-excursion "test"
 316                (invoke "py.test"))
 317              #t)))))
 318     (home-page "https://bitbucket.org/fenics-project/ufl/")
 319     (synopsis "Unified language for form-compilers")
 320     (description "The Unified Form Language (UFL) is a domain specific
 321 language for declaration of finite element discretizations of
 322 variational forms.  More precisely, it defines a flexible interface
 323 for choosing finite element spaces and defining expressions for weak
 324 forms in a notation close to mathematical notation.
 325
 326 UFL is part of the FEniCS Project.")
 327     (license license:lgpl3+)))
 328
 329 (define-public python-fenics-fiat
 330   (package
 331     (name "python-fenics-fiat")
 332     (version "2019.1.0")
 333     (source
 334       (origin
 335         (method url-fetch)
 336         (uri (pypi-uri "fenics-fiat" version))
 337         (sha256
 338           (base32
 339             "13sc7lma3d2mh43an7i4kkdbbk4cmvxjk45wi43xnjd7qc38zg4b"))))
 340     (build-system python-build-system)
 341     (native-inputs
 342      `(("python-pytest" ,python-pytest)))
 343     (propagated-inputs
 344      `(("python-numpy" ,python-numpy)
 345        ("python-sympy" ,python-sympy)))
 346     (arguments
 347      '(#:phases
 348        (modify-phases %standard-phases
 349          (replace 'check
 350            (lambda _
 351              (setenv "PYTHONPATH"
 352                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 353              (with-directory-excursion "test"
 354                ;; FIXME: three FIAT test modules are known to fail
 355                ;; with recent versions of pytest (>= 4).  These are
 356                ;; skipped for FIAT version 2019.1.0 pending an
 357                ;; upstream pull request. For details see request #59
 358                ;; at https://bitbucket.org/fenics-project/fiat/.
 359                (invoke "py.test" "unit/"
 360                        "--ignore=unit/test_fiat.py"
 361                        "--ignore=unit/test_quadrature.py"
 362                        "--ignore=unit/test_reference_element.py"))
 363              #t)))))
 364     (home-page "https://bitbucket.org/fenics-project/fiat/")
 365     (synopsis "Tabulation of finite element function spaces")
 366     (description
 367       "The FInite element Automatic Tabulator (FIAT) supports
 368 generation of arbitrary order instances of the Lagrange elements on
 369 lines, triangles, and tetrahedra.  It is also capable of generating
 370 arbitrary order instances of Jacobi-type quadrature rules on the same
 371 element shapes.  Further, H(div) and H(curl) conforming finite element
 372 spaces such as the families of Raviart-Thomas, Brezzi-Douglas-Marini
 373 and Nedelec are supported on triangles and tetrahedra.  Upcoming
 374 versions will also support Hermite and nonconforming elements.
 375
 376 FIAT is part of the FEniCS Project.")
 377     (license license:lgpl3+)))
 378
 379 (define-public python-fenics-ffc
 380   (package
 381     (name "python-fenics-ffc")
 382     (version "2019.1.0.post0")
 383     (source
 384       (origin
 385         (method url-fetch)
 386         (uri (pypi-uri "fenics-ffc" version))
 387         (sha256
 388           (base32
 389             "1f2a44ha65fg3a1prrbrsz4dgvibsv0j5c3pi2m52zi93bhwwgg9"))))
 390     (build-system python-build-system)
 391     (native-inputs
 392      `(("python-pytest" ,python-pytest)))
 393     (propagated-inputs
 394      `(("python-fenics-dijitso" ,python-fenics-dijitso)
 395        ("python-fenics-fiat" ,python-fenics-fiat)
 396        ("python-fenics-ufl" ,python-fenics-ufl)))
 397     (arguments
 398      '(#:phases
 399        (modify-phases %standard-phases
 400          (replace 'check
 401            (lambda _
 402              (setenv "HOME" (getcwd))
 403              (setenv "PYTHONPATH"
 404                      (string-append (getcwd) ":" (getenv "PYTHONPATH")))
 405              (with-directory-excursion "test"
 406                ;; FIXME: the tests in subdirectory
 407                ;; 'unit/ufc/finite_element' require the ffc_factory
 408                ;; extension module.  This module, located in the 'libs'
 409                ;; subdirectory, needs to be built and made accessible
 410                ;; prior to running the tests.
 411                (invoke "py.test" "unit/" "--ignore=unit/ufc/")
 412                (with-directory-excursion "uflacs"
 413                  (invoke "py.test" "unit/")))
 414              #t)))))
 415     (home-page "https://bitbucket.org/fenics-project/ffc/")
 416     (synopsis "Compiler for finite element variational forms")
 417     (description "The FEniCS Form Compiler (FFC) is a compiler for
 418 finite element variational forms.  From a high-level description of
 419 the form, it generates efficient low-level C++ code that can be used
 420 to assemble the corresponding discrete operator (tensor).  In
 421 particular, a bilinear form may be assembled into a matrix and a
 422 linear form may be assembled into a vector.  FFC may be used either
 423 from the command line (by invoking the @code{ffc} command) or as a
 424 Python module (@code{import ffc}).
 425
 426 FFC is part of the FEniCS Project.")
 427     ;; There are two files released with a public domain licence;
 428     ;; ufc.h and ufc_geometry.h, in subdirectory 'ffc/backends/ufc'.
 429     (license (list license:public-domain license:lgpl3+))))
 430
 431 (define-public fenics-dolfin
 432   (package
 433     (name "fenics-dolfin")
 434     (version "2019.1.0.post0")
 435     (source
 436       (origin
 437         (method url-fetch)
 438         (uri (string-append
 439               "https://bitbucket.org/fenics-project/dolfin/get/"
 440               version ".tar.gz"))
 441         (file-name (string-append name "-" version ".tar.gz"))
 442         (sha256
 443           (base32
 444            "1m91hwcq5gfj4qqswp8l8kj58nia48f0n4kq13w0xqj4biq7rla0"))
 445         (modules '((guix build utils)))
 446         (snippet
 447          '(begin
 448             ;; Make sure we don't use the bundled test framework.
 449             (delete-file-recursively "test/unit/cpp/catch")
 450             (substitute* "test/unit/cpp/main.cpp"
 451               ;; Use standard search paths for 'catch' header file.
 452               (("#include.*")
 453                "#include <catch.hpp>\n"))
 454             (substitute* "test/unit/cpp/CMakeLists.txt"
 455               ;; Specify directory to find the header file.
 456               (("(^set\\(CATCH_INCLUDE_DIR ).*(/catch\\))" _ front back)
 457                (string-append front
 458                               "$ENV{CATCH_DIR}/include" back "\n")))
 459             #t))))
 460     (build-system cmake-build-system)
 461     (inputs
 462      `(("blas" ,openblas)
 463        ("boost" ,boost)
 464        ("eigen" ,eigen)
 465        ("hdf5" ,hdf5-parallel-openmpi)
 466        ("lapack" ,lapack)
 467        ("libxml2" ,libxml2)
 468        ("openmpi" ,openmpi)
 469        ("python" ,python-3)
 470        ("scotch" ,pt-scotch32)
 471        ("suitesparse" ,suitesparse)
 472        ("sundials" ,sundials-openmpi)
 473        ("zlib" ,zlib)))
 474     (native-inputs
 475      `(("catch" ,catch-framework2-1)
 476        ("pkg-config" ,pkg-config)))
 477     (propagated-inputs
 478      `(("ffc" ,python-fenics-ffc)
 479        ("petsc" ,petsc-openmpi)
 480        ("slepc" ,slepc-openmpi)))
 481     (arguments
 482      `(#:cmake ,cmake-3.15.5
 483        #:configure-flags
 484        `("-DDOLFIN_ENABLE_DOCS:BOOL=OFF"
 485          "-DDOLFIN_ENABLE_HDF5:BOOL=ON"
 486          "-DDOLFIN_ENABLE_MPI:BOOL=ON"
 487          "-DDOLFIN_ENABLE_PARMETIS:BOOL=OFF"
 488          "-DDOLFIN_ENABLE_SCOTCH:BOOL=ON"
 489          "-DDOLFIN_ENABLE_SUNDIALS:BOOL=ON"
 490          "-DDOLFIN_ENABLE_TRILINOS:BOOL=OFF")
 491        #:phases
 492        (modify-phases %standard-phases
 493          (add-after 'patch-usr-bin-file 'mpi-setup
 494            ,%openmpi-setup)
 495          (add-after 'patch-source-shebangs 'set-paths
 496            (lambda _
 497              ;; Define paths to store locations.
 498              (setenv "BLAS_DIR" (assoc-ref %build-inputs "blas"))
 499              (setenv "CATCH_DIR" (assoc-ref %build-inputs "catch"))
 500              (setenv "LAPACK_DIR" (assoc-ref %build-inputs "lapack"))
 501              (setenv "PETSC_DIR" (assoc-ref %build-inputs "petsc"))
 502              (setenv "SLEPC_DIR" (assoc-ref %build-inputs "slepc"))
 503              (setenv "SCOTCH_DIR" (assoc-ref %build-inputs "scotch"))
 504              (setenv "SUNDIALS_DIR" (assoc-ref %build-inputs "sundials"))
 505              (setenv "UMFPACK_DIR" (assoc-ref %build-inputs "suitesparse"))
 506              #t))
 507          (add-before 'check 'pre-check
 508            (lambda _
 509              ;; The Dolfin repository uses git-lfs, whereby web links are
 510              ;; substituted for large files.  Guix does not currently support
 511              ;; git-lfs, so only the links are downloaded.  The tests that
 512              ;; require the absent meshes cannot run and are skipped.
 513              ;;
 514              ;; Two other serial tests fail and are skipped.
 515              ;; i) demo_stokes-iterative_serial,
 516              ;;   The MPI_Comm_rank() function was called before MPI_INIT was
 517              ;;   invoked
 518              ;; ii) demo_multimesh-stokes_serial:
 519              ;;   Warning: Found no facets matching domain for boundary
 520              ;;   condition.
 521              ;;
 522              ;; One mpi test fails and is skipped.
 523              ;; i) demo_stokes-iterative_mpi:
 524              ;;   The MPI_Comm_rank() function was called before MPI_INIT was
 525              ;;   invoked
 526              (call-with-output-file "CTestCustom.cmake"
 527                (lambda (port)
 528                  (display
 529                    (string-append
 530                     "set(CTEST_CUSTOM_TESTS_IGNORE "
 531                     "demo_bcs_serial "
 532                     "demo_bcs_mpi "
 533                     "demo_eigenvalue_serial "
 534                     "demo_eigenvalue_mpi "
 535                     "demo_navier-stokes_serial "
 536                     "demo_navier-stokes_mpi "
 537                     "demo_stokes-taylor-hood_serial "
 538                     "demo_stokes-taylor-hood_mpi "
 539                     "demo_subdomains_serial "
 540                     "demo_advection-diffusion_serial "
 541                     "demo_advection-diffusion_mpi "
 542                     "demo_auto-adaptive-navier-stokes_serial "
 543                     "demo_contact-vi-snes_serial "
 544                     "demo_contact-vi-snes_mpi "
 545                     "demo_contact-vi-tao_serial "
 546                     "demo_contact-vi-tao_mpi "
 547                     "demo_curl-curl_serial "
 548                     "demo_curl-curl_mpi "
 549                     "demo_dg-advection-diffusion_serial "
 550                     "demo_dg-advection-diffusion_mpi "
 551                     "demo_elasticity_serial "
 552                     "demo_elasticity_mpi "
 553                     "demo_elastodynamics_serial "
 554                     "demo_elastodynamics_mpi "
 555                     "demo_lift-drag_serial "
 556                     "demo_lift-drag_mpi "
 557                     "demo_mesh-quality_serial "
 558                     "demo_mesh-quality_mpi "
 559                     "demo_multimesh-stokes_serial "
 560                     "demo_stokes-iterative_serial "
 561                     "demo_stokes-iterative_mpi "
 562                     ")\n") port)))
 563              #t))
 564          (replace 'check
 565            (lambda _
 566              (and (invoke "make" "unittests")
 567                   (invoke "make" "demos")
 568                   (invoke "ctest" "-R" "unittests")
 569                   (invoke "ctest" "-R" "demo" "-R" "serial")
 570                   (invoke "ctest" "-R" "demo" "-R" "mpi")))))))
 571     (home-page "https://bitbucket.org/fenics-project/dolfin/")
 572     (synopsis "Problem solving environment for differential equations")
 573     (description
 574       "DOLFIN is a computational framework for finding numerical
 575 solutions to problems described by differential equations.  Numerical
 576 models in DOLFIN are constructed using general families of finite
 577 elements.  Data structures are provided for discretizing the governing
 578 system on a computational mesh.  A compact syntax, similar to
 579 mathematical notation, is made available for defining function spaces
 580 and expressing variational forms.  Interfaces to specialized matrix
 581 solvers are provided for solving the resultant linear systems.
 582
 583 @code{fenics-dolfin} is part of the FEniCS project.  It is the C++
 584 user interface to the FEniCS core components and external libraries.")
 585     ;; The source code for the DOLFIN C++ library is licensed under the
 586     ;; GNU Lesser General Public License, version 3 or later, with the
 587     ;; following exceptions:
 588     ;;
 589     ;; public-domain: dolfin/geometry/predicates.cpp
 590     ;;                dolfin/geometry/predicates.h
 591     ;;
 592     ;; zlib:          dolfin/io/base64.cpp
 593     ;;                dolfin/io/base64.h
 594     ;;
 595     ;; expat:         dolfin/io/pugiconfig.hpp
 596     ;;                dolfin/io/pugixml.cpp
 597     ;;                dolfin/io/pugixml.hpp
 598     (license (list license:public-domain
 599                    license:zlib
 600                    license:expat
 601                    license:lgpl3+))))
 602
 603 (define-public fenics
 604   (package (inherit fenics-dolfin)
 605     (name "fenics")
 606     (build-system python-build-system)
 607     (inputs
 608      `(("pybind11" ,pybind11)
 609        ("python-matplotlib" ,python-matplotlib)
 610        ,@(alist-delete "python" (package-inputs fenics-dolfin))))
 611     (native-inputs
 612      `(("cmake" ,cmake-minimal)
 613        ("ply" ,python-ply)
 614        ("pytest" ,python-pytest)
 615        ("python-decorator" ,python-decorator)
 616        ("python-pkgconfig" ,python-pkgconfig)
 617        ,@(package-native-inputs fenics-dolfin)))
 618     (propagated-inputs
 619      `(("dolfin" ,fenics-dolfin)
 620        ("petsc4py" ,python-petsc4py)
 621        ("slepc4py" ,python-slepc4py)))
 622     (arguments
 623      `(#:phases
 624        (modify-phases %standard-phases
 625          (add-after 'patch-source-shebangs 'set-paths
 626            (lambda _
 627              ;; Define paths to store locations.
 628              (setenv "PYBIND11_DIR" (assoc-ref %build-inputs "pybind11"))
 629              ;; Move to python sub-directory.
 630              (chdir "python")
 631              #t))
 632          (add-after 'build 'mpi-setup
 633            ,%openmpi-setup)
 634          (add-before 'check 'pre-check
 635            (lambda _
 636              ;; Exclude three tests that generate
 637              ;; 'NotImplementedError' in matplotlib version 3.1.2.
 638              ;; See
 639              ;; <https://github.com/matplotlib/matplotlib/issues/15382>.
 640              ;; Also exclude tests that require meshes supplied by
 641              ;; git-lfs.
 642              (substitute* "demo/test.py"
 643                (("(.*stem !.*)" line)
 644                 (string-append
 645                  line "\n"
 646                  "excludeList = [\n"
 647                  "'built-in-meshes', \n"
 648                  "'hyperelasticity', \n"
 649                  "'elasticity', \n"
 650                  "'multimesh-quadrature', \n"
 651                  "'multimesh-marking', \n"
 652                  "'mixed-poisson-sphere', \n"
 653                  "'mesh-quality', \n"
 654                  "'lift-drag', \n"
 655                  "'elastodynamics', \n"
 656                  "'dg-advection-diffusion', \n"
 657                  "'curl-curl', \n"
 658                  "'contact-vi-tao', \n"
 659                  "'contact-vi-snes', \n"
 660                  "'collision-detection', \n"
 661                  "'buckling-tao', \n"
 662                  "'auto-adaptive-navier-stokes', \n"
 663                  "'advection-diffusion', \n"
 664                  "'subdomains', \n"
 665                  "'stokes-taylor-hood', \n"
 666                  "'stokes-mini', \n"
 667                  "'navier-stokes', \n"
 668                  "'eigenvalue']\n"
 669                  "demos = ["
 670                  "d for d in demos if d[0].stem not in "
 671                  "excludeList]\n")))
 672              (setenv "HOME" (getcwd))
 673              (setenv "PYTHONPATH"
 674                      (string-append
 675                       (getcwd) "/build/lib.linux-x86_64-"
 676                       ,(version-major+minor (package-version python)) ":"
 677                       (getenv "PYTHONPATH")))
 678              ;; Restrict OpenBLAS to MPI-only in preference to MPI+OpenMP.
 679              (setenv "OPENBLAS_NUM_THREADS" "1")
 680              #t))
 681          (replace 'check
 682            (lambda _
 683              (with-directory-excursion "test"
 684                ;; Note: The test test_snes_set_from_options() in the file
 685                ;; unit/nls/test_PETScSNES_solver.py fails and is ignored.
 686                (and (invoke "py.test" "unit" "--ignore"
 687                             "unit/nls/test_PETScSNES_solver.py")
 688                     (invoke "mpirun" "-np" "3" "python" "-B" "-m"
 689                             "pytest" "unit" "--ignore"
 690                             "unit/nls/test_PETScSNES_solver.py")))
 691              (with-directory-excursion "demo"
 692                ;; Check demos.
 693                (invoke "python" "generate-demo-files.py")
 694                (and (invoke "python" "-m" "pytest" "-v" "test.py")
 695                     (invoke "python" "-m" "pytest" "-v" "test.py"
 696                             "--mpiexec=mpiexec" "--num-proc=3")))
 697              #t))
 698          (add-after 'install 'install-demo-files
 699            (lambda* (#:key outputs #:allow-other-keys)
 700              (let* ((demos (string-append
 701                             (assoc-ref outputs "out")
 702                             "/share/python-dolfin/demo")))
 703                (mkdir-p demos)
 704                (with-directory-excursion "demo"
 705                  (for-each (lambda (file)
 706                              (let* ((dir (dirname file))
 707                                     (tgt-dir (string-append demos "/" dir)))
 708                                (unless (equal? "." dir)
 709                                  (mkdir-p tgt-dir)
 710                                  (install-file file tgt-dir))))
 711                            (find-files "." ".*\\.(py|gz|xdmf)$"))))
 712              #t)))))
 713     (home-page "https://fenicsproject.org/")
 714     (synopsis "High-level environment for solving differential equations")
 715     (description
 716       "@code{fenics} is a computing platform for solving general classes of
 717 problems that involve differential equations.  @code{fenics} facilitates
 718 access to efficient methods for dealing with ordinary differential
 719 equations (ODEs) and partial differential equations (PDEs).  Systems of
 720 equations such as these are commonly encountered in areas of engineering,
 721 mathematics and the physical sciences.  It is particularly well-suited to
 722 problems that can be solved using the Finite Element Method (FEM).
 723
 724 @code{fenics} is the top level of the set of packages that are developed
 725 within the FEniCS project.  It provides the python user interface to the
 726 FEniCS core components and external libraries.")
 727     (license license:lgpl3+)))