diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 66556df9d851d38dfb53906aef6a7c6df00d0a02..ca4908181b4d6d0a6cf6762cc3803bca2fce81db 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -7,56 +7,56 @@ stages:
- install
- test
-env:bionic:
- image: keckj/hysop:ubuntu_bionic
+env:focal:
+ image: keckj/hysop:focal
stage: env
script:
- - "sh ci/scripts/version.sh"
+ - "bash ci/scripts/version.sh"
-config:bionic:
- image: keckj/hysop:ubuntu_bionic
+config:focal:
+ image: keckj/hysop:focal
stage: configure
script:
- - "sh ci/scripts/config.sh $CI_PROJECT_DIR/build/gcc-7 $CI_PROJECT_DIR/install/gcc-7 gcc-7 g++-7 gfortran-7"
- - "sh ci/scripts/config.sh $CI_PROJECT_DIR/build/clang-6 $CI_PROJECT_DIR/install/clang-6 clang-6.0 clang++-6.0 gfortran-7"
+ - "bash ci/scripts/config.sh $CI_PROJECT_DIR/build/gcc $CI_PROJECT_DIR/install/gcc gcc g++ gfortran"
+ - "bash ci/scripts/config.sh $CI_PROJECT_DIR/build/clang-8 $CI_PROJECT_DIR/install/clang-8 clang-8 clang++-8 gfortran"
dependencies:
- - env:bionic
+ - env:focal
artifacts:
paths:
- $CI_PROJECT_DIR/build
-build:bionic:
- image: keckj/hysop:ubuntu_bionic
+build:focal:
+ image: keckj/hysop:focal
stage: build
script:
- - "sh ci/scripts/build.sh $CI_PROJECT_DIR/build/gcc-7 gcc-7 g++-7 gfortran-7"
- - "sh ci/scripts/build.sh $CI_PROJECT_DIR/build/clang-6 clang-6.0 clang++-6.0 gfortran-7"
+ - "bash ci/scripts/build.sh $CI_PROJECT_DIR/build/gcc gcc g++ gfortran"
+ - "bash ci/scripts/build.sh $CI_PROJECT_DIR/build/clang-8 clang-8 clang++-8 gfortran"
dependencies:
- - config:bionic
+ - config:focal
artifacts:
paths:
- $CI_PROJECT_DIR/build
-install:bionic:
- image: keckj/hysop:ubuntu_bionic
+install:focal:
+ image: keckj/hysop:focal
stage: install
script:
- - "sh ci/scripts/install.sh $CI_PROJECT_DIR/build/gcc-7 $CI_PROJECT_DIR/install/gcc-7"
+ - "bash ci/scripts/install.sh $CI_PROJECT_DIR/build/gcc $CI_PROJECT_DIR/install/gcc"
dependencies:
- - build:bionic
+ - build:focal
artifacts:
paths:
- $CI_PROJECT_DIR/install
-test:bionic:
- image: keckj/hysop:ubuntu_bionic
+test:focal:
+ image: keckj/hysop:focal
stage: test
script:
- - "sh ci/scripts/test.sh $CI_PROJECT_DIR/install/gcc-7 $CI_PROJECT_DIR/hysop $CI_PROJECT_DIR/cache"
+ - "bash ci/scripts/test.sh $CI_PROJECT_DIR/install/gcc $CI_PROJECT_DIR/hysop $CI_PROJECT_DIR/cache"
dependencies:
- - install:bionic
+ - install:focal
cache:
paths:
- $CI_PROJECT_DIR/cache
- key: "test_cache_0000"
+ key: "hysop_cache"
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7da8399d2291c7b0b3dc6d26865f7f30c8ab4439..4f4a57e288c841c2388112e3db56dbf7743c9415 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,8 +18,13 @@
cmake_minimum_required(VERSION 3.0.2)
if(POLICY CMP0053)
+ #Â Simplify variable reference and escape sequence evaluation (cmake 3.1)
cmake_policy(SET CMP0053 NEW)
endif()
+if(POLICY CMP0074)
+ # find_package(<PackageName>) commands will first search prefixes specified by the <PackageName>_ROOT (cmake 3.12)
+ cmake_policy(SET CMP0074 NEW)
+endif()
# Set cmake modules directory (i.e. the one which contains all user-defined FindXXX.cmake files among other things)
set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
@@ -36,14 +41,15 @@ option(WITH_TESTS "Enable testing. Default = OFF" ON)
option(BUILD_SHARED_LIBS "Enable dynamic library build, default = ON." ON)
option(USE_CXX "Expand hysop with some new functions from a generated c++ to python interface, wrapped into hysop.cpp2hysop module. Default = ON." OFF)
option(WITH_SCALES "compile/create scales lib and link it with HySoP. Default = ON." ON)
+option(WITH_PARALLEL_COMPRESSED_HDF5 "Try to enable parallel compressed hdf5 interface. Default = ON." ON)
option(WITH_FFTW "Link with fftw library (required for some HySoP solvers), default = ON" ON)
option(WITH_EXTRAS "Link with some extra fortran libraries (like arnoldi solver), default = OFF" OFF)
-option(WITH_GPU "Use of GPU (required for some HySoP solvers), default = ON" ON)
+option(WITH_OPENCL "Use of GPU (required for some HySoP solvers), default = ON" ON)
option(WITH_MAIN_FORTRAN "Create an executable (test purpose) from fortran sources in src/main, linked with libhysop, default = OFF" OFF)
option(WITH_MAIN_CXX "Create an executable (test purpose) from cxx sources in src/hysop++/main, linked with libhysop, default = OFF" OFF)
-option(PROFILE "Enable profiling mode for HySoP. Default = ON" ON)
-option(VERBOSE "Enable verbose mode for HySoP. Default = ON" ON)
-option(DEBUG "Enable debug mode for HySoP. Default = OFF" OFF)
+option(PROFILE "Enable profiling mode for HySoP. Can also be enabled with HYSOP_PROFILE environment variable. Default = OFF" OFF)
+option(VERBOSE "Enable verbose mode for HySoP. Can also be enabled with HYSOP_VERBOSE environment variable. Default = OFF" OFF)
+option(DEBUG "Enable debug mode for HySoP. Can also be enabled with HYSOP_DEBUG environment variable. Default = OFF" OFF)
option(FULL_TEST "Enable all test options (pep8, mpi ...) - Default = OFF" OFF)
option(OPTIM "To allow python -OO run, some packages must be deactivated. Set this option to 'ON' to do so. Default = OFF" OFF)
option(WITH_MPI_TESTS "Enable mpi tests. Default = OFF." OFF)
@@ -116,7 +122,7 @@ if(USE_CXX)
endif()
if(USE_FORTRAN)
- set(LANGLIST ${LANGLIST} Fortran)
+ set(LANGLIST ${LANGLIST} C Fortran)
endif()
include(HysopVersion)
@@ -134,7 +140,6 @@ include(FindPythonModule)
# - python packages -
find_python_module(numpy REQUIRED)
find_python_module(scipy REQUIRED)
-find_python_module(scitools REQUIRED)
find_python_module(h5py REQUIRED)
find_python_module(sympy REQUIRED)
find_python_module(psutil REQUIRED)
@@ -145,23 +150,28 @@ find_python_module(editdistance REQUIRED)
find_python_module(portalocker REQUIRED)
find_python_module(tee REQUIRED)
find_python_module(colors REQUIRED) # ansicolor package
-find_python_module(backports.weakref REQUIRED)
find_python_module(argparse_color_formatter REQUIRED)
find_python_module(primefac REQUIRED)
-find_python_module(graph_tool REQUIRED)
-find_python_module(pyopencl REQUIRED)
+find_python_module(networkx REQUIRED)
find_python_module(pyfftw REQUIRED)
-find_python_module(gpyfft REQUIRED)
+find_python_module(backports.weakref REQUIRED) # python-backports.weakref
+#find_python_module(backports.functools-lru-cache REQUIRED) # python-backports.functools-lru-cache
+find_python_module(matplotlib OPTIONAL)
+find_python_module(pyvis OPTIONAL)
+
+find_package( OpenCL )
+if(${OpenCL_LIBRARY}) # Some opencl related python package fails to import on non OpenCL machines (cluster's frontend for instance)
+ find_python_module(pyopencl REQUIRED)
+ find_python_module(gpyfft REQUIRED)
+else()
+ find_python_module(pyopencl )
+ find_python_module(gpyfft )
+endif()
# --- MPI ---
if(USE_MPI)
find_package(MPI REQUIRED)
find_python_module(mpi4py REQUIRED)
endif()
-# --- PLOT --
-find_python_module(matplotlib)
-if(NOT matplotlib_FOUND)
- find_python_module(Gnuplot)
-endif()
# --- Wheel, required for a proper build/install process ---
find_python_module(wheel REQUIRED)
if(USE_CXX)
@@ -189,9 +199,8 @@ endif()
# --- FFTW ---
if(WITH_FFTW)
- set(FIND_FFTW_VERBOSE OFF)
- set(FIND_FFTW_DEBUG OFF)
- set(FIND_FFTW_SHARED_ONLY ON)
+ set(FIND_FFTW_VERBOSE CACHE BOOL OFF)
+ set(FIND_FFTW_DEBUG CACHE BOOL OFF)
compile_with(FFTW
REQUIRED COMPONENTS Fftw3f Fftw3d
Fftw3f-mpi Fftw3d-mpi
@@ -230,8 +239,28 @@ if(WITH_EXTRAS)
endif()
+# ========= Check parallel hdf5 availability =========
+if(WITH_PARALLEL_COMPRESSED_HDF5)
+ execute_process(
+ COMMAND ${PYTHON_EXECUTABLE} -c "import h5py; print('.'.join(str(_) for _ in h5py.h5.get_libversion()))"
+ OUTPUT_VARIABLE LIB_HDF5_VERSION)
+ string(REGEX REPLACE "\n$" "" LIB_HDF5_VERSION "${LIB_HDF5_VERSION}")
+ execute_process(
+ COMMAND ${PYTHON_EXECUTABLE} -c "import h5py; print(h5py.h5.get_libversion() >= (1,10,2) )"
+ OUTPUT_VARIABLE H5PY_PARALLEL_COMPRESSION_ENABLED)
+ if(H5PY_PARALLEL_COMPRESSION_ENABLED EQUAL "False")
+ message(WARNING "Your hdf5 library is too old to support parallel compression support. Minimal version is 1.10.2 but h5py was linked to version $LIB_HDF5_VERSION. Parallel HDF5 compression will be disabled.")
+ set(H5PY_PARALLEL_COMPRESSION_ENABLED "OFF")
+ else()
+ message(STATUS "Found h5py linked against libhdf5 version ${LIB_HDF5_VERSION}. Parallel HDF5 compression will enabled.")
+ set(H5PY_PARALLEL_COMPRESSION_ENABLED "ON")
+ endif()
+else()
+ set(H5PY_PARALLEL_COMPRESSION_ENABLED "OFF")
+endif()
+
# ========= Check which opencl devices are available on the system =========
-if(WITH_GPU)
+if(WITH_OPENCL)
execute_process(
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/opencl_explore.py "EXPLORE")
execute_process(
@@ -328,10 +357,8 @@ endif()
# set data layout ('fortran' order or 'C' order) in python (numpy).
if(FORTRAN_LAYOUT)
set(DATA_LAYOUT 'F')
- set(MPI_DATA_LAYOUT MPI.ORDER_F)
else()
set(DATA_LAYOUT 'C')
- set(MPI_DATA_LAYOUT MPI.ORDER_C)
endif()
if(EXISTS ${CMAKE_SOURCE_DIR}/${PACKAGE_NAME}/constants.py.in)
message(STATUS "Generate constant.py file ...")
@@ -379,6 +406,7 @@ if(USE_FORTRAN)
# Add compilation flags:
#append_Fortran_FLAGS("-Wall -fPIC -ffree-line-length-none -DBLOCKING_SEND_PLUS -DBLOCKING_SEND")
append_Fortran_FLAGS("-Wall -fPIC -ffree-line-length-none -cpp")
+ append_Fortran_FLAGS("-Wno-unused-dummy-argument -Wno-integer-division -Wno-unused-value -Wno-maybe-uninitialized -Wno-unused-function")
if(USE_MPI)
# -I
@@ -562,21 +590,6 @@ add_custom_target(pyclean COMMAND rm -f ${PYCFILES}
COMMAND rm ${CMAKE_SOURCE_DIR}/hysop/__init__.py
COMMENT "clean hysop sources and build.")
-# # ====== Create a Target to generate the documentation ======
-# find_package(Doxygen)
-# if(DOXYGEN_FOUND)
-# find_file(DOXY name doxypy.py PATH ENV{PATH})
-# if(DOXY-NOTFOUND)
-# message(STATUS "Warning, doxypy seems to be missing on your system. You may not be able to properly generate the documentation.")
-# endif()
-# configure_file(${CMAKE_SOURCE_DIR}/docs/config/hysop.doxyfile.in ${CMAKE_BINARY_DIR}/docs/config/hysop.doxyfile)
-# add_custom_target(doc COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/docs/config/hysop.doxyfile
-# COMMENT "Generate hysop documentation using doxygen.")
-# else()
-# message(STATUS "Warning : cmake cannot find doxygen on your system. It means you will not be able to generate documentation for hysop.")
-# add_custom_target(doc COMMAND echo "Doxygen was not found on your system. Documentation generation is not possible."
-# COMMENT "Generate hysop documentation using doxygen.")
-# endif()
# ============= Tests =============
if(WITH_TESTS)
@@ -629,14 +642,15 @@ if(VERBOSE_MODE)
message(STATUS " Project uses MPI : ${USE_MPI}")
message(STATUS " Project uses Scales : ${WITH_SCALES}")
message(STATUS " Project uses FFTW : ${WITH_FFTW}")
- message(STATUS " Project uses GPU : ${WITH_GPU}")
+ message(STATUS " Project uses OpenCL : ${WITH_OPENCL}")
+ message(STATUS " Project uses parallel HDF5 interface : ${H5PY_PARALLEL_COMPRESSION_ENABLED}")
message(STATUS " ${PROJECT_NAME} profile mode : ${PROFILE}")
message(STATUS " ${PROJECT_NAME} debug mode : ${DEBUG}")
message(STATUS " Enable -OO run? : ${OPTIM}")
if(DOUBLEPREC)
message(STATUS " Default real numbers precision : double.")
else()
- message(STATUS " Default real numbers precision : simple.")
+ message(STATUS " Default real numbers precision : single.")
endif()
message(STATUS "====================== ======= ======================")
message(STATUS " ")
@@ -653,7 +667,7 @@ if(VERBOSE_MODE)
endif()
# Add custom target to install compiled libraries locally
-add_custom_target(update_libs
+add_custom_target(update_libs
COMMAND find ${CMAKE_SOURCE_DIR}/hysop/ -name '*.so' -type f -delete
COMMAND find ${CMAKE_BINARY_DIR} -name '*.so' -type f -print0 | xargs -0 cp -t ${CMAKE_SOURCE_DIR}/hysop/
COMMAND [ -f "$ENV{HOME}/.hysop.__init__.py" ] && rm ${CMAKE_SOURCE_DIR}/hysop/__init__.py
diff --git a/INSTALL b/INSTALL
index bfa0f3666075ae491a0be0d6c0f8057066294845..196557af28df1cd74a002677dddb863f6bcefcb8 100644
--- a/INSTALL
+++ b/INSTALL
@@ -49,7 +49,7 @@ At the end of this step BUILDDIR contains all makefiles, setup.py and other requ
Some useful options for cmake :
--DFFTW_DIR : where to find fftw if it's not in a "standard" place.
+-DFFTW_ROOT : where to find fftw if it's not in a "standard" place.
-DWITH_SCALES=ON/OFF : to compile a hysop version including scales (default = on)
-DWITH_PPM=ON/OFF : to compile a hysop version including scales (default = off)
-DWITH_TESTS=ON/OFF: enable testing (i.e. prepare target "make test", default = off)
@@ -60,7 +60,7 @@ mkdir /home/mylogin/buildhysop
cd /home/mylogin/buildhysop
export FC=mpif90
module load cmake-2.8
-cmake -DFFTW_DIR=/softs/install/fftw3.1 ~/Softs/HySoP
+cmake -DFFTW_ROOT=/softs/install/fftw3.1 ~/Softs/HySoP
===================================================================================================================
3 - Build
diff --git a/ci/README.rst b/ci/README.rst
index 21b8d4d40732c7cb59397ab7532c4300f6c1fb2a..5be2a79d987767f6f54fe3f3d2040ca7ec448768 100644
--- a/ci/README.rst
+++ b/ci/README.rst
@@ -1,50 +1,4 @@
Continuous integration howto
============================
-DRAFT !!
-
-
-Docker reminder
----------------
-
-Use docker_images/osname/Dockerfile to create a docker image :
-
-For example::
-
- cd docker_images/debian
- docker build -t fperignon/hysop
-
-
-To start the image::
-
- docker run -ti fperignon/hysop bash
-
-Images list::
-
- docker images
-
-Then tag and push image on docker hub (might need login)::
-
- docker tag image_id fperignon/hysop:debian
- docker push fperignon/hysop:debian
-
-Pick image id in docker images list.
-
-
-Gitlab-ci
----------
-
-To use a given docker image in job:
-
-image: fperignon/hysop:debian
-
-
-The image will be pulled from docker hub.
-
-yml driver
-----------
-
-See gitlab-ci documentation : http://docs.gitlab.com/ce/ci/yaml/README.html
-
-In script, use -DCI_CONFIG=<something> option for cmake to send runner information to dashboard.
-
+See scripts in utils to build, run, push and pull the docker image for continuous integration tests.
diff --git a/ci/docker_images/ubuntu/bionic/Dockerfile b/ci/docker_images/ubuntu/bionic/Dockerfile
index 4c2cb4e8a5143cec09d74c8492d5ad82ac3ec774..c7f5c384509af05349077a311f7086ba721d7a5e 100644
--- a/ci/docker_images/ubuntu/bionic/Dockerfile
+++ b/ci/docker_images/ubuntu/bionic/Dockerfile
@@ -2,223 +2,238 @@
FROM ubuntu:bionic
MAINTAINER Jean-Baptiste.Keck@imag.fr
+# parallel builds
+ARG NTHREADS
+ENV MAKEFLAGS "-j${NTHREADS}"
+
# upgrade initial image
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update
RUN apt-get full-upgrade -y
# get build tools and required libraries
-RUN apt-get install -y expat
-RUN apt-get install -y unzip
-RUN apt-get install -y xz-utils
-RUN apt-get install -y automake
-RUN apt-get install -y libtool
-RUN apt-get install -y pkg-config
-RUN apt-get install -y cmake
-RUN apt-get install -y git
-RUN apt-get install -y vim
-RUN apt-get install -y ssh
-RUN apt-get install -y gcc
-RUN apt-get install -y gfortran
-RUN apt-get install -y cython
-RUN apt-get install -y swig
-RUN apt-get install -y lsb-core
-RUN apt-get install -y cpio
-RUN apt-get install -y libnuma1
-RUN apt-get install -y libpciaccess0
-RUN apt-get install -y libreadline-dev
-RUN apt-get install -y libboost-all-dev
-RUN apt-get install -y libblas-dev
-RUN apt-get install -y liblapack-dev
-RUN apt-get install -y libcgal-dev
-RUN apt-get install -y libatlas-base-dev
-RUN apt-get install -y libopenblas-dev
-RUN apt-get install -y libgfortran3
-RUN apt-get install -y libgcc1
-RUN apt-get install -y libopenmpi-dev
-RUN apt-get install -y libhdf5-openmpi-dev
-RUN apt-get install -y libfftw3-dev
-RUN apt-get install -y libfftw3-mpi-dev
-RUN apt-get install -y libgmp-dev
-RUN apt-get install -y libmpfr-dev
-RUN apt-get install -y libmpc-dev
-RUN apt-get install -y libsparsehash-dev
-RUN apt-get install -y libcairo-dev
-RUN apt-get install -y libcairomm-1.0-dev
-RUN apt-get install -y python
-RUN apt-get install -y python-dev
-RUN apt-get install -y python-pip
-RUN apt-get install -y python-tk
-RUN apt-get install -y opencl-headers
-RUN apt-get install -y ocl-icd-libopencl1
-RUN apt-get install -y clinfo
-
-# python packages
-RUN pip install --upgrade pip
-RUN pip install --upgrade setuptools
-RUN pip install --upgrade backports.weakref
-RUN pip install --upgrade cffi
-RUN pip install --upgrade wheel
-RUN pip install --upgrade pytest
-RUN pip install --upgrade numpy
-RUN pip install --upgrade scipy
-RUN pip install --upgrade sympy
-RUN pip install --upgrade matplotlib
-RUN pip install --upgrade mpi4py
-RUN pip install --upgrade h5py
-RUN pip install --upgrade gmpy2
-RUN pip install --upgrade psutil
-RUN pip install --upgrade py-cpuinfo
-RUN pip install --upgrade Mako
-RUN pip install --upgrade subprocess32
-RUN pip install --upgrade editdistance
-RUN pip install --upgrade portalocker
-RUN pip install --upgrade colors.py
-RUN pip install --upgrade tee
-RUN pip install --upgrade primefac
-RUN pip install --upgrade pycairo
-RUN pip install --upgrade weave
-RUN pip install --upgrade argparse_color_formatter
-RUN pip install --upgrade numba
-
-# For documentation
-# RUN pip install --upgrade sphinx
-# RUN pip install --upgrade sphinxcontrib-bibtex
-# RUN pip install --upgrade sphinx_bootstrap_theme
-# RUN pip install --upgrade strip-hints
-# RUN cd /tmp && git clone https://github.com/sphinx-contrib/doxylink.git && cd doxylink/sphinxcontrib/doxylink \
-# && mv doxylink.py doxylink.py3 && strip-hints doxylink.py3 > doxylink.py && rm doxylink.py3 \
-# && mv parsing.py parsing.py3 && strip-hints parsing.py3 > parsing.py && rm parsing.py3 \
-# && python setup.py install
-
-
-# scitools (python-scitools does not exist on ubuntu:bionic)
-RUN cd /tmp \
- && git clone https://github.com/hplgit/scitools \
- && cd scitools \
- && pip install . \
- && cd - \
- && rm -Rf /tmp/scitools
+RUN apt-get install -y expat unzip xz-utils automake libtool pkg-config cmake rsync git vim ssh clang gcc gfortran swig lsb-core cpio libnuma1 libpciaccess0 libreadline-dev libboost-all-dev libblas-dev liblapack-dev libcgal-dev libatlas-base-dev libopenblas-dev libgfortran3 libgcc1 libgmp-dev libmpfr-dev libmpc-dev libsparsehash-dev libcairo-dev libcairomm-1.0-dev python python-dev python-tk opencl-headers
+
+# python packages using pip2.7
+RUN cd /tmp && \
+ curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
+ python2.7 get-pip.py && \
+ pip2.7 install --upgrade pip && \
+ rm -f /tmp/get-pip.py
+RUN pip2.7 install --upgrade numpy setuptools cffi wheel pytest pybind11 cython
+
+# OpenMPI 4 + mpi4py (enable mpi1 compatibility for mpi4py)
+ENV MPI_ROOT "/usr/local"
+RUN cd /tmp && \
+ wget https://download.open-mpi.org/release/open-mpi/v4.0/openmpi-4.0.4.tar.gz && \
+ tar -xvzf openmpi-*.tar.gz && \
+ rm -f openmpi-*.tar.gz && \
+ cd openmpi-* && \
+ ./configure --enable-shared --disable-static --with-threads=posix --enable-ipv6 --prefix="${MPI_ROOT}" --with-hwloc=internal --with-libevent=internal --enable-mpi1-compatibility && \
+ make -j$(nproc) && \
+ make install && \
+ rm -rf /tmp/openmpi-*
+
+ENV MPICC "${MPI_ROOT}/bin/mpicc"
+RUN ldconfig && pip2.7 install --upgrade mpi4py
+
+# HDF5 + h5py (v1.10.6 is currently the last supported by h5py)
+RUN cd /tmp && \
+ wget https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/hdf5-1.10.6/src/hdf5-1.10.6.tar.gz && \
+ tar -xvzf hdf5-*.tar.gz && \
+ rm -rf hdf5-*.tar.gz && \
+ cd hdf5-* && \
+ CC="${MPICC}" ./configure --prefix="${MPI_ROOT}" --enable-parallel --enable-shared=yes --enable-static=no && \
+ make -j$(nproc) && \
+ make install && \
+ rm -rf /tmp/hdf5-*
+RUN CC="${MPICC}" HDF5_MPI="ON" HDF5_VERSION="1.10.6" HDF5_DIR="${MPI_ROOT}" pip2.7 install --upgrade --no-binary=h5py h5py
+
+# llvm + numba + llvmlite (llvmlite 0.32 has a bug with llvm8)
+RUN apt-get install -y llvm-8-dev libclang-8-dev clang-8
+ENV LLVM_CONFIG=llvm-config-8
+RUN pip2.7 install --upgrade numba llvmlite==0.31.0
+
+# other python packages
+RUN pip2.7 install --upgrade backports.weakref backports.tempfile scipy sympy matplotlib gmpy2 psutil py-cpuinfo Mako subprocess32 editdistance portalocker colors.py tee primefac pycairo weave argparse_color_formatter networkx pyvis zarr numcodecs jsonpickle
# patchelf
-RUN cd /tmp \
- && git clone https://github.com/NixOS/patchelf \
- && cd patchelf \
- && ./bootstrap.sh \
- && ./configure \
- && make \
- && make install \
- && cd - \
- && rm -Rf /tmp/patchelf
-
-RUN wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - \
- && echo 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic main' >> /etc/apt/sources.list \
- && echo 'deb-src http://apt.llvm.org/bionic/ llvm-toolchain-bionic main' >> /etc/apt/sources.list \
- && apt-get update \
- && apt-get install --assume-yes llvm-3.9 clang-3.9 libllvm3.9 libclang-3.9-dev
-
-# Intel OpenCl
-RUN cd /tmp \
-&& mkdir intel \
-&& cd intel \
-&& wget http://registrationcenter-download.intel.com/akdlm/irc_nas/12556/opencl_runtime_16.1.2_x64_rh_6.4.0.37.tgz \
-&& tar -xvzf opencl_runtime_16.1.2_x64_rh_6.4.0.37.tgz \
-&& cd opencl_runtime_16.1.2_x64_rh_6.4.0.37 \
-&& ls -la \
-&& sed -i "s/ACCEPT_EULA=decline/ACCEPT_EULA=accept/g" "silent.cfg" \
-&& ./install.sh --silent ./silent.cfg \
-&& cd /tmp \
-&& rm -Rf /tmp/intel
-
-# Fix OpenCl ICD
-RUN ln -s /usr/lib/x86_64-linux-gnu/libOpenCL.so.1 /usr/lib/x86_64-linux-gnu/libOpenCL.so
-RUN ldconfig
+RUN cd /tmp && \
+ git clone https://github.com/NixOS/patchelf && \
+ cd patchelf && \
+ ./bootstrap.sh && \
+ ./configure && \
+ make && \
+ make install && \
+ cd - && \
+ rm -Rf /tmp/patchelf
+
+# Intel experimental OpenCL platform with SYCL support (2020-06)
+ENV LD_LIBRARY_PATH "/opt/intel/oclcpuexp/x64:${LD_LIBRARY_PATH}"
+RUN mkdir -p /opt/intel/oclcpuexp && \
+ wget https://github.com/intel/llvm/releases/download/2020-06/oclcpuexp-2020.10.6.0.4_rel.tar.gz && \
+ tar -xvzf oclcpuexp-*.tar.gz && \
+ mv x64/ /opt/intel/oclcpuexp/ && \
+ mv clbltfnshared.rtl /opt/intel/oclcpuexp/ && \
+ rm -rf *.rtl oclcpuexp-* && \
+ wget https://github.com/oneapi-src/oneTBB/releases/download/v2020.3/tbb-2020.3-lin.tgz && \
+ tar -xvzf tbb-*.tgz && \
+ mv tbb/lib/intel64/gcc4.8/* /opt/intel/oclcpuexp/x64/ && \
+ rm -f /usr/local/lib/libOpenCL.so && \
+ rm -f /usr/local/lib/libOpenCL.so && \
+ rm -f /usr/local/lib/libOpenCL.so.1 && \
+ rm -f /usr/local/lib/libOpenCL.so.2.0 && \
+ ln -s /opt/intel/oclcpuexp/x64/libOpenCL.so /usr/local/lib/libOpenCL.so && \
+ ln -s /opt/intel/oclcpuexp/x64/libOpenCL.so.1 /usr/local/lib/libOpenCL.so.1 && \
+ ln -s /opt/intel/oclcpuexp/x64/libOpenCL.so.2.0 /usr/local/lib/libOpenCL.so.2.0 && \
+ mkdir -p /etc/OpenCL/vendors && \
+ echo /opt/intel/oclcpuexp/x64/libintelocl.so > /etc/OpenCL/vendors/intel_expcpu.icd && \
+ rm -rf /tmp/tbb*
+
+# clinfo 2.2.18 (2018)
+RUN cd /tmp && \
+ wget https://github.com/Oblomov/clinfo/archive/2.2.18.04.06.tar.gz && \
+ tar -xvzf *.tar.gz && \
+ rm -f *.tar.gz && \
+ cd clinfo-* && \
+ make && \
+ mv clinfo /usr/local/bin && \
+ rm -rf /tmp/clinfo-*
+
+# clpeak 1.1.0 RC2 (2019)
+RUN cd /tmp && \
+ wget https://github.com/krrishnarraj/clpeak/archive/1.1.0-rc2.tar.gz && \
+ tar -xvzf *.tar.gz && \
+ rm -f *.tar.gz && \
+ cd clpeak-* && \
+ mkdir build && \
+ cd build/ && \
+ cmake .. && \
+ make && \
+ mv clpeak /usr/local/bin && \
+ rm -rf /tmp/clpeak-*
# pyopencl
-RUN cd /tmp \
-&& pip install pybind11 \
-&& git clone https://github.com/inducer/pyopencl \
-&& cd pyopencl \
-&& git submodule update --init \
-&& ./configure.py \
-&& make \
-&& pip install --upgrade . \
-&& cd - \
-&& rm -Rf /tmp/pyopencl
+RUN cd /tmp && \
+ git clone https://github.com/inducer/pyopencl && \
+ cd pyopencl && \
+ git submodule update --init && \
+ git checkout v2020.1 && \
+ python2.7 configure.py && \
+ make && \
+ pip2.7 install --upgrade . && \
+ cd - && \
+ rm -Rf /tmp/pyopencl
# oclgrind
-RUN apt-get install --assume-yes --allow-unauthenticated llvm-6.0 clang-6.0 libllvm6.0 libclang-6.0-dev
-RUN cd /tmp \
- && git clone https://github.com/jrprice/Oclgrind \
- && cd Oclgrind \
- && mkdir build \
- && cd build \
- && cmake -DCMAKE_BUILD_TYPE=Release .. \
- && make \
- && make install \
- && cd - \
- && rm -Rf /tmp/Oclgrind
-
-# clpeak
-RUN cd /tmp \
- && git clone https://github.com/krrishnarraj/clpeak \
- && cd clpeak/ \
- && mkdir build \
- && cd build/ \
- && cmake .. \
- && make \
- && mv clpeak /usr/local/bin/ \
- && cd - \
- && rm -Rf /tmp/clpeak
+RUN cd /tmp && \
+ git clone https://github.com/jrprice/Oclgrind && \
+ cd Oclgrind && \
+ mkdir build && \
+ cd build && \
+ cmake -DCMAKE_BUILD_TYPE=Release .. && \
+ make && \
+ make install && \
+ cd - && \
+ rm -Rf /tmp/Oclgrind
# clFFT
-RUN cd /tmp \
- && ln -s /usr/local/lib /usr/local/lib64 \
- && git clone https://github.com/clMathLibraries/clFFT \
- && cd clFFT \
- && cd src \
- && mkdir build \
- && cd build \
- && cmake -DCMAKE_BUILD_TYPE=Release .. \
- && make \
- && make install \
- && cd - \
- && rm -Rf /tmp/clFFT
+RUN cd /tmp && \
+ ln -s /usr/local/lib /usr/local/lib64 && \
+ git clone https://github.com/clMathLibraries/clFFT && \
+ cd clFFT && \
+ cd src && \
+ mkdir build && \
+ cd build && \
+ cmake -DCMAKE_BUILD_TYPE=Release .. && \
+ make && \
+ make install && \
+ cd - && \
+ rm -Rf /tmp/clFFT
# gpyFFT
-RUN cd /tmp \
- && git clone https://github.com/geggo/gpyfft \
- && cd gpyfft \
- && pip install . \
- && cd - \
- && rm -Rf /tmp/gpyfft
-
-# python graphtools
-RUN cd /tmp \
- && wget https://downloads.skewed.de/graph-tool/graph-tool-2.26.tar.bz2 \
- && tar -xvjf graph-tool-2.26.tar.bz2 \
- && cd graph-tool-2.26 \
- && ./autogen.sh \
- && mkdir pycairo   \
- && find /usr/ -name 'pycairo.h' -exec cp {} ./pycairo/pycairo.h \; \
- && CPPFLAGS=-I. ./configure \
- && CPPFLAGS=-I. make -j16 \
- && make install \
- && cd - \
- && rm -Rf /tmp/graph-tool-2.26
-
-# clang 6 for hysop build test
-RUN apt-get install -y clang
-
-# pyfftw (with R2R transforms - experimental branch)
-RUN cd /tmp \
- && git clone https://github.com/drwells/pyFFTW \
- && cd pyFFTW \
- && git checkout r2r-try-two \
- && sed -i 's/\(fftw3[fl]\?_\)threads/\1omp/g' setup.py \
- && pip install . \
- && cd - \
- && rm -Rf /tmp/pyFFTW
+RUN cd /tmp && \
+ git clone https://github.com/geggo/gpyfft && \
+ cd gpyfft && \
+ pip2.7 install . && \
+ cd - && \
+ rm -Rf /tmp/gpyfft
+
+# HPTT (CPU tensor permutation library)
+RUN cd /tmp && \
+ git clone https://gitlab.com/keckj/hptt && \
+ cd hptt && \
+ mkdir build && \
+ cd build && \
+ cmake -DCMAKE_BUILD_TYPE=Release .. && \
+ make && \
+ make install && \
+ cd ../pythonAPI && \
+ pip2.7 install --upgrade . && \
+ cd /tmp && \
+ rm -Rf /tmp/hptt
+
+# fork of memory_tempfile for python 2.7
+RUN cd /tmp && \
+ git clone https://gitlab.com/keckj/memory-tempfile && \
+ cd memory-tempfile && \
+ pip2.7 install . && \
+ cd /tmp && \
+ rm -Rf /tmp/memory-tempfile
+
+# python flint (FLINT2 + ARB + python-flint)
+RUN cd /tmp \
+ && wget https://github.com/wbhart/flint2/archive/v2.6.1.tar.gz \
+ && tar -xvzf v2.6.1.tar.gz \
+ && cd flint2-2.6.1 \
+ && ./configure \
+ && make -j$(nproc) \
+ && make install \
+ && cd - \
+ && rm -rf flint2-2.6.1
+RUN cd /tmp \
+ && wget https://github.com/fredrik-johansson/arb/archive/2.18.1.tar.gz \
+ && tar -xvzf 2.18.1.tar.gz \
+ && cd arb-2.18.1 \
+ && ./configure \
+ && make -j$(nproc) \
+ && make install \
+ && cd - \
+ && rm -rf arb-2.18.1
+RUN pip2.7 install --upgrade python-flint
+
+# static fftw + pyfftw (with R2R transforms)
+# Weird pyfftw bug : not passing -O2 explicitely during build causes a segfault on import...
+# See https://bugs.gentoo.org/548776
+ENV FFTW_ROOT="/usr/local"
+ADD ci/patch/pyfftw.patch /tmp/pyfftw.patch
+RUN cd /tmp && \
+ wget http://www.fftw.org/fftw-3.3.8.tar.gz && \
+ tar -xvzf fftw-*.tar.gz && \
+ rm -f fftw-*.tar.gz && \
+ cd fftw-* && \
+ ./configure --enable-openmp --enable-threads --enable-mpi --enable-static --with-pic --prefix="${FFTW_ROOT}" --enable-single && \
+ make -j$(nproc) && \
+ make install && \
+ make clean && \
+ ./configure --enable-openmp --enable-threads --enable-mpi --enable-static --with-pic --prefix="${FFTW_ROOT}" && \
+ make -j8 && \
+ make install && \
+ make clean && \
+ ./configure --enable-openmp --enable-threads --enable-mpi --enable-static --with-pic --prefix="${FFTW_ROOT}" --enable-long-double && \
+ make -j8 && \
+ make install && \
+ rm -rf /tmp/fftw-*
+RUN cd /tmp && \
+ git clone https://github.com/drwells/pyFFTW && \
+ cd pyFFTW && \
+ git checkout r2r-try-two && \
+ sed -i 's/\(fftw3[fl]\?_\)threads/\1omp/g' setup.py && \
+ mv /tmp/pyfftw.patch . && \
+ patch -p0 -i pyfftw.patch && \
+ STATIC_FFTW_DIR="${FFTW_ROOT}/lib" CFLAGS="-Wl,-Bsymbolic -fopenmp -I${FFTW_ROOT}/include -O2" python2.7 setup.py build_ext --inplace && \
+ pip2.7 install --upgrade . && \
+ rm -rf /tmp/pyFFTW
# ensure all libraries are known by the runtime linker
RUN ldconfig
diff --git a/ci/docker_images/ubuntu/disco/Dockerfile b/ci/docker_images/ubuntu/disco/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..1a0ad6bfa9fcd4c634c1cff1a4d235d95a0014bf
--- /dev/null
+++ b/ci/docker_images/ubuntu/disco/Dockerfile
@@ -0,0 +1,222 @@
+# Test docker for gitlab-ci
+FROM ubuntu:disco
+MAINTAINER Jean-Baptiste.Keck@imag.fr
+
+# upgrade initial image
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get full-upgrade -y
+
+# get build tools and required libraries
+RUN apt-get install -y apt-utils
+RUN apt-get install -y expat
+RUN apt-get install -y unzip
+RUN apt-get install -y xz-utils
+RUN apt-get install -y automake
+RUN apt-get install -y libtool
+RUN apt-get install -y pkg-config
+RUN apt-get install -y cmake
+RUN apt-get install -y git
+RUN apt-get install -y vim
+RUN apt-get install -y ssh
+RUN apt-get install -y gcc
+RUN apt-get install -y gfortran
+RUN apt-get install -y cython
+RUN apt-get install -y swig
+RUN apt-get install -y lsb-core
+RUN apt-get install -y cpio
+RUN apt-get install -y libnuma1
+RUN apt-get install -y libpciaccess0
+RUN apt-get install -y libreadline-dev
+RUN apt-get install -y libboost-all-dev
+RUN apt-get install -y libblas-dev
+RUN apt-get install -y liblapack-dev
+RUN apt-get install -y libcgal-dev
+RUN apt-get install -y libatlas-base-dev
+RUN apt-get install -y libopenblas-dev
+RUN apt-get install -y libgfortran3
+RUN apt-get install -y libgcc1
+RUN apt-get install -y libopenmpi-dev
+RUN apt-get install -y libhdf5-openmpi-dev
+RUN apt-get install -y libfftw3-dev
+RUN apt-get install -y libfftw3-mpi-dev
+RUN apt-get install -y libgmp-dev
+RUN apt-get install -y libmpfr-dev
+RUN apt-get install -y libmpc-dev
+RUN apt-get install -y libflint-dev
+RUN apt-get install -y libsparsehash-dev
+RUN apt-get install -y libcairo-dev
+RUN apt-get install -y libcairomm-1.0-dev
+RUN apt-get install -y python
+RUN apt-get install -y python-dev
+RUN apt-get install -y python-pip
+RUN apt-get install -y python-tk
+RUN apt-get install -y python-backports.weakref
+RUN apt-get install -y python-backports.functools-lru-cache
+RUN apt-get install -y opencl-headers
+RUN apt-get install -y ocl-icd-libopencl1
+RUN apt-get install -y clinfo
+RUN apt-get install -y clang
+
+# some python packages
+RUN pip install --upgrade pip
+RUN pip install --upgrade setuptools
+RUN pip install --upgrade backports.weakref
+RUN pip install --upgrade cffi
+RUN pip install --upgrade wheel
+RUN pip install --upgrade pytest
+RUN pip install --upgrade numpy
+RUN pip install --upgrade scipy
+RUN pip install --upgrade sympy
+RUN pip install --upgrade matplotlib
+RUN pip install --upgrade mpi4py
+RUN CC=mpicc HDF5_MPI="ON" pip install --upgrade --no-binary=h5py h5py
+RUN pip install --upgrade gmpy2
+RUN pip install --upgrade psutil
+RUN pip install --upgrade py-cpuinfo
+RUN pip install --upgrade Mako
+RUN pip install --upgrade subprocess32
+RUN pip install --upgrade editdistance
+RUN pip install --upgrade portalocker
+RUN pip install --upgrade colors.py
+RUN pip install --upgrade tee
+RUN pip install --upgrade primefac
+RUN pip install --upgrade pycairo
+RUN pip install --upgrade weave
+RUN pip install --upgrade argparse_color_formatter
+RUN pip install --upgrade numba
+RUN pip install --upgrade pybind11
+
+# documentation
+RUN pip install --upgrade sphinx
+RUN pip install --upgrade sphinxcontrib-bibtex
+RUN pip install --upgrade sphinx_bootstrap_theme
+RUN pip install --upgrade strip-hints
+RUN cd /tmp && git clone https://github.com/sphinx-contrib/doxylink.git && cd doxylink/sphinxcontrib/doxylink \
+ && mv doxylink.py doxylink.py3 && strip-hints doxylink.py3 > doxylink.py && rm doxylink.py3 \
+ && mv parsing.py parsing.py3 && strip-hints parsing.py3 > parsing.py && rm parsing.py3 \
+ && cd ../.. && python setup.py install
+
+# scitools (python-scitools does not exist on ubuntu:disco)
+RUN cd /tmp \
+ && git clone https://github.com/hplgit/scitools \
+ && cd scitools \
+ && pip install . \
+ && cd - \
+ && rm -Rf /tmp/scitools
+
+# Intel OpenCl runtime
+RUN cd /tmp \
+&& mkdir intel \
+&& cd intel \
+&& wget http://registrationcenter-download.intel.com/akdlm/irc_nas/vcp/15532/l_opencl_p_18.1.0.015.tgz \
+&& tar -xvzf l_opencl_p_18.1.0.015.tgz \
+&& cd l_opencl_p_18.1.0.015 \
+&& sed -i "s/ACCEPT_EULA=decline/ACCEPT_EULA=accept/g" "silent.cfg" \
+&& ./install.sh --silent ./silent.cfg \
+&& cd /tmp \
+&& rm -Rf /tmp/intel
+
+# clpeak
+RUN cd /tmp \
+&& git clone https://github.com/krrishnarraj/clpeak \
+&& cd clpeak/ \
+&& mkdir build \
+&& cd build/ \
+&& cmake .. \
+&& make -j$(nproc) \
+&& mv clpeak /usr/local/bin/ \
+&& cd - \
+&& rm -Rf /tmp/clpeak
+
+# pyopencl
+RUN cd /tmp \
+&& git clone https://github.com/inducer/pyopencl \
+&& cd pyopencl \
+&& git submodule update --init \
+&& ./configure.py \
+&& make -j$(nproc) \
+&& pip install --upgrade . \
+&& cd - \
+&& rm -Rf /tmp/pyopencl
+
+# clFFT
+RUN cd /tmp \
+ && ln -s /usr/local/lib /usr/local/lib64 \
+ && git clone https://github.com/clMathLibraries/clFFT \
+ && cd clFFT \
+ && cd src \
+ && mkdir build \
+ && cd build \
+ && cmake -DCMAKE_BUILD_TYPE=Release .. \
+ && make -j$(nproc) \
+ && make install \
+ && cd - \
+ && rm -Rf /tmp/clFFT
+
+# gpyFFT
+RUN cd /tmp \
+ && git clone https://github.com/geggo/gpyfft \
+ && cd gpyfft \
+ && pip install . \
+ && cd - \
+ && rm -Rf /tmp/gpyfft
+
+# pyfftw (with R2R transforms - experimental branch)
+RUN cd /tmp \
+ && git clone https://github.com/drwells/pyFFTW \
+ && cd pyFFTW \
+ && git checkout r2r-try-two \
+ && sed -i 's/\(fftw3[fl]\?_\)threads/\1omp/g' setup.py \
+ && pip install . \
+ && cd - \
+ && rm -Rf /tmp/pyFFTW
+
+# python-flint
+RUN cd /tmp \
+ && wget https://github.com/fredrik-johansson/arb/archive/2.16.0.tar.gz \
+ && tar -xvzf 2.16.0.tar.gz \
+ && cd arb-2.16.0 \
+ && ./configure \
+ && make -j$(nproc) \
+ && make install \
+ && cd - \
+ && rm -Rf arb-2.16.0
+RUN cd /tmp \
+ && git clone https://github.com/fredrik-johansson/python-flint \
+ && cd python-flint \
+ && pip install . \
+ && cd - \
+ && rm -Rf python-flint
+
+# python graphtools
+RUN cd /tmp \
+ && wget https://downloads.skewed.de/graph-tool/graph-tool-2.28.tar.bz2 \
+ && tar -xvjf graph-tool-2.28.tar.bz2 \
+ && cd graph-tool-2.28 \
+ && ./autogen.sh \
+ && mkdir pycairo   \
+ && find /usr/ -name 'pycairo.h' -exec cp {} ./pycairo/pycairo.h \; \
+ && CPPFLAGS=-I. ./configure \
+ && CPPFLAGS=-I. make -j16 \
+ && make install \
+ && cd - \
+ && rm -Rf /tmp/graph-tool-2.28
+
+# fix some python packages...
+RUN pip uninstall -y backports.weakref
+RUN pip uninstall -y backports.functools-lru-cache
+RUN pip uninstall -y configparser
+RUN apt-get install --reinstall -y python-backports.weakref
+RUN apt-get install --reinstall -y python-backports.functools-lru-cache
+RUN apt-get install --reinstall -y python-configparser
+
+# ensure all libraries are known by the runtime linker
+RUN ldconfig
+
+# clean cached packages
+RUN rm -rf /var/lib/apt/lists/*
+RUN rm -rf $HOME/.cache/pip/*
+RUN rm -rf /tmp/*
+
+CMD ["/bin/bash"]
diff --git a/ci/docker_images/ubuntu/focal/Dockerfile b/ci/docker_images/ubuntu/focal/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..193df3282d70613218c0c2d2085f8632fb618e13
--- /dev/null
+++ b/ci/docker_images/ubuntu/focal/Dockerfile
@@ -0,0 +1,246 @@
+# Test docker for gitlab-ci
+FROM ubuntu:focal
+MAINTAINER Jean-Baptiste.Keck@imag.fr
+
+# parallel builds
+ARG NTHREADS
+ENV MAKEFLAGS "-j${NTHREADS}"
+
+# upgrade initial image
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get full-upgrade -y
+
+# get build tools and required libraries
+RUN apt-get install -y --no-install-recommends expat unzip xz-utils automake libtool pkg-config cmake rsync git vim ssh curl wget ca-certificates gcc g++ gfortran lsb-core cpio libnuma1 libpciaccess0 libreadline-dev libblas-dev liblapack-dev libgcc-9-dev libgfortran-9-dev libgmp-dev libmpfr-dev libmpc-dev python2.7-dev opencl-headers swig libgmp-dev libmpfr-dev libmpc-dev libcairo-dev libcairomm-1.0-dev python2.7-tk
+
+# python packages using pip2.7
+RUN cd /tmp && \
+ curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
+ python2.7 get-pip.py && \
+ pip2.7 install --upgrade pip && \
+ rm -f /tmp/get-pip.py
+RUN pip2.7 install --upgrade numpy setuptools cffi wheel pytest pybind11 cython
+
+# OpenMPI 4 + mpi4py (enable mpi1 compatibility for mpi4py)
+ENV MPI_ROOT "/usr/local"
+RUN cd /tmp && \
+ wget https://download.open-mpi.org/release/open-mpi/v4.0/openmpi-4.0.4.tar.gz && \
+ tar -xvzf openmpi-*.tar.gz && \
+ rm -f openmpi-*.tar.gz && \
+ cd openmpi-* && \
+ ./configure --enable-shared --disable-static --with-threads=posix --enable-ipv6 --prefix="${MPI_ROOT}" --with-hwloc=internal --with-libevent=internal --enable-mpi1-compatibility && \
+ make -j$(nproc) && \
+ make install && \
+ rm -rf /tmp/openmpi-*
+
+ENV MPICC "${MPI_ROOT}/bin/mpicc"
+RUN ldconfig && pip2.7 install --upgrade mpi4py
+
+# HDF5 + h5py (v1.10.6 is currently the last supported by h5py)
+RUN cd /tmp && \
+ wget https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/hdf5-1.10.6/src/hdf5-1.10.6.tar.gz && \
+ tar -xvzf hdf5-*.tar.gz && \
+ rm -rf hdf5-*.tar.gz && \
+ cd hdf5-* && \
+ CC="${MPICC}" ./configure --prefix="${MPI_ROOT}" --enable-parallel --enable-shared=yes --enable-static=no && \
+ make -j$(nproc) && \
+ make install && \
+ rm -rf /tmp/hdf5-*
+RUN CC="${MPICC}" HDF5_MPI="ON" HDF5_VERSION="1.10.6" HDF5_DIR="${MPI_ROOT}" pip2.7 install --upgrade --no-binary=h5py h5py
+
+# llvm + numba + llvmlite (llvmlite 0.32 has a bug with llvm8)
+RUN apt-get install -y llvm-8-dev libclang-8-dev clang-8
+ENV LLVM_CONFIG=llvm-config-8
+RUN pip2.7 install --upgrade numba llvmlite==0.31.0
+
+# other python packages
+RUN pip2.7 install --upgrade backports.weakref backports.tempfile scipy sympy matplotlib gmpy2 psutil py-cpuinfo Mako subprocess32 editdistance portalocker colors.py tee primefac pycairo weave argparse_color_formatter networkx pyvis zarr numcodecs jsonpickle
+
+# patchelf
+RUN cd /tmp && \
+ git clone https://github.com/NixOS/patchelf && \
+ cd patchelf && \
+ ./bootstrap.sh && \
+ ./configure && \
+ make && \
+ make install && \
+ cd - && \
+ rm -Rf /tmp/patchelf
+
+# Intel experimental OpenCL platform with SYCL support (2020-06)
+ENV LD_LIBRARY_PATH "/opt/intel/oclcpuexp/x64:${LD_LIBRARY_PATH}"
+RUN mkdir -p /opt/intel/oclcpuexp && \
+ wget https://github.com/intel/llvm/releases/download/2020-06/oclcpuexp-2020.10.6.0.4_rel.tar.gz && \
+ tar -xvzf oclcpuexp-*.tar.gz && \
+ mv x64/ /opt/intel/oclcpuexp/ && \
+ mv clbltfnshared.rtl /opt/intel/oclcpuexp/ && \
+ rm -rf *.rtl oclcpuexp-* && \
+ wget https://github.com/oneapi-src/oneTBB/releases/download/v2020.3/tbb-2020.3-lin.tgz && \
+ tar -xvzf tbb-*.tgz && \
+ mv tbb/lib/intel64/gcc4.8/* /opt/intel/oclcpuexp/x64/ && \
+ rm -f /usr/local/lib/libOpenCL.so && \
+ rm -f /usr/local/lib/libOpenCL.so && \
+ rm -f /usr/local/lib/libOpenCL.so.1 && \
+ rm -f /usr/local/lib/libOpenCL.so.2.0 && \
+ ln -s /opt/intel/oclcpuexp/x64/libOpenCL.so /usr/local/lib/libOpenCL.so && \
+ ln -s /opt/intel/oclcpuexp/x64/libOpenCL.so.1 /usr/local/lib/libOpenCL.so.1 && \
+ ln -s /opt/intel/oclcpuexp/x64/libOpenCL.so.2.0 /usr/local/lib/libOpenCL.so.2.0 && \
+ mkdir -p /etc/OpenCL/vendors && \
+ echo /opt/intel/oclcpuexp/x64/libintelocl.so > /etc/OpenCL/vendors/intel_expcpu.icd && \
+ rm -rf /tmp/tbb*
+
+# clinfo 2.2.18 (2018)
+RUN cd /tmp && \
+ wget https://github.com/Oblomov/clinfo/archive/2.2.18.04.06.tar.gz && \
+ tar -xvzf *.tar.gz && \
+ rm -f *.tar.gz && \
+ cd clinfo-* && \
+ make && \
+ mv clinfo /usr/local/bin && \
+ rm -rf /tmp/clinfo-*
+
+# clpeak 1.1.0 RC2 (2019)
+RUN cd /tmp && \
+ wget https://github.com/krrishnarraj/clpeak/archive/1.1.0-rc2.tar.gz && \
+ tar -xvzf *.tar.gz && \
+ rm -f *.tar.gz && \
+ cd clpeak-* && \
+ mkdir build && \
+ cd build/ && \
+ cmake .. && \
+ make && \
+ mv clpeak /usr/local/bin && \
+ rm -rf /tmp/clpeak-*
+
+# pyopencl
+RUN cd /tmp && \
+ git clone https://github.com/inducer/pyopencl && \
+ cd pyopencl && \
+ git submodule update --init && \
+ git checkout v2020.1 && \
+ python2.7 configure.py && \
+ make && \
+ pip2.7 install --upgrade . && \
+ cd - && \
+ rm -Rf /tmp/pyopencl
+
+# oclgrind
+RUN cd /tmp && \
+ git clone https://github.com/jrprice/Oclgrind && \
+ cd Oclgrind && \
+ mkdir build && \
+ cd build && \
+ cmake -DCMAKE_BUILD_TYPE=Release .. && \
+ make && \
+ make install && \
+ cd - && \
+ rm -Rf /tmp/Oclgrind
+
+# clFFT
+RUN cd /tmp && \
+ ln -s /usr/local/lib /usr/local/lib64 && \
+ git clone https://github.com/clMathLibraries/clFFT && \
+ cd clFFT && \
+ cd src && \
+ mkdir build && \
+ cd build && \
+ cmake -DCMAKE_BUILD_TYPE=Release .. && \
+ make && \
+ make install && \
+ cd - && \
+ rm -Rf /tmp/clFFT
+
+# gpyFFT
+RUN cd /tmp && \
+ git clone https://github.com/geggo/gpyfft && \
+ cd gpyfft && \
+ pip2.7 install . && \
+ cd - && \
+ rm -Rf /tmp/gpyfft
+
+# HPTT (CPU tensor permutation library)
+RUN cd /tmp && \
+ git clone https://gitlab.com/keckj/hptt && \
+ cd hptt && \
+ mkdir build && \
+ cd build && \
+ cmake -DCMAKE_BUILD_TYPE=Release .. && \
+ make && \
+ make install && \
+ cd ../pythonAPI && \
+ pip2.7 install --upgrade . && \
+ cd /tmp && \
+ rm -Rf /tmp/hptt
+
+# fork of memory_tempfile for python 2.7
+RUN cd /tmp && \
+ git clone https://gitlab.com/keckj/memory-tempfile && \
+ cd memory-tempfile && \
+ pip2.7 install . && \
+ cd /tmp && \
+ rm -Rf /tmp/memory-tempfile
+
+# python flint (FLINT2 + ARB + python-flint)
+RUN cd /tmp \
+ && wget https://github.com/wbhart/flint2/archive/v2.6.1.tar.gz \
+ && tar -xvzf v2.6.1.tar.gz \
+ && cd flint2-2.6.1 \
+ && ./configure \
+ && make -j$(nproc) \
+ && make install \
+ && cd - \
+ && rm -rf flint2-2.6.1
+RUN cd /tmp \
+ && wget https://github.com/fredrik-johansson/arb/archive/2.18.1.tar.gz \
+ && tar -xvzf 2.18.1.tar.gz \
+ && cd arb-2.18.1 \
+ && ./configure \
+ && make -j$(nproc) \
+ && make install \
+ && cd - \
+ && rm -rf arb-2.18.1
+RUN pip2.7 install --upgrade python-flint
+
+# static fftw + pyfftw (with R2R transforms)
+# Weird pyfftw bug : not passing -O2 explicitely during build causes a segfault on import...
+# See https://bugs.gentoo.org/548776
+ENV FFTW_ROOT="/usr/local"
+ADD ci/patch/pyfftw.patch /tmp/pyfftw.patch
+RUN cd /tmp && \
+ wget http://www.fftw.org/fftw-3.3.8.tar.gz && \
+ tar -xvzf fftw-*.tar.gz && \
+ rm -f fftw-*.tar.gz && \
+ cd fftw-* && \
+ ./configure --enable-openmp --enable-threads --enable-mpi --enable-static --with-pic --prefix="${FFTW_ROOT}" --enable-single && \
+ make -j$(nproc) && \
+ make install && \
+ make clean && \
+ ./configure --enable-openmp --enable-threads --enable-mpi --enable-static --with-pic --prefix="${FFTW_ROOT}" && \
+ make -j8 && \
+ make install && \
+ make clean && \
+ ./configure --enable-openmp --enable-threads --enable-mpi --enable-static --with-pic --prefix="${FFTW_ROOT}" --enable-long-double && \
+ make -j8 && \
+ make install && \
+ rm -rf /tmp/fftw-*
+RUN cd /tmp && \
+ git clone https://github.com/drwells/pyFFTW && \
+ cd pyFFTW && \
+ git checkout r2r-try-two && \
+ sed -i 's/\(fftw3[fl]\?_\)threads/\1omp/g' setup.py && \
+ mv /tmp/pyfftw.patch . && \
+ patch -p0 -i pyfftw.patch && \
+ STATIC_FFTW_DIR="${FFTW_ROOT}/lib" CFLAGS="-Wl,-Bsymbolic -fopenmp -I${FFTW_ROOT}/include -O2" python2.7 setup.py build_ext --inplace && \
+ pip2.7 install --upgrade . && \
+ rm -rf /tmp/pyFFTW
+
+# ensure all libraries are known by the runtime linker
+RUN ldconfig
+
+# clean cached packages
+RUN rm -rf /var/lib/apt/lists/*
+RUN rm -rf $HOME/.cache/pip/*
+RUN rm -rf /tmp/*
+
+CMD ["/bin/bash"]
diff --git a/ci/patch/pyfftw.patch b/ci/patch/pyfftw.patch
new file mode 100644
index 0000000000000000000000000000000000000000..d659715deef15bf3cc9fc35b01dc1ba04252ccb4
--- /dev/null
+++ b/ci/patch/pyfftw.patch
@@ -0,0 +1,40 @@
+--- setup.py.origin 2020-03-11 15:59:29.426762235 +0100
++++ setup.py 2020-03-11 16:02:32.366226427 +0100
+@@ -53,6 +53,9 @@
+ ISRELEASED = False
+ VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO)
+
++static_fftw_path = os.environ.get('STATIC_FFTW_DIR', None)
++link_static_fftw = static_fftw_path is not None
++
+ def get_package_data():
+ from pkg_resources import get_build_platform
+
+@@ -121,8 +124,27 @@
+
+ have_cython = False
+
++ if link_static_fftw:
++ from pkg_resources import get_build_platform
++ if get_build_platform() in ('win32', 'win-amd64'):
++ lib_pre = ''
++ lib_ext = '.lib'
++ else:
++ lib_pre = 'lib'
++ lib_ext = '.a'
++ extra_link_args = []
++ for lib in common_extension_args['libraries']:
++ extra_link_args.append(
++ os.path.join(static_fftw_path, lib_pre + lib + lib_ext))
++ # now that full paths to libraries are in extra_link_args remove them
++ # from common_extension_args
++ common_extension_args['libraries'] = []
++ else:
++ extra_link_args = []
++
+ ext_modules = [
+ Extension('pyfftw.pyfftw', sources=sources,
++ extra_link_args = extra_link_args,
+ **common_extension_args)]
+
+ if have_cython:
diff --git a/ci/scripts/build.sh b/ci/scripts/build.sh
old mode 100644
new mode 100755
index 1b894cab18e6caaf12d23afe32601ac74e51cffa..22fb87ba690b58beb52cd0389b2297d5c4f304c0
--- a/ci/scripts/build.sh
+++ b/ci/scripts/build.sh
@@ -1,18 +1,18 @@
#!/bin/bash
-set -e
+set -feu -o pipefail
if [ $# -ne 4 ]; then
echo "Usage ./build build_folder CC CXX FC"
exit 1
fi
-if [ ! -d "$1" ]; then
- echo "Folder {} does not exist."
+
+BUILD_FOLDER="$1"
+if [ ! -d "$BUILD_FOLDER" ]; then
+ echo "Folder $1 has not been generated by previous step."
exit 1
fi
-BUILD_FOLDER="$1"
-mkdir -p $BUILD_FOLDER
cd $BUILD_FOLDER
if [ ! -f Makefile ]; then
echo "The makefile has not been generated."
diff --git a/ci/scripts/build_and_debug.sh b/ci/scripts/build_and_debug.sh
new file mode 100755
index 0000000000000000000000000000000000000000..de66fc1046209834cc08435120916087392c244e
--- /dev/null
+++ b/ci/scripts/build_and_debug.sh
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+
+# /hysop should be mounted as read only by run_tests_in_docker.sh
+if [[ ! -d '/hysop' ]]; then
+ echo "This script should not be called from host, but from within a docker image."
+ echo " => /hysop has not been mounted (see hysop/ci/utils/run_debug.sh)."
+ exit 1
+fi
+
+CC=gcc
+CXX=g++
+FC=gfortran
+
+HYSOP_DIR='/tmp/hysop'
+
+cp -r /hysop "${HYSOP_DIR}"
+rm -rf "${HYSOP_DIR}/build"
+
+cd "${HYSOP_DIR}"
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Debug ..
+make -j8
+make install
+cd -
+rm -rf build
+
+apt-get update
+apt-get install -y gdb python-dbg
+
+bash
diff --git a/ci/scripts/build_and_test.sh b/ci/scripts/build_and_test.sh
new file mode 100755
index 0000000000000000000000000000000000000000..9465a2dd6a3e2544369ed5ca0fb1273be2b9f19e
--- /dev/null
+++ b/ci/scripts/build_and_test.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+
+# /hysop should be mounted as read only by run_tests_in_docker.sh
+if [[ ! -d '/hysop' ]]; then
+ echo "This script should not be called from host, but from within a docker image."
+ echo " => /hysop has not been mounted (see hysop/ci/utils/run_ci.sh)."
+ exit 1
+fi
+
+CC=gcc
+CXX=g++
+FC=gfortran
+
+HYSOP_DIR='/tmp/hysop'
+HYSOP_BUILD_DIR="${HYSOP_DIR}/build"
+HYSOP_INSTALL_DIR='/opt/hysop'
+
+cp -r /hysop "${HYSOP_DIR}"
+rm -rf "${HYSOP_BUILD_DIR}"
+
+SCRIPT_DIR="${HYSOP_DIR}/ci/scripts"
+cd "${HYSOP_DIR}"
+${SCRIPT_DIR}/version.sh
+${SCRIPT_DIR}/config.sh "${HYSOP_BUILD_DIR}" "${HYSOP_INSTALL_DIR}" "${CC}" "${CXX}" "${FC}"
+${SCRIPT_DIR}/build.sh "${HYSOP_BUILD_DIR}" "${CC}" "${CXX}" "${FC}"
+${SCRIPT_DIR}/install.sh "${HYSOP_BUILD_DIR}" "${HYSOP_INSTALL_DIR}"
+time ${SCRIPT_DIR}/test.sh "${HYSOP_INSTALL_DIR}" "${HYSOP_DIR}/hysop"
+
+# clean everything because image may be commited to retain hysop cache
+cd
+rm -rf /tmp/hysop
+pip2.7 uninstall hysop
diff --git a/ci/scripts/config.sh b/ci/scripts/config.sh
index c2c8e6a22e62fe59508a351c7b6e0b3d0a4e28df..ac2158623814d2e73893c48d6e827c8dd2c9c12e 100755
--- a/ci/scripts/config.sh
+++ b/ci/scripts/config.sh
@@ -1,5 +1,5 @@
#!/bin/bash
-set -e
+set -feu -o pipefail
if [ $# -ne 5 ]; then
echo "Usage ./config build_folder install_folder CC CXX FC"
@@ -20,9 +20,9 @@ ROOT_DIR="$(pwd)"
BUILD_DIR="$1"
INSTALL_DIR="$2"
-mkdir -p $BUILD_DIR
-cd $BUILD_DIR
-CC="$3" CXX="$4" FC="$5" cmake -DCMAKE_BUILD_TYPE=Release -DVERBOSE=OFF -DWITH_SCALES=ON -DHYSOP_INSTALL=$INSTALL_DIR $ROOT_DIR
+mkdir -p "${BUILD_DIR}"
+cd "${BUILD_DIR}"
+CC="$3" CXX="$4" FC="$5" cmake -DCMAKE_BUILD_TYPE=Release -DVERBOSE=OFF -DWITH_SCALES=ON -DPYTHON_EXECUTABLE="$(which python2.7)" -DHYSOP_INSTALL="${INSTALL_DIR}" -DFIND_FFTW_STATIC_ONLY=ON -DFIND_FFTW_VERBOSE=ON "${ROOT_DIR}"
if [ ! -f Makefile ]; then
echo "The makefile has not been generated."
diff --git a/ci/scripts/install.sh b/ci/scripts/install.sh
old mode 100644
new mode 100755
index f37f559698dc82b7289fb63a9ae8ea84f20e202c..82f3f64561b88e76e38b02cac4a2b8b6e66aaa44
--- a/ci/scripts/install.sh
+++ b/ci/scripts/install.sh
@@ -1,6 +1,7 @@
-
#!/bin/bash
-set -e
+set -feu -o pipefail
+
+PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE:-"$(which python2.7)"}
if [ $# -ne 2 ]; then
echo "Usage ./install build_folder install_folder"
@@ -20,15 +21,15 @@ fi
BUILD_FOLDER="$1"
INSTALL_FOLDER="$2"
-cd $BUILD_FOLDER
+cd "${BUILD_FOLDER}"
make install
-if [ ! -d "$INSTALL_FOLDER/lib/python2.7/site-packages/hysop" ]; then
- echo "$INSTALL_FOLDER/lib/python2.7/site-packages/hysop was not created."
+if [ ! -d "${INSTALL_FOLDER}/lib/python2.7/site-packages/hysop" ]; then
+ echo "${INSTALL_FOLDER}/lib/python2.7/site-packages/hysop was not created."
exit 1
fi
-export PYTHONPATH="$INSTALL_FOLDER/lib/python2.7/site-packages"
-python -c 'import hysop; print hysop'
+export PYTHONPATH="${INSTALL_FOLDER}/lib/python2.7/site-packages"
+"${PYTHON_EXECUTABLE}" -c 'import hysop; print hysop'
exit 0
diff --git a/ci/scripts/test.sh b/ci/scripts/test.sh
index d73406f8d7397a2a9d9c8dc6c1c777387fdc9bcf..706a8f1e11110def06193a245dbd09f168856663 100755
--- a/ci/scripts/test.sh
+++ b/ci/scripts/test.sh
@@ -1,13 +1,15 @@
#!/bin/bash
-set -e
+set -feu -o pipefail
+
+PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE:-"$(which python2.7)"}
if [ $# -lt 2 ]; then
- echo "Usage ./test install_folder hysop_folder [cache_dir]"
+ echo "Usage ./test install_folder hysop_folder [cache_dir] [backup_cache_dir]"
exit 1
fi
-if [ $# -gt 3 ]; then
- echo "Usage ./test install_folder hysop_folder [cache_dir]"
+if [ $# -gt 4 ]; then
+ echo "Usage ./test install_folder hysop_folder [cache_dir] [backup_cache_dir]"
exit 1
fi
@@ -21,93 +23,146 @@ if [ ! -d "$2" ]; then
exit 1
fi
-INSTALL_DIR=$1
-HYSOP_DIR=$2
-if [ $# -eq 3 ]; then
- CACHE_DIR=$3
+INSTALL_DIR="$1"
+HYSOP_DIR="$2"
+HYSOP_CACHE_DIR="${HOME}/.cache"
+
+if [ $# -gt 2 ]; then
+ CACHE_DIR="$3"
HAS_CACHE_DIR=true
else
HAS_CACHE_DIR=false
fi
-if [ "$HAS_CACHE_DIR" = true ]; then
- if [ -d "$CACHE_DIR" ]; then
+if [ $# -gt 3 ]; then
+ BACKUP_CACHE_DIR="$4"
+ HAS_BACKUP_CACHE_DIR=true
+else
+ HAS_BACKUP_CACHE_DIR=false
+fi
+
+if [ "${HAS_CACHE_DIR}" = true ]; then
+ mkdir -p "${HYSOP_CACHE_DIR}"
+ if [ -d "${CACHE_DIR}" ]; then
echo "Cache directory '$CACHE_DIR' was found."
- mkdir -p /root/.cache
- cp -r $CACHE_DIR/* /root/.cache
+ rsync -rtvu "${CACHE_DIR}/" "${HYSOP_CACHE_DIR}/"
else
- echo "Cache directory '$CACHE_DIR' was not found."
- mkdir -p $CACHE_DIR
+ # Untill gitlab allows cache on failure we need
+ # to provide initial cache so that CI succeeds (< 1h tests)
+ # See https://gitlab.com/gitlab-org/gitlab/-/issues/18969
+ # Initial cache can be injected in the docker image, see hysop/ci/utils/run_ci.sh.
+ echo "Cache directory '$CACHE_DIR' does not exist, trying to use backup cache directory."
+ if [[ "${HAS_BACKUP_CACHE_DIR}" = true ]]; then
+ if [[ -d "${BACKUP_CACHE_DIR}" ]]; then
+ echo "Backup cache directory '${BACKUP_CACHE_DIR}' was found."
+ rsync -rtvu "${BACKUP_CACHE_DIR}/" "${HYSOP_CACHE_DIR}/"
+ else
+ echo "Backup directory '${BACKUP_CACHE_DIR}' does not exist."
+ fi
+ else
+ echo "No backup cache directory has been specified."
+ fi
fi
+ mkdir -p "${CACHE_DIR}"
fi
-DO_TESTS=${DO_TESTS:-true}
-DO_EXAMPLES=${DO_EXAMPLES:-true}
-DO_LONG_TESTS=${DO_LONG_TESTS:-false}
-
-export PYTHONPATH="$INSTALL_DIR/lib/python2.7/site-packages:$INSTALL_DIR:$PYTHONPATH"
+export PYTHONPATH="${INSTALL_DIR}/lib/python2.7/site-packages:${INSTALL_DIR}"
export MPLBACKEND='cairo'
export HYSOP_VERBOSE=0
export HYSOP_DEBUG=0
export HYSOP_PROFILE=0
export HYSOP_KERNEL_DEBUG=0
-python -c 'import hysop; print hysop'
-
-if [ "$DO_TESTS" = true ]; then
- python "$HYSOP_DIR/core/arrays/tests/test_array.py"
- python "$HYSOP_DIR/core/graph/tests/test_graph.py"
- python "$HYSOP_DIR/fields/tests/test_fields.py"
- $HYSOP_DIR/fields/tests/test_cartesian.sh
- python "$HYSOP_DIR/numerics/tests/test_fft.py"
- python "$HYSOP_DIR/operator/tests/test_analytic.py"
- python "$HYSOP_DIR/operator/tests/test_transpose.py"
- python "$HYSOP_DIR/operator/tests/test_fd_derivative.py"
- python "$HYSOP_DIR/operator/tests/test_absorption.py"
- python "$HYSOP_DIR/operator/tests/test_lowpass_filter.py"
- python "$HYSOP_DIR/operator/tests/test_directional_advection.py"
- python "$HYSOP_DIR/operator/tests/test_directional_diffusion.py"
- python "$HYSOP_DIR/operator/tests/test_directional_stretching.py"
- python "$HYSOP_DIR/operator/tests/test_custom_symbolic.py"
- python "$HYSOP_DIR/operator/tests/test_spectral_derivative.py"
- python "$HYSOP_DIR/operator/tests/test_spectral_curl.py"
- python "$HYSOP_DIR/operator/tests/test_diffusion.py"
- python "$HYSOP_DIR/operator/tests/test_poisson.py"
- python "$HYSOP_DIR/operator/tests/test_solenoidal_projection.py"
- python "$HYSOP_DIR/operator/tests/test_poisson_curl.py"
-
- # If scales (fortran advection library) is installed
- python -c "from hysop.f2hysop import scales2py as scales" && python "$HYSOP_DIR/operator/tests/test_scales_advection.py"
- python -c "from hysop.f2hysop import scales2py as scales" && python "$HYSOP_DIR/operator/tests/test_bilevel_advection.py"
+
+# OpenMPI specific variables
+export OMPI_ALLOW_RUN_AS_ROOT=1
+export OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1
+export OMPI_MCA_rmaps_base_oversubscribe=1
+
+echo "Trying to load hysop module:"
+${PYTHON_EXECUTABLE} -c 'import hysop; print hysop'
+echo "module import successful !"
+echo
+
+echo "Default testing OpenCL platform is:"
+${PYTHON_EXECUTABLE} -c 'import hysop; from hysop.testsenv import iter_clenv; print next(iter(iter_clenv()));'
+
+RUN_TESTS=${RUN_TESTS:-true}
+RUN_EXAMPLES=${RUN_EXAMPLES:-true}
+RUN_LONG_TESTS=${RUN_LONG_TESTS:-false}
+
+COMMON_TEST_OPTIONS=''
+TEST_DIR="$HYSOP_DIR"
+COMMON_EXAMPLE_OPTIONS='-VNC -d16 -cp float -maxit 2 --autotuner-max-candidates 1 --save-checkpoint --checkpoint-dump-freq 0 --checkpoint-dump-period 0 --checkpoint-dump-last --checkpoint-dump-times'
+EXAMPLE_DIR="$HYSOP_DIR/../hysop_examples/examples"
+
+hysop_test() {
+ test=$1
+ echo
+ echo "TESTING $1"
+ echo "========$(printf '=%.0s' `seq ${#1}`)"
+ ${PYTHON_EXECUTABLE} "${TEST_DIR}/${1}" ${@:2} ${COMMON_TEST_OPTIONS}
+ echo
+}
+example_test() {
+ test=$1
+ echo
+ echo "EXAMPLE $1"
+ echo "========$(printf '=%.0s' `seq ${#1}`)"
+ ${PYTHON_EXECUTABLE} "${EXAMPLE_DIR}/${1}" ${@:2} ${COMMON_EXAMPLE_OPTIONS}
+ echo
+}
+
+if [ "$RUN_TESTS" = true ]; then
+ hysop_test "core/arrays/tests/test_array.py"
+ hysop_test "core/graph/tests/test_graph.py"
+ hysop_test "fields/tests/test_fields.py"
+ hysop_test "numerics/tests/test_fft.py"
+ hysop_test "operator/tests/test_analytic.py"
+ hysop_test "operator/tests/test_transpose.py"
+ hysop_test "operator/tests/test_fd_derivative.py"
+ hysop_test "operator/tests/test_absorption.py"
+ hysop_test "operator/tests/test_penalization.py"
+ hysop_test "operator/tests/test_velocity_correction.py"
+ hysop_test "operator/tests/test_restriction_filter.py"
+ hysop_test "operator/tests/test_directional_advection.py"
+ hysop_test "operator/tests/test_directional_diffusion.py"
+ hysop_test "operator/tests/test_directional_stretching.py"
+ hysop_test "operator/tests/test_custom_symbolic.py"
+ hysop_test "operator/tests/test_spectral_derivative.py"
+ hysop_test "operator/tests/test_spectral_curl.py"
+ hysop_test "operator/tests/test_diffusion.py"
+ hysop_test "operator/tests/test_poisson.py"
+ hysop_test "operator/tests/test_solenoidal_projection.py"
+ hysop_test "operator/tests/test_poisson_curl.py"
+ ${HYSOP_DIR}/fields/tests/test_cartesian.sh
+ ${HYSOP_DIR}/core/tests/test_checkpoint.sh
fi
-if [ "$DO_LONG_TESTS" = true ]; then
- python "$HYSOP_DIR/backend/device/codegen/kernels/tests/test_directional_advection.py"
- python "$HYSOP_DIR/backend/device/codegen/kernels/tests/test_directional_remesh.py"
+if [ "${RUN_LONG_TESTS}" = true ]; then
+ hysop_test "backend/device/codegen/kernels/tests/test_directional_advection.py"
+ hysop_test "backend/device/codegen/kernels/tests/test_directional_remesh.py"
fi
-if [ "$DO_EXAMPLES" = true ]; then
- export HYSOP_VERBOSE=1
- EXAMPLE_DIR="$HYSOP_DIR/../examples"
- EXAMPLE_OPTIONS='-cp default -maxit 2'
- python "$EXAMPLE_DIR/analytic/analytic.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/scalar_diffusion/scalar_diffusion.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/scalar_advection/scalar_advection.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/multiresolution/scalar_advection.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/shear_layer/shear_layer.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl python $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl opencl $EXAMPLE_OPTIONS
- python -c "from hysop.f2hysop import scales2py as scales" && python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl fortran $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/bubble/periodic_bubble.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/bubble/periodic_bubble_levelset.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/bubble/periodic_bubble_levelset_penalization.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/bubble/periodic_jet_levelset.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/particles_above_salt/particles_above_salt_periodic.py" $EXAMPLE_OPTIONS
- python "$EXAMPLE_DIR/particles_above_salt/particles_above_salt_symmetrized.py" $EXAMPLE_OPTIONS
+if [ "${RUN_EXAMPLES}" = true ]; then
+ example_test "analytic/analytic.py"
+ example_test "scalar_diffusion/scalar_diffusion.py"
+ example_test "scalar_advection/scalar_advection.py"
+ example_test "scalar_advection/levelset.py"
+ example_test "multiresolution/scalar_advection.py"
+ example_test "shear_layer/shear_layer.py"
+ example_test "taylor_green/taylor_green.py" '-impl python'
+ example_test "taylor_green/taylor_green.py" '-impl opencl'
+ example_test "bubble/periodic_bubble.py"
+ example_test "bubble/periodic_bubble_levelset.py"
+ example_test "bubble/periodic_bubble_levelset_penalization.py" #LLVM bug for DP
+ example_test "bubble/periodic_jet_levelset.py"
+ example_test "particles_above_salt/particles_above_salt_periodic.py"
+ example_test "particles_above_salt/particles_above_salt_symmetrized.py"
fi
-if [ "$HAS_CACHE_DIR" = true ]; then
- cp -r /root/.cache/* $CACHE_DIR/
- find $CACHE_DIR -name '*.lock' -delete
+if [ "${HAS_CACHE_DIR}" = true ]; then
+ rsync -rtvu "${HYSOP_CACHE_DIR}/" "${CACHE_DIR}/"
+ find "${CACHE_DIR}" -name '*.lock' -delete
fi
exit 0
diff --git a/ci/scripts/version.sh b/ci/scripts/version.sh
old mode 100644
new mode 100755
index 6588201ce29c4ab1eb55fc99d70a1c1339ef647e..b6bfb5687ab720254bb256f0f25b8ed4f8e1586a
--- a/ci/scripts/version.sh
+++ b/ci/scripts/version.sh
@@ -1,5 +1,5 @@
#!/bin/bash
-set -e
+set -feu -o pipefail
echo "HOST"
uname -a
echo
diff --git a/ci/utils/build_docker_image.sh b/ci/utils/build_docker_image.sh
new file mode 100755
index 0000000000000000000000000000000000000000..5722a9b78d340a131a25a01feb7abec641d1c632
--- /dev/null
+++ b/ci/utils/build_docker_image.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+NTHREADS="$(nproc)"
+UBUNTU_RELEASE=${1:-focal}
+
+docker build --rm=true --build-arg "NTHREADS=$NTHREADS" -t "keckj/hysop:${UBUNTU_RELEASE}" -f "${SCRIPT_DIR}/../docker_images/ubuntu/${UBUNTU_RELEASE}/Dockerfile" "${SCRIPT_DIR}/../.."
diff --git a/ci/utils/pull_docker_image.sh b/ci/utils/pull_docker_image.sh
new file mode 100755
index 0000000000000000000000000000000000000000..e73e452de24bad3f050af715fb8c875c74324d53
--- /dev/null
+++ b/ci/utils/pull_docker_image.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euf -o pipefail
+UBUNTU_RELEASE=${1:-focal}
+docker logout
+docker pull "keckj/hysop:${UBUNTU_RELEASE}"
diff --git a/ci/utils/push_docker_image.sh b/ci/utils/push_docker_image.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b36ade258042775cae7990aadb763c5b7a1747d1
--- /dev/null
+++ b/ci/utils/push_docker_image.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euf -o pipefail
+UBUNTU_RELEASE=${1:-focal}
+docker login
+docker push "keckj/hysop:${UBUNTU_RELEASE}"
+docker logout
diff --git a/ci/utils/run_ci.sh b/ci/utils/run_ci.sh
new file mode 100755
index 0000000000000000000000000000000000000000..0706ebb1251c5fd7e95d4d84bc7039de875bc957
--- /dev/null
+++ b/ci/utils/run_ci.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+UBUNTU_RELEASE=${1:-focal}
+DOCKER_IMG="keckj/hysop:${UBUNTU_RELEASE}"
+CONTAINER_ID='hysop_build_and_test'
+
+function remove_img() {
+ docker stop "${CONTAINER_ID}" || true
+ docker rm "${CONTAINER_ID}" || true
+}
+trap remove_img INT TERM EXIT KILL
+
+remove_img
+
+#docker logout
+#docker pull "${DOCKER_IMG}"
+docker create -v "${SCRIPT_DIR}/../..:/hysop:ro" --name="${CONTAINER_ID}" -it "${DOCKER_IMG}"
+docker start "${CONTAINER_ID}"
+
+docker exec "${CONTAINER_ID}" /hysop/ci/scripts/build_and_test.sh
+
+# on test success, upload hysop cache to the docker images
+docker commit "${CONTAINER_ID}" "${DOCKER_IMG}"
diff --git a/ci/utils/run_debug.sh b/ci/utils/run_debug.sh
new file mode 100755
index 0000000000000000000000000000000000000000..39b1b64a914b06922a4175735c46a8413953f9e9
--- /dev/null
+++ b/ci/utils/run_debug.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+UBUNTU_RELEASE=${1:-focal}
+DOCKER_IMG="keckj/hysop:${UBUNTU_RELEASE}"
+CONTAINER_ID='hysop_build_and_debug'
+
+function remove_img() {
+ docker stop "${CONTAINER_ID}" || true
+ docker rm "${CONTAINER_ID}" || true
+}
+trap remove_img INT TERM EXIT KILL
+
+remove_img
+
+#docker logout
+#docker pull "${DOCKER_IMG}"
+docker create -v "${SCRIPT_DIR}/../..:/hysop:ro" --name="${CONTAINER_ID}" -it "${DOCKER_IMG}"
+docker start "${CONTAINER_ID}"
+docker exec -it "${CONTAINER_ID}" /hysop/ci/scripts/build_and_debug.sh
diff --git a/ci/utils/run_docker_image.sh b/ci/utils/run_docker_image.sh
new file mode 100755
index 0000000000000000000000000000000000000000..05cd63e1ae16fdcfaff076dcd3604cdac73a8381
--- /dev/null
+++ b/ci/utils/run_docker_image.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+UBUNTU_RELEASE=${1:-focal}
+docker run -it -v "${SCRIPT_DIR}/../..:/hysop:ro" "keckj/hysop:${UBUNTU_RELEASE}"
diff --git a/cmake/FindFFTW.cmake b/cmake/FindFFTW.cmake
index badd224e19a624065bc60607bef28593ef54acd0..24b1798b1d0523b43126929d40964d3baa32eb3e 100644
--- a/cmake/FindFFTW.cmake
+++ b/cmake/FindFFTW.cmake
@@ -51,7 +51,7 @@
# Examples: fFtW3Q => FFTW3Q, fftw3f-mpi => FFTW3F_MPI
#
# == Using a specific FFTW ==
-# Set the variable ${FFTW_DIR} to your desired search paths if it's not in a standard place or if you want a specific version.
+# Set the variable ${FFTW_ROOT} to your desired search paths if it's not in a standard place or if you want a specific version.
#
# == Checking against a specific version or the library ==
# Not supported yet.
@@ -65,7 +65,7 @@
# Set ${FIND_FFTW_DEBUG} to ON before find_package call to enable debug mode
#
# Written by F. Pérignon, nov/2009
-# Updated by J-B. Keck, feb/2016
+# Updated by J-B. Keck, feb/2016, march/2020
# inspired from http://www.cmake.org/Wiki/CMake:How_To_Find_Libraries
find_package(PkgConfig)
@@ -86,14 +86,18 @@ list(APPEND FFTW_COMPILE_FLAGS "")
# -- rename library to match shared or static constraints
#Check whether to search static or dynamic libs
-set( CMAKE_FIND_LIBRARY_SUFFIXES_SAV ${CMAKE_FIND_LIBRARY_SUFFIXES} )
+set( CMAKE_FIND_LIBRARY_SUFFIXES_SAVE ${CMAKE_FIND_LIBRARY_SUFFIXES} )
-if( ${FFTW_USE_STATIC_LIBS} )
- set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX} )
-else()
+if( ${FIND_FFTW_SHARED_ONLY} )
set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_LIBRARY_SUFFIX} )
+elseif( ${FIND_FFTW_STATIC_ONLY} )
+ set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX} )
endif()
+# -- always look for base fftw3 library
+# (it contains common functions for all fftw libraries)
+list(APPEND FFTW_FIND_COMPONENTS "fftw3d")
+
foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
string(REPLACE "-" "_" fftw_comp_no_dash "${fftw_comp}")
string(TOLOWER ${fftw_comp_no_dash} component)
@@ -112,8 +116,6 @@ foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
# -- find library name given the component name
string(REPLACE "fftw3d" "fftw3" library "${component}")
- set(library "lib${library}${CMAKE_FIND_LIBRARY_SUFFIXES}")
-
if(FIND_FFTW_DEBUG)
message("\tFFTW::${fftw_comp}:${COMPONENT}:${component}, LIB=${library} HEADER=${header}")
endif()
@@ -131,7 +133,7 @@ foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
find_path(
${COMPONENT}_INCLUDE_DIR
NAMES ${header}
- PATHS ${fftw_DIR}
+ PATHS ${FFTW_ROOT}
PATHS ${${COMPONENT}_PKGCONF_INCLUDE_DIRS}
PATH_SUFFIXES include
NO_DEFAULT_PATH
@@ -160,7 +162,7 @@ foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
find_library(
${COMPONENT}_LIBRARY
NAMES ${library}
- PATHS ${fftw_DIR}
+ PATHS ${FFTW_ROOT}
PATHS ${${COMPONENT}_INCLUDE_DIR}/..
PATHS ${${COMPONENT}_PKGCONF_LIBRARY_DIRS}}
PATH_SUFFIXES lib
@@ -184,7 +186,6 @@ foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
set(LIBRARY_DIR_FOUND FALSE)
else()
get_filename_component(${COMPONENT}_LIBRARY_DIR "${${COMPONENT}_LIBRARY}" DIRECTORY)
- #set(${COMPONENT}_LIBRARY "${library}")
set(LIBRARY_DIR_FOUND TRUE)
endif()
@@ -223,11 +224,15 @@ foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
list(APPEND ${COMPONENT}_LIBRARIES ${${COMPONENT}_LIBRARY})
list(APPEND ${COMPONENT}_DEFINES "-DFFTW_HAS_${COMPONENT}")
- list(APPEND FFTW_INCLUDE_DIRS ${${COMPONENT}_INCLUDE_DIRS})
- list(APPEND FFTW_LIBRARY_DIRS ${${COMPONENT}_LIBRARY_DIRS})
- list(APPEND FFTW_LIBRARIES ${${COMPONENT}_LIBRARIES})
- list(APPEND FFTW_DEFINES ${${COMPONENT}_DEFINES})
- list(APPEND FFTW_COMPILE_FLAGS ${${COMPONENT}_COMPILE_FLAGS})
+ if ( "${COMPONENT}" STREQUAL "FFTW3D" )
+ # will be added last (link order)
+ else()
+ list(APPEND FFTW_INCLUDE_DIRS ${${COMPONENT}_INCLUDE_DIRS})
+ list(APPEND FFTW_LIBRARY_DIRS ${${COMPONENT}_LIBRARY_DIRS})
+ list(APPEND FFTW_LIBRARIES ${${COMPONENT}_LIBRARIES})
+ list(APPEND FFTW_DEFINES ${${COMPONENT}_DEFINES})
+ list(APPEND FFTW_COMPILE_FLAGS ${${COMPONENT}_COMPILE_FLAGS})
+ endif()
if(FIND_FFTW_VERBOSE)
message("\tFound FFTW::${fftw_comp} with parameters '-I${${COMPONENT}_INCLUDE_DIR} -L${${COMPONENT}_LIBRARY_DIR} -l${${COMPONENT}_LIBRARY}'.")
@@ -256,12 +261,21 @@ foreach(fftw_comp ${FFTW_FIND_COMPONENTS})
unset(COMPONENT)
endforeach()
+# Here base FFTW3 library should have been found
+# and it is added last for good link order.
+list(APPEND FFTW_INCLUDE_DIRS ${FFTW3D_INCLUDE_DIRS})
+list(APPEND FFTW_LIBRARY_DIRS ${FFTW3D_LIBRARY_DIRS})
+list(APPEND FFTW_LIBRARIES ${FFTW3D_LIBRARIES})
+list(APPEND FFTW_DEFINES ${FFTW3D_DEFINES})
+list(APPEND FFTW_COMPILE_FLAGS ${FFTW3D_COMPILE_FLAGS})
+
list(REMOVE_DUPLICATES FFTW_INCLUDE_DIRS)
list(REMOVE_DUPLICATES FFTW_LIBRARY_DIRS)
list(REMOVE_DUPLICATES FFTW_LIBRARIES)
list(REMOVE_DUPLICATES FFTW_DEFINES)
list(REMOVE_DUPLICATES FFTW_COMPILE_FLAGS)
-set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAV} )
+
+set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAVE} )
# -- check required variables, version and set FFTW_FOUND to TRUE if ok
find_package_handle_standard_args(FFTW FOUND_VAR FFTW_FOUND
diff --git a/cmake/FindPythonFull.cmake b/cmake/FindPythonFull.cmake
index 646611606ac36dbb90f17eab561856ce8a195189..857bde5c98a46db43bd3d7ff3314bf0bd7f3ee9d 100644
--- a/cmake/FindPythonFull.cmake
+++ b/cmake/FindPythonFull.cmake
@@ -32,6 +32,7 @@ if(EXISTS "${PYTHON_INCLUDE_DIRS}" AND EXISTS "${PYTHON_LIBRARY}" AND EXISTS "${
else()
set(PYTHON_FOUND FALSE)
# --- Find python interpreter
+ set(Python_ADDITIONAL_VERSIONS 2.7)
find_package(PythonInterp)
# --- Use distutils to explore python configuration corresponding to
diff --git a/docs/config/hysop.doxyfile.in b/docs/config/hysop.doxyfile.in
index db08da3edde2751ff9b746d4988f570d7da9974f..c05aa8654dfde98f54538409b09078fc80d3f9af 100644
--- a/docs/config/hysop.doxyfile.in
+++ b/docs/config/hysop.doxyfile.in
@@ -51,7 +51,7 @@ PROJECT_BRIEF = "Particle Methods simulation on hybrid architectures"
# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
# the logo to the output directory.
-PROJECT_LOGO = @CMAKE_CURRENT_SOURCE_DIR@/sphinx/figures/logo_hysop_nb.png
+PROJECT_LOGO = @CMAKE_CURRENT_SOURCE_DIR@/docs/sphinx/figures/logo_hysop_nb.png
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
# into which the generated documentation will be written. If a relative path is
diff --git a/docs/config/mainpage.doxygen b/docs/config/mainpage.doxygen
index c267d5085ed6c9dd88edddb6b142bb621122f0e5..e1f084f09e143121e91bbee813b7da227c3a4692 100644
--- a/docs/config/mainpage.doxygen
+++ b/docs/config/mainpage.doxygen
@@ -54,7 +54,7 @@ At the end of this step BUILDDIR contains all makefiles, setup.py and other requ
Some useful options for cmake :
-- -DFFTW_DIR : where to find fftw if it's not in a "standard" place.
+- -DFFTW_ROOT : where to find fftw if it's not in a "standard" place.
- -DWITH_SCALES=ON/OFF : to compile an HySoP version including scales (default = on)
- -DWITH_TESTS=ON/OFF: enable testing (i.e. prepare target "make test", default = off)
@@ -64,7 +64,7 @@ mkdir /home/mylogin/buildHySoP
cd /home/mylogin/buildHySoP
export FC=mpif90
module load cmake-2.8
-cmake -DFFTW_DIR=/softs/install/fftw3.1 ~/Softs/HySoP
+cmake -DFFTW_ROOT/softs/install/fftw3.1 ~/Softs/HySoP
\endcode
\subsection installDirConfig Install directory configuration :
diff --git a/docs/doxygen_layout/footer.html b/docs/doxygen_layout/footer.html
new file mode 100644
index 0000000000000000000000000000000000000000..3d5b2080eb4b181a024b11dd82d298895e6dbb6a
--- /dev/null
+++ b/docs/doxygen_layout/footer.html
@@ -0,0 +1,21 @@
+<!-- HTML footer for doxygen 1.8.11-->
+<!-- start footer part -->
+<!--BEGIN GENERATE_TREEVIEW-->
+<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
+ <ul>
+ $navpath
+ <li class="footer">$generatedby
+ <a href="http://www.doxygen.org/index.html">
+ <img class="footer" src="$relpath^doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
+ </ul>
+</div>
+<!--END GENERATE_TREEVIEW-->
+<!--BEGIN !GENERATE_TREEVIEW-->
+<hr class="footer"/><address class="footer"><small>
+$generatedby  <a href="http://www.doxygen.org/index.html">
+<img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
+</a> $doxygenversion
+</small></address>
+<!--END !GENERATE_TREEVIEW-->
+</body>
+</html>
diff --git a/docs/doxygen_layout/header.html b/docs/doxygen_layout/header.html
new file mode 100644
index 0000000000000000000000000000000000000000..a3520ad21bd61e38afb4308b395003ec4a9e98d2
--- /dev/null
+++ b/docs/doxygen_layout/header.html
@@ -0,0 +1,55 @@
+<!-- HTML header for doxygen 1.8.11-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen $doxygenversion"/>
+<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
+<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
+<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="$relpath^jquery.js"></script>
+<script type="text/javascript" src="$relpath^dynsections.js"></script>
+$treeview
+$search
+$mathjax
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+$extrastylesheet
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+
+<!--BEGIN TITLEAREA-->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+ <!--BEGIN PROJECT_LOGO-->
+ <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
+ <!--END PROJECT_LOGO-->
+ <!--BEGIN PROJECT_NAME-->
+ <td id="projectalign" style="padding-left: 0.5em;">
+ <div id="projectname">$projectname
+ <!--BEGIN PROJECT_NUMBER--> <span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
+ </div>
+ <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
+ </td>
+ <!--END PROJECT_NAME-->
+ <!--BEGIN !PROJECT_NAME-->
+ <!--BEGIN PROJECT_BRIEF-->
+ <td style="padding-left: 0.5em;">
+ <div id="projectbrief">$projectbrief</div>
+ </td>
+ <!--END PROJECT_BRIEF-->
+ <!--END !PROJECT_NAME-->
+ <!--BEGIN DISABLE_INDEX-->
+ <!--BEGIN SEARCHENGINE-->
+ <td>$searchbox</td>
+ <!--END SEARCHENGINE-->
+ <!--END DISABLE_INDEX-->
+ </tr>
+ </tbody>
+</table>
+</div>
+<!--END TITLEAREA-->
+<!-- end header part -->
diff --git a/docs/doxygen_layout/stylesheet.css b/docs/doxygen_layout/stylesheet.css
new file mode 100644
index 0000000000000000000000000000000000000000..9fb779cd22cb2a18cb6b2107b50b8666b5988b31
--- /dev/null
+++ b/docs/doxygen_layout/stylesheet.css
@@ -0,0 +1,1475 @@
+/* The standard CSS for doxygen 1.8.11 */
+
+body, table, div, p, dl {
+ font: 400 14px/22px Roboto,sans-serif;
+}
+
+/* @group Heading Levels */
+
+h1.groupheader {
+ font-size: 150%;
+}
+
+.title {
+ font: 400 14px/28px Roboto,sans-serif;
+ font-size: 150%;
+ font-weight: bold;
+ margin: 10px 2px;
+}
+
+h2.groupheader {
+ border-bottom: 1px solid #ACBABD;
+ color: #5C7075;
+ font-size: 150%;
+ font-weight: normal;
+ margin-top: 1.75em;
+ padding-top: 8px;
+ padding-bottom: 4px;
+ width: 100%;
+}
+
+h3.groupheader {
+ font-size: 100%;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ -webkit-transition: text-shadow 0.5s linear;
+ -moz-transition: text-shadow 0.5s linear;
+ -ms-transition: text-shadow 0.5s linear;
+ -o-transition: text-shadow 0.5s linear;
+ transition: text-shadow 0.5s linear;
+ margin-right: 15px;
+}
+
+h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
+ text-shadow: 0 0 15px cyan;
+}
+
+dt {
+ font-weight: bold;
+}
+
+div.multicol {
+ -moz-column-gap: 1em;
+ -webkit-column-gap: 1em;
+ -moz-column-count: 3;
+ -webkit-column-count: 3;
+}
+
+p.startli, p.startdd {
+ margin-top: 2px;
+}
+
+p.starttd {
+ margin-top: 0px;
+}
+
+p.endli {
+ margin-bottom: 0px;
+}
+
+p.enddd {
+ margin-bottom: 4px;
+}
+
+p.endtd {
+ margin-bottom: 2px;
+}
+
+/* @end */
+
+caption {
+ font-weight: bold;
+}
+
+span.legend {
+ font-size: 70%;
+ text-align: center;
+}
+
+h3.version {
+ font-size: 90%;
+ text-align: center;
+}
+
+div.qindex, div.navtab{
+ background-color: #F2F4F4;
+ border: 1px solid #C0CACD;
+ text-align: center;
+}
+
+div.qindex, div.navpath {
+ width: 100%;
+ line-height: 140%;
+}
+
+div.navtab {
+ margin-right: 15px;
+}
+
+/* @group Link Styling */
+
+a {
+ color: #677D83;
+ font-weight: normal;
+ text-decoration: none;
+}
+
+.contents a:visited {
+ color: #768D92;
+}
+
+a:hover {
+ text-decoration: underline;
+}
+
+a.qindex {
+ font-weight: bold;
+}
+
+a.qindexHL {
+ font-weight: bold;
+ background-color: #BBC6C9;
+ color: #ffffff;
+ border: 1px double #ABB9BD;
+}
+
+.contents a.qindexHL:visited {
+ color: #ffffff;
+}
+
+a.el {
+ font-weight: bold;
+}
+
+a.elRef {
+}
+
+a.code, a.code:visited, a.line, a.line:visited {
+ color: #4665A2;
+}
+
+a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
+ color: #4665A2;
+}
+
+/* @end */
+
+dl.el {
+ margin-left: -1cm;
+}
+
+pre.fragment {
+ border: 1px solid #C4CFE5;
+ background-color: #FBFCFD;
+ padding: 4px 6px;
+ margin: 4px 8px 4px 2px;
+ overflow: auto;
+ word-wrap: break-word;
+ font-size: 9pt;
+ line-height: 125%;
+ font-family: monospace, fixed;
+ font-size: 105%;
+}
+
+div.fragment {
+ padding: 4px 6px;
+ margin: 4px 8px 4px 2px;
+ background-color: #FCFDFD;
+ border: 1px solid #D7DEDF;
+}
+
+div.line {
+ font-family: monospace, fixed;
+ font-size: 13px;
+ min-height: 13px;
+ line-height: 1.0;
+ text-wrap: unrestricted;
+ white-space: -moz-pre-wrap; /* Moz */
+ white-space: -pre-wrap; /* Opera 4-6 */
+ white-space: -o-pre-wrap; /* Opera 7 */
+ white-space: pre-wrap; /* CSS3 */
+ word-wrap: break-word; /* IE 5.5+ */
+ text-indent: -53px;
+ padding-left: 53px;
+ padding-bottom: 0px;
+ margin: 0px;
+ -webkit-transition-property: background-color, box-shadow;
+ -webkit-transition-duration: 0.5s;
+ -moz-transition-property: background-color, box-shadow;
+ -moz-transition-duration: 0.5s;
+ -ms-transition-property: background-color, box-shadow;
+ -ms-transition-duration: 0.5s;
+ -o-transition-property: background-color, box-shadow;
+ -o-transition-duration: 0.5s;
+ transition-property: background-color, box-shadow;
+ transition-duration: 0.5s;
+}
+
+div.line:after {
+ content:"\000A";
+ white-space: pre;
+}
+
+div.line.glow {
+ background-color: cyan;
+ box-shadow: 0 0 10px cyan;
+}
+
+
+span.lineno {
+ padding-right: 4px;
+ text-align: right;
+ border-right: 2px solid #0F0;
+ background-color: #E8E8E8;
+ white-space: pre;
+}
+span.lineno a {
+ background-color: #D8D8D8;
+}
+
+span.lineno a:hover {
+ background-color: #C8C8C8;
+}
+
+div.ah, span.ah {
+ background-color: black;
+ font-weight: bold;
+ color: #ffffff;
+ margin-bottom: 3px;
+ margin-top: 3px;
+ padding: 0.2em;
+ border: solid thin #333;
+ border-radius: 0.5em;
+ -webkit-border-radius: .5em;
+ -moz-border-radius: .5em;
+ box-shadow: 2px 2px 3px #999;
+ -webkit-box-shadow: 2px 2px 3px #999;
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+ background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
+ background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%);
+}
+
+div.classindex ul {
+ list-style: none;
+ padding-left: 0;
+}
+
+div.classindex span.ai {
+ display: inline-block;
+}
+
+div.groupHeader {
+ margin-left: 16px;
+ margin-top: 12px;
+ font-weight: bold;
+}
+
+div.groupText {
+ margin-left: 16px;
+ font-style: italic;
+}
+
+body {
+ background-color: white;
+ color: black;
+ margin: 0;
+}
+
+div.contents {
+ margin-top: 10px;
+ margin-left: 12px;
+ margin-right: 8px;
+}
+
+td.indexkey {
+ background-color: #F2F4F4;
+ font-weight: bold;
+ border: 1px solid #D7DEDF;
+ margin: 2px 0px 2px 0;
+ padding: 2px 10px;
+ white-space: nowrap;
+ vertical-align: top;
+}
+
+td.indexvalue {
+ background-color: #F2F4F4;
+ border: 1px solid #D7DEDF;
+ padding: 2px 10px;
+ margin: 2px 0px;
+}
+
+tr.memlist {
+ background-color: #F3F5F6;
+}
+
+p.formulaDsp {
+ text-align: center;
+}
+
+img.formulaDsp {
+
+}
+
+img.formulaInl {
+ vertical-align: middle;
+}
+
+div.center {
+ text-align: center;
+ margin-top: 0px;
+ margin-bottom: 0px;
+ padding: 0px;
+}
+
+div.center img {
+ border: 0px;
+}
+
+address.footer {
+ text-align: right;
+ padding-right: 12px;
+}
+
+img.footer {
+ border: 0px;
+ vertical-align: middle;
+}
+
+/* @group Code Colorization */
+
+span.keyword {
+ color: #008000
+}
+
+span.keywordtype {
+ color: #604020
+}
+
+span.keywordflow {
+ color: #e08000
+}
+
+span.comment {
+ color: #800000
+}
+
+span.preprocessor {
+ color: #806020
+}
+
+span.stringliteral {
+ color: #002080
+}
+
+span.charliteral {
+ color: #008080
+}
+
+span.vhdldigit {
+ color: #ff00ff
+}
+
+span.vhdlchar {
+ color: #000000
+}
+
+span.vhdlkeyword {
+ color: #700070
+}
+
+span.vhdllogic {
+ color: #ff0000
+}
+
+blockquote {
+ background-color: #F9FAFA;
+ border-left: 2px solid #BBC6C9;
+ margin: 0 24px 0 4px;
+ padding: 0 12px 0 16px;
+}
+
+/* @end */
+
+/*
+.search {
+ color: #003399;
+ font-weight: bold;
+}
+
+form.search {
+ margin-bottom: 0px;
+ margin-top: 0px;
+}
+
+input.search {
+ font-size: 75%;
+ color: #000080;
+ font-weight: normal;
+ background-color: #e8eef2;
+}
+*/
+
+td.tiny {
+ font-size: 75%;
+}
+
+.dirtab {
+ padding: 4px;
+ border-collapse: collapse;
+ border: 1px solid #C0CACD;
+}
+
+th.dirtab {
+ background: #F2F4F4;
+ font-weight: bold;
+}
+
+hr {
+ height: 0px;
+ border: none;
+ border-top: 1px solid #7C9297;
+}
+
+hr.footer {
+ height: 1px;
+}
+
+/* @group Member Descriptions */
+
+table.memberdecls {
+ border-spacing: 0px;
+ padding: 0px;
+}
+
+.memberdecls td, .fieldtable tr {
+ -webkit-transition-property: background-color, box-shadow;
+ -webkit-transition-duration: 0.5s;
+ -moz-transition-property: background-color, box-shadow;
+ -moz-transition-duration: 0.5s;
+ -ms-transition-property: background-color, box-shadow;
+ -ms-transition-duration: 0.5s;
+ -o-transition-property: background-color, box-shadow;
+ -o-transition-duration: 0.5s;
+ transition-property: background-color, box-shadow;
+ transition-duration: 0.5s;
+}
+
+.memberdecls td.glow, .fieldtable tr.glow {
+ background-color: cyan;
+ box-shadow: 0 0 15px cyan;
+}
+
+.mdescLeft, .mdescRight,
+.memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+ background-color: #FBFBFC;
+ border: none;
+ margin: 4px;
+ padding: 1px 0 0 8px;
+}
+
+.mdescLeft, .mdescRight {
+ padding: 0px 8px 4px 8px;
+ color: #555;
+}
+
+.memSeparator {
+ border-bottom: 1px solid #DEE4F0;
+ line-height: 1px;
+ margin: 0px;
+ padding: 0px;
+}
+
+.memItemLeft, .memTemplItemLeft {
+ white-space: nowrap;
+}
+
+.memItemRight {
+ width: 100%;
+}
+
+.memTemplParams {
+ color: #768D92;
+ white-space: nowrap;
+ font-size: 80%;
+}
+
+/* @end */
+
+/* @group Member Details */
+
+/* Styles for detailed member documentation */
+
+.memtemplate {
+ font-size: 80%;
+ color: #768D92;
+ font-weight: normal;
+ margin-left: 9px;
+}
+
+.memnav {
+ background-color: #F2F4F4;
+ border: 1px solid #C0CACD;
+ text-align: center;
+ margin: 2px;
+ margin-right: 15px;
+ padding: 2px;
+}
+
+.mempage {
+ width: 100%;
+}
+
+.memitem {
+ padding: 0;
+ margin-bottom: 10px;
+ margin-right: 5px;
+ -webkit-transition: box-shadow 0.5s linear;
+ -moz-transition: box-shadow 0.5s linear;
+ -ms-transition: box-shadow 0.5s linear;
+ -o-transition: box-shadow 0.5s linear;
+ transition: box-shadow 0.5s linear;
+ display: table !important;
+ width: 100%;
+}
+
+.memitem.glow {
+ box-shadow: 0 0 15px cyan;
+}
+
+.memname {
+ font-weight: bold;
+ margin-left: 6px;
+}
+
+.memname td {
+ vertical-align: bottom;
+}
+
+.memproto, dl.reflist dt {
+ border-top: 1px solid #C3CDD0;
+ border-left: 1px solid #C3CDD0;
+ border-right: 1px solid #C3CDD0;
+ padding: 6px 0px 6px 0px;
+ color: #445256;
+ font-weight: bold;
+ text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+ background-image:url('nav_f.png');
+ background-repeat:repeat-x;
+ background-color: #EBEFEF;
+ /* opera specific markup */
+ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+ border-top-right-radius: 4px;
+ border-top-left-radius: 4px;
+ /* firefox specific markup */
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+ -moz-border-radius-topright: 4px;
+ -moz-border-radius-topleft: 4px;
+ /* webkit specific markup */
+ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+ -webkit-border-top-right-radius: 4px;
+ -webkit-border-top-left-radius: 4px;
+
+}
+
+.memdoc, dl.reflist dd {
+ border-bottom: 1px solid #C3CDD0;
+ border-left: 1px solid #C3CDD0;
+ border-right: 1px solid #C3CDD0;
+ padding: 6px 10px 2px 10px;
+ background-color: #FCFDFD;
+ border-top-width: 0;
+ background-image:url('nav_g.png');
+ background-repeat:repeat-x;
+ background-color: #FFFFFF;
+ /* opera specific markup */
+ border-bottom-left-radius: 4px;
+ border-bottom-right-radius: 4px;
+ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+ /* firefox specific markup */
+ -moz-border-radius-bottomleft: 4px;
+ -moz-border-radius-bottomright: 4px;
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+ /* webkit specific markup */
+ -webkit-border-bottom-left-radius: 4px;
+ -webkit-border-bottom-right-radius: 4px;
+ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+dl.reflist dt {
+ padding: 5px;
+}
+
+dl.reflist dd {
+ margin: 0px 0px 10px 0px;
+ padding: 5px;
+}
+
+.paramkey {
+ text-align: right;
+}
+
+.paramtype {
+ white-space: nowrap;
+}
+
+.paramname {
+ color: #602020;
+ white-space: nowrap;
+}
+.paramname em {
+ font-style: normal;
+}
+.paramname code {
+ line-height: 14px;
+}
+
+.params, .retval, .exception, .tparams {
+ margin-left: 0px;
+ padding-left: 0px;
+}
+
+.params .paramname, .retval .paramname {
+ font-weight: bold;
+ vertical-align: top;
+}
+
+.params .paramtype {
+ font-style: italic;
+ vertical-align: top;
+}
+
+.params .paramdir {
+ font-family: "courier new",courier,monospace;
+ vertical-align: top;
+}
+
+table.mlabels {
+ border-spacing: 0px;
+}
+
+td.mlabels-left {
+ width: 100%;
+ padding: 0px;
+}
+
+td.mlabels-right {
+ vertical-align: bottom;
+ padding: 0px;
+ white-space: nowrap;
+}
+
+span.mlabels {
+ margin-left: 8px;
+}
+
+span.mlabel {
+ background-color: #9DADB1;
+ border-top:1px solid #869A9F;
+ border-left:1px solid #869A9F;
+ border-right:1px solid #D7DEDF;
+ border-bottom:1px solid #D7DEDF;
+ text-shadow: none;
+ color: white;
+ margin-right: 4px;
+ padding: 2px 3px;
+ border-radius: 3px;
+ font-size: 7pt;
+ white-space: nowrap;
+ vertical-align: middle;
+}
+
+
+
+/* @end */
+
+/* these are for tree view inside a (index) page */
+
+div.directory {
+ margin: 10px 0px;
+ border-top: 1px solid #BBC6C9;
+ border-bottom: 1px solid #BBC6C9;
+ width: 100%;
+}
+
+.directory table {
+ border-collapse:collapse;
+}
+
+.directory td {
+ margin: 0px;
+ padding: 0px;
+ vertical-align: top;
+}
+
+.directory td.entry {
+ white-space: nowrap;
+ padding-right: 6px;
+ padding-top: 3px;
+}
+
+.directory td.entry a {
+ outline:none;
+}
+
+.directory td.entry a img {
+ border: none;
+}
+
+.directory td.desc {
+ width: 100%;
+ padding-left: 6px;
+ padding-right: 6px;
+ padding-top: 3px;
+ border-left: 1px solid rgba(0,0,0,0.05);
+}
+
+.directory tr.even {
+ padding-left: 6px;
+ background-color: #F9FAFA;
+}
+
+.directory img {
+ vertical-align: -30%;
+}
+
+.directory .levels {
+ white-space: nowrap;
+ width: 100%;
+ text-align: right;
+ font-size: 9pt;
+}
+
+.directory .levels span {
+ cursor: pointer;
+ padding-left: 2px;
+ padding-right: 2px;
+ color: #677D83;
+}
+
+.arrow {
+ color: #BBC6C9;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ cursor: pointer;
+ font-size: 80%;
+ display: inline-block;
+ width: 16px;
+ height: 22px;
+}
+
+.icon {
+ font-family: Arial, Helvetica;
+ font-weight: bold;
+ font-size: 12px;
+ height: 14px;
+ width: 16px;
+ display: inline-block;
+ background-color: #9DADB1;
+ color: white;
+ text-align: center;
+ border-radius: 4px;
+ margin-left: 2px;
+ margin-right: 2px;
+}
+
+.icona {
+ width: 24px;
+ height: 22px;
+ display: inline-block;
+}
+
+.iconfopen {
+ width: 24px;
+ height: 18px;
+ margin-bottom: 4px;
+ background-image:url('folderopen.png');
+ background-position: 0px -4px;
+ background-repeat: repeat-y;
+ vertical-align:top;
+ display: inline-block;
+}
+
+.iconfclosed {
+ width: 24px;
+ height: 18px;
+ margin-bottom: 4px;
+ background-image:url('folderclosed.png');
+ background-position: 0px -4px;
+ background-repeat: repeat-y;
+ vertical-align:top;
+ display: inline-block;
+}
+
+.icondoc {
+ width: 24px;
+ height: 18px;
+ margin-bottom: 4px;
+ background-image:url('doc.png');
+ background-position: 0px -4px;
+ background-repeat: repeat-y;
+ vertical-align:top;
+ display: inline-block;
+}
+
+table.directory {
+ font: 400 14px Roboto,sans-serif;
+}
+
+/* @end */
+
+div.dynheader {
+ margin-top: 8px;
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+
+address {
+ font-style: normal;
+ color: #4C5C60;
+}
+
+table.doxtable caption {
+ caption-side: top;
+}
+
+table.doxtable {
+ border-collapse:collapse;
+ margin-top: 4px;
+ margin-bottom: 4px;
+}
+
+table.doxtable td, table.doxtable th {
+ border: 1px solid #506165;
+ padding: 3px 7px 2px;
+}
+
+table.doxtable th {
+ background-color: #5F7379;
+ color: #FFFFFF;
+ font-size: 110%;
+ padding-bottom: 4px;
+ padding-top: 5px;
+}
+
+table.fieldtable {
+ /*width: 100%;*/
+ margin-bottom: 10px;
+ border: 1px solid #C3CDD0;
+ border-spacing: 0px;
+ -moz-border-radius: 4px;
+ -webkit-border-radius: 4px;
+ border-radius: 4px;
+ -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+ -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+ box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+}
+
+.fieldtable td, .fieldtable th {
+ padding: 3px 7px 2px;
+}
+
+.fieldtable td.fieldtype, .fieldtable td.fieldname {
+ white-space: nowrap;
+ border-right: 1px solid #C3CDD0;
+ border-bottom: 1px solid #C3CDD0;
+ vertical-align: top;
+}
+
+.fieldtable td.fieldname {
+ padding-top: 3px;
+}
+
+.fieldtable td.fielddoc {
+ border-bottom: 1px solid #C3CDD0;
+ /*width: 100%;*/
+}
+
+.fieldtable td.fielddoc p:first-child {
+ margin-top: 0px;
+}
+
+.fieldtable td.fielddoc p:last-child {
+ margin-bottom: 2px;
+}
+
+.fieldtable tr:last-child td {
+ border-bottom: none;
+}
+
+.fieldtable th {
+ background-image:url('nav_f.png');
+ background-repeat:repeat-x;
+ background-color: #EBEFEF;
+ font-size: 90%;
+ color: #445256;
+ padding-bottom: 4px;
+ padding-top: 5px;
+ text-align:left;
+ -moz-border-radius-topleft: 4px;
+ -moz-border-radius-topright: 4px;
+ -webkit-border-top-left-radius: 4px;
+ -webkit-border-top-right-radius: 4px;
+ border-top-left-radius: 4px;
+ border-top-right-radius: 4px;
+ border-bottom: 1px solid #C3CDD0;
+}
+
+
+.tabsearch {
+ top: 0px;
+ left: 10px;
+ height: 36px;
+ background-image: url('tab_b.png');
+ z-index: 101;
+ overflow: hidden;
+ font-size: 13px;
+}
+
+.navpath ul
+{
+ font-size: 11px;
+ background-image:url('tab_b.png');
+ background-repeat:repeat-x;
+ background-position: 0 -5px;
+ height:30px;
+ line-height:30px;
+ color:#AEBBBF;
+ border:solid 1px #D5DCDE;
+ overflow:hidden;
+ margin:0px;
+ padding:0px;
+}
+
+.navpath li
+{
+ list-style-type:none;
+ float:left;
+ padding-left:10px;
+ padding-right:15px;
+ background-image:url('bc_s.png');
+ background-repeat:no-repeat;
+ background-position:right;
+ color:#5D7176;
+}
+
+.navpath li.navelem a
+{
+ height:32px;
+ display:block;
+ text-decoration: none;
+ outline: none;
+ color: #49595D;
+ font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+ text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+ text-decoration: none;
+}
+
+.navpath li.navelem a:hover
+{
+ color:#95A7AB;
+}
+
+.navpath li.footer
+{
+ list-style-type:none;
+ float:right;
+ padding-left:10px;
+ padding-right:15px;
+ background-image:none;
+ background-repeat:no-repeat;
+ background-position:right;
+ color:#5D7176;
+ font-size: 8pt;
+}
+
+
+div.summary
+{
+ float: right;
+ font-size: 8pt;
+ padding-right: 5px;
+ width: 50%;
+ text-align: right;
+}
+
+div.summary a
+{
+ white-space: nowrap;
+}
+
+table.classindex
+{
+ margin: 10px;
+ white-space: nowrap;
+ margin-left: 3%;
+ margin-right: 3%;
+ width: 94%;
+ border: 0;
+ border-spacing: 0;
+ padding: 0;
+}
+
+div.ingroups
+{
+ font-size: 8pt;
+ width: 50%;
+ text-align: left;
+}
+
+div.ingroups a
+{
+ white-space: nowrap;
+}
+
+div.header
+{
+ background-image:url('nav_h.png');
+ background-repeat:repeat-x;
+ background-color: #FBFBFC;
+ margin: 0px;
+ border-bottom: 1px solid #D7DEDF;
+}
+
+div.headertitle
+{
+ padding: 5px 5px 5px 10px;
+}
+
+dl
+{
+ padding: 0 0 0 10px;
+}
+
+/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */
+dl.section
+{
+ margin-left: 0px;
+ padding-left: 0px;
+}
+
+dl.note
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #D0C000;
+}
+
+dl.warning, dl.attention
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #FF0000;
+}
+
+dl.pre, dl.post, dl.invariant
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #00D000;
+}
+
+dl.deprecated
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #505050;
+}
+
+dl.todo
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #00C0E0;
+}
+
+dl.test
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #3030E0;
+}
+
+dl.bug
+{
+ margin-left:-7px;
+ padding-left: 3px;
+ border-left:4px solid;
+ border-color: #C08050;
+}
+
+dl.section dd {
+ margin-bottom: 6px;
+}
+
+
+#projectlogo
+{
+ text-align: center;
+ vertical-align: bottom;
+ border-collapse: separate;
+}
+
+#projectlogo img
+{
+ border: 0px none;
+}
+
+#projectalign
+{
+ vertical-align: middle;
+}
+
+#projectname
+{
+ font: 300% Tahoma, Arial,sans-serif;
+ margin: 0px;
+ padding: 2px 0px;
+}
+
+#projectbrief
+{
+ font: 120% Tahoma, Arial,sans-serif;
+ margin: 0px;
+ padding: 0px;
+}
+
+#projectnumber
+{
+ font: 50% Tahoma, Arial,sans-serif;
+ margin: 0px;
+ padding: 0px;
+}
+
+#titlearea
+{
+ padding: 0px;
+ margin: 0px;
+ width: 100%;
+ border-bottom: 1px solid #869A9F;
+}
+
+.image
+{
+ text-align: center;
+}
+
+.dotgraph
+{
+ text-align: center;
+}
+
+.mscgraph
+{
+ text-align: center;
+}
+
+.diagraph
+{
+ text-align: center;
+}
+
+.caption
+{
+ font-weight: bold;
+}
+
+div.zoom
+{
+ border: 1px solid #B2BFC2;
+}
+
+dl.citelist {
+ margin-bottom:50px;
+}
+
+dl.citelist dt {
+ color:#596C70;
+ float:left;
+ font-weight:bold;
+ margin-right:10px;
+ padding:5px;
+}
+
+dl.citelist dd {
+ margin:2px 0;
+ padding:5px 0;
+}
+
+div.toc {
+ padding: 14px 25px;
+ background-color: #F8F9F9;
+ border: 1px solid #E4E9EA;
+ border-radius: 7px 7px 7px 7px;
+ float: right;
+ height: auto;
+ margin: 0 8px 10px 10px;
+ width: 200px;
+}
+
+div.toc li {
+ background: url("bdwn.png") no-repeat scroll 0 5px transparent;
+ font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif;
+ margin-top: 5px;
+ padding-left: 10px;
+ padding-top: 2px;
+}
+
+div.toc h3 {
+ font: bold 12px/1.2 Arial,FreeSans,sans-serif;
+ color: #768D92;
+ border-bottom: 0 none;
+ margin: 0;
+}
+
+div.toc ul {
+ list-style: none outside none;
+ border: medium none;
+ padding: 0px;
+}
+
+div.toc li.level1 {
+ margin-left: 0px;
+}
+
+div.toc li.level2 {
+ margin-left: 15px;
+}
+
+div.toc li.level3 {
+ margin-left: 30px;
+}
+
+div.toc li.level4 {
+ margin-left: 45px;
+}
+
+.inherit_header {
+ font-weight: bold;
+ color: gray;
+ cursor: pointer;
+ -webkit-touch-callout: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+
+.inherit_header td {
+ padding: 6px 0px 2px 5px;
+}
+
+.inherit {
+ display: none;
+}
+
+tr.heading h2 {
+ margin-top: 12px;
+ margin-bottom: 4px;
+}
+
+/* tooltip related style info */
+
+.ttc {
+ position: absolute;
+ display: none;
+}
+
+#powerTip {
+ cursor: default;
+ white-space: nowrap;
+ background-color: white;
+ border: 1px solid gray;
+ border-radius: 4px 4px 4px 4px;
+ box-shadow: 1px 1px 7px gray;
+ display: none;
+ font-size: smaller;
+ max-width: 80%;
+ opacity: 0.9;
+ padding: 1ex 1em 1em;
+ position: absolute;
+ z-index: 2147483647;
+}
+
+#powerTip div.ttdoc {
+ color: grey;
+ font-style: italic;
+}
+
+#powerTip div.ttname a {
+ font-weight: bold;
+}
+
+#powerTip div.ttname {
+ font-weight: bold;
+}
+
+#powerTip div.ttdeci {
+ color: #006318;
+}
+
+#powerTip div {
+ margin: 0px;
+ padding: 0px;
+ font: 12px/16px Roboto,sans-serif;
+}
+
+#powerTip:before, #powerTip:after {
+ content: "";
+ position: absolute;
+ margin: 0px;
+}
+
+#powerTip.n:after, #powerTip.n:before,
+#powerTip.s:after, #powerTip.s:before,
+#powerTip.w:after, #powerTip.w:before,
+#powerTip.e:after, #powerTip.e:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.nw:after, #powerTip.nw:before,
+#powerTip.sw:after, #powerTip.sw:before {
+ border: solid transparent;
+ content: " ";
+ height: 0;
+ width: 0;
+ position: absolute;
+}
+
+#powerTip.n:after, #powerTip.s:after,
+#powerTip.w:after, #powerTip.e:after,
+#powerTip.nw:after, #powerTip.ne:after,
+#powerTip.sw:after, #powerTip.se:after {
+ border-color: rgba(255, 255, 255, 0);
+}
+
+#powerTip.n:before, #powerTip.s:before,
+#powerTip.w:before, #powerTip.e:before,
+#powerTip.nw:before, #powerTip.ne:before,
+#powerTip.sw:before, #powerTip.se:before {
+ border-color: rgba(128, 128, 128, 0);
+}
+
+#powerTip.n:after, #powerTip.n:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.nw:after, #powerTip.nw:before {
+ top: 100%;
+}
+
+#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after {
+ border-top-color: #ffffff;
+ border-width: 10px;
+ margin: 0px -10px;
+}
+#powerTip.n:before {
+ border-top-color: #808080;
+ border-width: 11px;
+ margin: 0px -11px;
+}
+#powerTip.n:after, #powerTip.n:before {
+ left: 50%;
+}
+
+#powerTip.nw:after, #powerTip.nw:before {
+ right: 14px;
+}
+
+#powerTip.ne:after, #powerTip.ne:before {
+ left: 14px;
+}
+
+#powerTip.s:after, #powerTip.s:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.sw:after, #powerTip.sw:before {
+ bottom: 100%;
+}
+
+#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after {
+ border-bottom-color: #ffffff;
+ border-width: 10px;
+ margin: 0px -10px;
+}
+
+#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before {
+ border-bottom-color: #808080;
+ border-width: 11px;
+ margin: 0px -11px;
+}
+
+#powerTip.s:after, #powerTip.s:before {
+ left: 50%;
+}
+
+#powerTip.sw:after, #powerTip.sw:before {
+ right: 14px;
+}
+
+#powerTip.se:after, #powerTip.se:before {
+ left: 14px;
+}
+
+#powerTip.e:after, #powerTip.e:before {
+ left: 100%;
+}
+#powerTip.e:after {
+ border-left-color: #ffffff;
+ border-width: 10px;
+ top: 50%;
+ margin-top: -10px;
+}
+#powerTip.e:before {
+ border-left-color: #808080;
+ border-width: 11px;
+ top: 50%;
+ margin-top: -11px;
+}
+
+#powerTip.w:after, #powerTip.w:before {
+ right: 100%;
+}
+#powerTip.w:after {
+ border-right-color: #ffffff;
+ border-width: 10px;
+ top: 50%;
+ margin-top: -10px;
+}
+#powerTip.w:before {
+ border-right-color: #808080;
+ border-width: 11px;
+ top: 50%;
+ margin-top: -11px;
+}
+
+@media print
+{
+ #top { display: none; }
+ #side-nav { display: none; }
+ #nav-path { display: none; }
+ body { overflow:visible; }
+ h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
+ .summary { display: none; }
+ .memitem { page-break-inside: avoid; }
+ #doc-content
+ {
+ margin-left:0 !important;
+ height:auto !important;
+ width:auto !important;
+ overflow:inherit;
+ display:inline;
+ }
+}
+
diff --git a/docs/sphinx/devel/about_doc.rst b/docs/sphinx/devel/about_doc.rst
index 22c4cf828704bc1101b9bbf37224bb7c8b304003..e846e8355e2c518728b43844b8382ca368e401d4 100644
--- a/docs/sphinx/devel/about_doc.rst
+++ b/docs/sphinx/devel/about_doc.rst
@@ -3,9 +3,8 @@
How to document classes in HySoP
=================================
-We try to fit as much as possible with `numpydoc guide <https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt>`
+We try to fit as much as possible with `numpydoc guide <https://numpydoc.readthedocs.io/en/latest/>`
guide standards.
See the files fields/continuous.py and operator/drag_and_lift.py which are used as reference files for documentation
-and
-
+and
diff --git a/docs/sphinx/devel/about_operators_graph.rst b/docs/sphinx/devel/about_operators_graph.rst
new file mode 100644
index 0000000000000000000000000000000000000000..2ba3dfd61b7a4f6f31c06ef99f8f2ac5c2bb0600
--- /dev/null
+++ b/docs/sphinx/devel/about_operators_graph.rst
@@ -0,0 +1,45 @@
+.. _about_operators_graph:
+
+How HySoP deals with computational graphs of operators
+======================================================
+
+.. inheritance-diagram::
+ hysop.core.graph.computational_node.ComputationalGraphNode
+ hysop.core.graph.computational_graph.ComputationalGraph
+ hysop.core.graph.node_generator.ComputationalGraphNodeGenerator
+ hysop.core.graph.computational_operator.ComputationalGraphOperator
+ hysop.core.graph.computational_node_frontend.ComputationalGraphNodeFrontend
+ hysop.operator.directional.directional.DirectionalOperatorBase
+ hysop.operator.directional.directional.DirectionalOperatorGenerator
+ hysop.operator.directional.directional.DirectionalOperatorFrontend
+ hysop.numerics.splitting.directional_splitting.DirectionalSplitting
+ hysop.problem.Problem
+ :parts: 1
+ :caption: Inheritance diagram for HySoP computational graphs.
+
+
+HySoP library is designed for the user to manipulate only operators
+and problems. It internally build a directed graph of operators (low level
+computations or data operations) for running a single a solver
+iteration. Therefore, solving a Problem means running iteratively the
+graph traversal. Order of inserting elements in the Problem using
+:meth:`~hysop.problem.Problem.insert` (or graph using :meth:`~hysop.core.graph.computational_graph.ComputationalGraph.push_nodes`)
+is important.
+
+Two kind of object can be inserted into a graph:
+
+- a :class:`~hysop.core.graph.computational_node.ComputationalGraphNode` by means of:
+
+ * an operator (:class:`~hysop.core.graph.computational_operator.ComputationalGraphOperator`)
+ * a sub-graph (:class:`~hysop.core.graph.computational_graph.ComputationalGraph`) when using a operator of operators
+
+- an operator generator (:class:`~hysop.core.graph.node_generator.ComputationalGraphNodeGenerator` or
+ :class:`~hysop.core.graph.computational_node_frontend.ComputationalGraphNodeFrontend`). In that case, only generated
+ operators are inserted into graph, the generator itself is not inserted.
+
+We distinguish directional operators from operators. Directional
+operators must split into several operators (at least one per spatial
+directions) using a :class:`~hysop.numerics.splitting.directional_splitting.DirectionalSplitting`. The nested
+operators are sharing a common basis:
+:class:`~hysop.operator.directional.directional.DirectionalOperatorBase` that are generated by :class:`~hysop.operator.directional.directional.DirectionalOperatorGenerator`. Directional operators generators will automatically insert also
+transposition operators (see :ref:`about_work_arrays`).
diff --git a/docs/sphinx/devel/index.rst b/docs/sphinx/devel/index.rst
index 660c466335a11edf864680c296aed9dc49aa7d83..2eef3e21d7b6b4314f300b3c6022680ef804985c 100644
--- a/docs/sphinx/devel/index.rst
+++ b/docs/sphinx/devel/index.rst
@@ -2,7 +2,7 @@
############################
-HySoP Developers Guide
+HySoP Developers Guide
############################
This part is for developers of Hysop and provides guidelines on the "proper" ways to write python code, documentation, examples, tests ... in HySoP.
@@ -12,6 +12,11 @@ This part is for developers of Hysop and provides guidelines on the "proper" way
about_doc
coding_guidelines
+ fortran2python
+ about_operators_graph
about_work_arrays
+ about_codegen
+ about_autotuning
+ about_symbolic
memo_sphinx
hysop_validation
diff --git a/docs/sphinx/getting_started/index.rst b/docs/sphinx/getting_started/index.rst
index 98de687efe4acece6a0a8d34cce5aeb53f0f74d1..de02aae6d0c090a4309436a3c67a6250dc673c81 100644
--- a/docs/sphinx/getting_started/index.rst
+++ b/docs/sphinx/getting_started/index.rst
@@ -31,7 +31,7 @@ submodules. For example, try in a terminal window::
and
>>> from hysop import Box
- >>> from hysop.operator.poisson import Poisson
+ >>> from hysop.operators import Poisson
>>> dom = Box()
Use script
@@ -58,7 +58,7 @@ Basics : describe a problem in HySoP
This short introduction presents the basic objects to know to describe and solve properly a problem with HySoP.
-HySoP provides a framework for flow simulation, based on particular methods. The workflow for such a simulation will be:
+HySoP provides a framework for flow simulation, based on particles methods. The workflow for such a simulation will be:
* define a physical domain : geometry and boundary conditions,
* define some scalar or vector fields on this domain, the unknowns,
@@ -69,13 +69,13 @@ HySoP provides a framework for flow simulation, based on particular methods. The
* post-process the results.
Here is a short glossary of the objects which form a simulation process within HySoP:
-
+
**Domain**: a physical domain, defined by its origin, its size and some types of boundary conditions. Different space discretisations and data distributions can be associated with a domain. See details in :ref:`domains`.
-**Fields**: the unknowns of your problem, the 'classical' mathematical vector or scalar fields, i.e. a function which associates a scalar or a vector to each point of the space.
-Fields obviously depends on time and space.
+**Fields**: the unknowns of your problem, the 'classical' mathematical vector or scalar fields, i.e. a function which associates a scalar or a vector to each point of the space.
+Fields obviously depends on time and space. See details in :ref:`fields`.
-**Operator**: a set of equations (most of the time ode), defined on a domain, with some fields as unknowns.
+**Operator**: a set of equations (most of the time ode), defined on a domain, with some fields as unknowns. See details in :ref:`operators`.
**Problem**: a sequence of operators associated with a simulation.
@@ -83,7 +83,7 @@ All of the objects defined above are high-level continuous objects, only descrip
In particular, none of them depends on the type of execution (parallel or sequential) and on the number of mpi processes involved.
Indeed, to proceed with the simulation, it is necessary to define space and time discretization, to choose some numerical methods to solve each operator, in some words to configure and discretize the whole process. Thus, we need to introduce the following objects:
-**Discretization** : space discretization of the global domain (grid resolution, space step size ...).
+**Discretization** : space discretization of the global domain (grid resolution, space step size ...).
**Topology** : description of how data are distributed among mpi processes and of the space discretisation (global and local to each process)
@@ -91,13 +91,14 @@ For details about discretisation and data distribution, check :ref:`topologies`.
**Simulation**: description of the time discretisation (start and end time, time step ...)
-Consider for example the following advection problem,
+Consider for example the following advection problem,
.. math::
- \frac{\partial \rho(x,y,t)}{\partial t} + v(x,y,t).\nabla\rho(x,y,t) &=& 0
+ \frac{\partial \rho(x,y,t)}{\partial t} + v(x,y,t).\nabla\rho(x,y,t) = 0
+
+
-
where :math:`\rho`, a scalar field, and v, a vector field, are the unknowns, defined on a box-shaped domain with some given values on the boundaries
and initial values at time :math:`t=t_0`.
@@ -110,7 +111,7 @@ Then, in HySoP, you will have to define two *Fields*, representing :math:`\rho`
# A box-shaped 2d domain
dom = Box(length=[1., 1.], origin=[0., 0.])
# Choose a global space discretisation/grid resolution
- d2d = Discretization([65, 65])
+ d2d = Discretization([64, 64])
# Define some continuous fields
v = Field(domain=dom, name='velocity', is_vector=True)
rho = Field(domain=dom, name='rho')
@@ -118,10 +119,10 @@ Then, in HySoP, you will have to define two *Fields*, representing :math:`\rho`
# according to d2d
adv = Advection(v, rho, discretization=d2d)
# Time discretization
- simu = Simulation(nb_iter=100)
-
+ simu = Simulation(dt=0.01, nb_iter=100)
+
# ... some stuff to initialize fields values ...
-
+
# discretize operator and distribute data
adv.discretize()
adv.setup()
diff --git a/docs/sphinx/hysop.bib b/docs/sphinx/hysop.bib
index 63a5a0eae611353ecdb131dcf8a714f378faf3d6..6e8dd5e046b36f38579ccfd7a7854d411240bab8 100644
--- a/docs/sphinx/hysop.bib
+++ b/docs/sphinx/hysop.bib
@@ -43,9 +43,9 @@
Volume = {13},
Year = {1999}}
-@misc{cottet2000vortex,
+@misc{Cottet2000vortex,
title={Vortex methods: theory and practice},
author={Cottet, Georges-Henri and Koumoutsakos, Petros D},
year={2000},
publisher={Cambridge University Press}
-}
\ No newline at end of file
+}
diff --git a/docs/sphinx/index.rst.in b/docs/sphinx/index.rst.in
index a70e47b6ef165447fb4be63b39982cb68c75616d..89158201271167117b27f74454ced348e71c36f1 100644
--- a/docs/sphinx/index.rst.in
+++ b/docs/sphinx/index.rst.in
@@ -13,6 +13,7 @@ HySoP software: hybrid simulation with particles
getting_started/index
users_guide/index
examples/index
+ devel/index
reference/index
license
contacts
@@ -32,6 +33,3 @@ The library is mainly written in Python (high level functionnalities) and Fortra
.. image:: /figures/vorticity_field.*
:height: 200px
-
-
-
diff --git a/docs/sphinx/install_guide/index.rst b/docs/sphinx/install_guide/index.rst
index 4e6ed9939f2779d0577feba7632894921c216f82..1c15fb1ea819628ea68e1f69d7c1654072d30994 100644
--- a/docs/sphinx/install_guide/index.rst
+++ b/docs/sphinx/install_guide/index.rst
@@ -25,7 +25,7 @@ Note:
Check the end of cmake output, where the proper command will be indicated.
-
+
Then just run python interactively and ::
@@ -39,7 +39,7 @@ or run python on an hysop example file::
mpirun -np 4 python your_file.py
-
+
.. _hysop_config:
@@ -50,11 +50,28 @@ cmake configuration may be customized by user, using::
cmake -DOPTION_NAME=option_value path_to_source
-'OPTION_NAME' being one of the options described below.
+'OPTION_NAME' being one of the options described below. The most
+important options are listed here, other options are defined in
+`CMakeList.txt` file.
+
+Behavior options:
-* FFTW_DIR : where to find fftw if it's not in a "standard" place.
-* WITH_SCALES=ON/OFF : to compile an HySoP version including scales (default = on)
-* WITH_TESTS=ON/OFF: enable testing (i.e. prepare target "make test", default = off)
+* DOUBLEPREC=ON/OFF : Set default HySoP floating point
+ precision. Default=ON, ie double precision else single precision
+ will be used.
+* PROFILE=ON/OFF : Enable profiling mode for HySoP (default=ON).
+* VERBOSE=ON/OFF : Enable verbose mode for HySoP (default=ON).
+* DEBUG=ON/OFF : Enable debug mode for HySoP (default=OFF).
+
+Components options :
+
+* WITH_FFTW=ON/OFF : Link with fftw library (required for some HySoP solvers), (default=ON).
+* FFTW_ROOT : where to find fftw if it's not in a "standard" place.
+* WITH_EXTRAS=ON/OFF : Link with some extra fortran libraries (like arnoldi solver), (default=OFF).
+* WITH_GPU=ON/OFF : Use of GPU (required for some HySoP solvers), (default=ON)
+* WITH_SCALES=ON/OFF : to compile an HySoP version including scales (default = ON).
+* WITH_TESTS=ON/OFF : enable testing (i.e. prepare target "make test", default = OFF).
+* WITH_DOCUMENTATION=ON/OFF : Build Documentation. (default=OFF)
.. _hysop_dependencies:
@@ -62,11 +79,40 @@ cmake configuration may be customized by user, using::
Dependencies
------------
-* python > 2.7
+* python > 2.7 with the following packages:
+ - pip
+ - setuptools
+ - cffi
+ - pytest
+ - numpy
+ - scipy
+ - sympy
+ - matplotlib
+ - mpi4py
+ - h5py
+ - gmpy2
+ - py-cpuinfo
+ - colors.py
+ - tee
+ - primefac
+ - pycairo
+ - weave
+ - argparse_color_formatter
+ - numba
+ - pyopencl
+ - pyfftw
+ - gpyfftw
+ - scitools
+
* a proper mpi implementation including a fortran compiler
-* fftw
+* fftw library with single and double precision both for serial and
+ mpi versions
+* swig
+* hdf5 with parallel support
+* clFFT
+* graph-tools
+* dowygen and python sphinx package for generating the documentation
* cmake > 2.8
-* numpy, mpi4py, h5py
.. _hysop_install:
diff --git a/docs/sphinx/users_guide/domains.rst b/docs/sphinx/users_guide/domains.rst
index 5ce59548efd747851852ff4ccefc26fb985c51e3..89e9a4a1576a21a3f64f1a691cc910fb8af9c902 100644
--- a/docs/sphinx/users_guide/domains.rst
+++ b/docs/sphinx/users_guide/domains.rst
@@ -8,11 +8,11 @@ Domains
A :class:`~domain.Domain` is the physical space where fields and operators will be defined, associated with a coordinate system.
A domain is defined with its dimension (1, 2 or 3 dimensions domains are allowed in HySoP), some geometrical properties and some boundary conditions. Each point in the domain is identified with its space coordinates, denoted as :math:`x, y, z`.
-At the time only box-shaped domains are available in HySoP, thanks to object :class:`~box.Box`::
+At the time only box-shaped domains are available in HySoP, thanks to class :class:`~box.Box`::
from hysop import Box
# 1D
- b = Box(length=[2.], origin=[-1.], bc=PERIODIC)
+ b = Box(length=[2.], origin=[-1.])
# 3D
dom = Box(length=[1., 3., 5.], origin=[-1., 2., 3])
# Default
@@ -26,7 +26,8 @@ Default dimension is 3d, default sides length is 1. in each direction, and defau
dom = Box()
-Boundary conditions are set to periodic by default.
+Boundary conditions are set to periodic by default, but other types
+are available through :py:attr:`~constants.BoxBoundaryCondition`.
Parallelisation of the simulation
@@ -47,20 +48,20 @@ Communicators and tasks
Please check :ref:`mpi_utils` for communicator, tasks and other mpi-related definitions.
When created, a domain is automatically associated with a communicator and the processes of the communicator
-with a task. Default task is :class:`~hysop.constants.DEFAULT_TASK_ID` for all processes, and default communicator
+with a task. Default task is :obj:`~hysop.constants.DEFAULT_TASK_ID` for all processes, and default communicator
is main_comm::
from hysop import Box
- from hysop.mpi import main_comm, main_size
- from hysop.constants import DEFAULT_TASK_ID
+ from hysop.core.mpi import main_comm, main_size
+ from hysop.constants import HYSOP_DEFAULT_TASK_ID
dom = Box()
assert dom.comm_task == main_comm
- assert dom.tasks_list() == [DEFAULT_TASK_ID, ] * main_size
+ assert dom.tasks_list() == [HYSOP_DEFAULT_TASK_ID, ] * main_size
A process can be affected to one and only one task and dom.comm_task is the communicator associated to the task
of the current process.
-
+
Ok, let us now assume that we need to define three different tasks, in a simulation run with 8 mpi processes.
The idea is to bind processes 0, 4, 5 and 6 to task 'red', 1, 2, 3 to task 'green' and 7 to task 'yellow', as
shown in the figure below:
@@ -74,37 +75,37 @@ is attached to task number 12.
Try the following program with 8 processes to check the result::
from hysop import Box
- from hysop.mpi import main_comm, main_size, main_rank
- from hysop.constants import DEFAULT_TASK_ID
-
+ from hysop.core.mpi import main_comm, main_size, main_rank
+ from hysop.constants import HYSOP_DEFAULT_TASK_ID
+
RED = 4
GREEN = 1
YELLOW = 12
-
+
proc_tasks = [RED, ] * main_size
proc_tasks[1:4] = [GREEN, ] * 3
proc_tasks[7] = YELLOW
dom = Box(proc_tasks=proc_tasks)
-
+
assert dom.comm_task != main_comm
print 'process of rank ', main_rank, ' with task ', dom.current_task()
print 'rank/main_comm = ', main_rank, ' rank/comm_task', dom.comm_task.Get_rank()
-
+
Important remarks:
-* dom.comm_task defines a different object depending on which process you are.
+* `dom.comm_task` defines a different object depending on which process you are.
* the rank of a process in main_comm may be different from its rank in comm_task
Some useful methods:
-* dom.current_task() : returns the task id of the current process
-* dom.tasks_in_proc(i) : returns task id of process number i
-* dom.is_on_task(tid) : returns true if the current process belongs to task tid
+* `dom.current_task()` : returns the task id of the current process
+* `dom.tasks_in_proc(i)` : returns task id of process number i
+* `dom.is_on_task(tid)` : returns true if the current process belongs to task tid
MPI topologies
--------------
-.. currentmodule:: hysop.mpi
+.. currentmodule:: hysop.core.mpi
Domains may be distributed among several mpi processes, to allow parallel process of the simulation.
MPI cartesian topologies are used to handle the mapping between hysop objects and mpi processes.
@@ -116,12 +117,12 @@ Each process is identified with its rank in the topology and with its coordinate
.. image:: /figures/decomp_domain.*
Moreover, each process knows its neighbours in all directions.
-
+
Basic usage
^^^^^^^^^^^
-
-:class:`topology.Cartesian` objects are used to described this mpi grid layout (we'll see later that it also handles the local space discretisation, i.e. some meshes local to each process).
+
+:class:`topology.CartesianTopology` objects are used to described this mpi grid layout (we'll see later that it also handles the local space discretisation, i.e. some meshes local to each process).
Create a new mpi process distribution is quite simple in HySoP and must be managed through the domain on which
the topology will be defined, thanks to the method :meth:`~hysop.domain.domain.Domain.create_topology`.
By default mpi can find the 'best' processes distribution, depending on how many processes are available, on
@@ -133,13 +134,13 @@ the dimension of the space and on the way data are saved in memory (C or Fortran
# 2d grid of MPI processes
topo = dom.create_topology(d2d)
-Such a code executed with 4 mpi processes will create a topology similar to the one describe on the figure above.
+Such a code executed with 4 mpi processes will create a topology similar to the one describe on the figure above.
Notice the 'd2d' argument, used to specified the space discretisation, since, as said before, :class:`topology.Cartesian` are also used to managed the data distribution on some local meshes. Just ignore this d2d for the moment, we will come back to this in the next part.
The standard methods of a topology are::
# return the number of process in the topology
- print topo.size
+ print topo.size
# rank of the current process in the topology
print topo.rank
# rank of the neighbours of the current process
@@ -148,7 +149,7 @@ The standard methods of a topology are::
print topo.neighbours[:, d]
# id of the task owning this topology
print topo.task_id()
-
+
Advanced usage
^^^^^^^^^^^^^^
@@ -176,14 +177,14 @@ By default, topologies are periodic in each direction. Use isperiodic argument t
dom = Box(dimension=2)
d2d = Discretization([33,33])
- #
+ #
topo_4 = dom.create_topology(d2d, shape=[3, 2], isperiodic=[False, False])
topo_5 = dom.create_topology(d2d, shape=[3, 2], isperiodic=[False, True])
When executed with 6 mpi processes, topo_4 corresponds to left grid and topo_5 to right grid below
.. image:: /figures/periodic_topo.*
-
+
Periodic topologies may be useful to work with periodic domains or data.
@@ -195,7 +196,7 @@ Use a predifined mpi communicator
In some cases, it may be necessary to use a previously built mpi communicator (from another soft, from fortran subroutines ...)::
dom = Box(dimension=2)
- d2d = Discretization([33,33])
+ d2d = Discretization([33,33])
topo_4 = dom.create_topology(d2d, cartesian_topology=another_comm)
# another_comm being previously defined
@@ -209,7 +210,7 @@ Since domain and data may be distributed among mpi processes, we must distinguis
* **local** : all the parameters of the meshes on a given mpi process, i.e. the discretization of a sub-domain.
To summarize, you must choose a global discretisation for each topology, for which some local discretisations will be computed, depending on the number of processes and on the boundary conditions.
-
+
Global discretisation
---------------------
@@ -276,10 +277,10 @@ To conclude, here is a list of the most useful attributes of mesh class::
print mesh.position
# space step
print mesh.space_step
-
+
compute_index returns a list of python slices. For example, in our example of the figure above, on process 1, compute_index is equal to [slice(2, 5)], which means that first point has local index 2 and last point local index 4. This argument can be used to call a numpy array::
-
+
import hysop.tools.numpywrapper as npw
# init some arrays.
a = npw.zeros(topo.mesh.resolution)
@@ -294,8 +295,8 @@ coords or compute_coords returns a tuple, with coordinates values in each direct
def func(x, y):
return np.cos(x) + np.sin(y)
-
-
+
+
d2d = Discretization([11, 11], ghosts=[2, 2])
dom = Box(dimension=2)
topo = dom.create_topology(d2d)
@@ -350,4 +351,3 @@ A few remarks:
* arrays shapes must fit with the topology local resolution,
* ghost points implies mpi communications and impact the memory print of the numerical method. Therefore
they must be used only when required.
-
diff --git a/docs/sphinx/users_guide/finite_differences.rst.orig b/docs/sphinx/users_guide/finite_differences.rst.orig
deleted file mode 100644
index a40d96f71287ca95ca7715cf452eb7469e6913fc..0000000000000000000000000000000000000000
--- a/docs/sphinx/users_guide/finite_differences.rst.orig
+++ /dev/null
@@ -1,235 +0,0 @@
-.. _finite_differences:
-
-.. currentmodule:: hysop.numerics.finite_differences
-
-Finite differences schemes
---------------------------
-
-Differentiate some fields in one direction using finite differences.
-
-So, to compute
-
-.. math::
- \begin{eqnarray}
- result &=& \frac{\partial \rho}{\partial y}
- \end{eqnarray}
-
-<<<<<<< HEAD
-if tab is a numpy array representing the discrete values of the scalar field `:math: \rho`
-on a grid, then the basic usage of such schemes is :
-
-.. code::
-
-=======
-if tab is a numpy array representing the discrete values of the scalar field :math:`\rho`
-on a grid, then the basic usage of such schemes is :
-
-.. code::
-
->>>>>>> master
- # Build/declare the scheme for a given space discretization
- scheme = FDC2(step, indices)
- # Apply scheme on the array
- dir = 1 # y direction
- result = scheme(tab, dir, result)
-
-This will compute :
-
-<<<<<<< HEAD
-result[scheme.output_indices] = diff(tab[indices], dir), diff depending on
-the chosen scheme.
-
-A few important remarks:
-
-* step is the space discretization step size in each direction, i.e. a list of numpy array
- with d values, d being the dimension of the domain.
-* indices represent the set of points on which the scheme must be applied.
-* result must be a predefined numpy array of the 'right' size, here the same size/shape as tab.
-* In the previous default case, output_indices and input_indices are the same.
-* To optimize memory usage and computational time, it's possible to reduce the size of
- the output and/or to apply the scheme on a subset of the domain. All available possibilities
- are summarized through the examples below.
-* the size of the ghost layer depends on the scheme but is not checked! You must ensure
- that topo.ghosts() >= scheme.minimal_ghost_layer
-=======
-result = diff(tab[indices], dir), diff depending on
-the chosen scheme.
-
-
-Available schemes
-^^^^^^^^^^^^^^^^^
-
-* :class:`~FDC2` : first derivative, 2nd order centered scheme
-* :class:`~FD2C2`: second derivative, 2nd order centered scheme
-* :class:`~FDC4`: first derivative, 4th order centered scheme
-
-
-A few important remarks
-^^^^^^^^^^^^^^^^^^^^^^^
-
-* step is the space discretization step size in each direction, i.e. a list or numpy array
- with d values, d being the dimension of the domain. A common case is :code::
-
- step = topo.mesh.space_step
-
-* indices represent the set of points on which the scheme must be applied. This is usually
- a list of slices, for example, :code::
-
- indices = topo.mesh.iCompute
-
-* result must be a predefined numpy array of the 'right' size, here the same size/shape as tab.
-
-* To optimize memory usage and computational time, it's possible to reduce the size of
- the output and/or to apply the scheme on a subset of the domain. All available possibilities
- are summarized through the examples below.
-
-* the size of the ghost layer depends on the scheme but is not checked! You must ensure
- that topo.ghosts() >= scheme.minimal_ghost_layer.
-
-* for some schemes a work array may be provided during call. It must be a numpy array of
- the same size of the result. It's shape is not really important, since during call
- work will be reshaped to be of the same shape as result. This allows us to provide 1D array
- that may be shared between different operators/methods whatever the internal required shapes are.
-
-* Notice that most of the time, finite-differences are defined as internal methods of operators and work arrays management, indices list or ghosts layers are set/checked internally.
->>>>>>> master
-
-Default case : apply scheme on all the domain with a full-size result
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code::
-
- from hysop.numerics.finite_differences import FDC2
- box = Box(length=[1., 1.])
- d2d = Discretization([33, 33], [1, 1])
- topo = box.create_topology(d2d)
- rho = Field(box, name='rho')
- # discretize and initialize rho
- rd = rho.randomize(topo)
- # Get 'computational' points, i.e. grid points excluding ghosts
- ic = topo.mesh.iCompute
- # space step
- step = topo.mesh.space_step
- # field resolution on the grid defined by topo
- shape = topo.mesh.resolution
- result = npw.zeros(shape)
- scheme = FDC2(step, ic)
- assert (topo.ghosts() >= scheme.minimal_ghost_layer).all()
- result = scheme(rd.data[0], 1, result)
-
-In that case:
-
-* result.shape = (34, 34)
-* scheme.indices = [slice(1,33), slice(1,33)]
-* scheme.output_indices = [slice(0,32), slice(0,32)]
-
-
-Apply scheme on all the domain with a reduced result
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-If you do not want to allocate ghosts points for the result, then use:
-
-.. code::
-
- shape = np.asarray(topo.mesh.resolution).copy()
- shape -= 2 * topo.ghosts()
- shape = tuple(shape)
- result = npw.zeros(shape)
- scheme = FDC2(step, ic, indices_out=True)
- assert (topo.ghosts() >= scheme.minimal_ghost_layer).all()
- result = scheme(rd.data[0], 1, result)
-
-In that case:
-
-* result.shape = (32,32)
-* scheme.indices = [slice(1,33), slice(1,33)]
-* scheme.output_indices = [slice(0,32), slice(0,32)]
-
-
-Apply scheme on a subset of the domain with a full-size result
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code::
-
- # We define a subset of the domain,
- # a box of size half of the domain size.
- from hysop.domain.subsets import SubBox
- sl = topo.domain.length * 0.5
- orig = topo.domain.origin + 0.1 * topo.domain.length
- subbox = SubBox(parent=topo.domain, origin=orig, length=sl)
- indices = subbox.discretize(topo)[0]
- scheme = FDC2(step, indices)
- result = npw.zeros_like(rd.data[0])
- result = scheme(rd.data[0], 1, result)
-
-In that case:
-
-* result.shape = (34,34)
-* scheme.indices = [slice(4,21), slice(4,21)]
-* scheme.output_indices = scheme.indices
-
-
-Apply scheme on a subset of the domain with a reduced-size result
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code::
-
- # We define a subset of the domain,
- # a box of size half of the domain size.
- from hysop.domain.subsets import SubBox
- sl = topo.domain.length * 0.5
- orig = topo.domain.origin + 0.1 * topo.domain.length
- subbox = SubBox(parent=topo.domain, origin=orig, length=sl)
- indices = subbox.discretize(topo)[0]
- scheme = FDC2(step, indices, indices_out=True)
- shape = subbox.mesh[topo].resolution
- result = npw.zeros(shape)
- result = scheme(rd.data[0], 1, result)
-
-In that case:
-
-* result.shape = (17,17)
-* scheme.indices = [slice(4,21), slice(4,21)]
-* scheme.output_indices = [slice(0,17), slice(0,17)]scheme.indices
-
-
-Apply scheme on a subset of the domain with a predifined-size result
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Here you can choose explicitely where in result you want to put
-the values of the computed derivative.
-
-
-.. code::
-
- # We define a subset of the domain,
- # a box of size half of the domain size.
- from hysop.domain.subsets import SubBox
- sl = topo.domain.length * 0.5
- orig = topo.domain.origin + 0.1 * topo.domain.length
- subbox = SubBox(parent=topo.domain, origin=orig, length=sl)
- indices = subbox.discretize(topo)[0]
- shape = subbox.mesh[topo].resolution
- result = npw.zeros_like(rd.data[0)
- iout = [slice(2, 19), slice(3, 20)]
- scheme = FDC2(step, indices, indices_out=iout)
- result = scheme(rd.data[0], 1, result)
-
-In that case:
-
-* result.shape = (17,17)
-* scheme.indices = [slice(4,21), slice(4,21)]
-* scheme.output_indices = iout
-
-This option is usefull when input tab is a work array, with a size different
-from the topology resolution, and the result a field defined on the whole grid.
-
-<<<<<<< HEAD
-
-Available schemes
-^^^^^^^^^^^^^^^^^
-
-* :class:`~FDC2` : first derivative, 2nd order centered scheme
-* :class:`~FD2C2`: second derivative, 2nd order centered scheme
-* :class:`~FDC4`: first derivative, 4th order centered scheme
-=======
->>>>>>> master
diff --git a/docs/sphinx/users_guide/stretching.rst b/docs/sphinx/users_guide/stretching.rst
index c8a37b0e951aa5177e595d804734a51f00e21a25..ef2793c1d44666aec04fb3a5e9185098533ddbf3 100644
--- a/docs/sphinx/users_guide/stretching.rst
+++ b/docs/sphinx/users_guide/stretching.rst
@@ -1,6 +1,6 @@
.. _stretching:
-Stretching
+Stretching
==========
.. currentmodule:: hysop.operator.stretching
@@ -12,19 +12,19 @@ may be given under several formulations :cite:`Cottet2000vortex`:
.. math::
- \frac{\partial\omega}{\partial t} &=& [\nabla u] . \omega \\
- &=& [\nabla u]^T . \omega \\
- &=& \nabla.(\omega:u)
+ \frac{\partial\omega}{\partial t} &=& [\nabla u] \cdot \omega \\
+ &=& [\nabla u]^T \cdot \omega \\
+ &=& \nabla \cdot (\omega:u)
+
-
Solve
Two formulations are proposed :
* operator :class:`Conservative`, which corresponds to the resolution of the conservative form:
-
+
.. math::
\frac{\partial \omega}{\partial t} = div(\omega : u)
@@ -60,7 +60,7 @@ Linearized Stretching
---------------------
In the context of a global linear stability study of the Navier-Stokes equation, one may have to formulate and solve
-a "linearized stretching". See details in :ref:`global_linear_stability`.
+a "linearized stretching".
Let us decompose the vorticity and the velocity fields into the sum of the steady state solution, :math:`(.)_b`, and a perturbation,
:math:`(.)'`:
@@ -78,7 +78,7 @@ then the stretching part of the governing equations writes:
The corresponding operator is :class:`StretchingLinearized`, built with the same parameters as for the standard stretching
plus two fields corresponding to the steady state part of the velocity and the vorticity ('BF' below stands for 'Base Flow'):
-
+
.. code::
@@ -87,7 +87,3 @@ plus two fields corresponding to the steady state part of the velocity and the v
Notice that time-integrator for part A of the equation above is user-defined but set to Euler scheme for part B.
-
-
-
-
diff --git a/examples/fixed_point/heat_equation.py b/examples/fixed_point/heat_equation.py
deleted file mode 100644
index 43fddf9ed5e7bb12dfc653397991dff7920d3cc0..0000000000000000000000000000000000000000
--- a/examples/fixed_point/heat_equation.py
+++ /dev/null
@@ -1,141 +0,0 @@
-"""Example for fixed point iteration inside Simulation.
-
-We consider steady state of heat equation with a varying source term.
-Each time step, the source terms are computed analytically and then an
-iterative method is used to compute steady state solution.
-"""
-
-import numpy as np
-
-from hysop import Box, Simulation, Problem, Field, MPIParams
-from hysop.constants import Implementation, HYSOP_REAL, Backend, ResidualError
-from hysop.defaults import TimeParameters
-from hysop.operators import StrangSplitting, DirectionalDiffusion, \
- Convergence, AnalyticField, Dummy, CustomSymbolicOperator
-from hysop.methods import StrangOrder
-from hysop.parameters.scalar_parameter import ScalarParameter
-from hysop.topology.cartesian_topology import CartesianTopology
-from hysop.tools.parameters import Discretization
-from hysop.iterative_method import PseudoSimulation, IterativeMethod
-from hysop.symbolic.relational import Assignment
-from hysop.symbolic.misc import Select
-from hysop.symbolic.tmp import TmpScalar
-from hysop.simulation import eps
-import sympy as sp
-
-
-# Define the domain
-dim = 3
-npts = (33,33,33)
-box = Box(dim=dim, origin=[0., ]*dim, length=[1., ]*dim)
-outfreq = 1
-mpi_params = MPIParams(comm=box.task_comm, task_id=box.current_task())
-dt0 = 1e-3
-
-# Fields
-uSources = Field(domain=box, dtype=HYSOP_REAL, is_vector=False, name="uSources")
-u = Field(domain=box, dtype=HYSOP_REAL, is_vector=False, name="u")
-convergence = ScalarParameter(name="conv", dtype=HYSOP_REAL, quiet=True,
- initial_value=1e10)
-t, dt = TimeParameters(dtype=HYSOP_REAL)
-pseudo_dt = ScalarParameter(name='pseudo_dt', dtype=HYSOP_REAL, min_value=eps,
- initial_value=eps, quiet=True)
-
-# Topologies (needed to fix redistributes between the two problems)
-topo_nogh = CartesianTopology(
- domain=box,
- backend=Backend.HOST,
- discretization=Discretization(npts, ghosts=(0, 0, 0)),
- mpi_params=mpi_params)
-
-# Operator for setting iterative method
-(x0, x1, x2) = box.frame.coords
-utemp = TmpScalar(name='utemp', value=0., dtype=HYSOP_REAL)
-source = CustomSymbolicOperator(
- implementation=Implementation.OPENCL,
- name="BCAndSourceTerm",
- exprs=(
- # Source term
- Assignment(utemp, Select(u.s(), uSources.s(),
- sp.sqrt((x0-0.5)*(x0-0.5)+(x1-0.5)*(x1-0.5)+0.*x2)<=0.2)),
- # BC enforcement
- Assignment(utemp, Select(utemp, 0., x0<0.1)),
- Assignment(utemp, Select(utemp, 0., x0>0.9)),
- Assignment(utemp, Select(utemp, 0., x1<0.1)),
- Assignment(utemp, Select(utemp, 0., x1>0.9)),
- Assignment(u.s(), utemp)),
- variables={uSources: npts, u: npts},
- mpi_params=mpi_params)
-# Diffusion operator
-diffuse = DirectionalDiffusion(
- implementation=Implementation.OPENCL,
- name='diffuse',
- fields=(u),
- coeffs=(.1,),
- variables={u: npts},
- dt=pseudo_dt,
- mpi_params=mpi_params)
-splitting = StrangSplitting(splitting_dim=dim,
- order=StrangOrder.STRANG_FIRST_ORDER)
-splitting.push_operators(diffuse)
-# Convergence operator with absolute error
-conv = Convergence(convergence=convergence,
- method={ResidualError: ResidualError.ABSOLUTE},
- variables={u: topo_nogh},
- name='convergence',
- implementation=Implementation.PYTHON,
- mpi_params=mpi_params)
-# Dummy operators to fix in/out topologies
-fp_in = Dummy(implementation=Implementation.PYTHON,
- name="dummy_fixedpoint_input",
- variables={uSources: topo_nogh, u: topo_nogh},
- mpi_params=mpi_params)
-fp_out = Dummy(implementation=Implementation.PYTHON,
- name="dummy_fixedpoint_output",
- variables={u: topo_nogh},
- mpi_params=mpi_params)
-# Iterative method problem with convergence
-fixedPoint = IterativeMethod(stop_criteria=convergence, tolerance=1e-6,
- dt0=1e-3, dt=pseudo_dt,
- name="FixedPointIterations")
-fixedPoint.insert(fp_in, splitting, source, conv, fp_out)
-
-
-# Analytic operator for computing source term
-class CS():
- def __init__(self):
- self.coeff=1.
- def __call__(self, data, coords, t):
- (x, y, z) = coords[0]
- pos = [0.5, 0.5, 0.5]
- RADIUS = 0.2
- chi = lambda x,y,z: np.sqrt((x-pos[0])*(x-pos[0])+(y-pos[1])*(y-pos[1])+0.*z)<=RADIUS
- data[0][...] = 0.
- data[0][chi(x,y,z)] = np.cos(t())
- #self.coeff = self.coeff - 0.01
-heat_sources = AnalyticField(name='heat_sources',
- field=uSources, formula=CS(),
- variables = {uSources: topo_nogh},
- implementation=Implementation.PYTHON,
- extra_input_kwds={'t': t},
- mpi_params=mpi_params)
-# Dummy operators to fix in/out topologies
-fp_enter = Dummy(implementation=Implementation.PYTHON,
- name="dummy_fixedpoint_enter",
- variables={uSources: topo_nogh, u: topo_nogh},
- mpi_params=mpi_params)
-fp_after = Dummy(implementation=Implementation.PYTHON,
- name="dummy_fixedpoint_after",
- variables={u: topo_nogh},
- mpi_params=mpi_params)
-fp_after.dump_outputs(fields=(u,), frequency=outfreq)
-
-# Main problem (time iterations)
-problem = Problem(name="MainProblem")
-problem.insert(heat_sources, fp_enter, fixedPoint, fp_after)
-problem.build()
-simu = Simulation(start=0., end=np.pi*2, max_iter=1000, dt0=0.1, dt=dt, t=t)
-simu.write_parameters(t, fixedPoint.it_num,
- filename='parameters.txt', precision=8)
-problem.solve(simu)
-problem.finalize()
diff --git a/examples/scalar_advection/levelset.py b/examples/scalar_advection/levelset.py
deleted file mode 100644
index 9639474272296a41bf47101a5e1ecc6464a31a8b..0000000000000000000000000000000000000000
--- a/examples/scalar_advection/levelset.py
+++ /dev/null
@@ -1,176 +0,0 @@
-# coding: utf-8
-
-import numpy as np
-import sympy as sm
-
-
-from hysop import Field, Box, Simulation, Problem, \
- ScalarParameter, MPIParams, CartesianDiscretization, CartesianTopology
-from hysop.constants import Implementation, Backend
-from hysop.operators import DirectionalAdvection, StrangSplitting, Integrate, \
- AnalyticField, Advection
-from hysop.methods import Remesh, TimeIntegrator, ComputeGranularity, \
- Interpolation, StrangOrder
-import hysop.numerics.odesolvers.runge_kutta as rk
-from hysop.defaults import TimeParameters
-
-pi = np.pi
-dim = 3
-
-## Function to compute initial scalar values
-def init_scalar(data, coords):
- if dim == 3:
- (x,y,z) = coords[0]
- rr = np.sqrt((x - 0.35) ** 2 + (y - 0.35) ** 2 + (z - 0.35) ** 2)
- else:
- (x,y) = coords[0]
- rr = np.sqrt((x - 0.5) ** 2 + (y - 0.75) ** 2)
- data[0][...] = 0.
- data[0][rr < 0.15] = 1.
- rr = np.sqrt((x - 0.75) ** 2 + (y - 0.75) ** 2 + (z - 0.75) ** 2)
- data[0][rr < 0.1] += 1.
-
-# Define domain
-npts = (64,)*dim
-npts_s = (64, )*dim
-box = Box(origin=(0.,)*dim, length=(1.,)*dim, dim=dim)
-if dim == 3:
- dt0 = 0.35 / (4. * pi)
-else:
- dt0 = 0.35 / (2. * pi)
-cfl = 1. * dt0 * max(npts)
-
-# Get default MPI Parameters from domain (even for serial jobs)
-mpi_params = MPIParams(comm=box.task_comm,
- task_id=box.current_task())
-
-# Define parameters and field (time and analytic field)
-t, dt = TimeParameters(dtype=np.float64)
-velo = Field(domain=box, name='V', is_vector=True, dtype=np.float64)
-scalar = Field(domain=box, name='S0', nb_components=1, dtype=np.float64)
-vol = ScalarParameter('volume', dtype=np.float64)
-
-# Setup operator method dictionnary
-# Advection-Remesh operator discretization parameters
-method = {
- TimeIntegrator: rk.RK2,
- Remesh: Remesh.L4_2,
- Interpolation: Interpolation.LINEAR
-}
-
-# Create a simulation and solve the problem
-# (do not forget to specify the dt parameter here)
-simu = Simulation(start=0., end=3.+dt0/2,
- max_iter=100000,
- times_of_interest=(0., 3.),
- t=t, dt=dt, dt0=dt0)
-simu.write_parameters(simu.t, vol, filename='volume.txt', precision=8)
-
-
-# ghosts = (2,)*dim
-# d3d = CartesianDiscretization(npts, ghosts, default_boundaries=True)
-# topo = CartesianTopology(domain=box, discretization=d3d, backend=Backend.OPENCL)
-
-# Setup implementation specific variables
-#impl = Implementation.PYTHON
-impl = Implementation.FORTRAN
-#impl = Implementation.OPENCL
-extra_op_kwds = { 'mpi_params': mpi_params }
-if (impl is Implementation.PYTHON) or (impl is Implementation.FORTRAN):
- sin, cos = np.sin, np.cos
- def compute_velocity(data, coords, t):
- (x,y,z) = coords[0]
- data[0][...] = 2.*sin(pi*x)**2*sin(2.*pi*y)*sin(2.*pi*z)*cos(t()*pi/3.)
- data[1][...] = -sin(2.*pi*x)*sin(pi*y)**2*sin(2.*pi*z)*cos(t()*pi/3.)
- data[2][...] = -sin(2.*pi*x)*sin(2.*pi*y)*sin(pi*z)**2*cos(t()*pi/3.)
- formula = compute_velocity
-elif (impl is Implementation.OPENCL):
- sin, cos = sm.sin, sm.cos
- if dim == 3:
- x, y, z = box.frame.coords
- formula = (2.*sin(pi*x)**2*sin(2.*pi*y)*sin(2.*pi*z)*cos(t.s*pi/3.),
- -sin(2.*pi*x)*sin(pi*y)**2*sin(2.*pi*z)*cos(t.s*pi/3.),
- -sin(2.*pi*x)*sin(2.*pi*y)*sin(pi*z)**2*cos(t.s*pi/3.))
- else:
- x, y = box.frame.coords
- formula = (-sin(x*pi)**2*sin(y*pi*2)*cos(t.s*pi/3.),
- sin(y*pi)**2*sin(x*pi*2)*cos(t.s*pi/3.))
-else:
- msg='Unknown implementation \'{}\'.'.format(impl)
- raise ValueError(msg)
-
-
-analytic = AnalyticField(field=velo, formula=formula,
- variables={velo: npts},
- extra_input_kwds={'t': simu.t},
- implementation=Implementation.PYTHON if (impl is Implementation.FORTRAN) else impl,
- **extra_op_kwds)
-# Build the directional advection operator
-# here the cfl determines the maximum number of ghosts
-# advec = Advection(name='advec',
-# velocity = velo,
-# #velocity_cfl = cfl,
-# advected_fields = (scalar,),
-# dt = dt,
-# variables = {velo: npts, scalar: npts_s},
-# implementation=Implementation.FORTRAN,#relax_min_particles=True,
-# **extra_op_kwds)
-volume = Integrate(name='volume',
- field=scalar,
- variables={scalar: npts_s},
- parameter=vol,
- implementation=impl,
- **extra_op_kwds)
-
-if (impl is Implementation.FORTRAN):
- advec = Advection(name='advec',
- velocity = velo,
- advected_fields = (scalar,),
- dt = dt,
- variables = {velo: npts, scalar: npts_s},
- implementation=impl,#relax_min_particles=True,
- **extra_op_kwds)
-else:
- advec = DirectionalAdvection(name='advec',
- velocity = velo,
- velocity_cfl = cfl,
- advected_fields = (scalar,),
- dt = dt,
- variables = {velo: npts, scalar: npts_s},
- implementation=impl,#relax_min_particles=True,
- **extra_op_kwds)
- # Build the directional splitting operator graph
- splitting = StrangSplitting(splitting_dim=dim,
- order=StrangOrder.STRANG_SECOND_ORDER)
- splitting.push_operators(advec)
-
-# Create the problem we want to solve and insert our
-# directional splitting subgraph.
-# Add a writer of input field at given frequency.
-problem = Problem(method=method)
-problem.insert(analytic)
-if (impl is Implementation.FORTRAN):
- #advec.dump_inputs(fields=scalar, filename='S0', frequency=10)
- problem.insert(advec)
- problem.dump_inputs(fields=scalar, filename='S0', frequency=1)
-else:
- problem.insert(splitting)
- problem.dump_inputs(fields=scalar, filename='S0', frequency=10)
-#problem.insert(volume)
-problem.build()
-
-# If a visu_rank was provided, and show_graph was set,
-# display the graph on the given process rank.
-# if args.display_graph:
-# problem.display(args.visu_rank)
-
-# Initialize discrete velocity and scalar field
-dfields = problem.input_discrete_fields
-#dfields[velo].initialize(formula=init_velocity)
-dfields[scalar].initialize(formula=init_scalar)
-
-# Finally solve the problem
-problem.solve(simu)
-
-# Finalize
-problem.finalize()
diff --git a/hysop/__init__.py.in b/hysop/__init__.py.in
index 9a74933c94835d27dbb5698ee404841ddb70f52b..701856c217556b09b0468e89f46aa8d91b5651e2 100644
--- a/hysop/__init__.py.in
+++ b/hysop/__init__.py.in
@@ -2,9 +2,26 @@
Python package dedicated to flow simulation using particular methods
on hybrid architectures (MPI-GPU)
"""
-import psutil
+import psutil, signal, traceback, threading, sys, os, warnings
from functools import wraps
-from hysop.deps import __builtin__, print_function, os, sys, warnings, traceback
+from hysop.deps import __builtin__, print_function
+
+# Register debug signals (SIGUSR1(10)=print the main stack, SIGUSR2(12)=print the stack of all threads)
+def dumpstack(signal, frame):
+ traceback.print_stack()
+def dumpstacks(signal, frame):
+ #https://stackoverflow.com/questions/132058/showing-the-stack-trace-from-a-running-python-application
+ id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
+ code = []
+ for threadId, stack in sys._current_frames().items():
+ code.append("\n# Thread: %s(%d)" % (id2name.get(threadId,""), threadId))
+ for filename, lineno, name, line in traceback.extract_stack(stack):
+ code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
+ if line:
+ code.append(" %s" % (line.strip()))
+ print("\n".join(code))
+signal.signal(signal.SIGUSR1, dumpstack)
+signal.signal(signal.SIGUSR2, dumpstacks)
def get_env(target, default_value):
target = 'HYSOP_{}'.format(target)
@@ -33,6 +50,7 @@ __GPU_ENABLED__ = "@WITH_GPU@" is "ON"
__FFTW_ENABLED__ = "@WITH_FFTW@" is "ON"
__SCALES_ENABLED__ = "@WITH_SCALES@" is "ON"
__OPTIMIZE__ = not __debug__
+__H5PY_PARALLEL_COMPRESSION_ENABLED__ = ("@H5PY_PARALLEL_COMPRESSION_ENABLED@" is "ON")
__VERBOSE__ = get_env('VERBOSE', ("@VERBOSE@" is "ON"))
__DEBUG__ = get_env('DEBUG', ("@DEBUG@" is "ON"))
@@ -42,6 +60,8 @@ __TRACE_CALLS__ = get_env('TRACE_CALLS', False)
__TRACE_WARNINGS__ = get_env('TRACE_WARNINGS', False)
__TRACE_MEMALLOCS__ = get_env('TRACE_MEMALLOC', False)
__TRACE_KERNELS__ = get_env('TRACE_KERNELS', False)
+__TRACE_NOCOPY__ = get_env('TRACE_NOCOPY', False)
+__TRACE_NOACCUMULATE__ = get_env('TRACE_NOACCUMULATE', False)
__KERNEL_DEBUG__ = get_env('KERNEL_DEBUG', False)
__BACKTRACE_BIG_MEMALLOCS__ = get_env('BACKTRACE_BIG_MEMALLOCS', False)
@@ -52,7 +72,8 @@ __ENABLE_LONG_TESTS__ = get_env('ENABLE_LONG_TESTS', ("@ENABLE_LONG_TESTS@" is "
__ENABLE_THREADING__ = get_env('ENABLE_THREADING', True)
__MAX_THREADS__ = int(get_env('MAX_THREADS', psutil.cpu_count(logical=False)) if __ENABLE_THREADING__ else 1)
set_env('OMP_NUM_THREADS', __MAX_THREADS__)
-set_env('MKL_NUM_THREADS', __MAX_THREADS__)
+set_env('MKL_NUM_THREADS', 1)
+set_env('MKL_THREADING_LAYER', 'TBB' if __ENABLE_THREADING__ else 'SEQUENTIAL')
set_env('NUMBA_NUM_THREADS', __MAX_THREADS__)
set_env('NUMBA_THREADING_LAYER', 'workqueue') # Use 'numba -s' to list support
__DEFAULT_NUMBA_TARGET__ = ('parallel' if __ENABLE_THREADING__ else 'cpu')
@@ -72,6 +93,8 @@ if __MPI_ENABLED__:
shm_rank, intershm_size
else:
main_rank, main_size = 0, 1
+ interhost_size, intershm_size = 1, 1
+ host_rank, shm_rank = 0, 0
# define printing functions
def print(*args, **kargs):
@@ -125,13 +148,14 @@ from hysop.fields.continuous_field import Field
from hysop.fields.discrete_field import DiscreteField
from hysop.parameters.scalar_parameter import ScalarParameter
from hysop.parameters.tensor_parameter import TensorParameter
+from hysop.parameters.buffer_parameter import BufferParameter
from hysop.topology.cartesian_topology import Topology, CartesianTopology
from hysop.topology.topology_descriptor import TopologyDescriptor
from hysop.tools.parameters import CartesianDiscretization, MPIParams
from hysop.simulation import Simulation
from hysop.problem import Problem
from hysop.tools.io_utils import IO, IOParams
-__all__ = ['Box', 'Field', 'DiscreteField', 'ScalarParameter', 'TensorParameter',
+__all__ = ['Box', 'Field', 'DiscreteField', 'ScalarParameter', 'TensorParameter', 'BufferParameter',
'Domain', 'CartesianDiscretization', 'Simulation', 'MPIParams',
'Problem', 'IO', 'IOParams', 'IterativeMethod',
'Topology', 'CartesianTopology', 'TopologyDescriptor']
@@ -149,13 +173,13 @@ msg_start = '\nStarting {} version {}'.format(package_name, version)
if __MPI_ENABLED__:
msg_start += (' with {} mpi process(es) on {} host(s) '+
'providing {} shared memory node(s).').format(main_size,interhost_size,intershm_size)
-mprint(msg_start)
+vprint(msg_start)
default_path = IO.default_path()
cache_path = IO.default_cache_path()
msg_io = '\n*Default path for all i/o is \'{}\'.'.format(default_path)
msg_io += '\n*Default path for caching is \'{}\'.'.format(cache_path)
-mprint(msg_io)
+vprint(msg_io)
msg_threads = \
'''
@@ -165,7 +189,14 @@ msg_threads = \
HYSOP_MAX_THREADS: {}
--------------------------------
OMP_NUM_THREADS: {}
+ OMP_DYNAMIC: {}
+ OMP_NESTED: {}
+ OMP_MAX_ACTIVE_LEVELS: {}
+ --------------------------------
+ MKL_THREADING_LAYER: {}
MKL_NUM_THREADS: {}
+ MKL_DOMAIN_NUM_THREADS: {}
+ MKL_DYNAMIC: {}
--------------------------------
DEFAULT_NUMBA_TARGET: {}
NUMBA_THREADING_LAYER: {}
@@ -178,12 +209,18 @@ msg_threads = \
'''.format(
__ENABLE_THREADING__,
__MAX_THREADS__,
- os.environ['OMP_NUM_THREADS'],
- os.environ['MKL_NUM_THREADS'],
+ os.environ.get('OMP_NUM_THREADS', None),
+ os.environ.get('OMP_DYNAMIC', None),
+ os.environ.get('OMP_NESTED', None),
+ os.environ.get('OMP_MAX_ACTIVE_LEVELS', None),
+ os.environ.get('MKL_THREADING_LAYER', None),
+ os.environ.get('MKL_NUM_THREADS', None),
+ os.environ.get('MKL_DOMAIN_NUM_THREADS', None),
+ os.environ.get('MKL_DYNAMIC', None),
__DEFAULT_NUMBA_TARGET__,
- os.environ['NUMBA_THREADING_LAYER'],
- os.environ['NUMBA_NUM_THREADS'],
+ os.environ.get('NUMBA_THREADING_LAYER', None),
+ os.environ.get('NUMBA_NUM_THREADS', None),
__FFTW_NUM_THREADS__,
__FFTW_PLANNER_EFFORT__,
__FFTW_PLANNER_TIMELIMIT__)
-mprint(msg_threads)
+vprint(msg_threads)
diff --git a/hysop/backend/device/autotunable_kernel.py b/hysop/backend/device/autotunable_kernel.py
index 32d2d6359606ce48f4becb1d79becd79d39e5c35..b70bcf0dd35dcdaba49a087a8c3b22b110d0f874 100644
--- a/hysop/backend/device/autotunable_kernel.py
+++ b/hysop/backend/device/autotunable_kernel.py
@@ -23,7 +23,7 @@ class AutotunableKernel(object):
self.symbolic_mode = first_not_None(symbolic_mode, autotuner_config.debug)
def custom_hash(self, *args, **kwds):
- HASH_DEBUG=False
+ HASH_DEBUG=self.autotuner_config.dump_hash_logs
assert args or kwds, 'no arguments to be hashed.'
def _hash_arg(a):
@@ -273,7 +273,7 @@ class AutotunableKernel(object):
max_device_work_dim = self.max_device_work_dim()
max_device_work_group_size = self.max_device_work_group_size()
max_device_work_item_sizes = self.max_device_work_item_sizes()
-
+
max_work_group_size = min(max_device_work_group_size, max_kernel_work_group_size)
work_bounds = AutotunerWorkBoundsConfiguration(
@@ -732,9 +732,11 @@ class AutotunerWorkConfiguration(object):
def _load_default_filters(self, work_bounds, ordered_workload):
"""Load default local_work_size filters (mostly device limitations.)"""
- self.push_filter('max_device_work_item_sizes (default)', self.max_wi_sizes_filter,
+ self.push_filter('max_device_work_item_sizes (default filter, max_work_item_sizes={})'.format(work_bounds.max_device_work_item_sizes),
+ self.max_wi_sizes_filter,
max_work_item_sizes=work_bounds.max_device_work_item_sizes)
- self.push_filter('max_device_work_group_size (default)', self.max_wg_size_filter,
+ self.push_filter('max_device_work_group_size (default filter, max_device_work_group_size={})'.format(work_bounds.max_device_work_group_size),
+ self.max_wg_size_filter,
max_work_group_size=work_bounds.max_device_work_group_size)
if ordered_workload:
self.push_filter('ordered_workload (default)', self.ordered_workload_filter)
diff --git a/hysop/backend/device/codegen/base/codegen.py b/hysop/backend/device/codegen/base/codegen.py
index e5d5eccf32a0a3623c10c4b5e00904013d95b436..9110b9ee3b98f5eb357ecea056467f6c935fd936 100644
--- a/hysop/backend/device/codegen/base/codegen.py
+++ b/hysop/backend/device/codegen/base/codegen.py
@@ -1,4 +1,3 @@
-
from contextlib import contextmanager
from subprocess import call
@@ -7,6 +6,7 @@ from hysop.deps import it, sys, os, string, tempfile, operator
from hysop.backend.device.opencl import cl
from hysop.backend.device.codegen.base.utils import WriteOnceDict, VarDict
from hysop.backend.device.codegen.base.variables import CodegenVariable
+from hysop.core.mpi import main_rank
class CodeGenerator(object):
@@ -33,36 +33,36 @@ class CodeGenerator(object):
'function_declarations' : -200,
'kernel_declarations' : -100
}
-
+
def __init__(self,name,typegen,
ext='.tmp', known_vars=None,
initial_indent_level=0,
escape_seqs=None,keywords=None,
**kargs):
-
+
super(CodeGenerator,self).__init__(**kargs)
self.name = name
self.typegen = typegen
self.fbtype = typegen.fbtype
self.initial_indent_level = initial_indent_level
self.ext = ext
-
+
self.reset()
if (known_vars is not None):
- self.known_vars = known_vars
+ self.known_vars = known_vars
self._configure(escape_seqs,keywords)
-
+
def reset(self):
self.code = ''
self.indent_level = self.initial_indent_level
self.prototypes = {}
-
+
self.vars = VarDict()
self.known_vars = WriteOnceDict()
self.reqs = WriteOnceDict()
self.init_blocks()
-
+
def _configure(self,escape_seqs,keywords):
if escape_seqs is None:
self.escape_seqs = self.default_escape_seqs
@@ -80,13 +80,13 @@ class CodeGenerator(object):
self.last_block_priority = -1
self.register_default_codeblock()
return self
-
+
def register_default_codeblock(self,name='default',priority=1000,comment=None):
self.default_block_name = name
self.default_block = [priority, '', comment]
return self
-
-
+
+
def inject_vars(self, new_vars):
for varname in new_vars.keys():
if varname in self.vars.keys():
@@ -121,7 +121,7 @@ class CodeGenerator(object):
def to_file(self,folder,filename):
dst_file = folder + '/' + filename
- if not os.path.exists(folder):
+ if not os.path.exists(folder) and (main_rank == 0):
os.makedirs(folder)
with open(dst_file, 'w+') as f:
f.write(self.__str__())
@@ -147,10 +147,10 @@ class CodeGenerator(object):
def newl(self):
return self.escape_seqs['\n']
def space(self):
- return self.escape_seqs[' ']
+ return self.escape_seqs[' ']
def empty(self):
return ''
-
+
def current_indent(self):
return self.tab()*self.indent_level
@@ -211,8 +211,8 @@ class CodeGenerator(object):
return self.append(code)
- def comment(self,comments, simple=False,
- force_spacing=True, align=True,
+ def comment(self,comments, simple=False,
+ force_spacing=True, align=True,
upperband=False, lowerband=False,
prepend=False):
@@ -280,7 +280,7 @@ class CodeGenerator(object):
al.jumpline()
except:
raise
-
+
class VarBlock(object):
def __init__(self):
@@ -315,14 +315,14 @@ class CodeGenerator(object):
if e == 'inits':
for i,v in enumerate(self._varnames):
self._varnames[i] = v+';'
-
+
kargs = kargs[:-1].replace('[i]','[{i}]')
lines = []
for i in xrange(len(self._varnames)):
l = eval('line.format('+kargs.format(i=i)+')')
lines.append(l)
return lines
-
+
@contextmanager
def _var_block_(self):
vb = self.VarBlock()
@@ -335,7 +335,7 @@ class CodeGenerator(object):
self.sep = sep
self._lines = []
self._parts_count = None
-
+
def jumpline(self,count=1):
lines = ''+'\n'*(count-1)
self.append(lines)
@@ -359,10 +359,11 @@ class CodeGenerator(object):
def code(self):
if self._parts_count is None:
- msg='Call at least one append() before closing an _align_!'
- msg+='\n got: {}'.format(self._lines)
- raise RuntimeError(msg)
-
+ #msg='Call at least one append() before closing an _align_!'
+ #msg+='\n got: {}'.format(self._lines)
+ #raise RuntimeError(msg)
+ return []
+
maxlen = lambda i: max([len(line[i]) for line in self._lines if len(line)>1])
line_str = ''
for i in xrange(self._parts_count):
@@ -378,7 +379,7 @@ class CodeGenerator(object):
else:
code.append(line[0])
return code
-
+
@contextmanager
def _align_(self,sep='$'):
ab = self.AlignBlock(sep=sep)
@@ -427,7 +428,7 @@ class CodeGenerator(object):
self.blocks[blockname] = [priority,'',comment]
elif priority is not None and self.blocks[blockname][0] != priority:
raise ValueError('Priority mismatch!')
-
+
code = self.code
indent = self.indent_level
self.indent_level = self.initial_indent_level
@@ -465,7 +466,7 @@ class CodeGenerator(object):
def _block_(self,header_prefix='',header_postfix='',footer_postfix='',compact=False):
count = 1-int(compact)
newline = not compact
-
+
header = header_prefix + '{' + header_postfix
self.append(header.split('\n'),newline).indent(count)
yield self
@@ -474,8 +475,8 @@ class CodeGenerator(object):
self.code += ' '
footer = '}' + footer_postfix
self.dedent(count).append(footer)
-
-
+
+
#conditional facilities
@contextmanager
def _if_(self,cond,compact=False,force_spaces=False):
@@ -512,14 +513,14 @@ class CodeGenerator(object):
def _struct_(self,name,variables=None,typedef=None):
if name == '' and typedef is None:
raise ValueError('Cannot define a non typedefed anonymous struct!')
-
- header_prefix = 'struct ' + name
+
+ header_prefix = 'struct ' + name
if typedef:
declaration = 'typedef ' + header_prefix + ' ' + typedef + ';'
else:
declaration = header_prefix + ';'
self.declare_prototype(declaration, 'struct')
-
+
with self._codeblock_('struct_declarations'):
with self._block_(header_prefix=header_prefix+' ',
footer_postfix=';',compact=False) as b:
@@ -527,20 +528,20 @@ class CodeGenerator(object):
for v in variables:
self.append(v+';')
yield b
-
+
# union facilities
@contextmanager
def _union_(self,name,variables=None,typedef=None):
if name == '' and typedef is None:
raise ValueError('Cannot define a non typedefed anonymous struct!')
-
- header_prefix = 'union ' + name
+
+ header_prefix = 'union ' + name
if typedef:
declaration = 'typedef ' + header_prefix + ' ' + typedef + ';'
else:
declaration = header_prefix + ';'
self.declare_prototype(declaration, 'union')
-
+
with self._codeblock_('union_declarations'):
with self._block_(header_prefix=header_prefix+' ',
footer_postfix=';',compact=False) as b:
@@ -548,9 +549,9 @@ class CodeGenerator(object):
for v in variables:
self.append(v+';')
yield b
-
+
#looping facilities
- @contextmanager
+ @contextmanager
def _for_(self, custom, compact=False, unroll=False):
header_prefix = 'for (' + custom + ') '
if (unroll is not None) and (unroll is not False):
@@ -560,18 +561,18 @@ class CodeGenerator(object):
header_prefix = '#pragma unroll {}\n{}'.format(unroll, header_prefix)
with self._block_(header_prefix=header_prefix,compact=compact) as b:
yield b
- @contextmanager
+ @contextmanager
def _while_(self, custom, compact=False):
header_prefix = 'while (' + custom + ') '
with self._block_(header_prefix=header_prefix,compact=compact) as b:
yield b
- @contextmanager
+ @contextmanager
def _do_while_(self, custom, compact=False):
header_prefix = 'do '
footer_postfix = ' while (' + custom + ');'
with self._block_(header_prefix=header_prefix,footer_postfix=footer_postfix,compact=compact) as b:
yield b
-
+
#function facilities
@contextmanager
def _function_(self,name,output,args=[],args_impl=None,arg_spaces=True,inline=False,compact=False):
@@ -587,7 +588,7 @@ class CodeGenerator(object):
if newl and i != len(_args)-1:
newargs.append(self.newl())
return newargs
-
+
args = filter_args(args)
if not args_impl:
args_impl = args
@@ -602,8 +603,8 @@ class CodeGenerator(object):
sprefix = '{inline}{output} {name}'
sfun = '{prefix}({args})'
inline = self.keywords['inline']+' ' if inline else ''
-
-
+
+
prefix = sprefix.format(inline=inline,output=output,name=name)
indent = len(self.current_indent() + prefix)*' ' + ' '
if args:
@@ -612,8 +613,8 @@ class CodeGenerator(object):
pargs = []
prototype = sfun.format(prefix=prefix,args=''.join(pargs))
prototype += ';'
-
-
+
+
prefix = sprefix.format(inline='',output=output,name=name)
indent = len(self.current_indent() + prefix)*' ' + ' '
if args_impl:
@@ -638,8 +639,8 @@ class CodeGenerator(object):
req.generate(blocks,genset)
if self.name in genset:
- return
-
+ return
+
dname = self.default_block_name
(prio,_,self_com) = self.default_block
poverride = self.block_priorities_override[dname] if dname in self.block_priorities_override else None
@@ -648,18 +649,18 @@ class CodeGenerator(object):
blocks[dname] = [poverride if poverride else prio, code+self.code,self_com]
else:
blocks[dname] = [poverride if poverride else prio,self.code,self_com]
-
+
for blk_name, blk_val in self.blocks.iteritems():
priority,self_code,self_com = blk_val
poverride = self.block_priorities_override[blk_name] if blk_name in self.block_priorities_override else None
if blk_name in blocks.keys():
- (priority,code,com) = blocks[blk_name]
+ (priority,code,com) = blocks[blk_name]
blocks[blk_name] = [poverride if poverride else priority, code+self_code, self_com if self_com != '' else com]
else:
blocks[blk_name] = [poverride if poverride else priority,self_code,self_com]
-
+
genset.add(self.name)
-
+
def __str__(self):
blocks = {}
genset = set()
@@ -689,7 +690,7 @@ if __name__ == '__main__':
cg.declare_codeblocks(names=['top','footer'],priorities=[10,40]) \
.register_default_codeblock('body',30) \
.override_block_priorities(struct_prototypes=20, function_prototypes=21, kernel_prototypes=22)
-
+
with cg._codeblock_('top'):
cg.jumpline()
cg.comment('This is a test comment!\nIt is aligned even with different sizes!', upperband=True, lowerband=True)
@@ -708,7 +709,7 @@ if __name__ == '__main__':
with cg._function_('add','double',['double lhs', 'const double rhs'],inline=True,compact=True):
cg.append('return lhs+rhs;')
cg.jumpline()
-
+
cg.comment('Without compact mode:')
with cg._function_('get_number','int'):
cg.append('int k = 42;');
@@ -716,7 +717,7 @@ if __name__ == '__main__':
cg.append('k++;')
cg.append('return k;')
cg.jumpline()
-
+
cg.comment('Nested blocks:',simple=True)
with cg._block_():
with cg._block_():
@@ -735,20 +736,19 @@ if __name__ == '__main__':
cg._continue()
with cg._else_():
cg.append('i++;')
-
+
# test requirements feature (include another codegenerator and merge blocks at code generation)
ef = EmptyFunction()
ef.jumpline()
ef.register_default_codeblock(cg.default_block_name) #share the same default codeblock for the two generators
cg.require(ef)
cg.require(ef) #multiple dependency on the same generator are ignored (name based lookup)
-
+
#edit the current code directly by hand in a temporary file !
# cg.edit()
#save the file
cg.to_file('.','test.c')
-
+
#output the generated code to stdout
#print cg
-
diff --git a/hysop/backend/device/codegen/base/opencl_codegen.py b/hysop/backend/device/codegen/base/opencl_codegen.py
index eb77f99831e94b4a7b9be37c06ce76ff58a7b034..b984212441f0ddd9e13a6a7ed9ade79cbf7d1da2 100644
--- a/hysop/backend/device/codegen/base/opencl_codegen.py
+++ b/hysop/backend/device/codegen/base/opencl_codegen.py
@@ -390,6 +390,11 @@ class OpenClCodeGenerator(CodeGenerator):
self.barrier(_local=True)
with self._if_(cond1):
yield
+ @contextmanager
+ def _first_wg_execution_(self):
+ cond = ' && '.join('(0==get_group_id({i}))'.format(i=i) for i in xrange(3))
+ with self._if_(cond):
+ yield
@contextmanager
def _first_wi_execution_(self):
diff --git a/hysop/backend/device/codegen/base/struct_codegen.py b/hysop/backend/device/codegen/base/struct_codegen.py
index b6ff919fc6ca7bd6ac9e19d3b3a7b605b2520217..f858f28f44ec88832b67c6605688be344852be06 100644
--- a/hysop/backend/device/codegen/base/struct_codegen.py
+++ b/hysop/backend/device/codegen/base/struct_codegen.py
@@ -34,8 +34,9 @@ class StructCodeGenerator(OpenClCodeGenerator):
return self.dtype.fields
def c_decl(self):
+ assert (self.context is not None)
dtype,cdecl = cl.tools.match_dtype_to_c_struct( \
- self.device,self.ctype.replace('struct',''),self.dtype,self.context)
+ self.device,self.ctype.replace('struct',''),self.dtype,context=self.context)
return cdecl
def gencode(self, comments, ctype_overrides):
diff --git a/hysop/backend/device/codegen/base/union_codegen.py b/hysop/backend/device/codegen/base/union_codegen.py
index 98fb708ecc4c7b7edb063b5db912d395c236a51d..c574b2c5eac4126b2ec3ee9c511ee02b5e40ccb1 100644
--- a/hysop/backend/device/codegen/base/union_codegen.py
+++ b/hysop/backend/device/codegen/base/union_codegen.py
@@ -28,8 +28,9 @@ class UnionCodeGenerator(OpenClCodeGenerator):
self.gencode(comments, ctype_overrides)
def c_decl(self):
+ assert (self.context is not None)
dtype,cdecl = cl.tools.match_dtype_to_c_struct( \
- self.device,self.ctype.replace('union',''),self.dtype,self.context)
+ self.device,self.ctype.replace('union',''),self.dtype,context=self.context)
return cdecl
def fields(self):
diff --git a/hysop/backend/device/codegen/base/variables.py b/hysop/backend/device/codegen/base/variables.py
index e10575633fd63f093f49e79e215e0b9302e6157d..2e84e7fae725311e1239985278d29f78ee2b4671 100644
--- a/hysop/backend/device/codegen/base/variables.py
+++ b/hysop/backend/device/codegen/base/variables.py
@@ -528,11 +528,11 @@ class CodegenArray(CodegenVariable):
_svalue = [None]*s0
for d in xrange(s0):
_name = '{}_{}'.format(name, d)
- _value = value[d]
- _svalue = svalue[d]
- val, sval = CodegenArray.initialize_rec(_name, typegen,
+ dvalue = value[d]
+ dsvalue = svalue[d]
+ val, sval = CodegenArray._initialize_rec(_name, typegen,
storage, ctype, const, volatile,
- _shape, _sshape, _value, _svalue,
+ _shape, _sshape, dvalue, dsvalue,
_ptr_level, _ptr_restrict, _ptr_const, _ptr_volatile,
symbolic_mode)
var = CodegenArray(name=_name, typegen=typegen,
@@ -1031,7 +1031,7 @@ class CodegenStruct(CodegenVariable):
if __name__ == '__main__':
- from hysop.backend.device.codegen.base.test import test_typegen
+ from hysop.backend.device.codegen.base.test import _test_typegen as test_typegen
tg = test_typegen('float')
print':: ARRAYS ::'
diff --git a/hysop/backend/device/codegen/functions/directional_remesh.py b/hysop/backend/device/codegen/functions/directional_remesh.py
index b95e33c006ccc69bf72018050d288ed55ca78115..68defa89f3af24678e34b3f65f4853c580d8cf5f 100644
--- a/hysop/backend/device/codegen/functions/directional_remesh.py
+++ b/hysop/backend/device/codegen/functions/directional_remesh.py
@@ -1,61 +1,63 @@
from hysop.deps import sm, np, contextlib
from hysop.tools.types import check_instance, first_not_None
-from hysop.backend.device.opencl.opencl_types import OpenClTypeGen
+from hysop.backend.device.opencl.opencl_types import OpenClTypeGen
-from hysop.backend.device.codegen.base.opencl_codegen import OpenClCodeGenerator
+from hysop.backend.device.codegen.base.opencl_codegen import OpenClCodeGenerator
from hysop.backend.device.codegen.base.function_codegen import OpenClFunctionCodeGenerator
-from hysop.backend.device.codegen.base.variables import CodegenVariable, CodegenVectorClBuiltin
-from hysop.backend.device.codegen.base.utils import WriteOnceDict, ArgDict
-from hysop.backend.device.codegen.base.statistics import WorkStatistics
+from hysop.backend.device.codegen.base.variables import CodegenVariable, CodegenVectorClBuiltin
+from hysop.backend.device.codegen.base.utils import WriteOnceDict, ArgDict
+from hysop.backend.device.codegen.base.statistics import WorkStatistics
from hysop.backend.device.codegen.functions.polynomial import PolynomialFunction
from hysop.backend.device.codegen.functions.custom_atomics import CustomAtomicFunction
from hysop.constants import BoundaryCondition
from hysop.numerics.remesh.remesh import RemeshKernel
+from hysop.numerics.remesh.kernel_generator import Kernel
from hysop.numerics.stencil.stencil_generator import StencilGenerator
+
class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
def __init__(self, typegen, work_dim, itype, ftype,
- nparticles, nscalars,
- sboundary, remesh_kernel,
- use_atomics, remesh_criteria_eps,
- use_short_circuit=None,
- known_args=None,
- debug_mode=False):
-
- check_instance(sboundary,tuple,values=BoundaryCondition)
- check_instance(remesh_kernel, RemeshKernel)
+ nparticles, nscalars,
+ sboundary, remesh_kernel,
+ use_atomics, remesh_criteria_eps,
+ use_short_circuit=None,
+ known_args=None,
+ debug_mode=False):
+
+ check_instance(sboundary, tuple, values=BoundaryCondition)
+ check_instance(remesh_kernel, (RemeshKernel, Kernel))
assert remesh_kernel.n % 2 == 0 or remesh_kernel.n == 1
assert remesh_kernel.n > 0
use_short_circuit = first_not_None(use_short_circuit, typegen.use_short_circuit_ops)
- is_periodic = (sboundary[0]==BoundaryCondition.PERIODIC) and \
- (sboundary[1]==BoundaryCondition.PERIODIC)
+ is_periodic = (sboundary[0] == BoundaryCondition.PERIODIC) and \
+ (sboundary[1] == BoundaryCondition.PERIODIC)
ivtype = typegen.vtype(itype, nparticles)
fvtype = typegen.vtype(ftype, nparticles)
reqs = self.build_requirements(typegen, work_dim, itype, ftype,
- ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
- use_atomics, remesh_criteria_eps)
+ ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
+ use_atomics, remesh_criteria_eps)
- (args,basename) = self.build_prototype(reqs, typegen, work_dim, itype, ftype,
- ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
- use_atomics, remesh_criteria_eps, is_periodic)
+ (args, basename) = self.build_prototype(reqs, typegen, work_dim, itype, ftype,
+ ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
+ use_atomics, remesh_criteria_eps, is_periodic)
- super(DirectionalRemeshFunction,self).__init__(basename=basename,
- output=None, typegen=typegen, inline=True,
- args=args, known_args=known_args)
+ super(DirectionalRemeshFunction, self).__init__(basename=basename,
+ output=None, typegen=typegen, inline=True,
+ args=args, known_args=known_args)
self.update_requirements(reqs)
self.work_dim = work_dim
- self.itype = itype
- self.ftype = ftype
+ self.itype = itype
+ self.ftype = ftype
self.ivtype = ivtype
self.fvtype = fvtype
@@ -74,71 +76,70 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
@staticmethod
def _printv(ncomponents):
- assert ncomponents in [1,2,4,8,16]
- if ncomponents==1:
+ assert ncomponents in [1, 2, 4, 8, 16]
+ if ncomponents == 1:
return ''
else:
return 'v{}'.format(ncomponents)
-
def build_prototype(self, reqs, typegen, work_dim, itype, ftype,
- ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
- use_atomics, remesh_criteria_eps, is_periodic):
+ ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
+ use_atomics, remesh_criteria_eps, is_periodic):
args = ArgDict()
- atomic = 'atomic_' if use_atomics else ''
- criteria = '{}eps__'.format(remesh_criteria_eps) if (remesh_criteria_eps is not None) else 'full'
+ atomic = 'atomic_' if use_atomics else ''
+ criteria = '{}eps__'.format(remesh_criteria_eps) if (
+ remesh_criteria_eps is not None) else 'full'
- basename = '__{}remesh_{}d__lambda_{}_{}__{}__{}p__{}s__{}'.format(
- atomic, work_dim,
- remesh_kernel.n, remesh_kernel.r, ftype,
- nparticles, nscalars,
- criteria)
+ basename = '__{}remesh_{}d__lambda_{}_{}__{}__{}p__{}s__{}'.format(
+ atomic, work_dim,
+ remesh_kernel.n, remesh_kernel.r, ftype,
+ nparticles, nscalars,
+ criteria)
args['p'] = CodegenVectorClBuiltin(name='p', btype=ftype, dim=nparticles, typegen=typegen,
- add_impl_const=True, nl=True)
+ add_impl_const=True, nl=True)
scalars = []
for i in xrange(nscalars):
Si = CodegenVectorClBuiltin(name='s{}'.format(i), btype=ftype, dim=nparticles, typegen=typegen,
- add_impl_const=True, nl=(i==nscalars-1))
+ add_impl_const=True, nl=(i == nscalars-1))
scalars.append(Si)
args[Si.name] = Si
args['dx'] = CodegenVariable(name='dx', ctype=ftype, typegen=typegen,
- add_impl_const=True)
+ add_impl_const=True)
args['inv_dx'] = CodegenVariable(name='inv_dx', ctype=ftype, typegen=typegen,
- add_impl_const=True, nl=True)
+ add_impl_const=True, nl=True)
if is_periodic:
args['grid_size'] = CodegenVariable(name='grid_size', ctype=itype, typegen=typegen,
- add_impl_const=True)
+ add_impl_const=True)
args['line_offset'] = CodegenVariable(name='line_offset', ctype=itype, typegen=typegen,
- add_impl_const=True)
+ add_impl_const=True)
+ args['cache_width'] = CodegenVariable('cache_width', ctype=itype, typegen=typegen)
args['cache_ghosts'] = CodegenVariable(name='cache_ghosts', ctype=itype, typegen=typegen,
- add_impl_const=True)
+ add_impl_const=True)
args['active'] = CodegenVariable(name='active', ctype='bool', typegen=typegen,
- add_impl_const=True, nl=True)
-
+ add_impl_const=True, nl=True)
cached_scalars = []
for i in xrange(nscalars):
Si = CodegenVariable(name='S{}'.format(i), ctype=ftype, typegen=typegen,
- ptr_restrict=True, ptr=True, storage=self._local,
- ptr_const=False, add_impl_const=True, nl=True)
+ ptr_restrict=True, ptr=True, storage=self._local,
+ ptr_const=False, add_impl_const=True, nl=True)
cached_scalars.append(Si)
args[Si.name] = Si
self.scalars = scalars
self.cached_scalars = cached_scalars
- return (args,basename)
-
+ return (args, basename)
def build_requirements(self, typegen, work_dim, itype, ftype,
- ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
- use_atomics, remesh_criteria_eps):
+ ivtype, fvtype, nparticles, nscalars, sboundary, remesh_kernel,
+ use_atomics, remesh_criteria_eps):
reqs = WriteOnceDict()
@@ -146,24 +147,24 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
kernel = remesh_kernel
if kernel.poly_splitted:
self.poly_splitted = True
- name='lambda_{}_{}__{}'.format(kernel.n, kernel.r, '{}_{}')
+ name = 'lambda_{}_{}__{}'.format(kernel.n, kernel.r, '{}_{}')
for i, _ in enumerate(kernel.Pt_l):
- ilname = name.format(i,'left')
- irname = name.format(i,'right')
+ ilname = name.format(i, 'left')
+ irname = name.format(i, 'right')
Pil = PolynomialFunction(typegen, ftype, nparticles,
- kernel.Cl[:,i], ilname, use_fma=True, var='y')
+ kernel.Cl[:, i], ilname, use_fma=True, var='y')
Pir = PolynomialFunction(typegen, ftype, nparticles,
- kernel.Cr[:,i], irname, use_fma=True, var='y')
- P.append((Pil,Pir))
+ kernel.Cr[:, i], irname, use_fma=True, var='y')
+ P.append((Pil, Pir))
reqs[ilname] = Pil
reqs[irname] = Pir
else:
self.poly_splitted = False
- name='lambda_{}_{}__{}'.format(kernel.n, kernel.r, '{}')
+ name = 'lambda_{}_{}__{}'.format(kernel.n, kernel.r, '{}')
for i, _ in enumerate(kernel.Pt):
iname = name.format(i)
Pi = PolynomialFunction(typegen, ftype, nparticles,
- kernel.C[:,i], iname, use_fma=True, var='y')
+ kernel.C[:, i], iname, use_fma=True, var='y')
P.append((Pi,))
reqs[iname] = Pi
self.polynomials = P
@@ -189,9 +190,9 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
ivtype = s.ivtype
fvtype = s.fvtype
- nparticles = s.nparticles
- nscalars = s.nscalars
- sboundary = s.sboundary
+ nparticles = s.nparticles
+ nscalars = s.nscalars
+ sboundary = s.sboundary
use_atomics = s.use_atomics
use_short_circuit = s.use_short_circuit
remesh_criteria_eps = s.remesh_criteria_eps
@@ -210,18 +211,18 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
active = s.vars['active']
line_offset = s.vars['line_offset']
cache_ghosts = s.vars['cache_ghosts']
+ cache_width = s.vars['cache_width']
poly_splitted = s.poly_splitted
- printf_no_vector=True
- if printf_no_vector:
- vnf = '[{}]'.format(', '.join('%2.2f' for _ in xrange(nparticles)))
- vni = '[{}]'.format(', '.join('%i' for _ in xrange(nparticles)))
- expand_printf_vector = lambda x: ','.join(x[i] for i in xrange(nparticles))
- else:
- vnf = '[%2.2{}f]'.format(self._printv(nparticles))
- vni = '[%{}i]'.format(self._printv(nparticles))
- expand_printf_vector = lambda x: str(x)
+ lb = '[' if (nparticles > 1) else ''
+ rb = ']' if (nparticles > 1) else ''
+ vnf = '{}{}{}'.format(lb, ', '.join('%2.2f' for _ in xrange(nparticles)), rb)
+ vni = '{}{}{}'.format(lb, ', '.join('%i' for _ in xrange(nparticles)), rb)
+
+ def expand_printf_vector(x): return str(x) if (nparticles == 1) else ','.join(
+ '({}).s{}'.format(x, '0123456789abcdef'[i])
+ if isinstance(x, str) else x[i] for i in xrange(nparticles))
epv = expand_printf_vector
@contextlib.contextmanager
@@ -234,25 +235,27 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
dtype = tg.np_dtype(ftype)
- P = CodegenVariable(name='P', ctype=itype, typegen=tg,
- const=True, value=1+(self.kernel.n/2))
+ P = CodegenVariable(name='P', ctype=itype, typegen=tg,
+ const=True, value=1+(self.kernel.n/2))
eps = CodegenVariable(name='eps', ctype=ftype, typegen=tg,
- const=True, value=np.finfo(dtype).eps)
+ const=True, value=np.finfo(dtype).eps)
- rp = CodegenVectorClBuiltin(name='rp', btype=ftype, dim=nparticles, typegen=tg)
- y = CodegenVectorClBuiltin(name='y', btype=ftype, dim=nparticles, typegen=tg)
- ind = CodegenVectorClBuiltin(name='ind', btype=itype, dim=nparticles, typegen=tg)
+ rp = CodegenVectorClBuiltin(name='rp', btype=ftype, dim=nparticles, typegen=tg)
+ y = CodegenVectorClBuiltin(name='y', btype=ftype, dim=nparticles, typegen=tg)
+ ind = CodegenVectorClBuiltin(name='ind', btype=itype, dim=nparticles, typegen=tg)
find = CodegenVectorClBuiltin(name='find', btype=ftype, dim=nparticles, typegen=tg)
- vone = CodegenVectorClBuiltin(name='one', btype=ftype, dim=nparticles, typegen=tg, value=(1,)*nparticles)
+ vone = CodegenVectorClBuiltin(name='one', btype=ftype,
+ dim=nparticles, typegen=tg, value=(1,)*nparticles)
- tst0 = CodegenVectorClBuiltin(name='tst0', btype=ftype, dim=nparticles, typegen=tg)
- tst1 = CodegenVectorClBuiltin(name='tst1', btype=ftype, dim=nparticles, typegen=tg)
+ if debug_mode:
+ tst0 = CodegenVectorClBuiltin(name='tst0', btype=ftype, dim=nparticles, typegen=tg)
+ tst1 = CodegenVectorClBuiltin(name='tst1', btype=ftype, dim=nparticles, typegen=tg)
if poly_splitted:
wl = CodegenVectorClBuiltin(name='Wl', btype=ftype, dim=nparticles, typegen=tg)
wr = CodegenVectorClBuiltin(name='Wr', btype=ftype, dim=nparticles, typegen=tg)
w = CodegenVectorClBuiltin(name='W', btype=ftype, dim=nparticles, typegen=tg)
- weights = (wl,wr,w)
+ weights = (wl, wr, w)
else:
w = CodegenVectorClBuiltin(name='W', btype=ftype, dim=nparticles, typegen=tg)
weights = (w,)
@@ -263,7 +266,8 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
eps.declare(s)
s.jumpline()
- #s.decl_aligned_vars(tst0, tst1)
+ if debug_mode:
+ s.decl_aligned_vars(tst0, tst1)
s.decl_aligned_vars(rp, find, ind, y)
vone.declare(s, const=True)
s.decl_vars(*weights)
@@ -273,107 +277,123 @@ class DirectionalRemeshFunction(OpenClFunctionCodeGenerator):
s.append('{} = {}*{};'.format(rp, pos, inv_dx))
s.append('{} = fract({}, &{});'.format(y, rp, find))
s.append('{} = convert_{}_rtn({});'.format(ind, ivtype, find))
- #s.append('{} = floor({rp});'.format(tst0, rp=rp))
- #s.append('{} = {rp} - floor({rp});'.format(tst1, rp=rp))
if debug_mode:
+ s.append('{} = floor({rp});'.format(tst0, rp=rp))
+ s.append('{} = {rp} - floor({rp});'.format(tst1, rp=rp))
with self._ordered_wi_execution_(barrier=False):
- code = 'printf("%lu p={vnf}, rp={vnf}, floor(rp)={vnf}, rp-floor(rp)={vnf}, ind={vni}, y={vnf}, s0={vnf}, a=%f, b=%f, c=%f.\\n", {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {});'.format(
- 'get_local_id(0)', epv(pos), epv(rp), epv(tst0), epv(tst1), epv(ind), epv(y), epv(scalars[0]), 'floor(4.5f)', 'floor((float2)(1.5f,2.54f)).x', 'floor((float2)(1.5f,2.54f)).y',
- vnf=vnf, vni=vni)
+ code = 'printf("%lu p={vnf}, rp={vnf}, floor(rp)={vnf}, rp-floor(rp)={vnf}, ind={vni}, y={vnf}, s0={vnf}.\\n", {}, {}, {}, {}, {}, {}, {}, {});'.format(
+ 'get_local_id(0)', epv(pos), epv(rp), epv(tst0), epv(
+ tst1), epv(ind), epv(y), epv(scalars[0]),
+ vnf=vnf, vni=vni)
s.append(code)
- y.affect(s, init='{}-{}'.format(vone,y))
+ y.affect(s, init='{}-{}'.format(vone, y))
ind.affect(s, init='{} - {} - {}'.format(ind, P, line_offset))
+ if debug_mode:
+ s.barrier(_local=True)
+ if debug_mode:
+ with s._first_wi_execution_():
+ s.append('printf("SCALAR CACHE ({}): ");'.format(-1))
+ with s._for_('int ii=0; ii<cache_width; ii++'):
+ s.append('printf("%2.2f, ", S0[ii]);')
+ s.append('printf("\\n");')
for i, Pi in enumerate(self.polynomials):
s.jumpline()
with if_thread_active():
s.append('{} += 1;'.format(ind))
with s._align_() as al:
- for wj,Pij,yj in zip(weights, Pi, (y,'1-{}'.format(y))):
+ for wj, Pij, yj in zip(weights, Pi, (y, '1-{}'.format(y))):
wj.affect(al, align=True, init=Pij(y=yj))
if poly_splitted:
- if nparticles>1:
+ if nparticles > 1:
w.affect(al, align=True, init='select({}, {}, ({}<{}))'.format(
- wr, wl, y, tg.dump(0.5)))
+ wr, wl, y, tg.dump(0.5)))
else:
w.affect(al, align=True, init='convert_{fvtype}({}<{})*{} + convert_{fvtype}({}>={})*{}'.format(
- y,tg.dump(0.5), wl, y, tg.dump(0.5), wr, fvtype=fvtype))
+ y, tg.dump(0.5), wl, y, tg.dump(0.5), wr, fvtype=fvtype))
for iscal, (cached_scalar, scalar) in enumerate(zip(cached_scalars, scalars)):
- if nparticles>1:
- comment='Remeshing scalar {}, {} particles at a time.'.format(iscal, nparticles)
+ if nparticles > 1:
+ comment = 'Remeshing scalar {}, {} particles at a time.'.format(
+ iscal, nparticles)
s.jumpline()
s.comment(comment)
+ criterias = []
with s._block_():
for ipart in xrange(nparticles):
- cache_idx='{}+{}'.format(cache_ghosts, ind[ipart])
- val = '{}*{}'.format(w[ipart],scalar[ipart])
- if (remesh_criteria_eps is None):
- criteria = '{}!={}'.format(scalar[ipart], tg.dump(0.0))
- else:
- criteria = 'fabs({}) > {}*eps'.format(scalar[ipart], remesh_criteria_eps)
+ cache_idx = '{}+{}'.format(cache_ghosts, ind[ipart])
+ val = '{}*{}'.format(w[ipart], scalar[ipart])
+ if (remesh_criteria_eps is not None):
+ criteria = 'fabs({}) > {}*eps'.format(val, remesh_criteria_eps)
+ criterias.append(criteria)
if use_atomics:
atomic_add = s.reqs['atomic_add']
- atom_add = atomic_add(p='{}+{}'.format(cached_scalar,cache_idx), val=val)
- if use_short_circuit:
- code = '({}) && ({},true);'.format(criteria, atom_add)
+ atom_add = atomic_add(
+ p='{}+{}'.format(cached_scalar, cache_idx), val=val)
+ if (remesh_criteria_eps is not None):
+ if use_short_circuit:
+ code = '({}) && ({},true);'.format(criteria, atom_add)
+ else:
+ code = 'if({}) {{ {}; }}'.format(criteria, atom_add)
else:
- code = 'if({}) {{ {}; }}'.format(criteria, atom_add)
+ code = '{};'.format(atom_add)
else:
- if use_short_circuit:
- code = '({}) && (({} += {}),true);'.format(criteria, cached_scalar[cache_idx], val)
+ inplace_add = '{} += {}'.format(cached_scalar[cache_idx], val)
+ if (remesh_criteria_eps is not None):
+ if use_short_circuit:
+ code = '({}) && (({}),true);'.format(
+ criteria, inplace_add)
+ else:
+ code = 'if ({}) {{ {}; }}'.format(criteria, inplace_add)
else:
- code = 'if ({}) {{ {} += {}; }}'.format(criteria, cached_scalar[cache_idx], val)
+ code = '{};'.format(inplace_add)
s.append(code)
if debug_mode:
- val='{}*{}'.format(w,scalars[0])
- cache_idx='{}+{}'.format(cache_ghosts, ind[0])
+ val = '{}*{}'.format(w, scalars[0])
+ cache_idx = '{}+{}'.format(cache_ghosts, ind[0])
if poly_splitted:
- printf = 'printf("BATCH {}: %lu wrote {vnf} at idx={vni} with Wl={vnf}, Wr={vnf}, W={vnf}, cond={vni}.\\n",{},{},{},{},{},{},{});'.format(
- i, 'get_local_id(0)', val, ind, wl, wr, w, 'y<0.5f', vnf=vnf, vni=vni)
+ printf = 'printf("BATCH {}: %lu remeshed {vnf} at idx={vni} with Wl={vnf}, Wr={vnf}, W={vnf}, cond={vni}.\\n",{},{},{},{},{},{},{});'.format(
+ i, 'get_local_id(0)', epv(val), epv(ind), epv(wl), epv(wr), epv(w), epv('(y<0.5f)'), vnf=vnf, vni=vni)
else:
- printf = 'printf("BATCH {}: %lu wrote {vnf} at idx {vni} with W={vnf}.\\n",{},{},{},{});'.format(
- i, 'get_local_id(0)', val, ind, w, vni=vni, vnf=vnf)
- s.append(printf)
+ printf = 'printf("BATCH {}: %lu remeshed {vnf} at idx {vni} with W({vnf})={vnf}, new value is S0[{vni}]={vnf}.\\n",{},{},{},{},{},{},{});'.format(
+ i, 'get_local_id(0)', epv(val), epv(ind), epv(y), epv(w), cache_idx, epv(cached_scalars[0][cache_idx]), vni=vni, vnf=vnf)
+ with s._first_wg_execution_():
+ if criterias:
+ with s._if_(' || '.join(map(lambda x: '({})'.format(x), criterias))):
+ s.append(printf)
+ else:
+ s.append(printf)
if not use_atomics:
s.barrier(_local=True)
+ if debug_mode:
+ with s._first_wi_execution_():
+ s.append('printf("SCALAR CACHE ({}): ");'.format(i))
+ with s._for_('int ii=0; ii<cache_width; ii++'):
+ s.append('printf("%2.2f, ", S0[ii]);')
+ s.append('printf("\\n");')
if use_atomics:
s.barrier(_local=True)
- # def per_work_statistics(self):
- # dim = self.dim
- # ftype = self.ftype
- # storage = self.storage
-
- # stats = self.reqs['apply_stencil'].per_work_statistics()
- # if 'alpha' in self.known_args:
- # alpha = self.known_args['alpha']
- # else:
- # alpha = 0.5
- # stats.ops_per_type[ftype] += int(alpha!=0)*dim*3
- # stats.ops_per_type[ftype] += int(alpha!=1)*dim*2 + 2
-
- # retur
if __name__ == '__main__':
from hysop.backend.device.codegen.base.test import _test_typegen
from hysop.numerics.remesh.remesh import RemeshKernel
tg = _test_typegen('float')
- kernel = RemeshKernel(2, 2, split_polys=True)
+ kernel = RemeshKernel(2, 2, split_polys=False)
work_dim = 3
nparticles = 2
- nscalars = 2
+ nscalars = 1
- use_atomics = True
+ use_atomics = False
remesh_criteria_eps = None
drf = DirectionalRemeshFunction(tg, work_dim, 'int', tg.fbtype,
- nparticles, nscalars,
- (BoundaryCondition.PERIODIC,BoundaryCondition.PERIODIC),
- kernel, use_atomics, remesh_criteria_eps)
+ nparticles, nscalars,
+ (BoundaryCondition.PERIODIC, BoundaryCondition.PERIODIC),
+ kernel, use_atomics, remesh_criteria_eps, debug_mode=False)
drf.edit()
diff --git a/hysop/backend/device/codegen/functions/polynomial.py b/hysop/backend/device/codegen/functions/polynomial.py
index 1cb592148fae61c55e39231cf09c09c0d7f020c8..78b1a689dfde82d4662f01d1723f37e99a781c32 100644
--- a/hysop/backend/device/codegen/functions/polynomial.py
+++ b/hysop/backend/device/codegen/functions/polynomial.py
@@ -95,7 +95,7 @@ if __name__ == '__main__':
tg = _test_typegen('float')
pf = PolynomialFunction(tg,'float',4,
- [0,1,2,3,4,0,0,0,5,6,7,8,9,0], 'test_poly', True)
+ [0,1,2,3,4,0,0,0,5,6,7,8,9,0], 'test_poly', 'x', True)
pf.edit()
print pf.per_work_statistics()
diff --git a/hysop/backend/device/codegen/kernels/bandwidth.py b/hysop/backend/device/codegen/kernels/bandwidth.py
index 84df0d7f7cf682dd4418e54cec4836f7d5b67d7d..afbcd00ead28987401620ae21e3de4c7d5e90a61 100644
--- a/hysop/backend/device/codegen/kernels/bandwidth.py
+++ b/hysop/backend/device/codegen/kernels/bandwidth.py
@@ -1,5 +1,5 @@
-import contextlib
+import contextlib, random
from contextlib import contextmanager
import operator, hashlib
@@ -18,7 +18,8 @@ from hysop.backend.device.codegen.base.utils import WriteOnceDict, ArgD
from hysop.backend.device.opencl import cl, clCharacterize
from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
from hysop.backend.device.opencl.opencl_kernel import OpenClKernelLauncher
-from hysop.backend.device.kernel_autotuner import KernelAutotuner, AutotunerConfig
+from hysop.backend.device.kernel_autotuner import KernelAutotuner
+from hysop.backend.device.kernel_autotuner_config import KernelAutotunerConfig
class BandwidthKernel(KernelCodeGenerator):
@@ -52,9 +53,9 @@ class BandwidthKernel(KernelCodeGenerator):
def gen_kernel_arguments(self, typegen, vtype):
kargs = ArgDict()
kargs['dst'] = CodegenVariable(ctype=vtype,name='dst',ptr=True,typegen=typegen,
- nl=True,restrict=True,storage='__global')
+ nl=True,ptr_restrict=True,ptr_volatile=True, storage='__global')
kargs['src'] = CodegenVariable(ctype=vtype,name='src',ptr=True,typegen=typegen,
- nl=True,restrict=True,storage='__global',const=True)
+ nl=True,ptr_restrict=True,ptr_volatile=True,storage='__global',const=True)
return kargs
def gencode(self):
@@ -73,30 +74,24 @@ class BandwidthKernel(KernelCodeGenerator):
global_size.declare(s,const=True)
global_id.declare(s,const=True)
s.jumpline()
+
buf.declare(s)
- s.jumpline()
-
- if global_size.known():
- s.pragma('unroll')
- with s._for_('int {i}=0; {i}<{N}; {i}++'.format(i='i',N=self.nreads)):
- offset = '{}+i*{}'.format(global_id(),global_size())
- code = '{} += {};'.format(buf(), src[offset])
+ for i in range(self.nreads):
+ offset = '{}+{}uL*{}'.format(global_id(),i, global_size())
+ code = '{} {}= {};'.format(buf(), '+*-/'[i%4], src[offset])
s.append(code)
- s.jumpline()
-
- if global_size.known():
- s.pragma('unroll')
- with s._for_('int {i}=0; {i}<{N}; {i}++'.format(i='i',N=self.nwrites)):
- offset = '{}+i*{}'.format(global_id(),global_size())
- code = '{} = {};'.format(dst[offset], buf())
+ for i in range(self.nwrites):
+ offset = '{}+{}uL*{}'.format(global_id(),i,global_size())
+ code = '{} = {}+{};'.format(dst[offset], buf(), i)
s.append(code)
if __name__ == '__main__':
- from hysop.backend.device.codegen.base.test import test_typegen
+ from hysop.backend.device.codegen.base.test import _test_typegen
- tg = test_typegen('float')
- vtype = 'float'
+ tg = _test_typegen('float')
+ vtype = 'float4'
- ck = BandwidthKernel(tg, vtype, nreads=99, nwrites=1, known_vars={'global_size':1024})
+ ck = BandwidthKernel(tg, vtype, nreads=10, nwrites=1,
+ known_vars={'global_size':1024, 'local_size': 512})
ck.edit()
diff --git a/hysop/backend/device/codegen/kernels/custom_symbolic.py b/hysop/backend/device/codegen/kernels/custom_symbolic.py
index 61a916cdb1f1013ee5b7504b8d327fb9b7a62795..54954ac0e26005e2000179202604bbf798764925 100644
--- a/hysop/backend/device/codegen/kernels/custom_symbolic.py
+++ b/hysop/backend/device/codegen/kernels/custom_symbolic.py
@@ -21,7 +21,7 @@ from hysop.fields.continuous_field import Field
from hysop.fields.discrete_field import DiscreteScalarFieldView
from hysop.symbolic import space_symbols as symbolic_space_symbols
from hysop.symbolic import local_indices_symbols as symbolic_local_indices
-from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer
+from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer
from hysop.backend.device.opencl import cl, clTools, clCharacterize
from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
@@ -561,7 +561,7 @@ class CustomSymbolicKernelGenerator(KernelCodeGenerator):
args[i] = arg
strides[i] = stride
elif isinstance(obj, di.SimpleCounterTypes):
- assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer)), type(obj)
+ assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)), type(obj)
assert counts>0
if (obj in di.write_counter) and (di.write_counter[obj]>0):
continue
@@ -572,7 +572,7 @@ class CustomSymbolicKernelGenerator(KernelCodeGenerator):
storage=self._global, ctype=obj.ctype,
typegen=typegen, mesh_dim=csc.varray_dim,
ptr_restrict=True, const=True, volatile=volatile)
- if isinstance(obj, OpenClSymbolicBuffer):
+ if isinstance(obj, (OpenClSymbolicBuffer,OpenClSymbolicNdBuffer)):
csc.buffer_args[obj] = arg
else:
array_args[obj] = {0: arg}
@@ -613,7 +613,7 @@ class CustomSymbolicKernelGenerator(KernelCodeGenerator):
args[i] = arg
strides[i] = arg_strides
elif isinstance(obj, di.SimpleCounterTypes):
- assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer)), type(obj)
+ assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)), type(obj)
assert counts>0
vname = obj.varname
volatile = (vname in ei.is_volatile)
@@ -622,7 +622,7 @@ class CustomSymbolicKernelGenerator(KernelCodeGenerator):
storage=self._global, ctype=obj.ctype,
typegen=typegen, mesh_dim=csc.varray_dim,
ptr_restrict=True, const=False, volatile=volatile)
- if isinstance(obj, OpenClSymbolicBuffer):
+ if isinstance(obj, (OpenClSymbolicBuffer,OpenClSymbolicNdBuffer)):
csc.buffer_args[obj] = arg
else:
array_args[obj] = {0:arg}
@@ -1192,18 +1192,18 @@ class CustomSymbolicKernelGenerator(KernelCodeGenerator):
local_work))
self.jumpline()
- self.jumpline()
- self.comment('Compute global offsets and line pointers')
- with self._align_() as al:
- for array, vid in array_vids.iteritems():
- gids = array_gids[array]
- strides = array_strides[array]
- for (key, gid) in gids.iteritems():
- stride = strides[key]
- idot = ' $+ '.join('{}*{}'.format(vid[i], stride[i])
- for i in xrange(array_dim-1, -1, -1))
- gid.declare(al, init=idot, align=True)
- self.jumpline()
+ if self.array_vids:
+ self.comment('Compute global offsets and line pointers')
+ with self._align_() as al:
+ for array, vid in array_vids.iteritems():
+ gids = array_gids[array]
+ strides = array_strides[array]
+ for (key, gid) in gids.iteritems():
+ stride = strides[key]
+ idot = ' $+ '.join('{}*{}'.format(vid[i], stride[i])
+ for i in xrange(array_dim-1, -1, -1))
+ gid.declare(al, init=idot, align=True)
+ self.jumpline()
self.decl_aligned_vars(*tuple(aij for ai in self.array_line_data.values()
for aij in ai.values()))
yield ctx
diff --git a/hysop/backend/device/codegen/kernels/directional_remesh.py b/hysop/backend/device/codegen/kernels/directional_remesh.py
index 3d9d953a37c3def29bc9bff7c12e289c238fa2e2..9c1a437ac945caafa4301a7d9550efc2e6b9069f 100644
--- a/hysop/backend/device/codegen/kernels/directional_remesh.py
+++ b/hysop/backend/device/codegen/kernels/directional_remesh.py
@@ -11,23 +11,24 @@ from hysop.constants import DirectionLabels, BoundaryCondition, Backend, Precisi
from hysop.core.arrays.all import OpenClArray
from hysop.numerics.remesh.remesh import RemeshKernel
+from hysop.numerics.remesh.kernel_generator import Kernel
from hysop.fields.continuous_field import Field
from hysop.fields.discrete_field import DiscreteScalarFieldView
-from hysop.backend.device.opencl import cl, clTools, clCharacterize
-from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
-from hysop.backend.device.opencl.opencl_types import OpenClTypeGen
+from hysop.backend.device.opencl import cl, clTools, clCharacterize
+from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
+from hysop.backend.device.opencl.opencl_types import OpenClTypeGen
from hysop.backend.device.opencl.opencl_array_backend import OpenClArrayBackend
-from hysop.backend.device.codegen import CodeGeneratorWarning
-from hysop.backend.device.codegen.base.utils import WriteOnceDict, ArgDict
-from hysop.backend.device.codegen.base.statistics import WorkStatistics
-from hysop.backend.device.codegen.base.variables import CodegenStruct
-from hysop.backend.device.codegen.structs.mesh_info import MeshBaseStruct, MeshInfoStruct
+from hysop.backend.device.codegen import CodeGeneratorWarning
+from hysop.backend.device.codegen.base.utils import WriteOnceDict, ArgDict
+from hysop.backend.device.codegen.base.statistics import WorkStatistics
+from hysop.backend.device.codegen.base.variables import CodegenStruct
+from hysop.backend.device.codegen.structs.mesh_info import MeshBaseStruct, MeshInfoStruct
from hysop.backend.device.codegen.base.opencl_codegen import OpenClCodeGenerator
from hysop.backend.device.codegen.base.kernel_codegen import KernelCodeGenerator
-from hysop.backend.device.codegen.base.variables import CodegenVariable, \
- CodegenVectorClBuiltin, CodegenArray
+from hysop.backend.device.codegen.base.variables import CodegenVariable, \
+ CodegenVectorClBuiltin, CodegenArray
from hysop.backend.device.codegen.functions.directional_remesh import DirectionalRemeshFunction
@@ -36,23 +37,24 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
@staticmethod
def codegen_name(work_dim,
- remesh_kernel, ftype,
- nparticles, nscalars,
- remesh_criteria_eps,
- use_atomics, is_inplace):
+ remesh_kernel, ftype,
+ nparticles, nscalars,
+ remesh_criteria_eps,
+ use_atomics, is_inplace):
inplace = 'inplace_' if is_inplace else ''
- atomic = 'atomic_' if use_atomics else ''
- criteria = '{}eps__'.format(remesh_criteria_eps) if (remesh_criteria_eps is not None) else 'full'
+ atomic = 'atomic_' if use_atomics else ''
+ criteria = '{}eps__'.format(remesh_criteria_eps) if (
+ remesh_criteria_eps is not None) else 'full'
return 'directional_{}{}remesh_{}d__lambda_{}_{}__{}__{}p__{}s__{}'.format(
- inplace, atomic, work_dim,
- remesh_kernel.n, remesh_kernel.r, ftype,
- nparticles, nscalars,
- criteria)
+ inplace, atomic, work_dim,
+ remesh_kernel.n, remesh_kernel.r, ftype,
+ nparticles, nscalars,
+ criteria)
@classmethod
def scalars_out_cache_ghosts(cls, scalar_cfl, remesh_kernel):
assert scalar_cfl > 0.0, 'cfl <= 0.0'
- assert remesh_kernel.n >= 1 , 'Bad remeshing kernel.'
+ assert remesh_kernel.n >= 1, 'Bad remeshing kernel.'
if remesh_kernel.n > 1:
assert remesh_kernel.n % 2 == 0, 'Odd remeshing kernel moments.'
min_ghosts = int(1+npw.floor(scalar_cfl)+remesh_kernel.n/2)
@@ -79,21 +81,21 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
Return global_work_size from effective work_size and given local_work_size
global_work_size will be a multiple of local_work_size
"""
- work_dim = self.work_dim
- work_load = [1]*work_dim if (work_load is None) else work_load
+ work_dim = self.work_dim
+ work_load = [1]*work_dim if (work_load is None) else work_load
- work_size = np.asarray(work_size)
- work_load = np.asarray(work_load)
+ work_size = np.asarray(work_size)
+ work_load = np.asarray(work_load)
local_work_size = np.asarray(local_work_size)
nparticles = self.nparticles
- for i in xrange(1,work_dim):
+ for i in xrange(1, work_dim):
assert (local_work_size[i] == 1), 'local_work_size error!'
if 'local_size' in self.known_vars:
assert (self.known_vars['local_size'] == local_work_size[:work_dim]).all(),\
- 'local_work_size mismatch!'
+ 'local_work_size mismatch!'
max_global_size = self.get_max_global_size(work_size, work_load, nparticles)
global_size = ((max_global_size+local_work_size-1)/local_work_size) * local_work_size
@@ -105,13 +107,13 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
"""
Return a tuple of required (static,dynamic,total) cache bytes per workgroup
"""
- work_dim = self.work_dim
- ftype = self.ftype
- flt_bytes = self.typegen.FLT_BYTES[ftype]
+ work_dim = self.work_dim
+ ftype = self.ftype
+ flt_bytes = self.typegen.FLT_BYTES[ftype]
local_work_size = np.asarray(local_work_size)
- sc,dc = 0,0
+ sc, dc = 0, 0
count = self.nscalars*(self.nparticles*local_work_size[0]+2*self.min_ghosts)
if self.local_size_known:
assert (self.known_vars['local_size'] == local_work_size[:work_dim]).all()
@@ -123,27 +125,26 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
dc *= flt_bytes
tc = sc+dc
- return (sc,dc,tc)
-
+ return (sc, dc, tc)
def __init__(self, typegen, work_dim, ftype,
- nparticles, nscalars, sboundary, is_inplace,
- scalar_cfl, remesh_kernel,
- use_short_circuit=None,
- unroll_loops=None,
- group_scalars=None,
- remesh_criteria_eps=None,
- use_atomics = False,
- symbolic_mode = False,
- debug_mode = False,
- tuning_mode = False,
- known_vars = None):
-
- assert work_dim>0 and work_dim<=3
- assert nscalars>0
- assert nparticles in [1,2,4,8,16]
- check_instance(sboundary,tuple,values=BoundaryCondition)
- check_instance(remesh_kernel, RemeshKernel)
+ nparticles, nscalars, sboundary, is_inplace,
+ scalar_cfl, remesh_kernel,
+ use_short_circuit=None,
+ unroll_loops=None,
+ group_scalars=None,
+ remesh_criteria_eps=None,
+ use_atomics=False,
+ symbolic_mode=False,
+ debug_mode=False,
+ tuning_mode=False,
+ known_vars=None):
+
+ assert work_dim > 0 and work_dim <= 3
+ assert nscalars > 0
+ assert nparticles in [1, 2, 4, 8, 16]
+ check_instance(sboundary, tuple, values=BoundaryCondition)
+ check_instance(remesh_kernel, (RemeshKernel, Kernel))
use_short_circuit = first_not_None(use_short_circuit, typegen.use_short_circuit_ops)
unroll_loops = first_not_None(unroll_loops, typegen.unroll_loops)
@@ -159,11 +160,11 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
assert sboundary[0] in [BoundaryCondition.PERIODIC, BoundaryCondition.NONE]
assert sboundary[1] in [BoundaryCondition.PERIODIC, BoundaryCondition.NONE]
- is_periodic = (sboundary[0]==BoundaryCondition.PERIODIC \
- and sboundary[1]==BoundaryCondition.PERIODIC)
+ is_periodic = (sboundary[0] == BoundaryCondition.PERIODIC
+ and sboundary[1] == BoundaryCondition.PERIODIC)
if is_periodic:
- msg='Local periodic boundary have been deprecated, use BoundaryCondition.NONE instead.'
+ msg = 'Local periodic boundary have been deprecated, use BoundaryCondition.NONE instead.'
raise RuntimeError(msg)
known_vars = known_vars or dict()
@@ -174,57 +175,58 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
vitype = typegen.vtype(itype, nparticles)
name = DirectionalRemeshKernelGenerator.codegen_name(work_dim,
- remesh_kernel, ftype,
- nparticles, nscalars, remesh_criteria_eps,
- use_atomics, is_inplace)
+ remesh_kernel, ftype,
+ nparticles, nscalars, remesh_criteria_eps,
+ use_atomics, is_inplace)
kernel_reqs = self.build_requirements(typegen, work_dim, itype, ftype,
- sboundary, nparticles, nscalars, nfields, group_scalars,
- symbolic_mode,
- remesh_criteria_eps, use_atomics, remesh_kernel,
- use_short_circuit, known_vars, debug_mode)
+ sboundary, nparticles, nscalars, nfields, group_scalars,
+ symbolic_mode,
+ remesh_criteria_eps, use_atomics, remesh_kernel,
+ use_short_circuit, known_vars, debug_mode)
kernel_args = self.gen_kernel_arguments(typegen, work_dim, itype, ftype,
- nparticles, nscalars, nfields, group_scalars, local_size_known, is_inplace,
- debug_mode, kernel_reqs, known_vars, symbolic_mode)
-
- super(DirectionalRemeshKernelGenerator,self).__init__(
- name=name,
- typegen=typegen,
- work_dim=work_dim,
- kernel_args=kernel_args,
- known_vars=known_vars,
- vec_type_hint=ftype,
- symbolic_mode=symbolic_mode)
+ nparticles, nscalars, nfields, group_scalars, local_size_known, is_inplace,
+ debug_mode, kernel_reqs, known_vars, symbolic_mode)
+
+ super(DirectionalRemeshKernelGenerator, self).__init__(
+ name=name,
+ typegen=typegen,
+ work_dim=work_dim,
+ kernel_args=kernel_args,
+ known_vars=known_vars,
+ vec_type_hint=ftype,
+ symbolic_mode=symbolic_mode)
self.update_requirements(kernel_reqs)
- self.min_ghosts = self.scalars_out_cache_ghosts(scalar_cfl, remesh_kernel)
- self.itype = itype
- self.ftype = ftype
- self.vitype = vitype
- self.vftype = vftype
- self.work_dim = work_dim
- self.sboundary = sboundary
- self.nparticles = nparticles
- self.nscalars = nscalars
- self.nfields = nfields
- self.group_scalars = group_scalars
+ self.min_ghosts = self.scalars_out_cache_ghosts(scalar_cfl, remesh_kernel)
+ self.itype = itype
+ self.ftype = ftype
+ self.vitype = vitype
+ self.vftype = vftype
+ self.work_dim = work_dim
+ self.sboundary = sboundary
+ self.nparticles = nparticles
+ self.nscalars = nscalars
+ self.nfields = nfields
+ self.group_scalars = group_scalars
self.local_size_known = local_size_known
- self.is_inplace = is_inplace
- self.use_atomics = use_atomics
+ self.is_inplace = is_inplace
+ self.use_atomics = use_atomics
self.use_short_circuit = use_short_circuit
- self.unroll_loops = unroll_loops
- self.remesh_kernel = remesh_kernel
- self.debug_mode = debug_mode
- self.tuning_mode = tuning_mode
+ self.unroll_loops = unroll_loops
+ self.remesh_kernel = remesh_kernel
+ self.debug_mode = debug_mode
+ self.tuning_mode = tuning_mode
self.gencode()
+ # self.edit()
def build_requirements(self, typegen, work_dim, itype, ftype,
- sboundary, nparticles, nscalars, nfields, group_scalars, symbolic_mode,
- remesh_criteria_eps, use_atomics, remesh_kernel, use_short_circuit,
- known_vars, debug_mode):
+ sboundary, nparticles, nscalars, nfields, group_scalars, symbolic_mode,
+ remesh_criteria_eps, use_atomics, remesh_kernel, use_short_circuit,
+ known_vars, debug_mode):
reqs = WriteOnceDict()
vsize = upper_pow2_or_3(work_dim)
@@ -238,49 +240,49 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
# without atomics we can only remesh on particle at a time
nparticles_remeshed = nparticles if use_atomics else 1
reqs['remesh'] = DirectionalRemeshFunction(typegen=typegen, work_dim=work_dim,
- itype=itype, ftype=ftype, nparticles=nparticles_remeshed, nscalars=nscalars,
- sboundary=sboundary, remesh_kernel=remesh_kernel, use_atomics=use_atomics,
- remesh_criteria_eps=remesh_criteria_eps, debug_mode=debug_mode,
- use_short_circuit=use_short_circuit)
+ itype=itype, ftype=ftype, nparticles=nparticles_remeshed, nscalars=nscalars,
+ sboundary=sboundary, remesh_kernel=remesh_kernel, use_atomics=use_atomics,
+ remesh_criteria_eps=remesh_criteria_eps, debug_mode=debug_mode,
+ use_short_circuit=use_short_circuit)
return reqs
def gen_kernel_arguments(self, typegen, work_dim, itype, ftype,
- nparticles, nscalars, nfields, group_scalars, local_size_known, is_inplace,
- debug_mode, kernel_reqs, known_vars, symbolic_mode):
+ nparticles, nscalars, nfields, group_scalars, local_size_known, is_inplace,
+ debug_mode, kernel_reqs, known_vars, symbolic_mode):
kargs = ArgDict()
mesh_dim = upper_pow2_or_3(work_dim)
self.position, self.position_strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='position',
- known_vars=known_vars, symbolic_mode=symbolic_mode,
- storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
- ptr_restrict=True, const=True)
+ known_vars=known_vars, symbolic_mode=symbolic_mode,
+ storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
+ ptr_restrict=True, const=True)
- scalars_data_in = []
+ scalars_data_in = []
scalars_strides_in = []
for i in xrange(nfields):
- args_in = []
+ args_in = []
strides_in = []
for j in xrange(group_scalars[i]):
if is_inplace:
- arg, strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='S{}_{}_inout'.format(i,j),
- known_vars=known_vars, symbolic_mode=symbolic_mode,
- storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
- const=False, ptr_restrict=True)
+ arg, strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='S{}_{}_inout'.format(i, j),
+ known_vars=known_vars, symbolic_mode=symbolic_mode,
+ storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
+ const=False, ptr_restrict=True)
else:
- arg, strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='S{}_{}_in'.format(i,j),
- known_vars=known_vars, symbolic_mode=symbolic_mode,
- storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
- const=True, ptr_restrict=True)
+ arg, strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='S{}_{}_in'.format(i, j),
+ known_vars=known_vars, symbolic_mode=symbolic_mode,
+ storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
+ const=True, ptr_restrict=True)
args_in.append(arg)
strides_in.append(strides)
scalars_data_in.append(tuple(args_in))
scalars_strides_in.append(tuple(strides_in))
- scalars_data_in = tuple(scalars_data_in)
+ scalars_data_in = tuple(scalars_data_in)
scalars_strides_in = tuple(scalars_strides_in)
if is_inplace:
- scalars_data_out = scalars_data_in
+ scalars_data_out = scalars_data_in
scalars_strides_out = scalars_strides_in
else:
scalars_data_out = []
@@ -289,10 +291,10 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
args_out = []
strides_out = []
for j in xrange(group_scalars[i]):
- arg, strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='S{}_{}_out'.format(i,j),
- known_vars=known_vars, symbolic_mode=symbolic_mode,
- storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
- const=False, ptr_restrict=True)
+ arg, strides = OpenClArrayBackend.build_codegen_arguments(kargs, name='S{}_{}_out'.format(i, j),
+ known_vars=known_vars, symbolic_mode=symbolic_mode,
+ storage=self._global, ctype=ftype, typegen=typegen, mesh_dim=mesh_dim,
+ const=False, ptr_restrict=True)
args_out.append(arg)
strides_out.append(strides)
scalars_data_out.append(tuple(args_out))
@@ -300,60 +302,60 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
scalars_data_out = tuple(scalars_data_out)
scalars_strides_out = tuple(scalars_strides_out)
- self.scalars_data_in = scalars_data_in
+ self.scalars_data_in = scalars_data_in
self.scalars_data_out = scalars_data_out
self.scalars_strides_in = scalars_strides_in
self.scalars_strides_out = scalars_strides_out
- if debug_mode:
- kargs['dbg0'] = CodegenVariable(storage=self._global,name='dbg0',ctype=itype,
- typegen=typegen, ptr_restrict=True,ptr=True,const=False,add_impl_const=True)
- kargs['dbg1'] = CodegenVariable(storage=self._global,name='dbg1',ctype=itype,
- typegen=typegen, ptr_restrict=True,ptr=True,const=False,add_impl_const=True)
+ # if debug_mode:
+ # kargs['dbg0'] = CodegenVariable(storage=self._global,name='dbg0',ctype=itype,
+ # typegen=typegen, ptr_restrict=True,ptr=True,const=False,add_impl_const=True)
+ # kargs['dbg1'] = CodegenVariable(storage=self._global,name='dbg1',ctype=itype,
+ # typegen=typegen, ptr_restrict=True,ptr=True,const=False,add_impl_const=True)
kargs['position_mesh_info'] = kernel_reqs['MeshInfoStruct'].build_codegen_variable(
- const=True, name='position_mesh_info')
+ const=True, name='position_mesh_info')
if is_inplace:
for i in xrange(nfields):
kargs['S{}_inout_mesh_info'.format(i)] = \
- kernel_reqs['MeshInfoStruct'].build_codegen_variable(
- const=True, name='S{}_inout_mesh_info'.format(i), nl=True)
+ kernel_reqs['MeshInfoStruct'].build_codegen_variable(
+ const=True, name='S{}_inout_mesh_info'.format(i), nl=True)
else:
for i in xrange(nfields):
kargs['S{}_in_mesh_info'.format(i)] = \
- kernel_reqs['MeshInfoStruct'].build_codegen_variable(
- const=True, name='S{}_in_mesh_info'.format(i), nl=True)
+ kernel_reqs['MeshInfoStruct'].build_codegen_variable(
+ const=True, name='S{}_in_mesh_info'.format(i), nl=True)
for i in xrange(nfields):
kargs['S{}_out_mesh_info'.format(i)] = \
- kernel_reqs['MeshInfoStruct'].build_codegen_variable(
- const=True, name='S{}_out_mesh_info'.format(i), nl=True)
+ kernel_reqs['MeshInfoStruct'].build_codegen_variable(
+ const=True, name='S{}_out_mesh_info'.format(i), nl=True)
if not local_size_known:
- kargs['buffer'] = CodegenVariable(storage=self._local, ctype=ftype,
- add_impl_const=True, name='buffer', ptr=True, ptr_restrict=True,
- typegen=typegen, nl=False)
+ kargs['buffer'] = CodegenVariable(storage=self._local, ctype=ftype,
+ add_impl_const=True, name='buffer', ptr=True, ptr_restrict=True,
+ typegen=typegen, nl=False)
return kargs
def gencode(self):
- s = self
+ s = self
tg = s.typegen
- dim = s.work_dim
- itype = s.itype
- ftype = s.ftype
- vitype = s.vitype
- vftype = s.vftype
- sboundary = s.sboundary
- nparticles = s.nparticles
- nscalars = s.nscalars
- nfields = s.nfields
- min_ghosts = s.min_ghosts
- is_inplace = s.is_inplace
+ dim = s.work_dim
+ itype = s.itype
+ ftype = s.ftype
+ vitype = s.vitype
+ vftype = s.vftype
+ sboundary = s.sboundary
+ nparticles = s.nparticles
+ nscalars = s.nscalars
+ nfields = s.nfields
+ min_ghosts = s.min_ghosts
+ is_inplace = s.is_inplace
use_atomics = s.use_atomics
- work_dim = s.work_dim
- debug_mode = s.debug_mode
+ work_dim = s.work_dim
+ debug_mode = s.debug_mode
tuning_mode = s.tuning_mode
use_short_circuit = s.use_short_circuit
@@ -364,121 +366,128 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
local_size_known = s.local_size_known
- global_id = s.vars['global_id']
- local_id = s.vars['local_id']
- group_id = s.vars['group_id']
+ global_id = s.vars['global_id']
+ local_id = s.vars['local_id']
+ group_id = s.vars['group_id']
+
+ global_index = s.vars['global_index']
+ local_index = s.vars['local_index']
- global_index = s.vars['global_index']
- local_index = s.vars['local_index']
+ global_size = s.vars['global_size']
+ local_size = s.vars['local_size']
- global_size = s.vars['global_size']
- local_size = s.vars['local_size']
+ # if debug_mode:
+ #dbg0 = s.vars['dbg0']
+ #dbg1 = s.vars['dbg1']
- if debug_mode:
- dbg0 = s.vars['dbg0']
- dbg1 = s.vars['dbg1']
+ lb = '[' if (nparticles > 1) else ''
+ rb = ']' if (nparticles > 1) else ''
+ vnf = '{}{}{}'.format(lb, ', '.join('%2.2f' for _ in xrange(nparticles)), rb)
+ vni = '{}{}{}'.format(lb, ', '.join('%i' for _ in xrange(nparticles)), rb)
- vnf = '[%2.2{}f]'.format(self._printv(nparticles))
- vni = '[%{}d]'.format(self._printv(nparticles))
+ def expand_printf_vector(x): return str(x) if (nparticles == 1) else ','.join(
+ '({}).s{}'.format(x, '0123456789abcdef'[i])
+ if isinstance(x, str) else x[i] for i in xrange(nparticles))
+ epv = expand_printf_vector
position_mesh_info = s.vars['position_mesh_info']
if is_inplace:
- scalars_mesh_info_in = [s.vars['S{}_inout_mesh_info'.format(i)] for i in xrange(nfields)]
+ scalars_mesh_info_in = [
+ s.vars['S{}_inout_mesh_info'.format(i)] for i in xrange(nfields)]
scalars_mesh_info_out = scalars_mesh_info_in
else:
- scalars_mesh_info_in = [s.vars['S{}_in_mesh_info'.format(i)] for i in xrange(nfields)]
- scalars_mesh_info_out = [s.vars['S{}_out_mesh_info'.format(i)] for i in xrange(nfields)]
+ scalars_mesh_info_in = [s.vars['S{}_in_mesh_info'.format(i)] for i in xrange(nfields)]
+ scalars_mesh_info_out = [s.vars['S{}_out_mesh_info'.format(i)] for i in xrange(nfields)]
- position_base = s.vars['position_base']
- position_offset = s.vars['position_offset']
+ position_base = s.vars['position_base']
+ position_offset = s.vars['position_offset']
position_strides = s.vars['position_strides']
position = s.position
- scalars_data_in = s.scalars_data_in
+ scalars_data_in = s.scalars_data_in
scalars_data_out = s.scalars_data_out
- scalars_strides_in = s.scalars_strides_in
+ scalars_strides_in = s.scalars_strides_in
scalars_strides_out = s.scalars_strides_out
- compute_grid_size = position_mesh_info['local_mesh']['compute_resolution'].view(
- 'compute_grid_size',slice(None,work_dim),const=True)
+ compute_grid_size = position_mesh_info['local_mesh']['compute_resolution'].view(
+ 'compute_grid_size', slice(None, work_dim), const=True)
position_grid_size = position_mesh_info['local_mesh']['resolution'].view(
- 'pos_grid_size', slice(0,work_dim), const=True)
+ 'pos_grid_size', slice(0, work_dim), const=True)
position_grid_ghosts = position_mesh_info['ghosts'].view(
- 'pos_grid_ghosts', slice(0,work_dim), const=True)
+ 'pos_grid_ghosts', slice(0, work_dim), const=True)
position_global_id = CodegenVectorClBuiltin('pos_gid', itype, work_dim, typegen=tg)
- dx = position_mesh_info['dx'].view('dx', slice(0,1), const=True)
- inv_dx = position_mesh_info['inv_dx'].view('inv_dx', slice(0,1), const=True)
- xmin = position_mesh_info['local_mesh']['xmin'].view('xmin', slice(0,1), const=True)
+ dx = position_mesh_info['dx'].view('dx', slice(0, 1), const=True)
+ inv_dx = position_mesh_info['inv_dx'].view('inv_dx', slice(0, 1), const=True)
+ xmin = position_mesh_info['local_mesh']['xmin'].view('xmin', slice(0, 1), const=True)
if is_inplace:
scalars_in_grid_size = tuple(smi['local_mesh']['resolution'].view(
- 'S{}_inout_grid_size'.format(i), slice(0,work_dim), const=True)
- for (i,smi) in enumerate(scalars_mesh_info_out))
+ 'S{}_inout_grid_size'.format(i), slice(0, work_dim), const=True)
+ for (i, smi) in enumerate(scalars_mesh_info_out))
scalars_in_grid_ghosts = tuple(smi['ghosts'].view(
- 'S{}_inout_grid_ghosts'.format(i),slice(0,work_dim), const=True)
- for (i,smi) in enumerate(scalars_mesh_info_out))
+ 'S{}_inout_grid_ghosts'.format(i), slice(0, work_dim), const=True)
+ for (i, smi) in enumerate(scalars_mesh_info_out))
scalars_in_global_id = tuple(CodegenVectorClBuiltin('S{}_inout_gid'.format(i),
- itype, work_dim, typegen=tg) for i in xrange(nfields))
+ itype, work_dim, typegen=tg) for i in xrange(nfields))
- scalars_data_out_grid_size = scalars_in_grid_size
+ scalars_data_out_grid_size = scalars_in_grid_size
scalars_data_out_grid_ghosts = scalars_in_grid_ghosts
- scalars_data_out_global_id = scalars_in_global_id
+ scalars_data_out_global_id = scalars_in_global_id
grid_ghosts = (position_grid_ghosts,) + scalars_in_grid_ghosts
- grid_sizes = (position_grid_size,) + scalars_in_grid_size
- global_ids = (position_global_id,) + scalars_in_global_id
+ grid_sizes = (position_grid_size,) + scalars_in_grid_size
+ global_ids = (position_global_id,) + scalars_in_global_id
else:
scalars_in_grid_size = tuple(smi['local_mesh']['resolution'].view(
- 'S{}_in_grid_size'.format(i), slice(0,work_dim), const=True)
- for (i,smi) in enumerate(scalars_mesh_info_in))
+ 'S{}_in_grid_size'.format(i), slice(0, work_dim), const=True)
+ for (i, smi) in enumerate(scalars_mesh_info_in))
scalars_data_out_grid_size = tuple(smi['local_mesh']['resolution'].view(
- 'S{}_out_grid_size'.format(i), slice(0,work_dim), const=True)
- for (i,smi) in enumerate(scalars_mesh_info_out))
+ 'S{}_out_grid_size'.format(i), slice(0, work_dim), const=True)
+ for (i, smi) in enumerate(scalars_mesh_info_out))
scalars_in_grid_ghosts = tuple(smi['ghosts'].view('S{}_in_grid_ghosts'.format(i),
- slice(0,work_dim), const=True) for (i,smi) in enumerate(scalars_mesh_info_in))
+ slice(0, work_dim), const=True) for (i, smi) in enumerate(scalars_mesh_info_in))
scalars_data_out_grid_ghosts = tuple(smi['ghosts'].view('S{}_out_grid_ghosts'.format(i),
- slice(0,work_dim), const=True) for (i,smi) in enumerate(scalars_mesh_info_out))
+ slice(0, work_dim), const=True) for (i, smi) in enumerate(scalars_mesh_info_out))
scalars_in_global_id = tuple(CodegenVectorClBuiltin('S{}_in_gid'.format(i),
- itype, work_dim, typegen=tg) for i in xrange(nfields))
+ itype, work_dim, typegen=tg) for i in xrange(nfields))
scalars_data_out_global_id = tuple(CodegenVectorClBuiltin('S{}_out_gid'.format(i),
- itype, work_dim, typegen=tg) for i in xrange(nfields))
+ itype, work_dim, typegen=tg) for i in xrange(nfields))
grid_ghosts = (position_grid_ghosts,) + scalars_in_grid_ghosts + \
- scalars_data_out_grid_ghosts
- grid_sizes = (position_grid_size,) + scalars_in_grid_size + scalars_data_out_grid_size
- global_ids = (position_global_id,) + scalars_in_global_id + scalars_data_out_global_id
+ scalars_data_out_grid_ghosts
+ grid_sizes = (position_grid_size,) + scalars_in_grid_size + scalars_data_out_grid_size
+ global_ids = (position_global_id,) + scalars_in_global_id + scalars_data_out_global_id
s.update_vars(position=position,
- inv_dx=inv_dx,
- position_grid_ghosts=position_grid_ghosts, compute_grid_size=compute_grid_size)
- s.update_vars(**dict((sij.name,sij) for si in scalars_data_in for sij in si))
+ inv_dx=inv_dx,
+ position_grid_ghosts=position_grid_ghosts, compute_grid_size=compute_grid_size)
+ s.update_vars(**dict((sij.name, sij) for si in scalars_data_in for sij in si))
if not is_inplace:
- s.update_vars(**dict((sij.name,sij) for si in scalars_data_out for sij in si))
-
+ s.update_vars(**dict((sij.name, sij) for si in scalars_data_out for sij in si))
npart = CodegenVariable(name='nparticles', ctype=itype, typegen=tg, value=nparticles)
cache_ghosts = CodegenVariable('cache_ghosts', itype, typegen=tg,
- value=min_ghosts,
- symbolic_mode=symbolic_mode)
- cache_width = CodegenVariable('cache_width', itype, typegen=tg,
- init='{}*{} + 2*{}'.format(npart, local_size[0], cache_ghosts))
+ value=min_ghosts,
+ symbolic_mode=symbolic_mode)
+ cache_width = CodegenVariable('cache_width', itype, typegen=tg,
+ init='{}*{} + 2*{}'.format(npart, local_size[0], cache_ghosts))
local_work = CodegenVariable('lwork', 'int', tg, const=True,
- init='{}*{}'.format(nparticles,local_size[0]))
+ init='{}*{}'.format(nparticles, local_size[0]))
- local_offset = CodegenVariable('local_offset',itype,tg)
- line_offset = CodegenVariable('line_offset',itype,tg)
- particle_offset = CodegenVariable('particle_offset',itype,tg)
+ local_offset = CodegenVariable('local_offset', itype, tg)
+ line_offset = CodegenVariable('line_offset', itype, tg)
+ particle_offset = CodegenVariable('particle_offset', itype, tg)
def _line_init(base_ptr, global_id, grid_strides):
- _id=''
+ _id = ''
if work_dim > 1:
_id += '$ + ({} $* {})'.format(global_id[work_dim-1], grid_strides[work_dim-1])
for i in xrange(work_dim-2, 0, -1):
@@ -487,16 +496,16 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
return '{}{}'.format(base_ptr, _id)
line_position = position.newvar('line_position',
- init=_line_init(position, position_global_id, position_strides))
+ init=_line_init(position, position_global_id, position_strides))
- line_scalars_in = []
+ line_scalars_in = []
line_scalars_data_out = []
for (Si, Si_global_id, Si_grid_strides) in \
zip(scalars_data_in, scalars_in_global_id, scalars_strides_in):
Li = []
for (Sij, Sij_strides) in zip(Si, Si_grid_strides):
lij = Sij.newvar('line_{}'.format(Sij.name),
- init=_line_init(Sij, Si_global_id, Sij_strides))
+ init=_line_init(Sij, Si_global_id, Sij_strides))
Li.append(lij)
line_scalars_in.append(tuple(Li))
for (Si, Si_global_id, Si_grid_strides) in \
@@ -504,10 +513,10 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
Li = []
for (Sij, Sij_strides) in zip(Si, Si_grid_strides):
lij = Sij.newvar('line_{}'.format(Sij.name),
- init=_line_init(Sij, Si_global_id, Sij_strides))
+ init=_line_init(Sij, Si_global_id, Sij_strides))
Li.append(lij)
line_scalars_data_out.append(tuple(Li))
- line_scalars_in = tuple(line_scalars_in)
+ line_scalars_in = tuple(line_scalars_in)
line_scalars_data_out = tuple(line_scalars_data_out)
line_vars = ((line_position,),) + line_scalars_in
@@ -519,85 +528,85 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
if local_size_known:
L = s.known_vars['local_size']
for i in xrange(nfields):
- Si = []
+ Si = []
BSi = []
for j in xrange(group_scalars[i]):
- Sij = CodegenArray(name='S{}_{}'.format(i,j),
- dim=1, ctype=ftype, typegen=tg,
- shape=(nparticles*L[0]+2*min_ghosts,), storage=self._local)
+ Sij = CodegenArray(name='S{}_{}'.format(i, j),
+ dim=1, ctype=ftype, typegen=tg,
+ shape=(nparticles*L[0]+2*min_ghosts,), storage=self._local)
Si.append(Sij)
cached_scalars.append(tuple(Si))
else:
buf = self.vars['buffer']
- k=0
+ k = 0
for i in xrange(nfields):
- Si = []
+ Si = []
BSi = []
for j in xrange(group_scalars[i]):
- Sij = CodegenVariable(name='S{}_{}'.format(i,j),ctype=ftype,typegen=tg,
- ptr_restrict=True, ptr=True, storage=self._local,
- ptr_const=True,
- init='{} + {}*{}'.format(buf,k,cache_width))
+ Sij = CodegenVariable(name='S{}_{}'.format(i, j), ctype=ftype, typegen=tg,
+ ptr_restrict=True, ptr=True, storage=self._local,
+ ptr_const=True,
+ init='{} + {}*{}'.format(buf, k, cache_width))
Si.append(Sij)
- k+=1
+ k += 1
cached_scalars.append(tuple(Si))
- cache_scalars = tuple(cached_scalars)
+ cache_scalars = tuple(cached_scalars)
boundary_scalars = tuple(boundary_scalars)
- pos = CodegenVectorClBuiltin('p', ftype, nparticles, tg)
- tuning_pos = CodegenVectorClBuiltin('tp', ftype, nparticles, tg)
+ pos = CodegenVectorClBuiltin('p', ftype, nparticles, tg)
+ tuning_pos = CodegenVectorClBuiltin('tp', ftype, nparticles, tg)
scalars = []
for i in xrange(nfields):
si = []
for j in xrange(group_scalars[i]):
- sij = CodegenVectorClBuiltin('s{}_{}'.format(i,j), ftype, nparticles, tg)
+ sij = CodegenVectorClBuiltin('s{}_{}'.format(i, j), ftype, nparticles, tg)
si.append(sij)
scalars.append(tuple(si))
scalars = tuple(scalars)
-
- vzero = CodegenVectorClBuiltin('vzero', ftype, nparticles, tg,
- value=np.zeros(shape=(nparticles,), dtype=np.float64))
+ vzero = CodegenVectorClBuiltin('vzero', ftype, nparticles, tg,
+ value=np.zeros(shape=(nparticles,), dtype=np.float64))
kmax = CodegenVariable('kmax', itype, tg, const=True,
- init='(({}+{lwork}-1)/{lwork})'.format(
- compute_grid_size[0], lwork=local_work))
+ init='(({}+{lwork}-1)/{lwork})'.format(
+ compute_grid_size[0], lwork=local_work))
- loopvars = 'kji'
- first = CodegenVariable('first', 'bool', tg, const=True, init='({}==0)'.format(loopvars[0]))
- last = CodegenVariable('last', 'bool', tg, const=True, init='({}=={}-1)'.format(loopvars[0],kmax))
- active = CodegenVariable('active','bool', tg, const=True)
- last_active = CodegenVariable('last_active','bool', tg, const=True)
+ loopvars = 'kji'
+ first = CodegenVariable('first', 'bool', tg, const=True, init='({}==0)'.format(loopvars[0]))
+ last = CodegenVariable('last', 'bool', tg, const=True,
+ init='({}=={}-1)'.format(loopvars[0], kmax))
+ active = CodegenVariable('active', 'bool', tg, const=True)
+ last_active = CodegenVariable('last_active', 'bool', tg, const=True)
last_particle = CodegenVariable('last_particle', itype, tg, const=True,
- init='{} - {}*({}-1)*{}'.format(compute_grid_size[0], nparticles, kmax, local_size[0]))
+ init='{} - {}*({}-1)*{}'.format(compute_grid_size[0], nparticles, kmax, local_size[0]))
@contextlib.contextmanager
def _work_iterate_(i):
try:
- if i==0:
+ if i == 0:
fval = '0'
gsize = '1'
N = kmax
- ghosts = '({}-{})'.format(position_grid_ghosts[i],cache_ghosts)
+ ghosts = '({}-{})'.format(position_grid_ghosts[i], cache_ghosts)
else:
fval = global_id.fval(i)
gsize = global_size[i]
- N = '{Sx}'.format(Sx=compute_grid_size[i])
+ N = '{Sx}'.format(Sx=compute_grid_size[i])
ghosts = position_grid_ghosts[i]
with s._for_('int {i}={fval}; {i}<{N}; {i}+={gsize}'.format(
- i=loopvars[i], fval=fval, gsize=gsize,N=N),
- unroll=(i==0) and unroll_loops) as ctx:
+ i=loopvars[i], fval=fval, gsize=gsize, N=N),
+ unroll=(i == 0) and unroll_loops) as ctx:
- if i==0:
+ if i == 0:
with s._align_() as al:
line_offset.declare(al, align=True, const=True, init='{}*{}'.format(
loopvars[0], local_work))
local_offset.declare(al, align=True, const=True, init='{}*{}'.format(
- nparticles,local_id[0]))
+ nparticles, local_id[0]))
particle_offset.declare(al, align=True, const=True, init='{} + {}'.format(
line_offset, local_offset))
s.jumpline()
@@ -605,19 +614,19 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
first.declare(al, align=True)
last.declare(al, align=True)
active.declare(al, init='({} < {})'.format(particle_offset,
- compute_grid_size[0]), align=True)
+ compute_grid_size[0]), align=True)
last_active.declare(al, init='{} && ({}+{}-1 >= {})'.format(active, particle_offset,
- nparticles, compute_grid_size[0]), align=True)
- elif i==1:
+ nparticles, compute_grid_size[0]), align=True)
+ elif i == 1:
kmax.declare(s)
last_particle.declare(s)
s.jumpline()
- if i>0:
+ if i > 0:
with s._align_() as al:
- for field_gid, field_ghosts in zip(global_ids, grid_ghosts) :
- al.append('{} $= {} $+ {};'.format(field_gid[i],
- loopvars[i], field_ghosts[i]))
+ for field_gid, field_ghosts in zip(global_ids, grid_ghosts):
+ al.append('{} $= {} $+ {};'.format(field_gid[i],
+ loopvars[i], field_ghosts[i]))
al.jumpline()
yield ctx
except:
@@ -644,7 +653,7 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
def if_first_or_last_thread_active():
#cond= '{} || {}'.format(last_active, first)
- cond= '{}'.format(last_active)
+ cond = '{}'.format(last_active)
return if_last_thread_active(cond)
with s._kernel_():
@@ -676,15 +685,15 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
s.decl_vars(*global_ids)
with s._align_() as al:
- _pos=(pos,)
+ _pos = (pos,)
if tuning_mode:
- _pos+=(tuning_pos,)
- s.decl_vars(*(_pos+tuple(sij for si in scalars for sij in si)), align=True, codegen=al)
+ _pos += (tuning_pos,)
+ s.decl_vars(*(_pos+tuple(sij for si in scalars for sij in si)),
+ align=True, codegen=al)
s.jumpline()
-
- nested_loops = [_work_iterate_(i) for i in xrange(dim-1,-1,-1)]
- if work_dim==1:
+ nested_loops = [_work_iterate_(i) for i in xrange(dim-1, -1, -1)]
+ if work_dim == 1:
kmax.declare(s)
last_particle.declare(s)
with contextlib.nested(*nested_loops):
@@ -692,69 +701,60 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
s.comment('Compute global offsets and line pointers')
with s._align_() as al:
position_global_id.affect(al, i=0, align=True,
- init='{} + {}'.format(particle_offset, position_grid_ghosts[0]))
+ init='{} + {}'.format(particle_offset, position_grid_ghosts[0]))
if not is_inplace:
for _gid, _ghosts in zip(scalars_in_global_id, scalars_in_grid_ghosts):
_gid.affect(al, i=0, align=True,
- init='{} + {}'.format(particle_offset, _ghosts[0]))
+ init='{} + {}'.format(particle_offset, _ghosts[0]))
for _gid, _ghosts in zip(scalars_data_out_global_id, scalars_data_out_grid_ghosts):
_gid.affect(al, i=0, align=True,
- init='{} + {} - {}'.format(particle_offset, _ghosts[0],
- cache_ghosts))
+ init='{} + {} - {}'.format(particle_offset, _ghosts[0],
+ cache_ghosts))
s.jumpline()
s.decl_aligned_vars(*(lvij for lvi in line_vars for lvij in lvi))
s.comment('Get back left cache from right cache')
with s._for_('int l={}; l<2*{}; l+={}'.format(local_id[0],
- cache_ghosts, local_size[0]), unroll=unroll_loops):
+ cache_ghosts, local_size[0]), unroll=unroll_loops):
with s._if_('{}'.format(first)):
- with s._align_() as al:
- for csi in cached_scalars:
- for csij in csi:
- csij.affect(al, align=True,
- i='l',
- init=tg.dump(+0.0))
+ with s._align_() as al:
+ for csi in cached_scalars:
+ for csij in csi:
+ csij.affect(al, align=True,
+ i='l',
+ init=tg.dump(+0.0))
with s._else_():
- end_id='{}+{}'.format(local_work, 'l')
+ end_id = '{}+{}'.format(local_work, 'l')
if debug_mode:
- s.append('printf("%i loaded back %2.2f from position %i.\\n", {}, {}, {});'.format(local_id[0], cached_scalars[0][0][end_id], end_id))
+ s.append('printf("%i loaded back %2.2f from position %i.\\n", {}, {}, {});'.format(
+ local_id[0], cached_scalars[0][0][end_id], end_id))
with s._align_() as al:
for csi in cached_scalars:
- for csij in csi:
+ for csij in csi:
csij.affect(al, align=True,
- i='l',
- init=csij[end_id])
+ i='l',
+ init=csij[end_id])
s.barrier(_local=True)
s.jumpline()
-
s.comment('Fill right cache with zeros, excluding left ghosts')
- for al, active_cond, k in if_last_thread_active():
- for csi in cached_scalars:
- for csij in csi:
- offset = '{}+2*{}+${}'.format(local_offset, cache_ghosts, k)
- store = s.vstore(1, csij, offset, vzero[k], align=True,
- suppress_semicolon=True)
- if use_short_circuit:
- code = '{} $&& (({}),true);'.format(active_cond, store)
- else:
- code = 'if ({}) ${{ {}; }}'.format(active_cond, store)
- al.append(code)
- with if_thread_active():
- for csi in cached_scalars:
- for csij in csi:
- offset = '{}+2*{}'.format(local_offset, cache_ghosts)
- s.append(s.vstore(nparticles, csij, offset, vzero))
+ for csi in cached_scalars:
+ for csij in csi:
+ offset = '{}+2*{}'.format(local_offset, cache_ghosts)
+ s.append(s.vstore(nparticles, csij, offset, vzero))
s.jumpline()
- s.comment('Load position and scalars at current index, {} particles at a time.'.format(nparticles))
- for al, active_cond, k in if_last_thread_active():
- load = self.vload(1, line_position, '{}+{}'.format(particle_offset,k), align=True)
+ s.comment(
+ 'Load position and scalars at current index, {} particles at a time.'.format(nparticles))
+ for al, active_cond, k in if_last_thread_active():
+ load = self.vload(1, line_position,
+ '{}+{}'.format(particle_offset, k), align=True)
if use_short_circuit:
- code = '{} $= ({} $? {} $: {});'.format(pos[k], active_cond, load, tg.dump(0.0))
+ code = '{} $= ({} $? {} $: {});'.format(
+ pos[k], active_cond, load, tg.dump(0.0))
else:
code = 'if ({}) {{ {posk} $= {}; $}} $else {{ {posk} $= {}; $}}'.format(active_cond,
- load, tg.dump(0.0), posk=pos[k])
+ load, tg.dump(0.0), posk=pos[k])
al.append(code)
if is_inplace:
_id = '{}+{}+{}'.format(particle_offset, cache_ghosts, k)
@@ -764,16 +764,16 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
for sij, line_sij in zip(si, line_si):
load = self.vload(1, line_sij, _id, align=True)
if use_short_circuit:
- code = '{} $= ({} $? {} $: {});'.format(sij[k], active_cond, load, tg.dump(0.0))
+ code = '{} $= ({} $? {} $: {});'.format(
+ sij[k], active_cond, load, tg.dump(0.0))
else:
code = 'if ({}) {{ {sijk} $= {}; $}} $else {{ {sijk} $= {}; $}}'.format(active_cond,
- load, tg.dump(0.0), sijk=sij[k])
+ load, tg.dump(0.0), sijk=sij[k])
al.append(code)
-
with if_thread_active():
with s._align_() as al:
pos.affect(al, align=True,
- init=self.vload(nparticles, line_position, particle_offset, align=True))
+ init=self.vload(nparticles, line_position, particle_offset, align=True))
if is_inplace:
_id = '{}+{}'.format(particle_offset, cache_ghosts)
@@ -782,14 +782,23 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
for si, line_si in zip(scalars, line_scalars_in):
for sij, line_sij in zip(si, line_si):
sij.affect(al, align=True,
- init=self.vload(nparticles, line_sij, _id, align=True))
+ init=self.vload(nparticles, line_sij, _id, align=True))
+ with s._else_():
+ for k in xrange(nparticles):
+ code = '{} = NAN;'.format(pos[k])
+ s.append(code)
+ for si, line_si in zip(scalars, line_scalars_in):
+ for sij, line_sij in zip(si, line_si):
+ code = '{} = NAN;'.format(sij[k])
+ s.append(code)
+
s.barrier(_local=True)
s.jumpline()
if tuning_mode:
code = '{} = max(min({pos}, ({pid}+{one})*{dx}), ({pid}-{one})*{dx});'.format(
- tuning_pos, pos=pos, dx=dx,
- pid=particle_offset, one=tg.dump(1.0))
+ tuning_pos, pos=pos, dx=dx,
+ pid=particle_offset, one=tg.dump(1.0))
s.append(code)
if debug_mode:
@@ -797,36 +806,38 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
s.append('printf("\\n");')
s.append('printf("\\nGLOBAL SCALAR VALUES\\n");')
with s._for_('int ii=0; ii<{}; ii++'.format(compute_grid_size[0])):
- s.append('printf("%2.2f, ", {}[cache_ghosts+ii]);'.format(line_scalars_in[0][0]))
+ s.append(
+ 'printf("%2.2f, ", {}[cache_ghosts+ii]);'.format(line_scalars_in[0][0]))
s.append('printf("\\n\\n");')
with s._ordered_wi_execution_(barrier=True):
- s.append('printf("lid.x=%i, k=%i/%i, line_offset=%i, local_offset=%i, poffset=%i, first=%i, last=%i, active=%i, last_active=%i, p={vnf}, s0={vnf}\\n", {},k,kmax,line_offset,local_offset,particle_offset,first,last,active,last_active,p,s0_0);'.format(local_id[0], vnf=vnf))
- s.barrier(_local=True, _global=True)
+ s.append('printf("lid.x=%i, k=%i/%i, line_offset=%i, local_offset=%i, poffset=%i, first=%i, last=%i, active=%i, last_active=%i, p={vnf}, s0={vnf}\\n", {},k,kmax,line_offset,local_offset,particle_offset,first,last,active,last_active,{},{});'.format(
+ local_id[0], epv(pos), epv(scalars[0][0]), vnf=vnf))
+ s.barrier(_local=True)
with s._first_wi_execution_():
- s.append('printf("\\n");')
s.append('printf("\\nLEFT SCALAR CACHE (BEFORE REMESH)\\n");')
- with s._for_('int ii=0; ii<2*cache_ghosts; ii++'):
+ with s._for_('int ii=0; ii<cache_width; ii++'):
s.append('printf("%2.2f, ", S0_0[ii]);')
- s.append('printf("\\n\\n");')
+ s.append('printf("\\n");')
s.comment('Remesh scalars in cache.')
with s._block_():
remesh = s.reqs['remesh']
remesh_kargs = {
- 'dx':dx,
- 'inv_dx':inv_dx,
+ 'dx': dx,
+ 'inv_dx': inv_dx,
+ 'cache_width': cache_width,
'cache_ghosts': cache_ghosts,
'active': active,
'line_offset': line_offset
}
- k=0
+ k = 0
for ci in cached_scalars:
for cij in ci:
remesh_kargs['S{}'.format(k)] = cij
- k+=1
+ k += 1
if use_atomics:
# with atomic summation in cache, we can remesh everything at a time
@@ -834,25 +845,29 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
remesh_kargs['p'] = tuning_pos
else:
remesh_kargs['p'] = pos
- k=0
+ k = 0
for si in scalars:
for sij in si:
remesh_kargs['s{}'.format(k)] = sij
- k+=1
+ k += 1
call = remesh(**remesh_kargs)
s.append('{};'.format(call))
else:
# without atomics we can only remesh on particle at a time
for p in xrange(nparticles):
+ if debug_mode:
+ with s._first_wi_execution_():
+ s.append(
+ 'printf("\\nREMESHING PARTICLES {}*k+{}:\\n");'.format(nparticles, p))
if tuning_mode:
remesh_kargs['p'] = tuning_pos[p]
else:
remesh_kargs['p'] = pos[p]
- k=0
+ k = 0
for si in scalars:
for sij in si:
remesh_kargs['s{}'.format(k)] = sij[p]
- k+=1
+ k += 1
call = remesh(**remesh_kargs)
s.append('{};'.format(call))
s.barrier(_local=True, _global=True)
@@ -873,96 +888,106 @@ class DirectionalRemeshKernelGenerator(KernelCodeGenerator):
for al, active_cond, k in if_first_or_last_thread_active():
for si, li in zip(cached_scalars, line_scalars_data_out):
for sij, lij in zip(si, li):
- load = self.vload(1, sij, '{}+{}'.format(local_offset, k))
+ load = self.vload(1, sij, '{}+{}'.format(local_offset, k))
_id = '{}+{}'.format(particle_offset, k)
- store = self.vstore(1, lij, _id, load, align=True, jmp=True, suppress_semicolon=True)
+ store = self.vstore(1, lij, _id, load, align=True,
+ jmp=True, suppress_semicolon=True)
if use_short_circuit:
code = '{} $&& (({}),true)'.format(active_cond, store)
+ if debug_mode:
+ code += ' && (printf("last_active %i wrote %2.2f from cache position %i to global id %i.\\n", {},{},{},{}));'.format(
+ local_id[0], load, '{}+{}'.format(local_offset, k), _id)
+ else:
+ code += ';'
else:
- code = 'if ({}) ${{ {}; }}'.format(active_cond, store)
- if debug_mode:
- code += ' && (printf("last_active %i wrote %2.2f from cache position %i to global id %i.\\n", {},{},{},{}));'.format(
- local_id[0], load, '{}+{}'.format(local_offset,k), _id)
- else:
- code += ';'
+ code = 'if ({}) ${{ {}; '.format(active_cond, store)
+ if debug_mode:
+ code += 'printf("last_active %i wrote %2.2f from cache position %i to global id %i.\\n", {},{},{},{});'.format(
+ local_id[0], load, '{}+{}'.format(local_offset, k), _id)
+ code += '}'
al.append(code)
with if_thread_active(not_first=False):
with s._align_() as al:
if debug_mode:
s.append('printf("%i wrote {vnf} from cache position %i to global id %i.\\n", {},{},{},{});'.format(
local_id[0],
- self.vload(nparticles, cached_scalars[0], local_offset),
- local_offset, particle_offset, compute_grid_size[0], cache_ghosts, compute_grid_size[0]),
- vnf=vnf)
+ epv(self.vload(nparticles, cached_scalars[0][0], local_offset)),
+ local_offset, particle_offset, compute_grid_size[0], cache_ghosts, compute_grid_size[0],
+ vnf=vnf))
for ci, li in zip(cached_scalars, line_scalars_data_out):
for cij, lij in zip(ci, li):
- load = self.vload(nparticles, cij, '{}'.format(local_offset))
+ load = self.vload(nparticles, cij, '{}'.format(local_offset))
_id = particle_offset
- store = self.vstore(nparticles, lij, _id, load, align=True, jmp=True)
+ store = self.vstore(nparticles, lij, _id,
+ load, align=True, jmp=True)
al.append(store)
s.jumpline()
with s._if_('{}'.format(last)):
with s._for_('int l={}; l<2*{}; l+={}'.format(local_id[0],
- cache_ghosts, local_size[0]), unroll=unroll_loops):
+ cache_ghosts, local_size[0]), unroll=unroll_loops):
with s._align_() as al:
_gid = '{}+{}+{}'.format(line_offset, last_particle, 'l')
for ci, li in zip(cached_scalars, line_scalars_data_out):
- for cij, lij in zip(ci,li):
- init=cij['{}+{}'.format(last_particle, 'l')]
+ for cij, lij in zip(ci, li):
+ init = cij['{}+{}'.format(last_particle, 'l')]
lij.affect(i=_gid, init=init, align=True, codegen=al)
if debug_mode:
with s._ordered_wi_execution_(barrier=False):
s.append('printf("%i initiated last write from cache position %i+%i=%i to global id %i+%i+%i=%i with value %2.2f.\\n", {}, {},{},{}, {},{},{},{}, {});'.format(
- local_id[0], last_particle, 'l', '{}+l'.format(last_particle),
- line_offset, last_particle, 'l', '{}+{}+l'.format(line_offset, last_particle),
+ local_id[0], last_particle, 'l', '{}+l'.format(
+ last_particle),
+ line_offset, last_particle, 'l', '{}+{}+l'.format(
+ line_offset, last_particle),
'S0_0[{}+l]'.format(last_particle)))
s.barrier(_local=True, _global=True)
+
if __name__ == '__main__':
from hysop.backend.device.opencl import cl
from hysop.backend.device.codegen.base.test import _test_mesh_info, _test_typegen
from hysop.numerics.remesh.remesh import RemeshKernel
- kernel = RemeshKernel(4,2, split_polys=True)
+ kernel = RemeshKernel(4, 2, split_polys=False)
- work_dim=3
- ghosts=(0,0,0)
- sresolution =(1024,512,256)
- local_size = (128,1,1)
- global_size = (16050,55,440)
+ work_dim = 3
+ ghosts = (0, 0, 0)
+ sresolution = (1024, 512, 256)
+ local_size = (128, 1, 1)
+ global_size = (16050, 55, 440)
tg = _test_typegen('float', 'hex')
- (_,smesh_info) = _test_mesh_info('scalars_mesh_info',tg,work_dim,ghosts,sresolution)
- (_,pmesh_info) = _test_mesh_info('position_mesh_info',tg,work_dim,ghosts,sresolution)
+ (_, smesh_info) = _test_mesh_info('scalars_mesh_info', tg, work_dim, ghosts, sresolution)
+ (_, pmesh_info) = _test_mesh_info('position_mesh_info', tg, work_dim, ghosts, sresolution)
scalar_cfl = 1.5
dak = DirectionalRemeshKernelGenerator(typegen=tg, ftype=tg.fbtype,
- work_dim=work_dim,
- nparticles=4,
- nscalars=2,
- remesh_kernel=kernel,
- scalar_cfl=scalar_cfl,
- use_atomics=False,
- is_inplace=True,
- symbolic_mode=False,
- debug_mode=False,
- tuning_mode=True,
- sboundary=(BoundaryCondition.NONE, BoundaryCondition.NONE),
- known_vars=dict(
- S0_inout_mesh_info=smesh_info,
- S1_inout_mesh_info=smesh_info,
- S0_in_mesh_info=smesh_info,
- S1_in_mesh_info=smesh_info,
- S0_out_mesh_info=smesh_info,
- S1_out_mesh_info=smesh_info,
- position_mesh_info=pmesh_info,
- local_size=local_size[:work_dim],
- global_size=global_size[:work_dim]
- )
- )
+ work_dim=work_dim,
+ nparticles=4,
+ nscalars=2,
+ remesh_kernel=kernel,
+ scalar_cfl=scalar_cfl,
+ use_atomics=False,
+ is_inplace=True,
+ symbolic_mode=False,
+ debug_mode=False,
+ tuning_mode=False,
+ sboundary=(BoundaryCondition.NONE,
+ BoundaryCondition.NONE),
+ known_vars=dict(
+ S0_inout_mesh_info=smesh_info,
+ S1_inout_mesh_info=smesh_info,
+ S0_in_mesh_info=smesh_info,
+ S1_in_mesh_info=smesh_info,
+ S0_out_mesh_info=smesh_info,
+ S1_out_mesh_info=smesh_info,
+ position_mesh_info=pmesh_info,
+ local_size=local_size[:work_dim],
+ global_size=global_size[:work_dim]
+ )
+ )
print 'scalars_out_min_gosts = {}'.format(dak.scalars_out_cache_ghosts(scalar_cfl, kernel))
print 'required cache: {}'.format(dak.required_workgroup_cache_size(local_size))
diff --git a/hysop/backend/device/codegen/kernels/empty.py b/hysop/backend/device/codegen/kernels/empty.py
index 23412a6e3b44d8c0f1cf6d77c774fac96adac779..d9aa561028c8f74999947134255cf32b2942a954 100644
--- a/hysop/backend/device/codegen/kernels/empty.py
+++ b/hysop/backend/device/codegen/kernels/empty.py
@@ -19,15 +19,15 @@ class EmptyKernel(KernelCodeGenerator):
def gencode(self):
s = self
with s._kernel_():
- s.append(s.vars['global_size'].define())
- s.append(s.vars['local_size'].define())
- s.append(s.vars['global_id'].define())
+ #s.vars['global_size'].declare(s)
+ #s.vars['local_size'].declare(s)
+ s.vars['global_id'].declare(s)
s.check_workitem_bounds('grid_size')
if __name__ == '__main__':
- from hysop.backend.device.codegen.base.test import test_typegen
- typegen = test_typegen('float')
+ from hysop.backend.device.codegen.base.test import _test_typegen
+ typegen = _test_typegen('float')
ek = EmptyKernel(typegen)
print ek
diff --git a/hysop/backend/device/codegen/kernels/transpose.py b/hysop/backend/device/codegen/kernels/transpose.py
index 4d4701de045b93cf0c6f7e8424394aae6606c5fc..58257139d07103e50b451e5bd7a1074e9110d71a 100644
--- a/hysop/backend/device/codegen/kernels/transpose.py
+++ b/hysop/backend/device/codegen/kernels/transpose.py
@@ -25,8 +25,8 @@ class TransposeKernelGenerator(KernelCodeGenerator):
use_diagonal_coordinates):
pdim = len(axes)
axes = [ str(j) if i!=j else 'X' for i,j in enumerate(axes) ]
- return '{}transpose_{}_{}_{}d__N{}__T{}__P{}__{}'.format(
- 'diag_' if use_diagonal_coordinates else '',
+ return 'transpose{}_{}_{}_{}d__N{}__T{}__P{}__{}'.format(
+ '_dc' if use_diagonal_coordinates else '_nc',
'inplace' if is_inplace else 'out_of_place',
ctype.replace(' ','_'), pdim, vectorization, tile_size, tile_padding,
'_'.join(axes))
@@ -724,7 +724,9 @@ to prevent memory camping that may occur during global input read or output writ
if __name__ == '__main__':
from hysop.backend.device.codegen.base.test import _test_typegen
tg = _test_typegen('float')
- ek = TransposeKernelGenerator(typegen=tg, ctype='short', vectorization=2,
+ ek = TransposeKernelGenerator(typegen=tg,
+ ctype='short',
+ vectorization=4,
axes=(2,1,0,4,3),
tile_size=8, tile_padding=1,
is_inplace=False,
diff --git a/hysop/backend/device/codegen/symbolic/expr.py b/hysop/backend/device/codegen/symbolic/expr.py
index a2d1d25553489c363c857614b21d625ebd3e4964..c8c86e978e51f00a7557e8823b50a3151e761f00 100644
--- a/hysop/backend/device/codegen/symbolic/expr.py
+++ b/hysop/backend/device/codegen/symbolic/expr.py
@@ -1,4 +1,6 @@
+import sympy as sm
from hysop.symbolic import Symbol, Expr
+from hysop.symbolic.array import OpenClSymbolicBuffer, OpenClSymbolicNdBuffer
from hysop.tools.types import check_instance, first_not_None, to_tuple, to_list
from hysop.tools.numerics import is_fp, is_signed, is_unsigned, is_integer, is_complex
from sympy.printing.ccode import C99CodePrinter
@@ -184,7 +186,7 @@ class OpenClIndexedVariable(OpenClVariable):
dim = index.var.dim
components = cl_components(ctype)
ctype = cls.vtype(cl_basetype(ctype), components*dim)
- except AttributeError:
+ except AttributeError as e:
dim = 1
obj = super(OpenClIndexedVariable, cls).__new__(cls, ctype, var, index)
obj.index = index
@@ -192,16 +194,19 @@ class OpenClIndexedVariable(OpenClVariable):
return obj
def _ccode(self, printer):
- try:
- return self.var[self.index]
- except:
- var = printer._print(self.var)
- if (self.dim>1):
- vals = ', '.join('{}[{}]'.format(var, self.index.var[i]) for i in xrange(self.dim))
- return '({})({})'.format(self.ctype, vals)
- else:
- index = printer._print(self.index)
- return '{}[{}]'.format(var, index)
+ if not isinstance(self.var, (OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)):
+ try:
+ return self.var[self.index]
+ except Exception as e:
+ pass
+
+ var = printer._print(self.var)
+ if (self.dim>1):
+ vals = ', '.join('{}[{}]'.format(var, self.index.var[i]) for i in xrange(self.dim))
+ return '({})({})'.format(self.ctype, vals)
+ else:
+ index = printer._print(self.index)
+ return '{}[{}]'.format(var, index)
class OpenClAssignment(TypedExpr):
def __new__(cls, ctype, var, op, rhs):
diff --git a/hysop/backend/device/codegen/symbolic/functions/custom_symbolic_function.py b/hysop/backend/device/codegen/symbolic/functions/custom_symbolic_function.py
index bea546b853b04616fe2d940be1df3f7e05651ae7..f5db424fbce9e08c3f1283e6eb07798e11b5fb7d 100644
--- a/hysop/backend/device/codegen/symbolic/functions/custom_symbolic_function.py
+++ b/hysop/backend/device/codegen/symbolic/functions/custom_symbolic_function.py
@@ -13,8 +13,9 @@ from hysop.symbolic.base import UnsplittedExpr
from hysop.symbolic.parameter import SymbolicScalarParameter, SymbolicTensorParameter
from hysop.symbolic.field import SymbolicDiscreteField
from hysop.symbolic.misc import ApplyStencil, Cast
-from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer
+from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer
from hysop.symbolic.tmp import TmpScalar
+from hysop.symbolic.constant import SymbolicConstant
from hysop.symbolic.spectral import WaveNumberIndex
from hysop.backend.device.codegen.symbolic.expr import VLoad, VStore, \
@@ -184,8 +185,11 @@ class CustomSymbolicFunction(OpenClFunctionCodeGenerator):
elif isinstance(expr, complex):
pexpr = ComplexFloatingPointConstant(csc.typegen.fbtype+'2', expr)
elif isinstance(expr, npw.number):
- ctype = dtype_to_ctype(expr)
+ ctype = dtype_to_ctype(expr.dtype)
pexpr = NumericalConstant(ctype, expr)
+ elif isinstance(expr, SymbolicConstant):
+ expr.assert_bound()
+ pexpr = self.parse_expr(csc, name, expr.value, args, reqs)
elif isinstance(expr, Cast):
target_ctype = dtype_to_ctype(expr.dtype)
pexpr = self.parse_expr(csc, name, expr.expr, args, reqs)
@@ -246,7 +250,7 @@ class CustomSymbolicFunction(OpenClFunctionCodeGenerator):
raise NotImplementedError()
else:
pexpr = OpenClVariable(var.ctype, var)
- elif isinstance(expr, OpenClSymbolicBuffer):
+ elif isinstance(expr, (OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)):
buf = csc.buffer_args[expr]
self.check_and_set(args, buf.name, buf)
pexpr = OpenClVariable(buf.ctype, buf)
diff --git a/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py b/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py
index 4685157e6e3c2bbfcae1c2ba1ad196d81ef82b7d..da378bd7bb54c37f43d9dc033dd2a045824795a7 100644
--- a/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py
+++ b/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py
@@ -60,7 +60,7 @@ class CustomSymbolicAffectKernelGenerator(CustomSymbolicKernelGenerator):
for (i,expr) in enumerate(exprs):
if isinstance(expr, CodeSection):
section_pexprs, findex = self._build_expr_requirements(csc, known_vars,
- expr.args, out_args, fcalls, is_out_of_date, reqs, findex+i)
+ expr.args, out_args, fcalls, is_out_of_date, reqs, findex)
pexpr = CodeSection(*section_pexprs)
elif isinstance(expr, Assignment):
lhs, rhs = expr.args
@@ -80,6 +80,14 @@ class CustomSymbolicAffectKernelGenerator(CustomSymbolicKernelGenerator):
elif isinstance(lhs, IndexedBuffer):
var = lhs.indexed_object
index = lhs.index
+ fname='f{}'.format(findex)
+ findex+=1
+ index_fn = CustomSymbolicFunction(csc=csc, name=fname, expr=index,
+ inline=(not csc.tuning_mode), known_args=known_vars)
+ fn_kwds = index_fn.args.copy()
+ index = FunctionCall(index_fn.ctype, index_fn, fn_kwds)
+ fcalls.append(index)
+ reqs[fname] = index_fn
lhs = OpenClIndexedVariable(var.ctype, var, index)
is_tmp = True
elif isinstance(lhs, TmpScalar):
@@ -96,14 +104,14 @@ class CustomSymbolicAffectKernelGenerator(CustomSymbolicKernelGenerator):
msg='Unknown lhs type {} for assignment, valid ones are SymbolicDiscreteField.'
msg=msg.format(type(lhs))
raise NotImplementedError(msg)
-
- fname='f{}'.format(findex+i)
+
+ fname='f{}'.format(findex)
+ findex+=1
rhs_fn = CustomSymbolicFunction(csc=csc, name=fname, expr=rhs, target_ctype=lhs.ctype,
inline=(not csc.tuning_mode), known_args=known_vars)
fn_kwds = rhs_fn.args.copy()
rhs = FunctionCall(rhs_fn.ctype, rhs_fn, fn_kwds)
fcalls.append(rhs)
-
reqs[fname] = rhs_fn
assert (lhs.ctype == rhs.ctype), '{} != {}'.format(lhs.ctype, rhs.ctype)
@@ -114,4 +122,4 @@ class CustomSymbolicAffectKernelGenerator(CustomSymbolicKernelGenerator):
else:
pexpr = expr
pexprs += (pexpr,)
- return pexprs, findex+i
+ return pexprs, findex
diff --git a/hysop/backend/device/codegen/symbolic/map.py b/hysop/backend/device/codegen/symbolic/map.py
index d740c7171867265ec5673762f61473f10784701b..ab087c5372bde5e8c509d2a6b5d54c63736a6486 100644
--- a/hysop/backend/device/codegen/symbolic/map.py
+++ b/hysop/backend/device/codegen/symbolic/map.py
@@ -120,8 +120,6 @@ def _map_func(csc, expr, promoted_args, ctype, reqs):
else:
msg='min({})'.format(ctype)
raise NotImplementedError(msg)
- elif expr.func is sm.exp:
- return BuiltinFunction('exp')
elif expr.func in _func_mappings:
return _func_mappings[expr.func]
return expr.func
@@ -174,6 +172,8 @@ _func_mappings = {
sm.sinh: BuiltinFunction('sinh'),
sm.tanh: BuiltinFunction('tanh'),
sm.exp: BuiltinFunction('exp'),
+ sm.log: BuiltinFunction('log'),
+ sm.sign: BuiltinFunction('sign'),
sm.StrictGreaterThan: OpenClLogicalGT,
sm.StrictLessThan: OpenClLogicalLT,
sm.GreaterThan: OpenClLogicalGE,
diff --git a/hysop/backend/device/kernel_autotuner.py b/hysop/backend/device/kernel_autotuner.py
index 5e8b840f5e9f94ea0659d6078f5bffd02a87fd05..3a1cdb53b88e14027e1ce3756f6fee1e408203f8 100644
--- a/hysop/backend/device/kernel_autotuner.py
+++ b/hysop/backend/device/kernel_autotuner.py
@@ -12,6 +12,7 @@ from hysop.tools.cache import load_cache, update_cache
from hysop.backend.device.autotunable_kernel import AutotunableKernel, \
AutotunerWorkConfiguration
from hysop.backend.device.kernel_statistics import KernelStatistics
+from hysop.backend.device.kernel_autotuner_statistics import AutotunedKernelStatistics
from hysop.backend.device.codegen import CodeGeneratorWarning
class KernelGenerationError(RuntimeError):
@@ -27,12 +28,15 @@ class KernelAutotuner(object):
@staticmethod
def _hash_func():
return hashlib.new('sha256')
-
- @staticmethod
- def cache_dir():
- cache_dir = IO.cache_path() + '/kernel_autotuner'
- return cache_dir
-
+
+ def use_tmp_cache(self):
+ self._cache_dir = IO.get_tmp_dir('kernel_autotuner')
+ def use_system_cache(self):
+ self._cache_dir = IO.cache_path() + '/kernel_autotuner'
+
+ def cache_dir(self):
+ assert (self._cache_dir is not None)
+ return self._cache_dir
def cache_file(self):
cache_file = '{}/{}.pklz'.format(self.cache_dir(), self.name.replace(' ','_'))
return cache_file
@@ -40,7 +44,6 @@ class KernelAutotuner(object):
def _reload_cache(self, extra_kwds_hash):
cache_file = self.cache_file()
if self.verbose:
- print
print self.indent(1)+'>Loading cached results from \'{}\'.'.format(cache_file)
self.all_results = load_cache(cache_file)
config_key = self.autotuner_config_key()
@@ -79,12 +82,25 @@ class KernelAutotuner(object):
self.indent = lambda i: ' '*i
self.verbose = self.autotuner_config.verbose
- self.prg_idx = 4
- self.knl_idx = 5
- self.stats_idx = 6
- self.src_idx = 7
- self.src_hash_idx = 9
- self.logs_idx = 10
+ self.result_keys = (
+ 'extra_parameters', #00
+ 'work_size', #01
+ 'work_load', #02
+ 'global_work_size', #03
+ 'local_work_size', #04
+ 'program', #05
+ 'kernel', #06
+ 'kernel_statistics', #07
+ 'kernel_src', #08
+ 'kernel_name', #09
+ 'src_hash', #10
+ 'extra_kwds_hash', #10
+ 'extra_kwds_hash_logs' #12
+ )
+ for (i, pname) in enumerate(self.result_keys):
+ setattr(self, '{}_idx'.format(pname), i)
+
+ self._cache_dir = None
def autotune(self, extra_kwds,
first_working=False,
@@ -104,34 +120,42 @@ class KernelAutotuner(object):
autotuner_config = self.autotuner_config
extra_kwds_hash, extra_kwds_hash_logs = tkernel.hash_extra_kwds(extra_kwds)
+ hasher = self._hash_func()
+ hasher.update(str(extra_kwds_hash))
+ extra_kwds_hash = hasher.hexdigest()
+ check_instance(extra_kwds_hash, str)
check_instance(extra_kwds_hash_logs, str)
+ file_basename = '{}_{}'.format(self.name, extra_kwds_hash[:4])
- self._print_header()
- results = self._reload_cache(extra_kwds_hash)
-
+ self._print_header(extra_kwds)
if autotuner_config.override_cache:
if self.verbose:
- print self.indent(1)+'>Ignoring cached results, benching all kernels.'
- best_candidate = None
- elif first_working:
+ print self.indent(1)+'>Using temporary cache folder, benching all new kernels.'
+ self.use_tmp_cache()
+ else:
+ self.use_system_cache()
+ results = self._reload_cache(extra_kwds_hash)
+
+ if first_working:
best_candidate = None
else:
best_candidate = self._load_results_from_cache(tkernel, results, extra_kwds,
- force_verbose, force_debug, extra_kwds_hash_logs)
+ force_verbose, force_debug, extra_kwds_hash, extra_kwds_hash_logs, file_basename)
if (best_candidate is None):
best_candidate = self._autotune_kernels(tkernel, results, extra_kwds,
- force_verbose, force_debug, first_working, extra_kwds_hash_logs)
+ force_verbose, force_debug, first_working,
+ extra_kwds_hash, extra_kwds_hash_logs, file_basename)
+ from_cache = False
+ else:
+ from_cache = True
- result_keys = ('extra_parameters', 'work_load', 'global_work_size', 'local_work_size',
- 'program', 'kernel', 'kernel_statistics', 'kernel_src', 'kernel_name',
- 'src_hash', 'hash_logs')
- assert len(result_keys) == len(best_candidate)
- return dict(zip(result_keys, best_candidate))
+ assert len(self.result_keys) == len(best_candidate)
+ return dict(zip(self.result_keys, best_candidate)), file_basename, from_cache
def _load_results_from_cache(self, tkernel, results, extra_kwds,
- force_verbose, force_debug, extra_kwds_hash_logs):
+ force_verbose, force_debug, extra_kwds_hash, extra_kwds_hash_logs, file_basename):
if (self.FULL_RESULTS_KEY not in results):
if self.verbose:
print (' >No best candidate was cached for this configuration, '
@@ -146,10 +170,19 @@ class KernelAutotuner(object):
# pyopencl kernel and program objects.
best_candidate = copy.deepcopy(results[self.FULL_RESULTS_KEY])
- (extra_parameters, work_load, global_work_size, local_work_size,
- prg, kernel, statistics, cached_kernel_src,
- cached_kernel_name, cached_src_hash,
- cached_kernel_hash_logs) = best_candidate
+ (extra_parameters,
+ work_size, work_load, global_work_size, local_work_size,
+ prg, kernel, statistics, cached_kernel_src,
+ cached_kernel_name, cached_src_hash,
+ cached_kernel_hash, cached_kernel_hash_logs) = best_candidate
+
+ if (cached_kernel_hash != extra_kwds_hash):
+ msg='\nCached kernel extra_kwds hash did not match the benched one:\n {}\n {}\n'
+ msg+='\nThis might be due to an upgrade of the generated code or '
+ msg+='a faulty implementation of {}.hash_extra_kwds().'
+ msg=msg.format(cached_kernel_hash, extra_kwds_hash, type(tkernel).__name__)
+ warnings.warn(msg, CodeGeneratorWarning)
+ return None
assert prg is None
assert kernel is None
@@ -202,59 +235,83 @@ class KernelAutotuner(object):
warnings.warn(msg, CodeGeneratorWarning)
return None
- (prg, kernel) = self.build_from_source(kernel_name=kernel_name,
- kernel_src=kernel_src,
- build_options=self.build_opts,
- force_verbose=force_verbose,
- force_debug=force_debug)
-
- self.check_kernel(tkernel=tkernel, kernel=kernel,
- global_work_size=global_work_size,
- local_work_size=local_work_size)
+ try:
+ (prg, kernel) = self.build_from_source(kernel_name=kernel_name,
+ kernel_src=kernel_src,
+ build_options=self.build_opts,
+ force_verbose=force_verbose,
+ force_debug=force_debug)
+ except Exception as e:
+ msg = 'Could not use cached kernel because there was a problem during build:'
+ msg +='\n {}'.format(e)
+ print msg
+ return None
+
+ try:
+ self.check_kernel(tkernel=tkernel, kernel=kernel,
+ global_work_size=global_work_size,
+ local_work_size=local_work_size)
+ except Exception as e:
+ msg = 'Could not use cached kernel because the following error occured during checkup:'
+ msg +='\n {}'.format(e)
+ print msg
+ return None
- best_candidate[self.prg_idx] = prg
- best_candidate[self.knl_idx] = kernel
- best_candidate[self.src_idx] = kernel_src
- best_candidate[self.logs_idx] = extra_kwds_hash_logs
+ best_candidate[self.program_idx] = prg
+ best_candidate[self.kernel_idx] = kernel
+ best_candidate[self.kernel_src_idx] = kernel_src
+ best_candidate[self.extra_kwds_hash_logs_idx] = extra_kwds_hash_logs
return tuple(best_candidate)
def _autotune_kernels(self, tkernel, results, extra_kwds,
- force_verbose, force_debug, first_working, extra_kwds_hash_logs):
+ force_verbose, force_debug, first_working,
+ extra_kwds_hash, extra_kwds_hash_logs, file_basename):
autotuner_config = self.autotuner_config
if first_working:
nruns = 1
else:
nruns = autotuner_config.nruns
- max_candidates = autotuner_config.max_candidates
+ max_candidates = extra_kwds.get('max_candidates', autotuner_config.max_candidates)
bench_results = {}
best_stats = None
step_count = 0
self._print_step(step_count, 'all', nruns)
+
+ ks = AutotunedKernelStatistics(tkernel, extra_kwds)
+ ks.max_candidates = max_candidates
+ ks.nruns = nruns
+ ks.file_basename = file_basename
with Timer() as timer:
params = tkernel.compute_parameters(extra_kwds=extra_kwds)
total_count, pruned_count, kept_count, failed_count = 0,0,0,0
abort = False
for extra_parameters in params.iter_parameters():
-
+ extra_param_hash = tkernel.hash_extra_parameters(extra_parameters)
try:
(max_kernel_work_group_size, preferred_work_group_size_multiple) = \
self.collect_kernel_infos(tkernel=tkernel,
extra_parameters=extra_parameters,
extra_kwds=extra_kwds)
- except KernelGenerationError as e:
- if __KERNEL_DEBUG__:
- sys.stderr.write(str(e)+'\n')
+ pks = ks.push_parameters(extra_param_hash,
+ extra_parameters=extra_parameters,
+ max_kernel_work_group_size=max_kernel_work_group_size,
+ preferred_work_group_size_multiple=preferred_work_group_size_multiple)
+ except Exception as e:
+ msg = 'Autotuner could not determine kernel info for parameters {} because of the following KernelGenerationError:\n{}\n'
+ msg = msg.format(extra_parameters, e)
+ warnings.warn(msg, CodeGeneratorWarning)
+ pks = ks.push_parameters(extra_param_hash, extra_parameters=extra_parameters)
continue
work_bounds = tkernel.compute_work_bounds(max_kernel_work_group_size=max_kernel_work_group_size,
preferred_work_group_size_multiple=preferred_work_group_size_multiple,
extra_parameters=extra_parameters,
extra_kwds=extra_kwds)
- extra_param_hash = tkernel.hash_extra_parameters(extra_parameters)
+ work_size = work_bounds.work_size
self._print_parameters(extra_parameters, work_bounds)
@@ -274,7 +331,6 @@ class KernelAutotuner(object):
work_load=work_load, extra_parameters=extra_parameters,
extra_kwds=extra_kwds)
self._print_workload(work_load, work)
-
for local_work_size in work.iter_local_work_size():
global_work_size = tkernel.compute_global_work_size(
local_work_size=local_work_size, work=work,
@@ -297,7 +353,7 @@ class KernelAutotuner(object):
hasher.update(kernel_src)
src_hash = hasher.hexdigest()
- if (not autotuner_config.override_cache) and (run_key in results):
+ if (run_key in results):
(cache_src_hash, cache_stats) = results[run_key]
if (cache_src_hash != src_hash):
msg='\nCached parameters candidate did not match the '
@@ -339,24 +395,38 @@ class KernelAutotuner(object):
kept_count += 1
if (best_stats is None) or (statistics.mean < best_stats.mean):
+ local_best = True
best_stats = statistics
+ else:
+ local_best = False
candidate = (extra_parameters,
+ tuple(work_size),
tuple(work_load),
tuple(global_work_size),
tuple(local_work_size),
prg, kernel, statistics,
kernel_src, kernel_name,
- src_hash, extra_kwds_hash_logs)
+ src_hash, extra_kwds_hash, extra_kwds_hash_logs)
results[run_key] = (src_hash, statistics)
bench_results[run_key] = candidate
+ pks.push_run_statistics(run_key,
+ work_size=work_size, work_load=work_load,
+ local_work_size=local_work_size, global_work_size=global_work_size,
+ statistics=statistics, pruned=pruned,
+ local_best=local_best, error=None)
except KernelGenerationError as e:
if __KERNEL_DEBUG__:
sys.stderr.write(str(e)+'\n')
failed_count += 1
statistics = None
from_cache=False
+ pks.push_run_statistics(run_key,
+ work_size=work_size, work_load=work_load,
+ local_work_size=local_work_size, global_work_size=global_work_size,
+ statistics=None, pruned=None,
+ local_best=None, error=e)
total_count += 1
abort = (max_candidates is not None) and \
((pruned_count + kept_count) >= max_candidates)
@@ -383,34 +453,49 @@ class KernelAutotuner(object):
assert total_count == (kept_count+pruned_count+failed_count)
if (kept_count == 0):
- msg = 'No bench result were generated, aborting.'
+ msg = 'No bench result were generated out of {} runs '
+ msg += '(kept_count={}, pruned_count={}, failed_count={}), aborting.'
+ msg = msg.format(total_count, kept_count, pruned_count, failed_count)
raise RuntimeError(msg)
keep_only = max(previous_pow2(kept_count),1)
self._print_first_step_results(total_count, kept_count, pruned_count,
failed_count, keep_only)
- candidates = sorted(bench_results.items(), key=lambda x: x[1][self.stats_idx])
+ candidates = sorted(bench_results.items(), key=lambda x: x[1][self.kernel_statistics_idx])
candidates = candidates[:keep_only]
while(len(candidates)>1):
step_count += 1
nruns *= 2
-
+
self._print_step(step_count, '{} BEST'.format(len(candidates)), nruns)
for (run_key, run_params) in candidates:
- (extra_params, work_load, global_work_size, local_work_size,
- _, kernel, old_stats, _, _, _, _) = run_params
+ (extra_params, work_size, work_load, global_work_size, local_work_size,
+ _, kernel, old_stats, _, _, _, _, _) = run_params
self.bench_one_from_binary(kernel=kernel,
target_nruns=nruns,
old_stats=old_stats,
best_stats=best_stats,
global_work_size=global_work_size,
local_work_size=local_work_size)
- candidates = sorted(candidates, key=lambda x: x[1][self.stats_idx])
- self._print_step_results(candidates, self.stats_idx)
+ candidates = sorted(candidates, key=lambda x: x[1][self.kernel_statistics_idx])
+ self._print_step_results(candidates, self.kernel_statistics_idx)
candidates = candidates[:max(previous_pow2(len(candidates)),1)]
+ ks.push_step(step_count, candidates)
best_candidate = candidates[0][1]
self._print_footer(ellapsed=timer.interval, best_candidate=best_candidate)
+ if autotuner_config.filter_statistics(file_basename):
+ ks.exec_time = timer.interval
+ ks.best_candidate = best_candidate
+ ks.kernel_name = self.name
+ ks.kept_count = kept_count
+ ks.pruned_count = pruned_count
+ ks.failed_count = failed_count
+ ks.total_count = total_count
+ ks.extra_kwds_hash = best_candidate[self.extra_kwds_hash_idx]
+ if autotuner_config.plot_statistics and not first_working:
+ ks.plot()
+
# Regenerate final kernel
best_candidate = list(best_candidate)
self._build_final_kernel(tkernel, best_candidate, extra_kwds)
@@ -418,10 +503,10 @@ class KernelAutotuner(object):
# Export best candidate results
if not self.STORE_FULL_KERNEL_SOURCES:
- best_candidate[self.src_idx] = None
- best_candidate[self.logs_idx] = None
- best_candidate[self.prg_idx] = None
- best_candidate[self.knl_idx] = None
+ best_candidate[self.kernel_src_idx] = None
+ best_candidate[self.extra_kwds_hash_logs_idx] = None
+ best_candidate[self.program_idx] = None
+ best_candidate[self.kernel_idx] = None
results[self.FULL_RESULTS_KEY] = best_candidate
self._dump_cache()
@@ -429,8 +514,8 @@ class KernelAutotuner(object):
def _build_final_kernel(self, tkernel, best_candidate,
extra_kwds):
- (extra_parameters, work_load, global_work_size, local_work_size,
- _, _, _, _, _, _, _) = best_candidate
+ (extra_parameters, work_size, work_load, global_work_size, local_work_size,
+ _, _, _, _, _, _, _, _) = best_candidate
global_work_size = npw.asintegerarray(global_work_size)
local_work_size = npw.asintegerarray(local_work_size)
@@ -455,11 +540,11 @@ class KernelAutotuner(object):
self.check_kernel(tkernel=tkernel, kernel=kernel,
global_work_size=global_work_size,
local_work_size=local_work_size)
-
- best_candidate[self.prg_idx] = prg
- best_candidate[self.knl_idx] = kernel
- best_candidate[self.src_idx] = kernel_src
- best_candidate[self.src_hash_idx] = src_hash
+
+ best_candidate[self.program_idx] = prg
+ best_candidate[self.kernel_idx] = kernel
+ best_candidate[self.kernel_src_idx] = kernel_src
+ best_candidate[self.src_hash_idx] = src_hash
return best_candidate
def _compute_args_list(self, args_mapping, **kernel_args):
@@ -605,7 +690,7 @@ class KernelAutotuner(object):
def _print_separator(self):
print '_'*80
- def _print_header(self):
+ def _print_header(self, extra_kwds):
verbose = self.verbose
if verbose:
self._print_separator()
@@ -614,7 +699,7 @@ class KernelAutotuner(object):
self.autotuner_config.autotuner_flag,
self.autotuner_config.nruns,
self.autotuner_config.prune_threshold,
- self.autotuner_config.max_candidates)
+ extra_kwds.get('max_candidates', self.autotuner_config.max_candidates))
print ' *build_opts: {}'.format(self.tunable_kernel.build_opts or 'None')
return verbose
@@ -696,17 +781,17 @@ class KernelAutotuner(object):
print config
- def _print_step_results(self, sorted_candidates, stats_idx):
+ def _print_step_results(self, sorted_candidates, kernel_statistics_idx):
if self.verbose==2:
best = sorted_candidates[0][1]
worst = sorted_candidates[-1][1]
- print self.indent(2)+'worst candidate: {}'.format(worst[stats_idx])
- print self.indent(2)+'best candidate: {}'.format(best[stats_idx])
+ print self.indent(2)+'worst candidate: {}'.format(worst[kernel_statistics_idx])
+ print self.indent(2)+'best candidate: {}'.format(best[kernel_statistics_idx])
def _print_footer(self, ellapsed, best_candidate):
if self.verbose:
- (best_extra_params, best_work_load, best_global_size, best_local_size,
- _, _, best_stats, _, _, _, _) = best_candidate
+ (best_extra_params, best_work_size, best_work_load, best_global_size, best_local_size,
+ _, _, best_stats, _, _, _, _, _) = best_candidate
if self.verbose>1:
if ellapsed is not None:
self._print_separator()
diff --git a/hysop/backend/device/kernel_autotuner_config.py b/hysop/backend/device/kernel_autotuner_config.py
index 9d4dd7d460b69d01f28bfcb362cfa5e3ae3e784b..ee4483e49fc367fe0adc538371c6efdff2a211a0 100644
--- a/hysop/backend/device/kernel_autotuner_config.py
+++ b/hysop/backend/device/kernel_autotuner_config.py
@@ -16,26 +16,36 @@ class KernelAutotunerConfig(object):
}
def __init__(self,
- dump_folder = None,
- autotuner_flag = None,
- prune_threshold = None,
- max_candidates = None,
- verbose = None,
- debug = None,
- dump_kernels = None,
+ dump_folder = None,
+ autotuner_flag = None,
+ prune_threshold = None,
+ max_candidates = None,
+ verbose = None,
+ debug = None,
+ dump_kernels = None,
+ dump_hash_logs = None,
generate_isolation_file = None,
- override_cache = None,
- nruns = None):
+ override_cache = None,
+ nruns = None,
+ plot_statistics = None,
+ filter_statistics = None,
+ postprocess_kernels = None,
+ postprocess_nruns = None):
dump_folder = first_not_None(dump_folder, self.default_dump_folder())
autotuner_flag = first_not_None(autotuner_flag, DEFAULT_AUTOTUNER_FLAG)
prune_threshold = first_not_None(prune_threshold, DEFAULT_AUTOTUNER_PRUNE_THRESHOLD)
- max_candidates = first_not_None(max_candidates, 4)
+ max_candidates = first_not_None(max_candidates, 1 if __KERNEL_DEBUG__ else 4)
verbose = first_not_None(verbose, 2*__VERBOSE__)
debug = first_not_None(debug, __KERNEL_DEBUG__)
- dump_kernels = first_not_None(dump_kernels, __KERNEL_DEBUG__)
+ dump_kernels = first_not_None(dump_kernels, __KERNEL_DEBUG__)
+ dump_hash_logs = first_not_None(dump_hash_logs, __KERNEL_DEBUG__)
generate_isolation_file = first_not_None(generate_isolation_file, __KERNEL_DEBUG__)
override_cache = first_not_None(override_cache, False)
+ plot_statistics = first_not_None(plot_statistics, False)
+ filter_statistics = first_not_None(filter_statistics, lambda kernel_name: True)
+ postprocess_kernels = first_not_None(postprocess_kernels, False)
+ postprocess_nruns = first_not_None(postprocess_nruns, 16)
if (nruns is None):
nruns = self._default_initial_runs[autotuner_flag]
@@ -49,6 +59,8 @@ class KernelAutotunerConfig(object):
check_instance(debug, bool)
check_instance(nruns, int)
check_instance(max_candidates, int, allow_none=True)
+ check_instance(postprocess_nruns, int)
+ assert callable(filter_statistics)
self.autotuner_flag = autotuner_flag
self.prune_threshold = prune_threshold
@@ -58,8 +70,13 @@ class KernelAutotunerConfig(object):
self.nruns = nruns
self.dump_folder = dump_folder
self.dump_kernels = dump_kernels
+ self.dump_hash_logs = dump_hash_logs
self.max_candidates = max_candidates
self.generate_isolation_file = generate_isolation_file
+ self.plot_statistics = plot_statistics
+ self.filter_statistics = filter_statistics
+ self.postprocess_kernels = postprocess_kernels
+ self.postprocess_nruns = postprocess_nruns
@abstractmethod
def default_dump_folder(self):
diff --git a/hysop/backend/device/kernel_autotuner_statistics.py b/hysop/backend/device/kernel_autotuner_statistics.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f086e2b00f60bc0b2c3838c5997c6a572477fc8
--- /dev/null
+++ b/hysop/backend/device/kernel_autotuner_statistics.py
@@ -0,0 +1,105 @@
+
+import sys
+import numpy as np
+from hysop.tools.types import check_instance
+
+class AutotunedKernelStatistics(dict):
+ class AutotunedParameterStatistics(dict):
+ class AutotunedRunStatistics(object):
+ def __init__(self,
+ work_size, work_load,
+ local_work_size, global_work_size,
+ statistics, pruned,
+ local_best, error):
+ self.work_size = work_size
+ self.work_load = work_load
+ self.local_work_size = local_work_size
+ self.global_work_size = global_work_size
+ self.statistics = statistics
+ self.pruned = pruned
+ self.local_best = local_best
+ self.error = error
+ def good(self):
+ return (self.error is None)
+ def __init__(self, extra_parameters,
+ max_kernel_work_group_size=None,
+ preferred_work_group_size_multiple=None):
+ self.extra_parameters = extra_parameters
+ self.max_kernel_work_group_size = max_kernel_work_group_size
+ self.preferred_work_group_size_multiple = preferred_work_group_size_multiple
+ def push_run_statistics(self, run_key, **kwds):
+ self[run_key] = self.AutotunedRunStatistics(**kwds)
+ def good(self):
+ return len(self)>0
+ def __init__(self, tkernel, extra_kwds):
+ self.tkernel = tkernel
+ self.extra_kwds = extra_kwds
+ self.max_candidates = None
+ self.nruns = None
+ self.exec_time = None
+ self.best_candidate = None
+ self.kernel_name = None
+ self.kept_count = None
+ self.pruned_count = None
+ self.failed_count = None
+ self.total_count = None
+ self.file_basename = None
+ self.steps = {}
+ def push_parameters(self, extra_param_hash, **kwds):
+ return self.setdefault(extra_param_hash, self.AutotunedParameterStatistics(**kwds))
+ def push_step(self, step_id, candidates):
+ self.steps[step_id] = candidates
+
+ def plot(self):
+ self.collect_exec_times()
+ self.plot_histogram()
+
+ def plot_histogram(self):
+ from matplotlib import pyplot as plt
+ run_times = self.run_times.copy()
+ for unit in ('ns', 'us', 'ms', 's'):
+ if run_times.min() < 1e2:
+ break
+ run_times*=1e-3
+ vmin, vmax, vmean = run_times.min(), run_times.max(), np.median(run_times) #.mean()
+ run_times /= np.mean(run_times)
+ vnmin, vnmax, vnmean = run_times.min(), run_times.max(), np.median(run_times) #.mean()
+ imin = int(np.floor(np.log10(vnmin)))
+ imax = int(np.ceil(np.log10(vnmax)))
+ xmin = 10.0**imin
+ xmax = 10.0**imax
+ logbins = np.geomspace(xmin, xmax, (imax-imin+1)*10)
+ fig, axe = plt.subplots()
+ fig.suptitle(self.kernel_name, weight='bold')
+ rect = plt.Rectangle( (vnmin*2,0.0), (xmax-2*vnmin), 1.0e4, alpha=0.1)
+ axe.add_patch(rect)
+ _, _, rects = axe.hist(run_times, bins=logbins)
+ h = max(r.get_height() for r in rects)
+ axe.set_title('{} configurations (kept={}, pruned={}, failed={}) over {} runs'.format(self.total_count,
+ self.kept_count, self.pruned_count, self.failed_count, self.nruns))
+ axe.set_xlim(xmin, xmax)
+ axe.set_ylim(0, int(1.05*h))
+ axe.set_xlabel('Relative performance (% of mean execution time)')
+ axe.set_ylabel('Frequency')
+ axe.set_xscale('log')
+ axe.axvline(x=vnmin, label=r'best: ${:.1f} {unit}$'.format(vmin, unit=unit), color='lime')
+ axe.axvline(x=vnmean, label=r'median: ${:.1f} {unit}$ (x{:.1f})'.format(vmean, vnmean/vnmin, unit=unit), color='darkorange')
+ axe.axvline(x=vnmax, label=r'worst: ${:.1f} {unit}$ (x{:.1f})'.format(vmax, vnmax/vnmin, unit=unit), color='r')
+ axe.legend(framealpha=1.0, title='Execution times')
+ fname = '{}/{}_histo.svg'.format(self.tkernel.autotuner_config.dump_folder, self.file_basename)
+ fig.savefig(fname, bbox_inches='tight', format='svg')
+
+ def collect_exec_times(self):
+ run_times = ()
+ for (extra_param_hash, parameter_statistics) in self.iteritems():
+ if not parameter_statistics.good():
+ continue
+ for (run_key, run_statistics) in parameter_statistics.iteritems():
+ if not run_statistics.good():
+ continue
+ run_time = run_statistics.statistics.mean
+ run_times += (run_time,)
+ #run_times += run_statistics.statistics.data[:self.nruns]
+ run_times = np.asarray(run_times, dtype=np.float64)
+ self.run_times = run_times
+
diff --git a/hysop/backend/device/kernel_config.py b/hysop/backend/device/kernel_config.py
index a029463d4a9afc5e96c57c2a43b27899d602f085..334ab9e34cbbad72498c1a64e739fda4b42f81ba 100644
--- a/hysop/backend/device/kernel_config.py
+++ b/hysop/backend/device/kernel_config.py
@@ -16,7 +16,7 @@ class KernelConfig(object):
float_dump_mode=None,
use_short_circuit_ops=None,
unroll_loops=None):
-
+
autotuner_config = first_not_None(autotuner_config, self.default_autotuner_config())
user_build_options = first_not_None(user_build_options, [])
user_size_constants = first_not_None(user_size_constants, [])
diff --git a/hysop/backend/device/kernel_statistics.py b/hysop/backend/device/kernel_statistics.py
index 45e9aa565f9f833caa889852f83cf047e47250a2..ed7484a5daf4094fa4b89fffeeb623c1defa329b 100644
--- a/hysop/backend/device/kernel_statistics.py
+++ b/hysop/backend/device/kernel_statistics.py
@@ -7,7 +7,7 @@ class KernelStatistics(object):
Execution statistics extracted from kernel events.
"""
- def __init__(self, min_, max_, total, nruns, **kwds):
+ def __init__(self, min_, max_, total, nruns, data=None, **kwds):
"""
Initialize KernelStatistics from nruns.
Statistics should be given in nanoseconds.
@@ -17,10 +17,12 @@ class KernelStatistics(object):
check_instance(max_, (int,long), allow_none=True)
check_instance(total, (int,long), allow_none=True)
check_instance(nruns, (int,long))
+ check_instance(data, (list,tuple), allow_none=True)
self._min = min_
self._max = max_
self._total = total
self._nruns = nruns
+ self._data = None if (data is None) else tuple(data)
def _get_min(self):
return self._min
@@ -33,12 +35,15 @@ class KernelStatistics(object):
return self._total
def _get_nruns(self):
return self._nruns
+ def _get_data(self):
+ return self._data
min = property(_get_min)
max = property(_get_max)
mean = property(_get_mean)
total = property(_get_total)
nruns = property(_get_nruns)
+ data = property(_get_data)
@staticmethod
def cmp(lhs,rhs):
@@ -81,11 +86,13 @@ class KernelStatistics(object):
self._min = other.min
self._max = other.max
self._total = other.total
+ self._data = tuple(other.data)
else:
+ self._min = min(self.min, other.min)
+ self._max = max(self.max, other.max)
self._nruns += other.nruns
- self._min = min(self.min, other.min)
- self._max = max(self.max, other.max)
- self._total = self.total + other.total
+ self._total += other.total
+ self._data += other.data
return self
def __str__(self):
diff --git a/hysop/backend/device/opencl/__init__.py b/hysop/backend/device/opencl/__init__.py
index f0cab904263ccf6cf22bae72903faf32ee98ada1..e63a4b7acfd8a3acad7e1ebcb18c0b0f20eefdcd 100644
--- a/hysop/backend/device/opencl/__init__.py
+++ b/hysop/backend/device/opencl/__init__.py
@@ -24,17 +24,17 @@ except ImportError:
from pyopencl import _cl as cl_api
-from hysop import __DEFAULT_PLATFORM_ID__, __DEFAULT_DEVICE_ID__
+from hysop import __DEFAULT_PLATFORM_ID__, __DEFAULT_DEVICE_ID__, __PROFILE__, get_env
from hysop.tools.io_utils import IO
from hysop.backend.device import KERNEL_DUMP_FOLDER
-OPENCL_KERNEL_DUMP_FOLDER='{}/opencl'.format(KERNEL_DUMP_FOLDER)
+OPENCL_KERNEL_DUMP_FOLDER = '{}/opencl'.format(KERNEL_DUMP_FOLDER)
"""Default opencl kernel dump folder."""
-__OPENCL_PROFILE__ = False
+__OPENCL_PROFILE__ = get_env('OPENCL_PROFILE', __PROFILE__)
"""Boolean, true to enable OpenCL profiling events to time computations"""
-## open cl underlying implementation
+# open cl underlying implementation
cl = pyopencl
"""PyOpencl module, underlying OpenCL implementation"""
@@ -59,8 +59,8 @@ clElementwise = pyopencl.elementwise
clCharacterize = pyopencl.characterize
"""PyOpenCL characterize"""
-if ('CLFFT_REQUEST_NOMEMALLOC' not in os.environ):
- os.environ['CLFFT_REQUEST_NOMEMALLOC'] = '1'
+if ('CLFFT_REQUEST_LIB_NOMEMALLOC' not in os.environ):
+ os.environ['CLFFT_REQUEST_LIB_NOMEMALLOC'] = '1'
if ('CLFFT_CACHE_PATH' not in os.environ):
os.environ['CLFFT_CACHE_PATH'] = IO.default_cache_path() + '/clfft'
if not os.path.isdir(os.environ['CLFFT_CACHE_PATH']):
@@ -69,4 +69,3 @@ if not os.path.isdir(os.environ['CLFFT_CACHE_PATH']):
except:
print("Could not create clfft cache directory '{}'.".format(
os.environ['CLFFT_CACHE_PATH']))
-
diff --git a/hysop/backend/device/opencl/autotunable_kernels/advection_dir.py b/hysop/backend/device/opencl/autotunable_kernels/advection_dir.py
index 35fff01b7c7c4180a3ba45e7e94d83675f2a9b5a..36fe61754be53042b9b0b6dba431c2c1f4d64268 100644
--- a/hysop/backend/device/opencl/autotunable_kernels/advection_dir.py
+++ b/hysop/backend/device/opencl/autotunable_kernels/advection_dir.py
@@ -134,7 +134,7 @@ class OpenClAutotunableDirectionalAdvectionKernel(OpenClAutotunableKernel):
## Register extra parameters
autotuner_flag = self.autotuner_config.autotuner_flag
- caching_options = [True, False]
+ caching_options = [True]
if (autotuner_flag == AutotunerFlags.ESTIMATE):
max_workitem_workload = [1,1,1]
nparticles_options = [1]
@@ -142,10 +142,10 @@ class OpenClAutotunableDirectionalAdvectionKernel(OpenClAutotunableKernel):
max_workitem_workload = [1,4,1]
nparticles_options = [1,2,4]
elif (autotuner_flag == AutotunerFlags.PATIENT):
- max_workitem_workload = [1,8,8]
+ max_workitem_workload = [1,8,1]
nparticles_options = [1,2,4,8,16]
elif (autotuner_flag == AutotunerFlags.EXHAUSTIVE):
- max_workitem_workload = [1,16,16]
+ max_workitem_workload = [1,8,8]
nparticles_options = [1,2,4,8,16]
if (extra_kwds['is_bilevel'] is not None):
diff --git a/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py b/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py
index 884c1f3446853d28d32143b8e99dbf160b8d0976..9831ca86cb40d7ae8726f049af77d9fd1a1b1965 100644
--- a/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py
+++ b/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py
@@ -7,7 +7,7 @@ from hysop.tools.misc import upper_pow2_or_3
from hysop.constants import AutotunerFlags, BoundaryCondition, SymbolicExpressionKind
from hysop.numerics.remesh.remesh import RemeshKernel
from hysop.fields.cartesian_discrete_field import CartesianDiscreteScalarFieldView
-from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer
+from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer
from hysop.fields.discrete_field import DiscreteScalarFieldView
from hysop.backend.device.codegen import CodeGeneratorWarning
@@ -153,7 +153,7 @@ class OpenClAutotunableCustomSymbolicKernel(OpenClAutotunableKernel):
isolation_params[vname+'_base'] = dict(count=dfield.npoints,
dtype=dfield.dtype, fill=i)
elif isinstance(obj, di.SimpleCounterTypes):
- assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer)), type(obj)
+ assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)), type(obj)
if (counts==0):
continue
if (obj in di.write_counter) and (di.write_counter[obj]>0):
@@ -185,7 +185,7 @@ class OpenClAutotunableCustomSymbolicKernel(OpenClAutotunableKernel):
isolation_params[vname+'_base'] = dict(count=dfield.npoints,
dtype=dfield.dtype, fill=i)
elif isinstance(obj, di.SimpleCounterTypes):
- assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer)), type(obj)
+ assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)), type(obj)
vname = obj.varname
kernel_args[vname+'_base'] = obj.base_data
target_stride_args[vname+'_strides'] = make_strides(obj.strides, obj.dtype)
@@ -281,7 +281,7 @@ class OpenClAutotunableCustomSymbolicKernel(OpenClAutotunableKernel):
args_mapping[vname+'_offset'] = (arg_index, offset_dtype)
arg_index += 1
elif isinstance(obj, di.SimpleCounterTypes):
- assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer)), type(obj)
+ assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)), type(obj)
if (counts==0):
continue
if (obj in di.write_counter) and (di.write_counter[obj]>0):
@@ -316,7 +316,7 @@ class OpenClAutotunableCustomSymbolicKernel(OpenClAutotunableKernel):
args_mapping[vname+'_offset'] = (arg_index, offset_dtype)
arg_index += 1
elif isinstance(obj, di.SimpleCounterTypes):
- assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer)), type(obj)
+ assert isinstance(obj, (OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer)), type(obj)
if (counts==0):
continue
vname = obj.varname
diff --git a/hysop/backend/device/opencl/autotunable_kernels/remesh_dir.py b/hysop/backend/device/opencl/autotunable_kernels/remesh_dir.py
index aee89fd51eec7d32aa3a147e85fdaf8a78eb8911..4f92191c477f63c9b5f83ac01799983ec7cfb07a 100644
--- a/hysop/backend/device/opencl/autotunable_kernels/remesh_dir.py
+++ b/hysop/backend/device/opencl/autotunable_kernels/remesh_dir.py
@@ -1,10 +1,10 @@
-
from hysop.deps import warnings
from hysop.tools.numpywrappers import npw
from hysop.tools.types import check_instance
from hysop.tools.misc import upper_pow2_or_3
from hysop.constants import AutotunerFlags, BoundaryCondition
from hysop.numerics.remesh.remesh import RemeshKernel
+from hysop.numerics.remesh.kernel_generator import Kernel
from hysop.fields.cartesian_discrete_field import CartesianDiscreteScalarFieldView
from hysop.backend.device.codegen import CodeGeneratorWarning
@@ -15,16 +15,17 @@ from hysop.backend.device.opencl.opencl_array import OpenClArray
from hysop.backend.device.opencl.opencl_autotunable_kernel import OpenClAutotunableKernel
from hysop.backend.device.kernel_autotuner import KernelGenerationError
+
class OpenClAutotunableDirectionalRemeshKernel(OpenClAutotunableKernel):
"""Autotunable interface for directional remeshing kernel code generators."""
- def autotune(self, direction, scalar_cfl,
- position, scalars_in, scalars_out, is_inplace,
- remesh_kernel, remesh_criteria_eps,
- force_atomics, relax_min_particles,
- hardcode_arrays, **kwds):
+ def autotune(self, direction, scalar_cfl,
+ position, scalars_in, scalars_out, is_inplace,
+ remesh_kernel, remesh_criteria_eps,
+ force_atomics, relax_min_particles,
+ hardcode_arrays, **kwds):
"""Autotune this kernel with specified configuration.
-
+
hardcode_arrays means that array offset and strides can be hardcoded
into the kernels as constants.
"""
@@ -32,152 +33,153 @@ class OpenClAutotunableDirectionalRemeshKernel(OpenClAutotunableKernel):
check_instance(scalars_out, tuple, values=CartesianDiscreteScalarFieldView)
precision = self.typegen.dtype
-
+
dim = position.dim
if not (1 <= dim <= 3):
- msg='Dimension mismatch {}.'.format(dim)
+ msg = 'Dimension mismatch {}.'.format(dim)
raise ValueError(msg)
if not (0 <= direction < dim):
- msg='Invalid direction {}.'.format(direction)
+ msg = 'Invalid direction {}.'.format(direction)
raise ValueError(msg)
if not issubclass(precision, npw.floating):
- msg='Precision is not a npw.floating subtype, got {}.'.format(precision)
+ msg = 'Precision is not a npw.floating subtype, got {}.'.format(precision)
raise TypeError(msg)
- if not isinstance(scalar_cfl, float) or scalar_cfl<=0.0:
- msg='Invalid scalar_cfl value {}.'.format(scalar_cfl)
+ if not isinstance(scalar_cfl, float) or scalar_cfl <= 0.0:
+ msg = 'Invalid scalar_cfl value {}.'.format(scalar_cfl)
raise ValueError(msg)
- if len(scalars_in)!=len(scalars_out):
+ if len(scalars_in) != len(scalars_out):
raise ValueError('Unmatched scalars input/output.')
- if not isinstance(remesh_kernel, RemeshKernel):
- msg='Invalid remesh_kernel type {}.'.format(type(remesh_kernel))
+ if not isinstance(remesh_kernel, RemeshKernel) and not isinstance(remesh_kernel, Kernel):
+ msg = 'Invalid remesh_kernel type {}.'.format(type(remesh_kernel))
raise TypeError(msg)
if (remesh_criteria_eps is not None) and \
- (not isinstance(remesh_criteria_eps, float) or \
- (remesh_criteria_eps<0.0)):
- msg='Invalid remesh_criteria_eps value {}.'.format(remesh_criteria_eps)
+ (not isinstance(remesh_criteria_eps, float) or
+ (remesh_criteria_eps < 0.0)):
+ msg = 'Invalid remesh_criteria_eps value {}.'.format(remesh_criteria_eps)
raise ValueError(msg)
if not isinstance(force_atomics, bool):
- msg='Invalid force_atomics value {}, should be a boolean.'
- msg=msg.format(force_atomics)
+ msg = 'Invalid force_atomics value {}, should be a boolean.'
+ msg = msg.format(force_atomics)
raise ValueError(msg)
if not isinstance(relax_min_particles, bool):
- msg='Invalid relax_min_particles value {}, should be a boolean.'
- msg=msg.format(relax_min_particles)
+ msg = 'Invalid relax_min_particles value {}, should be a boolean.'
+ msg = msg.format(relax_min_particles)
raise ValueError(msg)
if (force_atomics and relax_min_particles):
- msg= 'Cannot relax min particles when force_atomics is set because '
- msg+='there is no minimum particles to be used when using atomic accumulators.'
+ msg = 'Cannot relax min particles when force_atomics is set because '
+ msg += 'there is no minimum particles to be used when using atomic accumulators.'
raise ValueError(msg)
if (position.dtype != precision):
- #TODO implement mixed precision kernels
- msg='Array type for position {} do not match required operator precision {}.'
- msg=msg.format(position.dtype, precision.__name__)
+ # TODO implement mixed precision kernels
+ msg = 'Array type for position {} do not match required operator precision {}.'
+ msg = msg.format(position.dtype, precision.__name__)
raise NotImplementedError(msg)
-
- pshape = position.compute_resolution
- work_size = npw.asarray(pshape, dtype=npw.int32).copy()
- work_dim = work_size.size
+
+ pshape = position.compute_resolution
+ work_size = npw.asarray(pshape, dtype=npw.int32).copy()
+ work_dim = work_size.size
group_scalars = tuple(dfield.nb_components for dfield in scalars_in)
- nfields = len(group_scalars)
- nscalars = sum(group_scalars)
- ftype = clTools.dtype_to_ctype(precision)
-
+ nfields = len(group_scalars)
+ nscalars = sum(group_scalars)
+ ftype = clTools.dtype_to_ctype(precision)
+
min_s_ghosts = DirectionalRemeshKernelGenerator.scalars_out_cache_ghosts(scalar_cfl,
- remesh_kernel)
-
+ remesh_kernel)
+
min_nparticles = 2 if relax_min_particles else int(2*npw.ceil(scalar_cfl))
-
- assert (min_s_ghosts>=1)
- assert (min_nparticles>=2)
-
+
+ assert (min_s_ghosts >= 1)
+ assert (min_nparticles >= 2)
+
name = DirectionalRemeshKernelGenerator.codegen_name(work_dim, remesh_kernel,
- ftype, min_nparticles, nscalars, remesh_criteria_eps, False, is_inplace)
+ ftype, min_nparticles, nscalars, remesh_criteria_eps, False, is_inplace)
for dsin, dsout in zip(scalars_in, scalars_out):
if (dsin.nb_components != dsout.nb_components):
- msg='Components mismatch between input field {} and output field {}, '
- msg+='got input={}, output={}, cannot remesh.'
- msg=msg.format(dsin.name, dsout.name, dsin.nb_components, dsout.nb_components)
+ msg = 'Components mismatch between input field {} and output field {}, '
+ msg += 'got input={}, output={}, cannot remesh.'
+ msg = msg.format(dsin.name, dsout.name, dsin.nb_components, dsout.nb_components)
raise ValueError(msg)
if (dsin.compute_resolution != pshape).any() or \
(dsout.compute_resolution != pshape).any():
- msg='Resolution mismatch between particles and scalars, '
- msg+='got input={}, output={} but pshape={}, cannot remesh.'
- msg=msg.format(dsin.compute_resolution, dsout.compute_resolution, pshape)
+ msg = 'Resolution mismatch between particles and scalars, '
+ msg += 'got input={}, output={} but pshape={}, cannot remesh.'
+ msg = msg.format(dsin.compute_resolution, dsout.compute_resolution, pshape)
raise ValueError(msg)
if (dsout.ghosts[-1] < min_s_ghosts):
- msg= 'Given boundary condition implies minimum ghosts numbers to be at '
- msg+='least {} in remeshed direction for output scalar but only {} ghosts '
- msg+='are present in the grid for output scalar {}.'
- msg=msg.format(min_s_ghosts, dsout.ghosts[-1], dsout.name)
+ msg = 'Given boundary condition implies minimum ghosts numbers to be at '
+ msg += 'least {} in remeshed direction for output scalar but only {} ghosts '
+ msg += 'are present in the grid for output scalar {}.'
+ msg = msg.format(min_s_ghosts, dsout.ghosts[-1], dsout.name)
raise ValueError(msg)
- if is_inplace and (dsin.dfield !=dsout.dfield):
- msg='Remeshing inplace but input and output discrete Field differs '
- msg+='for {} and {}.'.format(dsin.name, dsout.name)
+ if is_inplace and (dsin.dfield != dsout.dfield):
+ msg = 'Remeshing inplace but input and output discrete Field differs '
+ msg += 'for {} and {}.'.format(dsin.name, dsout.name)
raise ValueError(msg)
- if (dsin.dtype != precision) or (dsout.dtype!=precision):
- #TODO implement mixed precision kernels
- msg='Array types ({}={}, {}={}) do not match required operator precision {}.'
- msg=msg.format(dsin.name, dsin.dtype, dsout.name, dsout.dtype, precision.__name__)
+ if (dsin.dtype != precision) or (dsout.dtype != precision):
+ # TODO implement mixed precision kernels
+ msg = 'Array types ({}={}, {}={}) do not match required operator precision {}.'
+ msg = msg.format(dsin.name, dsin.dtype, dsout.name, dsout.dtype, precision.__name__)
raise NotImplementedError(msg)
-
+
make_offset, offset_dtype = self.make_array_offset()
- make_strides, strides_dtype = self.make_array_strides(position.dim,
- hardcode_arrays=hardcode_arrays)
-
+ make_strides, strides_dtype = self.make_array_strides(position.dim,
+ hardcode_arrays=hardcode_arrays)
+
kernel_args = {}
known_args = {}
isolation_params = {}
mesh_info_vars = {}
target_args = known_args if hardcode_arrays else kernel_args
- kernel_args['position_base'] = position.sdata.base_data
+ kernel_args['position_base'] = position.sdata.base_data
target_args['position_strides'] = make_strides(position.sdata.strides, position.dtype)
- target_args['position_offset'] = make_offset(position.sdata.offset, position.dtype)
+ target_args['position_offset'] = make_offset(position.sdata.offset, position.dtype)
mesh_info_vars['position_mesh_info'] = \
- self.mesh_info('position_mesh_info', position.mesh)
- isolation_params['position_base'] = dict(count=position.npoints,
- dtype=position.dtype, arg_value=position.sbuffer.get())
+ self.mesh_info('position_mesh_info', position.mesh)
+ isolation_params['position_base'] = dict(count=position.npoints,
+ dtype=position.dtype, arg_value=position.sbuffer.get())
arg_index = 1 + 2*(1-hardcode_arrays)
if is_inplace:
- for (i,dsinout) in enumerate(scalars_in):
+ for (i, dsinout) in enumerate(scalars_in):
mi = 'S{}_inout_mesh_info'.format(i)
mesh_info_vars[mi] = self.mesh_info(mi, dsinout.mesh)
for j in xrange(dsinout.nb_components):
- prefix = 'S{}_{}_inout'.format(i,j)
- kernel_args[prefix+'_base'] = dsinout.data[j].base_data
- target_args[prefix+'_strides'] = make_strides(dsinout.data[j].strides,
- dsinout.dtype)
- target_args[prefix+'_offset'] = make_offset(dsinout.data[j].offset,
- dsinout.dtype)
- isolation_params[prefix+'_base'] = dict(count=dsinout.data[j].size,
- dtype=dsinout.dtype, fill=10*i+j)
+ prefix = 'S{}_{}_inout'.format(i, j)
+ kernel_args[prefix+'_base'] = dsinout.data[j].base_data
+ target_args[prefix+'_strides'] = make_strides(dsinout.data[j].strides,
+ dsinout.dtype)
+ target_args[prefix+'_offset'] = make_offset(dsinout.data[j].offset,
+ dsinout.dtype)
+ isolation_params[prefix+'_base'] = dict(count=dsinout.data[j].size,
+ dtype=dsinout.dtype, fill=10*i+j)
arg_index += 1 + 2*(1-hardcode_arrays)
assert i == nfields-1
else:
- for (i,dsin) in enumerate(scalars_in):
+ for (i, dsin) in enumerate(scalars_in):
mi = 'S{}_in_mesh_info'.format(i)
mesh_info_vars[mi] = self.mesh_info(mi, dsin.mesh)
for j in xrange(dsin.nb_components):
- prefix = 'S{}_{}_in'.format(i,j)
- kernel_args[prefix+'_base'] = dsin.data[j].base_data
+ prefix = 'S{}_{}_in'.format(i, j)
+ kernel_args[prefix+'_base'] = dsin.data[j].base_data
target_args[prefix+'_strides'] = make_strides(dsin.data[j].strides, dsin.dtype)
- target_args[prefix+'_offset'] = make_offset(dsin.data[j].offset, dsin.dtype)
- isolation_params[prefix+'_base'] = dict(count=dsin.data[j].size,
- dtype=dsin.dtype, fill=10*i+j)
+ target_args[prefix+'_offset'] = make_offset(dsin.data[j].offset, dsin.dtype)
+ isolation_params[prefix+'_base'] = dict(count=dsin.data[j].size,
+ dtype=dsin.dtype, fill=10*i+j)
arg_index += 1 + 2*(1-hardcode_arrays)
assert i == nfields-1
- for (i,dsout) in enumerate(scalars_out):
+ for (i, dsout) in enumerate(scalars_out):
mi = 'S{}_out_mesh_info'.format(i)
mesh_info_vars[mi] = self.mesh_info(mi, dsout.mesh)
for j in xrange(dsout.nb_components):
- prefix = 'S{}_{}_out'.format(i,j)
- kernel_args[prefix+'_base'] = dsout.data[j].base_data
- target_args[prefix+'_strides'] = make_strides(dsout.data[j].strides, dsout.dtype)
- target_args[prefix+'_offset'] = make_offset(dsout.data[j].offset, dsout.dtype)
- isolation_params[prefix+'_base'] = dict(count=dsout.data[j].size,
- dtype=dsout.dtype, fill=0)
+ prefix = 'S{}_{}_out'.format(i, j)
+ kernel_args[prefix+'_base'] = dsout.data[j].base_data
+ target_args[prefix +
+ '_strides'] = make_strides(dsout.data[j].strides, dsout.dtype)
+ target_args[prefix+'_offset'] = make_offset(dsout.data[j].offset, dsout.dtype)
+ isolation_params[prefix+'_base'] = dict(count=dsout.data[j].size,
+ dtype=dsout.dtype, fill=0)
arg_index += 1 + 2*(1-hardcode_arrays)
assert i == nfields-1
assert len(kernel_args) == arg_index
@@ -185,17 +187,16 @@ class OpenClAutotunableDirectionalRemeshKernel(OpenClAutotunableKernel):
assert arg_index == (1+2*(1-hardcode_arrays))*(1+(2-is_inplace)*nscalars)
return super(OpenClAutotunableDirectionalRemeshKernel, self).autotune(name=name,
- position=position, scalars_in=scalars_in, scalars_out=scalars_out,
- is_inplace=is_inplace, min_s_ghosts=min_s_ghosts,
- precision=precision, nscalars=nscalars, group_scalars=group_scalars,
- remesh_kernel=remesh_kernel, remesh_criteria_eps=remesh_criteria_eps,
- force_atomics=force_atomics, min_nparticles=min_nparticles, ftype=ftype,
- scalar_cfl=scalar_cfl, kernel_args=kernel_args, mesh_info_vars=mesh_info_vars,
- work_dim=work_dim, work_size=work_size,
- known_args=known_args, hardcode_arrays=hardcode_arrays,
- offset_dtype=offset_dtype, strides_dtype=strides_dtype,
- isolation_params=isolation_params, **kwds)
-
+ position=position, scalars_in=scalars_in, scalars_out=scalars_out,
+ is_inplace=is_inplace, min_s_ghosts=min_s_ghosts,
+ precision=precision, nscalars=nscalars, group_scalars=group_scalars,
+ remesh_kernel=remesh_kernel, remesh_criteria_eps=remesh_criteria_eps,
+ force_atomics=force_atomics, min_nparticles=min_nparticles, ftype=ftype,
+ scalar_cfl=scalar_cfl, kernel_args=kernel_args, mesh_info_vars=mesh_info_vars,
+ work_dim=work_dim, work_size=work_size,
+ known_args=known_args, hardcode_arrays=hardcode_arrays,
+ offset_dtype=offset_dtype, strides_dtype=strides_dtype,
+ isolation_params=isolation_params, **kwds)
def compute_args_mapping(self, extra_kwds, extra_parameters):
"""
@@ -206,87 +207,86 @@ class OpenClAutotunableDirectionalRemeshKernel(OpenClAutotunableKernel):
arg_position being an int and arg_type(s) a type or
tuple of types which will be checked against.
"""
-
- is_inplace = extra_kwds['is_inplace']
- scalars_in = extra_kwds['scalars_in']
- scalars_out = extra_kwds['scalars_out']
- nscalars = extra_kwds['nscalars']
- strides_dtype = extra_kwds['strides_dtype']
- offset_dtype = extra_kwds['offset_dtype']
+
+ is_inplace = extra_kwds['is_inplace']
+ scalars_in = extra_kwds['scalars_in']
+ scalars_out = extra_kwds['scalars_out']
+ nscalars = extra_kwds['nscalars']
+ strides_dtype = extra_kwds['strides_dtype']
+ offset_dtype = extra_kwds['offset_dtype']
hardcode_arrays = extra_kwds['hardcode_arrays']
-
+
args_mapping = {}
arg_index = 0
args_mapping['position_base'] = (0, cl.MemoryObjectHolder)
arg_index += 1
if not hardcode_arrays:
- args_mapping['position_strides'] = (1, strides_dtype)
- args_mapping['position_offset'] = (2, offset_dtype)
+ args_mapping['position_strides'] = (1, strides_dtype)
+ args_mapping['position_offset'] = (2, offset_dtype)
arg_index += 2
if is_inplace:
- for (i,dsinout) in enumerate(scalars_in):
+ for (i, dsinout) in enumerate(scalars_in):
for j in xrange(dsinout.nb_components):
- prefix = 'S{}_{}_inout'.format(i,j)
+ prefix = 'S{}_{}_inout'.format(i, j)
args_mapping[prefix+'_base'] = (arg_index, cl.MemoryObjectHolder)
- arg_index+=1
+ arg_index += 1
if not hardcode_arrays:
args_mapping[prefix+'_strides'] = (arg_index+0, strides_dtype)
- args_mapping[prefix+'_offset'] = (arg_index+1, offset_dtype)
+ args_mapping[prefix+'_offset'] = (arg_index+1, offset_dtype)
arg_index += 2
else:
- for (i,dsin) in enumerate(scalars_in):
+ for (i, dsin) in enumerate(scalars_in):
for j in xrange(dsin.nb_components):
- prefix = 'S{}_{}_in'.format(i,j)
- args_mapping[prefix+'_base'] = (arg_index, cl.MemoryObjectHolder)
+ prefix = 'S{}_{}_in'.format(i, j)
+ args_mapping[prefix+'_base'] = (arg_index, cl.MemoryObjectHolder)
arg_index += 1
if not hardcode_arrays:
args_mapping[prefix+'_strides'] = (arg_index+0, strides_dtype)
- args_mapping[prefix+'_offset'] = (arg_index+1, offset_dtype)
+ args_mapping[prefix+'_offset'] = (arg_index+1, offset_dtype)
arg_index += 2
- for (i,dsout) in enumerate(scalars_out):
+ for (i, dsout) in enumerate(scalars_out):
for j in xrange(dsout.nb_components):
- prefix = 'S{}_{}_out'.format(i,j)
- args_mapping[prefix+'_base'] = (arg_index, cl.MemoryObjectHolder)
+ prefix = 'S{}_{}_out'.format(i, j)
+ args_mapping[prefix+'_base'] = (arg_index, cl.MemoryObjectHolder)
arg_index += 1
if not hardcode_arrays:
args_mapping[prefix+'_strides'] = (arg_index+0, strides_dtype)
- args_mapping[prefix+'_offset'] = (arg_index+1, offset_dtype)
+ args_mapping[prefix+'_offset'] = (arg_index+1, offset_dtype)
arg_index += 2
- assert len(args_mapping)==arg_index
+ assert len(args_mapping) == arg_index
assert arg_index == (1+2*(1-hardcode_arrays))*(1+(2-is_inplace)*nscalars)
return args_mapping
-
- def compute_parameters(self, extra_kwds):
+ def compute_parameters(self, extra_kwds):
"""Register extra parameters to optimize."""
check_instance(extra_kwds, dict, keys=str)
- ftype = extra_kwds['ftype']
- work_dim = extra_kwds['work_dim']
- precision = extra_kwds['precision']
+ ftype = extra_kwds['ftype']
+ work_dim = extra_kwds['work_dim']
+ precision = extra_kwds['precision']
force_atomics = extra_kwds['force_atomics']
- nparticles_options = [1,2,4,8,16]
+ nparticles_options = [1, 2, 4, 8, 16]
use_atomics_options = [True] if force_atomics else [True, False]
if True in use_atomics_options:
cl_env = self.cl_env
- msg=None
+ msg = None
if ftype == 'float':
if not cl_env.has_extension('cl_khr_local_int32_base_atomics'):
- msg='OpenCL device {} does not support int32 atomics '
- msg+='(cl_khr_local_int32_base_atomics).'
- msg=msg.format(cl_env.device.name)
+ msg = 'OpenCL device {} does not support int32 atomics '
+ msg += '(cl_khr_local_int32_base_atomics).'
+ msg = msg.format(cl_env.device.name)
elif ftype == 'double':
if not cl_env.has_extension('cl_khr_int64_base_atomics'):
- msg='OpenCL device {} does not support int64 atomics '
- msg+='(cl_khr_int64_base_atomics).'
- msg=msg.format(cl_env.device.name)
+ msg = 'OpenCL device {} does not support int64 atomics '
+ msg += '(cl_khr_int64_base_atomics).'
+ msg = msg.format(cl_env.device.name)
else:
msg = 'Atomic remeshing kernel has not been implemented for '
- msg+= '{} yet.'.format(precision)
+ msg += '{} yet.'.format(precision)
if msg:
if force_atomics:
@@ -297,113 +297,112 @@ class OpenClAutotunableDirectionalRemeshKernel(OpenClAutotunableKernel):
msg += '\nAtomic version of the remeshing kernel will be disabled.'
warnings.warn(msg, CodeGeneratorWarning)
use_atomics_options.remove(True)
-
+
autotuner_flag = self.autotuner_config.autotuner_flag
if (autotuner_flag == AutotunerFlags.ESTIMATE):
if True in use_atomics_options:
use_atomics_options.pop(False)
- max_workitem_workload = [1,1,1]
+ max_workitem_workload = [1, 1, 1]
elif (autotuner_flag == AutotunerFlags.MEASURE):
- max_workitem_workload = [1,8,1]
+ max_workitem_workload = [1, 8, 1]
elif (autotuner_flag == AutotunerFlags.PATIENT):
- max_workitem_workload = [1,8,8]
+ max_workitem_workload = [1, 8, 8]
elif (autotuner_flag == AutotunerFlags.EXHAUSTIVE):
- max_workitem_workload = [1,16,16]
+ max_workitem_workload = [1, 16, 16]
max_workitem_workload = npw.asarray(max_workitem_workload[:work_dim])
extra_kwds['max_work_load'] = max_workitem_workload
-
+
params = super(OpenClAutotunableDirectionalRemeshKernel, self).compute_parameters(
- extra_kwds=extra_kwds)
+ extra_kwds=extra_kwds)
params.register_extra_parameter('use_atomics', use_atomics_options)
params.register_extra_parameter('nparticles', nparticles_options)
return params
-
+
def compute_min_max_wg_size(self, work_bounds, work_load, global_work_size,
- extra_parameters, extra_kwds):
+ extra_parameters, extra_kwds):
"""Default min and max workgroup size."""
cache_ghosts = extra_kwds['min_s_ghosts']
- min_wg_size = npw.ones(shape=work_bounds.work_dim, dtype=npw.int32)
+ min_wg_size = npw.ones(shape=work_bounds.work_dim, dtype=npw.int32)
min_wg_size[0] = max(min_wg_size[0], 2*cache_ghosts)
max_wg_size = npw.ones(shape=work_bounds.work_dim, dtype=npw.int32)
max_wg_size[0] = max(global_work_size[0], min_wg_size[0])
return (min_wg_size, max_wg_size)
-
+
def compute_global_work_size(self, local_work_size, work, extra_parameters, extra_kwds):
gs = super(OpenClAutotunableDirectionalRemeshKernel, self).compute_global_work_size(
- local_work_size=local_work_size, work=work,
- extra_parameters=extra_parameters, extra_kwds=extra_kwds)
+ local_work_size=local_work_size, work=work,
+ extra_parameters=extra_parameters, extra_kwds=extra_kwds)
gs[0] = local_work_size[0]
return gs
def generate_kernel_src(self, global_work_size, local_work_size,
- extra_parameters, extra_kwds, tuning_mode, dry_run):
+ extra_parameters, extra_kwds, tuning_mode, dry_run):
"""Generate kernel name and source code"""
- ## Extract usefull variables
- ftype = extra_kwds['ftype']
- work_dim = extra_kwds['work_dim']
- nscalars = extra_kwds['nscalars']
- known_args = extra_kwds['known_args']
- is_inplace = extra_kwds['is_inplace']
- scalar_cfl = extra_kwds['scalar_cfl']
- remesh_kernel = extra_kwds['remesh_kernel']
- group_scalars = extra_kwds['group_scalars']
- mesh_info_vars = extra_kwds['mesh_info_vars']
- min_nparticles = extra_kwds['min_nparticles']
+ # Extract usefull variables
+ ftype = extra_kwds['ftype']
+ work_dim = extra_kwds['work_dim']
+ nscalars = extra_kwds['nscalars']
+ known_args = extra_kwds['known_args']
+ is_inplace = extra_kwds['is_inplace']
+ scalar_cfl = extra_kwds['scalar_cfl']
+ remesh_kernel = extra_kwds['remesh_kernel']
+ group_scalars = extra_kwds['group_scalars']
+ mesh_info_vars = extra_kwds['mesh_info_vars']
+ min_nparticles = extra_kwds['min_nparticles']
remesh_criteria_eps = extra_kwds['remesh_criteria_eps']
- ## Extract and check parameters
- nparticles = extra_parameters['nparticles']
+ # Extract and check parameters
+ nparticles = extra_parameters['nparticles']
use_atomics = extra_parameters['use_atomics']
if (not use_atomics) and (nparticles < min_nparticles):
- msg='Insufficient number of particles, min={}, got {}.'
- msg=msg.format(min_nparticles, nparticles)
+ msg = 'Insufficient number of particles, min={}, got {}.'
+ msg = msg.format(min_nparticles, nparticles)
raise KernelGenerationError(msg)
- ## Get compile time OpenCL known variables
+ # Get compile time OpenCL known variables
known_vars = super(OpenClAutotunableDirectionalRemeshKernel, self).generate_kernel_src(
- global_work_size=global_work_size,
- local_work_size=local_work_size,
- extra_parameters=extra_parameters,
- extra_kwds=extra_kwds, tuning_mode=tuning_mode, dry_run=dry_run)
+ global_work_size=global_work_size,
+ local_work_size=local_work_size,
+ extra_parameters=extra_parameters,
+ extra_kwds=extra_kwds, tuning_mode=tuning_mode, dry_run=dry_run)
known_vars.update(mesh_info_vars)
known_vars.update(known_args)
-
+
# disable periodic-periodic because we exchange ghosts anyways
sboundaries = (BoundaryCondition.NONE, BoundaryCondition.NONE,)
-
- ## Generate OpenCL source code
- codegen = DirectionalRemeshKernelGenerator(typegen=self.typegen,
- work_dim=work_dim, ftype=ftype,
- nparticles=nparticles, nscalars=nscalars,
- sboundary=sboundaries, is_inplace=is_inplace,
- scalar_cfl=scalar_cfl, remesh_kernel=remesh_kernel,
- group_scalars=group_scalars,
- remesh_criteria_eps=remesh_criteria_eps,
- use_atomics = use_atomics,
- symbolic_mode = self.symbolic_mode,
- tuning_mode = tuning_mode,
- debug_mode = False,
- known_vars = known_vars)
-
+
+ # Generate OpenCL source code
+ codegen = DirectionalRemeshKernelGenerator(typegen=self.typegen,
+ work_dim=work_dim, ftype=ftype,
+ nparticles=nparticles, nscalars=nscalars,
+ sboundary=sboundaries, is_inplace=is_inplace,
+ scalar_cfl=scalar_cfl, remesh_kernel=remesh_kernel,
+ group_scalars=group_scalars,
+ remesh_criteria_eps=remesh_criteria_eps,
+ use_atomics=use_atomics,
+ symbolic_mode=self.symbolic_mode,
+ tuning_mode=tuning_mode,
+ debug_mode=False,
+ known_vars=known_vars)
+
kernel_name = codegen.name
- kernel_src = str(codegen)
+ kernel_src = str(codegen)
- ## Check if cache would fit
+ # Check if cache would fit
if (local_work_size is not None):
self.check_cache(codegen.required_workgroup_cache_size(local_work_size)[2])
return (kernel_name, kernel_src)
-
+
def hash_extra_kwds(self, extra_kwds):
"""Hash extra_kwds dictionnary for caching purposes."""
- kwds = ('remesh_criteria_eps', 'nscalars', 'ftype',
+ kwds = ('remesh_criteria_eps', 'nscalars', 'ftype',
'is_inplace', 'remesh_kernel', 'work_size',
'known_args')
- return self.custom_hash(*tuple(extra_kwds[kwd] for kwd in kwds),
- mesh_info_vars=extra_kwds['mesh_info_vars'])
-
+ return self.custom_hash(*tuple(extra_kwds[kwd] for kwd in kwds),
+ mesh_info_vars=extra_kwds['mesh_info_vars'])
diff --git a/hysop/backend/device/opencl/autotunable_kernels/transpose.py b/hysop/backend/device/opencl/autotunable_kernels/transpose.py
index 5a040be34a49a0d9021c8d83cb3297c6c267cde4..1dbd3fdb78a802c946817ba22653ef3b891f0d63 100644
--- a/hysop/backend/device/opencl/autotunable_kernels/transpose.py
+++ b/hysop/backend/device/opencl/autotunable_kernels/transpose.py
@@ -1,4 +1,7 @@
+import math
+import itertools as it
+
from hysop.tools.numpywrappers import npw
from hysop.tools.types import check_instance
from hysop.tools.misc import upper_pow2, previous_pow2, upper_pow2_or_3
@@ -12,13 +15,18 @@ from hysop.backend.device.kernel_autotuner import KernelGenerationError
class OpenClAutotunableTransposeKernel(OpenClAutotunableKernel):
"""Autotunable interface for transpose kernel code generators."""
- def _max_tile_size(self, shape, dtype, tile_indexes):
+ def _max_tile_size(self, shape, dtype, tile_indexes, is_inplace):
"""Compute max tile size that will fit in device cache."""
nbytes = dtype.itemsize
- max_cache_elems = int(self.usable_cache_bytes_per_wg / nbytes)
+ factor = 2.0 if is_inplace else 1.0
+ max_cache_elems = int(self.usable_cache_bytes_per_wg / (factor*nbytes))
if len(tile_indexes)==2:
- max_ts_cache = int(npw.sqrt(max_cache_elems))/2
+ x = int(npw.sqrt(max_cache_elems))
+ #while x*(x+1) > max_cache_elems:
+ #x-=1
+ # tile offsetting will just trigger the usual cache exception
+ max_ts_cache = x
else:
# no cache is used
max_ts_cache = npw.inf
@@ -27,7 +35,7 @@ class OpenClAutotunableTransposeKernel(OpenClAutotunableKernel):
max_ts_shape = max(tile_shape)
max_tile_size = min(max_ts_cache, max_ts_shape)
- return upper_pow2(max_tile_size)
+ return max_tile_size
def autotune(self, is_inplace,
input_buffer, output_buffer,
@@ -132,8 +140,8 @@ class OpenClAutotunableTransposeKernel(OpenClAutotunableKernel):
tile_indices = extra_kwds['tile_indices']
dtype = extra_kwds['dtype']
shape = extra_kwds['shape']
+ is_inplace = extra_kwds['is_inplace']
last_axe_permuted = extra_kwds['last_axe_permuted']
- max_tile_size = self._max_tile_size(shape, dtype, tile_indices)
flag = self.autotuner_config.autotuner_flag
vectorization = (1,)
@@ -142,21 +150,14 @@ class OpenClAutotunableTransposeKernel(OpenClAutotunableKernel):
use_diagonal_coordinates += (True,)
tile_padding = (0,1,)
- tile_sizes = (max_tile_size,)
- tile_size = max_tile_size
- while tile_size>1:
- tile_size = previous_pow2(tile_size)
- tile_sizes += (tile_size,)
- if flag == AutotunerFlags.ESTIMATE:
- ntiles = 1
- elif flag == AutotunerFlags.MEASURE:
- ntiles = 2
- elif flag == AutotunerFlags.PATIENT:
- ntiles = 4
- elif flag == AutotunerFlags.EXHAUSTIVE:
- ntiles = len(tile_sizes)
- ntiles = min(ntiles, len(tile_sizes))
- tile_sizes = tile_sizes[:ntiles]
+ max_tile_size = self._max_tile_size(shape, dtype, tile_indices, is_inplace)
+ imax = int(math.log(max_tile_size, 2))
+ jmax = int(math.log(max_tile_size, 3)) if flag in (AutotunerFlags.EXHAUSTIVE,) else 0
+ tile_sizes = tuple( int((2**i)*(3**j))
+ for (i,j) in it.product(range(0,imax+1), range(0,jmax+1)))
+ tile_sizes = (max_tile_size,) + tuple(sorted(tile_sizes, reverse=True))
+ tile_sizes = tuple(filter(lambda x: (x>=max_tile_size//8) and (x<=max_tile_size), tile_sizes))
+
params.register_extra_parameter('vectorization', vectorization)
params.register_extra_parameter('use_diagonal_coordinates', use_diagonal_coordinates)
diff --git a/hysop/backend/device/opencl/opencl_array.py b/hysop/backend/device/opencl/opencl_array.py
index 39cf0e7a57a41d90c22917ccb5f7c88e89b5a1f5..42df5ec55a7474bf3d93c4a8cb4da618f547881c 100644
--- a/hysop/backend/device/opencl/opencl_array.py
+++ b/hysop/backend/device/opencl/opencl_array.py
@@ -78,9 +78,12 @@ class OpenClArray(Array):
alignment = self.backend.device.mem_base_addr_align
if (offset % alignment) == 0:
# try to return a subbuffer
- buf = self.base_data[offset:]
- buf.__parent = self.base_data
- return buf
+ try:
+ buf = self.base_data[offset:]
+ buf.__parent = self.base_data
+ return buf
+ except:
+ raise clArray.ArrayHasOffsetError
else:
raise
diff --git a/hysop/backend/device/opencl/opencl_array_backend.py b/hysop/backend/device/opencl/opencl_array_backend.py
index 7d274a4db6ae1d187066721cc371d093ec2e4007..bc60c191871f46e468d499799bfe0c96e061a622 100644
--- a/hysop/backend/device/opencl/opencl_array_backend.py
+++ b/hysop/backend/device/opencl/opencl_array_backend.py
@@ -21,7 +21,7 @@ from hysop.core.arrays.array import Array
from hysop.backend.device.opencl.opencl_allocator import OpenClAllocator
from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
-from hysop.backend.device.opencl.opencl_kernel_launcher import OpenClKernelLauncherI
+from hysop.backend.device.opencl.opencl_kernel_launcher import OpenClKernelLauncherI, trace_kernel, profile_kernel
from hysop.tools.numerics import is_fp, is_integer, is_signed, is_unsigned,\
get_dtype, match_dtype
@@ -63,15 +63,16 @@ class _ElementwiseKernel(object):
self.kernel_args = kernel_args
self.kernel_kwds = kernel_kwds
self.default_queue = default_queue
+ self._apply_msg=' '+name+'<<<{}>>>()'.format(args[0].shape)
def global_size_configured(self):
return True
def __call__(self, queue=None, wait_for=None, **kwds):
- if __KERNEL_DEBUG__:
- print ' '+self._name+'<<<{}>>>()'.format(self.kernel_args[0].shape)
+ trace_kernel(self._apply_msg)
queue = first_not_None(queue, self.default_queue)
self.kernel_kwds['queue'] = queue
self.kernel_kwds['wait_for'] = wait_for
evt = self.kernel(*self.kernel_args, **self.kernel_kwds)
+ profile_kernel(None, evt, self._apply_msg)
self._register_event(queue, evt)
return evt
@@ -142,15 +143,16 @@ class _ReductionKernel(object):
self.kernel_args = kernel_args
self.kernel_kwds = kernel_kwds
self.default_queue = default_queue
+ self._apply_msg=' '+name+'<<<{}>>>()'.format(self.kernel_args[0].shape)
def global_size_configured(self):
return True
def __call__(self, queue=None, wait_for=None, **kwds):
- if __KERNEL_DEBUG__:
- print ' '+self._name+'<<<{}>>>()'.format(self.kernel_args[0].shape)
+ trace_kernel(self._apply_msg)
queue = first_not_None(queue, self.default_queue)
self.kernel_kwds['queue'] = queue
self.kernel_kwds['wait_for'] = wait_for
(out, evt) = self.kernel(*self.kernel_args, **self.kernel_kwds)
+ profile_kernel(None, evt, self._apply_msg)
self._register_event(queue, evt)
self.out = out
return evt
@@ -312,7 +314,8 @@ class OpenClArrayBackend(ArrayBackend):
from hysop.core.arrays.all import HostArrayBackend, \
default_host_array_backend
host_array_backend = first_not_None(host_array_backend, default_host_array_backend)
- queue = first_not_None(queue, cl_env.default_queue)
+ if (queue is None):
+ queue = cl_env.default_queue
allocator = first_not_None(allocator, cl_env.allocator)
key = (cl_env, queue, allocator, host_array_backend)
if key in cls.__backends:
@@ -347,8 +350,8 @@ class OpenClArrayBackend(ArrayBackend):
msg='Non-default queue support has been disabled. Please provide a cl_env only.'
if (cl_env is None):
raise RuntimeError(msg)
- if (queue is not None) and (queue is not cl_env.default_queue):
- raise RuntimeError(msg)
+ #if (queue is not None) and (queue is not cl_env.default_queue):
+ #raise RuntimeError(msg)
if (queue is None):
if (cl_env is None):
@@ -1005,7 +1008,7 @@ class OpenClArrayBackend(ArrayBackend):
msg+= '\n'
print msg
raise
-
+
if build_kernel_launcher:
return knl.to_kernel_launcher(name=kernel_build_kwargs['name'],
**kernel_call_kwargs)
@@ -1465,7 +1468,6 @@ class OpenClArrayBackend(ArrayBackend):
###########################
# ARRAY CREATION ROUTINES #
-
def array(self, shape, dtype=HYSOP_REAL, order=default_order,
queue=None, min_alignment=None,
buf=None, offset=0,
@@ -1522,7 +1524,8 @@ class OpenClArrayBackend(ArrayBackend):
handle = self._call(clArray.Array, cq=cq, shape=shape, dtype=dtype, order=order,
allocator=None, data=buf, offset=offset,
strides=strides, events=events)
- return self.wrap(handle)
+ array = self.wrap(handle)
+ return array
def asarray(self, a, queue=None, async=False,
dtype=None, order=default_order, array_queue=QueuePolicy.SAME_AS_TRANSFER):
@@ -1633,29 +1636,29 @@ class OpenClArrayBackend(ArrayBackend):
order = first_not_None(order, getattr(a, 'order', default_order))
return self.array(shape=shape, queue=queue,
dtype=dtype, order=order, min_alignment=min_alignment)
- def full_like(self, a, fill_value, dtype=None, order=None, subok=True, queue=None, min_alignment=None):
+ def full_like(self, a, fill_value, dtype=None, order=None, subok=True, queue=None, min_alignment=None, shape=None):
"""
Return a new array with the same shape and type as a given array.
Queue is set as default queue.
"""
a = self.empty_like(a=a, dtype=dtype, order=order, subok=subok,
- queue=queue, min_alignment=min_alignment)
+ queue=queue, min_alignment=min_alignment, shape=shape)
self.fill(a, value=fill_value, queue=queue)
return a
- def zeros_like(self, a, dtype=None, order=None, subok=True, queue=None, min_alignment=None):
+ def zeros_like(self, a, dtype=None, order=None, subok=True, queue=None, min_alignment=None, shape=None):
"""
Return an array of zeros with the same shape and type as a given array.
Queue is set as default queue.
"""
return self.full_like(a=a,fill_value=0,dtype=dtype,order=order,subok=subok,
- queue=queue, min_alignment=min_alignment)
- def ones_like(self, a, dtype=None, order=None, subok=True, queue=None, min_alignment=None):
+ queue=queue, min_alignment=min_alignment, shape=shape)
+ def ones_like(self, a, dtype=None, order=None, subok=True, queue=None, min_alignment=None, shape=None):
"""
Return an array of ones with the same shape and type as a given array.
Queue is set as default queue.
"""
return self.full_like(a=a,fill_value=1,dtype=dtype,order=order,subok=subok,
- queue=queue, min_alignment=min_alignment)
+ queue=queue, min_alignment=min_alignment, shape=shape)
def arange(self, *args, **kargs):
"""
diff --git a/hysop/backend/device/opencl/opencl_autotunable_kernel.py b/hysop/backend/device/opencl/opencl_autotunable_kernel.py
index 346c9675316c73c0c5ac1c562505e975985295e6..50756c8be8f2eb959f587214dc2d624c53f240d5 100644
--- a/hysop/backend/device/opencl/opencl_autotunable_kernel.py
+++ b/hysop/backend/device/opencl/opencl_autotunable_kernel.py
@@ -1,11 +1,14 @@
+import subprocess, sys
from abc import ABCMeta, abstractmethod
-from hysop import __KERNEL_DEBUG__
+from hysop import __KERNEL_DEBUG__, vprint
from hysop.deps import os
from hysop.constants import Backend
from hysop.tools.numpywrappers import npw
from hysop.tools.types import check_instance, first_not_None, to_tuple, to_list
from hysop.tools.misc import upper_pow2_or_3
from hysop.tools.units import bytes2str
+from hysop.tools.numerics import get_dtype
+from hysop.core.mpi import main_rank
from hysop.backend.device.kernel_autotuner import KernelGenerationError
from hysop.backend.device.autotunable_kernel import AutotunableKernel, AutotunerWorkConfiguration
@@ -33,7 +36,7 @@ class OpenClAutotunableKernel(AutotunableKernel):
from hysop.backend.device.opencl.opencl_kernel_autotuner import OpenClKernelAutotuner
autotuner = OpenClKernelAutotuner(name=name, tunable_kernel=self)
- best_candidate_results = autotuner.autotune(extra_kwds=extra_kwds,
+ best_candidate_results, file_basename, from_cache = autotuner.autotune(extra_kwds=extra_kwds,
force_verbose=force_verbose, force_debug=force_debug)
check_instance(best_candidate_results, dict)
@@ -43,7 +46,8 @@ class OpenClAutotunableKernel(AutotunableKernel):
**extra_kwds['kernel_args'])
return self.format_best_candidate(name=name, extra_kwds=extra_kwds,
- args_mapping=args_mapping, args_list=args_list,
+ args_mapping=args_mapping, args_list=args_list, autotuner=autotuner,
+ file_basename=file_basename, from_cache=from_cache,
**best_candidate_results)
def compute_global_work_size(self, work, local_work_size,
@@ -71,7 +75,7 @@ class OpenClAutotunableKernel(AutotunableKernel):
"""
known_vars = {}
if (global_work_size is not None) and (local_work_size is not None):
- assert ((global_work_size % local_work_size)==0).all(), "{0} {1}".format(
+ assert ((global_work_size % local_work_size)==0).all(), "global_works_size={0} local_work_size={1}".format(
global_work_size, local_work_size)
known_vars.update({
'work_dim': int(global_work_size.size),
@@ -81,11 +85,15 @@ class OpenClAutotunableKernel(AutotunableKernel):
})
return known_vars
- def format_best_candidate(self, name, extra_kwds, extra_parameters, work_load,
+ def format_best_candidate(self, autotuner,
+ file_basename, from_cache, name,
+ extra_kwds, extra_parameters,
+ work_size, work_load,
global_work_size, local_work_size,
args_mapping, args_list,
program, kernel, kernel_name, kernel_src,
- kernel_statistics, src_hash, hash_logs):
+ kernel_statistics, src_hash,
+ extra_kwds_hash, extra_kwds_hash_logs):
"""
Post treatment callback for autotuner results.
Transform autotuner results in user friendly kernel wrappers.
@@ -95,6 +103,8 @@ class OpenClAutotunableKernel(AutotunableKernel):
Use the build_launcher method to build OpenClKernelLauncher from this OpenClKernel.
"""
+ check_instance(file_basename, str)
+ check_instance(from_cache, bool)
check_instance(extra_parameters, dict, keys=str)
check_instance(extra_kwds, dict, keys=str)
check_instance(work_load, tuple, values=npw.int32)
@@ -106,18 +116,82 @@ class OpenClAutotunableKernel(AutotunableKernel):
check_instance(kernel_name, str)
check_instance(kernel_statistics, OpenClKernelStatistics)
check_instance(src_hash, str)
- check_instance(hash_logs, str)
-
- isolation_params = extra_kwds['isolation_params']
-
- kernel_source = self.generate_source_file(kernel_name, kernel_src)
-
- kernel_isolation = self.generate_oclgrind_isolation_file(kernel,
- kernel_name, kernel_source,
- global_work_size, local_work_size,
- args_list, args_mapping, isolation_params)
-
- kernel = OpenClKernel(name=kernel_name, program=program,
+ check_instance(extra_kwds_hash, str)
+ check_instance(extra_kwds_hash_logs, str)
+
+ autotuner_config = autotuner.autotuner_config
+ if autotuner_config.filter_statistics(file_basename):
+ kernel_hash_logs = self.generate_hash_logs(file_basename, extra_kwds_hash_logs)
+ kernel_source = self.generate_source_file(file_basename, kernel_src)
+ kernel_isolation = self.generate_oclgrind_isolation_file(kernel,
+ file_basename, kernel_source,
+ global_work_size, local_work_size,
+ args_list, args_mapping,
+ extra_kwds['isolation_params'])
+
+ if autotuner_config.postprocess_kernels:
+ # /!\ REGENERATE KERNEL STATISTICS /!\
+ # because of tuning_mode = false, kernel source code and performance may change
+ del kernel_statistics
+ for i,arg in enumerate(args_list):
+ kernel.set_arg(i, arg)
+ kernel_statistics, _ = autotuner.bench_one_from_binary(kernel=kernel,
+ target_nruns=autotuner_config.postprocess_nruns,
+ old_stats=None, best_stats=None,
+ global_work_size=global_work_size,
+ local_work_size=local_work_size)
+
+ # execute command FILE_BASENAME FROM_CACHE
+ # AUTOTUNER_DUMP_DIR AUTOTUNER_NAME KERNEL_NAME
+ # MEAN_EXECUTION_TIME_NS MIN_EXECUTION_TIME_NS MAX_EXECUTION_TIME_NS
+ # KERNEL_SOURCE_FILE KERNEL_ISOLATION_FILE KERNEL_HASH_LOGS_FILE
+ # VENDOR_NAME DEVICE_NAME
+ # WORK_SIZE WORK_LOAD
+ # GLOBAL_WORK_SIZE LOCAL_WORK_SIZE
+ # EXTRA_PARAMETERS EXTRA_KWDS_HASH SRC_HASH
+ command = [str(autotuner_config.postprocess_kernels),
+ str(file_basename),
+ '1' if from_cache else '0',
+ str(autotuner_config.dump_folder),
+ str(autotuner.name),
+ str(kernel_name),
+ str(kernel_statistics.mean),
+ str(kernel_statistics.min),
+ str(kernel_statistics.max),
+ str(kernel_source),
+ str(kernel_isolation),
+ str(kernel_hash_logs),
+ str(kernel.context.devices[0].platform.name.strip()),
+ str(kernel.context.devices[0].name.strip()),
+ str(work_size),
+ str(work_load),
+ str(global_work_size),
+ str(local_work_size),
+ str(extra_parameters),
+ str(extra_kwds_hash),
+ str(src_hash)]
+ if autotuner_config.debug:
+ print('POSTPROCESSING KERNEL {}:\n'.format(autotuner.name) + ' '.join(command))
+ try:
+ subprocess.check_call(command)
+ except OSError as e:
+ msg="\nFATAL ERROR: Could not find or execute postprocessing script '{}'.".format(command[0])
+ print msg
+ print
+ raise
+ except subprocess.CalledProcessError as e:
+ if (e.returncode == 10):
+ msg="Postprocessing script has requested to stop the simulation (return code 10), exiting."
+ vprint(msg)
+ sys.exit(0)
+ else:
+ msg='\nFATAL ERROR: Failed to call autotuner postprocessing command.\n{}\n'
+ msg=msg.format(' '.join(command))
+ print(msg)
+ print
+ raise
+
+ kernel = OpenClKernel(name=autotuner.name, program=program,
args_mapping=args_mapping,
default_queue=None,
default_global_work_size=global_work_size,
@@ -125,6 +199,7 @@ class OpenClAutotunableKernel(AutotunableKernel):
default_args=None)
args_dict = extra_kwds['kernel_args']
+
return (kernel, args_dict)
def generate_source_file(self, kernel_name, kernel_src, force=False):
@@ -134,14 +209,31 @@ class OpenClAutotunableKernel(AutotunableKernel):
# dump the best kernel
dump_folder = self.autotuner_config.dump_folder
- dump_file=dump_folder+'/'+'{}.cl'.format(kernel_name.replace(' ', '_'))
- if not os.path.exists(dump_folder):
+ dump_file=dump_folder+'/{}__{}.cl'.format(
+ kernel_name.replace(' ', '_'), main_rank)
+ if not os.path.exists(dump_folder) and (main_rank == 0):
os.makedirs(dump_folder)
with open(dump_file, 'w+') as f:
if self.autotuner_config.verbose:
print ' >Saving OpenCL kernel source to \'{}\'.'.format(dump_file)
f.write(kernel_src)
return dump_file
+
+ def generate_hash_logs(self, kernel_name, hash_logs, force=False):
+ if (not force) and (not self.autotuner_config.dump_hash_logs):
+ return None
+
+ # dump the best kernel
+ dump_folder = self.autotuner_config.dump_folder
+ dump_file=dump_folder+'/{}__{}_hash_logs.txt'.format(
+ kernel_name.replace(' ', '_'), main_rank)
+ if not os.path.exists(dump_folder) and (main_rank == 0):
+ os.makedirs(dump_folder)
+ with open(dump_file, 'w+') as f:
+ if self.autotuner_config.verbose:
+ print ' >Saving hash logs to \'{}\'.'.format(dump_file)
+ f.write(hash_logs)
+ return dump_file
def generate_oclgrind_isolation_file(self, kernel, kernel_name, kernel_source,
global_work_size, local_work_size,
@@ -158,7 +250,8 @@ class OpenClAutotunableKernel(AutotunableKernel):
assert len(sorted_args) == len(args_list)
dump_folder = self.autotuner_config.dump_folder
- dump_file=dump_folder+'/'+'{}.sim'.format(kernel_name.replace(' ', '_'))
+ dump_file=dump_folder+'/{}__{}.sim'.format(
+ kernel_name.replace(' ', '_'), main_rank)
with open(dump_file, 'w+') as f:
msg ='# Isolation configuration file for kernel {}.'.format(kernel_name)
msg+='\n# See https://github.com/jrprice/Oclgrind/wiki/Running-Kernels-in-Isolation '
@@ -175,7 +268,7 @@ class OpenClAutotunableKernel(AutotunableKernel):
arg_isol = isolation_params[arg_name]
elif isinstance(arg_value, npw.ndarray):
assert arg_value.dtype == arg_types
- arg_isol = dict(count=arg_value.size*arg_value.dtype.itemsize, dtype=npw.uint8)
+ arg_isol = dict(count=arg_value.size, dtype=arg_value.dtype)
elif isinstance(arg_value, npw.number):
arg_value = npw.asarray([arg_value], dtype=arg_types)
arg_isol = dict(count=1, dtype=arg_value.dtype)
@@ -189,29 +282,46 @@ class OpenClAutotunableKernel(AutotunableKernel):
except:
type_str = type(arg_types).__name__
msg+='\n# argument {} with type {}\n'.format(arg_name, type_str)
- msg+=self.format_oclgrind_isolation_argument(arg_isol, arg_value)
+ msg+=self.format_oclgrind_isolation_argument(arg_name, arg_isol, arg_value)
msg+='\n'
if self.autotuner_config.verbose:
print ' >Saving oclgrind kernel isolation file to \'{}\'.'.format(dump_file)
f.write(msg)
return dump_file
- def format_oclgrind_isolation_argument(self, arg_isol, arg_value):
+ def format_oclgrind_isolation_argument(self, arg_name, arg_isol, arg_value):
+ from pyopencl.cltypes import vec_types, vec_type_to_scalar_and_count
+ from hysop.backend.device.opencl.opencl_types import cl_vec_types, cl_vec_type_to_scalar_and_count
check_instance(arg_isol, dict)
assert 'count' in arg_isol
assert 'dtype' in arg_isol
+ dtype = get_dtype(arg_isol['dtype'])
+ if (dtype == npw.void):
+ dtype = arg_value.dtype
+ if dtype in vec_types:
+ dtype, vect = vec_type_to_scalar_and_count(dtype)
+ dtype = npw.dtype(get_dtype(dtype))
+ if (vect==3):
+ vect=4
+ elif dtype in cl_vec_types:
+ dtype, vect = cl_vec_type_to_scalar_and_count(dtype)
+ dtype = npw.dtype(get_dtype(dtype))
+ if (vect==3):
+ vect=4
+ elif dtype is npw.complex64:
+ dtype, vect = npw.float32, 2
+ elif dtype is npw.complex128:
+ dtype, vect = npw.float64, 2
+ else:
+ dtype, vect = dtype, 1
+ dtype = npw.dtype(get_dtype(dtype))
+ itemsize = dtype.itemsize
+ dtype = dtype.type
count = arg_isol['count']
- dtype = arg_isol['dtype']
assert count >= 1
- if isinstance(dtype, npw.dtype):
- itemsize = dtype.itemsize
- dtype = dtype.type
- else:
- itemsize = dtype(0).itemsize
+ assert vect >= 1
+ count *= vect
size = count * itemsize
- assert issubclass(dtype, npw.generic)
-
- arg = '<size={}'.format(size)
typemap = {
npw.int8: 'char',
@@ -224,9 +334,8 @@ class OpenClAutotunableKernel(AutotunableKernel):
npw.uint64: 'ulong',
npw.float32: 'float',
npw.float64: 'double',
- npw.complex64: 'float2',
- npw.complex128: 'double2'
}
+ arg = '<size={}'.format(size)
dump_data = False
dump_hex_data = False
@@ -240,26 +349,31 @@ class OpenClAutotunableKernel(AutotunableKernel):
elif 'range' in arg_isol:
slices = arg_isol['range']
assert isinstance(slices, slice)
- assert dtype in typemap.keys()
- ranges = slices.indices(count)
+ assert dtype in typemap.keys(), dtype
+ ranges = list(slices.indices(count))
+ assert (ranges[1]-ranges[0])//ranges[2] in (count, count//vect)
+ if ((ranges[1]-ranges[0])//ranges[2] == count//vect):
+ ranges[0]*=vect
+ ranges[1]*=vect
+ assert (ranges[1]-ranges[0])//ranges[2] == count, '{} != {}'.format((ranges[1]-ranges[0])//ranges[2], count)
arg+=' range={}:{}:{}'.format(ranges[0], ranges[2], ranges[1]-1)
arg+=' {}'.format(typemap[dtype])
else:
- if 'arg_value' in arg_isol:
+ if ('arg_value' in arg_isol):
arg_value = arg_isol['arg_value']
assert isinstance(arg_value, npw.ndarray), type(arg_value)
- if dtype in typemap:
+ if (dtype in typemap):
arg+=' {}'.format(typemap[dtype])
dump_data=True
else:
arg+=' uint8 hex'
dump_hex_data=True
- if ('dump' in arg_isol) and (arg_isol['dump'] is True):
+ if (('dump' in arg_isol) and (arg_isol['dump'] is True)):
arg+= ' dump'
arg+='>'
if dump_data:
- arg+= '\n' + ' '.join(str(x) for x in arg_value.flatten())
+ arg+= '\n' + ' '.join(str(x).replace(',','').replace('(','').replace(')','') for x in arg_value.flatten())
if dump_hex_data:
view = arg_value.ravel().view(dtype=npw.uint8)
arg+= '\n' + ' '.join('{:02x}'.format(ord(x)) for x in arg_value.tobytes())
diff --git a/hysop/backend/device/opencl/opencl_buffer.py b/hysop/backend/device/opencl/opencl_buffer.py
index 322e2d86c001e75680cbdeb260577a96a3bc6584..cf7dd81df468f8efed2a978188b6a9a6742b2eac 100644
--- a/hysop/backend/device/opencl/opencl_buffer.py
+++ b/hysop/backend/device/opencl/opencl_buffer.py
@@ -12,29 +12,12 @@ class OpenClBuffer(DeviceBuffer, cl.Buffer):
super(OpenClBuffer,self).__init__(context=context, flags=mem_flags,
size=size, hostbuf=hostbuf)
- @classmethod
- def from_int_ptr(cls, int_ptr_value, retain=True):
- """
- Creates an OpenClBuffer from a raw opencl pointer (as an int).
- """
- obj = cl.Buffer.from_int_ptr(int_ptr_value=int_ptr_value, retain=retain)
- obj.__class__ = OpenClBuffer
- return obj
-
- @classmethod
- def from_cl_buffer(cls, cl_buffer):
- """
- Creates an OpenClBuffer from a cl_buffer.
- """
- assert isinstance(cl_buffer, cl.Buffer)
- return cls.from_int_ptr(cl_buffer.int_ptr, retain=True)
-
def get_int_ptr(self):
return self.int_ptr
def ref_count(self):
return self.reference_count
-
+
def aligned_view(self, alignment, size=None):
assert alignment>0
assert not (alignment & (alignment-1)), 'alignment is not a power of 2.'
diff --git a/hysop/backend/device/opencl/opencl_copy_kernel_launchers.py b/hysop/backend/device/opencl/opencl_copy_kernel_launchers.py
index f74adb00f1c8114c009c90f88e64099319922a2c..353a6755b74f7d11b0e98027b06c4135b9ea2b78 100644
--- a/hysop/backend/device/opencl/opencl_copy_kernel_launchers.py
+++ b/hysop/backend/device/opencl/opencl_copy_kernel_launchers.py
@@ -9,7 +9,7 @@ from hysop.tools.units import bytes2str
from hysop.tools.numpywrappers import npw
from hysop.core.arrays.all import Array, HostArray, OpenClArray
from hysop.backend.device.opencl import cl, clArray
-from hysop.backend.device.opencl.opencl_kernel_launcher import OpenClKernelLauncher
+from hysop.backend.device.opencl.opencl_kernel_launcher import OpenClKernelLauncher, trace_kernel, profile_kernel
from hysop.backend.device.opencl.opencl_kernel_statistics import OpenClKernelStatistics
@@ -50,14 +50,14 @@ class OpenClCopyKernelLauncher(OpenClKernelLauncher):
return dict(self._enqueue_copy_kwds.items())
def __call__(self, queue=None, wait_for=None, **kwds):
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- print ' '+self._apply_msg
+ trace_kernel(' '+self._apply_msg)
queue = first_not_None(queue, self._default_queue)
if (wait_for is not None):
wait_for = to_list(wait_for)
check_instance(queue, cl.CommandQueue)
evt = cl.enqueue_copy(queue=queue, wait_for=wait_for,
**self._enqueue_copy_kwds)
+ profile_kernel(None, evt, self._apply_msg)
return evt
def global_size_configured(self):
@@ -520,7 +520,7 @@ class OpenClCopyBufferRectLauncher(OpenClCopyKernelLauncher):
dst_nelems, dst_dtype, bytes2str(dst_bytes), dst_bytes)
if (src_bytes != dst_bytes):
raise ValueError(msg0)
-
+
src_data, src_region, src_origin, src_pitches = cls._compute_region(src, src_indices)
dst_data, dst_region, dst_origin, dst_pitches = cls._compute_region(dst, dst_indices)
diff --git a/hysop/backend/device/opencl/opencl_discrete.py b/hysop/backend/device/opencl/opencl_discrete.py
deleted file mode 100644
index a3625d64fc92d2d70ff7d4d7449591fbd2b64d43..0000000000000000000000000000000000000000
--- a/hysop/backend/device/opencl/opencl_discrete.py
+++ /dev/null
@@ -1,93 +0,0 @@
-"""Discrete field defined on device (GPU)
-"""
-from hysop import __VERBOSE__
-from hysop.constants import HYSOP_ORDER, HYSOP_REAL, DirectionLabels
-from hysop.fields.discrete_field import DiscreteField
-from hysop.backend.device.opencl import cl
-from hysop.backend.device.opencl.opencl_kernel import OpenClKernelLauncher, OpenClKernelListLauncher
-
-from hysop.tools.numpywrappers import npw
-from hysop.backend.device.opencl.opencl_array_backend import OpenClArrayBackend
-
-
-class OpenClDiscreteField(DiscreteField):
- """GPU Discrete vector field implementation.
- Allocates OpenCL device memory for the field.
- """
- def __init__(self, cl_env, name, is_vector=False, topology=None):
- """GPU Discrete vector field implementation.
- Allocates OpenCL device memory for the field.
-
- Parameters
- ----------
-
- queue : OpenCL queue
- topology : :class:`~hysop.topology.topology.CartesianTopology`, optional
- mpi topology and local meshes info
- is_vector: boolean, optional
- true if parent field is a vector field, default=False
- name : string, optional
- Field name
- """
- # init base class
- super(OpenClDiscreteField, self).__init__(topology, is_vector, name)
-
- # OpenCL environment
- self.cl_env = cl_env
- self.npcl = OpenClArrayBackend(cl_env=cl_env)
-
- # OpenCL arrays
- self.gpu_data = [None] * self.nb_components
-
- # True if device allocations have been done,
- self.gpu_allocated = False
-
- # OpenCL Events list modifying this field
- self.events = []
-
- # Get the ids of processes involved in the field discretisation.
- # Default = all, otherwise, get info from input topology if given.
- if topology is None:
- from hysop.core.mpi import main_rank
- self._rank = main_rank
- else:
- self._rank = topology.rank
-
- @classmethod
- def from_field(cls, cl_env, vfield):
- if not isinstance(vfield, OpenClDiscreteField):
- vfield.__class__ = cls
- OpenClDiscreteField.__init__(
- vfield, cl_env,
- vfield.topology, vfield.nb_components > 1, vfield.name)
-
- def allocate(self):
- """Device blocking memory allocations."""
- queue = self.cl_env.default_queue()
- if not self.gpu_allocated:
- self.gpu_data = [ self.npcl.asarray(array) for array in self.data ]
-
- def wait(self):
- """
- Waiting for all events completion in the field list.
- Resets the events list.
- """
- if __VERBOSE__:
- print "{" + str(self._rank) + "}", "Wait events :", self.name
- for e in self.events:
- e.wait()
- self.events = []
-
-
- def to_device(self):
- pass
-
- def to_host(self):
- pass
-
- def initialize(self):
- pass
- def finalize(self):
- pass
- def get_profiling_info(self):
- pass
diff --git a/hysop/backend/device/opencl/opencl_elementwise.py b/hysop/backend/device/opencl/opencl_elementwise.py
index f000c02d1879bbe5e856f166282617407bdf0289..937235da17d46bef591102bfe4ae5ee3cde6eb89 100644
--- a/hysop/backend/device/opencl/opencl_elementwise.py
+++ b/hysop/backend/device/opencl/opencl_elementwise.py
@@ -1,7 +1,6 @@
-
from hysop.constants import Precision
from hysop.tools.types import check_instance, first_not_None, to_tuple
-from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer
+from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer, OpenClSymbolicNdBuffer
from hysop.operator.base.custom_symbolic_operator import SymbolicExpressionParser
from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
from hysop.backend.device.opencl.opencl_kernel_config import OpenClKernelConfig
@@ -13,6 +12,7 @@ class OpenClElementwiseKernelGenerator(object):
def __init__(self, cl_env, kernel_config=None, user_build_options=None):
kernel_config = first_not_None(kernel_config, OpenClKernelConfig())
user_build_options = to_tuple(first_not_None(user_build_options, ()))
+
check_instance(cl_env, OpenClEnvironment)
check_instance(kernel_config, OpenClKernelConfig)
check_instance(user_build_options, tuple)
@@ -30,6 +30,7 @@ class OpenClElementwiseKernelGenerator(object):
unroll_loops=unroll_loops)
build_options = set()
+ build_options.update(kernel_config.user_build_options)
build_options.update(cl_env.default_build_opts)
build_options.update(typegen.ftype_build_options())
build_options.update(user_build_options)
@@ -55,12 +56,15 @@ class OpenClElementwiseKernelGenerator(object):
call_only_once = kwds.pop('call_only_once', False)
disable_vectorization = kwds.pop('disable_vectorization', True)
force_volatile = kwds.pop('force_volatile', ())
+ max_candidates=kwds.pop('max_candidates', None)
+ compute_resolution=kwds.pop('compute_resolution', None)
debug = kwds.pop('debug', False)
if kwds:
msg='Unknown keyword arguments: {}'.format(kwds.keys())
raise ValueError(msg)
- expr_info = SymbolicExpressionParser.parse(name, {}, *exprs)
+ expr_info = SymbolicExpressionParser.parse(name, {}, *exprs,
+ compute_resolution=compute_resolution)
assert not expr_info.has_direction, expr_info
expr_info.compute_granularity = 0
@@ -85,14 +89,14 @@ class OpenClElementwiseKernelGenerator(object):
self._kernel_autotuner.autotune(expr_info=expr_info,
queue=queue, first_working=call_only_once,
disable_vectorization=disable_vectorization,
- debug=debug)
+ debug=debug, max_candidates=max_candidates)
kl = kernel.build_launcher(**args_dict)
return (kl, update_input_parameters)
def elementwise(self, name, *exprs, **kwds):
- kernel, update_input_parameters = self.elementwise_kernel(name, *exprs)
+ kernel, update_input_parameters = self.elementwise_kernel(name, *exprs, **kwds)
queue = kwds.pop('queue', self._cl_env.default_queue)
def call_kernel(queue=queue, kernel=kernel,
update_input_parameters=update_input_parameters):
@@ -103,6 +107,10 @@ class OpenClElementwiseKernelGenerator(object):
def symbolic_buffers(cls, *names, **kwds):
return OpenClSymbolic.symbolic_buffers(*names, **kwds)
+ @classmethod
+ def symbolic_ndbuffers(cls, *names, **kwds):
+ return OpenClSymbolic.symbolic_ndbuffers(*names, **kwds)
+
@classmethod
def symbolic_arrays(cls, *names, **kwds):
return OpenClSymbolic.symbolic_arrays(*names, **kwds)
@@ -110,22 +118,45 @@ class OpenClElementwiseKernelGenerator(object):
@classmethod
def symbolic_tmp_scalars(cls, *names, **kwds):
return OpenClSymbolic.symbolic_tmp_scalars(*names, **kwds)
+
+ @classmethod
+ def symbolic_constants(cls, *names, **kwds):
+ return OpenClSymbolic.symbolic_constants(*names, **kwds)
@classmethod
- def arrays_to_symbols(cls, *arrays):
+ def arrays_to_symbols(cls, *arrays, **kwds):
symbols = ()
for (i,array) in enumerate(arrays):
name='a{}'.format(i)
- symbol = OpenClSymbolicArray(name=name, memory_object=array)
+ symbol = OpenClSymbolicArray(name=name, memory_object=array, **kwds)
+ symbols += (symbol,)
+ return symbols
+
+ @classmethod
+ def arrays_to_ndbuffers(cls, *arrays, **kwds):
+ symbols = ()
+ for (i,array) in enumerate(arrays):
+ name='ab{}'.format(i)
+ symbol = OpenClSymbolicNdBuffer(name=name, memory_object=array, **kwds)
+ symbols += (symbol,)
+ return symbols
+
+ @classmethod
+ def dfields_to_ndbuffers(cls, *dfields, **kwds):
+ symbols = ()
+ for dfield in dfields:
+ assert dfield.is_scalar
+ symbol = OpenClSymbolicNdBuffer(name=dfield.name,
+ memory_object=dfield.sbuffer, ghosts=dfield.ghosts, **kwds)
symbols += (symbol,)
return symbols
@classmethod
- def buffer_to_symbols(cls, *buffers):
+ def buffer_to_symbols(cls, *buffers, **kwds):
symbols = ()
for (i,buf) in enumerate(buffers):
name='b{}'.format(i)
- symbol = OpenClSymbolicBuffer(name=name, memory_object=buf)
+ symbol = OpenClSymbolicBuffer(name=name, memory_object=buf, **kwds)
symbols += (symbol,)
return symbols
diff --git a/hysop/backend/device/opencl/opencl_env.py b/hysop/backend/device/opencl/opencl_env.py
index 04593a335e9fa0137919efafb06ad889255641ec..8668534bd72470c0246d6a81a1fe3c5ebc506e26 100644
--- a/hysop/backend/device/opencl/opencl_env.py
+++ b/hysop/backend/device/opencl/opencl_env.py
@@ -1,5 +1,3 @@
-
-
from hysop import vprint, dprint
from hysop import __VERBOSE__, __KERNEL_DEBUG__, __DEFAULT_PLATFORM_ID__, __DEFAULT_DEVICE_ID__
from hysop.deps import hashlib, np, os, copy, re
@@ -9,6 +7,7 @@ from hysop.tools.io_utils import IO
from hysop.tools.units import bytes2str
from hysop.tools.warning import HysopWarning
from hysop.tools.string_utils import framed_str
+from hysop.core.mpi import main_rank
from hysop.backend.device.opencl import cl, clTools, __OPENCL_PROFILE__, OPENCL_KERNEL_DUMP_FOLDER
from hysop.backend.device.opencl.opencl_tools import convert_device_type, convert_precision
@@ -26,7 +25,7 @@ class OpenClEnvironment(TaggedObject):
platform_id = None,
device_id = None,
device_type = None,
- gl_sharing=False,
+ gl_sharing=False,
strict=True,
name=None,
**kwds):
@@ -49,22 +48,22 @@ class OpenClEnvironment(TaggedObject):
Use strict device and platform checks.
Try to match exactly given platform and device IDs.
Also try to match given device type. Else raise an error.
- If this is set to False, try to fallback to a working
- compute device (possibly on a different platform and of a
+ If this is set to False, try to fallback to a working
+ compute device (possibly on a different platform and of a
different device type).
name : str, optional
Name used for memory pool logging.
Defaults to device name.
kwds: dict
Extra arguments for memory pool creation.
-
+
Notes
-----
- See hysop.backend.device.opencl.opencl_tools.get_or_create_opencl_env() to
+ See hysop.backend.device.opencl.opencl_tools.get_or_create_opencl_env() to
create an OpenClEnvironment that will persist and thus maximize memory pool
memory reuse on target device.
"""
-
+
super(OpenClEnvironment, self).__init__(tag_prefix='clenv', **kwds)
platform_id = first_not_None(platform_id, __DEFAULT_PLATFORM_ID__)
@@ -78,9 +77,9 @@ class OpenClEnvironment(TaggedObject):
device_type: {}
gl_sharing: {}
comm size: {}'''.format(
- name, platform_id, device_id,
+ name, platform_id, device_id,
device_type, gl_sharing, mpi_params.size)
-
+
device_type = convert_device_type(device_type)
try:
# OpenCL platform
@@ -96,9 +95,10 @@ class OpenClEnvironment(TaggedObject):
context = get_context(device, gl_sharing)
# OpenCL default queue
self._queues = { 'default_queue': create_queue(context) }
+ self._default_queue_enabled = True
queue = self.default_queue
# OpenCL allocator
- allocator = OpenClImmediateAllocator(queue=queue,
+ allocator = OpenClImmediateAllocator(queue=queue,
mem_flags=cl.mem_flags.READ_WRITE)
# OpenCL memory pool
if (name is None):
@@ -107,7 +107,7 @@ class OpenClEnvironment(TaggedObject):
if pos>0:
name = name[:pos]
name=name.strip()
-
+
self._platform = platform
self._device = device
@@ -147,7 +147,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
msg+='\n'
msg+='\n -- Queue --'
msg+='\n *properties: {}'.format(queue.properties)
-
+
title=' Creating OpenCL environment {} '.format(self.tag)
msg=framed_str(title=title, msg=msg)
vprint(msg)
@@ -160,12 +160,12 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
_kargs['float_dump_mode'] = 'hex'
self.default_build_opts = []
-
+
if __OPENCL_PROFILE__ and self.device.vendor.find('NVIDIA') >= 0:
self.default_build_opts.append('-cl-nv-verbose')
self.macros = {}
-
+
self._mpi_params = mpi_params
self.is_master = (mpi_params.rank==0)
self.is_multi_device = (mpi_params.size>1)
@@ -173,9 +173,9 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
self.platform_id = platform_id
self.device_id = device_id
self.name = name
-
+
self._check_comm_devices()
-
+
def build_typegen(self, precision, float_dump_mode,
use_short_circuit_ops, unroll_loops):
from hysop.constants import Precision
@@ -207,7 +207,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
return (self is not other)
def __hash__(self):
return id(self)
-
+
def extensions(self):
return [ext.strip() for ext in self._device.extensions.split(' ') if ext.strip() != '']
def has_extension(self, extension):
@@ -221,7 +221,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
if self.has_extension('cl_nv_device_attribute_query'):
bus_id = self.device.pci_bus_id_nv
slot_id = self.device.pci_slot_id_nv
- dev_id = (slot_id >> 3)
+ dev_id = (slot_id >> 3)
fn_id = (slot_id & 0x07)
bus_id0 = (bus_id >> 8 )
bus_id1 = (bus_id & 0xff)
@@ -254,7 +254,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
if self.is_master:
device_identifiers = tuple(dev[1] for dev in devices)
good = (len(device_identifiers) == len(set(device_identifiers)))
-
+
formatted_devices = ('rank {}: {}'.format(rank, dev_id) for (rank, dev_id)
in devices)
msg='\n'+'*'*82
@@ -264,12 +264,17 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
msg+='\n'+'*'*82
else:
good, msg = None, None
-
+
(good, msg) = comm.bcast(obj=(good, msg), root=0)
if not good:
import warnings
warnings.warn(msg, HysopWarning)
+ def enable_default_queue(self):
+ self._default_queue_enabled = True
+ def disable_default_queue(self):
+ self._default_queue_enabled = False
+
def get_platform(self):
return self._platform
def get_context(self):
@@ -283,6 +288,9 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
# def get_memory_pool(self):
# return self._mempool
def get_default_queue(self):
+ if not self._default_queue_enabled:
+ msg='Default queue has been disabled.'
+ raise RuntimeError(msg)
return self.queue('default_queue')
def get_mpi_params(self):
return self._mpi_params
@@ -311,7 +319,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
allocator = property(get_allocator)
cl_version = property(get_cl_version)
# memory_pool = property(get_memory_pool)
- default_queue = property(get_default_queue)
+ default_queue = property(get_default_queue)
mpi_params = property(get_mpi_params)
def queue(self, name):
@@ -325,7 +333,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
self._queues[name] = queue
return queue
- def _create_cl_program(self, file_list,
+ def _create_cl_program(self, file_list,
vector_width=4,
nb_remesh_components=1,
build_options='',
@@ -346,7 +354,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
force verbose mode
force_debug: bool, optional, default=None
force debug mode (kernel source dumping and preprocessing)
-
+
Returns OpenCL kernel
Parse the sources to handle single and double precision.
"""
@@ -357,7 +365,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
if cl.device_type.to_string(self.device.type) == 'GPU' and \
self.precision is DOUBLE_GPU:
gpu_src += '#pragma OPENCL EXTENSION cl_khr_fp64: enable \n'
-
+
if isinstance(files, list):
file_list = files
else:
@@ -381,12 +389,12 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
gpu_src += "".join(
self.parse_file(f, vector_width, nb_remesh_components))
f.close()
-
+
# print gpu_src
if self.macros is not None:
for k in self.macros:
gpu_src = gpu_src.replace(k, str(self.macros[k]))
-
+
if self.precision is FLOAT_GPU:
# Rexexp to add 'f' suffix to float constants
# Match 1.2, 1.234, 1.2e3, 1.2E-05
@@ -394,7 +402,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
gpu_src = float_replace.sub(r'\g<float>f', gpu_src)
else:
gpu_src = gpu_src.replace('float', 'double')
-
+
# Log final opencl generated code for debug purposes
if DEBUG:
kernel_name = (file_list[-1].split('/')[-1]).replace('.cl','_parsed')
@@ -408,7 +416,7 @@ device.opencl_c_version, bytes2str(device.global_mem_size))
return '\n\t\t'+'\n\t\t'.join(L)
dump_prefix = \
'''
-/*
+/*
Dumped OpenCL Kernel '{}'
vector_width: {}
nb_remesh_components: {}
@@ -417,21 +425,22 @@ Dumped OpenCL Kernel '{}'
all build_options: {}
*/
'''.format(kernel_name,
- vector_width,
- nb_remesh_components,
+ vector_width,
+ nb_remesh_components,
listformat(file_list),
- listformat(self.default_build_opts),
+ listformat(self.default_build_opts),
listformat(build_options))
-
dumped_src = dump_prefix + gpu_src
-
- dump_folder=IO.default_path()+'/'+OPENCL_KERNEL_DUMP_FOLDER
- dump_file_prefix=dump_folder+'/'+kernel_name
+
+ dump_folder=os.path.join(IO.default_path(), OPENCL_KERNEL_DUMP_FOLDER)
+ dump_file_prefix=os.path.join(dump_folder, 'rk{}_'.format(main_rank)+kernel_name)
tmp_dump_file=dump_file_prefix+'.c'
dump_file=dump_file_prefix+'.cl'
- if not os.path.exists(dump_folder):
+
+ if not os.path.exists(dump_folder) and (main_rank == 0):
os.makedirs(dump_folder)
+
with open(tmp_dump_file, 'w+') as f:
f.write(dumped_src)
@@ -441,7 +450,7 @@ Dumped OpenCL Kernel '{}'
opts = build_options
opts = re.sub('-cl-([a-z0-9]+-?)+ ','',opts)
cmd = ['gcc',opts,'-E','-c',tmp_dump_file,'-o',dump_file_prefix+'_preprocessed.cl']
- subprocess.check_call(' '.join(cmd), shell=True);
+ subprocess.check_call(' '.join(cmd), shell=True);
finally:
os.rename(tmp_dump_file,dump_file)
@@ -455,8 +464,8 @@ Dumped OpenCL Kernel '{}'
- def build_src(self, files,
- build_options='',
+ def build_src(self, files,
+ build_options='',
vector_width=4,
nb_remesh_components=1):
"""Build OpenCL sources
@@ -491,13 +500,13 @@ Dumped OpenCL Kernel '{}'
vprint(" - ", sf)
# --- create kernel from cl files ---
- prg = self._create_cl_program(files=file_list,
+ prg = self._create_cl_program(files=file_list,
build_options=build_options,
vector_width=vector_width,
nb_remesh_components=nb_remesh_components,
force_verbose=force_verbose,
force_debug=force_debug)
-
+
# --- Build kernel ---
try:
build = prg.build(build_options)
@@ -521,17 +530,17 @@ Dumped OpenCL Kernel '{}'
cl.program_build_info.LOG))
vprint("===\n")
return build
-
- def build_raw_src(self, src, build_options=[],
+
+ def build_raw_src(self, src, build_options=[],
kernel_name=None,
force_verbose=None, force_debug=None):
"""Build raw OpenCL sources
Parameters
----------
- src : string
+ src : string
OpenCL source code
build_options : string
Compiler options to use for building
@@ -543,7 +552,7 @@ Dumped OpenCL Kernel '{}'
DEBUG = False if (force_debug is None) else force_debug
gpu_src = src
-
+
src_hash = hashlib.sha1(gpu_src).hexdigest()
if (kernel_name is None):
kernel_name = src_hash
@@ -553,13 +562,14 @@ Dumped OpenCL Kernel '{}'
if VERBOSE:
print '=== Kernel raw source compiling ==='
prg = cl.Program(self.context, gpu_src)
-
- dump_folder=IO.default_path()+'/'+OPENCL_KERNEL_DUMP_FOLDER
+
+ dump_folder=os.path.join(IO.default_path(), OPENCL_KERNEL_DUMP_FOLDER)
+
if DEBUG:
# dump kernel source while in debug mode
- if not os.path.exists(dump_folder):
+ if not os.path.exists(dump_folder) and (main_rank == 0):
os.makedirs(dump_folder)
- dump_file=dump_folder+'/'+'{}_dump.cl'.format(kernel_name)
+ dump_file=os.path.join(dump_folder, 'rk{}_{}_dump.cl'.format(main_rank, kernel_name))
print 'Dumping kernel src at \'{}\'.'.format(dump_file)
with open(dump_file, 'w+') as f:
f.write(gpu_src)
@@ -572,17 +582,17 @@ Dumped OpenCL Kernel '{}'
# Build OpenCL program
try:
build = prg.build(s_build_opts)
- except Exception, e:
+ except Exception as e:
# always dump source when build fails
- if not os.path.exists(dump_folder):
+ if not os.path.exists(dump_folder) and (main_rank == 0):
os.makedirs(dump_folder)
- dump_file=dump_folder+'/'+'{}_build_fail.cl'.format(kernel_name)
+ dump_file=os.path.join(dump_folder, 'rk{}_{}_build_fail.cl'.format(main_rank, kernel_name))
with open(dump_file, 'w+') as f:
f.write(gpu_src)
- vprint('Build options : ', s_build_opts)
- vprint('Build Failed: dumped source to {}.'.format(dump_file))
+ print('Build options : ', s_build_opts)
+ print('Build Failed: dumped source to {}.'.format(dump_file))
raise e
-
+
if VERBOSE:
print 'Compiler status: {}'.format(
build.get_build_info(self.device, cl.program_build_info.STATUS))
diff --git a/hysop/backend/device/opencl/opencl_fft.py b/hysop/backend/device/opencl/opencl_fft.py
index cc4e2330a89bc24917997e325e3639f115af19d4..07d3b680b3870ba47f0e250806d6424b90b287b0 100644
--- a/hysop/backend/device/opencl/opencl_fft.py
+++ b/hysop/backend/device/opencl/opencl_fft.py
@@ -1,7 +1,14 @@
-
import warnings
import numpy as np
-from gpyfft.fft import FFT, gfft, GFFT
+try:
+ from gpyfft.fft import FFT, gfft, GFFT
+except ImportError as e:
+ class FFT():
+ def __init__(self):
+ assert False, "Du to gpyfft import error ({}), this class is useless".format(e)
+ gfft, GFFT = None, None
+ print e
+ print "Some functionnalities may not work. It seems that hysop is called from non OpenCL machine."
from hysop import vprint
from hysop.tools.types import first_not_None
from hysop.tools.warning import HysopWarning
@@ -11,9 +18,10 @@ from hysop.tools.numpywrappers import npw
from hysop.backend.device.opencl import cl, clArray
from hysop.backend.device.codegen.base.variables import dtype_to_ctype
+
class OpenClFFT(FFT):
- def __init__(self, context, queue, in_array,
+ def __init__(self, context, queue, in_array,
out_array=None, axes=None,
fast_math=False, real=False,
keep_buffer_offset=False):
@@ -28,9 +36,9 @@ class OpenClFFT(FFT):
axes = np.argsort(in_array.strides)
else:
axes = np.asarray(axes)
-
+
t_strides_in, t_distance_in, t_batchsize_in, t_shape, axes_transform = \
- self.calculate_transform_strides(axes, in_array)
+ self.calculate_transform_strides(axes, in_array)
if (out_array is not None):
t_inplace = False
@@ -44,7 +52,7 @@ class OpenClFFT(FFT):
assert (out_array.offset + out_array.nbytes) < in_array.offset
else:
t_inplace = True
- msg='error finding transform axis (consider setting axes argument)'
+ msg = 'error finding transform axis (consider setting axes argument)'
assert np.all(axes_transform == axes_transform_out), msg
else:
out_array = in_array
@@ -57,29 +65,29 @@ class OpenClFFT(FFT):
precision = gfft.CLFFT_DOUBLE
if in_array.dtype in (np.float32, np.float64):
- layout_in = gfft.CLFFT_REAL
+ layout_in = gfft.CLFFT_REAL
layout_out = gfft.CLFFT_HERMITIAN_INTERLEAVED
expected_out_shape = list(in_array.shape)
expected_out_shape[axes_transform[0]] = \
- expected_out_shape[axes_transform[0]]//2 + 1
- msg='output array shape {} does not match expected shape: {}'
- msg=msg.format(out_array.shape, expected_out_shape)
+ expected_out_shape[axes_transform[0]]//2 + 1
+ msg = 'output array shape {} does not match expected shape: {}'
+ msg = msg.format(out_array.shape, expected_out_shape)
assert out_array.shape == tuple(expected_out_shape), msg
elif in_array.dtype in (np.complex64, np.complex128):
if not real:
- layout_in = gfft.CLFFT_COMPLEX_INTERLEAVED
+ layout_in = gfft.CLFFT_COMPLEX_INTERLEAVED
layout_out = gfft.CLFFT_COMPLEX_INTERLEAVED
else:
- layout_in = gfft.CLFFT_HERMITIAN_INTERLEAVED
+ layout_in = gfft.CLFFT_HERMITIAN_INTERLEAVED
layout_out = gfft.CLFFT_REAL
t_shape = t_shape_out
if t_inplace and ((layout_in is gfft.CLFFT_REAL) or
(layout_out is gfft.CLFFT_REAL)):
- assert ((in_array.strides[axes_transform[0]] == in_array.dtype.itemsize) and \
+ assert ((in_array.strides[axes_transform[0]] == in_array.dtype.itemsize) and
(out_array.strides[axes_transform[0]] == out_array.dtype.itemsize)), \
- 'inline real transforms need stride 1 for first transform axis'
+ 'inline real transforms need stride 1 for first transform axis'
self.t_shape = t_shape
self.batchsize = t_batchsize_in
@@ -93,24 +101,24 @@ class OpenClFFT(FFT):
plan.batch_size = self.batchsize
plan.precision = precision
plan.layouts = (layout_in, layout_out)
-
+
assert not keep_buffer_offset
- (in_data, out_data) = self.set_offset_callbacks(plan, in_array, out_array,
- layout_in, layout_out,
- keep_buffer_offset)
-
+ (in_data, out_data) = self.set_offset_callbacks(plan, in_array, out_array,
+ layout_in, layout_out,
+ keep_buffer_offset)
+
self.plan = plan
- self.in_array = in_array
+ self.in_array = in_array
self.out_array = out_array
self.in_data = in_data
self.out_data = out_data
self.temp_buffer = None
- self._baked = False
- self._allocated = False
-
+ self._baked = False
+ self._allocated = False
+
def set_offset_callbacks(self, plan, in_array, out_array, layout_in, layout_out,
- keep_buffer_offset):
+ keep_buffer_offset):
try:
if keep_buffer_offset:
raise clArray.ArrayHasOffsetError
@@ -131,38 +139,38 @@ class OpenClFFT(FFT):
post, output_buffer_offset = self.post_offset_callback(out_array, layout_out)
plan.set_callback('post_callback', post, 'post', user_data=None)
- self.input_buffer_offset = input_buffer_offset
+ self.input_buffer_offset = input_buffer_offset
self.output_buffer_offset = output_buffer_offset
return (in_data, out_data)
-
+
def bake(self):
if self._baked:
- msg='Plan was already baked.'
+ msg = 'Plan was already baked.'
raise RuntimeError(msg)
msg = 'Baking {}[precision={}, shape={}, inplace={}, layout_in={}, layout_out={}]'.format(
- self.__class__.__name__,
- self.precision, self.t_shape, self.t_inplace,
- self.layout_in, self.layout_out)
+ self.__class__.__name__,
+ self.precision, self.t_shape, self.t_inplace,
+ self.layout_in, self.layout_out)
self.plan.bake(self.queue)
self._baked = True
return self
def allocate(self, buf=None):
if self._allocated:
- msg='Plan was already allocated.'
+ msg = 'Plan was already allocated.'
raise RuntimeError(msg)
size = self.plan.temp_array_size
- if (size>0):
+ if (size > 0):
if (buf is None):
- msg='Allocating temporary buffer of size {} for clFFT::{}.'
- msg=msg.format(bytes2str(size), id(self))
+ msg = 'Allocating temporary buffer of size {} for clFFT::{}.'
+ msg = msg.format(bytes2str(size), id(self))
warnings.warn(msg, HysopWarning)
buf = cl.Buffer(self.context, cl.mem_flags.READ_WRITE, size=size)
self.temp_buffer = buf
elif (buf.size != size):
- msg='Buffer does not match required size: {} != {}'
- msg=msg.format(buf.size, size)
+ msg = 'Buffer does not match required size: {} != {}'
+ msg = msg.format(buf.size, size)
raise ValueError(msg)
else:
self.temp_buffer = buf.data
@@ -174,9 +182,9 @@ class OpenClFFT(FFT):
def enqueue(self, queue=None, wait_for_events=None, direction_forward=True):
"""
Enqueue transform with array base_data.
- /!\ Do not forget to offset input and output by array.offset
- within custom user callbacks, only base_data is passed
- to ensure OpenCL pointers alignment of kernel arguments.
+ /!\ Do not forget to offset input and output by array.offset
+ within custom user callbacks, only base_data is passed
+ to ensure OpenCL pointers alignment of kernel arguments.
See self.set_offset_callbacks().
"""
self._assert_ready()
@@ -184,21 +192,21 @@ class OpenClFFT(FFT):
queue = first_not_None(queue, self.queue)
if self.t_inplace:
- events = self.plan.enqueue_transform((queue,),
- (in_data,),
- direction_forward=direction_forward,
- temp_buffer=self.temp_buffer,
- wait_for_events=wait_for_events)
+ events = self.plan.enqueue_transform((queue,),
+ (in_data,),
+ direction_forward=direction_forward,
+ temp_buffer=self.temp_buffer,
+ wait_for_events=wait_for_events)
else:
- events = self.plan.enqueue_transform((queue,),
- (in_data,), (out_data),
- direction_forward=direction_forward,
- temp_buffer=self.temp_buffer,
- wait_for_events=wait_for_events)
+ events = self.plan.enqueue_transform((queue,),
+ (in_data,), (out_data),
+ direction_forward=direction_forward,
+ temp_buffer=self.temp_buffer,
+ wait_for_events=wait_for_events)
return events
-
+
def enqueue_arrays(self, *args, **kwds):
- msg='Enqueue arrays is not supported.'
+ msg = 'Enqueue arrays is not supported.'
raise NotImplementedError(msg)
@property
@@ -212,94 +220,94 @@ class OpenClFFT(FFT):
def _assert_ready(self):
if __debug__ and not self.ready:
- msg='Plan is not ready:'
- msg+='\n *baked: {}'
- msg+='\n *allocated: {}'
- msg+='\n'
- msg=msg.format(self._baked, self._allocated)
+ msg = 'Plan is not ready:'
+ msg += '\n *baked: {}'
+ msg += '\n *allocated: {}'
+ msg += '\n'
+ msg = msg.format(self._baked, self._allocated)
raise RuntimeError(msg)
-
+
@classmethod
def check_dtype(cls, dtype, layout):
if layout in (gfft.CLFFT_HERMITIAN_INTERLEAVED, gfft.CLFFT_COMPLEX_INTERLEAVED):
if not is_complex(dtype):
- msg='Layout is {} but got array with dtype {}.'
- msg=msg.format(layout, dtype)
+ msg = 'Layout is {} but got array with dtype {}.'
+ msg = msg.format(layout, dtype)
raise RuntimeError(msg)
elif layout in (gfft.CLFFT_REAL,):
if not is_fp(dtype):
- msg='Layout is CLFFT_REAL but got array with dtype {}.'
- msg=msg.format(dtype)
+ msg = 'Layout is CLFFT_REAL but got array with dtype {}.'
+ msg = msg.format(dtype)
raise RuntimeError(msg)
else:
- msg='Unsupported data layout {}.'
- msg=msg.format(layout)
+ msg = 'Unsupported data layout {}.'
+ msg = msg.format(layout)
raise NotImplementedError(msg)
-
+
def pre_offset_callback(self, in_array, layout_in):
dtype = in_array.dtype
fp = dtype_to_ctype(dtype)
self.check_dtype(dtype, layout_in)
if (in_array.offset % dtype.itemsize) != 0:
- msg='Unaligned array offset.'
+ msg = 'Unaligned array offset.'
raise RuntimeError(msg)
base_offset = (in_array.offset // dtype.itemsize)
callback = \
- '''
+ '''
{fp} pre_callback(__global void* input,
const uint offset,
__global void* userdata) {{
- __global {fp}* in = (__global {fp}*) input;
+ __global {fp}* in = (__global {fp}*) input;
return in[{base_offset}uL+offset];
}}
'''.format(fp=fp, base_offset=base_offset)
-
+
input_buffer_offset = '{}uL'.format(base_offset)
-
+
return callback, input_buffer_offset
-
+
def post_offset_callback(self, out_array, layout_out):
dtype = out_array.dtype
self.check_dtype(dtype, layout_out)
fp = dtype_to_ctype(dtype)
if (out_array.offset % dtype.itemsize) != 0:
- msg='Unaligned array offset.'
+ msg = 'Unaligned array offset.'
raise RuntimeError(msg)
base_offset = (out_array.offset // dtype.itemsize)
-
+
callback = \
- '''
+ '''
void post_callback(__global void* output,
const uint offset,
__global void* userdata,
const {fp} fftoutput) {{
- __global {fp}* out = (__global {fp}*) output;
+ __global {fp}* out = (__global {fp}*) output;
out[{base_offset}uL+offset] = fftoutput;
}}
'''.format(fp=fp, base_offset=base_offset)
output_buffer_offset = '{}uL'.format(base_offset)
-
+
return callback, output_buffer_offset
-
+
@classmethod
def allocate_plans(cls, operator, plans):
tmp_size = max(plan.required_buffer_size for plan in plans)
- msg='Allocating an additional {} temporary buffer for clFFT in operator {}.'.format(
- bytes2str(tmp_size), operator.name)
+ msg = 'Allocating an additional {} temporary buffer for clFFT in operator {}.'.format(
+ bytes2str(tmp_size), operator.name)
- if (tmp_size>0):
+ if (tmp_size > 0):
vprint(msg)
tmp_buffer = operator.backend.empty(shape=(tmp_size), dtype=npw.uint8)
for plan in plans:
if (plan.required_buffer_size > tmp_buffer.nbytes):
- msg='\nFATAL ERROR: Failed to allocate temporary buffer for clFFT.'
- msg+='\n => clFFT expected {} bytes but only {} bytes have been allocated.\n'
- msg=msg.format(plan.required_buffer_size, tmp_buffer.nbytes)
+ msg = '\nFATAL ERROR: Failed to allocate temporary buffer for clFFT.'
+ msg += '\n => clFFT expected {} bytes but only {} bytes have been allocated.\n'
+ msg = msg.format(plan.required_buffer_size, tmp_buffer.nbytes)
raise RuntimeError(msg)
- elif (plan.required_buffer_size>0):
+ elif (plan.required_buffer_size > 0):
buf = tmp_buffer[:plan.required_buffer_size]
plan.allocate(buf=buf)
else:
@@ -310,4 +318,3 @@ class OpenClFFT(FFT):
plan.allocate()
tmp_buffer = None
return tmp_buffer
-
diff --git a/hysop/backend/device/opencl/opencl_kernel_autotuner.py b/hysop/backend/device/opencl/opencl_kernel_autotuner.py
index c01af580aa541c7937b65c94940d3fe899585144..63495c5a149988102a97c6d3554993e662a0d910 100644
--- a/hysop/backend/device/opencl/opencl_kernel_autotuner.py
+++ b/hysop/backend/device/opencl/opencl_kernel_autotuner.py
@@ -22,9 +22,9 @@ class OpenClKernelAutotuner(KernelAutotuner):
self.cl_env.device.name.strip(),
self.build_opts)
- def _print_header(self):
+ def _print_header(self, *args, **kwds):
cl_env = self.cl_env
- verbose = super(OpenClKernelAutotuner, self)._print_header()
+ verbose = super(OpenClKernelAutotuner, self)._print_header(*args, **kwds)
if verbose:
print ' *platform: {}'.format(cl_env.platform.name.strip())
print ' *device: {}'.format(cl_env.device.name.strip())
diff --git a/hysop/backend/device/opencl/opencl_kernel_launcher.py b/hysop/backend/device/opencl/opencl_kernel_launcher.py
index 97007b619c26349a45ba6fb7da45b7e8ed3e7e02..ceebbb47bb69cdb6962adbdb885a00a546d6ad4d 100644
--- a/hysop/backend/device/opencl/opencl_kernel_launcher.py
+++ b/hysop/backend/device/opencl/opencl_kernel_launcher.py
@@ -1,13 +1,54 @@
-
from abc import ABCMeta, abstractmethod
-from hysop import vprint, dprint, __KERNEL_DEBUG__, __TRACE_KERNELS__
+from hysop import __KERNEL_DEBUG__, __TRACE_KERNELS__, __TRACE_NOCOPY__, __TRACE_NOACCUMULATE__
from hysop.deps import it, warnings
from hysop.tools.decorators import debug
from hysop.tools.types import check_instance, first_not_None
from hysop.tools.numpywrappers import npw
-from hysop.backend.device.opencl import cl
+from hysop.backend.device.opencl import cl, __OPENCL_PROFILE__
from hysop.backend.device.opencl.opencl_kernel_statistics import OpenClKernelStatistics
from hysop.tools.warning import HysopWarning
+
+def should_trace_kernel(kernel_msg):
+ assert isinstance(kernel_msg, str)
+ kernel_msg = kernel_msg.strip()
+ if __TRACE_NOCOPY__ and kernel_msg.startswith('enqueue_copy'):
+ return False
+ elif __TRACE_NOACCUMULATE__ and kernel_msg.startswith('add<<<'):
+ return False
+ else:
+ return True
+
+should_profile_kernel = should_trace_kernel
+
+if (__KERNEL_DEBUG__ or __TRACE_KERNELS__):
+ def trace_kernel(kernel_msg):
+ if should_trace_kernel(kernel_msg):
+ print kernel_msg
+else:
+ def trace_kernel(kernel_msg):
+ pass
+
+if __OPENCL_PROFILE__:
+ def profile_kernel(kernel, evt, kernel_msg=None):
+ evt.wait()
+ if (kernel is None):
+ assert (kernel_msg is not None)
+ else:
+ assert (kernel_msg is None)
+ show_profiling_info = getattr(kernel, '_show_profiling_info', True)
+ if show_profiling_info:
+ if not hasattr(kernel, '_apply_msg'):
+ msg = 'Kernel of type {} has no \'_apply_msg\' attribute, this is required for profiling.'
+ msg=kernel_msg.format(type(kernel).__name__)
+ raise AttributeError(kernel_msg)
+ kernel_msg = kernel._apply_msg
+
+ if (kernel_msg is not None) and should_profile_kernel(kernel_msg):
+ print '{} | {}'.format(evt.profile.end - evt.profile.start, kernel_msg.strip())
+else:
+ def profile_kernel(kernel, evt, kernel_msg=None):
+ pass
+
class OpenClKernelListLauncher(object):
"""
@@ -118,8 +159,7 @@ class OpenClKernelListLauncher(object):
If this OpenClKernelListLauncher is empty, cl.wait_for_events
will be called instead.
"""
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- print self._apply_msg
+ trace_kernel(self._apply_msg)
if __debug__:
parameters = self._parameters
@@ -131,17 +171,17 @@ class OpenClKernelListLauncher(object):
kernels = self._kernels
if kernels:
- evt = kernels[0].__call__(queue=queue, wait_for=wait_for, **kwds)
+ evt = kernels[0](queue=queue, wait_for=wait_for, **kwds)
for kernel in kernels[1:]:
try:
- evt = kernel.__call__(queue=queue, **kwds)
+ evt = kernel(queue=queue, **kwds)
except:
msg='\nFailed to call kernel {} of type {}.\n'
msg=msg.format(kernel.name,type(kernel).__name__)
print msg
raise
else:
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
+ if (__KERNEL_DEBUG__ or __TRACE_KERNELS__):
msg='No kernels enqueued for KernelListLauncher::{}'.format(self.name)
warnings.warn(msg, HysopWarning)
evt = cl.enqueue_marker(queue=queue, wait_for=wait_for)
@@ -283,6 +323,7 @@ class LauncherI(object):
"""
pass
+
class OpenClKernelLauncherI(LauncherI):
"""
Interface for any object that has the ability to enqueue a OpenCL kernel
@@ -301,7 +342,7 @@ class OpenClKernelLauncherI(LauncherI):
def check_kernel_arg(self, arg, arg_id, arg_name, arg_type):
"""Check kernel argument type prior to setargs."""
- if not __KERNEL_DEBUG__ or __TRACE_KERNELS__:
+ if not (__KERNEL_DEBUG__ or __TRACE_KERNELS__):
return
if isinstance(arg_type, npw.dtype) or \
(isinstance(arg_type, tuple) and len(arg_type)==1
@@ -327,15 +368,14 @@ class OpenClKernelLauncherI(LauncherI):
msg=msg.format(self.name, arg_name, arg_id, arg_type, type(arg))
raise RuntimeError(msg)
-class HostLauncherI(LauncherI):
+class HostLauncherI(LauncherI):
def __init__(self, name, **kwds):
super(HostLauncherI, self).__init__(name=name, **kwds)
self._apply_msg = ' HostLauncher.{}()'.format(name)
def __call__(self):
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- print self._apply_msg
+ trace_kernel(self._apply_msg)
def parameters(self):
return {}
@@ -343,6 +383,7 @@ class HostLauncherI(LauncherI):
def global_size_configured(self):
return True
+
class OpenClKernelLauncher(OpenClKernelLauncherI):
"""
Wraps an OpenCL kernel ready to be enqueued without extra arguments.
@@ -413,7 +454,7 @@ class OpenClKernelLauncher(OpenClKernelLauncherI):
self._default_local_work_size = default_local_work_size
self._default_queue = default_queue
self._kernel_is_shared = kernel_is_shared
- self._apply_msg = ' {}<<<{}, {}>>>'.format(name, '{}', '{}')
+ self._apply_msg = ' {}<<<>>>'.format(name)
def queue_configured(self):
"""
@@ -473,14 +514,15 @@ class OpenClKernelLauncher(OpenClKernelLauncherI):
assert isinstance(global_work_size, tuple)
assert isinstance(local_work_size, (tuple, type(None)))
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- print self._apply_msg.format(global_work_size, local_work_size)
+ apply_msg = self._apply_msg.format(global_work_size, local_work_size)
+ trace_kernel(apply_msg)
kernel = self._set_kernel_args(**kwds)
evt = cl.enqueue_nd_range_kernel(queue=queue, kernel=kernel,
global_work_size=global_work_size,
local_work_size=local_work_size, wait_for=wait_for)
+ profile_kernel(None, evt, apply_msg)
self._register_event(queue, evt)
return evt
@@ -665,9 +707,8 @@ class OpenClIterativeKernelLauncher(OpenClParametrizedKernelLauncher):
assert isinstance(global_work_size, tuple)
assert isinstance(local_work_size, (tuple, type(None)))
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- apply_msg = self._apply_msg.format('{}', global_work_size, local_work_size, '{}')
- print apply_msg.format(' ', '<yielder>')
+ apply_msg = self._apply_msg.format('{}', global_work_size, local_work_size, '{}')
+ trace_kernel(apply_msg.format(' ', '<yielder>'))
kernel = self._set_kernel_args(**kwds)
@@ -678,12 +719,11 @@ class OpenClIterativeKernelLauncher(OpenClParametrizedKernelLauncher):
arg_types = self.iterated_parameter_arg_types
arg_names = self.iterated_parameter_arg_names
for i,args in enumerate(self.iter_parameters()):
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- apply_msg = self._apply_msg.format('{}', global_work_size, local_work_size,
- '{}')
- print apply_msg.format(' | ', ', '.join('{}={}'.format(pname, pval)
- for (pname,pval) in zip(arg_names, args)))
-
+ apply_msg = self._apply_msg.format('{}', global_work_size, local_work_size,
+ '{}')
+ apply_msg = apply_msg.format(' | ', ', '.join('{}={}'.format(pname, pval)
+ for (pname,pval) in zip(arg_names, args)))
+ trace_kernel(apply_msg)
for arg_id, arg_name, arg_type, arg_value in zip(arg_ids, arg_names,
arg_types, args):
@@ -694,6 +734,7 @@ class OpenClIterativeKernelLauncher(OpenClParametrizedKernelLauncher):
global_work_size=global_work_size,
local_work_size=local_work_size,
wait_for=(wait_for if (i==0 or out_of_order_queue) else None))
+ profile_kernel(None, evt, apply_msg)
self._register_event(queue, evt)
if out_of_order_queue:
diff --git a/hysop/backend/device/opencl/opencl_kernel_statistics.py b/hysop/backend/device/opencl/opencl_kernel_statistics.py
index ea622e2a9a294b153f53ac0d4c25c8913a7f2902..b59d5ff9ad31570709d86122e27914ffdc67b1fa 100644
--- a/hysop/backend/device/opencl/opencl_kernel_statistics.py
+++ b/hysop/backend/device/opencl/opencl_kernel_statistics.py
@@ -16,6 +16,7 @@ class OpenClKernelStatistics(KernelStatistics):
total = dt0
maxi = dt0
mini = dt0
+ data = [dt0]
for evt in events[1:]:
dt = (evt.profile.end - evt.profile.start)
total += dt
@@ -23,11 +24,13 @@ class OpenClKernelStatistics(KernelStatistics):
mini = dt
if dt>maxi:
maxi = dt
+ data.append(dt)
else:
nruns = 0
mini = None
maxi = None
total = None
+ data = None
# OpenCl profiling units are already in nanoseconds so we
# are good.
@@ -35,5 +38,6 @@ class OpenClKernelStatistics(KernelStatistics):
# of the timer not the unit.
super(OpenClKernelStatistics, self).__init__(
nruns=nruns, total=total,
- min_=mini, max_=maxi, **kwds)
+ min_=mini, max_=maxi,
+ data=data, **kwds)
diff --git a/hysop/backend/device/opencl/opencl_operator.py b/hysop/backend/device/opencl/opencl_operator.py
index ff07113106c7fb812a104362503f301068234ca5..f72cd70960ee9a3537837075e4004cf9ee6fccba 100644
--- a/hysop/backend/device/opencl/opencl_operator.py
+++ b/hysop/backend/device/opencl/opencl_operator.py
@@ -160,6 +160,7 @@ class OpenClOperator(ComputationalGraphOperator):
self._initialize_cl_build_options(kernel_config.user_build_options)
self._initialize_cl_size_constants(kernel_config.user_size_constants)
+ self._initialize_kernel_generator()
def check(self):
super(OpenClOperator, self).check()
@@ -300,6 +301,15 @@ class OpenClOperator(ComputationalGraphOperator):
else:
cl_defines[usc[0]] = None
self._cl_defines = cl_defines
+
+ def _initialize_kernel_generator(self):
+ """
+ Initialize a OpenClElementwiseKernelGenerator.
+ """
+ from hysop.backend.device.opencl.opencl_elementwise import OpenClElementwiseKernelGenerator
+ self.elementwise_kernel_generator = OpenClElementwiseKernelGenerator(
+ cl_env=self.cl_env,
+ kernel_config=self.kernel_config)
@classmethod
def supports_multiple_topologies(cls):
diff --git a/hysop/backend/device/opencl/opencl_symbolic.py b/hysop/backend/device/opencl/opencl_symbolic.py
index 07bb81b22b9ab518290c74e5ddc2b4d8f802719d..d0d414e6254fe9a5201862ee1c81af87b1ac6583 100644
--- a/hysop/backend/device/opencl/opencl_symbolic.py
+++ b/hysop/backend/device/opencl/opencl_symbolic.py
@@ -9,9 +9,10 @@ expressions.
used to provide a common interface to all discrete operators working with the
opencl backend and using kernels generated on the fly from symbolic expressions.
"""
+import numpy as np
from abc import ABCMeta
from hysop.tools.decorators import debug
-from hysop.tools.types import check_instance, first_not_None, InstanceOf
+from hysop.tools.types import check_instance, first_not_None, InstanceOf, to_tuple
from hysop.tools.numpywrappers import npw
from hysop.fields.continuous_field import ScalarField, TensorField, Field
from hysop.parameters.tensor_parameter import Parameter, TensorParameter
@@ -20,7 +21,7 @@ from hysop.operator.base.custom_symbolic_operator import ValidExpressions, \
from hysop.backend.device.opencl.opencl_operator import OpenClOperator
from hysop.constants import ComputeGranularity, SpaceDiscretization, TranspositionState, \
DirectionLabels, SymbolicExpressionKind
-from hysop.numerics.interpolation.interpolation import Interpolation
+from hysop.numerics.interpolation.interpolation import MultiScaleInterpolation
from hysop.numerics.odesolvers.runge_kutta import TimeIntegrator
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.backend.device.opencl.autotunable_kernels.custom_symbolic import \
@@ -65,10 +66,11 @@ class OpenClSymbolic(OpenClOperator):
"""
super(OpenClSymbolic, self).__init__(**kwds)
self.expressions = {}
+ self.extra_kwds = {}
self.expr_infos = {}
self.symbolic_kernels = {}
- def require_symbolic_kernel(self, name, *exprs):
+ def require_symbolic_kernel(self, name, *exprs, **extra_kwds):
if self.initialized:
msg='{} has already been initialized, cannot require a new symbolic kernel.'
msg=msg.format(self.name)
@@ -76,77 +78,68 @@ class OpenClSymbolic(OpenClOperator):
check_instance(name, str)
check_instance(exprs, tuple, values=ValidExpressions, minsize=1)
self.expressions[name] = exprs
+ self.extra_kwds[name] = extra_kwds
@classmethod
- def symbolic_buffers(cls, *names, **kwds):
- from hysop.symbolic.array import OpenClSymbolicBuffer
- buffers = ()
- if ('count' in kwds):
- count = kwds.pop('count')
- assert len(names)==1
- snames = tuple(names[0]+subscript(i) for i in xrange(count))
- var_names = tuple('{}{}'.format(names[0], i) for i in xrange(count))
- latex_names = tuple('{}_{{{}}}'.format(names[0], i) for i in xrange(count))
- else:
- snames = names
- varnames = names
- latexnames = names
- for (name, pname, var_name, latex_name) in zip(var_names, snames, var_names, latex_names):
- assert ',' not in name
- check_instance(name, str)
- buf = OpenClSymbolicBuffer(name=name,
- pretty_name=pname,
- var_name=var_name,
- latex_name=latex_name,
- memory_object=None, **kwds)
- buffers += (buf,)
- return buffers
-
- @classmethod
- def symbolic_arrays(cls, *names, **kwds):
- from hysop.symbolic.array import OpenClSymbolicArray
+ def __symbolic_variables(cls, *names, **kwds):
+ scls = kwds.pop('scls')
+
arrays = ()
- if ('count' in kwds):
- count = kwds.pop('count')
+ shape = to_tuple(kwds.get('shape', kwds.get('count', ())))
+ if shape:
assert len(names)==1
- snames = tuple(names[0]+subscript(i) for i in xrange(count))
- var_names = tuple('{}{}'.format(names[0], i) for i in xrange(count))
- latex_names = tuple('{}_{{{}}}'.format(names[0], i) for i in xrange(count))
+ snames = tuple(names[0]+subscripts(idx,',',disable_unicode=False) for idx in np.ndindex(*shape))
+ var_names = tuple(names[0]+subscripts(idx,'_',disable_unicode=True) for idx in np.ndindex(*shape))
else:
snames = names
var_names = names
- latex_names = names
- for (name, pname, var_name, latex_name) in zip(var_names, snames, var_names, latex_names):
+ shape = len(names)
+ for (name, pname, var_name) in zip(var_names, snames, var_names):
assert ',' not in name
check_instance(name, str)
- arr = OpenClSymbolicArray(name=name, pretty_name=pname,
- var_name=var_name, latex_name=latex_name,
- memory_object=None, **kwds)
+ arr = scls(name=name, pretty_name=pname, var_name=var_name, **kwds)
arrays += (arr,)
- return arrays
+ return np.asarray(arrays).reshape(shape)
+
+ @classmethod
+ def symbolic_ndbuffers(cls, *names, **kwds):
+ from hysop.symbolic.array import OpenClSymbolicNdBuffer
+ assert 'memory_object' not in kwds
+ assert 'scls' not in kwds
+ kwds['memory_object'] = None
+ kwds['scls'] = OpenClSymbolicNdBuffer
+ return cls.__symbolic_variables(*names, **kwds)
+
+ @classmethod
+ def symbolic_buffers(cls, *names, **kwds):
+ from hysop.symbolic.array import OpenClSymbolicBuffer
+ assert 'memory_object' not in kwds
+ assert 'scls' not in kwds
+ kwds['memory_object'] = None
+ kwds['scls'] = OpenClSymbolicBuffer
+ return cls.__symbolic_variables(*names, **kwds)
+
+ @classmethod
+ def symbolic_arrays(cls, *names, **kwds):
+ from hysop.symbolic.array import OpenClSymbolicArray
+ assert 'memory_object' not in kwds
+ assert 'scls' not in kwds
+ kwds['scls'] = OpenClSymbolicArray
+ return cls.__symbolic_variables(*names, **kwds)
@classmethod
def symbolic_tmp_scalars(cls, *names, **kwds):
from hysop.symbolic.tmp import TmpScalar
- scalars = ()
- if ('count' in kwds):
- count = kwds.pop('count')
- assert len(names)==1
- snames = tuple(names[0]+subscript(i) for i in xrange(count))
- var_names = tuple('{}{}'.format(names[0], i) for i in xrange(count))
- latex_names = tuple('{}_{{{}}}'.format(names[0], i) for i in xrange(count))
- else:
- snames = names
- var_names = names
- latex_names = names
- for (name, pname, var_name, latex_name) in zip(var_names, snames, var_names, latex_names):
- assert ',' not in name
- check_instance(name, str)
- tmp = TmpScalar(name=name, pretty_name=pname,
- var_name=var_name, latex_name=latex_name,
- **kwds)
- scalars += (tmp,)
- return scalars
+ assert 'scls' not in kwds
+ kwds['scls'] = TmpScalar
+ return cls.__symbolic_variables(*names, **kwds)
+
+ @classmethod
+ def symbolic_constants(cls, *names, **kwds):
+ from hysop.symbolic.constant import SymbolicConstant
+ assert 'scls' not in kwds
+ kwds['scls'] = SymbolicConstant
+ return cls.__symbolic_variables(*names, **kwds)
@debug
def handle_method(self, method):
@@ -158,7 +151,7 @@ class OpenClSymbolic(OpenClOperator):
self.cr = method.pop(ComputeGranularity)
self.space_discretization = method.pop(SpaceDiscretization)
self.time_integrator = method.pop(TimeIntegrator)
- self.interpolation = method.pop(Interpolation)
+ self.interpolation = method.pop(MultiScaleInterpolation)
assert (2 <= self.space_discretization), self.space_discretization
assert (self.space_discretization % 2 == 0), self.space_discretization
@@ -223,7 +216,6 @@ class OpenClSymbolic(OpenClOperator):
@debug
def get_field_requirements(self):
"""Extract field requirements from first expression parsing stage."""
-
requirements = super(OpenClSymbolic, self).get_field_requirements()
for expr_info in self.expr_infos.values():
@@ -330,7 +322,7 @@ class OpenClSymbolic(OpenClOperator):
for (name, expr_info) in self.expr_infos.iteritems():
kernel, args_dict, update_input_parameters = \
- kernel_autotuner.autotune(expr_info=expr_info)
+ kernel_autotuner.autotune(expr_info=expr_info, **self.extra_kwds[name])
kl = kernel.build_launcher(**args_dict)
self.symbolic_kernels[name] = (kl, update_input_parameters)
diff --git a/hysop/backend/device/opencl/opencl_tools.py b/hysop/backend/device/opencl/opencl_tools.py
index cc4b66f6d9d69a798fef41653167d8d5722b1c54..155e8609a0acb7fcf8bb8aa62032631500854c0a 100644
--- a/hysop/backend/device/opencl/opencl_tools.py
+++ b/hysop/backend/device/opencl/opencl_tools.py
@@ -15,16 +15,16 @@
from hysop.deps import sys, os, re, itertools, hashlib, pickle, gzip, hashlib
from hysop import __VERBOSE__, __KERNEL_DEBUG__, \
- __DEFAULT_PLATFORM_ID__, __DEFAULT_DEVICE_ID__
+ __DEFAULT_PLATFORM_ID__, __DEFAULT_DEVICE_ID__
from hysop import vprint
from hysop.backend.device.opencl import cl, __OPENCL_PROFILE__
-from hysop.constants import np, Precision, DeviceType, HYSOP_REAL
-from hysop.core.mpi import MPI, main_comm
+from hysop.constants import np, Precision, DeviceType, HYSOP_REAL
+from hysop.core.mpi import MPI
from hysop.tools.parameters import MPIParams
-from hysop.tools.io_utils import IO
+from hysop.tools.io_utils import IO
from hysop.tools.decorators import static_vars
-from hysop.tools.types import check_instance, to_tuple, first_not_None
+from hysop.tools.types import check_instance, to_tuple, first_not_None
class KernelError(Exception):
@@ -32,7 +32,7 @@ class KernelError(Exception):
Custom exception for kernel errors.
"""
def __init__(msg, err):
- super(KernelError,self).__init__(msg)
+ super(KernelError, self).__init__(msg)
self.msg = msg
self.err = err
@@ -89,14 +89,14 @@ def convert_device_type(device_type):
if (device_type is None):
return None
check_instance(device_type, DeviceType)
-
+
conversion = {
- DeviceType.ALL: cl.device_type.ALL,
- DeviceType.ACCELERATOR: cl.device_type.ACCELERATOR,
- DeviceType.CPU: cl.device_type.CPU,
- DeviceType.GPU: cl.device_type.GPU,
- #DeviceType.CUSTOM: cl.device_type.CUSTOM,
- DeviceType.DEFAULT: cl.device_type.DEFAULT,
+ DeviceType.ALL: cl.device_type.ALL,
+ DeviceType.ACCELERATOR: cl.device_type.ACCELERATOR,
+ DeviceType.CPU: cl.device_type.CPU,
+ DeviceType.GPU: cl.device_type.GPU,
+ # DeviceType.CUSTOM: cl.device_type.CUSTOM,
+ DeviceType.DEFAULT: cl.device_type.DEFAULT,
}
if device_type not in conversion.keys():
@@ -105,6 +105,7 @@ def convert_device_type(device_type):
return conversion[device_type]
+
def convert_precision(precision):
"""
Converts a hysop precision to corresponding numpy dtype.
@@ -112,22 +113,22 @@ def convert_precision(precision):
if (precision is None):
return None
check_instance(precision, Precision)
-
+
if precision == Precision.SAME:
- msg='Cannot convert Precision.SAME to numpy dtype.'
+ msg = 'Cannot convert Precision.SAME to numpy dtype.'
raise ValueError(msg)
if precision == Precision.QUAD:
- msg= 'Numpy does not support the 128-bit IEEE quad precision data type.'
+ msg = 'Numpy does not support the 128-bit IEEE quad precision data type.'
raise RuntimeError(msg)
-
- #TODO when long double will be supported check if device has np.float96 or np.float128 long doubles
+
+ # TODO when long double will be supported check if device has np.float96 or np.float128 long doubles
# (ie padded to 3*32bits or 2*64bits)
conversion = {
- Precision.DEFAULT: HYSOP_REAL,
- Precision.LONG_DOUBLE: np.longdouble,
- Precision.DOUBLE: np.float64,
- Precision.FLOAT: np.float32,
- Precision.HALF: np.float16,
+ Precision.DEFAULT: HYSOP_REAL,
+ Precision.LONG_DOUBLE: np.longdouble,
+ Precision.DOUBLE: np.float64,
+ Precision.FLOAT: np.float32,
+ Precision.HALF: np.float16,
}
if precision not in conversion.keys():
@@ -137,44 +138,51 @@ def convert_precision(precision):
return conversion[precision]
+@static_vars(opencl_environments=dict())
+def get_device_number(platform_id=None):
+ platform_id = first_not_None(platform_id, __DEFAULT_PLATFORM_ID__)
+ platform = get_platform(platform_id, strict=True)
+ return len(platform.get_devices())
+
+
@static_vars(opencl_environments=dict())
def get_or_create_opencl_env(mpi_params,
- platform_id = None,
- device_id = None,
- device_type = None,
- gl_sharing=False,
- **kargs):
+ platform_id=None,
+ device_id=None,
+ device_type=None,
+ gl_sharing=False,
+ **kargs):
"""
Create or an OpenClEnvironment from given parameters if it does not already exists.
- All environements are kept alive (cached) in a dictionary local to this
+ All environements are kept alive (cached) in a dictionary local to this
function (ie. all opencl operators can share the same OpenClEnvironment).
"""
-
+
platform_id = first_not_None(platform_id, __DEFAULT_PLATFORM_ID__)
- device_id = first_not_None(device_id, __DEFAULT_DEVICE_ID__)
+ device_id = first_not_None(device_id, __DEFAULT_DEVICE_ID__)
device_type = first_not_None(device_type, DeviceType.ALL)
-
+
check_instance(mpi_params, MPIParams)
check_instance(platform_id, int)
check_instance(device_id, int)
check_instance(device_type, DeviceType, allow_none=True)
check_instance(gl_sharing, bool)
-
+
key = (mpi_params, platform_id, device_id, device_type, gl_sharing,)
-
+
opencl_envs = get_or_create_opencl_env.opencl_environments
if key in opencl_envs:
return opencl_envs[key]
-
+
from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
- env = OpenClEnvironment(platform_id=platform_id, device_id=device_id,
- device_type=device_type, gl_sharing=gl_sharing, mpi_params=mpi_params,
- **kargs)
+ env = OpenClEnvironment(platform_id=platform_id, device_id=device_id,
+ device_type=device_type, gl_sharing=gl_sharing, mpi_params=mpi_params,
+ **kargs)
opencl_envs[key] = env
return env
-
+
def create_queue(ctx, props=None):
"""
@@ -192,7 +200,6 @@ def create_queue(ctx, props=None):
return queue
-
def get_work_items(resolution, vector_width=1):
"""Set the optimal work-item number and OpenCL space index.
@@ -249,7 +256,6 @@ def get_work_items(resolution, vector_width=1):
return workItemNumber, gwi, lwi
-
def get_platform(platform_id, strict):
"""Returns an OpenCL platform
platform_id : int
@@ -265,17 +271,18 @@ def get_platform(platform_id, strict):
except IndexError:
plist = cl.get_platforms()
platform = plist[0]
- msg= ' Incorrect platform_id : {}'.format(platform_id)
- msg+=' Only {} are available.'.format(len(plist))
+ msg = ' Incorrect platform_id : {}'.format(platform_id)
+ msg += ' Only {} are available.'.format(len(plist))
if strict:
msg += '\n FATAL ERROR: Strict platform_id condition violated.\n'
print(msg)
raise
else:
- msg+=' --> getting default platform {}.'.format(platform.name)
+ msg += ' --> getting default platform {}.'.format(platform.name)
vprint(msg)
return platform
+
def get_device(platform, device_id, device_type, strict):
"""Returns an OpenCL device
@@ -301,7 +308,7 @@ def get_device(platform, device_id, device_type, strict):
else:
device = platform.get_devices()[device_id]
except IndexError:
- msg = '\nIncorrect device_id {}'.format(device_id)
+ msg = '\nIncorrect device_id {}'.format(device_id)
msg += '\nThere is only {} devices available.'.format(len(platform.get_devices()))
if strict:
msg += '\nFATAL ERROR: Strict device_id condition violated.\n'
@@ -312,7 +319,7 @@ def get_device(platform, device_id, device_type, strict):
vprint(msg)
device = platform.get_devices()[0]
except:
- msg = '\nCould not get a device of type {}'.format(device_type)
+ msg = '\nCould not get a device of type {}'.format(device_type)
if strict:
msg += '\nFATAL ERROR: Strict device_type condition violated.\n'
vprint(msg)
@@ -366,8 +373,6 @@ def get_context(devices, gl_sharing):
return ctx
-
-
def parse_opencl_file(f, n=8, nb_remesh_components=1):
"""Parse a file containing OpenCL sources.
diff --git a/hysop/backend/device/opencl/opencl_types.py b/hysop/backend/device/opencl/opencl_types.py
index d474928bd12fdda1aaf8a7590a0b358a3c3f01fe..203d6e5df1923462b73fc7bdfcf5780bc240ff4d 100644
--- a/hysop/backend/device/opencl/opencl_types.py
+++ b/hysop/backend/device/opencl/opencl_types.py
@@ -140,6 +140,7 @@ vtype_int = [np.int32, vec.int2, vec.int3, vec.int4, vec.int8, vec.int16 ]
vtype_uint = [np.uint32, vec.uint2, vec.uint3, vec.uint4, vec.uint8, vec.uint16 ]
vtype_simple = [np.float32, vec.float2, vec.float3, vec.float4, vec.float8, vec.float16 ]
vtype_double = [np.float64, vec.double2, vec.double3, vec.double4, vec.double8, vec.double16 ]
+cl_vec_types = vtype_int + vtype_uint + vtype_simple + vtype_double
make_int = [npmake(np.int32), vec.make_int2, vec.make_int3,
vec.make_int4, vec.make_int8,
@@ -218,6 +219,16 @@ def cl_type_to_dtype(cl_type):
N = components(cl_type)
return typen(btype,N)
+def cl_vec_type_to_scalar_and_count(cl_vec_type):
+ assert cl_vec_type in cl_vec_types
+ cvt = cl_vec_type
+ for vtypes in (vtype_int, vtype_uint, vtype_simple, vtype_double):
+ if cvt in vtypes:
+ btype = vtypes[0]
+ count = vsizes[vtypes.index(cvt)]
+ return (btype, count)
+ msg='cl_vec_types != U(vtype_*)'
+ raise RuntimeError(msg)
class TypeGen(object):
def __init__(self, fbtype='float', float_dump_mode='dec'):
diff --git a/hysop/backend/device/opencl/operator/analytic.py b/hysop/backend/device/opencl/operator/analytic.py
index 7ea4fce4e5c4a593a39fa182a6642bc3ad47ee11..916ea10ae34f194ad9928831115df67ae854e241 100644
--- a/hysop/backend/device/opencl/operator/analytic.py
+++ b/hysop/backend/device/opencl/operator/analytic.py
@@ -2,7 +2,7 @@
from hysop.deps import sm
from hysop.tools.types import check_instance, first_not_None, to_tuple
from hysop.tools.decorators import debug
-from hysop.fields.continuous_field import Field
+from hysop.fields.continuous_field import ScalarField, Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.backend.device.opencl.operator.custom_symbolic import OpenClCustomSymbolicOperator
from hysop.symbolic.relational import Assignment
@@ -23,7 +23,7 @@ class OpenClAnalyticField(OpenClCustomSymbolicOperator):
Parameters
----------
- field: hysop.field.continuous_field.Field
+ field: hysop.field.continuous_field.ScalarField
Continuous field to be modified.
formula : sm.Basic or array-like of sm.Basic
field.nb_components symbolic expressions as a tuple.
@@ -33,8 +33,8 @@ class OpenClAnalyticField(OpenClCustomSymbolicOperator):
Base class arguments.
"""
formula = to_tuple(formula)
- check_instance(field, Field)
- check_instance(formula, tuple, values=sm.Basic, size=field.nb_components)
+ check_instance(field, ScalarField)
+ check_instance(formula, tuple, values=(type(None),sm.Basic), size=field.nb_components)
check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
exprs = ()
diff --git a/hysop/backend/device/opencl/operator/directional/advection_dir.py b/hysop/backend/device/opencl/operator/directional/advection_dir.py
index c7e3ff9c411f4f658cb3742961e3802412923e1e..819034fe55efd0e5d5bac1d60fe3fa57c5d0bf66 100644
--- a/hysop/backend/device/opencl/operator/directional/advection_dir.py
+++ b/hysop/backend/device/opencl/operator/directional/advection_dir.py
@@ -142,7 +142,7 @@ class OpenClDirectionalAdvection(DirectionalAdvectionBase, OpenClDirectionalOper
kwds['remesh_criteria_eps'] = self.remesh_criteria_eps
kwds['force_atomics'] = self.force_atomics
kwds['relax_min_particles'] = self.relax_min_particles
-
+
assert len(scalars_in)==len(scalars_out)
kl = OpenClKernelListLauncher(name='remesh')
for (Sin, Sout) in zip(scalars_in, scalars_out):
@@ -151,6 +151,7 @@ class OpenClDirectionalAdvection(DirectionalAdvectionBase, OpenClDirectionalOper
(remesh_kernel, args_dict) = kernel.autotune(force_verbose=self._force_autotuner_verbose,
force_debug=self._force_autotuner_debug, hardcode_arrays=True, **kwds)
kl += remesh_kernel.build_launcher(**args_dict)
+ self.remesh_kernel_launcher = kl
return kl
def _collect_redistribute_kernels(self):
@@ -158,8 +159,9 @@ class OpenClDirectionalAdvection(DirectionalAdvectionBase, OpenClDirectionalOper
dsoutputs = self.dadvected_fields_out
kl = OpenClKernelListLauncher(name='accumulate_and_exchange_ghosts')
for sout in dsoutputs.values():
+ ghosts = tuple(sout.ghosts[:-1])+(self.remesh_ghosts,)
kl += sout.accumulate_ghosts(directions=sout.dim-1,
- ghosts=remesh_ghosts,
+ ghosts=ghosts,
build_launcher=True)
kl += sout.exchange_ghosts(build_launcher=True)
self.accumulate_and_exchange = kl
diff --git a/hysop/backend/device/opencl/operator/directional/stretching_dir.py b/hysop/backend/device/opencl/operator/directional/stretching_dir.py
index e062196d4820902ccd86f3c61fb00feffa17639b..cab44515bb67e7ef7e428f9f9038c33c937b55b6 100644
--- a/hysop/backend/device/opencl/operator/directional/stretching_dir.py
+++ b/hysop/backend/device/opencl/operator/directional/stretching_dir.py
@@ -3,7 +3,7 @@ from hysop import Field, TopologyDescriptor
from hysop.deps import np
from hysop.tools.decorators import debug
from hysop.tools.types import check_instance
-from hysop.core.graph.graph import not_initialized, initialized, discretized, ready
+from hysop.core.graph.graph import not_initialized, initialized, discretized, ready, op_apply
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.constants import StretchingFormulation, BoundaryCondition
@@ -195,7 +195,7 @@ class OpenClDirectionalStretching(OpenClDirectionalOperator):
velocity_mesh_info=velocity_mesh_info,
vorticity_mesh_info=vorticity_mesh_info)
- @debug
+ @op_apply
def apply(self,**kargs):
super(OpenClDirectionalStretching,self).apply(**kargs)
raise NotImplementedError()
diff --git a/hysop/backend/device/opencl/operator/enstrophy.py b/hysop/backend/device/opencl/operator/enstrophy.py
index e996f21547b9d34e20d27623005cc4e96e69757e..c587f106276472f552b2debb08e9808a37f74e5c 100644
--- a/hysop/backend/device/opencl/operator/enstrophy.py
+++ b/hysop/backend/device/opencl/operator/enstrophy.py
@@ -56,4 +56,7 @@ class OpenClEnstrophy(EnstrophyBase, OpenClSymbolic):
evt = self.WdotW_kernel(queue=queue, **self.WdotW_update_parameters())
evt = self.sum_kernel(queue=queue)
evt.wait()
- self.enstrophy.value = self.coeff * self.sum_kernel.out.get()[0]
+ local_enstrophy = self.coeff * self.sum_kernel.out.get()[0]
+
+ # collect enstrophy from all processes
+ self.enstrophy.value = self._collect(local_enstrophy)
diff --git a/hysop/backend/device/opencl/operator/external_force.py b/hysop/backend/device/opencl/operator/external_force.py
index 7fe49b28518f6d17546c6f38805f896a7060cb1e..6bbce34dbd2f6df4a2f8bd5beba1b8b1c810efbd 100644
--- a/hysop/backend/device/opencl/operator/external_force.py
+++ b/hysop/backend/device/opencl/operator/external_force.py
@@ -293,7 +293,8 @@ class SymbolicExternalForce(ExternalForce):
self.ghost_exchangers = ghost_exchangers
self.compute_statistics = compute_statistics
self.update_statistics = update_statistics
-
+
+ @op_apply
def apply(self, op, **kwds):
for (field, Ft) in self.forward_transforms.iteritems():
evt = Ft()
diff --git a/hysop/backend/device/opencl/operator/integrate.py b/hysop/backend/device/opencl/operator/integrate.py
index 1bec265d0859a0639e6e910fd2f44920506e1ea6..6fb77abe3f8d3f25d05716b8ad6140c66ce9ce7a 100644
--- a/hysop/backend/device/opencl/operator/integrate.py
+++ b/hysop/backend/device/opencl/operator/integrate.py
@@ -1,14 +1,15 @@
-
from hysop.tools.decorators import debug
from hysop.backend.device.opencl.opencl_operator import OpenClOperator, op_apply
from hysop.operator.base.integrate import IntegrateBase
+import pyopencl
+
class OpenClIntegrate(IntegrateBase, OpenClOperator):
@debug
def __init__(self, **kwds):
super(OpenClIntegrate, self).__init__(**kwds)
-
+
@debug
def get_field_requirements(self):
# force 0 ghosts for the reduction (pyopencl reduction kernel)
@@ -16,26 +17,53 @@ class OpenClIntegrate(IntegrateBase, OpenClOperator):
topo, req = requirements.get_input_requirement(self.field)
req.max_ghosts = (0,)*self.field.dim
return requirements
-
+
@debug
def setup(self, work):
super(OpenClIntegrate, self).setup(work)
- self.sum_kernels = tuple(self.dF.backend.sum(a=self.dF.data[i],
- build_kernel_launcher=True, async=True)
- for i in xrange(self.dF.nb_components))
-
+ if self.expr is None:
+ self.sum_kernels = tuple(
+ self.dF.backend.sum(a=self.dF.data[i],
+ build_kernel_launcher=True, async=True)
+ for i in xrange(self.dF.nb_components))
+ else:
+ from hysop.backend.device.codegen.base.variables import dtype_to_ctype
+ self.sum_kernels = tuple(
+ pyopencl.reduction.ReductionKernel(
+ self.cl_env.context,
+ self.dF.dtype,
+ neutral='0',
+ reduce_expr="a+b",
+ map_expr=self.expr,
+ arguments="__global {} *x".format(dtype_to_ctype(self.dF.dtype)))
+ for i in xrange(self.dF.nb_components))
+
@op_apply
def apply(self, **kwds):
+ value = self.parameter._value.copy()
queue = self.cl_env.default_queue
evts = ()
- for knl in self.sum_kernels:
- evt = knl(queue=queue)
- evts += (evt,)
- value = self.parameter._value.copy()
- for (i,evt) in enumerate(evts):
- evt.wait()
- Pi = self.sum_kernels[i].out.get()[0]
+ values = ()
+ if self.expr is None:
+ for knl in self.sum_kernels:
+ evt = knl(queue=queue)
+ evts += (evt,)
+ for (i, evt) in enumerate(evts):
+ evt.wait()
+ values += (self.sum_kernels[i].out.get()[0],)
+ else:
+ outs = ()
+ for i, knl in enumerate(self.sum_kernels):
+ out, evt = knl(self.dF.buffers[i], queue=queue, return_event=True)
+ evts += (evt,)
+ outs += (out,)
+ for (i, evt) in enumerate(evts):
+ evt.wait()
+ values += (outs[i].get(),)
+
+ for i, Pi in enumerate(values):
if (self.scaling_coeff[i] is None):
self.scaling_coeff[i] = 1.0 / Pi
value[i] = self.scaling_coeff[i] * Pi
- self.parameter.value = value
+ # compute value from all processes
+ self.parameter.value = self._collect(value)
diff --git a/hysop/backend/device/opencl/operator/spatial_filtering.py b/hysop/backend/device/opencl/operator/spatial_filtering.py
index b04b9a82d766061593a115062e8c7a622cfa6f04..1501c1b295ecee4d7d81556c6b763c02eeb263fd 100644
--- a/hysop/backend/device/opencl/operator/spatial_filtering.py
+++ b/hysop/backend/device/opencl/operator/spatial_filtering.py
@@ -1,19 +1,182 @@
+import numpy as np
import functools
+
from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import debug
+from hysop.tools.numpywrappers import npw
from hysop.backend.device.opencl.opencl_operator import OpenClOperator
from hysop.core.graph.graph import op_apply
from hysop.fields.continuous_field import Field
from hysop.parameters.parameter import Parameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
-from hysop.operator.base.spatial_filtering import RemeshLowpassFilterBase, SpectralLowpassFilterBase
+from hysop.operator.base.spatial_filtering import RemeshRestrictionFilterBase, SpectralRestrictionFilterBase, \
+ SubgridRestrictionFilterBase, PolynomialInterpolationFilterBase, PolynomialRestrictionFilterBase
+from hysop.backend.device.opencl.opencl_symbolic import OpenClSymbolic
from hysop.backend.device.opencl.opencl_copy_kernel_launchers import OpenClCopyBufferRectLauncher
from hysop.backend.device.opencl.opencl_kernel_launcher import OpenClKernelListLauncher
from hysop.backend.device.opencl.opencl_elementwise import OpenClElementwiseKernelGenerator
+from hysop.symbolic import local_indices_symbols
from hysop.symbolic.relational import Assignment
-class OpenClSpectralLowpassFilter(SpectralLowpassFilterBase, OpenClOperator):
+class OpenClPolynomialInterpolationFilter(PolynomialInterpolationFilterBase, OpenClOperator):
+
+ @debug
+ def discretize(self):
+ if self.discretized:
+ return
+ super(OpenClPolynomialInterpolationFilter, self).discretize()
+ dFin = self.dFin
+ dFout = self.dFout
+ gr = self.grid_ratio
+ dim = dFin.dim
+ assert dFin.is_scalar
+ assert dFout.is_scalar
+ assert self.subgrid_interpolator.gr == gr
+
+ ekg = self.elementwise_kernel_generator
+ Wr = self.subgrid_interpolator.Wr
+ n = self.subgrid_interpolator.n
+ ghosts = np.asarray(self.subgrid_interpolator.ghosts)
+
+ I = np.asarray(local_indices_symbols[:dim][::-1])
+ fin, fout = ekg.dfields_to_ndbuffers(dFin, dFout)
+ Fin = ekg.symbolic_tmp_scalars('F', shape=n, dtype=dFin.dtype)
+ Fout_values = Wr.dot(Fin.ravel()).reshape(gr)
+
+ exprs = ()
+ for idx in np.ndindex(*n):
+ e = Assignment(Fin[idx], fin(I+idx-ghosts))
+ exprs += (e,)
+ for idx in np.ndindex(*gr):
+ e = Assignment(fout(gr*I+idx), Fout_values[idx])
+ exprs += (e,)
+ kname='interpolate_grid_{}'.format(self.polynomial_interpolation_method).lower()
+ interpolate_grid_kernel, _ = ekg.elementwise_kernel(kname,
+ *exprs, compute_resolution=self.iter_shape, debug=False)
+
+ exchange_ghosts = self.dFout.exchange_ghosts(build_launcher=True)
+
+ kl = OpenClKernelListLauncher(name=kname)
+ kl += interpolate_grid_kernel
+ kl += exchange_ghosts
+
+ self.execute_kernels = functools.partial(kl, queue=self.cl_env.default_queue)
+
+ @op_apply
+ def apply(self, **kwds):
+ super(OpenClPolynomialInterpolationFilter, self).apply(**kwds)
+ evt = self.execute_kernels()
+
+
+class OpenClPolynomialRestrictionFilter(PolynomialRestrictionFilterBase, OpenClOperator):
+
+ @debug
+ def discretize(self):
+ if self.discretized:
+ return
+ super(OpenClPolynomialRestrictionFilter, self).discretize()
+ dFin = self.dFin
+ dFout = self.dFout
+ gr = self.grid_ratio
+ dim = dFin.dim
+ assert dFin.is_scalar
+ assert dFout.is_scalar
+ assert self.subgrid_restrictor.gr == gr
+
+ ekg = self.elementwise_kernel_generator
+ Rr = self.subgrid_restrictor.Rr / self.subgrid_restrictor.GR
+ ghosts = np.asarray(self.subgrid_restrictor.ghosts)
+
+ I = np.asarray(local_indices_symbols[:dim][::-1])
+ fin, fout = ekg.dfields_to_ndbuffers(dFin, dFout)
+
+ def gen_inputs(*idx):
+ return fin(gr*I+idx-ghosts)
+ input_values = np.asarray(tuple(map(gen_inputs, np.ndindex(*Rr.shape)))).reshape(Rr.shape)
+ output_value = (Rr*input_values).sum()
+
+ e = Assignment(fout(I), output_value)
+ exprs = (e,)
+
+ kname='restrict_grid_{}'.format(self.polynomial_interpolation_method).lower()
+ restriction_grid_kernel, _ = ekg.elementwise_kernel(kname,
+ *exprs, compute_resolution=self.iter_shape, debug=False)
+
+ exchange_ghosts = self.dFout.exchange_ghosts(build_launcher=True)
+
+ kl = OpenClKernelListLauncher(name=kname)
+ kl += restriction_grid_kernel
+ kl += exchange_ghosts
+
+ self.execute_kernels = functools.partial(kl, queue=self.cl_env.default_queue)
+
+ @op_apply
+ def apply(self, **kwds):
+ super(OpenClPolynomialRestrictionFilter, self).apply(**kwds)
+ evt = self.execute_kernels()
+
+
+class OpenClSubgridRestrictionFilter(SubgridRestrictionFilterBase, OpenClSymbolic):
+ """
+ OpenCL implementation for lowpass spatial filtering: small grid -> coarse grid
+ using the subgrid method.
+ """
+ def __init__(self, **kwds):
+ super(OpenClSubgridRestrictionFilter, self).__init__(**kwds)
+ Fin = self.Fin
+ Fout = self.Fout
+ dim = Fin.dim
+ assert Fin.is_scalar
+ assert Fout.is_scalar
+
+ # We do not know the grid ratio and array strides before discretization.
+ # so we defer the initialization of those integers with symbolic constants.
+ symbolic_input_buffer, = self.symbolic_buffers('fine_grid')
+ symbolic_output_buffer = self.Fout.s()
+
+ symbolic_grid_ratio = self.symbolic_constants('gr', count=dim, dtype=npw.int32)
+ symbolic_input_strides = self.symbolic_constants('is', count=dim, dtype=npw.int32)
+ symbolic_input_ghosts = self.symbolic_constants('gs', count=dim, dtype=npw.int32)
+
+ I = local_indices_symbols[:dim][::-1]
+ read_idx = npw.dot(symbolic_input_strides, npw.add(npw.multiply(symbolic_grid_ratio, I), symbolic_input_ghosts))
+ expr = Assignment(symbolic_output_buffer, symbolic_input_buffer[read_idx])
+ self.require_symbolic_kernel('extract_subgrid', expr)
+
+ self.symbolic_input_buffer = symbolic_input_buffer
+ self.symbolic_output_buffer = symbolic_output_buffer
+ self.symbolic_grid_ratio = symbolic_grid_ratio
+ self.symbolic_input_strides = symbolic_input_strides
+ self.symbolic_input_ghosts = symbolic_input_ghosts
+
+ @debug
+ def setup(self, work):
+ dFin, dFout = self.dFin, self.dFout
+ ibuffer, obuffer = dFin.sbuffer, dFout.sbuffer
+ self.symbolic_input_buffer.bind_memory_object(ibuffer)
+ for i in xrange(dFin.dim):
+ self.symbolic_grid_ratio[i].bind_value(self.grid_ratio[i])
+ self.symbolic_input_strides[i].bind_value(ibuffer.strides[i] // ibuffer.dtype.itemsize)
+ self.symbolic_input_ghosts[i].bind_value(dFin.ghosts[i])
+
+ super(OpenClSubgridRestrictionFilter, self).setup(work)
+
+ (extract_subgrid, _) = self.symbolic_kernels['extract_subgrid']
+ exchange_ghosts = self.dFout.exchange_ghosts(build_launcher=True)
+
+ kl = OpenClKernelListLauncher(name='extract_subgrid')
+ kl += extract_subgrid
+ kl += exchange_ghosts
+
+ self.execute_kernels = functools.partial(kl, queue=self.cl_env.default_queue)
+
+ @op_apply
+ def apply(self, **kwds):
+ evt = self.execute_kernels()
+
+
+class OpenClSpectralRestrictionFilter(SpectralRestrictionFilterBase, OpenClOperator):
"""
OpenCL implementation for lowpass spatial filtering: small grid -> coarse grid
using the spectral method.
@@ -68,7 +231,7 @@ class OpenClSpectralLowpassFilter(SpectralLowpassFilterBase, OpenClOperator):
@op_apply
def apply(self, **kwds):
"""Apply spectral filter (which is just a square window centered on low frequencies)."""
- super(OpenClSpectralLowpassFilter, self).apply(**kwds)
+ super(OpenClSpectralRestrictionFilter, self).apply(**kwds)
evt = self.Ft(**kwds)
evt = self.filter()
evt = self.Bt(**kwds)
diff --git a/hysop/backend/host/fortran/__init__.py b/hysop/backend/host/fortran/__init__.py
index 8b137891791fe96927ad78e64b0aad7bded08bdc..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/hysop/backend/host/fortran/__init__.py
+++ b/hysop/backend/host/fortran/__init__.py
@@ -1 +0,0 @@
-
diff --git a/hysop/backend/host/fortran/operator/diffusion.py b/hysop/backend/host/fortran/operator/diffusion.py
index 5a9bf4749c7e57ff8fa646596f8700abb7690213..631584a942eea3b08ffbb66eec0a0875ecf86cc0 100644
--- a/hysop/backend/host/fortran/operator/diffusion.py
+++ b/hysop/backend/host/fortran/operator/diffusion.py
@@ -1,6 +1,6 @@
from hysop.backend.host.fortran.operator.fortran_fftw import FortranFFTWOperator, fftw2py
-from hysop.tools.types import check_instance, InstanceOf
-from hysop.tools.decorators import debug
+from hysop.tools.types import check_instance, InstanceOf
+from hysop.tools.decorators import debug
from hysop.tools.numpywrappers import npw
from hysop.fields.continuous_field import Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
@@ -73,7 +73,7 @@ class DiffusionFFTW(FortranFFTWOperator):
def initialize(self, **kwds):
- super(DiffusionFFTW,self).initialize(**kwds)
+ super(DiffusionFFTW, self).initialize(**kwds)
dim = self.dim
if (dim==2):
# only 1-component fields are supported in 2D
@@ -81,11 +81,16 @@ class DiffusionFFTW(FortranFFTWOperator):
self._nfields_per_call = 1
elif (dim==3):
# only 3-component fields are supported in 3D
- if (self.Fin.nb_components % 3 != 0):
- msg='Only mutiple of 3-component fields are supported for 3D FFTW diffusion.'
+ if (self.Fin.nb_components % 3 == 0):
+ self._solve = self._solve_3d
+ self._nfields_per_call = 3
+ elif (self.Fin.nb_components == 1):
+ self._solve = self._solve_3d_scalar
+ self._nfields_per_call = 1
+ else:
+ msg='Only mutiple of 3-component fields or scalar fields'
+ msg += ' are supported for 3D FFTW diffusion.'
raise NotImplementedError(msg)
- self._solve = self._solve_3d
- self._nfields_per_call = 3
else:
raise NotImplementedError(str(dim) + "D case not yet implemented.")
@@ -114,17 +119,17 @@ class DiffusionFFTW(FortranFFTWOperator):
super(DiffusionFFTW,self).apply(**kargs)
nudt = self.dt()*self.nu()
buffers, ghosts = self.buffers, self.ghosts
-
+
if (not self.is_inplace):
self.dFout.copy(self.dFin, compute_slice=True)
-
+
nfields_per_call = self._nfields_per_call
for i in xrange(self.dFout.nb_components // nfields_per_call):
bufs = buffers[nfields_per_call*i:nfields_per_call*(i+1)]
self._solve(nudt, ghosts, *bufs)
-
+
self.dFout.exchange_ghosts()
-
+
def _solve_2d(self, nudt, ghosts, *buffers):
"""
Solve 2D diffusion problem, 1-component buffer expected
@@ -136,3 +141,9 @@ class DiffusionFFTW(FortranFFTWOperator):
Solve 3D diffusion problem, 3-component buffers expected
"""
fftw2py.solve_diffusion_3d(nudt, *(buffers + (ghosts,)))
+
+ def _solve_3d_scalar(self, nudt, ghosts, *buffers):
+ """
+ Solve 3D diffusion problem, scalar buffers expected
+ """
+ fftw2py.solve_diffusion_scalar_3d(nudt, buffers, ghosts)
diff --git a/hysop/backend/host/fortran/operator/fortran_fftw.py b/hysop/backend/host/fortran/operator/fortran_fftw.py
index 529453a8875dd22a569249f46141808fb4883b8b..87c552aabc51fff77872767178d61e902d5b5e97 100644
--- a/hysop/backend/host/fortran/operator/fortran_fftw.py
+++ b/hysop/backend/host/fortran/operator/fortran_fftw.py
@@ -4,7 +4,8 @@ try:
from hysop.f2hysop import fftw2py
except ImportError:
raise
- msg = 'HySoP fortran fftw bindings are not available for your hysop install.'
+ msg = 'HySoP fortran fftw bindings are not available '
+ msg += 'for your hysop install.'
msg += 'Try to recompile HySoP with WITH_FFTW=ON'
raise ImportError(msg)
@@ -18,17 +19,35 @@ from hysop.fields.continuous_field import Field
from hysop.backend.host.fortran.fortran_operator import FortranOperator
class FortranFFTWOperator(FortranOperator):
+ """Base class for Fortran FFTW interface.
+
+ Defines HySoP compatible fields requirements and initializes
+ fftw2py interface.
+ """
@debug
def __init__(self, input_fields, output_fields, **kwds):
- super(FortranFFTWOperator, self).__init__(input_fields=input_fields,
- output_fields=output_fields, **kwds)
-
- check_instance(input_fields, dict, keys=Field, values=CartesianTopologyDescriptors)
- check_instance(output_fields, dict, keys=Field, values=CartesianTopologyDescriptors)
-
- for f in set(input_fields.keys()+output_fields.keys()):
- for fi in f.fields:
+ """
+ Parameters
+ ----------
+ input_field : dictionary of fields:topology with
+ :class:`~hysop.fields.continuous_field.Field` as keys
+ output_field: dictionary of fields:topology with
+ :class:`~hysop.fields.continuous_field.Field` as keys
+ """
+ super(FortranFFTWOperator, self).__init__(
+ input_fields=input_fields,
+ output_fields=output_fields,
+ **kwds)
+ check_instance(input_fields, dict, keys=Field,
+ values=CartesianTopologyDescriptors)
+ check_instance(output_fields, dict, keys=Field,
+ values=CartesianTopologyDescriptors)
+
+ nb_components =input_fields.keys()[0].nb_components
+ tensor_fields = set(input_fields.keys()+output_fields.keys())
+ for tf in tensor_fields:
+ for fi in tf.fields:
if (fi.dtype != HYSOP_REAL):
msg='FortranFFTW operators only work with HYSOP_REAL precision specified during hysop '
msg+='build.'
@@ -43,8 +62,9 @@ class FortranFFTWOperator(FortranOperator):
msg+='\n lboundaries: {}'.format(fi.lboundaries)
msg+='\n rboundaries: {}'.format(fi.rboundaries)
raise RuntimeError(msg)
-
-
+
+ # Special case: 3D diffusion of a scalar
+ self._scalar_3d = (nb_components == 1) and all(tf.nb_components==1 for tf in tensor_fields)
domain = self.input_fields.keys()[0].domain
self.dim = domain.dim
@@ -54,16 +74,15 @@ class FortranFFTWOperator(FortranOperator):
def get_field_requirements(self):
requirements = super(FortranFFTWOperator, self).get_field_requirements()
dim = self.domain.dim
-
+
# Set can_split to True in all directions except the contiguous one
# for inputs and outputs.
for is_input, (field, td, req) in requirements.iter_requirements():
- can_split = req.can_split
- can_split[:-1] = False
- can_split[-1] = True
+ can_split = [False, ] * dim
+ can_split[0] = True
req.can_split = can_split
return requirements
-
+
@debug
def get_node_requirements(self):
node_reqs = super(FortranFFTWOperator, self).get_node_requirements()
@@ -90,15 +109,15 @@ class FortranFFTWOperator(FortranOperator):
@debug
def get_work_properties(self):
- return super(FortranFFTWOperator,self).get_work_properties()
+ return super(FortranFFTWOperator, self).get_work_properties()
@debug
def setup(self, work=None):
- super(FortranFFTWOperator,self).setup(work=work)
+ super(FortranFFTWOperator, self).setup(work=work)
@debug
def finalize(self, clean_fftw_solver=False, **kwds):
- super(FortranFFTWOperator,self).finalize(**kwds)
+ super(FortranFFTWOperator, self).finalize(**kwds)
if clean_fftw_solver:
fftw2py.clean_fftw_solver(self.dim)
@@ -114,18 +133,27 @@ class FortranFFTWOperator(FortranOperator):
comm = self.mpi_params.comm
size = self.mpi_params.size
- msg = 'input topology is not compliant with fftw.'
+ msg = 'input topology is not compliant with fftw. {} {}'.format(
+ topo.cart_dim, topo.proc_shape)
assert topo.cart_dim == 1, msg
- assert topo.cart_shape[-1] == size, msg
-
+ assert topo.proc_shape[-1] == size, msg
+
global_resolution = topo.global_resolution.astype(npw.int64)
length = topo.domain.length.astype(HYSOP_REAL)
- local_resolution, global_start = fftw2py.init_fftw_solver(
+ if self._scalar_3d:
+ local_resolution, global_start = fftw2py.init_fftw_solver_scalar(
+ global_resolution, length, comm=comm.py2f())
+ else:
+ local_resolution, global_start = fftw2py.init_fftw_solver(
global_resolution, length, comm=comm.py2f())
- assert (topo.mesh.local_resolution == local_resolution).all(),'Local resolution mismatch.'
- assert (topo.mesh.global_start == global_start).all(), 'Global start mismatch.'
+ assert (topo.mesh.compute_resolution == local_resolution).all(), \
+ 'Local resolution mismatch ({} != {}).'.format(
+ topo.mesh.compute_resolution, local_resolution)
+ assert (topo.mesh.global_start == global_start).all(), \
+ 'Global start mismatch ({} != {}).'.format(
+ topo.mesh.global_start, global_start)
@classmethod
def supports_mpi(cls):
diff --git a/hysop/backend/host/fortran/operator/poisson.py b/hysop/backend/host/fortran/operator/poisson.py
index 662be77cfe0bec173a7b6339e32d3086017806d5..6f5638ff9506973ba2f8af09ad16fa54d695e4d5 100644
--- a/hysop/backend/host/fortran/operator/poisson.py
+++ b/hysop/backend/host/fortran/operator/poisson.py
@@ -1,12 +1,10 @@
-from hysop.tools.types import check_instance, InstanceOf
-from hysop.tools.decorators import debug
-from hysop.tools.numpywrappers import npw
+from hysop.tools.types import check_instance
+from hysop.tools.decorators import debug
from hysop.fields.continuous_field import Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
-from hysop.constants import FieldProjection
from hysop.backend.host.fortran.operator.fortran_fftw import fftw2py, FortranFFTWOperator
from hysop.core.graph.graph import op_apply
-import numpy as np
+from hysop.constants import HYSOP_REAL
class PoissonFFTW(FortranFFTWOperator):
@@ -47,9 +45,10 @@ class PoissonFFTW(FortranFFTWOperator):
input_fields = {Fin: variables[Fin]}
output_fields = {Fout: variables[Fout]}
- super(PoissonFFTW, self).__init__(input_fields=input_fields,
- output_fields=output_fields,
- **kwds)
+ super(PoissonFFTW, self).__init__(
+ input_fields=input_fields,
+ output_fields=output_fields,
+ **kwds)
self.Fin = Fin
self.Fout = Fout
@@ -66,18 +65,18 @@ class PoissonFFTW(FortranFFTWOperator):
if self.discretized:
return
super(PoissonFFTW, self).discretize()
- self.dFin = self.get_input_discrete_field(self.Fin)
+ self.dFin = self.get_input_discrete_field(self.Fin)
self.dFout = self.get_output_discrete_field(self.Fout)
assert (self.dFin.ghosts == self.dFout.ghosts).all(), \
"Input and output fields must have the same ghosts."
- self.ghosts = self.dFin.ghosts.astype(np.int64) # prevent f2py copy
+ self.ghosts = self.dFin.ghosts.astype(HYSOP_REAL) # prevent f2py copy
self.buffers = self.dFin.buffers + self.dFout.buffers
@op_apply
def apply(self, **kargs):
+ """Solves Poisson equation
+ """
super(PoissonFFTW, self).apply(**kargs)
(buf_in, buf_out) = self.buffers
self._solve(buf_in, buf_out, self.ghosts)
- buf_out[...] *= -1
self.dFout.exchange_ghosts()
-
diff --git a/hysop/backend/host/fortran/operator/poisson_curl.py b/hysop/backend/host/fortran/operator/poisson_curl.py
index eb18be4656b00ab9618be8410dd09a762c372fa6..2ba02d42e30c9b0917dd7481a7f79850810db99e 100644
--- a/hysop/backend/host/fortran/operator/poisson_curl.py
+++ b/hysop/backend/host/fortran/operator/poisson_curl.py
@@ -1,6 +1,5 @@
-from hysop.tools.types import check_instance, InstanceOf
-from hysop.tools.decorators import debug
-from hysop.tools.numpywrappers import npw
+from hysop.tools.types import check_instance
+from hysop.tools.decorators import debug
from hysop.fields.continuous_field import Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.constants import FieldProjection
@@ -14,10 +13,12 @@ class FortranPoissonCurl(PoissonCurlOperatorBase, FortranFFTWOperator):
def initialize(self, **kwds):
super(FortranPoissonCurl, self).initialize(**kwds)
dim = self.dim
- if (dim==2):
- self._solve = self._solve_2d
- elif (dim==3):
- self._solve = self._solve_3d
+ if (dim == 2):
+ self._solve_poisson = self._solve_poisson_2d
+ self._solve_diffuse = self._solve_diffuse_2d
+ elif (dim == 3):
+ self._solve_poisson = self._solve_poisson_3d
+ self._solve_diffuse = self._solve_diffuse_3d
else:
raise NotImplementedError('dim = {}'.format(dim))
@@ -29,11 +30,12 @@ class FortranPoissonCurl(PoissonCurlOperatorBase, FortranFFTWOperator):
ghosts_u = dU.ghosts.astype(np.int64)
ghosts_w = dW.ghosts.astype(np.int64)
-
+
poisson_buffers = dW.buffers + dU.buffers
assert all(b.flags.f_contiguous for b in poisson_buffers)
self.poisson_args = poisson_buffers + (ghosts_w, ghosts_u)
+ self.diffuse_args = dW.buffers + (ghosts_w, )
self.projection_args = dW.buffers + (ghosts_w,)
@op_apply
@@ -42,9 +44,12 @@ class FortranPoissonCurl(PoissonCurlOperatorBase, FortranFFTWOperator):
if self.do_project(simulation):
self._project()
self.dW.exchange_ghosts()
- self._solve()
+ if self.should_diffuse:
+ self._solve_diffuse()
+ self.dW.exchange_ghosts()
+ self._solve_poisson()
self.dU.exchange_ghosts()
-
+
def _project(self):
"""
Apply projection on vorticity such that the
@@ -53,15 +58,27 @@ class FortranPoissonCurl(PoissonCurlOperatorBase, FortranFFTWOperator):
"""
fftw2py.projection_om_3d(*self.projection_args)
- def _solve_2d(self):
+ def _solve_poisson_2d(self):
"""
Solve 2D poisson problem, no projection, no correction.
"""
fftw2py.solve_poisson_2d(*self.poisson_args)
-
- def _solve_3d(self):
+
+ def _solve_poisson_3d(self):
"""
- Solve 3D poisson problem, no projection, no correction
+ Solve 3D poisson problem, no projection, no correction.
"""
fftw2py.solve_poisson_3d(*self.poisson_args)
+
+ def _solve_diffuse_2d(self):
+ """
+ Solve 2D diffusion problem, 1-component buffer expected
+ """
+ fftw2py.solve_diffusion_2d(self.nu()*self.dt(), *self.diffuse_args)
+
+ def _solve_diffuse_3d(self):
+ """
+ Solve 3D poisson problem with diffusion, no projection, no correction.
+ """
+ fftw2py.solve_diffusion_3d(self.nu()*self.dt(), *self.diffuse_args)
diff --git a/hysop/backend/host/fortran/operator/scales_advection.py b/hysop/backend/host/fortran/operator/scales_advection.py
index 100845d30cc8d4114c70487d374495522b75b0fa..fe175eb419301fe765740a00d71a10dcf33b2699 100644
--- a/hysop/backend/host/fortran/operator/scales_advection.py
+++ b/hysop/backend/host/fortran/operator/scales_advection.py
@@ -1,14 +1,10 @@
-# coding: utf-8
-
-import hysop
-import numpy as np
-
try:
from hysop.f2hysop import scales2py as scales
except ImportError:
msgE = 'scales package not available for your hysop install.'
msgE += 'Try to recompile with WITH_SCALES=ON'
raise ImportError(msgE)
+from hysop import __VERBOSE__, __DEBUG__
from hysop.constants import HYSOP_REAL
from hysop.tools.decorators import debug
from hysop.core.graph.computational_operator import ComputationalGraphOperator
@@ -51,7 +47,7 @@ class ScalesAdvection(FortranOperator):
Interpolation.M4: 'M4',
Interpolation.Mp4: 'Mp4'}
- __dim_splitting_to_scales = {StrangOrder.STRANG_FIRST_ORDER: 'classic',
+ __dim_splitting_to_scales = {StrangOrder.STRANG_FIRST_ORDER: 'classic',
StrangOrder.STRANG_SECOND_ORDER: 'strang'}
__default_method = {
@@ -85,8 +81,7 @@ class ScalesAdvection(FortranOperator):
@debug
def __init__(self, velocity,
advected_fields_in, advected_fields_out,
- variables, dt,
- **kwds):
+ variables, dt, **kwds):
"""Particle advection of field(s),
on any backend, with cartesian remeshing.
@@ -140,14 +135,14 @@ class ScalesAdvection(FortranOperator):
assert is_inplace, 'Cannot mix inplace and out of place scales advection.'
else:
is_inplace = False
-
+
super(ScalesAdvection, self).__init__(
input_fields=input_fields,
output_fields=output_fields,
input_params=input_params,
output_params=output_params,
**kwds)
-
+
if (velocity.dim != 3) or (velocity.nb_components != 3):
raise NotImplementedError("Scales only implements 3D advection.")
if any((sfield.dim != 3) for sfield in self.fields):
@@ -170,7 +165,7 @@ class ScalesAdvection(FortranOperator):
@debug
def handle_method(self, method):
super(ScalesAdvection, self).handle_method(method)
-
+
# Translate directional split into Scales configuration
strang_order = method.pop(StrangOrder)
try:
@@ -188,7 +183,7 @@ class ScalesAdvection(FortranOperator):
print "Unknown remesh method for Scales ({} given).".format(
self.remesh_kernel)
raise e
-
+
# Translate hysop multi scale interpolation to Scales interpolation
ms_interp = method.pop(MultiScaleInterpolation)
try:
@@ -197,11 +192,11 @@ class ScalesAdvection(FortranOperator):
print "Unknown multi scale interpolation method for Scales ({} given)".format(
ms_interp)
raise e
-
+
self.time_integrator = method.pop(TimeIntegrator)
assert self.time_integrator is RK2, \
"Scales uses RK2 time integration only"
-
+
self.interp = method.pop(Interpolation)
assert self.interp is Interpolation.LINEAR, \
"Scales uses linear interpolation only."
@@ -209,19 +204,23 @@ class ScalesAdvection(FortranOperator):
@debug
def get_field_requirements(self):
requirements = super(ScalesAdvection, self).get_field_requirements()
- for is_input, (field,td,req) in requirements.iter_requirements():
- req.can_split = [0, 1, 1]
+ dim = self.domain.dim
+ for is_input, (field, td, req) in requirements.iter_requirements():
req.min_ghosts = (0,)*3
req.max_ghosts = (0,)*3
+ can_split = [False, ] * dim
+ can_split[0] = True
+ req.can_split = can_split
+
return requirements
@debug
def discretize(self):
super(ScalesAdvection, self).discretize()
-
+
is_inplace = self.is_inplace
dvelocity = self.get_input_discrete_field(self.velocity)
-
+
# Ravel all tensor fields to scalar fields and get corresponding discrete scalar fields
dadvected_fields_in = tuple(self.get_input_discrete_field(ifield)
for itfield in self.advected_fields_in
@@ -231,9 +230,9 @@ class ScalesAdvection(FortranOperator):
for ofield in otfield.fields)
assert len(dadvected_fields_in) == len(dadvected_fields_out)
if is_inplace:
- assert all((din._dfield is dout._dfield)
+ assert all((din._dfield is dout._dfield)
for (din, dout) in zip(dadvected_fields_in, dadvected_fields_out))
-
+
# check that every advected field has the same grid size and space step
dS0 = self.get_input_discrete_field(self.first_scalar)
for df in set(dadvected_fields_in + dadvected_fields_out):
@@ -245,7 +244,7 @@ class ScalesAdvection(FortranOperator):
msg='Resolution mismatch between discrete fields {} and {}.'
msg=msg.format(df.name, dS0.name)
raise ValueError(msg)
-
+
# The SCALES library for advection works only with
# 3D 1-component scalars or 3-components vectors so we
# merge advected scalars back to 3-component tensors while we can.
@@ -258,10 +257,10 @@ class ScalesAdvection(FortranOperator):
dfields_in = dadvected_fields_in[3*i:3*(i+1)]
dfields_out = dadvected_fields_out[3*i:3*(i+1)]
sin = CartesianDiscreteTensorField.from_dfields(name='Sin{}'.format(i),
- dfields=dfields_in,
+ dfields=dfields_in,
shape=(3,))
sout = CartesianDiscreteTensorField.from_dfields(name='Sout{}'.format(i),
- dfields=dfields_out,
+ dfields=dfields_out,
shape=(3,))
buffers = dvelocity.buffers + sout.buffers
assert all(b.flags.f_contiguous for b in buffers)
@@ -307,14 +306,17 @@ class ScalesAdvection(FortranOperator):
assert (dfo.periodicity.all()), msg1
sresol = s_topo.mesh.grid_resolution
- assert (sresol%s_topo.proc_shape == 0).all(),\
+ assert (sresol % s_topo.proc_shape == 0).all(),\
"Scales support only equally sized local resolutions"
+ verbosity = __VERBOSE__ or __DEBUG__
+
scalesres, global_start = scales.init_advection_solver(
sresol,
s_topo.domain.length,
s_topo.proc_shape,
self.mpi_params.comm.py2f(),
+ verbosity,
order=self._scales_kernel,
dim_split=self._dim_split)
@@ -353,20 +355,23 @@ class ScalesAdvection(FortranOperator):
raise NotImplementedError(msg)
self._scales_func = tuple(scales_func)
-
+
@op_apply
def apply(self, **kwds):
+ """Solve advection using Fortran SCALES library
+ """
super(ScalesAdvection, self).apply(**kwds)
# scales only operates inplace so we copy input to output first
- if (not self.is_inplace):
+ if (not self.is_inplace):
for (dSin, dSout) in zip(self.dSin, self.dSout):
dSout.copy(dSin, compute_slices=True)
-
+
# call scales advection
dt = self.dt()
- for (scale_func, buffers) in zip(self._scales_func, self.all_buffers):
- scale_func(dt, *buffers)
+
+ for (scales_func, buffers) in zip(self._scales_func, self.all_buffers):
+ scales_func(dt, *buffers)
@classmethod
def supports_mpi(cls):
diff --git a/hysop/backend/host/host_array_backend.py b/hysop/backend/host/host_array_backend.py
index 734140c5306a4824a57caeedc42a662038e01180..0f54b53e802c8e26aa1de3530e15f3a9e86e0a51 100644
--- a/hysop/backend/host/host_array_backend.py
+++ b/hysop/backend/host/host_array_backend.py
@@ -256,7 +256,7 @@ class HostArrayBackend(ArrayBackend):
- def empty_like(self, a, dtype=None, order=None, subok=True):
+ def empty_like(self, a, dtype=None, order=None, subok=True, shape=None):
"""
Return a new array with the same shape and type as a given array.
Data is allocated from backend allocator.
@@ -273,32 +273,32 @@ class HostArrayBackend(ArrayBackend):
except AttributeError:
order = default_order
return self.empty(
- shape = a.shape,
- dtype = dtype or a.dtype,
+ shape = first_not_None(shape, a.shape),
+ dtype = first_not_None(dtype, a.dtype),
order = order)
- def full_like(self, a, fill_value, dtype=None, order=None, subok=True):
+ def full_like(self, a, fill_value, dtype=None, order=None, subok=True, shape=None):
"""
Return a new array with the same shape and type as a given array.
Data is allocated from backend allocator.
"""
- a = self.empty_like(a=a, dtype=dtype, order=order, subok=subok)
+ a = self.empty_like(a=a, dtype=dtype, order=order, subok=subok, shape=shape)
self.fill(a, value=fill_value)
return a
- def zeros_like(self, a, dtype=None, order=None, subok=True):
+ def zeros_like(self, a, dtype=None, order=None, subok=True, shape=None):
"""
Return an array of zeros with the same shape and type as a given array.
Data is allocated from backend allocator.
"""
- return self.full_like(a=a,fill_value=0,dtype=dtype,order=order,subok=subok)
+ return self.full_like(a=a,fill_value=0,dtype=dtype,order=order,subok=subok,shape=shape)
- def ones_like(self, a, dtype=None, order=None, subok=True):
+ def ones_like(self, a, dtype=None, order=None, subok=True, shape=None):
"""
Return an array of ones with the same shape and type as a given array.
Data is allocated from backend allocator.
"""
- return self.full_like(a=a,fill_value=1,dtype=dtype,order=order,subok=subok)
+ return self.full_like(a=a,fill_value=1,dtype=dtype,order=order,subok=subok,shape=shape)
# Filling facility
def fill(self, a, value):
diff --git a/hysop/backend/host/python/operator/analytic.py b/hysop/backend/host/python/operator/analytic.py
index 4f9ffb5a281b8e366e259871bd67c3e1850f786e..7d9dd1a93dbb7473cfdbc16c6ad8ae4047955b7f 100644
--- a/hysop/backend/host/python/operator/analytic.py
+++ b/hysop/backend/host/python/operator/analytic.py
@@ -3,7 +3,7 @@ from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import debug
from hysop.backend.host.host_operator import HostOperator
from hysop.core.graph.graph import op_apply
-from hysop.fields.continuous_field import Field
+from hysop.fields.continuous_field import Field, ScalarField
from hysop.parameters.parameter import Parameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
@@ -24,7 +24,7 @@ class PythonAnalyticField(HostOperator):
Parameters
----------
- field: hysop.field.continuous_field.Field
+ field: hysop.field.continuous_field.ScalarField
Continuous field to be modified.
formula : callable
The formula to be applied onto the field.
@@ -44,19 +44,21 @@ class PythonAnalyticField(HostOperator):
"""
extra_input_kwds = first_not_None(extra_input_kwds, {})
- check_instance(field, Field)
+ check_instance(field, ScalarField)
assert callable(formula), type(formula)
check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
check_instance(extra_input_kwds, dict, keys=str)
-
+
input_fields = {}
- output_fields = { field: variables[field] }
+ output_fields = { field: self.get_topo_descriptor(variables, field) }
input_params = {}
extra_kwds = {}
+ map_fields = {}
for (k,v) in extra_input_kwds.iteritems():
if isinstance(v, Field):
- input_fields[k] = v
+ input_fields[v] = self.get_topo_descriptor(variables, v)
+ map_fields[v] = k
elif isinstance(v, Parameter):
input_params[k] = v
extra_kwds[k] = v
@@ -66,9 +68,11 @@ class PythonAnalyticField(HostOperator):
super(PythonAnalyticField, self).__init__(input_fields=input_fields,
output_fields=output_fields,
input_params=input_params, **kwds)
+
self.field = field
self.formula = formula
self.extra_kwds = extra_kwds
+ self.map_fields = map_fields
@debug
def discretize(self):
@@ -77,13 +81,14 @@ class PythonAnalyticField(HostOperator):
super(PythonAnalyticField, self).discretize()
dfield = self.get_output_discrete_field(self.field)
extra_kwds = self.extra_kwds
+ map_fields = self.map_fields
assert 'data' not in extra_kwds
assert 'coords' not in extra_kwds
- extra_kwds['data'] = dfield.data
- extra_kwds['coords'] = dfield.get_attributes('mesh', 'local_mesh_coords')
- for (field, dfield) in self.input_discrete_fields:
+ extra_kwds['data'] = dfield.compute_data[0]
+ extra_kwds['coords'] = dfield.compute_mesh_coords
+ for (field, dfield) in self.input_discrete_fields.iteritems():
assert field.name not in extra_kwds, field.name
- extra_kwds[field.name] = dfield.data
+ extra_kwds[map_fields[field]] = dfield.compute_data
self.dfield = dfield
@op_apply
diff --git a/hysop/backend/host/python/operator/convergence.py b/hysop/backend/host/python/operator/convergence.py
index 5ed1c2ac87caa07bba2e522bc60a87d6858ec97a..7a2c3651fb699ae4b4e7b4b7858edc5612101d54 100644
--- a/hysop/backend/host/python/operator/convergence.py
+++ b/hysop/backend/host/python/operator/convergence.py
@@ -5,10 +5,12 @@ Convergence python backend.
from hysop.constants import HYSOP_REAL
from hysop.backend.host.host_operator import HostOperator
from hysop.operator.base.convergence import ConvergenceBase
-from hysop.tools.decorators import debug
+from hysop.tools.decorators import debug
from hysop.core.graph.graph import op_apply
from hysop.tools.numpywrappers import npw
from hysop.constants import ResidualError
+import mpi4py.MPI as MPI
+import numpy as np
class PythonConvergence(ConvergenceBase, HostOperator):
@@ -17,44 +19,50 @@ class PythonConvergence(ConvergenceBase, HostOperator):
@debug
def __init__(self, **kwds):
super(PythonConvergence, self).__init__(**kwds)
- assert self.mpi_params.size == 1
@debug
def setup(self, **kwds):
super(PythonConvergence, self).setup(**kwds)
self.field_buffers = self.dField.compute_buffers
- self._tmp_convergence = npw.zeros((self.field.nb_components))
+ self._tmp_convergence = npw.zeros((1+self.field.nb_components),
+ dtype=self.convergence.dtype)
+ self._tmp_reduce = npw.zeros((1+self.field.nb_components),
+ dtype=self.convergence.dtype)
old = [npw.zeros(_.shape) for _ in self.field_buffers]
self.dField_old = tuple(old)
+ self.__compute_error_absolute = lambda ui, ui_old: npw.max(npw.abs(ui - ui_old))
+ self.__compute_error_relative = lambda ui, ui_old, max_ui: npw.max(
+ npw.abs(ui - ui_old))/max_ui
if self._residual_computation == ResidualError.ABSOLUTE:
- self.__compute_error = lambda ui, ui_old, max_ui: npw.max(npw.abs(ui - ui_old))
+ self.__compute_error = self.__compute_error_absolute
elif self._residual_computation == ResidualError.RELATIVE:
- self.__compute_error = lambda ui, ui_old, max_ui: npw.max(npw.abs(ui - ui_old))/max_ui
+ self.__compute_error = self.__compute_error_relative
else:
raise RuntimeError('Unknown residual computation method.')
self._eps = npw.finfo(HYSOP_REAL).eps
self._large_zero = 1e3 * npw.finfo(HYSOP_REAL).eps
- @debug
- def reinit(self, **kwds):
- u = self.field_buffers
- u_old = self.dField_old
- for ui, ui_old in zip(u, u_old):
- ui_old[...] = ui
-
@op_apply
- def apply(self, simulation, **kwds):
- u = self.field_buffers
+ def apply(self, **kwds):
+ u = self.field_buffers
u_old = self.dField_old
- self._tmp_convergence[...] = 1e10
+
+ self._tmp_convergence[...] = 0.
for (i, (ui, ui_old)) in enumerate(zip(u, u_old)):
- max_ui = npw.max(npw.abs(ui))
- if max_ui < self._large_zero:
- self._tmp_convergence[i] = self._eps
- else:
- self._tmp_convergence[i] = self.__compute_error(ui, ui_old, max_ui)
+ self._tmp_convergence[i] = self.__compute_error_absolute(ui, ui_old)
ui_old[...] = ui
- self.convergence.value = self._tmp_convergence
+ self._tmp_convergence[-1] = npw.sum(self._tmp_convergence)
+ if self._residual_computation == ResidualError.RELATIVE:
+ max_u = npw.max([npw.max(npw.abs(_)) for _ in u])
+ self._tmp_convergence /= max_u
+ self.mpi_params.comm.Allreduce(sendbuf=self._tmp_convergence,
+ recvbuf=self._tmp_reduce,
+ op=MPI.MAX)
+ self.convergence.value = self._tmp_reduce[-1]
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
diff --git a/hysop/backend/host/python/operator/custom.py b/hysop/backend/host/python/operator/custom.py
index 7244319bafa9af97ebdb397345b77b4de855e336..25f8f48fbdeaccf6e8bc276d714aa7bc93076cf8 100644
--- a/hysop/backend/host/python/operator/custom.py
+++ b/hysop/backend/host/python/operator/custom.py
@@ -1,6 +1,6 @@
from hysop.tools.decorators import debug
from hysop.tools.types import check_instance
-from hysop.fields.continuous_field import Field
+from hysop.fields.continuous_field import Field, VectorField
from hysop.parameters.parameter import Parameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.backend.host.host_operator import HostOperator
@@ -9,14 +9,17 @@ from hysop.core.graph.graph import op_apply
class PythonCustomOperator(HostOperator):
@debug
- def __init__(self, func, invars=None, outvars=None, variables=None, **kwds):
+ def __init__(self, func, invars=None, outvars=None,
+ extra_args=None, variables=None, ghosts=None, **kwds):
check_instance(invars, (tuple, list), values=(Field, Parameter),
allow_none=True)
check_instance(outvars, (tuple, list), values=(Field, Parameter),
allow_none=True)
+ check_instance(extra_args, tuple, allow_none=True)
check_instance(variables, dict, keys=Field,
values=CartesianTopologyDescriptors,
allow_none=True)
+ check_instance(ghosts, int, allow_none=True)
input_fields, output_fields = {}, {}
input_params, output_params = {}, {}
if invars is not None:
@@ -31,15 +34,32 @@ class PythonCustomOperator(HostOperator):
output_fields[v] = variables[v]
elif isinstance(v, Parameter):
output_params[v.name] = v
-
self.invars, self.outvars = invars, outvars
self.func = func
-
+ self.extra_args = tuple()
+ if not extra_args is None:
+ self.extra_args = extra_args
+ self._ghosts = ghosts
super(PythonCustomOperator, self).__init__(
input_fields=input_fields, output_fields=output_fields,
input_params=input_params, output_params=output_params,
**kwds)
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
+ @debug
+ def get_field_requirements(self):
+ requirements = super(PythonCustomOperator, self).get_field_requirements()
+ if not self._ghosts is None:
+ for it in requirements.iter_requirements():
+ if not it[1] is None:
+ is_input, (field, td, req) = it
+ min_ghosts = (max(g, self._ghosts) for g in req.min_ghosts.copy())
+ req.min_ghosts = min_ghosts
+ return requirements
+
@debug
def discretize(self):
if self.discretized:
@@ -47,27 +67,33 @@ class PythonCustomOperator(HostOperator):
super(PythonCustomOperator, self).discretize()
dinvar, dinparam = [], []
doutvar, doutparam = [], []
+ idf, odf = self.input_discrete_fields, self.output_discrete_fields
self.ghost_exchanger = []
if self.invars is not None:
for v in self.invars:
if isinstance(v, Field):
- for vd in self.input_discrete_fields[v].buffers:
- dinvar.append(vd)
+ for _v in v if isinstance(v, VectorField) else (v, ):
+ for vd in idf[_v]:
+ dinvar.append(vd)
elif isinstance(v, Parameter):
dinparam.append(v)
if self.outvars is not None:
for v in self.outvars:
if isinstance(v, Field):
- for vd in self.output_discrete_fields[v].buffers:
- doutvar.append(vd)
- self.ghost_exchanger.append(
- self.output_discrete_fields[v].build_ghost_exchanger())
+ for _v in v if isinstance(v, VectorField) else (v, ):
+ for vd in self.output_discrete_fields[_v]:
+ doutvar.append(vd)
+ gh = self.output_discrete_fields[_v].build_ghost_exchanger()
+ if gh is not None:
+ self.ghost_exchanger.append(gh)
elif isinstance(v, Parameter):
doutparam.append(v)
- self.dinvar, self.doutvar = dinvar, doutvar
- self.dinparam, self.doutparam = dinparam, doutparam
+ self.dinvar, self.doutvar = tuple(dinvar), tuple(doutvar)
+ self.dinparam, self.doutparam = tuple(dinparam), tuple(doutparam)
@op_apply
def apply(self, **kwds):
super(PythonCustomOperator, self).apply(**kwds)
- self.doutvar = self.func(*(self.dinvar + self.dinparam + self.doutparam))
+ self.func(*(self.dinvar + self.dinparam + self.doutvar + self.doutparam + self.extra_args))
+ for gh_exch in self.ghost_exchanger:
+ gh_exch.exchange_ghosts()
diff --git a/hysop/backend/host/python/operator/derivative.py b/hysop/backend/host/python/operator/derivative.py
index 7317aa43d5dbdf8ceacbfe38e228a9a9879a7a51..e4a16f48b8bced67f5530d57c1d3b23ece44b8f2 100644
--- a/hysop/backend/host/python/operator/derivative.py
+++ b/hysop/backend/host/python/operator/derivative.py
@@ -1,5 +1,3 @@
-
-
from hysop.operator.base.derivative import FiniteDifferencesSpaceDerivativeBase, \
SpectralSpaceDerivativeBase
from hysop.backend.host.host_operator import HostOperator
@@ -13,7 +11,7 @@ class PythonSpectralSpaceDerivative(SpectralSpaceDerivativeBase, HostOperator):
Compute a derivative of a scalar field in a given direction
using spectral methods.
"""
-
+
def setup(self, work):
super(PythonSpectralSpaceDerivative, self).setup(work=work)
dA = self.dA
@@ -23,7 +21,7 @@ class PythonSpectralSpaceDerivative(SpectralSpaceDerivativeBase, HostOperator):
self.scale = dA.sbuffer[self.scaling_view][aview]
else:
self.scale = dA
-
+
@op_apply
def apply(self, **kwds):
self.Ft()
@@ -63,7 +61,7 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
"""
Initialize a FiniteDifferencesSpaceDerivative operator on the python backend.
- See hysop.operator.base.derivative.FiniteDifferencesSpaceDerivativeBase for
+ See hysop.operator.base.derivative.FiniteDifferencesSpaceDerivativeBase for
more information.
Parameters
@@ -80,7 +78,7 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
csg = CenteredStencilGenerator()
csg.configure(dtype=MPQ, dim=1)
stencil = csg.generate_exact_stencil(
- derivative=self.directional_derivative,
+ derivative=self.directional_derivative,
order=self.space_discretization)
self.stencil = stencil
@@ -89,9 +87,9 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
stencil = self.stencil
G = max(stencil.L, stencil.R)
d = self.d
-
+
# set min_ghosts for input field
- requirements = super(PythonFiniteDifferencesSpaceDerivative,
+ requirements = super(PythonFiniteDifferencesSpaceDerivative,
self).get_field_requirements()
for is_input, (field, td, req) in requirements.iter_requirements():
if (field is self.Fin):
@@ -99,7 +97,7 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
ghosts[d] = max(G, ghosts[d])
req.min_ghosts = ghosts
return requirements
-
+
@debug
def discretize(self):
super(PythonFiniteDifferencesSpaceDerivative, self).discretize()
@@ -127,7 +125,7 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
self.scale = dA.buffers[self.scaling_view][aview]
else:
self.scale = dA
-
+
@op_apply
def apply(self, **kwds):
"""Compute derivative."""
@@ -135,15 +133,16 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
stencil = self.stencil
_in, out, scale = self._in, self.out, self.scale
iview, d = self.iview, self.d
+
if (self.is_inplace):
dtmp = self.dtmp
- stencil.apply(a=_in, out=dtmp,
+ stencil.apply(a=_in, out=dtmp,
axis=d, iview=iview)
out[...] = dtmp
else:
stencil.apply(a=_in, out=out,
axis=d, iview=iview)
-
+
if self.scale_by_field:
out[...] *= scale
elif self.scale_by_parameter:
@@ -154,3 +153,4 @@ class PythonFiniteDifferencesSpaceDerivative(FiniteDifferencesSpaceDerivativeBas
elif self.scale_by_value:
out[...] *= scale
+ self.dFout.exchange_ghosts()
diff --git a/hysop/backend/host/python/operator/diffusion.py b/hysop/backend/host/python/operator/diffusion.py
index dac0916f143323db0ff5af21ecbcf765a609ed5b..ec36df387b3d16c7dda75e911adcd4017e6cb02d 100644
--- a/hysop/backend/host/python/operator/diffusion.py
+++ b/hysop/backend/host/python/operator/diffusion.py
@@ -7,7 +7,7 @@ from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import debug
from hysop.tools.numpywrappers import npw
from hysop.tools.numerics import is_complex, complex_to_float_dtype
-from hysop.tools.numba_utils import make_numba_signature
+from hysop.tools.numba_utils import make_numba_signature, prange
from hysop.backend.host.host_operator import HostOperator, OpenClMappable
from hysop.core.graph.graph import op_apply
from hysop.fields.continuous_field import Field
@@ -42,7 +42,7 @@ class PythonDiffusion(DiffusionOperatorBase, OpenClMappable, HostOperator):
'(n,m),(n),(m),()->(n,m)', target=target,
nopython=True, cache=True)
def filter_diffusion_2d(Fin, K0, K1, nu_dt, Fout):
- for i in range(Fin.shape[0]):
+ for i in prange(Fin.shape[0]):
for j in range(Fin.shape[1]):
Fout[i,j] /= (1 - nu_dt*(K0[i] + K1[j]))
F = filter_diffusion_2d
@@ -51,8 +51,8 @@ class PythonDiffusion(DiffusionOperatorBase, OpenClMappable, HostOperator):
'(n,m,p),(n),(m),(p),()->(n,m,p)', target=target,
nopython=True, cache=True)
def filter_diffusion_3d(Fin, K0, K1, K2, nu_dt, Fout):
- for i in range(Fin.shape[0]):
- for j in range(Fin.shape[1]):
+ for i in prange(Fin.shape[0]):
+ for j in prange(Fin.shape[1]):
for k in range(Fin.shape[2]):
Fout[i,j,k] /= (1 - nu_dt*(K0[i] + K1[j] + K2[k]))
F = filter_diffusion_3d
@@ -61,9 +61,9 @@ class PythonDiffusion(DiffusionOperatorBase, OpenClMappable, HostOperator):
'(n,m,p,q),(n),(m),(p),(q),()->(n,m,p,q)', target=target,
nopython=True, cache=True)
def filter_diffusion_4d(Fin, K0, K1, K2, K3, nu_dt, Fout):
- for i in range(Fin.shape[0]):
- for j in range(Fin.shape[1]):
- for k in range(Fin.shape[2]):
+ for i in prange(Fin.shape[0]):
+ for j in prange(Fin.shape[1]):
+ for k in prange(Fin.shape[2]):
for l in range(Fin.shape[3]):
Fout[i,j,k,l] /= (1 - nu_dt*(K0[i] + K1[j] + K2[k] + K3[l]))
else:
@@ -75,7 +75,9 @@ class PythonDiffusion(DiffusionOperatorBase, OpenClMappable, HostOperator):
def setup(self, work):
super(PythonDiffusion, self).setup(work=work)
diffusion_filters = ()
- for (Fo,Ft,Kd) in zip(self.dFout.dfields, self.forward_transforms, self.all_dkds):
+ for (Fo,Ft,Kd) in zip(self.dFout.dfields,
+ self.forward_transforms,
+ self.all_dkds):
args = (Ft.full_output_buffer,) + tuple(Kd)
F = self.build_diffusion_filter(Fo.dim, *args)
diffusion_filters += (F,)
@@ -94,7 +96,7 @@ class PythonDiffusion(DiffusionOperatorBase, OpenClMappable, HostOperator):
self.backward_transforms,
self.diffusion_filters):
Ft(simulation=simulation)
- filter_diffusion(nu_dt, Ft.output_buffer)
+ filter_diffusion(nu_dt, Ft.full_output_buffer)
Bt(simulation=simulation)
for Fo in self.dFout.dfields:
diff --git a/hysop/backend/host/python/operator/directional/advection_dir.py b/hysop/backend/host/python/operator/directional/advection_dir.py
index 2ced633ce090fa572e9dd9ff8a253051afb518f8..9501cf42915b76dbec0e3128fbc6bc6df28cb800 100644
--- a/hysop/backend/host/python/operator/directional/advection_dir.py
+++ b/hysop/backend/host/python/operator/directional/advection_dir.py
@@ -9,12 +9,12 @@ from hysop.constants import BoundaryCondition
from hysop.backend.host.host_operator import ComputeGranularity
from hysop.backend.host.host_directional_operator import HostDirectionalOperator
from hysop.operator.base.advection_dir import DirectionalAdvectionBase
-from hysop.methods import Interpolation
+from hysop.methods import Interpolation, PolynomialInterpolation
from hysop.numerics.odesolvers.runge_kutta import ExplicitRungeKutta, Euler, RK2, RK3, RK4
-class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperator):
+DEBUG = False
- DEBUG = False
+class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperator):
counter = 0
@debug
@@ -71,7 +71,10 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
if self.is_inplace:
self.dstmp = work.get_buffer(self, 'stmp', handle=True)
- assert (self.is_bilevel is None), "Python bilevel advection has not been implemented yet."
+ if self.is_bilevel:
+ msg="Python bilevel advection has not been implemented yet."
+ raise NotImplementedError(msg)
+
self._prepare_apply()
def _prepare_apply(self):
@@ -119,28 +122,62 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
self._inout_shapes = (in_shapes, out_shapes)
@op_apply
- def apply(self, **kwds):
+ def apply(self, simulation=None, debug_dumper=None, **kwds):
super(PythonDirectionalAdvection, self).apply(**kwds)
+ dsoutputs = self.dadvected_fields_out
dt = self.dt() * self.dt_coeff
- self.counter += 1
-
- if self.DEBUG:
+ if DEBUG:
+ import inspect
+ if (debug_dumper is not None):
+ def dump(dfield, tag):
+ it = simulation.current_iteration
+ t = simulation.t()
+ _file,_line = inspect.stack()[1][1:3]
+ debug_dumper(it, t, tag, tuple(df.sdata.get().handle[df.compute_slices]
+ for df in dfield.dfields), description=None)
+ else:
+ def dump(*args, **kwds):
+ pass
+ Sin = self.dadvected_fields_in.values()[0]
+ Sout = self.dadvected_fields_out.values()[0]
+ P = self.dposition
print 'DT= {}'.format(dt)
self._compute_advection(dt)
print 'P'
- self.dposition.print_with_ghosts()
+ print P.collect_data()
+ dump(P, 'P')
print 'S (before remesh)'
- self.dadvected_fields_in.values()[0].print_with_ghosts()
- print 'S (before remesh with ghosts)'
- self.dadvected_fields_in.values()[0].print_with_ghosts(outer_ghosts=None)
+ print Sin.collect_data()
+ dump(Sin, 'Sin before remesh')
self._compute_remesh()
- print 'S (after accumulation)'
- self.dadvected_fields_out.values()[0].print_with_ghosts()
+ print 'S (before accumulation)'
+ print Sout[0].sbuffer[Sout[0].local_slices(ghosts=(0,self.remesh_ghosts))]
+ dump(Sin, 'Sout (after remesh)')
+ for sout in dsoutputs.values():
+ print 'Accumulate {}'.format(sout.short_description())
+ ghosts = tuple(sout.ghosts[:-1])+(self.remesh_ghosts,)
+ sout.accumulate_ghosts(directions=sout.dim-1, ghosts=ghosts)
+ print 'S (after accumulation, before ghost exchange)'
+ print Sout.collect_data()
+ dump(Sin, 'Sout (after accumulation)')
+ for sout in dsoutputs.values():
+ print 'Exchange {}'.format(sout.short_description())
+ sout.exchange_ghosts()
+ print 'S (after ghost exchange)'
+ print Sout.collect_data()
+ dump(Sin, 'Sout (after exchange)')
else:
self._compute_advection(dt)
self._compute_remesh()
+ for sout in dsoutputs.values():
+ ghosts = tuple(sout.ghosts[:-1])+(self.remesh_ghosts,)
+ sout.accumulate_ghosts(directions=sout.dim-1, ghosts=ghosts)
+ for sout in dsoutputs.values():
+ sout.exchange_ghosts()
+
+ self.counter += 1
def _interp_velocity(self, Vin, Vout, dX, I, Ig, lidx, ridx, inv_dx, is_periodic, Vr):
"""
@@ -164,7 +201,7 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
if is_periodic:
lidx[...] += N
lidx[...] %= N
- elif __debug__:
+ elif DEBUG:
min_lidx, max_lidx = lidx.min(), lidx.max()
M = Vin.shape[-1]
assert min_lidx >= 0, 'index out of bounds: {} < 0'.format(min_lidx)
@@ -200,7 +237,7 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
Vd = Vd[view[:-1]+(slice(None),)]
Vr = self.Vr # relative velocity
- if __debug__:
+ if DEBUG:
# check if CFL condition is met
cfl = self.velocity_cfl
Vmin, Vmax = Vd.min(), Vd.max()
@@ -257,7 +294,7 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
else:
msg = 'Unknown Runge-Kutta scheme {}.'.format(rk_scheme)
raise ValueError(msg)
- if __debug__:
+ if DEBUG:
# check min and max positions
Pmin, Pmax = P.min(), P.max()
finfo = npw.finfo(P.dtype)
@@ -289,7 +326,7 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
(_,_,_,_,X0) = self._velocity_mesh_attributes
(mesh_it, dx, inv_dx, compute_view, N0) = self._scalar_mesh_attributes
- if self.DEBUG:
+ if DEBUG:
print 'GLOBAL START'
print 'X0: {}'.format(X0[0])
print 'N0: {}'.format(N0)
@@ -330,7 +367,7 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
R0[...] -= I0
R0[...] *= -1 # we need -alpha for the left point
- if __debug__:
+ if DEBUG:
Imin, Imax = I0.min(), I0.max()
amin, amax = R0.min(), R0.max()
assert (Imin >= -scalar_advection_ghosts), '{} >= -{}'.format(Imin,
@@ -380,7 +417,7 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
if is_periodic:
Ix += N
Ix %= N
- if __debug__:
+ if DEBUG:
assert npw.all(Ix>=0), 'ix={}, ix < 0'.format(ix)
Si[I[:-1]+(Ix,)] += (R1[..., in_idx]*sin[..., in_idx])
@@ -388,31 +425,14 @@ class PythonDirectionalAdvection(DirectionalAdvectionBase, HostDirectionalOperat
sout[...] = Si
sid+=1
-
- if self.DEBUG:
- print 'S (before accumulation)'
- self.dadvected_fields_out.values()[0].print_with_ghosts(outer_ghosts=None)
- print 'S (before accumulation without ghosts)'
- self.dadvected_fields_out.values()[0].print_with_ghosts()
-
- # sum remeshed ghosts
- for sout in dsoutputs.values():
- sout.accumulate_ghosts(directions=sout.dim-1, ghosts=self.remesh_ghosts)
-
- if self.DEBUG:
- print 'S (after accumulation, before ghost exchange)'
- self.dadvected_fields_out.values()[0].print_with_ghosts(outer_ghosts=None)
-
- # exchange ghosts
- for sout in dsoutputs.values():
- sout.exchange_ghosts()
-
@debug
def handle_method(self, method):
super(PythonDirectionalAdvection, self).handle_method(method)
cr = method.pop(ComputeGranularity)
assert 0 <= cr <= self.velocity.dim-1
- assert self.interp == Interpolation.LINEAR
+ msg='Interpolation {}.{} is not supported for operator {}.'.format(
+ self.interp.__class__.__name__, self.interp, self.__class__.__name__)
+ assert self.interp in (Interpolation.LINEAR, PolynomialInterpolation.LINEAR), msg
self.compute_granularity = cr
@classmethod
diff --git a/hysop/backend/host/python/operator/directional/stretching_dir.py b/hysop/backend/host/python/operator/directional/stretching_dir.py
index 7c3341c9daba413660f10b41dc9f348c622e32df..3112bbb3983364cc2d162c1d730c87fa0e635a06 100644
--- a/hysop/backend/host/python/operator/directional/stretching_dir.py
+++ b/hysop/backend/host/python/operator/directional/stretching_dir.py
@@ -100,3 +100,7 @@ class PythonDirectionalStretching(DirectionalStretchingBase, HostDirectionalOper
for wn in Wnames:
W[wn][...] = Wout[wn]
self.ghost_exchanger.exchange_ghosts()
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
diff --git a/hysop/backend/host/python/operator/enstrophy.py b/hysop/backend/host/python/operator/enstrophy.py
index f583191b522e071c0d9cd0136b1dbe06f321a697..a11a3b5cbc3f66bdebed9f0e7d6ce6141c2b1c03 100644
--- a/hysop/backend/host/python/operator/enstrophy.py
+++ b/hysop/backend/host/python/operator/enstrophy.py
@@ -14,7 +14,6 @@ class PythonEnstrophy(EnstrophyBase, HostOperator):
@debug
def __init__(self, **kwds):
super(PythonEnstrophy, self).__init__(**kwds)
- assert self.mpi_params.size == 1
@debug
def setup(self, work):
@@ -29,10 +28,10 @@ class PythonEnstrophy(EnstrophyBase, HostOperator):
WdW[...] = 0.0
for Wi in W:
- WdW[...] += (Wi ** 2)
+ WdW[...] += self.rho_0 * (Wi ** 2)
# Compute enstrophy
- # TODO reduce over all mpi process
local_enstrophy = self.coeff * npw.sum(WdW, dtype=self.enstrophy.dtype)
- self.enstrophy.value = local_enstrophy
+ # collect enstrophy from all processes
+ self.enstrophy.value = self._collect(local_enstrophy)
diff --git a/hysop/backend/host/python/operator/flowrate_correction.py b/hysop/backend/host/python/operator/flowrate_correction.py
old mode 100755
new mode 100644
index f68d5e7363368e0dd02fd28075ffd414e2bd7b97..9ed4274584801523e25207a038513728489a39ee
--- a/hysop/backend/host/python/operator/flowrate_correction.py
+++ b/hysop/backend/host/python/operator/flowrate_correction.py
@@ -19,8 +19,6 @@ class PythonFlowRateCorrection(HostOperator):
the box input face (X=orgin, normal=(-1,0,0))
Velocity is corrected in X-direction from prescribed flowrate
Velocity is corrected in Y and Z-direction from mean vorticity
-
- Note: Required flowrate is given in XYZ components.
"""
@debug
@@ -46,7 +44,7 @@ class PythonFlowRateCorrection(HostOperator):
self.absorption_start = absorption_start
if self.absorption_start is None:
self.absorption_start = velocity.domain.end[-1]
- ## TODO: Correction is taking an absorption start (see absorption operator) only in X dir.
+ # TODO: Correction is taking an absorption start (see absorption operator) only in X dir.
super(PythonFlowRateCorrection, self).__init__(
input_fields=input_fields, output_fields=output_fields,
input_params=input_params, **kwds)
@@ -54,11 +52,8 @@ class PythonFlowRateCorrection(HostOperator):
@debug
def get_field_requirements(self):
requirements = super(PythonFlowRateCorrection, self).get_field_requirements()
- dim = self.domain.dim
for is_input, (field, td, req) in requirements.iter_requirements():
req.axes = ((0, 1, 2), )
- req.min_ghosts = (0, ) * dim
- req.max_ghosts = (0, ) * dim
return requirements
@debug
@@ -68,57 +63,38 @@ class PythonFlowRateCorrection(HostOperator):
super(PythonFlowRateCorrection, self).discretize()
self.dvelocity = self.input_discrete_tensor_fields[self.velocity]
self.dvorticity = self.input_discrete_tensor_fields[self.vorticity]
-
- def get_mesh_attr(attr, *args):
- if(len(args)==0):
- v = [eval('_.mesh.'+attr) for _ in self.dvelocity]
- else:
- v = [eval('_.mesh.'+attr)(*args) for _ in self.dvelocity]
- for vv in v[1:]:
- if isinstance(v[0], np.ndarray):
- assert (v[0] == vv).all()
- else:
- assert v[0] == vv
- return v[0]
-
- domain = self.dvelocity.domain
- mesh_global_origin = get_mesh_attr('global_origin')
- mesh_local_origin = get_mesh_attr('local_origin')
- mesh_local_compute_slices = get_mesh_attr('local_compute_slices')
- mesh_local_mesh_coordsX = get_mesh_attr('local_mesh_coords[0]')
- mesh_local_mesh_coordsY = get_mesh_attr('local_mesh_coords[1]')
- mesh_local_mesh_coordsZ = get_mesh_attr('local_mesh_coords[2]')
+ vtopo = self.dvelocity[0].topology
+ wtopo = self.dvorticity[0].topology
+ vmesh = vtopo.mesh
+ wmesh = wtopo.mesh
# Compute volume and surface integration coefficients
- spaceStep = self.dvelocity.space_step
- lengths = domain.length
+ spaceStep = vmesh.space_step
+ lengths = vtopo.domain.length
self._inv_ds = 1. / np.prod(lengths[:-1])
- self._inv_dvol = 1. / (lengths[0]*lengths[1]*(self.absorption_start-domain.origin[-1]))
+ self._inv_dvol = 1. / (lengths[0]*lengths[1] *
+ (self.absorption_start-vtopo.domain.origin[-1]))
self.coeff_mean = np.prod(spaceStep) / np.prod(lengths)
# Compute space coordinates from domain origin
- z0, y0, x0 = mesh_global_origin
- self.x_coord = mesh_local_mesh_coordsX - x0
- self.y_coord = (mesh_local_mesh_coordsY - y0 - lengths[1]/2.)/2.
- self.z_coord = (mesh_local_mesh_coordsZ - z0 - lengths[0]/2.)/2.
+ x0 = vmesh.global_origin[-1]
+ self.x_coord = vmesh.local_mesh_coords[0] - x0
# Compute slices for volume and surface integration
- gstart = mesh_local_origin.copy()
- gstart[-1] = mesh_global_origin[-1]
- gstart_local_indices = get_mesh_attr('point_local_indices', gstart)
- if get_mesh_attr('is_inside_local_domain', gstart):
- ind4integ_v = [_ for _ in mesh_local_compute_slices]
- ind4integ_v[-1] = gstart_local_indices[-1]
+ gstart = vmesh.local_origin.copy()
+ gstart[-1] = vmesh.global_origin[-1]
+ if vmesh.is_inside_local_domain(gstart):
+ ind4integ_v = [_ for _ in vmesh.local_compute_slices]
+ ind4integ_v[-1] = vmesh.point_local_indices(gstart)[-1]
self._ind4integ_v = tuple(ind4integ_v)
else:
self._ind4integ_v = None
self._ds_in = np.prod(spaceStep[0:2])
- ind4integ_w = [_ for _ in mesh_local_compute_slices]
- box_end = mesh_local_origin.copy()
+ ind4integ_w = [_ for _ in wmesh.local_compute_slices]
+ box_end = wmesh.local_origin.copy()
box_end[-1] = self.absorption_start
- box_end_local_indices = get_mesh_attr('point_local_indices', box_end)
ind4integ_w[-1] = slice(ind4integ_w[-1].start,
- box_end_local_indices[-1],
+ wmesh.point_local_indices(box_end)[-1],
ind4integ_w[-1].step)
self._ind4integ_w = tuple(ind4integ_w)
self._ds_box = np.prod(spaceStep)
@@ -161,12 +137,13 @@ class PythonFlowRateCorrection(HostOperator):
flowrate_req = self.flowrate() * self._inv_ds
velo_shift = np.zeros((dv.dim, ))
- velo_shift = flowrate_req - self.rates[0:dv.dim]
+ velo_shift = flowrate_req - self.rates[dv.dim-1::-1]
# Shift velocity Vx
- dv.data[0][...] += velo_shift[0]
+ dv.data[0][...] += velo_shift[2]
# Update Vy and Vz with mean vorticity
dv.data[1][...] += velo_shift[1] + self.rates[dv.dim+2]*self.x_coord
- dv.data[2][...] += velo_shift[2] - self.rates[dv.dim+1]*self.x_coord
- self.ghost_exchanger()
+ dv.data[2][...] += velo_shift[0] + self.rates[dv.dim+1]*self.x_coord
+ if (self.ghost_exchanger is not None):
+ self.ghost_exchanger()
diff --git a/hysop/backend/host/python/operator/integrate.py b/hysop/backend/host/python/operator/integrate.py
new file mode 100644
index 0000000000000000000000000000000000000000..044e07038a88f3694865f50234951f6e28f44686
--- /dev/null
+++ b/hysop/backend/host/python/operator/integrate.py
@@ -0,0 +1,25 @@
+from hysop.tools.decorators import debug
+from hysop.core.graph.graph import op_apply
+from hysop.backend.host.host_operator import HostOperator
+from hysop.operator.base.integrate import IntegrateBase
+import numpy as np
+
+
+class PythonIntegrate(IntegrateBase, HostOperator):
+
+ @debug
+ def __init__(self, **kwds):
+ super(PythonIntegrate, self).__init__(**kwds)
+ assert self.expr is None, "expr not yet implemented for Python backend (see opencl integrate operator)"
+
+ @op_apply
+ def apply(self, **kwds):
+ value = self.parameter._value.copy()
+ for i in xrange(self.dF.nb_components):
+ Pi = np.sum(self.dF.data[i][self.dF.compute_slices])
+ if (self.scaling_coeff[i] is None):
+ self.scaling_coeff[i] = 1.0 / Pi
+ value[i] = self.scaling_coeff[i] * Pi
+
+ # compute value from all processes
+ self.parameter.value = self._collect(value)
diff --git a/hysop/backend/host/python/operator/min_max.py b/hysop/backend/host/python/operator/min_max.py
index 0f7ce42cad1887b1fabd0e0cc68bcee6a55ec1c9..f16aa7be7f52359b7c84f9036dddef1f199bdbb3 100644
--- a/hysop/backend/host/python/operator/min_max.py
+++ b/hysop/backend/host/python/operator/min_max.py
@@ -6,7 +6,7 @@ from hysop.backend.host.host_operator import HostOperator
from hysop.backend.host.python.operator.derivative import PythonSpectralSpaceDerivative, \
PythonFiniteDifferencesSpaceDerivative
-class PythonMinMaxFieldStatistics(MinMaxFieldStatisticsBase,
+class PythonMinMaxFieldStatistics(MinMaxFieldStatisticsBase,
HostOperator):
"""Python implementation backend of operator MinMaxFieldStatistics."""
@@ -21,8 +21,12 @@ class PythonMinMaxFieldStatistics(MinMaxFieldStatisticsBase,
super(PythonMinMaxFieldStatistics, self).apply(**kwds)
self.compute_statistics(**kwds)
+ @classmethod
+ def supports_mpi(cls):
+ return True
-class PythonMinMaxSpectralDerivativeStatistics(MinMaxDerivativeStatisticsBase,
+
+class PythonMinMaxSpectralDerivativeStatistics(MinMaxDerivativeStatisticsBase,
PythonSpectralSpaceDerivative):
"""Python implementation backend of operator MinMaxSpectralDerivativeStatistics."""
@op_apply
@@ -32,7 +36,7 @@ class PythonMinMaxSpectralDerivativeStatistics(MinMaxDerivativeStatisticsBase,
self.compute_statistics(**kwds)
-class PythonMinMaxFiniteDifferencesDerivativeStatistics(MinMaxDerivativeStatisticsBase,
+class PythonMinMaxFiniteDifferencesDerivativeStatistics(MinMaxDerivativeStatisticsBase,
PythonFiniteDifferencesSpaceDerivative):
"""Python implementation backend of operator MinMaxFiniteDifferencesDerivativeStatistics."""
@op_apply
@@ -40,3 +44,7 @@ class PythonMinMaxFiniteDifferencesDerivativeStatistics(MinMaxDerivativeStatisti
"""Compute derivative and then statistics."""
super(PythonMinMaxFiniteDifferencesDerivativeStatistics, self).apply(**kwds)
self.compute_statistics(**kwds)
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
diff --git a/hysop/backend/host/python/operator/penalization.py b/hysop/backend/host/python/operator/penalization.py
old mode 100755
new mode 100644
index 6f3d0d58a7e0faf7655954babd42fc2dea255bfa..238b8dad33a617e40e918d7af607935c20839a09
--- a/hysop/backend/host/python/operator/penalization.py
+++ b/hysop/backend/host/python/operator/penalization.py
@@ -1,8 +1,10 @@
+from hysop.constants import PenalizationFormulation
from hysop.backend.host.host_operator import HostOperator
from hysop.tools.types import check_instance, InstanceOf
from hysop.tools.decorators import debug
from hysop.fields.continuous_field import Field
from hysop.parameters.scalar_parameter import ScalarParameter
+from hysop.parameters.tensor_parameter import TensorParameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.methods import SpaceDiscretization
from hysop.core.memory.memory_request import MemoryRequest
@@ -28,6 +30,7 @@ class PythonPenalizeVorticity(HostOperator):
dm = super(PythonPenalizeVorticity, cls).default_method()
dm.update(cls.__default_method)
return dm
+
@classmethod
def available_methods(cls):
am = super(PythonPenalizeVorticity, cls).available_methods()
@@ -37,15 +40,17 @@ class PythonPenalizeVorticity(HostOperator):
@debug
def __init__(self, obstacles, variables,
velocity, vorticity,
- dt, coeff=None, **kwds):
+ dt, coeff=None, ubar=None, formulation=None, **kwds):
check_instance(velocity, Field)
check_instance(vorticity, Field)
check_instance(variables, dict, keys=Field,
values=CartesianTopologyDescriptors)
check_instance(dt, ScalarParameter)
- check_instance(coeff, (ScalarParameter, float))
+ check_instance(coeff, (ScalarParameter, float, type(lambda x: x)), allow_none=True)
+ check_instance(ubar, TensorParameter, allow_none=True)
+ check_instance(formulation, PenalizationFormulation, allow_none=True)
check_instance(obstacles, (tuple, dict), values=Field,
- keys=(ScalarParameter, float), check_kwds=False)
+ keys=(ScalarParameter, float, type(lambda x: x)), check_kwds=False)
input_fields = {velocity: variables[velocity],
vorticity: variables[vorticity]}
@@ -53,12 +58,23 @@ class PythonPenalizeVorticity(HostOperator):
input_params = {dt.name: dt}
if isinstance(coeff, ScalarParameter):
+ self.coeff = lambda o: coeff()*o
+ elif isinstance(coeff, type(lambda x: x)):
self.coeff = coeff
- else:
- self.coeff = ScalarParameter("penal_coeff", initial_value=coeff)
+ elif not coeff is None:
+ c = ScalarParameter("penal_coeff", initial_value=coeff)
+ self.coeff = lambda o: c()*o
if isinstance(obstacles, dict):
- obs = obstacles
+ obs = {}
+ for c, o in obstacles.iteritems():
+ if isinstance(c, ScalarParameter):
+ obs[lambda x: c()*x] = o
+ elif isinstance(c, type(lambda x: x)):
+ obs[c] = o
+ elif not c is None:
+ _ = ScalarParameter("penal_coeff", initial_value=c)
+ obs[lambda x: _()*x] = o
else:
obs = {}
for o in obstacles:
@@ -66,6 +82,16 @@ class PythonPenalizeVorticity(HostOperator):
for o in obs.values():
assert o.nb_components == 1
input_fields[o] = variables[o]
+ self._ubar = ubar
+ if ubar is None:
+ self._ubar = TensorParameter(
+ name="ubar", shape=(velocity.dim,),
+ quiet=True, dtype=velocity.dtype,
+ initial_value=(0.,)*velocity.dim)
+ if formulation is None or formulation is PenalizationFormulation.IMPLICIT:
+ self._compute_penalization = self._compute_penalization_implicit
+ else:
+ self._compute_penalization = self._compute_penalization_exact
self.velocity = velocity
self.vorticity = vorticity
@@ -91,13 +117,14 @@ class PythonPenalizeVorticity(HostOperator):
@debug
def get_field_requirements(self):
- requirements = super(PythonPenalizeVorticity, self).get_field_requirements()
+ requirements = super(PythonPenalizeVorticity,
+ self).get_field_requirements()
stencil = self.stencil[0]
G = max(max(a, b) for a, b in zip(stencil.L, stencil.R))
for is_input, (field, td, req) in requirements.iter_requirements():
min_ghosts = (max(g, G) for g in req.min_ghosts.copy())
req.min_ghosts = min_ghosts
- req.axes = ((0, 1, 2), )
+ req.axes = (tuple(range(field.dim)), )
return requirements
@debug
@@ -105,30 +132,36 @@ class PythonPenalizeVorticity(HostOperator):
if self.discretized:
return
super(PythonPenalizeVorticity, self).discretize()
+ dim = self.velocity.dim
self.dvelocity = self.input_discrete_tensor_fields[self.velocity]
- self.dvorticity = self.input_discrete_tensor_fields[self.vorticity]
+ if dim == 2:
+ self.dvorticity = self.input_discrete_fields[self.vorticity]
+ if dim == 3:
+ self.dvorticity = self.input_discrete_tensor_fields[self.vorticity]
dv, dw = self.dvelocity, self.dvorticity
stencil = self.stencil[0]
G = max(max(a, b) for a, b in zip(stencil.L, stencil.R))
- view = dv.local_slices(ghosts=(G, G, G))
+ view = dv.local_slices(ghosts=(G, )*dim)
V = tuple(Vi[view] for Vi in dv.buffers)
- view = dw.local_slices(ghosts=(G, G, G))
+ view = dw.local_slices(ghosts=(G, )*dim)
W = tuple(Wi[view] for Wi in dw.buffers)
self.W, self.V = W, V
self.dobstacles = {}
for c, o in self.obstacles.iteritems():
o_df = self.input_discrete_fields[o]
- self.dobstacles[c] = o_df.data[0][o_df.local_slices(ghosts=(G, G, G))]
+ self.dobstacles[c] = o_df.data[0][o_df.local_slices(
+ ghosts=(G, )*dim)]
for s, dx in zip(self.stencil, dw.space_step):
s.replace_symbols({s.dx: dx})
- self.ghost_exchanger = dw.build_ghost_exchanger()
+ self.w_ghost_exchanger = dw.build_ghost_exchanger()
+ self.v_ghost_exchanger = dv.build_ghost_exchanger()
@debug
def get_work_properties(self):
- requests = super(PythonPenalizeVorticity, self).get_work_properties()
+ requests = super(PythonPenalizeVorticity, self).get_work_properties()
buffers = MemoryRequest.empty_like(
a=self.V[0], nb_components=4, backend=self.dvelocity.backend)
requests.push_mem_request('Wtmp', buffers)
@@ -139,49 +172,75 @@ class PythonPenalizeVorticity(HostOperator):
Wtmp = work.get_buffer(self, 'Wtmp', handle=True)
self.tmp_v = Wtmp[0:3]
self.tmp = Wtmp[-1]
+ if self.velocity.dim == 2:
+ self._compute_vorticity = self._compute_vorticity_2d
+ if self.velocity.dim == 3:
+ self._compute_vorticity = self._compute_vorticity_3d
@classmethod
def supported_dimensions(cls):
- return (3, )
+ return (3, 2)
@classmethod
def supports_mpi(cls):
return True
+ def _compute_penalization_implicit(self):
+ dt = self.dt()
+ self.tmp[...] = 0.
+ for c, o in self.dobstacles.iteritems():
+ self.tmp[...] += (-dt) * c(o) / (1.0 + dt * c(o))
+
+ def _compute_penalization_exact(self):
+ dt = self.dt()
+ self.tmp[...] = 1.
+ for c, o in self.dobstacles.iteritems():
+ self.tmp[...] *= np.exp(-dt*c(o))
+ self.tmp[...] -= 1.
+
@op_apply
def apply(self, **kwds):
super(PythonPenalizeVorticity, self).apply(**kwds)
- dt = self.dt()
- V, W = self.V, self.W
+ self.v_ghost_exchanger()
# Penalize velocity
- self.tmp[...] = 0.
- for c, o in self.dobstacles.iteritems():
- dtcoeff = dt * c()
- self.tmp[...] += -dtcoeff*o / (1.0 + dtcoeff*o)
- for v, tmp in zip(V, self.tmp_v):
- tmp[...] = v * self.tmp
+ self._compute_penalization()
+ for ubar, v, tmp in zip(self._ubar(), self.V, self.tmp_v):
+ tmp[...] = (v - ubar) * self.tmp
+
+ self._compute_vorticity()
+ self.w_ghost_exchanger()
+ def _compute_vorticity_3d(self):
# compute penalized vorticity:
# (dvz/dy - dvy/dz)
# W = (dvx/dz - dvz/dx)
# (dvy/dx - dvx/dy)
# X direction
self.tmp = self.stencil[0](a=self.tmp_v[2], out=self.tmp, axis=2)
- W[1][...] += -self.tmp
+ self.W[1][...] += -self.tmp
self.tmp = self.stencil[0](a=self.tmp_v[1], out=self.tmp, axis=2)
- W[2][...] += self.tmp
+ self.W[2][...] += self.tmp
# Y direction
self.tmp = self.stencil[1](a=self.tmp_v[0], out=self.tmp, axis=1)
- W[2][...] += -self.tmp
+ self.W[2][...] += -self.tmp
self.tmp = self.stencil[1](a=self.tmp_v[2], out=self.tmp, axis=1)
- W[0][...] += self.tmp
+ self.W[0][...] += self.tmp
# Z direction
self.tmp = self.stencil[2](a=self.tmp_v[1], out=self.tmp, axis=0)
- W[0][...] += -self.tmp
+ self.W[0][...] += -self.tmp
self.tmp = self.stencil[2](a=self.tmp_v[0], out=self.tmp, axis=0)
- W[1][...] += self.tmp
+ self.W[1][...] += self.tmp
- self.ghost_exchanger()
+ def _compute_vorticity_2d(self):
+ # compute penalized vorticity:
+ # W = (dvy/dx - dvx/dy)
+ # X direction
+ self.tmp = self.stencil[0](a=self.tmp_v[1], out=self.tmp, axis=1)
+ self.W[0][...] += self.tmp
+
+ # Y direction
+ self.tmp = self.stencil[1](a=self.tmp_v[0], out=self.tmp, axis=0)
+ self.W[0][...] += -self.tmp
diff --git a/hysop/backend/host/python/operator/poisson.py b/hysop/backend/host/python/operator/poisson.py
index 1472ac28ea954977ef633e5ec1eeecbb4c0bab99..ae0536e56548413eb9495e02d99e293c5051e675 100644
--- a/hysop/backend/host/python/operator/poisson.py
+++ b/hysop/backend/host/python/operator/poisson.py
@@ -6,7 +6,7 @@ from hysop import __DEFAULT_NUMBA_TARGET__
from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import debug
from hysop.tools.numpywrappers import npw
-from hysop.tools.numba_utils import make_numba_signature
+from hysop.tools.numba_utils import make_numba_signature, prange
from hysop.backend.host.host_operator import HostOperator, OpenClMappable
from hysop.core.graph.graph import op_apply
from hysop.fields.continuous_field import Field
@@ -38,7 +38,7 @@ class PythonPoisson(PoissonOperatorBase, OpenClMappable, HostOperator):
'(n,m),(n),(m)->(n,m)', target=target,
nopython=True, cache=True)
def filter_poisson_2d(Fin, K0, K1, Fout):
- for i in range(1, Fin.shape[0]):
+ for i in prange(1, Fin.shape[0]):
for j in range(0, Fin.shape[1]):
Fout[i,j] /= (K0[i] + K1[j])
for j in range(1, Fin.shape[1]):
@@ -50,11 +50,11 @@ class PythonPoisson(PoissonOperatorBase, OpenClMappable, HostOperator):
'(n,m,p),(n),(m),(p)->(n,m,p)', target=target,
nopython=True, cache=True)
def filter_poisson_3d(Fin, K0, K1, K2, Fout):
- for i in range(1, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(1, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] /= (K0[i] + K1[j] + K2[k])
- for j in range(1, Fin.shape[1]):
+ for j in prange(1, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[0,j,k] /= (K0[0] + K1[j] + K2[k])
for k in range(1, Fin.shape[2]):
@@ -66,16 +66,16 @@ class PythonPoisson(PoissonOperatorBase, OpenClMappable, HostOperator):
'(n,m,p,q),(n),(m),(p),(q)->(n,m,p,q)', target=target,
nopython=True, cache=True)
def filter_poisson_4d(Fin, K0, K1, K2, K3, Fout):
- for i in range(1, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
- for k in range(0, Fin.shape[2]):
+ for i in prange(1, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
+ for k in prange(0, Fin.shape[2]):
for l in range(0, Fin.shape[3]):
Fout[i,j,k,l] /= (K0[i] + K1[j] + K2[k] + K3[l])
- for j in range(1, Fin.shape[1]):
- for k in range(0, Fin.shape[2]):
+ for j in prange(1, Fin.shape[1]):
+ for k in prange(0, Fin.shape[2]):
for l in range(0, Fin.shape[3]):
Fout[0,j,k,l] /= (K0[0] + K1[j] + K2[k] + K3[l])
- for k in range(1, Fin.shape[2]):
+ for k in prange(1, Fin.shape[2]):
for l in range(0, Fin.shape[3]):
Fout[0,0,k,l] /= (K0[0] + K1[0] + K2[k] + K3[l])
for l in range(1, Fin.shape[3]):
diff --git a/hysop/backend/host/python/operator/poisson_curl.py b/hysop/backend/host/python/operator/poisson_curl.py
index 13e80586673b405bb3c7f797ba6042fffbd64ea9..5e724b48c35a283de97d93325cf4f7224397c2ba 100644
--- a/hysop/backend/host/python/operator/poisson_curl.py
+++ b/hysop/backend/host/python/operator/poisson_curl.py
@@ -5,7 +5,7 @@ from hysop import __DEFAULT_NUMBA_TARGET__
from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import debug
from hysop.tools.numpywrappers import npw
-from hysop.tools.numba_utils import make_numba_signature
+from hysop.tools.numba_utils import make_numba_signature, prange
from hysop.core.graph.graph import op_apply
from hysop.backend.host.host_operator import HostOperator, OpenClMappable
from hysop.operator.base.poisson_curl import SpectralPoissonCurlOperatorBase
@@ -28,7 +28,7 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_2d__0_m(Fin, K1, Fout):
- for i in range(0, Fin.shape[0]):
+ for i in prange(0, Fin.shape[0]):
for j in range(0, Fin.shape[1]):
Fout[i,j] = -K1[j]*Fin[i,j]
return functools.partial(filter_curl_2d__0_m, *args)
@@ -42,7 +42,7 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_2d__1_n(Fin, K0, Fout):
- for i in range(0, Fin.shape[0]):
+ for i in prange(0, Fin.shape[0]):
for j in range(0, Fin.shape[1]):
Fout[i,j] = +K0[i]*Fin[i,j]
return functools.partial(filter_curl_2d__1_n, *args)
@@ -55,8 +55,8 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_3d__0_n(Fin, K, Fout):
- for i in range(0, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(0, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] = -K[i]*Fin[i,j,k]
return functools.partial(filter_curl_3d__0_n, *args)
@@ -69,8 +69,8 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_3d__0_m(Fin, K, Fout):
- for i in range(0, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(0, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] = -K[j]*Fin[i,j,k]
return functools.partial(filter_curl_3d__0_m, *args)
@@ -83,8 +83,8 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_3d__0_p(Fin, K, Fout):
- for i in range(0, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(0, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] = -K[k]*Fin[i,j,k]
return functools.partial(filter_curl_3d__0_p, *args)
@@ -97,8 +97,8 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_3d__1_n(Fin, K, Fout):
- for i in range(0, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(0, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] += K[i]*Fin[i,j,k]
return functools.partial(filter_curl_3d__1_n, *args)
@@ -111,8 +111,8 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_3d__1_m(Fin, K, Fout):
- for i in range(0, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(0, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] += K[j]*Fin[i,j,k]
return functools.partial(filter_curl_3d__1_m, *args)
@@ -125,8 +125,8 @@ class PythonPoissonCurl(SpectralPoissonCurlOperatorBase, OpenClMappable, HostOpe
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def filter_curl_3d__1_p(Fin, K, Fout):
- for i in range(0, Fin.shape[0]):
- for j in range(0, Fin.shape[1]):
+ for i in prange(0, Fin.shape[0]):
+ for j in prange(0, Fin.shape[1]):
for k in range(0, Fin.shape[2]):
Fout[i,j,k] += K[k]*Fin[i,j,k]
return functools.partial(filter_curl_3d__1_p, *args)
diff --git a/hysop/backend/host/python/operator/solenoidal_projection.py b/hysop/backend/host/python/operator/solenoidal_projection.py
index c131813b96f2e2fa82378186b07fcd60fde84ff9..a73a02da477b7f7f5ca004e553a09a49167e6ea6 100644
--- a/hysop/backend/host/python/operator/solenoidal_projection.py
+++ b/hysop/backend/host/python/operator/solenoidal_projection.py
@@ -9,7 +9,7 @@ from hysop.tools.numpywrappers import npw
from hysop.backend.host.host_operator import HostOperator, OpenClMappable
from hysop.core.graph.graph import op_apply
from hysop.operator.base.solenoidal_projection import SolenoidalProjectionOperatorBase
-from hysop.tools.numba_utils import make_numba_signature
+from hysop.tools.numba_utils import make_numba_signature, prange
class PythonSolenoidalProjection(SolenoidalProjectionOperatorBase, OpenClMappable, HostOperator):
"""
@@ -39,8 +39,8 @@ class PythonSolenoidalProjection(SolenoidalProjectionOperatorBase, OpenClMappabl
KK10, KK11, KK12,
KK20, KK21, KK22,
Fout0, Fout1, Fout2):
- for i in range(0, Fin0.shape[0]):
- for j in range(0, Fin0.shape[1]):
+ for i in prange(0, Fin0.shape[0]):
+ for j in prange(0, Fin0.shape[1]):
for k in range(0, Fin0.shape[2]):
F0 = Fin0[i,j,k]
F1 = Fin1[i,j,k]
@@ -73,8 +73,8 @@ class PythonSolenoidalProjection(SolenoidalProjectionOperatorBase, OpenClMappabl
@nb.guvectorize([signature], layout,
target=target, nopython=True, cache=True)
def compute_div_3d(Fin0, Fin1, Fin2, K0, K1, K2, Fout):
- for i in range(0, Fin0.shape[0]):
- for j in range(0, Fin0.shape[1]):
+ for i in prange(0, Fin0.shape[0]):
+ for j in prange(0, Fin0.shape[1]):
for k in range(0, Fin0.shape[2]):
Fout[i,j,k] = (K0[i]*Fin0[i,j,k] + K1[j]*Fin1[i,j,k] + K2[k]*Fin2[i,j,k])
diff --git a/hysop/backend/host/python/operator/spatial_filtering.py b/hysop/backend/host/python/operator/spatial_filtering.py
index 82bcaf19d7ae35bd35d2b7da0e173c8ceae982d5..811384d313979d622506af035fe4ac1a0e0e19ba 100644
--- a/hysop/backend/host/python/operator/spatial_filtering.py
+++ b/hysop/backend/host/python/operator/spatial_filtering.py
@@ -1,4 +1,5 @@
+import numpy as np
from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import debug
from hysop.backend.host.host_operator import HostOperator
@@ -6,16 +7,71 @@ from hysop.core.graph.graph import op_apply
from hysop.fields.continuous_field import Field
from hysop.parameters.parameter import Parameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
-from hysop.operator.base.spatial_filtering import RemeshLowpassFilterBase, SpectralLowpassFilterBase, SubgridLowpassFilterBase
+from hysop.operator.base.spatial_filtering import (
+ PolynomialInterpolationFilterBase,
+ RemeshRestrictionFilterBase,
+ SpectralRestrictionFilterBase,
+ SubgridRestrictionFilterBase,
+ PolynomialRestrictionFilterBase)
-class PythonRemeshLowpassFilter(RemeshLowpassFilterBase, HostOperator):
+
+class PythonPolynomialInterpolationFilter(PolynomialInterpolationFilterBase, HostOperator):
+ def discretize(self, **kwds):
+ if self.discretized:
+ return
+ super(PythonPolynomialInterpolationFilter, self).discretize(**kwds)
+ self.Wr = self.subgrid_interpolator.Wr.astype(self.dtype)
+
+ @op_apply
+ def apply(self, **kwds):
+ """Apply analytic formula."""
+ super(PythonPolynomialInterpolationFilter, self).apply(**kwds)
+ fin = self.fin
+ fout = self.fout
+ periodicity = self.dFin.periodicity
+ gr, n = self.subgrid_interpolator.gr, self.subgrid_interpolator.n
+ Wr = self.Wr
+
+ for idx in np.ndindex(*self.iter_shape):
+ oslc = tuple(slice(j*gr[i], (j+1)*gr[i], 1) for i,j in enumerate(idx))
+ islc = tuple(slice(periodicity[i]+j, periodicity[i]+j+n[i], 1)
+ for i,j in enumerate(idx))
+ fout[oslc] = Wr.dot(fin[islc].ravel()).reshape(gr)
+ self.dFout.exchange_ghosts()
+
+
+class PythonPolynomialRestrictionFilter(PolynomialRestrictionFilterBase, HostOperator):
+ def discretize(self, **kwds):
+ if self.discretized:
+ return
+ super(PythonPolynomialRestrictionFilter, self).discretize(**kwds)
+ SR = self.subgrid_restrictor
+ self.Rr = SR.Rr.astype(self.dtype) / SR.GR
+ assert (self.Rr.shape == tuple(2*gi+1 for gi in SR.ghosts)), Rr.shape
+
+ @op_apply
+ def apply(self, **kwds):
+ """Apply analytic formula."""
+ super(PythonPolynomialRestrictionFilter, self).apply(**kwds)
+ fin = self.fin
+ fout = self.fout
+ gr = self.subgrid_restrictor.gr
+ Rr = self.Rr
+ rshape = Rr.shape
+
+ for idx in np.ndindex(*self.iter_shape):
+ islc = tuple(slice(j*gr[i], j*gr[i]+rshape[i], 1) for i,j in enumerate(idx))
+ fout[idx] = (Rr*fin[islc]).sum()
+ self.dFout.exchange_ghosts()
+
+class PythonRemeshRestrictionFilter(RemeshRestrictionFilterBase, HostOperator):
"""
Python implementation for lowpass spatial filtering: small grid -> coarse grid
using remeshing kernels.
"""
def setup(self, **kwds):
- super(PythonRemeshLowpassFilter, self).setup(**kwds)
+ super(PythonRemeshRestrictionFilter, self).setup(**kwds)
fin = self.fin
iratio = self.iratio
oshape = self.fout.shape
@@ -29,7 +85,7 @@ class PythonRemeshLowpassFilter(RemeshLowpassFilterBase, HostOperator):
@op_apply
def apply(self, **kwds):
"""Apply analytic formula."""
- super(PythonRemeshLowpassFilter, self).apply(**kwds)
+ super(PythonRemeshRestrictionFilter, self).apply(**kwds)
fin, fout = self.fin, self.fout
fout[...] = 0
@@ -38,7 +94,7 @@ class PythonRemeshLowpassFilter(RemeshLowpassFilterBase, HostOperator):
self.dFout.exchange_ghosts()
-class PythonSpectralLowpassFilter(SpectralLowpassFilterBase, HostOperator):
+class PythonSpectralRestrictionFilter(SpectralRestrictionFilterBase, HostOperator):
"""
Python implementation for lowpass spatial filtering: small grid -> coarse grid
using the spectral method.
@@ -47,7 +103,7 @@ class PythonSpectralLowpassFilter(SpectralLowpassFilterBase, HostOperator):
@op_apply
def apply(self, simulation, **kwds):
"""Apply spectral filter (which is just a square window centered on low frequencies)."""
- super(PythonSpectralLowpassFilter, self).apply(**kwds)
+ super(PythonSpectralRestrictionFilter, self).apply(**kwds)
self.Ft(simulation=simulation)
for i, (src_slc, dst_slc) in enumerate(zip(*self.fslices)):
self.FOUT[dst_slc] = self.FIN[src_slc]
@@ -65,7 +121,7 @@ class PythonSpectralLowpassFilter(SpectralLowpassFilterBase, HostOperator):
return scaling
-class PythonSubgridLowpassFilter(SubgridLowpassFilterBase, HostOperator):
+class PythonSubgridRestrictionFilter(SubgridRestrictionFilterBase, HostOperator):
"""
Python implementation for lowpass spatial filtering: small grid -> coarse grid
byt just taking subpoints.
@@ -74,7 +130,7 @@ class PythonSubgridLowpassFilter(SubgridLowpassFilterBase, HostOperator):
@op_apply
def apply(self, simulation, **kwds):
"""Apply subgrid filter."""
- super(PythonSubgridLowpassFilter, self).apply(**kwds)
+ super(PythonSubgridRestrictionFilter, self).apply(**kwds)
self.fout[...] = self.fin[...]
self.dFout.exchange_ghosts()
diff --git a/hysop/backend/host/python/operator/transpose.py b/hysop/backend/host/python/operator/transpose.py
index 36e591c6bba0507b27f807ddb8a85df0aecaf431..840ac9c97c7edcc481d596cee270ec8f094e6405 100644
--- a/hysop/backend/host/python/operator/transpose.py
+++ b/hysop/backend/host/python/operator/transpose.py
@@ -1,10 +1,21 @@
-from hysop.deps import np
-
+from hysop.constants import MemoryOrdering
from hysop.tools.decorators import debug, profile
from hysop.backend.host.host_operator import HostOperator
from hysop.operator.base.transpose_operator import TransposeOperatorBase
from hysop.core.graph.graph import op_apply
+import numpy as np
+try:
+ import hptt
+ HAS_HPTT=True
+ # required version is: https://gitlab.com/keckj/hptt
+except ImportError:
+ HAS_HPTT=False
+ import warnings
+ from hysop.tools.warning import HysopPerformanceWarning
+ msg='Failed to import HPTT module, falling back to slow numpy transpose. Required version is available at https://gitlab.com/keckj/hptt.'
+ warnings.warn(msg, HysopPerformanceWarning)
+
class PythonTranspose(TransposeOperatorBase, HostOperator):
"""
Inplace and out of place field transposition and permutations in general.
@@ -16,25 +27,69 @@ class PythonTranspose(TransposeOperatorBase, HostOperator):
"""Initialize a Transpose operator on the python backend."""
super(PythonTranspose, self).__init__(**kwds)
+
+ def discretize(self):
+ super(PythonTranspose, self).discretize()
+ assert self.din.dtype == self.dout.dtype
+ dtype = self.din.dtype
+ if HAS_HPTT and (dtype in (np.float32, np.float64, np.complex64, np.complex128)):
+ if self.is_inplace:
+ self.exec_transpose = self.transpose_hptt_inplace
+ else:
+ self.exec_transpose = self.transpose_hptt_outofplace
+ else:
+ if self.is_inplace:
+ self.exec_transpose = self.transpose_np_inplace
+ else:
+ self.exec_transpose = self.transpose_np_outofplace
+
+ @debug
+ def get_field_requirements(self):
+ requirements = super(PythonTranspose, self).get_field_requirements()
+ for (is_input, reqs) in requirements.iter_requirements():
+ if (reqs is None):
+ continue
+ (field, td, req) = reqs
+ req.memory_order = MemoryOrdering.ANY
+ return requirements
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
@op_apply
def apply(self, **kwds):
""" Transpose in or out of place."""
super(PythonTranspose,self).apply(**kwds)
+ self.exec_transpose(**kwds)
+
+ def transpose_hptt_inplace(self, **kwds):
+ axes = self.axes
+ din, dout, dtmp = self.din, self.dout, self.dtmp.handle.view(np.ndarray)
+ assert self.din.dfield is self.dout.dfield
+ for i in xrange(din.nb_components):
+ hptt.transpose(a=din.buffers[i], out=dtmp, axes=axes)
+ dout.buffers[i][...] = dtmp
+
+ def transpose_hptt_outofplace(self, **kwds):
+ axes = self.axes
+ din, dout = self.din, self.dout
+ assert self.din.dfield is not self.dout.dfield
+ for i in xrange(din.nb_components):
+ hptt.transpose(a=din.buffers[i], out=dout.buffers[i], axes=axes)
+ def transpose_np_inplace(self, **kwds):
axes = self.axes
-
- if self.is_inplace:
- din, dout, dtmp = self.din, self.dout, self.dtmp.handle.view(np.ndarray)
- assert self.din.dfield is self.dout.dfield
- for i in xrange(din.nb_components):
- dtmp[...] = np.transpose(din.buffers[i], axes=axes)
- dout.buffers[i][...] = dtmp
- else:
- din, dout = self.din, self.dout
- assert self.din.dfield is not self.dout.dfield
- for i in xrange(din.nb_components):
- dout.buffers[i][...] = np.transpose(din.buffers[i], axes=axes)
-
- @classmethod
- def supports_mpi(cls):
- return True
+ din, dout, dtmp = self.din, self.dout, self.dtmp.handle.view(np.ndarray)
+ assert self.din.dfield is self.dout.dfield
+ for i in xrange(din.nb_components):
+ dtmp[...] = np.transpose(din.buffers[i], axes=axes)
+ dout.buffers[i][...] = dtmp
+
+ def transpose_np_outofplace(self, **kwds):
+ axes = self.axes
+ din, dout = self.din, self.dout
+ assert self.din.dfield is not self.dout.dfield
+ for i in xrange(din.nb_components):
+ dout.buffers[i][...] = np.transpose(din.buffers[i], axes=axes)
+
diff --git a/hysop/backend/host/python/operator/vorticity_absorption.py b/hysop/backend/host/python/operator/vorticity_absorption.py
old mode 100755
new mode 100644
diff --git a/hysop/constants.py.in b/hysop/constants.py.in
index 00ad5a1f0384ac3c7f0e61966249c50a7b36796d..21923e645f8f021dd1380abb2cc4a048b3726090 100644
--- a/hysop/constants.py.in
+++ b/hysop/constants.py.in
@@ -43,7 +43,7 @@ HYSOP_INTEGER = np.int32
SIZEOF_HYSOP_INTEGER = int(HYSOP_INTEGER(1).nbytes)
"""Size in memory of hysop integer type"""
-HYSOP_DIM = np.int16
+HYSOP_DIM = np.int32
"""integer used for arrays dimensions"""
SIZEOF_HYSOP_DIM = int(HYSOP_DIM(1).nbytes)
"""Size in memory of hysop dim type"""
@@ -66,9 +66,6 @@ if __MPI_ENABLED__:
HYSOP_MPI_INTEGER = MPI.INT
"""integer type used in MPI"""
- HYSOP_MPI_ORDER = @MPI_DATA_LAYOUT@
- """Default array layout for MPI"""
-
HYSOP_DEFAULT_TASK_ID = 999
"""Default value for task id (mpi task)"""
@@ -149,9 +146,25 @@ BoundaryCondition = EnumFactory.create('BoundaryCondition',
'HOMOGENEOUS_NEUMANN', 'HOMOGENEOUS_DIRICHLET',
'NEUMANN', 'DIRICHLET' ])
"""Boundary conditions enum"""
+
+class BoundaryConditionConfig(object):
+ def __init__(self, bc, data=None):
+ assert isinstance(bc, BoundaryCondition), type(bc)
+ self.bc = bc
+ self.data = data
+ def __str__(self):
+ return bc.__str__()[:-1] + ', {})'.format(self.data)
+ def __repr__(self):
+ return bc.__repr__()[:-1] + ', {})'.format(self.data)
+for bc in BoundaryCondition.fields():
+ bc = getattr(BoundaryCondition, bc)
+ bc.bc = bc
+ bc.bind_data = lambda data, bc=bc: BoundaryConditionConfig(bc=bc, data=data)
def boundary2str(b):
"""Helper function to convert a BoundaryCondition to a short string."""
+ if isinstance(b, BoundaryConditionConfig):
+ b = b.bc
sstr = {
BoundaryCondition.NONE: 'NONE',
BoundaryCondition.MIXED: 'MIXED',
@@ -192,6 +205,11 @@ StretchingFormulation = EnumFactory.create('StretchingFormulation',
['GRAD_UW', 'GRAD_UW_T', 'MIXED_GRAD_UW', 'CONSERVATIVE'])
"""Stretching formulations"""
+PenalizationFormulation = EnumFactory.create(
+ 'PenalizationFormulation',
+ ['IMPLICIT', 'EXACT'])
+"""Penalization formulations"""
+
SpaceDiscretization = EnumFactory.create('SpaceDiscretization',
['FDC2', 'FDC4', 'FDC6', 'FDC8'])
"""Space discretization for stencil generation"""
diff --git a/hysop/core/arrays/array.py b/hysop/core/arrays/array.py
index f2fa434ea080844913a8b00a1236408b66709f5d..27a8f7b48266d1e6fcbb87381cb659168a05eb93 100644
--- a/hysop/core/arrays/array.py
+++ b/hysop/core/arrays/array.py
@@ -350,10 +350,10 @@ class Array(object):
return default_order
else:
axes = self.logical_axes()
- fortran = np.arange(dim)
- if (axes==fortran[::-1]).all():
+ c_axes = np.arange(dim)
+ if (axes==c_axes).all():
return MemoryOrdering.C_CONTIGUOUS
- elif (axes==fortran).all():
+ elif (axes==c_axes[::-1]).all():
return MemoryOrdering.F_CONTIGUOUS
else:
return MemoryOrdering.OUT_OF_ORDER
diff --git a/hysop/core/arrays/array_backend.py b/hysop/core/arrays/array_backend.py
index 29278852eacd7e1d32e5c559d1fbe1974df1c5cd..534855a98ec74029b7bdb14476bdc36a467de0ae 100644
--- a/hysop/core/arrays/array_backend.py
+++ b/hysop/core/arrays/array_backend.py
@@ -549,7 +549,7 @@ Exception was:
"""
self._not_implemented_yet('empty')
- def empty_like(self, a, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True):
+ def empty_like(self, a, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True, shape=None):
"""
Return a new array with the same shape and type as a given array.
"""
@@ -573,7 +573,7 @@ Exception was:
"""
self._not_implemented_yet('ones')
- def ones_like(self, a, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True):
+ def ones_like(self, a, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True, shape=None):
"""
Return an array of ones with the same shape and type as a given array.
"""
@@ -585,7 +585,7 @@ Exception was:
"""
self._not_implemented_yet('zeros')
- def zeros_like(self, a, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True):
+ def zeros_like(self, a, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True, shape=None):
"""
Return an array of zeros with the same shape and type as a given array.
"""
@@ -597,7 +597,7 @@ Exception was:
"""
self._not_implemented_yet('full')
- def full_like(self, a, fill_value, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True):
+ def full_like(self, a, fill_value, dtype=None, order=MemoryOrdering.SAME_ORDER, subok=True, shape=None):
"""
Return a full array with the same shape and type as a given array.
"""
diff --git a/hysop/core/arrays/tests/test_array.py b/hysop/core/arrays/tests/test_array.py
index 2520b3435bcd3d58773478a7b27cb79bfcc8f62b..cfe8cfeff084fd8997b14c180ba5837342b6cb13 100644
--- a/hysop/core/arrays/tests/test_array.py
+++ b/hysop/core/arrays/tests/test_array.py
@@ -3,7 +3,7 @@ import warnings
from contextlib import contextmanager
from random import randint
from hysop.testsenv import opencl_failed, iter_clenv, \
- __HAS_OPENCL_BACKEND__, __ENABLE_LONG_TESTS__
+ __HAS_OPENCL_BACKEND__, __ENABLE_LONG_TESTS__
from hysop.tools.contexts import printoptions
from hysop.tools.numerics import match_float_type, is_unsigned, is_integer, is_complex
from hysop.tools.types import to_list
@@ -14,6 +14,7 @@ from hysop.core.arrays.all import HostArrayBackend, OpenClArrayBackend, ArrayBac
from hysop.backend.host.host_allocator import HostAllocator
from hysop.core.memory.mempool import MemoryPool
+
class TestArray(object):
@classmethod
@@ -23,7 +24,7 @@ class TestArray(object):
@classmethod
def teardown_class(cls):
pass
-
+
def setup_method(self, method):
pass
@@ -38,195 +39,204 @@ class TestArray(object):
d = backend.full_like(c, fill_value=2)
e = backend.empty_like(d)
e.fill(3)
- for buf,val in zip([a,b,c,d,e],[-1,0,1,2,3]):
+ for buf, val in zip([a, b, c, d, e], [-1, 0, 1, 2, 3]):
assert buf.ndim == 1
- assert buf.size == 10
+ assert buf.size == 10
assert buf.shape == (10,)
assert buf.itemsize == 2
assert buf.nbytes == 20
assert buf.dtype == np.int16
- assert buf.sum().get()==val*10
- assert buf.prod()==val**10
+ assert buf.sum().get() == val*10
+ assert buf.prod() == val**10
assert buf.is_c_contiguous()
assert buf.is_fortran_contiguous()
assert buf.is_hysop_contiguous()
-
- a = backend.empty(shape=(10,10,), dtype=np.float64,
- order=MemoryOrdering.C_CONTIGUOUS)
+
+ a = backend.empty(shape=(10, 10,), dtype=np.float64,
+ order=MemoryOrdering.C_CONTIGUOUS)
a.fill(15)
b = backend.zeros_like(a)
c = backend.ones_like(b)
d = backend.full_like(c, fill_value=2)
- for buf,val in zip([a,b,c,d],[15,0,1,2]):
+ for buf, val in zip([a, b, c, d], [15, 0, 1, 2]):
assert buf.ndim == 2
- assert buf.size == 100
- assert buf.shape == (10,10,)
+ assert buf.size == 100
+ assert buf.shape == (10, 10,)
assert buf.itemsize == 8
assert buf.nbytes == 800
assert buf.dtype == np.float64
- assert np.allclose(buf.sum().get(),val*100.0)
+ assert np.allclose(buf.sum().get(), val*100.0)
assert buf.is_c_contiguous()
-
- a = backend.empty(shape=(10,10,), dtype=np.float32,
- order=MemoryOrdering.F_CONTIGUOUS)
+
+ a = backend.empty(shape=(10, 10,), dtype=np.float32,
+ order=MemoryOrdering.F_CONTIGUOUS)
a.fill(15)
b = backend.zeros_like(a)
c = backend.ones_like(b)
d = backend.full_like(c, fill_value=2)
- for buf,val in zip([a,b,c,d],[15,0,1,2]):
+ for buf, val in zip([a, b, c, d], [15, 0, 1, 2]):
assert buf.ndim == 2
- assert buf.size == 100
- assert buf.shape == (10,10,)
+ assert buf.size == 100
+ assert buf.shape == (10, 10,)
assert buf.itemsize == 4
assert buf.nbytes == 400
assert buf.dtype == np.float32
- assert buf.sum().get()==val*100
+ assert buf.sum().get() == val*100
assert buf.is_fortran_contiguous()
-
+
a.fill(5)
b.copy_from(a)
c.copy_from(b.handle)
d = c.copy()
- for buf in [a,b,c,d]:
+ for buf in [a, b, c, d]:
assert buf.ndim == 2
- assert buf.size == 100
- assert buf.shape == (10,10,)
+ assert buf.size == 100
+ assert buf.shape == (10, 10,)
assert buf.itemsize == 4
assert buf.nbytes == 400
assert buf.dtype == np.float32
- assert buf.sum().get()==5*100
+ assert buf.sum().get() == 5*100
assert buf.is_fortran_contiguous()
def _test_transpose_routines(self, backend):
-
+
# ensure strides are working as intended
# (strides are in bytes but itemsize == 1 byte here)
- A = backend.arange(2*4*8, dtype=np.int8).reshape((2,4,8), order=MemoryOrdering.C_CONTIGUOUS)
- B = backend.arange(2*4*8, dtype=np.int8).reshape((2,4,8), order=MemoryOrdering.F_CONTIGUOUS)
- i1,j1,k1 = (randint(0, A.shape[i]-1) for i in xrange(3))
- i0,j0,k0 = (randint(0, A.shape[i]-1) for i in xrange(3))
-
- assert A.dtype.itemsize==1
- assert A.shape == (2,4,8)
+ A = backend.arange(2*4*8, dtype=np.int8).reshape((2, 4, 8),
+ order=MemoryOrdering.C_CONTIGUOUS)
+ B = backend.arange(2*4*8, dtype=np.int8).reshape((2, 4, 8),
+ order=MemoryOrdering.F_CONTIGUOUS)
+ i1, j1, k1 = (randint(0, A.shape[i]-1) for i in xrange(3))
+ i0, j0, k0 = (randint(0, A.shape[i]-1) for i in xrange(3))
+
+ assert A.dtype.itemsize == 1
+ assert A.shape == (2, 4, 8)
assert A[0][0][0] == 0
- assert A[0][0][1] == 1
+ assert A[0][0][1] == 1
assert A[0][1][0] == 8
assert A[1][0][0] == 8*4
- assert A.strides == (8*4,8,1)
+ assert A.strides == (8*4, 8, 1)
assert A[1][1][1] == np.sum(np.asarray(A.strides) / A.dtype.itemsize)
- assert A[i1][j1][k1] == np.sum(np.asarray(A.strides) * (i1,j1,k1))
- assert A[i0][j0][k0] == np.sum(np.asarray(A.strides) * (i0,j0,k0))
- assert (A[i1][j1][k1]-A[i0][j0][k0]) == np.dot(A.strides, (i1-i0,j1-j0,k1-k0))
-
- assert B.dtype.itemsize==1
- assert B.shape == (2,4,8)
+ assert A[i1][j1][k1] == np.sum(np.asarray(A.strides) * (i1, j1, k1))
+ assert A[i0][j0][k0] == np.sum(np.asarray(A.strides) * (i0, j0, k0))
+ assert (A[i1][j1][k1]-A[i0][j0][k0]) == np.dot(A.strides, (i1-i0, j1-j0, k1-k0))
+
+ assert B.dtype.itemsize == 1
+ assert B.shape == (2, 4, 8)
assert B[0][0][0] == 0
assert B[0][0][1] == 2*4
assert B[0][1][0] == 2
assert B[1][0][0] == 1
- assert B.strides == (1,2,2*4)
+ assert B.strides == (1, 2, 2*4)
assert B[1][1][1] == np.sum(np.asarray(B.strides) / B.dtype.itemsize)
- assert B[i1][j1][k1] == np.sum(np.asarray(B.strides) * (i1,j1,k1))
- assert B[i0][j0][k0] == np.sum(np.asarray(B.strides) * (i0,j0,k0))
- assert (B[i1][j1][k1]-B[i0][j0][k0]) == np.dot(B.strides, (i1-i0,j1-j0,k1-k0))
-
+ assert B[i1][j1][k1] == np.sum(np.asarray(B.strides) * (i1, j1, k1))
+ assert B[i0][j0][k0] == np.sum(np.asarray(B.strides) * (i0, j0, k0))
+ assert (B[i1][j1][k1]-B[i0][j0][k0]) == np.dot(B.strides, (i1-i0, j1-j0, k1-k0))
+
# ensure permutations are working as intended
- A = backend.arange(6, dtype=np.int8).reshape((1,2,3), order=MemoryOrdering.C_CONTIGUOUS)
- B = backend.arange(6, dtype=np.int8).reshape((1,2,3), order=MemoryOrdering.F_CONTIGUOUS)
- for arr in (A,B):
- # all 3d permutations
- assert backend.transpose(arr, axes=(0,1,2)).shape == (1,2,3)
- assert backend.transpose(arr, axes=(0,2,1)).shape == (1,3,2)
- assert backend.transpose(arr, axes=(1,0,2)).shape == (2,1,3)
- assert backend.transpose(arr, axes=(2,1,0)).shape == (3,2,1)
- assert backend.transpose(arr, axes=(2,0,1)).shape == (3,1,2)
- assert backend.transpose(arr, axes=(1,2,0)).shape == (2,3,1)
-
+ A = backend.arange(6, dtype=np.int8).reshape((1, 2, 3), order=MemoryOrdering.C_CONTIGUOUS)
+ B = backend.arange(6, dtype=np.int8).reshape((1, 2, 3), order=MemoryOrdering.F_CONTIGUOUS)
+ for arr in (A, B):
+ # all 3d permutations
+ assert backend.transpose(arr, axes=(0, 1, 2)).shape == (1, 2, 3)
+ assert backend.transpose(arr, axes=(0, 2, 1)).shape == (1, 3, 2)
+ assert backend.transpose(arr, axes=(1, 0, 2)).shape == (2, 1, 3)
+ assert backend.transpose(arr, axes=(2, 1, 0)).shape == (3, 2, 1)
+ assert backend.transpose(arr, axes=(2, 0, 1)).shape == (3, 1, 2)
+ assert backend.transpose(arr, axes=(1, 2, 0)).shape == (2, 3, 1)
+
# transpositions (cycles of length 2)
- assert backend.transpose(backend.transpose(arr, axes=(0,1,2)), axes=(0,1,2)).shape == (1,2,3)
- assert backend.transpose(backend.transpose(arr, axes=(0,2,1)), axes=(0,2,1)).shape == (1,2,3)
- assert backend.transpose(backend.transpose(arr, axes=(1,0,2)), axes=(1,0,2)).shape == (1,2,3)
- assert backend.transpose(backend.transpose(arr, axes=(2,1,0)), axes=(2,1,0)).shape == (1,2,3)
- assert backend.transpose(backend.transpose(arr, axes=(2,0,1)), axes=(1,2,0)).shape == (1,2,3)
- assert backend.transpose(backend.transpose(arr, axes=(1,2,0)), axes=(2,0,1)).shape == (1,2,3)
+ assert backend.transpose(backend.transpose(arr, axes=(0, 1, 2)),
+ axes=(0, 1, 2)).shape == (1, 2, 3)
+ assert backend.transpose(backend.transpose(arr, axes=(0, 2, 1)),
+ axes=(0, 2, 1)).shape == (1, 2, 3)
+ assert backend.transpose(backend.transpose(arr, axes=(1, 0, 2)),
+ axes=(1, 0, 2)).shape == (1, 2, 3)
+ assert backend.transpose(backend.transpose(arr, axes=(2, 1, 0)),
+ axes=(2, 1, 0)).shape == (1, 2, 3)
+ assert backend.transpose(backend.transpose(arr, axes=(2, 0, 1)),
+ axes=(1, 2, 0)).shape == (1, 2, 3)
+ assert backend.transpose(backend.transpose(arr, axes=(1, 2, 0)),
+ axes=(2, 0, 1)).shape == (1, 2, 3)
# cycles of length 3
- assert backend.transpose(backend.transpose(backend.transpose(arr, axes=(2,0,1)), axes=(2,0,1)), axes=(2,0,1)).shape == (1,2,3)
- assert backend.transpose(backend.transpose(backend.transpose(arr, axes=(1,2,0)), axes=(1,2,0)), axes=(1,2,0)).shape == (1,2,3)
-
+ assert backend.transpose(backend.transpose(backend.transpose(
+ arr, axes=(2, 0, 1)), axes=(2, 0, 1)), axes=(2, 0, 1)).shape == (1, 2, 3)
+ assert backend.transpose(backend.transpose(backend.transpose(
+ arr, axes=(1, 2, 0)), axes=(1, 2, 0)), axes=(1, 2, 0)).shape == (1, 2, 3)
+
# roll, swap and move axes
- assert backend.rollaxis(arr, axis=0, start=0).shape == (1,2,3)
- assert backend.rollaxis(arr, axis=1, start=0).shape == (2,1,3)
- assert backend.rollaxis(arr, axis=2, start=0).shape == (3,1,2)
- assert backend.rollaxis(arr, axis=0, start=1).shape == (1,2,3)
- assert backend.rollaxis(arr, axis=1, start=1).shape == (1,2,3)
- assert backend.rollaxis(arr, axis=2, start=1).shape == (1,3,2)
- assert backend.rollaxis(arr, axis=0, start=2).shape == (2,1,3)
- assert backend.rollaxis(arr, axis=1, start=2).shape == (1,2,3)
- assert backend.rollaxis(arr, axis=2, start=2).shape == (1,2,3)
- assert backend.rollaxis(arr, axis=0, start=3).shape == (2,3,1)
- assert backend.rollaxis(arr, axis=1, start=3).shape == (1,3,2)
- assert backend.rollaxis(arr, axis=2, start=3).shape == (1,2,3)
-
- assert backend.swapaxes(arr, axis1=0, axis2=0).shape == (1,2,3)
- assert backend.swapaxes(arr, axis1=1, axis2=0).shape == (2,1,3)
- assert backend.swapaxes(arr, axis1=2, axis2=0).shape == (3,2,1)
- assert backend.swapaxes(arr, axis1=0, axis2=1).shape == (2,1,3)
- assert backend.swapaxes(arr, axis1=1, axis2=1).shape == (1,2,3)
- assert backend.swapaxes(arr, axis1=2, axis2=1).shape == (1,3,2)
- assert backend.swapaxes(arr, axis1=0, axis2=2).shape == (3,2,1)
- assert backend.swapaxes(arr, axis1=1, axis2=2).shape == (1,3,2)
- assert backend.swapaxes(arr, axis1=2, axis2=2).shape == (1,2,3)
-
- assert backend.moveaxis(arr, source=0, destination=0).shape == (1,2,3)
- assert backend.moveaxis(arr, source=1, destination=0).shape == (2,1,3)
- assert backend.moveaxis(arr, source=2, destination=0).shape == (3,1,2)
- assert backend.moveaxis(arr, source=0, destination=1).shape == (2,1,3)
- assert backend.moveaxis(arr, source=1, destination=1).shape == (1,2,3)
- assert backend.moveaxis(arr, source=2, destination=1).shape == (1,3,2)
- assert backend.moveaxis(arr, source=0, destination=2).shape == (2,3,1)
- assert backend.moveaxis(arr, source=1, destination=2).shape == (1,3,2)
- assert backend.moveaxis(arr, source=2, destination=2).shape == (1,2,3)
-
+ assert backend.rollaxis(arr, axis=0, start=0).shape == (1, 2, 3)
+ assert backend.rollaxis(arr, axis=1, start=0).shape == (2, 1, 3)
+ assert backend.rollaxis(arr, axis=2, start=0).shape == (3, 1, 2)
+ assert backend.rollaxis(arr, axis=0, start=1).shape == (1, 2, 3)
+ assert backend.rollaxis(arr, axis=1, start=1).shape == (1, 2, 3)
+ assert backend.rollaxis(arr, axis=2, start=1).shape == (1, 3, 2)
+ assert backend.rollaxis(arr, axis=0, start=2).shape == (2, 1, 3)
+ assert backend.rollaxis(arr, axis=1, start=2).shape == (1, 2, 3)
+ assert backend.rollaxis(arr, axis=2, start=2).shape == (1, 2, 3)
+ assert backend.rollaxis(arr, axis=0, start=3).shape == (2, 3, 1)
+ assert backend.rollaxis(arr, axis=1, start=3).shape == (1, 3, 2)
+ assert backend.rollaxis(arr, axis=2, start=3).shape == (1, 2, 3)
+
+ assert backend.swapaxes(arr, axis1=0, axis2=0).shape == (1, 2, 3)
+ assert backend.swapaxes(arr, axis1=1, axis2=0).shape == (2, 1, 3)
+ assert backend.swapaxes(arr, axis1=2, axis2=0).shape == (3, 2, 1)
+ assert backend.swapaxes(arr, axis1=0, axis2=1).shape == (2, 1, 3)
+ assert backend.swapaxes(arr, axis1=1, axis2=1).shape == (1, 2, 3)
+ assert backend.swapaxes(arr, axis1=2, axis2=1).shape == (1, 3, 2)
+ assert backend.swapaxes(arr, axis1=0, axis2=2).shape == (3, 2, 1)
+ assert backend.swapaxes(arr, axis1=1, axis2=2).shape == (1, 3, 2)
+ assert backend.swapaxes(arr, axis1=2, axis2=2).shape == (1, 2, 3)
+
+ assert backend.moveaxis(arr, source=0, destination=0).shape == (1, 2, 3)
+ assert backend.moveaxis(arr, source=1, destination=0).shape == (2, 1, 3)
+ assert backend.moveaxis(arr, source=2, destination=0).shape == (3, 1, 2)
+ assert backend.moveaxis(arr, source=0, destination=1).shape == (2, 1, 3)
+ assert backend.moveaxis(arr, source=1, destination=1).shape == (1, 2, 3)
+ assert backend.moveaxis(arr, source=2, destination=1).shape == (1, 3, 2)
+ assert backend.moveaxis(arr, source=0, destination=2).shape == (2, 3, 1)
+ assert backend.moveaxis(arr, source=1, destination=2).shape == (1, 3, 2)
+ assert backend.moveaxis(arr, source=2, destination=2).shape == (1, 2, 3)
def _test_array_manipulation_routines(self, backend):
t3d = TranspositionState[3]
-
- a = backend.empty(shape=(8,4,2), dtype=np.int8,
- order=MemoryOrdering.C_CONTIGUOUS)
- b = backend.empty(shape=(2,4,8), dtype=np.int8,
- order=MemoryOrdering.F_CONTIGUOUS)
- a.copy_from(backend.arange(0,a.size,dtype=a.dtype))
- b.copy_from(backend.arange(0,b.size,dtype=b.dtype))
-
- assert a.transposition_state()==t3d.ZYX
- assert b.transposition_state()==t3d.XYZ
- assert (a.ravel()==b.ravel(order=MemoryOrdering.C_CONTIGUOUS)).all()
+
+ a = backend.empty(shape=(8, 4, 2), dtype=np.int8,
+ order=MemoryOrdering.C_CONTIGUOUS)
+ b = backend.empty(shape=(2, 4, 8), dtype=np.int8,
+ order=MemoryOrdering.F_CONTIGUOUS)
+ a.copy_from(backend.arange(0, a.size, dtype=a.dtype))
+ b.copy_from(backend.arange(0, b.size, dtype=b.dtype))
+
+ assert a.transposition_state() == t3d.ZYX
+ assert b.transposition_state() == t3d.XYZ
+ assert (a.ravel() == b.ravel(order=MemoryOrdering.C_CONTIGUOUS)).all()
a = a.transpose_to_state(t3d.XZY)
b = b.transpose_to_state(t3d.XZY)
assert a.order == MemoryOrdering.OUT_OF_ORDER
assert b.order == MemoryOrdering.OUT_OF_ORDER
- assert a.transposition_state()==t3d.XZY
- assert b.transposition_state()==t3d.XZY
+ assert a.transposition_state() == t3d.XZY
+ assert b.transposition_state() == t3d.XZY
- a = a.transpose([2,0,1])
- b = b.transpose([1,2,0])
- assert a.transposition_state()==t3d.YXZ
- assert b.transposition_state()==t3d.ZYX
+ a = a.transpose([2, 0, 1])
+ b = b.transpose([1, 2, 0])
+ assert a.transposition_state() == t3d.YXZ
+ assert b.transposition_state() == t3d.ZYX
a = a.transpose_to_state(t3d.ZYX)
b = b.transpose_to_state(t3d.XYZ)
- assert (a.ravel()==b.ravel(order=MemoryOrdering.C_CONTIGUOUS)).all()
+ assert (a.ravel() == b.ravel(order=MemoryOrdering.C_CONTIGUOUS)).all()
a = a.reshape(8*4*2)
b = a.reshape(8*4*2)
assert a.order == default_order
assert b.order == default_order
- assert (a==b).all()
+ assert (a == b).all()
- a = a.reshape((8,4,2), order=MemoryOrdering.C_CONTIGUOUS)
- b = b.reshape((8,4,2), order=MemoryOrdering.F_CONTIGUOUS)
+ a = a.reshape((8, 4, 2), order=MemoryOrdering.C_CONTIGUOUS)
+ b = b.reshape((8, 4, 2), order=MemoryOrdering.F_CONTIGUOUS)
assert a.order == MemoryOrdering.C_CONTIGUOUS
assert b.order == MemoryOrdering.F_CONTIGUOUS
@@ -251,150 +261,149 @@ class TestArray(object):
assert a0.transposition_state() == t3d.XYZ
assert a1.transposition_state() == t3d.ZYX
- assert (a0==a).all()
- assert (a1==a).all()
- assert (a2==a).all()
+ assert (a0 == a).all()
+ assert (a1 == a).all()
+ assert (a2 == a).all()
def _test_binary_operations(self, backend):
- a = backend.rand((10,10))
+ a = backend.rand((10, 10))
b = backend.rint(a)
- a = backend.rint(backend.rand((10,10))).astype(np.uint8)
- b = backend.rint(backend.rand((10,10))).astype(np.uint8)
- c = backend.rint(backend.rand((10,10))).astype(np.uint8)
- d = backend.rint(backend.rand((10,10))).astype(np.uint8)
-
+ a = backend.rint(backend.rand((10, 10))).astype(np.uint8)
+ b = backend.rint(backend.rand((10, 10))).astype(np.uint8)
+ c = backend.rint(backend.rand((10, 10))).astype(np.uint8)
+ d = backend.rint(backend.rand((10, 10))).astype(np.uint8)
+
assert ((~(~a)) == a).all()
- assert (((a<<2<<3)>>5) == a).all()
- assert ((a>>1)==0).all()
- assert ((a|b|c|d)==(d|c|b|a)).all()
- assert ((a&b&c&d)==(d&c&b&a)).all()
- assert ((a^b)==(b^a)).all()
- assert ((~(a|b))==((~a)&(~b))).all()
-
- a = backend.rint(10000*backend.rand((10,10))).astype(np.uint64)
- b = backend.rint(10000*backend.rand((10,10))).astype(np.uint64)
- c = backend.rint(10000*backend.rand((10,10))).astype(np.uint64)
- d = backend.rint(10000*backend.rand((10,10))).astype(np.uint64)
-
+ assert (((a << 2 << 3) >> 5) == a).all()
+ assert ((a >> 1) == 0).all()
+ assert ((a | b | c | d) == (d | c | b | a)).all()
+ assert ((a & b & c & d) == (d & c & b & a)).all()
+ assert ((a ^ b) == (b ^ a)).all()
+ assert ((~(a | b)) == ((~a) & (~b))).all()
+
+ a = backend.rint(10000*backend.rand((10, 10))).astype(np.uint64)
+ b = backend.rint(10000*backend.rand((10, 10))).astype(np.uint64)
+ c = backend.rint(10000*backend.rand((10, 10))).astype(np.uint64)
+ d = backend.rint(10000*backend.rand((10, 10))).astype(np.uint64)
+
assert ((~(~a)) == a).all()
- assert (((a<<2<<3)>>5) == a).all()
- assert ((a|b|c|d)==(d|c|b|a)).all()
- assert ((a&b&c&d)==(d&c&b&a)).all()
- assert ((a^b)==(b^a)).all()
- assert ((~(a|b))==((~a)&(~b))).all()
-
+ assert (((a << 2 << 3) >> 5) == a).all()
+ assert ((a | b | c | d) == (d | c | b | a)).all()
+ assert ((a & b & c & d) == (d & c & b & a)).all()
+ assert ((a ^ b) == (b ^ a)).all()
+ assert ((~(a | b)) == ((~a) & (~b))).all()
+
def _test_arithmetic_operations(self, backend):
- a = backend.rand((10,10)).astype(np.float64).clip(0.1, 0.9)
+ a = backend.rand((10, 10)).astype(np.float64).clip(0.1, 0.9)
a = (a-0.5)*10
-
- b = 10*backend.rand((10,10)).astype(np.float64).clip(0.1, 0.9)
- c = 10*backend.rand((10,10)).astype(np.float64).clip(0.1, 0.9)
- d = 10*backend.rand((10,10)).astype(np.float64).clip(0.1, 0.9)
-
-
- assert backend.allclose( 4.0+a, a+4.0 )
- assert backend.allclose( 4.0-a, -(a-4.0) )
- assert backend.allclose( 4.0*a, a*4.0 )
- assert backend.allclose( 4.0/a, 1.0/(a/4.0) )
-
- f,i = backend.modf(a)
- assert backend.allclose( backend.trunc(a), i )
- f,i = backend.modf(b)
- assert backend.allclose( backend.fmod(b,1), f )
-
- assert backend.allclose( b//1, i )
- assert backend.allclose( b%1, f )
-
- assert backend.allclose( a-b, -(b-a) )
- assert backend.allclose( a+b-c-d, -c-d+b+a )
- assert backend.allclose( a*b*c*d, d*c*a*b )
+
+ b = 10*backend.rand((10, 10)).astype(np.float64).clip(0.1, 0.9)
+ c = 10*backend.rand((10, 10)).astype(np.float64).clip(0.1, 0.9)
+ d = 10*backend.rand((10, 10)).astype(np.float64).clip(0.1, 0.9)
+
+ assert backend.allclose(4.0+a, a+4.0)
+ assert backend.allclose(4.0-a, -(a-4.0))
+ assert backend.allclose(4.0*a, a*4.0)
+ assert backend.allclose(4.0/a, 1.0/(a/4.0))
+
+ f, i = backend.modf(a)
+ assert backend.allclose(backend.trunc(a), i)
+ f, i = backend.modf(b)
+ assert backend.allclose(backend.fmod(b, 1), f)
+
+ assert backend.allclose(b//1, i)
+ assert backend.allclose(b % 1, f)
+
+ assert backend.allclose(a-b, -(b-a))
+ assert backend.allclose(a+b-c-d, -c-d+b+a)
+ assert backend.allclose(a*b*c*d, d*c*a*b)
#assert backend.allclose( (a/b)*(c/d), (a*c)/(b*d) )
- a = a%b
- a = a//b
-
+ a = a % b
+ a = a//b
+
a = c.copy()
assert backend.allclose(c, a)
- a+=1
- assert backend.allclose(c+1,a)
- a-=3
- assert backend.allclose(c+1-3,a)
- a*=2
- assert backend.allclose(2*(c+1-3),a)
- a/=3
- assert backend.allclose(2*(c+1-3)/3,a)
- a//=4
- assert backend.allclose((2*(c+1-3)/3)//4,a)
- a%=2
- assert backend.allclose(((2*(c+1-3)/3)//4)%2,a)
-
+ a += 1
+ assert backend.allclose(c+1, a)
+ a -= 3
+ assert backend.allclose(c+1-3, a)
+ a *= 2
+ assert backend.allclose(2*(c+1-3), a)
+ a /= 3
+ assert backend.allclose(2*(c+1-3)/3, a)
+ a //= 4
+ assert backend.allclose((2*(c+1-3)/3)//4, a)
+ a %= 2
+ assert backend.allclose(((2*(c+1-3)/3)//4) % 2, a)
+
def _test_backend_versus_numpy_operations(self, backend):
npb = backend
-
+
atol = [None]
# pollute array with +inf, -inf and NaNs values
def pollute(arr):
- mask = lambda p: (np.random.rand(*arr.shape)<p)
+ def mask(p): return (np.random.rand(*arr.shape) < p)
arr[mask(0.20)] = -np.inf
arr[mask(0.20)] = +np.inf
- arr[mask(0.20)] = np.nan
+ arr[mask(0.20)] = np.nan
- def allclose(np_array, backend_array, equal_nan=True, atol=atol,
- relaxed_precision=False, ignore_mask=None):
- atol = atol[0] # 1*epsilon
+ def allclose(np_array, backend_array, equal_nan=True, atol=atol,
+ relaxed_precision=False, ignore_mask=None):
+ atol = atol[0] # 1*epsilon
if relaxed_precision:
- atol=1e-2
+ atol = 1e-2
if (backend_array is None):
- msg='Backend returned nothing (got None).'
+ msg = 'Backend returned nothing (got None).'
raise ValueError(msg)
if not np.isscalar(np_array) and not isinstance(np_array, np.ndarray):
- msg='first arg is not a np.ndarray (got {})'
- msg=msg.format(np_array)
+ msg = 'first arg is not a np.ndarray (got {})'
+ msg = msg.format(np_array)
raise ValueError(msg)
if isinstance(backend_array, Array):
backend_array = backend_array.get().handle
if (ignore_mask is not None):
- np_array = np_array[~ignore_mask]
+ np_array = np_array[~ignore_mask]
backend_array = backend_array[~ignore_mask]
return np.allclose(np_array, backend_array, equal_nan=equal_nan, atol=atol)
-
+
unary_ops = [
- 'reciprocal', 'negative', 'absolute', 'fabs',
- 'sin', 'cos', 'arcsin', 'arccos', 'arctan', 'tan',
- 'degrees', 'radians', 'deg2rad', 'rad2deg',
- 'sinh', 'cosh', 'arcsinh', 'arccosh', 'arctanh',
- #'tanh', 'around', #FIXME
- 'rint', 'fix', 'floor', 'ceil', 'trunc',
- 'exp', 'expm1', 'exp2',
- 'log', 'log10', 'log2', 'log1p',
- 'signbit', 'reciprocal', 'negative',
- 'sqrt', 'cbrt', 'square', 'sign',
- 'nan_to_num',
- 'prod', 'sum', 'nanprod', 'nansum',
- 'cumprod', 'cumsum', 'nancumprod', 'nancumsum',
- 'isfinite', 'isinf', 'isnan', 'isneginf', 'isposinf',
- 'real', 'imag', 'angle', 'conj', 'real_if_close'
- ]
-
+ 'reciprocal', 'negative', 'absolute', 'fabs',
+ 'sin', 'cos', 'arcsin', 'arccos', 'arctan', 'tan',
+ 'degrees', 'radians', 'deg2rad', 'rad2deg',
+ 'sinh', 'cosh', 'arcsinh', 'arccosh', 'arctanh',
+ # 'tanh', 'around', #FIXME
+ 'rint', 'fix', 'floor', 'ceil', 'trunc',
+ 'exp', 'expm1', 'exp2',
+ 'log', 'log10', 'log2', 'log1p',
+ 'signbit', 'reciprocal', 'negative',
+ 'sqrt', 'cbrt', 'square', 'sign',
+ 'nan_to_num',
+ 'prod', 'sum', 'nanprod', 'nansum',
+ 'cumprod', 'cumsum', 'nancumprod', 'nancumsum',
+ 'isfinite', 'isinf', 'isnan', 'isneginf', 'isposinf',
+ 'real', 'imag', 'angle', 'conj', 'real_if_close'
+ ]
+
binary_ops = [
- 'minimum', 'maximum', 'fmin', 'fmax',
- 'add', 'subtract', 'multiply', 'power',
- 'divide', 'floor_divide', 'true_divide',
- 'equal', 'not_equal', 'less_equal', 'greater_equal', 'less', 'greater',
- 'mod', 'fmod', 'remainder', 'hypot',
- 'arctan2',
- 'logaddexp', 'logaddexp2',
- 'copysign'
- ]
-
+ 'minimum', 'maximum', 'fmin', 'fmax',
+ 'add', 'subtract', 'multiply', 'power',
+ 'divide', 'floor_divide', 'true_divide',
+ 'equal', 'not_equal', 'less_equal', 'greater_equal', 'less', 'greater',
+ 'mod', 'fmod', 'remainder', 'hypot',
+ 'arctan2',
+ 'logaddexp', 'logaddexp2',
+ 'copysign'
+ ]
+
array_unary_ops = ['__neg__', '__abs__']
array_binary_ops = [
- '__eq__', '__ne__', '__le__', '__ge__', '__lt__', '__gt__',
- '__add__', '__sub__', '__mul__', '__pow__',
- '__floordiv__', '__div__', '__mod__',
- '__radd__', '__rsub__', '__rmul__', '__rpow__',
- '__rfloordiv__', '__rdiv__', '__rmod__'
+ '__eq__', '__ne__', '__le__', '__ge__', '__lt__', '__gt__',
+ '__add__', '__sub__', '__mul__', '__pow__',
+ '__floordiv__', '__div__', '__mod__',
+ '__radd__', '__rsub__', '__rmul__', '__rpow__',
+ '__rfloordiv__', '__rdiv__', '__rmod__'
]
# real_skip_list = ['angle', 'real', 'imag', 'conj', 'real_if_close']
@@ -405,83 +414,82 @@ class TestArray(object):
'logaddexp', 'logaddexp2', 'copysign', 'frexp',
'__mod__', '__rmod__']
- splitting_ops = [ 'frexp', 'modf' ]
+ splitting_ops = ['frexp', 'modf']
- def ignore_infty(ref_out,backend_out,**kargs):
- mask = np.isinf(ref_out)
+ def ignore_infty(ref_out, backend_out, **kargs):
+ mask = np.isinf(ref_out)
mask |= np.isinf(backend_out)
return mask
def positive_int_rhs(variables):
- assert 'b' in variables # b is rhs
+ assert 'b' in variables # b is rhs
rhs = variables['b']
dtype = rhs[0].dtype
if is_integer(dtype):
- for i,v in enumerate(rhs):
+ for i, v in enumerate(rhs):
rhs[i] = abs(v)
- def clamp(_amin,_amax):
+ def clamp(_amin, _amax):
def _filter(variables):
- for k,_vars in variables.iteritems():
- for i,var in enumerate(_vars):
+ for k, _vars in variables.iteritems():
+ for i, var in enumerate(_vars):
if is_complex(var):
- if isinstance(var,np.ndarray):
- np.clip(var.real, _amin,_amax, variables[k][i].real)
- np.clip(var.imag, _amin,_amax, variables[k][i].imag)
+ if isinstance(var, np.ndarray):
+ np.clip(var.real, _amin, _amax, variables[k][i].real)
+ np.clip(var.imag, _amin, _amax, variables[k][i].imag)
else:
amin = _amin + 1j*_amin
amax = _amax + 1j*_amax
- var.backend.clip_components(var,amin,amax,variables[k][i])
+ var.backend.clip_components(var, amin, amax, variables[k][i])
else:
- if isinstance(var,np.ndarray):
- np.clip(var.real,_amin,_amax,variables[k][i])
+ if isinstance(var, np.ndarray):
+ np.clip(var.real, _amin, _amax, variables[k][i])
else:
- var.backend.clip(var,_amin,_amax,variables[k][i])
+ var.backend.clip(var, _amin, _amax, variables[k][i])
return _filter
-
-
+
pow_constraints = [positive_int_rhs]
- pow_constraints.append( clamp(+0,+3) )
+ pow_constraints.append(clamp(+0, +3))
- ## Extra contraints on inputs
+ # Extra contraints on inputs
# should be a list of functions taking variables as inputsq
input_constraints = {
'power': pow_constraints,
'__pow__': pow_constraints,
'__rpow__': pow_constraints,
- 'cumprod': clamp(0.1,1.1),
- 'nancumprod': clamp(0.1,1.1)
+ 'cumprod': clamp(0.1, 1.1),
+ 'nancumprod': clamp(0.1, 1.1)
}
-
- ## Extra contraints on outputs
- # Generate a mask of values thats should not
+
+ # Extra contraints on outputs
+ # Generate a mask of values thats should not
# be compared to numpy solution in allclose check)
# all keys are operator names
- # all values are function of dtype and backend,
+ # all values are function of dtype and backend,
output_constraints = {
'cumprod': [ignore_infty],
'nancumprod': [ignore_infty]
}
-
+
class TestContext(object):
def __init__(self, opname, input_constraints, variables):
- self.opname = opname
-
+ self.opname = opname
+
# if there is a specific constraint we copy everything
dtypes = {}
if opname in input_constraints:
- for vname,vargs in variables.iteritems():
- for i,var in enumerate(vargs):
+ for vname, vargs in variables.iteritems():
+ for i, var in enumerate(vargs):
variables[vname][i] = variables[vname][i].copy()
filters = to_list(input_constraints[opname])
for f in filters:
f(variables)
self.dtypes = dtypes
- for vname,vargs in variables.iteritems():
+ for vname, vargs in variables.iteritems():
dtypes[vname] = variables[vname][0].dtype
- for i,var in enumerate(vargs):
- varname='{}{}'.format(vname,i)
+ for i, var in enumerate(vargs):
+ varname = '{}{}'.format(vname, i)
setattr(self, varname, var)
setattr(self, vname, vargs)
@@ -490,15 +498,14 @@ class TestArray(object):
def __exit__(self, exception, e, traceback):
if (e is not None):
- msg='\nTESTING: Test failed in at {}::{}() with dtypes {}\n'
- msg=msg.format(backend.__class__.__name__,self.opname,self.dtypes)
+ msg = '\nTESTING: Test failed in at {}::{}() with dtypes {}\n'
+ msg = msg.format(backend.__class__.__name__, self.opname, self.dtypes)
print msg
raise exception, e, traceback
-
def check_inputs(name, _in):
- isclose = np.isclose(_in[0],_in[1].get(handle=True), equal_nan=True)
- if not isclose.all():
+ isclose = np.isclose(_in[0], _in[1].get(handle=True), equal_nan=True)
+ if not isclose.all():
print '{} inputs mismatch...'.format(name)
print '{} NUMPY INPUT:'.format(name.upper())
print _in[0][~isclose]
@@ -510,72 +517,72 @@ class TestArray(object):
if (r0 is None) and (r1 is None):
return
elif (r0 is None):
- msg='numpy::{} returned None.'.format(opname)
+ msg = 'numpy::{} returned None.'.format(opname)
raise TypeError(msg)
elif (r1 is None):
- msg='{}::{} returned None.'.format(backend.__class__.__name__,opname)
+ msg = '{}::{} returned None.'.format(backend.__class__.__name__, opname)
raise TypeError(msg)
else:
if isinstance(r1, Array):
r1 = r1.get(handle=True)
- if isinstance(backend,OpenClArrayBackend):
+ if isinstance(backend, OpenClArrayBackend):
# FIXME OpenCl support for float16
- if r0.dtype==np.float16:
+ if r0.dtype == np.float16:
r1 = r1.astype(np.float16)
- if r0.dtype==np.bool:
+ if r0.dtype == np.bool:
r1 = r1.astype(np.bool)
-
+
if (r0.dtype == np.bool) and (r1.dtype == np.bool):
- l2 = np.sqrt(np.nansum(r0^r1)) / r0.size
- linf = np.nanmax(r0^r1)
+ l2 = np.sqrt(np.nansum(r0 ^ r1)) / r0.size
+ linf = np.nanmax(r0 ^ r1)
else:
m0 = np.isfinite(r0)
m1 = np.isfinite(r1)
- if (m0!=m1).any():
- l2 = np.inf
+ if (m0 != m1).any():
+ l2 = np.inf
linf = np.inf
else:
try:
R0, R1 = r0[m0], r1[m0]
- l2 = np.sqrt(np.sum((R0-R1)*np.conj(R0-R1)) / R0.size)
+ l2 = np.sqrt(np.sum((R0-R1)*np.conj(R0-R1)) / R0.size)
linf = np.max(np.abs(R0-R1))
except ValueError:
- l2 = 0
+ l2 = 0
linf = 0
- msg1='(l2={}, linf={}).'
- msg1=msg1.format(l2, linf)
-
+ msg1 = '(l2={}, linf={}).'
+ msg1 = msg1.format(l2, linf)
+
if (r0.dtype == r1.dtype):
- mask=None
+ mask = None
if opname in output_constraints:
mask_generators = to_list(output_constraints[opname])
- mask = mask_generators[0](ref_out=r0,backend_out=r1)
+ mask = mask_generators[0](ref_out=r0, backend_out=r1)
for mask_gen in mask_generators[1:]:
- mask |= mask_gen(ref_out=r0,backend_out=r1)
+ mask |= mask_gen(ref_out=r0, backend_out=r1)
- close = allclose(r0,r1,ignore_mask=mask)
+ close = allclose(r0, r1, ignore_mask=mask)
tol = atol[0]
if not close:
- close = allclose(r0,r1,relaxed_precision=True,ignore_mask=mask)
+ close = allclose(r0, r1, relaxed_precision=True, ignore_mask=mask)
tol = 1e-2
if close:
- msg='WARNING: test passed with relaxed precision for {}::{}.'
- msg=msg.format(backend.__class__.__name__, opname)
+ msg = 'WARNING: test passed with relaxed precision for {}::{}.'
+ msg = msg.format(backend.__class__.__name__, opname)
print msg
if not close:
msg = '\n{}::{} returned dtypes did match (got {}) '
- msg+= 'but failed to match numpy output,'
- msg+='\n absolute tolerance was set to {}.'
- msg=msg.format(backend.__class__.__name__,opname,r1.dtype,tol)
+ msg += 'but failed to match numpy output,'
+ msg += '\n absolute tolerance was set to {}.'
+ msg = msg.format(backend.__class__.__name__, opname, r1.dtype, tol)
print msg
if isinstance(r0, np.ndarray) and isinstance(r1, np.ndarray):
- failed=(~np.isclose(r0,r1,equal_nan=True,atol=atol[0]))
+ failed = (~np.isclose(r0, r1, equal_nan=True, atol=atol[0]))
if (lhs is not None):
- check_inputs('lhs',lhs)
+ check_inputs('lhs', lhs)
print 'LHS_INPUT'
print lhs[0][failed]
if (rhs is not None):
- check_inputs('rhs',rhs)
+ check_inputs('rhs', rhs)
print 'RHS INPUT'
print rhs[0][failed]
print 'EXPECTED'
@@ -585,28 +592,28 @@ class TestArray(object):
else:
print 'r0 => {}'.format(r0.__class__)
print 'r1 => {}'.format(r1.__class__)
- msg0='Method {}::{} failed to match numpy output'
- msg0=msg0.format(backend.__class__.__name__, opname)
- msg=msg0+msg1
+ msg0 = 'Method {}::{} failed to match numpy output'
+ msg0 = msg0.format(backend.__class__.__name__, opname)
+ msg = msg0+msg1
print
print msg
raise ValueError(msg)
else:
- msg0='{}::{} matched numpy output '
- msg0=msg0.format(backend.__class__.__name__, opname)
- msg=msg0+msg1
+ msg0 = '{}::{} matched numpy output '
+ msg0 = msg0.format(backend.__class__.__name__, opname)
+ msg = msg0+msg1
print msg
else:
msg = '\n{}::{} returned dtypes didn\'t match (expected {} but got {}).'
msg = msg.format(backend.__class__.__name__, opname, r0.dtype, r1.dtype)
print msg
- msg='{}::{} returned dtypes did not match, '\
+ msg = '{}::{} returned dtypes did not match, '\
'got {} but numpy returned {}.'
- msg=msg.format(backend.__class__.__name__, opname, r1.dtype, r0.dtype)
+ msg = msg.format(backend.__class__.__name__, opname, r1.dtype, r0.dtype)
raise ValueError(msg)
- def test_operators(a,b,A,B,skip=[]):
+ def test_operators(a, b, A, B, skip=[]):
with warnings.catch_warnings():
warnings.simplefilter('ignore')
@@ -615,52 +622,52 @@ class TestArray(object):
continue
f0 = getattr(np, opname)
f1 = getattr(npb, opname)
- with TestContext(opname, input_constraints,
- variables={'a':[a,A]}) as ctx:
+ with TestContext(opname, input_constraints,
+ variables={'a': [a, A]}) as ctx:
r0 = f0(ctx.a0)
r1 = f1(ctx.a1)
- check_close(ctx.a,None,r0,r1,opname)
+ check_close(ctx.a, None, r0, r1, opname)
for opname in binary_ops:
if opname in skip:
continue
f0 = getattr(np, opname)
f1 = getattr(npb, opname)
- with TestContext(opname, input_constraints,
- variables={'a':[a,A],'b':[b,B]}) as ctx:
- r0 = f0(ctx.a0,ctx.b0)
- r1 = f1(ctx.a1,ctx.b1)
- check_close(ctx.a,ctx.b,r0,r1,opname)
-
+ with TestContext(opname, input_constraints,
+ variables={'a': [a, A], 'b': [b, B]}) as ctx:
+ r0 = f0(ctx.a0, ctx.b0)
+ r1 = f1(ctx.a1, ctx.b1)
+ check_close(ctx.a, ctx.b, r0, r1, opname)
+
for opname in splitting_ops:
if opname in skip:
continue
- with TestContext(opname, input_constraints,
- variables={'a':[a,A],'b':[b,B]}) as ctx:
+ with TestContext(opname, input_constraints,
+ variables={'a': [a, A], 'b': [b, B]}) as ctx:
f0 = getattr(np, opname)
f1 = getattr(npb, opname)
r00, r01 = f0(ctx.a0)
r10, r11 = f1(ctx.a1)
- check_close(ctx.a,None,r00,r10,opname)
- check_close(ctx.a,None,r01,r11,opname)
-
+ check_close(ctx.a, None, r00, r10, opname)
+ check_close(ctx.a, None, r01, r11, opname)
+
for opname in array_unary_ops:
if opname in skip:
continue
- with TestContext(opname, input_constraints,
- variables={'a':[a,A]}) as ctx:
+ with TestContext(opname, input_constraints,
+ variables={'a': [a, A]}) as ctx:
f0 = getattr(ctx.a0, opname)
f1 = getattr(ctx.a1, opname)
r0 = f0()
r1 = f1()
- check_close(ctx.a,None,r0,r1,opname)
+ check_close(ctx.a, None, r0, r1, opname)
for opname in array_binary_ops:
if opname in skip:
continue
- with TestContext(opname, input_constraints,
- variables={'a':[a,A],'b':[b,B]}) as ctx:
- if opname.find('__r')==0:
+ with TestContext(opname, input_constraints,
+ variables={'a': [a, A], 'b': [b, B]}) as ctx:
+ if opname.find('__r') == 0:
f0 = getattr(ctx.b0, opname)
f1 = getattr(ctx.b1, opname)
r0 = f0(ctx.a0)
@@ -670,9 +677,8 @@ class TestArray(object):
f1 = getattr(ctx.a1, opname)
r0 = f0(ctx.b0)
r1 = f1(ctx.b1)
- check_close(ctx.a,ctx.b,r0,r1,opname)
+ check_close(ctx.a, ctx.b, r0, r1, opname)
-
def make_arrays(dtype):
ftype = match_float_type(dtype)
atol[0] = np.finfo(ftype).eps
@@ -683,93 +689,92 @@ class TestArray(object):
if is_unsigned(dtype):
a = abs(a)
b = abs(b)
- a = a.astype(dtype) # <= negative number to unsigned dtype conversion wraps
+ a = a.astype(dtype) # <= negative number to unsigned dtype conversion wraps
b = b.astype(dtype)
if is_complex(dtype):
- a+= (np.random.rand(8192)-0.5)*100j
- b+= (np.random.rand(8192)-0.5)*100j
-
- A, B = npb.asarray(a), npb.asarray(b)
- assert allclose( a, A )
- assert allclose( b, B )
- assert npb.allclose( npb.asarray(a), A, equal_nan=True )
- assert npb.allclose( npb.asarray(b), B, equal_nan=True )
-
- return a,b,A,B
-
- #FIXME numpy quad float support (gcc __float128), not implemented yet as
+ a += (np.random.rand(8192)-0.5)*100j
+ b += (np.random.rand(8192)-0.5)*100j
+
+ A, B = npb.asarray(a), npb.asarray(b)
+ assert allclose(a, A)
+ assert allclose(b, B)
+ assert npb.allclose(npb.asarray(a), A, equal_nan=True)
+ assert npb.allclose(npb.asarray(b), B, equal_nan=True)
+
+ return a, b, A, B
+
+ # FIXME numpy quad float support (gcc __float128), not implemented yet as
if __ENABLE_LONG_TESTS__:
- signed_types = (np.int8, np.int16, np.int32, np.int64,)
+ signed_types = (np.int8, np.int16, np.int32, np.int64,)
unsigned_types = (np.uint8, np.uint16, np.uint32, np.uint64,)
- float_types = (np.float16,np.float32,np.float64, np.longdouble)
- complex_types = (np.complex64, np.complex128, np.clongdouble)
+ float_types = (np.float16, np.float32, np.float64, np.longdouble)
+ complex_types = (np.complex64, np.complex128, np.clongdouble)
else:
- signed_types = ()
+ signed_types = ()
unsigned_types = ()
- float_types = (np.float32,)
- complex_types = (np.complex64,)
-
+ float_types = (np.float32,)
+ complex_types = (np.complex64,)
+
for dtype in signed_types:
print '\n== SIGNED INTEGER OPS {} =='.format(dtype)
- a,b,A,B = make_arrays(dtype)
- test_operators(a,b,A,B)
-
+ a, b, A, B = make_arrays(dtype)
+ test_operators(a, b, A, B)
+
for dtype in unsigned_types:
print '\n== UNSIGNED INTEGER OPS {} =='.format(dtype)
- a,b,A,B = make_arrays(dtype)
- test_operators(a,b,A,B)
-
+ a, b, A, B = make_arrays(dtype)
+ test_operators(a, b, A, B)
+
# FIXME OpenCl backend half float and long double support
for dtype in float_types:
print '\n== FLOAT OPS {} =='.format(dtype)
- if isinstance(backend,OpenClArrayBackend) and (dtype in [np.float16,np.longdouble]):
+ if isinstance(backend, OpenClArrayBackend) and (dtype in [np.float16, np.longdouble]):
print ' -- NO SUPPORT PROVIDED BY BACKEND --'
- continue
-
- a,b,A,B = make_arrays(dtype)
- test_operators(a,b,A,B)
-
+ continue
+
+ a, b, A, B = make_arrays(dtype)
+ test_operators(a, b, A, B)
+
print '\n== POLLUTED FLOAT OPS {} =='.format(dtype)
pollute(a)
pollute(b)
- A, B = npb.asarray(a), npb.asarray(b)
- test_operators(a,b,A,B)
-
- #FIXME OpenCL complex functions: arcsin, arccos, floordix, pow, ...
+ A, B = npb.asarray(a), npb.asarray(b)
+ test_operators(a, b, A, B)
+
+ # FIXME OpenCL complex functions: arcsin, arccos, floordix, pow, ...
for dtype in complex_types:
print '\n== COMPLEX OPS {} =='.format(dtype)
- if isinstance(backend,OpenClArrayBackend):
+ if isinstance(backend, OpenClArrayBackend):
if dtype in [np.clongdouble]:
print ' -- NO SUPPORT PROVIDED BY BACKEND --'
- continue
+ continue
skip_list = [x for x in complex_skip_list]
skip_list += ['arcsin', 'arccos', 'arctan',
'arcsinh', 'arccosh', 'arctanh',
- 'exp2', 'expm1',
+ 'exp2', 'expm1',
'log2', 'log10', 'log1p',
'floor_divide', '__floordiv__', '__rfloordiv__']
else:
skip_list = complex_skip_list
-
- a,b,A,B = make_arrays(dtype)
- test_operators(a,b,A,B, skip=skip_list)
-
+
+ a, b, A, B = make_arrays(dtype)
+ test_operators(a, b, A, B, skip=skip_list)
+
print '\n== POLLUTED COMPLEX OPS {} =='.format(dtype)
pollute(a)
pollute(b)
-
- if isinstance(backend,OpenClArrayBackend):
- skip_list+=['power', '__rpow__', '__pow__']
-
- A, B = npb.asarray(a), npb.asarray(b)
- test_operators(a,b,A,B, skip=skip_list)
+
+ if isinstance(backend, OpenClArrayBackend):
+ skip_list += ['power', '__rpow__', '__pow__']
+
+ A, B = npb.asarray(a), npb.asarray(b)
+ test_operators(a, b, A, B, skip=skip_list)
def _test_backend_versus_numpy(self, backend):
self._test_backend_versus_numpy_operations(backend)
-
def _test_backend(self, backend):
with printoptions(linewidth=240, edgeitems=4, threshold=20):
# self._test_array_creation_routines(backend)
@@ -777,26 +782,26 @@ class TestArray(object):
# self._test_binary_operations(backend)
# self._test_arithmetic_operations(backend)
self._test_backend_versus_numpy(backend)
- #self._test_array_manipulation_routines(backend)
-
+ # self._test_array_manipulation_routines(backend)
+
def test_host_array_backend_allocator(self):
allocator = HostAllocator()
backend = HostArrayBackend(allocator=allocator)
self._test_backend(backend)
- def test_host_array_backend_mempool(self):
- allocator = HostAllocator()
- pool = allocator.memory_pool(name='host')
- backend = HostArrayBackend(allocator=pool)
+ # def test_host_array_backend_mempool(self):
+ # allocator = HostAllocator()
+ # pool = allocator.memory_pool(name='host')
+ # backend = HostArrayBackend(allocator=pool)
+
+ # self._test_backend(backend)
+
+ # backend.allocator.print_allocation_report()
+ # assert backend.allocator.active_blocks == 0
+ # backend.allocator.stop_holding()
+ # assert backend.allocator.held_blocks == 0
+ # backend.allocator.print_allocation_report()
- self._test_backend(backend)
-
- backend.allocator.print_allocation_report()
- assert backend.allocator.active_blocks == 0
- backend.allocator.stop_holding()
- assert backend.allocator.held_blocks == 0
- backend.allocator.print_allocation_report()
-
@opencl_failed
def test_opencl_array_backend_allocator(self):
from hysop.backend.device.opencl.opencl_allocator import OpenClImmediateAllocator
@@ -806,27 +811,28 @@ class TestArray(object):
allocator = OpenClImmediateAllocator(queue=cl_env.default_queue)
backend = OpenClArrayBackend(cl_env=cl_env, allocator=allocator)
self._test_backend(backend)
-
- @opencl_failed
- def test_opencl_array_backend_pool(self):
- from hysop.backend.device.opencl.opencl_allocator import OpenClImmediateAllocator
- for cl_env in iter_clenv():
- allocator = OpenClImmediateAllocator(queue=cl_env.default_queue)\
- .memory_pool(name=cl_env.device.name)
- backend = OpenClArrayBackend(cl_env=cl_env, allocator=allocator)
-
- self._test_backend(backend)
-
- backend.allocator.print_allocation_report()
- assert backend.allocator.active_blocks == 0
- backend.allocator.stop_holding()
- assert backend.allocator.held_blocks == 0
- backend.allocator.print_allocation_report()
+
+ # @opencl_failed
+ # def test_opencl_array_backend_pool(self):
+ # from hysop.backend.device.opencl.opencl_allocator import OpenClImmediateAllocator
+ # for cl_env in iter_clenv():
+ # allocator = OpenClImmediateAllocator(queue=cl_env.default_queue)\
+ # .memory_pool(name=cl_env.device.name)
+ # backend = OpenClArrayBackend(cl_env=cl_env, allocator=allocator)
+
+ # self._test_backend(backend)
+
+ # backend.allocator.print_allocation_report()
+ # assert backend.allocator.active_blocks == 0
+ # backend.allocator.stop_holding()
+ # assert backend.allocator.held_blocks == 0
+ # backend.allocator.print_allocation_report()
+
if __name__ == '__main__':
test = TestArray()
test.test_host_array_backend_allocator()
- #test.test_host_array_backend_mempool()
+ # test.test_host_array_backend_mempool()
if __HAS_OPENCL_BACKEND__:
test.test_opencl_array_backend_allocator()
- #test.test_opencl_array_backend_pool()
+ # test.test_opencl_array_backend_pool()
diff --git a/hysop/core/checkpoints.py b/hysop/core/checkpoints.py
new file mode 100644
index 0000000000000000000000000000000000000000..592ee6dec62e77e589890bdaba48a86c639f7bef
--- /dev/null
+++ b/hysop/core/checkpoints.py
@@ -0,0 +1,846 @@
+import functools, shutil, operator, os, warnings, shutil, tarfile, uuid
+import numpy as np
+from hysop.tools.types import check_instance, first_not_None, to_tuple, to_list
+from hysop.tools.units import bytes2str, time2str
+from hysop.tools.io_utils import IOParams
+from hysop.tools.numerics import default_invalid_value
+from hysop.tools.string_utils import vprint_banner, vprint
+from hysop.core.mpi import Wtime
+from hysop.domain.box import Box
+from hysop.parameters import ScalarParameter, TensorParameter, BufferParameter
+from hysop.fields.cartesian_discrete_field import CartesianDiscreteScalarField
+
+class CheckpointHandler(object):
+ def __init__(self, load_checkpoint_path, save_checkpoint_path,
+ compression_method, compression_level,
+ io_params, relax_constraints):
+ check_instance(load_checkpoint_path, str, allow_none=True)
+ check_instance(save_checkpoint_path, str, allow_none=True)
+ check_instance(compression_method, str, allow_none=True)
+ check_instance(compression_level, int, allow_none=True)
+ check_instance(io_params, IOParams, allow_none=True)
+ check_instance(relax_constraints, bool)
+
+ if (compression_method is not None):
+ from numcodecs import blosc
+ available_compressors = blosc.list_compressors()
+ if compression_method not in available_compressors:
+ msg='User specified compression method \'{}\' which is not supported by blosc. Available compressors are {}.'
+ raise RuntimeError(msg.format(compression_method, ', '.join(available_compressors)))
+ if (compression_level is not None):
+ if (compression_level < 0) or (compression_level > 9):
+ msg='User specified compression level {} that is not in valid range [0,9].'
+ raise RuntimeError(msg.format(compression_level))
+
+ self._load_checkpoint_path = load_checkpoint_path
+ self._save_checkpoint_path = save_checkpoint_path
+ self._compression_method = compression_method
+ self._compression_level = compression_level
+ self._io_params = io_params
+ self._relax_constraints = relax_constraints
+
+ self._checkpoint_template = None
+ self._checkpoint_compressor = None
+
+ @property
+ def load_checkpoint_path(self):
+ return self._load_checkpoint_path
+ @property
+ def save_checkpoint_path(self):
+ return self._save_checkpoint_path
+ @property
+ def compression_method(self):
+ return self._compression_method
+ @property
+ def compression_level(self):
+ return self._compression_level
+ @property
+ def io_params(self):
+ return self._io_params
+ @property
+ def relax_constraints(self):
+ return self._relax_constraints
+
+ def get_mpio_parameters(self, mpi_params):
+ io_params = self.io_params
+ comm = mpi_params.comm
+ io_leader = io_params.io_leader
+ is_io_leader = (io_leader == mpi_params.rank)
+ return (io_params, mpi_params, comm, io_leader, is_io_leader)
+
+ def is_io_leader(self, mpi_params):
+ return (self.io_params.io_leader == mpi_params.rank)
+
+ def finalize(self, mpi_params):
+ if ((self._checkpoint_template is not None)
+ and os.path.exists(self._checkpoint_template)
+ and self.is_io_leader(mpi_params)):
+ try:
+ shutil.rmtree(self._checkpoint_template)
+ except OSError:
+ pass
+ self._checkpoint_template = None
+ self._checkpoint_compressor = None
+
+ def load_checkpoint(self, problem, simulation):
+ from hysop.problem import Problem
+ from hysop.simulation import Simulation
+ check_instance(problem, Problem)
+ check_instance(simulation, Simulation)
+
+ load_checkpoint_path = self.load_checkpoint_path
+ if (load_checkpoint_path is None):
+ return
+
+ vprint('\n>Loading {}problem checkpoint from \'{}\'...'.format(
+ 'relaxed' if self.relax_constraints else '', load_checkpoint_path))
+ if not os.path.exists(load_checkpoint_path):
+ msg='Failed to load checkpoint \'{}\' because the file does not exist.'
+ raise RuntimeError(msg.format(load_checkpoint))
+ if (self.io_params is None):
+ msg='Load checkpoint has been set to \'{}\' but checkpoint_io_params has not been specified.'
+ raise RuntimeError(msg.format(load_checkpoint_path))
+
+ (io_params, mpi_params, comm, io_leader, is_io_leader) = self.get_mpio_parameters(problem.mpi_params)
+ start = Wtime()
+
+ # extract checkpoint to directory if required
+ if os.path.isfile(load_checkpoint_path):
+ if load_checkpoint_path.endswith('.tar'):
+ if is_io_leader:
+ load_checkpoint_dir = os.path.join(os.path.dirname(load_checkpoint_path),
+ os.path.basename(load_checkpoint_path).replace('.tar', ''))
+ while os.path.exists(load_checkpoint_dir):
+ # ok, use another directory name to avoid dataloss...
+ load_checkpoint_dir = os.path.join(os.path.dirname(load_checkpoint_path),
+ '{}'.format(uuid.uuid4().hex))
+ tf = tarfile.open(load_checkpoint_path, mode='r')
+ tf.extractall(path=load_checkpoint_dir)
+ else:
+ load_checkpoint_dir = None
+ load_checkpoint_dir = comm.bcast(load_checkpoint_dir, root=io_leader)
+ should_remove_dir = True
+ else:
+ msg='Can only load checkpoint with tar extension, got {}.'
+ raise NotImplementedError(msg.format(load_checkpoint_path))
+ elif os.path.isdir(load_checkpoint_path):
+ load_checkpoint_dir = load_checkpoint_path
+ should_remove_dir = False
+ else:
+ raise RuntimeError
+
+ # import checkpoint data
+ self._import_checkpoint(problem, simulation, load_checkpoint_dir)
+
+ if (is_io_leader and should_remove_dir):
+ shutil.rmtree(load_checkpoint_dir)
+
+ ellapsed = Wtime() - start
+ msg=' > Successfully imported checkpoint in {}.'
+ vprint(msg.format(time2str(ellapsed)))
+
+ def should_dump(self, simulation):
+ io_params = self.io_params
+ if (self.save_checkpoint_path is None):
+ return False
+ if (io_params is None):
+ return False
+ return io_params.should_dump(simulation)
+
+
+ # Checkpoint is first exported as a directory containing a hierarchy of arrays (field and parameters data + metadata)
+ # This folder is than tarred (without any form of compression) so that a checkpoint consists in a single movable file.
+ # Data is already compressed during data export by the zarr module, using the blosc compressor (snappy, clevel=9).
+ def save_checkpoint(self, problem, simulation):
+ save_checkpoint_path = self.save_checkpoint_path
+ if (self.save_checkpoint_path is None):
+ return
+
+ if (self.io_params is None):
+ msg='Load checkpoint has been set to \'{}\' but checkpoint io_params has not been specified.'
+ raise RuntimeError(msg.format(load_checkpoint_path))
+
+ vprint('>Exporting problem checkpoint to \'{}\':'.format(save_checkpoint_path))
+ if not save_checkpoint_path.endswith('.tar'):
+ msg='Can only export checkpoint with tar extension, got {}.'
+ raise NotImplementedError(msg.format(save_checkpoint_path))
+ save_checkpoint_tar = save_checkpoint_path
+
+ (io_params, mpi_params, comm, io_leader, is_io_leader) = self.get_mpio_parameters(problem.mpi_params)
+ start = Wtime()
+
+ # create a backup of last checkpoint just in case things go wrong
+ if is_io_leader and os.path.exists(save_checkpoint_tar):
+ backup_checkpoint_tar = save_checkpoint_tar + '.bak'
+ if os.path.exists(backup_checkpoint_tar):
+ os.remove(backup_checkpoint_tar)
+ os.rename(save_checkpoint_tar, backup_checkpoint_tar)
+ else:
+ backup_checkpoint_tar = None
+
+ # determine checkpoint dump directory
+ if is_io_leader:
+ save_checkpoint_dir = os.path.join(os.path.dirname(save_checkpoint_tar),
+ os.path.basename(save_checkpoint_tar).replace('.tar', ''))
+ while os.path.exists(save_checkpoint_dir):
+ # ok, use another directory name to avoid dataloss...
+ save_checkpoint_dir = os.path.join(os.path.dirname(save_checkpoint_tar),
+ '{}'.format(uuid.uuid4().hex))
+ else:
+ save_checkpoint_dir = None
+ save_checkpoint_dir = mpi_params.comm.bcast(save_checkpoint_dir, root=io_leader)
+
+ # try to create the checkpoint directory, this is a collective MPI operation
+ try:
+ success, reason, nbytes = self._export_checkpoint(problem, simulation, save_checkpoint_dir)
+ except Exception as e:
+ raise
+ success = False
+ reason = str(e)
+ success = comm.allreduce(int(success)) == comm.size
+
+ # Compress checkpoint directory to tar (easier to copy/move between clusters)
+ # Note that there is no effective compression here, zarr already compressed field/param data
+ if success and is_io_leader and os.path.isdir(save_checkpoint_dir):
+ try:
+ with tarfile.open(save_checkpoint_tar, 'w') as tf:
+ for (root, dirs, files) in os.walk(save_checkpoint_dir):
+ for f in files:
+ fpath = os.path.join(root, f)
+ tf.add(fpath, arcname=fpath.replace(save_checkpoint_dir+os.path.sep,''))
+
+ if os.path.isfile(save_checkpoint_tar):
+ shutil.rmtree(save_checkpoint_dir)
+ else:
+ raise RuntimeError('Could not tar checkpoint datadir.')
+
+ ellapsed = Wtime() - start
+ effective_nbytes = os.path.getsize(save_checkpoint_tar)
+ compression_ratio = max(1.0, float(nbytes)/effective_nbytes)
+
+ msg=' > Successfully exported checkpoint in {} with a compression ratio of {:.1f} ({}).'
+ vprint(msg.format(time2str(ellapsed), compression_ratio, bytes2str(effective_nbytes)))
+ except Exception as e:
+ success = False
+ reason = str(e)
+ success = comm.allreduce(int(success)) == comm.size
+
+ if success:
+ if (backup_checkpoint_tar is not None) and os.path.isfile(backup_checkpoint_tar) and is_io_leader:
+ os.remove(backup_checkpoint_tar)
+ return
+
+ from hysop.tools.warning import HysopDumpWarning
+ msg='Failed to export checkpoint because: {}.'.format(reason)
+ warnings.warn(msg, HysopDumpWarning)
+
+ # Something went wrong (I/O error or other) so we rollback to previous checkpoint (if there is one)
+ vprint(' | An error occured during checkpoint creation, rolling back to previous checkpoint...')
+ if is_io_leader:
+ if os.path.exists(save_checkpoint_dir):
+ shutil.rmtree(save_checkpoint_dir)
+ if os.path.exists(save_checkpoint_tar):
+ os.remove(save_checkpoint_tar)
+ if (backup_checkpoint_tar is not None) and os.path.exists(backup_checkpoint_tar):
+ os.rename(backup_checkpoint_tar, save_checkpoint_tar)
+
+
+ def create_checkpoint_template(self, problem, simulation):
+ # Create groups of arrays on disk (only hierarchy and array metadata is stored in the template)
+ # /!\ ZipStores are not safe from multiple processes so we use a DirectoryStore
+ # that can then be tarred manually by io_leader.
+
+ save_checkpoint_path = self.save_checkpoint_path
+ if (save_checkpoint_path is None):
+ return
+
+ if not save_checkpoint_path.endswith('.tar'):
+ msg='Can only export checkpoint with tar extension, got {}.'
+ raise NotImplementedError(msg.format(save_checkpoint_path))
+
+ (io_params, mpi_params, comm, io_leader, is_io_leader) = self.get_mpio_parameters(problem.mpi_params)
+
+ # determine an empty directory for the template
+ if is_io_leader:
+ checkpoint_template = os.path.join(os.path.dirname(save_checkpoint_path),
+ os.path.basename(save_checkpoint_path).replace('.tar', '.template'))
+ while os.path.exists(checkpoint_template):
+ # ok, use another directory name to avoid dataloss...
+ checkpoint_template = os.path.join(os.path.dirname(save_checkpoint_path),
+ '{}'.format(uuid.uuid4().hex))
+ else:
+ checkpoint_template = None
+ checkpoint_template = comm.bcast(checkpoint_template, root=io_leader)
+ self._checkpoint_template = checkpoint_template
+
+ vprint('\n>Creating checkpoint template as \'{}\'...'.format(checkpoint_template))
+ import zarr
+ from numcodecs import blosc, Blosc
+ blosc.use_threads = (mpi_params.size == 1) # disable threads for multiple processes (can deadlock)
+
+ # array data compressor
+ self._compression_method = first_not_None(self._compression_method, 'zstd')
+ self._compression_level = first_not_None(self._compression_level, 6)
+ compressor = Blosc(cname=self._compression_method, clevel=self._compression_level, shuffle=Blosc.SHUFFLE)
+ self._checkpoint_compressor = compressor
+
+ # io_leader creates a directory layout on (hopefully) shared filesystem
+ if is_io_leader:
+ if os.path.exists(checkpoint_template):
+ shutil.rmtree(checkpoint_template)
+ store = zarr.DirectoryStore(path=checkpoint_template)
+ root = zarr.open_group(store=store, mode='w', path='data')
+ params_group = root.create_group('params')
+ fields_group = root.create_group('fields')
+ simu_group = root.create_group('simulation')
+ operators_group = root.create_group('operators')
+ else:
+ store = None
+ root = None
+ params_group = None
+ fields_group = None
+ simu_group = None
+
+ # count number of total data bytes without compression
+ nbytes = 0
+ fmt_key = self._format_zarr_key
+
+ # operators
+ for op in problem.nodes:
+ if not op.checkpoint_required():
+ continue
+ key = fmt_key(op.checkpoint_datagroup_key())
+ if (key in operators_group):
+ msg=('Operator checkpoint key \'{}\' has already been taken by another operator, '
+ 'consider overriding {}.checkpoint_datagroup_key() or disable checkpointing '
+ 'for one of the two operators by tweeking the checkpoint_required() method.')
+ raise RuntimeError(msg.format(key, op.__class__.__name__))
+ operators_group.create_group(key)
+
+ # Generate parameter arrays
+ # Here we expect that each process store parameters that are in sync
+ # For each parameter we assume that the same values are broadcast to all processes
+ # even if is not enforced by the library (should cover most current use cases...)
+ for param in sorted(problem.parameters, key=operator.attrgetter('name')):
+ if not is_io_leader:
+ continue
+ if isinstance(param, (ScalarParameter, TensorParameter, BufferParameter)):
+ # all those parameters store their data in a numpy ndarray so we're good
+ assert isinstance(param._value, np.ndarray), type(param._value)
+ value = param._value
+ array = params_group.create_dataset(name=fmt_key(param.name),
+ overwrite=False, data=None, synchronizer=None,
+ compressor=compressor, shape=value.shape, chunks=None,
+ dtype=value.dtype, fill_value=default_invalid_value(value.dtype))
+ array.attrs['kind'] = param.__class__.__name__
+ nbytes += value.nbytes
+ else:
+ msg = 'Cannot export parameter of type {}.'.format(param.__class__.__name__)
+ raise NotImplementedError(msg)
+
+ # Generate discrete field arrays
+ # Here we assume that each process has a non-empty chunk of data
+ for field in sorted(problem.fields, key=operator.attrgetter('name')):
+
+ # we do not care about fields discretized only on temporary fields
+ if all(df.is_tmp for df in field.discrete_fields.values()):
+ continue
+
+ if is_io_leader:
+ field_group = fields_group.create_group(fmt_key(field.name))
+ else:
+ field_group = None
+
+ dim = field.dim
+ domain = field.domain._domain
+
+ if isinstance(domain, Box):
+ if (field_group is not None):
+ field_group.attrs['domain'] = 'Box'
+ field_group.attrs['dim'] = domain.dim
+ field_group.attrs['origin'] = to_tuple(domain.origin)
+ field_group.attrs['end'] = to_tuple(domain.end)
+ field_group.attrs['length'] = to_tuple(domain.length)
+ else:
+ # for now we just handle Boxed domains
+ raise NotImplementedError
+
+ for (k, topo) in enumerate(sorted(field.discrete_fields, key=operator.attrgetter('full_tag'))):
+ dfield = field.discrete_fields[topo]
+ mesh = topo.mesh._mesh
+
+ # we do not care about temporary fields
+ if dfield.is_tmp:
+ continue
+
+ if not isinstance(dfield, CartesianDiscreteScalarField):
+ # for now we just handle CartesianDiscreteScalarFields.
+ raise NotImplementedError
+
+ global_resolution = topo.global_resolution # logical grid size
+ grid_resolution = topo.grid_resolution # effective grid size
+ ghosts = topo.ghosts
+
+ # get local resolutions exluding ghosts
+ compute_resolutions = comm.gather(to_tuple(mesh.compute_resolution), root=io_leader)
+
+ # is the current process handling a right boundary data block on a distributed axe ?
+ is_at_right_boundary = (mesh.is_at_right_boundary*(mesh.proc_shape>1)).any()
+ is_at_right_boundary = np.asarray(comm.gather(is_at_right_boundary, root=io_leader))
+
+ if not is_io_leader:
+ continue
+
+ # io_leader can now determine wether the cartesian discretization is uniformly distributed
+ # between processes or not
+ inner_compute_resolutions = tuple(compute_resolutions[i] for i in range(len(compute_resolutions))
+ if not is_at_right_boundary[i])
+ grid_is_uniformly_distributed = all(res == inner_compute_resolutions[0]
+ for res in inner_compute_resolutions)
+
+ if grid_is_uniformly_distributed:
+ # We divide the array in 'compute_resolution' chunks, no sychronization is required.
+ # Here there is no need to use the process locker to write this array data.
+ # Each process writes its own independent block of data of size 'compute_resolution'.
+ should_sync = False
+ chunks = inner_compute_resolutions[0]
+ else:
+ # We divide the array in >=1MB chunks (chunks are given in terms of elements)
+ # Array chunks may overlap different processes so we need interprocess sychronization (slow)
+ assert (comm.size > 1)
+ should_sync = True
+ if dim == 1:
+ chunks = 1024*1024 # at least 1MB / chunk
+ elif dim == 2:
+ chunks = (1024,1024) # at least 1MB / chunk
+ elif dim == 3:
+ chunks = (64,128,128) # at least 1MB / chunk
+ else:
+ raise NotImplementedError(dim)
+
+ if should_sync:
+ raise NotImplementedError
+
+ # Create array (no memory is allocated here, even on disk because data blocks are empty)
+ dtype = dfield.dtype
+ shape = grid_resolution
+
+ # We scale the keys up to 100 topologies, which seams to be a pretty decent upper limit
+ # on a per field basis.
+ array = field_group.create_dataset(name='topo_{:02d}'.format(k),
+ overwrite=False, data=None, synchronizer=None,
+ compressor=compressor, shape=shape, chunks=chunks,
+ dtype=dtype, fill_value=default_invalid_value(dtype))
+ array.attrs['should_sync'] = should_sync
+
+ # We cannot rely on discrete mesh name because of topology names
+ # so we save some field metadata to be able to differentiate between
+ # discrete fields with the exact same grid resolution.
+ # proc_shape and name are used in last resort to differentiate discrete fields.
+ array.attrs['lboundaries'] = to_tuple(map(str, mesh.global_lboundaries))
+ array.attrs['rboundaries'] = to_tuple(map(str, mesh.global_rboundaries))
+ array.attrs['ghosts'] = to_tuple(mesh.ghosts)
+ array.attrs['proc_shape'] = to_tuple(mesh.proc_shape)
+ array.attrs['name'] = dfield.name
+
+ nbytes += np.prod(shape, dtype=np.int64) * dtype.itemsize
+
+ if (root is not None):
+ root.attrs['nbytes'] = nbytes
+ msg='>Maximum checkpoint size will be {}, without compression and metadata.'
+ vprint(root.tree())
+ vprint(msg.format(bytes2str(nbytes)))
+
+ # some zarr store formats require a final close to flush data
+ try:
+ if (root is not None):
+ root.close()
+ except AttributeError:
+ pass
+
+
+ def _export_checkpoint(self, problem, simulation, save_checkpoint_dir):
+ # Given a template, fill field and parameters data from all processes.
+ # returns (bool, msg) where bool is True on success
+ (io_params, mpi_params, comm, io_leader, is_io_leader) = self.get_mpio_parameters(problem.mpi_params)
+
+ # checkpoint template may have been deleted by user during simulation
+ if (self._checkpoint_template is None) or (not os.path.isdir(self._checkpoint_template)):
+ self.create_checkpoint_template(problem)
+ checkpoint_template = self._checkpoint_template
+ checkpoint_compressor = self._checkpoint_compressor
+
+ if is_io_leader:
+ if os.path.exists(save_checkpoint_dir):
+ shutil.rmtree(save_checkpoint_dir)
+ shutil.copytree(checkpoint_template, save_checkpoint_dir)
+ comm.Barrier()
+
+ if not os.path.isdir(save_checkpoint_dir):
+ msg='Could not find checkpoint directory \'{}\'. Are you using a network file system ?'.format(save_checkpoint_dir)
+ raise RuntimeError(msg)
+
+ #Every process now loads the same dataset template
+ import zarr
+ try:
+ store = zarr.DirectoryStore(save_checkpoint_dir)
+ root = zarr.open_group(store=store, mode='r+', synchronizer=None, path='data')
+ fields_group = root['fields']
+ params_group = root['params']
+ simu_group = root['simulation']
+ operators_group = root['operators']
+ nbytes = root.attrs['nbytes']
+ except:
+ msg='A fatal error occured during checkpoint export, checkpoint template may be illformed.'
+ vprint(msg)
+ vprint()
+ raise
+
+ fmt_key = self._format_zarr_key
+
+ # Export simulation data
+ if is_io_leader:
+ simulation.save_checkpoint(simu_group, mpi_params, io_params, checkpoint_compressor)
+
+ # Export operator data
+ for op in problem.nodes:
+ if not op.checkpoint_required():
+ continue
+ key = fmt_key(op.checkpoint_datagroup_key())
+ operator_group = operators_group[key]
+ op.save_checkpoint(operator_group, mpi_params, io_params, checkpoint_compressor)
+
+ # Currently there is no distributed parameter capabilities so io_leader has to dump all parameters
+ if is_io_leader:
+ msg = ' | dumping parameters...'
+ vprint(msg)
+ for param in sorted(problem.parameters, key=operator.attrgetter('name')):
+ if isinstance(param, (ScalarParameter, TensorParameter, BufferParameter)):
+ array = params_group[fmt_key(param.name)]
+ assert array.attrs['kind'] == param.__class__.__name__
+ assert array.dtype == param._value.dtype
+ assert array.shape == param._value.shape
+ array[...] = param._value
+ else:
+ msg = 'Cannot dump parameter of type {}.'.format(param.__class__.__name__)
+ raise NotImplementedError(msg)
+
+ # Unlike parameter all processes participate for fields
+ for field in sorted(problem.fields, key=operator.attrgetter('name')):
+
+ # we do not care about fields discretized only on temporary fields
+ if all(df.is_tmp for df in field.discrete_fields.values()):
+ continue
+
+ msg = ' | dumping field {}...'.format(field.pretty_name)
+ vprint(msg)
+
+ field_group = fields_group[fmt_key(field.name)]
+ for (k, topo) in enumerate(sorted(field.discrete_fields, key=operator.attrgetter('full_tag'))):
+ dfield = field.discrete_fields[topo]
+ mesh = topo.mesh._mesh
+
+ # we do not care about temporary fields
+ if dfield.is_tmp:
+ continue
+
+ dataset = 'topo_{:02d}'.format(k) # key has to match template
+ array = field_group[dataset]
+ should_sync = array.attrs['should_sync']
+
+ assert dfield.nb_components == 1
+ assert (array.shape == mesh.grid_resolution).all(), (array.shape, mesh.grid_resolution)
+ assert array.dtype == dfield.dtype, (array.dtype, dfield.dtype)
+
+ if should_sync:
+ # Should not be required untill we allow non-uniform discretizations
+ global_start = mesh.global_start
+ global_stop = mesh.global_stop
+ raise NotImplementedError('Synchronized multiprocess write has not been implemented yet.')
+ else:
+ assert ((mesh.compute_resolution == array.chunks).all()
+ or (mesh.is_at_right_boundary*(mesh.proc_shape>1)).any())
+ local_data = dfield.compute_data[0].get()
+ global_slices = mesh.global_compute_slices
+ array[global_slices] = local_data # ok, every process writes to an independent data blocks
+
+ # Some zarr store formats require a final close to flush data
+ try:
+ root.close()
+ except AttributeError:
+ pass
+
+ return True, None, nbytes
+
+
+ # On data import, there is no need to synchronize read-only arrays
+ # so we are good with multiple processes reading overlapping data blocks
+ def _import_checkpoint(self, problem, simulation, load_checkpoint_dir):
+
+ (io_params, mpi_params, comm, io_leader, is_io_leader) = self.get_mpio_parameters(problem.mpi_params)
+ mpi_params.comm.Barrier()
+
+ if not os.path.isdir(load_checkpoint_dir):
+ msg='Could not find checkpoint directory \'{}\'. Are you using a network file system ?'.format(load_checkpoint_dir)
+ raise RuntimeError(msg)
+
+ import zarr
+ store = zarr.DirectoryStore(load_checkpoint_dir)
+ try:
+ root = zarr.open_group(store=store, mode='r', synchronizer=None, path='data')
+ params_group = root['params']
+ fields_group = root['fields']
+ simu_group = root['simulation']
+ except:
+ msg='A fatal error occured during checkpoint import, checkpoint data may be illformed.'
+ vprint(msg)
+ vprint()
+ raise
+
+ # Define helper functions
+ relax_constraints = self.relax_constraints
+ raise_error = self._raise_error
+ if relax_constraints:
+ raise_warning = self._raise_warning
+ else:
+ raise_warning = self._raise_error
+ load_array_data = functools.partial(self._load_array_data, on_mismatch=raise_warning)
+ fmt_key = self._format_zarr_key
+
+ # Import simulation data after parameters are up to date
+ msg = ' | importing simulation...'
+ vprint(msg)
+ simulation.load_checkpoint(simu_group, mpi_params, io_params, relax_constraints)
+
+ # Import operator data
+ for op in problem.nodes:
+ if not op.checkpoint_required():
+ continue
+ key = fmt_key(op.checkpoint_datagroup_key())
+ if (key not in operators_group):
+ msg='Could not find operator key \'{}\' in checkpoint.'
+ raise_warning(msg.format(key))
+ continue
+ operator_group = operators_group[key]
+ op.load_checkpoint(operator_group, mpi_params, io_params, relax_constraints)
+
+ # Import parameters, hopefully parameter names match the ones in the checkpoint
+ msg = ' | importing parameters...'
+ vprint(msg)
+ for param in sorted(problem.parameters, key=operator.attrgetter('name')):
+ key = fmt_key(param.name)
+
+ if (key not in params_group):
+ msg='Checkpoint directory \'{}\' does not contain any data regarding to parameter {}'
+ msg=msg.format(load_checkpoint_dir, param.name)
+ raise_error(msg)
+
+ array = params_group[key]
+
+ if array.attrs['kind'] != param.__class__.__name__:
+ msg='Parameter kind do not match with checkpointed parameter {}, loaded kind {} but expected {}.'
+ msg=msg.format(param.name, array.attrs['kind'], param.__class__.__name__)
+ raise_error(msg)
+
+ if isinstance(param, (ScalarParameter, TensorParameter, BufferParameter)):
+ value = param._value
+
+ if (array.shape != value.shape):
+ msg='Parameter shape does not match with checkpointed parameter {}, loaded shape {} but expected {}.'
+ msg=msg.format(param.name, array.shape, value.shape)
+ raise_error(msg)
+
+ if (array.dtype != value.dtype):
+ msg='Parameter datatype does not match with checkpointed parameter {}, loaded dtype {} but expected {}.'
+ msg=msg.format(param.name, array.dtype, value.dtype)
+ raise_warning(msg)
+
+ value[...] = array[...]
+ else:
+ msg = 'Cannot import parameter of type {}.'.format(param.__class__.__name__)
+ raise NotImplementedError(msg)
+
+ # Import discrete fields, this is a bit more tricky because topologies or simply topology
+ # names can change. Moreover there is currently no waranty that the same operator graph is
+ # generated for the exact same problem configuration each time. We just emit user warnings
+ # if we find a way to match topologies that do not match exactly checkpointed ones.
+ for field in sorted(problem.fields, key=operator.attrgetter('name')):
+ domain = field.domain._domain
+
+ # we do not care about fields discretized only on temporary fields
+ if all(df.is_tmp for df in field.discrete_fields.values()):
+ continue
+
+ msg = ' | importing field {}...'.format(field.pretty_name)
+ vprint(msg)
+
+ field_key = fmt_key(field.name)
+ if (field_key not in fields_group):
+ msg='Checkpoint directory \'{}\' does not contain any data regarding to field {}'
+ msg=msg.format(load_checkpoint_dir, field.name)
+ raise_error(msg)
+
+ field_group = fields_group[field_key]
+
+ # check that domain matches
+ if field_group.attrs['domain'] != domain.__class__.__name__:
+ msg='Domain kind does not match with checkpointed field {}, loaded kind {} but expected {}.'
+ msg=msg.format(field.name, field_group.attrs['domain'], domain.__class__.__name__)
+ raise_error(msg)
+ if field_group.attrs['dim'] != domain.dim:
+ msg='Domain dim does not match with checkpointed field {}, loaded dim {} but expected {}.'
+ msg=msg.format(field.name, field_group.attrs['dim'], domain.dim)
+ raise_error(msg)
+ if field_group.attrs['origin'] != to_list(domain.origin):
+ msg='Domain origin does not match with checkpointed field {}, loaded origin {} but expected {}.'
+ msg=msg.format(field.name, field_group.attrs['origin'], domain.origin)
+ raise_error(msg)
+ if field_group.attrs['end'] != to_list(domain.end):
+ msg='Domain end does not match with checkpointed field {}, loaded end {} but expected {}.'
+ msg=msg.format(field.name, field_group.attrs['end'], domain.end)
+ raise_error(msg)
+ if field_group.attrs['length'] != to_list(domain.length):
+ msg='Domain length does not match with checkpointed field {}, loaded length {} but expected {}.'
+ msg=msg.format(field.name, field_group.attrs['length'], domain.length)
+ raise_error(msg)
+
+ for (k, topo) in enumerate(sorted(field.discrete_fields, key=operator.attrgetter('full_tag'))):
+ dfield = field.discrete_fields[topo]
+ mesh = topo.mesh._mesh
+
+ # we do not care about temporary fields
+ if dfield.is_tmp:
+ continue
+
+ # for now we just handle CartesianDiscreteScalarFields.
+ if not isinstance(dfield, CartesianDiscreteScalarField):
+ raise NotImplementedError
+
+ # first we need to exactly match global grid resolution
+ candidates = tuple(filter(lambda d: np.equal(d.shape, mesh.grid_resolution).all(), field_group.values()))
+ if len(candidates)==0:
+ msg='Could not find any topology with shape {} for field {}, available discretizations are: {}.'
+ msg=msg.format(to_tuple(mesh.grid_resolution), field.name,
+ ', '.join(set(str(d.shape) for d in field_group.values())))
+ raise_error(msg)
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ # Here multiple topologies have the extact same grid resolution so we try to match boundary conditions
+ old_candidates = candidates
+ candidates = tuple(filter(lambda d: d.attrs['lboundaries'] == to_tuple(map(str, mesh.global_lboundaries)), candidates))
+ candidates = tuple(filter(lambda d: d.attrs['rboundaries'] == to_tuple(map(str, mesh.global_rboundaries)), candidates))
+ if len(candidates)==0:
+ # ok, the user changed the boundary conditions, we ignore boundary condition information
+ candidates = old_candidates
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ # From now on multiple topologies have the same grid resolution and boundary conditions
+ # We try to match exact ghost count, user did likely not change the order of the methods.
+ old_candidates = candidates
+ candidates = tuple(filter(lambda d: d.attrs['ghosts'] == to_tuple(mesh.ghosts), candidates))
+ if len(candidates)==0:
+ # ok, the user made a change that affected ghosts, we ignore the ghost condition
+ candidates = old_candidates
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ # Now we try to differentiate by using zero ghost info (ghosts may change with method order, but zero-ghost is very specific)
+ # Topology containing zero ghost layer usually target Fortran topologies for FFT operators or method that do not require any ghosts.
+ old_candidates = candidates
+ candidates = tuple(filter(lambda d: (np.equal(d.attrs['ghosts'],0) == (mesh.ghosts==0)).all(), candidates))
+ if len(candidates)==0:
+ # ok, we ignore the zero-ghost condition
+ candidates = old_candidates
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ # Now we try to match exact topology shape (the MPICart grid of processes)
+ # We try this late because use may run the simulation again with a different number of processes.
+ old_candidates = candidates
+ candidates = tuple(filter(lambda d: d.attrs['proc_shape'] == to_tuple(mesh.proc_shape), candidates))
+ if len(candidates)==0:
+ # ok, we ignore the proc shape
+ candidates = old_candidates
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ # Now we try to differentiate by using topo splitting info (axes on which data is distributed)
+ # This again is very specific and can differentiate topologies used for spectral transforms.
+ old_candidates = candidates
+ candidates = tuple(filter(lambda d: (np.greater(d.attrs['proc_shape'],1) == (mesh.proc_shape>1)).all(), candidates))
+ if len(candidates)==0:
+ # ok, we ignore the MPI data splitting condition
+ candidates = old_candidates
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ # Ok now, our last hope is to match the discrete field name
+ old_candidates = candidates
+ candidates = tuple(filter(lambda d: d.attrs['name'] == dfield.name, candidates))
+ if len(candidates)==0:
+ # ok, we ignore the name
+ candidates = old_candidates
+ elif len(candidates)==1:
+ load_array_data(candidates[0], dfield)
+ continue
+
+ assert len(candidates) > 1, 'Something went wrong.'
+
+ msg='Could not discriminate checkpointed topologies for field {}, got {} candidates remaining.'
+ msg=msg.format(field.name, len(candidates))
+ raise_error(msg)
+
+
+ @staticmethod
+ def _load_array_data(array, dfield, on_mismatch):
+ mesh = dfield.mesh._mesh
+ assert np.equal(array.shape, mesh.grid_resolution).all()
+
+ # compare attributes but ignore name because this can be annoying
+ attr_names = ('left boundaries', 'right boundaries', 'ghost layers', 'process shape', 'datatype')
+ array_attributes = (array.attrs['lboundaries'], array.attrs['rboundaries'], array.attrs['ghosts'],
+ array.attrs['proc_shape'], array.dtype)
+ dfield_attributes = (list(map(str, mesh.global_lboundaries)), list(map(str, mesh.global_rboundaries)),
+ list(mesh.ghosts), list(mesh.proc_shape))
+
+ for (name,lhs,rhs) in zip(attr_names, array_attributes, dfield_attributes):
+ if lhs==rhs:
+ continue
+ msg='{} do not match with checkpointed field {}, loaded {} {} but expected {}.'
+ msg=msg.format(name, dfield.field.name, name, lhs, rhs)
+ on_mismatch(msg)
+
+ global_slices = mesh.global_compute_slices
+ data = np.asarray(array[global_slices], dtype=dfield.dtype)
+ dfield.compute_data[0][...] = data
+ dfield.exchange_ghosts()
+
+ @staticmethod
+ def _raise_error(msg):
+ vprint(' | error: {}\n'.format(msg))
+ vprint()
+ err = 'FATAL ERROR: Failed to import checkpoint, because the following error occured: {}.'
+ raise RuntimeError(err.format(msg))
+
+ @staticmethod
+ def _raise_warning(msg):
+ msg = ' | warning: {}'.format(msg)
+ vprint(msg)
+
+ @staticmethod
+ def _format_zarr_key(k):
+ # note keys that contains the special characters '/' and '\' do not work well with zarr
+ # so we need to replace it by another character such as '_'.
+ # We cannot use utf8 characters such as u+2215 (division slash).
+ if (k is None):
+ return None
+ return k.replace('/', '_').replace('\\', '_')
+
diff --git a/hysop/core/graph/computational_graph.py b/hysop/core/graph/computational_graph.py
index 27ae81716ead3604f7b672b1dd36061da385fc22..13ec3a71168f598b9816264bbd1cec825b491be7 100644
--- a/hysop/core/graph/computational_graph.py
+++ b/hysop/core/graph/computational_graph.py
@@ -1,22 +1,25 @@
# coding: utf-8
from hysop import __DEBUG__, __VERBOSE__, vprint, dprint
-from hysop.tools.decorators import debug
+from hysop.tools.decorators import debug
from hysop.tools.types import to_list, to_set, to_tuple, first_not_None, check_instance
from hysop.tools.string_utils import framed_str, strlen, multiline_split
from hysop.tools.numpywrappers import npw
from hysop.core.graph.graph import not_implemented, initialized, discretized, \
- ready, graph_built, not_initialized
-from hysop.core.graph.graph import Graph, ComputationalGraphNodeData, gt, graph_draw
-from hysop.core.graph.computational_node import ComputationalGraphNode
+ ready, graph_built, not_initialized
+from hysop.core.graph.graph import ComputationalGraphNodeData
+from hysop.core.graph.computational_node import ComputationalGraphNode
from hysop.core.graph.computational_operator import ComputationalGraphOperator
from hysop.core.graph.node_generator import ComputationalGraphNodeGenerator
+from hysop.core.graph.node_requirements import NodeRequirements, OperatorRequirements
from hysop.core.memory.memory_request import MultipleOperatorMemoryRequests
from hysop.fields.field_requirements import MultiFieldRequirements
from hysop.topology.topology import Topology
+from hysop.core.mpi import main_rank
from abc import ABCMeta, abstractmethod
+
class ComputationalGraph(ComputationalGraphNode):
"""
Interface of an abstract graph of continuous operators (ie. a computational graph).
@@ -28,8 +31,8 @@ class ComputationalGraph(ComputationalGraphNode):
@debug
def __init__(self, candidate_input_tensors=None,
- candidate_output_tensors=None,
- **kwds):
+ candidate_output_tensors=None,
+ **kwds):
"""
Parameters
----------
@@ -47,22 +50,22 @@ class ComputationalGraph(ComputationalGraphNode):
"""
if ('input_fields' in kwds.keys()) or ('output_fields' in kwds.keys()):
- msg='input_fields or output_fields parameters should not be used in {}, they are \
+ msg = 'input_fields or output_fields parameters should not be used in {}, they are \
deduced during graph construction (building step).'.format(cls)
raise ValueError(msg)
if ('input_params' in kwds.keys()) or ('output_params' in kwds.keys()):
- msg='input_params or output_params parameters should not be used in {}, they are \
+ msg = 'input_params or output_params parameters should not be used in {}, they are \
deduced during graph construction (building step).'.format(cls)
raise ValueError(msg)
- super(ComputationalGraph,self).__init__(input_fields=None, output_fields=None,
- **kwds)
+ super(ComputationalGraph, self).__init__(input_fields=None, output_fields=None,
+ **kwds)
self.nodes = []
self.graph = None
self.graph_built = False
self.graph_is_rendering = False
- self.candidate_input_tensors = set(first_not_None(candidate_input_tensors, ()))
+ self.candidate_input_tensors = set(first_not_None(candidate_input_tensors, ()))
self.candidate_output_tensors = set(first_not_None(candidate_output_tensors, ()))
@graph_built
@@ -71,12 +74,64 @@ class ComputationalGraph(ComputationalGraphNode):
for node in self.nodes:
self._profiler += node._profiler
+ def node_requirements_report(self, requirements):
+ values = [(u'OPERATOR', u'TOPOLOGY', u'TSTATE', u'GHOSTS', u'MEMORY ORDER',
+ u'NODE.MRO[0]', u'NODE.MRO[1]', u'NODE.MRO[2]')]
+ for node in self.nodes:
+ reqs = node.get_node_requirements()
+ if not isinstance(reqs, OperatorRequirements):
+ continue
+ opname = node.pretty_name.decode('utf-8')
+ optypes = type(node).__mro__
+ n = len(optypes)
+ optypes = tuple(_.__name__ for _ in optypes[:min(3, n)]) + (u'',)*(3-n)
+ vals = (opname,
+ reqs.enforce_unique_topology_shape, reqs.enforce_unique_transposition_state,
+ reqs.enforce_unique_ghosts, reqs.enforce_unique_memory_order,
+ ) + optypes
+ vals = tuple(unicode(x) for x in vals)
+ values.append(vals)
+
+ template = u'\n {:<{name_size}} {:^{topology_size}} {:^{tstates_size}} {:^{ghosts_size}} {:^{order_size}} {:<{type_size0}} {:<{type_size1}} {:<{type_size2}}'
+ name_size = max(strlen(s[0]) for s in values)
+ topology_size = max(strlen(s[1]) for s in values)
+ tstates_size = max(strlen(s[2]) for s in values)
+ ghosts_size = max(strlen(s[3]) for s in values)
+ order_size = max(strlen(s[4]) for s in values)
+ type_size0 = max(strlen(s[5]) for s in values)
+ type_size1 = max(strlen(s[6]) for s in values)
+ type_size2 = max(strlen(s[7]) for s in values)
+
+ ss = u''
+ for (opname, enforce_unique_topology_shape, enforce_unique_transposition_state,
+ enforce_unique_ghosts, enforce_unique_memory_order, optype0, optype1, optype2) in values:
+ ss += template.format(
+ opname,
+ enforce_unique_topology_shape,
+ enforce_unique_transposition_state,
+ enforce_unique_ghosts,
+ enforce_unique_memory_order,
+ optype0, optype1, optype2,
+ name_size=name_size,
+ topology_size=topology_size,
+ tstates_size=tstates_size,
+ ghosts_size=ghosts_size,
+ order_size=order_size,
+ type_size0=type_size0,
+ type_size1=type_size1,
+ type_size2=type_size2)
+
+ title = u'ComputationalGraph {} node requirements report '.format(
+ self.pretty_name.decode('utf-8'))
+ return u'\n{}\n'.format(framed_str(title=title, msg=ss[1:])).encode('utf-8')
+
def field_requirements_report(self, requirements):
inputs, outputs = {}, {}
sinputs, soutputs = {}, {}
+
def sorted_reqs(reqs):
- return sorted(reqs, key=lambda x: \
- '{}::{}'.format(x.field.name, x.operator.name))
+ return sorted(reqs, key=lambda x:
+ '{}::{}'.format(x.field.name, x.operator.name))
for field, mreqs in requirements.input_field_requirements.iteritems():
for td, reqs in mreqs.requirements.iteritems():
for req in reqs:
@@ -86,16 +141,18 @@ class ComputationalGraph(ComputationalGraphNode):
for field, reqs in td_reqs.iteritems():
for req in sorted_reqs(reqs):
opname = getattr(req.operator, 'pretty_name', 'UnknownOperator').decode('utf-8')
- fname = getattr(req.field, 'pretty_name', 'UnknownField').decode('utf-8')
- min_ghosts=req.ghost_str(req.min_ghosts)
- max_ghosts=req.ghost_str(req.max_ghosts+1)
- discr = str(req.operator.input_fields[field].grid_resolution)
+ fname = getattr(req.field, 'pretty_name', 'UnknownField').decode('utf-8')
+ min_ghosts = req.ghost_str(req.min_ghosts)
+ max_ghosts = req.ghost_str(req.max_ghosts+1)
+ discr = str(req.operator.input_fields[field].grid_resolution)
ghosts = u'{}<=ghosts<{}'.format(min_ghosts, max_ghosts)
- can_split=req.can_split.view(npw.int8)
- memory_order=u'{}'.format(req.memory_order) if req.memory_order else u'ANY'
- tstates=u'{}'.format(u','.join(str(ts) for ts in req.tstates)) \
- if req.tstates else 'ANY'
- sin.append( (opname, fname, discr, ghosts, memory_order, tstates) )
+ can_split = req.can_split.view(npw.int8)
+ memory_order = u'{}'.format(req.memory_order) if req.memory_order else u'ANY'
+ can_split = u'[{}]'.format(
+ u','.join('1' if cs else '0' for cs in req.can_split))
+ tstates = u'{}'.format(u','.join(str(ts) for ts in req.tstates)) \
+ if req.tstates else 'ANY'
+ sin.append((opname, fname, discr, ghosts, memory_order, can_split, tstates))
for field, mreqs in requirements.output_field_requirements.iteritems():
for td, reqs in mreqs.requirements.iteritems():
for req in reqs:
@@ -105,101 +162,118 @@ class ComputationalGraph(ComputationalGraphNode):
for field, reqs in td_reqs.iteritems():
for req in sorted_reqs(reqs):
opname = getattr(req.operator, 'pretty_name', 'UnknownOperator').decode('utf-8')
- fname = getattr(req.field, 'pretty_name', 'UnknownField').decode('utf-8')
- min_ghosts=req.ghost_str(req.min_ghosts)
- max_ghosts=req.ghost_str(req.max_ghosts+1)
- discr = str(req.operator.output_fields[field].grid_resolution)
+ fname = getattr(req.field, 'pretty_name', 'UnknownField').decode('utf-8')
+ min_ghosts = req.ghost_str(req.min_ghosts)
+ max_ghosts = req.ghost_str(req.max_ghosts+1)
+ discr = str(req.operator.output_fields[field].grid_resolution)
ghosts = u'{}<=ghosts<{}'.format(min_ghosts, max_ghosts)
- can_split=req.can_split.view(npw.int8)
- memory_order=u'{}'.format(req.memory_order) if req.memory_order else u'ANY'
- tstates=u'{}'.format(u','.join(str(ts) for ts in req.tstates)) \
- if req.tstates else u'ANY'
- sout.append( (opname, fname, discr, ghosts, memory_order, tstates) )
-
- titles = [[(u'OPERATOR', u'FIELD', u'DISCRETIZATION', u'GHOSTS', u'MEMORY ORDER', u'TSTATES')]]
- name_size = max(len(s[0]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
- field_size = max(len(s[1]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
- discr_size = max(len(s[2]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
- ghosts_size = max(len(s[3]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
- order_size = max(len(s[4]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
- tstates_size = max(len(s[5]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
-
- template = u'\n {:<{name_size}} {:^{field_size}} {:^{discr_size}} {:^{ghosts_size}} {:^{order_size}} {:^{tstates_size}}'
-
- ss= u'>INPUTS:'
+ can_split = req.can_split.view(npw.int8)
+ memory_order = u'{}'.format(req.memory_order) if req.memory_order else u'ANY'
+ can_split = u'[{}]'.format(
+ u','.join('1' if cs else '0' for cs in req.can_split))
+ tstates = u'{}'.format(u','.join(str(ts) for ts in req.tstates)) \
+ if req.tstates else u'ANY'
+ sout.append((opname, fname, discr, ghosts, memory_order, can_split, tstates))
+
+ titles = [[(u'OPERATOR', u'FIELD', u'DISCRETIZATION', u'GHOSTS',
+ u'MEMORY ORDER', u'CAN_SPLIT', u'TSTATES')]]
+ name_size = max(len(s[0]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
+ field_size = max(len(s[1]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
+ discr_size = max(len(s[2]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
+ ghosts_size = max(len(s[3]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
+ order_size = max(len(s[4]) for ss in sinputs.values()+soutputs.values()+titles for s in ss)
+ cansplit_size = max(len(s[5]) for ss in sinputs.values() +
+ soutputs.values()+titles for s in ss)
+ tstates_size = max(len(s[6]) for ss in sinputs.values() +
+ soutputs.values()+titles for s in ss)
+
+ template = u'\n {:<{name_size}} {:^{field_size}} {:^{discr_size}} {:^{ghosts_size}} {:^{order_size}} {:^{cansplit_size}} {:^{tstates_size}}'
+
+ ss = u'>INPUTS:'
if sinputs:
for (td, sreqs) in sinputs.iteritems():
if isinstance(td, Topology):
- ss+=u'\n {}'.format(td.short_description())
+ ss += u'\n {}'.format(td.short_description())
else:
- ss+=u'\n {}'.format(td)
- ss+= template.format(*titles[0][0],
- name_size=name_size, field_size=field_size,
+ ss += u'\n {}'.format(td)
+ ss += template.format(*titles[0][0],
+ name_size=name_size, field_size=field_size,
+ discr_size=discr_size, ghosts_size=ghosts_size,
+ order_size=order_size, cansplit_size=cansplit_size,
+ tstates_size=tstates_size)
+ for (opname, fname, discr, ghosts, order, can_split, tstates) in sreqs:
+ ss += template.format(
+ opname, fname, discr, ghosts, order, can_split, tstates,
+ name_size=name_size, field_size=field_size,
discr_size=discr_size, ghosts_size=ghosts_size,
- order_size=order_size, tstates_size=tstates_size)
- for (opname, fname, discr, ghosts, order, tstates) in sreqs:
- ss+=template.format(
- opname, fname, discr, ghosts, order, tstates,
- name_size=name_size, field_size=field_size,
- discr_size=discr_size, ghosts_size=ghosts_size,
- order_size=order_size, tstates_size=tstates_size)
+ order_size=order_size, cansplit_size=cansplit_size,
+ tstates_size=tstates_size)
else:
- ss+=u' None'
- ss+= u'\n>OUTPUTS:'
+ ss += u' None'
+ ss += u'\n>OUTPUTS:'
if soutputs:
for (td, sreqs) in soutputs.iteritems():
if isinstance(td, Topology):
- ss+=u'\n {}'.format(td.short_description())
+ ss += u'\n {}'.format(td.short_description())
else:
- ss+=u'\n {}'.format(td)
- ss+= template.format(*titles[0][0],
- name_size=name_size, field_size=field_size,
+ ss += u'\n {}'.format(td)
+ ss += template.format(*titles[0][0],
+ name_size=name_size, field_size=field_size,
+ discr_size=discr_size, ghosts_size=ghosts_size,
+ order_size=order_size, cansplit_size=cansplit_size,
+ tstates_size=tstates_size)
+ for (opname, fname, discr, ghosts, order, can_split, tstates) in sreqs:
+ ss += template.format(
+ opname, fname, discr, ghosts, order, can_split, tstates,
+ name_size=name_size, field_size=field_size,
discr_size=discr_size, ghosts_size=ghosts_size,
- order_size=order_size, tstates_size=tstates_size)
- for (opname, fname, discr, ghosts, order, tstates) in sreqs:
- ss+=template.format(
- opname, fname, discr, ghosts, order, tstates,
- name_size=name_size, field_size=field_size,
- discr_size=discr_size, ghosts_size=ghosts_size,
- order_size=order_size, tstates_size=tstates_size)
+ order_size=order_size, cansplit_size=cansplit_size,
+ tstates_size=tstates_size)
else:
- ss+=u' None'
+ ss += u' None'
- title = u' ComputationalGraph {} field requirements report '.format(self.pretty_name.decode('utf-8'))
+ title = u'ComputationalGraph {} field requirements report '.format(
+ self.pretty_name.decode('utf-8'))
return u'\n{}\n'.format(framed_str(title=title, msg=ss)).encode('utf-8')
def domain_report(self):
domains = self.get_domains()
- ops={}
+ ops = {}
- maxlen = (None, 40, None, 40, None)
- split_sep = (None, ',', None, ',', None)
+ maxlen = (None, 40, None, 40, None)
+ split_sep = (None, ',', None, ',', None)
newline_prefix = (None, ' ', '', ' ', None)
- replace = ('', '', '-', '', '')
+ replace = ('', '', '-', '', '')
- for (domain,operators) in domains.iteritems():
+ for (domain, operators) in domains.iteritems():
if (domain is None):
continue
for op in sorted(operators, key=lambda x: x.pretty_name):
- finputs = u','.join( sorted([f.pretty_name.decode('utf-8') for f in op.iter_input_fields() if f.domain is domain]))
- foutputs =u','.join( sorted([f.pretty_name.decode('utf-8') for f in op.iter_output_fields() if f.domain is domain]))
- pinputs = u','.join( sorted([p.pretty_name.decode('utf-8') for p in op.input_params.values()]))
- poutputs =u','.join( sorted([p.pretty_name.decode('utf-8') for p in op.output_params.values()]))
- infields = u'[{}]'.format(finputs) if finputs else u''
+ finputs = u','.join(sorted([f.pretty_name.decode('utf-8')
+ for f in op.iter_input_fields() if f.domain is domain]))
+ foutputs = u','.join(sorted([f.pretty_name.decode('utf-8')
+ for f in op.iter_output_fields() if f.domain is domain]))
+ pinputs = u','.join(sorted([p.pretty_name.decode('utf-8')
+ for p in op.input_params.values()]))
+ poutputs = u','.join(sorted([p.pretty_name.decode('utf-8')
+ for p in op.output_params.values()]))
+ infields = u'[{}]'.format(finputs) if finputs else u''
outfields = u'[{}]'.format(foutputs) if foutputs else u''
- inparams = u'[{}]'.format(pinputs) if pinputs else u''
+ inparams = u'[{}]'.format(pinputs) if pinputs else u''
outparams = u'[{}]'.format(poutputs) if poutputs else u''
- inputs = u'{}{}{}'.format(infields, u'x' if infields and inparams else u'', inparams)
- outputs = u'{}{}{}'.format(outfields, u'x' if outfields and outparams else u'', outparams)
+ inputs = u'{}{}{}'.format(
+ infields, u'x' if infields and inparams else u'', inparams)
+ outputs = u'{}{}{}'.format(
+ outfields, u'x' if outfields and outparams else u'', outparams)
if inputs == u'':
- inputs=u'no inputs'
+ inputs = u'no inputs'
if outputs == u'':
- outputs=u'no outputs'
+ outputs = u'no outputs'
- opname = op.pretty_name.decode('utf-8')
- optype = type(op).__name__
+ opname = op.pretty_name.decode('utf-8')
+ optype = type(op).__name__
strdata = (opname, inputs, '->', outputs, optype)
op_data = ops.setdefault(domain, [])
@@ -208,109 +282,108 @@ class ComputationalGraph(ComputationalGraphNode):
if (None in domains):
operators = domains[None]
for op in sorted(operators, key=lambda x: x.pretty_name):
- pinputs = u','.join( sorted([p.pretty_name.decode('utf-8') for p in op.input_params.values()]))
- poutputs =u','.join( sorted([p.pretty_name.decode('utf-8') for p in op.output_params.values()]))
- inparams = u'[{}]'.format(pinputs) if pinputs else ''
+ pinputs = u','.join(sorted([p.pretty_name.decode('utf-8')
+ for p in op.input_params.values()]))
+ poutputs = u','.join(sorted([p.pretty_name.decode('utf-8')
+ for p in op.output_params.values()]))
+ inparams = u'[{}]'.format(pinputs) if pinputs else ''
outparams = u'[{}]'.format(poutputs) if poutputs else ''
- inputs=u'{}'.format(inparams)
- outputs=u'{}'.format(outparams)
+ inputs = u'{}'.format(inparams)
+ outputs = u'{}'.format(outparams)
if inputs == '':
- inputs=u'no inputs'
+ inputs = u'no inputs'
if outputs == '':
- outputs=u'no outputs'
- opname = op.pretty_name.decode('utf-8')
- optype = type(op).__name__
+ outputs = u'no outputs'
+ opname = op.pretty_name.decode('utf-8')
+ optype = type(op).__name__
strdata = (opname, inputs, '->', outputs, optype)
op_data = ops.setdefault(None, [])
op_data += multiline_split(strdata, maxlen, split_sep, replace, newline_prefix)
- name_size = max(strlen(s[0]) for ss in ops.values() for s in ss)
- in_size = max(strlen(s[1]) for ss in ops.values() for s in ss)
+ name_size = max(strlen(s[0]) for ss in ops.values() for s in ss)
+ in_size = max(strlen(s[1]) for ss in ops.values() for s in ss)
arrow_size = max(strlen(s[2]) for ss in ops.values() for s in ss)
- out_size = max(strlen(s[3]) for ss in ops.values() for s in ss)
- type_size = max(strlen(s[4]) for ss in ops.values() for s in ss)
+ out_size = max(strlen(s[3]) for ss in ops.values() for s in ss)
+ type_size = max(strlen(s[4]) for ss in ops.values() for s in ss)
ss = u''
- for (domain,dops) in ops.iteritems():
+ for (domain, dops) in ops.iteritems():
if (domain is None):
continue
ss += u'\n>{}'.format(domain.short_description())
ss += u'\n {:<{name_size}} {:<{in_size}} {:<{arrow_size}} {:<{out_size}} {:<{type_size}}'.format(
- 'OPERATOR', 'INPUTS', '', 'OUTPUTS', 'OPERATOR TYPE',
- name_size=name_size, in_size=in_size,
- arrow_size=arrow_size,
- out_size=out_size, type_size=type_size)
+ 'OPERATOR', 'INPUTS', '', 'OUTPUTS', 'OPERATOR TYPE',
+ name_size=name_size, in_size=in_size,
+ arrow_size=arrow_size,
+ out_size=out_size, type_size=type_size)
for (opname, inputs, arrow, outputs, optype) in dops:
ss += u'\n {:<{name_size}} {:<{in_size}} {:<{arrow_size}} {:<{out_size}} {:<{type_size}}'.format(
- opname, inputs, arrow, outputs, optype,
- name_size=name_size, in_size=in_size,
- arrow_size=arrow_size,
- out_size=out_size, type_size=type_size)
+ opname, inputs, arrow, outputs, optype,
+ name_size=name_size, in_size=in_size,
+ arrow_size=arrow_size,
+ out_size=out_size, type_size=type_size)
if (None in domains):
ss += u'\n>Domainless operators:'
ss += u'\n {:<{name_size}} {:<{in_size}} {:<{arrow_size}} {:<{out_size}} {:<{type_size}}'.format(
- 'OPERATOR', 'INPUTS', '', 'OUTPUTS', 'OPERATOR TYPE',
- name_size=name_size, in_size=in_size,
- arrow_size=arrow_size,
- out_size=out_size, type_size=type_size)
+ 'OPERATOR', 'INPUTS', '', 'OUTPUTS', 'OPERATOR TYPE',
+ name_size=name_size, in_size=in_size,
+ arrow_size=arrow_size,
+ out_size=out_size, type_size=type_size)
for (opname, inputs, arrow, outputs, optype) in ops[None]:
ss += u'\n {:<{name_size}} {:<{in_size}} {:<{arrow_size}} {:<{out_size}} {:<{type_size}}'.format(
- opname, inputs, arrow, outputs, optype,
- name_size=name_size, in_size=in_size,
- arrow_size=arrow_size,
- out_size=out_size, type_size=type_size)
+ opname, inputs, arrow, outputs, optype,
+ name_size=name_size, in_size=in_size,
+ arrow_size=arrow_size,
+ out_size=out_size, type_size=type_size)
- title=u' ComputationalGraph {} domain and operator report '.format(self.pretty_name.decode('utf-8'))
+ title = u'ComputationalGraph {} domain and operator report '.format(
+ self.pretty_name.decode('utf-8'))
return u'\n{}\n'.format(framed_str(title=title, msg=ss[1:])).encode('utf-8')
-
def topology_report(self):
- ss=''
- for (backend,topologies) in self.get_topologies().iteritems():
+ ss = ''
+ for (backend, topologies) in self.get_topologies().iteritems():
ss += u'\n {}:'.format(backend.short_description())
ss += u'\n *'+'\n *'.join(t.short_description()
- for t in sorted(topologies, key=lambda x: x.id))
- title = u' ComputationalGraph {} topology report '.format(self.pretty_name.decode('utf-8'))
+ for t in sorted(topologies, key=lambda x: x.id))
+ title = u'ComputationalGraph {} topology report '.format(
+ self.pretty_name.decode('utf-8'))
return u'\n{}\n'.format(framed_str(title=title, msg=ss[1:]))
def variable_report(self):
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
fields = self.fields
topologies = {}
for field in self.fields:
field_topologies = {}
- for (i,vid) in enumerate(self.sorted_nodes):
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
- if field in op.input_fields:
- topo = op.input_fields[field]
- field_topologies.setdefault(topo, []).append(op)
- if field in op.output_fields:
- topo = op.output_fields[field]
- field_topologies.setdefault(topo, []).append(op)
+ for (i, node) in enumerate(self.nodes):
+ if field in node.input_fields:
+ topo = node.input_fields[field]
+ field_topologies.setdefault(topo, []).append(node)
+ if field in node.output_fields:
+ topo = node.output_fields[field]
+ field_topologies.setdefault(topo, []).append(node)
for topo in sorted(field_topologies.keys(), key=lambda x: x.tag):
- pnames = set(op.pretty_name.decode('utf-8') for op in field_topologies[topo])
+ pnames = set(node.pretty_name.decode('utf-8') for node in field_topologies[topo])
pnames = sorted(pnames)
nbyline = 4
nentries = len(pnames)//nbyline
n0 = len(str(topo.backend.kind).lower())
n1 = len(str(topo.tag))
for i in xrange(nentries):
- sops=u', '.join(pnames[nbyline*i:nbyline*(i+1)])
- if (i!=nentries-1) or (len(pnames)%nbyline!=0):
- sops+=','
- if (i==0):
+ sops = u', '.join(pnames[nbyline*i:nbyline*(i+1)])
+ if (i != nentries-1) or (len(pnames) % nbyline != 0):
+ sops += ','
+ if (i == 0):
entries = (str(topo.backend.kind).lower(), topo.tag, sops)
else:
entries = ('', '-'*n1, sops)
topologies.setdefault(field, []).append(entries)
- if (len(pnames)%nbyline != 0):
- sops=u', '.join(pnames[nbyline*nentries:])
- if (nentries==0):
+ if (len(pnames) % nbyline != 0):
+ sops = u', '.join(pnames[nbyline*nentries:])
+ if (nentries == 0):
entries = (str(topo.backend.kind).lower(), topo.tag, sops)
else:
entries = ('', '-'*n1, sops)
@@ -318,7 +391,7 @@ class ComputationalGraph(ComputationalGraphNode):
titles = [[(u'BACKEND', u'TOPOLOGY', u'OPERATORS')]]
backend_size = max(len(s[0]) for ss in topologies.values()+titles for s in ss)
- topo_size = max(len(s[1]) for ss in topologies.values()+titles for s in ss)
+ topo_size = max(len(s[1]) for ss in topologies.values()+titles for s in ss)
template = u'\n {:<{backend_size}} {:<{topo_size}} {}'
sizes = {'backend_size': backend_size,
'topo_size': topo_size}
@@ -331,95 +404,94 @@ class ComputationalGraph(ComputationalGraphNode):
for entries in field_topologies:
ss += template.format(*entries, **sizes)
- title = u' ComputationalGraph {} fields report '.format(self.pretty_name.decode('utf-8'))
+ title = u'ComputationalGraph {} fields report '.format(
+ self.pretty_name.decode('utf-8'))
ss = u'\n{}\n'.format(framed_str(title=title, msg=ss[1:]))
return ss.encode('utf-8')
def operator_report(self):
- maxlen = (None, None, 40, None, 40, None)
- split_sep = (None, None, ',', None, ',', None)
+ maxlen = (None, None, 40, None, 40, None)
+ split_sep = (None, None, ',', None, ',', None)
newline_prefix = (None, None, ' ', '', ' ', None)
- replace = ('--', '', '', '-', '', '')
+ replace = ('--', '', '', '-', '', '')
reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
ops = []
- for (i,vid) in enumerate(self.sorted_nodes):
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
-
+ for (i, node) in enumerate(self.nodes):
handled_inputs, handled_outputs = (), ()
finputs, foutputs = [], []
- for f in op.input_tensor_fields:
+ for f in node.input_tensor_fields:
f0 = f.fields[0]
- t0 = op.input_fields[f0]
- if all((op.input_fields[fi] is t0) for fi in f.fields):
+ t0 = node.input_fields[f0]
+ if all((node.input_fields[fi] is t0) for fi in f.fields):
finputs.append(u'{}.{}'.format(f.pretty_name.decode('utf-8'),
t0.pretty_tag.decode('utf-8')))
handled_inputs += f.fields
- for f in op.output_tensor_fields:
+ for f in node.output_tensor_fields:
f0 = f.fields[0]
- t0 = op.output_fields[f0]
- if all((op.output_fields[fi] is t0) for fi in f.fields):
+ t0 = node.output_fields[f0]
+ if all((node.output_fields[fi] is t0) for fi in f.fields):
foutputs.append(u'{}.{}'.format(f.pretty_name.decode('utf-8'),
t0.pretty_tag.decode('utf-8')))
handled_outputs += f.fields
- finputs += [u'{}.{}'.format(f.pretty_name.decode('utf-8'),
- t.pretty_tag.decode('utf-8'))
- for (f,t) in op.input_fields.iteritems()
- if f not in handled_inputs]
- foutputs += [u'{}.{}'.format(f.pretty_name.decode('utf-8'),
- t.pretty_tag.decode('utf-8'))
- for (f,t) in op.output_fields.iteritems()
- if f not in handled_outputs]
+ finputs += [u'{}.{}'.format(f.pretty_name.decode('utf-8'),
+ t.pretty_tag.decode('utf-8'))
+ for (f, t) in node.input_fields.iteritems()
+ if f not in handled_inputs]
+ foutputs += [u'{}.{}'.format(f.pretty_name.decode('utf-8'),
+ t.pretty_tag.decode('utf-8'))
+ for (f, t) in node.output_fields.iteritems()
+ if f not in handled_outputs]
finputs = u','.join(sorted(finputs))
foutputs = u','.join(sorted(foutputs))
- pinputs = u','.join( sorted([p.pretty_name.decode('utf-8')
- for p in op.input_params.values()]))
- poutputs = u','.join( sorted([p.pretty_name.decode('utf-8')
- for p in op.output_params.values()]))
+ pinputs = u','.join(sorted([p.pretty_name.decode('utf-8')
+ for p in node.input_params.values()]))
+ poutputs = u','.join(sorted([p.pretty_name.decode('utf-8')
+ for p in node.output_params.values()]))
- infields = u'[{}]'.format(finputs) if finputs else u''
+ infields = u'[{}]'.format(finputs) if finputs else u''
outfields = u'[{}]'.format(foutputs) if foutputs else u''
- inparams = u'[{}]'.format(pinputs) if pinputs else u''
+ inparams = u'[{}]'.format(pinputs) if pinputs else u''
outparams = u'[{}]'.format(poutputs) if poutputs else u''
- inputs = u'{}{}{}'.format(infields, u'x' if infields and inparams else u'', inparams)
- outputs = u'{}{}{}'.format(outfields, u'x' if outfields and outparams else u'', outparams)
+ inputs = u'{}{}{}'.format(infields, u'x' if infields and inparams else u'', inparams)
+ outputs = u'{}{}{}'.format(
+ outfields, u'x' if outfields and outparams else u'', outparams)
if inputs == '':
- inputs=u'no inputs'
+ inputs = u'no inputs'
if outputs == '':
- outputs=u'no outputs'
+ outputs = u'no outputs'
- opname = op.pretty_name.decode('utf-8')
- optype = type(op).__name__
+ opname = node.pretty_name.decode('utf-8')
+ optype = type(node).__name__
strdata = (str(i), opname, inputs, '->', outputs, optype)
ops += multiline_split(strdata, maxlen, split_sep, replace, newline_prefix)
- isize = max(strlen(s[0]) for s in ops)
- name_size = max(strlen(s[1]) for s in ops)
- in_size = max(strlen(s[2]) for s in ops)
+ isize = max(strlen(s[0]) for s in ops)
+ name_size = max(strlen(s[1]) for s in ops)
+ in_size = max(strlen(s[2]) for s in ops)
arrow_size = max(strlen(s[3]) for s in ops)
- out_size = max(strlen(s[4]) for s in ops)
- type_size = max(strlen(s[5]) for s in ops)
+ out_size = max(strlen(s[4]) for s in ops)
+ type_size = max(strlen(s[5]) for s in ops)
ss = u' {:<{isize}} {:<{name_size}} {:<{in_size}} {:<{arrow_size}} {:<{out_size}} {:<{type_size}}'.format(
- 'ID', 'OPERATOR', 'INPUTS', '', 'OUTPUTS', 'OPERATOR TYPE',
- isize=isize,
- name_size=name_size, in_size=in_size,
- arrow_size=arrow_size,
- out_size=out_size, type_size=type_size)
+ 'ID', 'OPERATOR', 'INPUTS', '', 'OUTPUTS', 'OPERATOR TYPE',
+ isize=isize,
+ name_size=name_size, in_size=in_size,
+ arrow_size=arrow_size,
+ out_size=out_size, type_size=type_size)
for (i, opname, inputs, arrow, outputs, optype) in ops:
ss += u'\n {:>{isize}} {:<{name_size}} {:<{in_size}} {:<{arrow_size}} {:<{out_size}} {:<{type_size}}'.format(
- i, opname, inputs, arrow, outputs, optype,
- isize=isize,
- name_size=name_size, in_size=in_size,
- arrow_size=arrow_size,
- out_size=out_size, type_size=type_size)
-
- title = u' ComputationalGraph {} discrete operator report '.format(self.pretty_name.decode('utf-8'))
+ i, opname, inputs, arrow, outputs, optype,
+ isize=isize,
+ name_size=name_size, in_size=in_size,
+ arrow_size=arrow_size,
+ out_size=out_size, type_size=type_size)
+
+ title = u'ComputationalGraph {} discrete operator report '.format(
+ self.pretty_name.decode('utf-8'))
return u'\n{}\n'.format(framed_str(title=title, msg=ss)).encode('utf-8')
def get_domains(self):
@@ -472,10 +544,11 @@ class ComputationalGraph(ComputationalGraphNode):
def available_methods(self):
avail_methods = {}
if not self.nodes:
- msg=u'No nodes present in ComputationalGraph {}.'.format(self.pretty_name.decode('utf-8'))
+ msg = u'No nodes present in ComputationalGraph {}.'.format(
+ self.pretty_name.decode('utf-8'))
raise RuntimeError(msg.encode('utf-8'))
for node in self.nodes:
- for (k,v) in node.available_methods().iteritems():
+ for (k, v) in node.available_methods().iteritems():
v = to_set(v)
if (k in avail_methods):
avail_methods[k].update(v)
@@ -488,10 +561,10 @@ class ComputationalGraph(ComputationalGraphNode):
@debug
def initialize(self,
- is_root=True,
- topgraph_method=None,
- outputs_are_inputs=False,
- **kwds):
+ is_root=True,
+ topgraph_method=None,
+ outputs_are_inputs=False,
+ **kwds):
if self.initialized:
return
self.is_root = is_root
@@ -499,7 +572,7 @@ class ComputationalGraph(ComputationalGraphNode):
if is_root:
self.pre_initialize(**kwds)
- msg=u'ComputationalGraph {} is empty.'
+ msg = u'ComputationalGraph {} is empty.'
assert len(self.nodes) > 0, msg.format(self.pretty_name.decode('utf-8')).encode('utf-8')
for node in self.nodes:
@@ -537,7 +610,7 @@ class ComputationalGraph(ComputationalGraphNode):
self.handle_topologies(self.input_topology_states, self.output_topology_states)
self.check()
- self.initialized=True
+ self.initialized = True
if is_root:
self.post_initialize(**kwds)
@@ -545,25 +618,24 @@ class ComputationalGraph(ComputationalGraphNode):
def check(self):
super(ComputationalGraph, self).check()
reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
- op.check()
+ for node in self.nodes:
+ node.check()
@debug
def get_field_requirements(self):
requirements = super(ComputationalGraph, self).get_field_requirements()
+ if (self.is_root and __VERBOSE__) or __DEBUG__ or self.__FORCE_REPORTS__:
+ print self.node_requirements_report(requirements)
for node in self.nodes:
node_requirements = node.get_and_set_field_requirements()
requirements.update(node_requirements)
- if ((self.is_root and __VERBOSE__) or __DEBUG__ or self.__FORCE_REPORTS__):
+ if (self.is_root and __VERBOSE__) or __DEBUG__ or self.__FORCE_REPORTS__:
print self.field_requirements_report(requirements)
return requirements
@debug
def handle_topologies(self, input_topology_states, output_topology_states):
- from hysop.problem import Problem
+ from hysop.problem import Problem
# do not call super method
for node in self.nodes:
assert isinstance(node, ComputationalGraphOperator) or isinstance(node, Problem)
@@ -572,7 +644,7 @@ class ComputationalGraph(ComputationalGraphNode):
assert (node._field_requirements is not None)
if not isinstance(node, Problem):
node.handle_topologies(input_topology_states[node], output_topology_states[node])
- node.input_topology_states = input_topology_states[node]
+ node.input_topology_states = input_topology_states[node]
node.output_topology_states = output_topology_states[node]
self.topology_handled = True
@@ -585,12 +657,12 @@ class ComputationalGraph(ComputationalGraphNode):
builder = GraphBuilder(node=self)
builder.configure(current_level=current_level,
- outputs_are_inputs=outputs_are_inputs, **kwds)
+ outputs_are_inputs=outputs_are_inputs, **kwds)
builder.build_graph()
input_fields = builder.input_fields
output_fields = builder.output_fields
- candidate_input_tensors = self.candidate_input_tensors
+ candidate_input_tensors = self.candidate_input_tensors
candidate_output_tensors = self.candidate_output_tensors
input_tensor_fields = ()
@@ -610,15 +682,15 @@ class ComputationalGraph(ComputationalGraphNode):
input_params=builder.input_params,
output_params=builder.output_params)
- self.graph = builder.graph
+ self.graph = builder.graph
self.reduced_graph = builder.reduced_graph
- self.sorted_nodes = builder.sorted_nodes
- self.nodes = builder.nodes
- self.input_topology_states = builder.op_input_topology_states
+ self.sorted_nodes = builder.sorted_nodes
+ self.nodes = builder.nodes
+ self.input_topology_states = builder.op_input_topology_states
self.output_topology_states = builder.op_output_topology_states
self.initial_input_topology_states = builder.input_topology_states
- self.final_output_topology_states = builder.output_topology_states
+ self.final_output_topology_states = builder.output_topology_states
self.level = current_level
@@ -630,86 +702,94 @@ class ComputationalGraph(ComputationalGraphNode):
print self.variable_report()
print self.operator_report()
- @debug
- @graph_built
- def display(self, visu_rank=0, vertex_font_size=10, edge_font_size=16):
+ def display(self, visu_rank=0, show_buttons=False):
"""
Display the reduced computational graph.
"""
from hysop import main_rank
if (visu_rank is None) or (main_rank != visu_rank):
return
+
+ net = self.to_pyvis()
+
+ import tempfile
+ with tempfile.NamedTemporaryFile(suffix='.html') as f:
+ net.show(f.name)
+
+ def to_html(self, path, io_rank=0, show_buttons=False):
+ """
+ Generate an interactive computational graph in an html file.
+ """
+ from hysop import main_rank
+ if (io_rank is None) or (main_rank != io_rank):
+ return
+
+ net = self.to_pyvis()
+ net.write_html(path)
+
+ @graph_built
+ def to_pyvis(self, width=None, height=None, with_custom_nodes=True):
+ """
+ Convert the graph to a pyvis network for vizualization.
+ """
+ try:
+ import pyvis, matplotlib
+ except ImportError:
+ msg='\nFATAL ERROR: Graph vizualization requires pyvis and matplotlib.\n'
+ print(msg)
+ raise
+
+ width = first_not_None(width, 1920)
+ height = first_not_None(height, 1080)
+
+ graph = self.reduced_graph
+ network = pyvis.network.Network(directed=True, width=width, height=height)
+ known_nodes = set()
+
+ def add_node(node):
+ node_id = int(node)
+ if node_id not in known_nodes:
+ network.add_node(node_id, label=node.label,
+ title=node.title, color=node.color,
+ shape=node.shape(with_custom_nodes))
+ known_nodes.add(node_id)
+
+ def add_edge(from_node, to_node):
+ from_node_id = int(from_node)
+ to_node_id = int(to_node)
+ edge = graph[from_node][to_node]
+ network.add_edge(from_node_id, to_node_id,
+ title=str(edge.get('data', 'no edge data')))
+
+ for node in graph:
+ add_node(node)
+ for out_node in graph[node]:
+ add_node(out_node)
+ add_edge(node, out_node)
+
+ return network
- graph = self.reduced_graph
- edge_text = graph.edge_properties['var_names']
- vertex_text = graph.vertex_properties['op_pnames']
- vertex_info = graph.vertex_properties['op_info']
- if 'command_queues' in graph.vp:
- command_queues = graph.vertex_properties['command_queues']
- active_ops = graph.vertex_properties['active_ops']
- else:
- command_queues = None
- active_ops = None
-
- def draw():
- import time
- from gi.repository import Gtk, GObject
- from graph_tool.draw import GraphWindow, sfdp_layout
-
- pos_layout = sfdp_layout(graph)
-
- win = GraphWindow(graph, pos_layout, geometry=(800,600),
- vertex_text = vertex_text,
- edge_text = edge_text,
- vertex_font_size = vertex_font_size,
- edge_font_size = edge_font_size,
- vertex_color = active_ops,
- vertex_fill_color = command_queues,
- display_props=vertex_info,
- display_props_size=14,
- max_render_time=50)
-
- def update_window():
- win.graph.regenerate_surface()
- win.graph.queue_draw()
- time.sleep(0.01)
- return True
-
- GObject.idle_add(update_window)
- win.connect("delete_event", Gtk.main_quit)
- win.show_all()
- Gtk.main()
- self.graph_is_rendering = False
-
- self.graph_is_rendering = True
-
- from threading import Thread
- display_thread = Thread(target=draw)
- display_thread.start()
@debug
@graph_built
def discretize(self):
if self.discretized:
return
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
- if not op.discretized:
- op.discretize()
+ for node in self.nodes:
+ if not node.discretized:
+ node.discretize()
if self.is_root:
input_discrete_fields = {}
- for (field,topo) in self.input_fields.iteritems():
+ for (field, topo) in self.input_fields.iteritems():
istate = self.initial_input_topology_states[field][1]
- istate = istate.copy(is_read_only=False) # problem inputs are writeable for initialization
+ # problem inputs are writeable for initialization
+ istate = istate.copy(is_read_only=False)
dfield = field.discretize(topo, istate)
input_discrete_fields[field] = dfield
output_discrete_fields = {}
- for field,topo in self.output_fields.iteritems():
+ for field, topo in self.output_fields.iteritems():
ostate = self.final_output_topology_states[field][1]
dfield = field.discretize(topo, ostate)
output_discrete_fields[field] = dfield
@@ -735,20 +815,20 @@ class ComputationalGraph(ComputationalGraphNode):
output_discrete_tensor_fields[tfield] = tdfield
discrete_fields = tuple(set(input_discrete_fields.values() +
- output_discrete_fields.values()))
+ output_discrete_fields.values()))
discrete_tensor_fields = tuple(set(input_discrete_tensor_fields.values() +
output_discrete_tensor_fields.values()))
else:
- input_discrete_fields = None
+ input_discrete_fields = None
output_discrete_fields = None
input_discrete_tensor_fields = None
output_discrete_tensor_fields = None
discrete_fields = None
discrete_tensor_fields = None
- self.input_discrete_fields = input_discrete_fields
+ self.input_discrete_fields = input_discrete_fields
self.output_discrete_fields = output_discrete_fields
self.input_discrete_tensor_fields = input_discrete_tensor_fields
self.output_discrete_tensor_fields = output_discrete_tensor_fields
@@ -757,24 +837,20 @@ class ComputationalGraph(ComputationalGraphNode):
self.discretized = True
-
@debug
@discretized
def get_work_properties(self):
requests = MultipleOperatorMemoryRequests()
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
- if op not in requests.operators():
- wp = op.get_work_properties()
- requests += wp
- if __DEBUG__ or (__VERBOSE__ and self.level==0) or self.__FORCE_REPORTS__:
+ for node in self.nodes:
+ if node not in requests.operators():
+ wp = node.get_work_properties()
+ requests += node.get_work_properties()
+ if __DEBUG__ or (__VERBOSE__ and self.level == 0) or self.__FORCE_REPORTS__:
srequests = requests.sreport()
ss = (srequests if (srequests != u'') else u' *no extra work requested*')
- title= u' ComputationalGraph {} work properties report '.format(self.pretty_name.decode('utf-8'))
+ title = u'ComputationalGraph {} work properties report '.format(
+ self.pretty_name.decode('utf-8'))
vprint(u'\n{}\n'.format(framed_str(title=title, msg=ss)).encode('utf-8'))
return requests
@@ -786,13 +862,9 @@ class ComputationalGraph(ComputationalGraphNode):
if (work is None):
work = self.get_work_properties()
work.allocate(allow_subbuffers=allow_subbuffers)
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
- if not op.ready:
- op.setup(work=work)
+ for node in self.nodes:
+ if not node.ready:
+ node.setup(work=work)
self.ready = True
def build(self, outputs_are_inputs=True, method=None, allow_subbuffers=False):
@@ -812,46 +884,27 @@ class ComputationalGraph(ComputationalGraphNode):
@debug
@ready
def apply(self, **kwds):
- drawing = self.graph_is_rendering
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
-
- if drawing:
- active_ops = reduced_graph.vertex_properties['active_ops']
- old_color = None
- for vid in self.sorted_nodes:
- if old_color:
- active_ops[vertex] = old_color
- vertex = reduced_graph.vertex(vid)
- old_color = active_ops[vertex]
- active_ops[vertex] = 'red'
- op = operators[vertex]
- dprint('{}.apply()'.format(op.name))
- op.apply(**kwds)
- active_ops[vertex] = old_color
- else:
- for op in self.nodes:
- dprint('{}.apply()'.format(op.name))
- op.apply(**kwds)
+ for node in self.nodes:
+ dprint('{}.apply()'.format(node.name))
+ node.apply(**kwds)
@debug
@ready
def finalize(self, **kwds):
reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
- if op.ready:
- op.finalize(**kwds)
+ for node in self.nodes:
+ if node.ready:
+ node.finalize(**kwds)
self.ready = False
@classmethod
def supports_multiple_field_topologies(cls):
return True
+
@classmethod
def supports_multiple_topologies(cls):
return True
+
@classmethod
def supports_mpi(cls):
return True
diff --git a/hysop/core/graph/computational_node.py b/hysop/core/graph/computational_node.py
index adffa2b5434ba16fcf854c3ed47dfbedff9f174f..89f7a1fe07c9206f2c4f5480dcbf77c5bd80c211 100644
--- a/hysop/core/graph/computational_node.py
+++ b/hysop/core/graph/computational_node.py
@@ -6,58 +6,61 @@ Base for directionally splitted advection solvers (pure-python and GPU version).
from abc import ABCMeta, abstractmethod
from hysop import dprint
-from hysop.deps import copy, warnings
-from hysop.tools.types import InstanceOf, to_set, check_instance, first_not_None
-from hysop.tools.io_utils import IOParams
+from hysop.deps import copy, warnings
+from hysop.tools.types import InstanceOf, to_set, check_instance, first_not_None
+from hysop.tools.io_utils import IOParams
from hysop.parameters.parameter import Parameter
from hysop.fields.continuous_field import Field, ScalarField, TensorField
from hysop.core.graph.node_requirements import NodeRequirements
-from hysop.core.graph.graph import not_implemented, wraps,\
- not_initialized, initialized, discretized, ready
+from hysop.core.graph.graph import not_implemented, wraps,\
+ not_initialized, initialized, discretized, ready
from hysop.core.graph.continuous import OperatorBase
from hysop.topology.topology import Topology, TopologyView
from hysop.tools.decorators import debug
from hysop.tools.warning import HysopWarning
-
+from hysop.topology.cartesian_descriptor import get_topo_descriptor_discretization
+
def base_initialized(f):
assert callable(f)
@wraps(f)
- def _check(*args,**kwds):
+ def _check(*args, **kwds):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self._base_initialized:
- reason='this self._init_base() has not been called yet.'
+ reason = 'this self._init_base() has not been called yet.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kwds)
+ return f(*args, **kwds)
return _check
+
def topology_handled(f):
assert callable(f)
@wraps(f)
- def _check(*args,**kwds):
+ def _check(*args, **kwds):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self.topology_handled:
- reason='this self.handle_topologies() has not been called yet.'
+ reason = 'this self.handle_topologies() has not been called yet.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kwds)
+ return f(*args, **kwds)
return _check
+
class ComputationalGraphNode(OperatorBase):
"""
Interface of an abstract computational graph node.
"""
__metaclass__ = ABCMeta
-
+
@debug
- def __init__(self, input_fields=None, output_fields=None,
- input_params=None, output_params=None,
- input_tensor_fields=None, output_tensor_fields=None,
- name=None, pretty_name=None, method=None, **kwds):
+ def __init__(self, input_fields=None, output_fields=None,
+ input_params=None, output_params=None,
+ input_tensor_fields=None, output_tensor_fields=None,
+ name=None, pretty_name=None, method=None, to_be_skipped_func=None, **kwds):
"""
Initialize a ComputationalGraphNode.
@@ -86,16 +89,16 @@ class ComputationalGraphNode(OperatorBase):
Pretty name of this node (string), optional, defaults to name.
method: dict, optional
user method specification for this graph node, optional, defaults to None.
- kwds:
+ kwds:
arguments for base classes (mpi_params and io_params).
Attributes
----------
- name: str
+ name: str
name of this node (used for printing and display purpose).
- pretty_name: str
+ pretty_name: str
Pretty name of this node (used for printing and display purpose).
- input_fields: dict
+ input_fields: dict
input fields as a dictionnary (see Notes).
output_fields: dict
output fields as a dictionnary (see Notes).
@@ -107,54 +110,54 @@ class ComputationalGraphNode(OperatorBase):
flag set after discretize() has been called.
ready: bool
flag set after setup() has been called.
-
+
method : dict(MethodKey, MethodValue)
method, set after initialize() has been called.
input_field_requirements : dict(Field, DiscreteFieldRequirements)
input constraints, set after initialize() has been called.
output_field_requirements = {}
output constraints, set after initialize() has been called.
-
+
Notes
-----
- For the input and output fields, the keys of the dicts have to be of
+ For the input and output fields, the keys of the dicts have to be of
type :class:`hysop.fields.continuous_field.Field`.
- and the values should consist of
+ and the values should consist of
:class:`hysop.topology.topology_descriptor.TopologyDescriptors` instances
ie. an already defined topology or a topology descriptor.
VectorFields and TensorFields are expanded to ScalarFields.
- For input and output parameters, the keys of the dicts can be arbitrary names that
+ For input and output parameters, the keys of the dicts can be arbitrary names that
can be used to retrieve the parameters
Giving the following keywords as inputs (in **kwds) will throw a ValueError:
input_vars, output_vars, variables, iwork, rwork, work, backend
- About the method parameter:
+ About the method parameter:
One can not directly use the method parameter after this call.
User method is put into attribute base_method awaiting the initialization step.
See ComputationalGraphNode.handle_method() to see how method is handled.
"""
should_init = (input_fields is not None) or (output_fields is not None) \
- or (input_params is not None) or (output_params is not None)
-
+ or (input_params is not None) or (output_params is not None)
+
# Check extra args
cls = self.__class__
for _ in ('variables', 'input_vars', 'output_vars'):
if _ in kwds.keys():
- msg='The \'{}\' parameter should not be used in {}, use input_fields and '
- msg +='output_fields instead.'
+ msg = 'The \'{}\' parameter should not be used in {}, use input_fields and '
+ msg += 'output_fields instead.'
msg = msg.format(_, cls)
raise ValueError(msg)
if ('iwork' in kwds) or ('rwork' in kwds) or ('work' in kwds):
- msg='work, rwork or iwork parameters can not be used before the full description \
+ msg = 'work, rwork or iwork parameters can not be used before the full description \
of the graph in class {}.'.format(cls)
raise ValueError(msg)
if ('backend' in kwds):
- msg='{} is not a ComputationalGraphNodeFrontend thus no backend can be specified.'
- msg=msg.format(cls)
+ msg = '{} is not a ComputationalGraphNodeFrontend thus no backend can be specified.'
+ msg = msg.format(cls)
raise ValueError(msg)
# Expand input and output TensorFields to ScalarFields
@@ -165,12 +168,12 @@ class ComputationalGraphNode(OperatorBase):
for tfield in input_tensor_fields:
for field in tfield:
if (field not in input_fields):
- msg='Input fields and input tensor fields mismatch.'
+ msg = 'Input fields and input tensor fields mismatch.'
raise RuntimeError(msg)
elif (input_fields is not None):
input_tensor_fields = tuple(filter(lambda x: x.is_tensor, input_fields.keys()))
- input_fields = {sfield: topod for (tfield,topod) in input_fields.iteritems()
- for sfield in tfield.fields }
+ input_fields = {sfield: topod for (tfield, topod) in input_fields.iteritems()
+ for sfield in tfield.fields}
else:
input_tensor_fields = ()
@@ -180,86 +183,86 @@ class ComputationalGraphNode(OperatorBase):
for tfield in output_tensor_fields:
for field in tfield:
if (field not in output_fields):
- msg='Output fields and output tensor fields mismatch.'
+ msg = 'Output fields and output tensor fields mismatch.'
raise RuntimeError(msg)
elif (output_fields is not None):
output_tensor_fields = tuple(filter(lambda x: x.is_tensor, output_fields.keys()))
- output_fields = {sfield: topod for (tfield,topod) in output_fields.iteritems()
- for sfield in tfield.fields }
+ output_fields = {sfield: topod for (tfield, topod) in output_fields.iteritems()
+ for sfield in tfield.fields}
else:
output_tensor_fields = ()
# Check input values
- input_fields = first_not_None(input_fields, {})
+ input_fields = first_not_None(input_fields, {})
output_fields = first_not_None(output_fields, {})
- input_params = first_not_None(input_params, {})
+ input_params = first_not_None(input_params, {})
output_params = first_not_None(output_params, {})
- method = first_not_None(method, {})
- name = first_not_None(name, self.__class__.__name__)
- pretty_name = first_not_None(pretty_name, name)
-
+ method = first_not_None(method, {})
+ name = first_not_None(name, self.__class__.__name__)
+ pretty_name = first_not_None(pretty_name, name)
+
if isinstance(pretty_name, unicode):
pretty_name = pretty_name.encode('utf-8')
-
+
if not isinstance(name, str):
- msg='name is not a string but a {}.'
+ msg = 'name is not a string but a {}.'
raise ValueError(msg.format(name.__class__))
- if not isinstance(pretty_name, (str,unicode)):
- msg='pretty_name is not a string but a {}.'
+ if not isinstance(pretty_name, (str, unicode)):
+ msg = 'pretty_name is not a string but a {}.'
raise ValueError(msg.format(name.__class__))
if not isinstance(input_fields, dict):
- msg='input_fields is not a dict but a {}.'
+ msg = 'input_fields is not a dict but a {}.'
raise ValueError(msg.format(input_fields.__class__))
if not isinstance(output_fields, dict):
- msg='output_fields is not a dict but a {}.'
+ msg = 'output_fields is not a dict but a {}.'
raise ValueError(msg.format(output_fields.__class__))
if not isinstance(input_params, dict):
input_params = to_set(input_params)
- input_params = { p.name:p for p in input_params }
+ input_params = {p.name: p for p in input_params}
if not isinstance(output_params, dict):
output_params = to_set(output_params)
- output_params = { p.name:p for p in output_params }
-
- self.name = name
- self.pretty_name = pretty_name
+ output_params = {p.name: p for p in output_params}
- self.input_fields = input_fields
- self.output_fields = output_fields
+ self.name = name
+ self.pretty_name = pretty_name
- self.input_params = input_params
- self.output_params = output_params
-
- self.input_tensor_fields = input_tensor_fields
+ self.input_fields = input_fields
+ self.output_fields = output_fields
+
+ self.input_params = input_params
+ self.output_params = output_params
+
+ self.input_tensor_fields = input_tensor_fields
self.output_tensor_fields = output_tensor_fields
self.base_method = method
- self.initialized = False
+ self.initialized = False
self.topology_handled = False
- self.discretized = False
- self.ready = False
+ self.discretized = False
+ self.ready = False
- self.input_discrete_fields = None
+ self.input_discrete_fields = None
self.output_discrete_fields = None
- self.discrete_fields = None
- self.input_discrete_tensor_fields = None
+ self.discrete_fields = None
+ self.input_discrete_tensor_fields = None
self.output_discrete_tensor_fields = None
- self.discrete_tensor_fields = None
+ self.discrete_tensor_fields = None
if not hasattr(self, '_field_requirements'):
self._field_requirements = None
# graph builder hints to build I/O operators.
- self._input_fields_to_dump = []
+ self._input_fields_to_dump = []
self._output_fields_to_dump = []
- self._input_params_to_dump = []
+ self._input_params_to_dump = []
self._output_params_to_dump = []
self._base_initialized = False
self.__kwds = kwds
-
+
if should_init:
- self._init_base(input_fields, output_fields,
+ self._init_base(input_fields, output_fields,
input_tensor_fields, output_tensor_fields,
input_params, output_params)
else:
@@ -267,10 +270,18 @@ class ComputationalGraphNode(OperatorBase):
# => defer initialization of base class until full initialization.
from hysop.core.graph.computational_graph import ComputationalGraph
check_instance(self, ComputationalGraph)
- io_params = kwds.get('io_params', True)
+ io_params = kwds.get('io_params', False)
self.io_params = io_params
self._set_io()
+ # Default function for skipping operator's apply
+ def to_be_skipped(*args, **kwargs):
+ return False
+ if to_be_skipped_func is None:
+ self.to_be_skipped = to_be_skipped
+ else:
+ self.to_be_skipped = to_be_skipped_func
+
def _get_is_domainless(self):
"""Return True if this node has no input nor output fields."""
return (not self.input_fields) and (not self.output_fields)
@@ -289,7 +300,7 @@ class ComputationalGraphNode(OperatorBase):
else:
scalar_fields += (field,)
return (scalar_fields, tensor_fields)
-
+
@debug
def _setup_method(self, topgraph_method):
"""
@@ -298,13 +309,13 @@ class ComputationalGraphNode(OperatorBase):
"""
cls = type(self)
if topgraph_method:
- base_method = self.base_method
+ base_method = self.base_method
avail_methods = self.available_methods()
extra_keys = set(topgraph_method.keys())\
- .intersection(avail_methods.keys())\
- .difference(self.base_method.keys())
+ .intersection(avail_methods.keys())\
+ .difference(self.base_method.keys())
- method = self.base_method.copy()
+ method = self.base_method.copy()
for k in extra_keys:
method[k] = topgraph_method[k]
else:
@@ -314,23 +325,23 @@ class ComputationalGraphNode(OperatorBase):
return method
@debug
- def _init_base(self, input_fields, output_fields,
- input_tensor_fields, output_tensor_fields,
- input_params, output_params):
+ def _init_base(self, input_fields, output_fields,
+ input_tensor_fields, output_tensor_fields,
+ input_params, output_params):
"""
Initialize base class and check everything.
"""
# Merge scalar and tensor fields
all_input_fields = tuple(input_tensor_fields)
for ofield in input_fields.keys():
- if not any (ofield in tf for tf in input_tensor_fields):
+ if not any(ofield in tf for tf in input_tensor_fields):
all_input_fields += (ofield,)
all_output_fields = tuple(output_tensor_fields)
for ofield in output_fields.keys():
- if not any (ofield in tf for tf in output_tensor_fields):
+ if not any(ofield in tf for tf in output_tensor_fields):
all_output_fields += (ofield,)
-
+
assert not self._base_initialized
check_instance(input_fields, dict, keys=ScalarField)
check_instance(output_fields, dict, keys=ScalarField)
@@ -341,41 +352,41 @@ class ComputationalGraphNode(OperatorBase):
check_instance(all_input_fields, tuple, values=Field)
check_instance(all_output_fields, tuple, values=Field)
- self.input_fields = input_fields
+ self.input_fields = input_fields
self.output_fields = output_fields
- self.input_params = input_params
+ self.input_params = input_params
self.output_params = output_params
self.input_tensor_fields = input_tensor_fields
self.output_tensor_fields = output_tensor_fields
-
+
ifields = set(self.input_fields.keys())
ofields = set(self.output_fields.keys())
- fields = tuple(ifields.union(ofields))
-
+ fields = tuple(ifields.union(ofields))
+
itfields = set(self.input_tensor_fields)
otfields = set(self.output_tensor_fields)
- tfields = tuple(itfields.union(otfields))
-
+ tfields = tuple(itfields.union(otfields))
+
iparams = set(self.input_params.values())
oparams = set(self.output_params.values())
parameters = tuple(iparams.union(oparams))
-
- if 'mpi_params' in self.__kwds:
+
+ if ('mpi_params' in self.__kwds) and ('ComputationalGraph' not in map(lambda c: c.__name__, self.__class__.__mro__)):
mpi_params = self.__kwds['mpi_params']
for topo in set(self.input_fields.values() + self.output_fields.values()):
if isinstance(topo, Topology) and (topo.mpi_params != mpi_params):
- msg='MPI parameters mismatch between already specified topology mpi_params '
- msg+='and operator MPI paramaters in operator {}.'.format(self.name)
- msg+='\n *operator: {}'.format(mpi_params)
- msg+='\n *field: {}'.format(topo.mpi_params)
- msg+='\n'
+ msg = 'MPI parameters mismatch between already specified topology mpi_params '
+ msg += 'and operator MPI paramaters in operator {}.'.format(self.name)
+ msg += '\n *operator: {}'.format(mpi_params)
+ msg += '\n *field: {}'.format(topo.mpi_params)
+ msg += '\n'
raise RuntimeError(msg)
-
- super(ComputationalGraphNode, self).__init__(name=self.name,
- fields=fields,
- tensor_fields=tfields,
- parameters=parameters,
- **self.__kwds)
+
+ super(ComputationalGraphNode, self).__init__(name=self.name,
+ fields=fields,
+ tensor_fields=tfields,
+ parameters=parameters,
+ **self.__kwds)
self._base_initialized = True
self.all_input_fields = all_input_fields
self.all_output_fields = all_output_fields
@@ -391,30 +402,30 @@ class ComputationalGraphNode(OperatorBase):
method.update(user_method)
available_methods = self.available_methods()
- for (k,v) in method.iteritems():
+ for (k, v) in method.iteritems():
if k not in available_methods.keys():
- msg='{} is not an available method key for computational node {}.'
+ msg = '{} is not an available method key for computational node {}.'
msg = msg.format(k, self.name)
warnings.warn(msg, HysopWarning)
continue
-
+
available = to_set(available_methods[k])
- instances = set(x for x in available if isinstance(x,InstanceOf))
+ instances = set(x for x in available if isinstance(x, InstanceOf))
available = available.difference(instances)
-
- good=False
+
+ good = False
for instance in instances:
if instance.match_instance(v):
- good=True
+ good = True
break
good = good or (v in available)
if (not good):
- msg='{} is not an available method value for key {},'.format(v, k.__name__)
- msg+='\n possible values are {}.'.format(available_methods[k])
+ msg = '{} is not an available method value for key {},'.format(v, k.__name__)
+ msg += '\n possible values are {}.'.format(available_methods[k])
raise ValueError(msg)
return method
-
+
@debug
@base_initialized
def check(self):
@@ -425,7 +436,7 @@ class ComputationalGraphNode(OperatorBase):
self._check_variables()
self._check_topologies()
self._check_support()
-
+
@debug
@base_initialized
def _check_variables(self):
@@ -434,14 +445,14 @@ class ComputationalGraphNode(OperatorBase):
Called automatically in ComputationalGraphNode.check()
"""
for variables in [self.input_fields, self.output_fields]:
- for (k,v) in variables.iteritems():
- if not isinstance(k,Field):
- msg = 'Given key is not a continuous Field (got a {}).'
+ for (k, v) in variables.iteritems():
+ if not isinstance(k, Field):
+ msg = 'Given key is not a continuous Field (got a {}).'
raise TypeError(msg.format(k.__class__))
if not isinstance(v, TopologyView):
- msg='Expected a Topology instance but got a {}.'.format(v.__class__)
- msg+='\nAll topologies are expected to be set after '
- msg+='ComputationalGraph.get_field_requirements() has been called.'
+ msg = 'Expected a Topology instance but got a {}.'.format(v.__class__)
+ msg += '\nAll topologies are expected to be set after '
+ msg += 'ComputationalGraph.get_field_requirements() has been called.'
raise TypeError(msg)
@debug
@@ -456,11 +467,11 @@ class ComputationalGraphNode(OperatorBase):
_multi_topo_fields (list of field that have at least two different topologies)
Called automatically in ComputationalGraphNode.check()
"""
- is_distributed = (self.mpi_params.size > 1)
- has_multiple_topologies = False
+ is_distributed = (self.mpi_params.size > 1)
+ has_multiple_topologies = False
has_multiple_field_topologies = False
multi_topo_fields = set()
-
+
topos = (self.input_fields.values()+self.output_fields.values())
if topos:
topo_ref = topos[0].topology
@@ -475,16 +486,16 @@ class ComputationalGraphNode(OperatorBase):
multi_topo_fields.add(ifield)
has_multiple_field_topologies = True
- self._is_distributed = is_distributed
- self._has_multiple_topologies = has_multiple_topologies
+ self._is_distributed = is_distributed
+ self._has_multiple_topologies = has_multiple_topologies
self._has_multiple_field_topologies = has_multiple_field_topologies
- self._multi_topo_fields = multi_topo_fields
-
+ self._multi_topo_fields = multi_topo_fields
+
@debug
@base_initialized
def _check_support(self):
"""
- Check input and output variables topologies against the supported topologies of
+ Check input and output variables topologies against the supported topologies of
this node.
See ComputationalGraphNode.supports_multiple_topologies()
@@ -495,29 +506,29 @@ class ComputationalGraphNode(OperatorBase):
cls = self.__class__
if (self._has_multiple_field_topologies) and \
(not cls.supports_multiple_field_topologies()):
- msg='Graph operator \'{}\' does not support multiple topologies yet.'
- msg+= '\nTopology mismatch for continuous variable(s) {} between '
- msg+= 'input and output variables.'
- msg=msg.format(self.name, [f.name for f in self._multi_topo_fields])
+ msg = 'Graph operator \'{}\' does not support multiple topologies yet.'
+ msg += '\nTopology mismatch for continuous variable(s) {} between '
+ msg += 'input and output variables.'
+ msg = msg.format(self.name, [f.name for f in self._multi_topo_fields])
raise NotImplementedError(msg)
if (self._has_multiple_topologies) and \
(not cls.supports_multiple_topologies()):
- msg='Graph operator {} does not support multiple field topologies yet.'
- msg=msg.format(self.node_tag)
- msg+='\n>Input topologies:'
+ msg = 'Graph operator {} does not support multiple field topologies yet.'
+ msg = msg.format(self.node_tag)
+ msg += '\n>Input topologies:'
for (field, topo) in self.input_fields.iteritems():
- msg+='\n *{} -> {}'.format(field.short_description(), topo.short_description())
- msg+='\n>Output topologies:'
+ msg += '\n *{} -> {}'.format(field.short_description(), topo.short_description())
+ msg += '\n>Output topologies:'
for (field, topo) in self.output_fields.iteritems():
- msg+='\n *{} -> {}'.format(field.short_description(), topo.short_description())
+ msg += '\n *{} -> {}'.format(field.short_description(), topo.short_description())
raise NotImplementedError(msg)
if (self._is_distributed) and (not cls.supports_mpi()):
- msg='\nMPI multi-process has not been implemented in graph operator \'{}\' yet!\n'
- msg=msg.format(type(self))
+ msg = '\nMPI multi-process has not been implemented in graph operator \'{}\' yet!\n'
+ msg = msg.format(type(self))
raise NotImplementedError(msg)
-
-## ComputationalGraphNode interface
+
+# ComputationalGraphNode interface
@base_initialized
def get_topologies(self):
"""
@@ -532,7 +543,7 @@ class ComputationalGraphNode(OperatorBase):
def get_domains(self):
"""
Returns all the domains used in this operator.
- Domains are keys and values are operators that have variables
+ Domains are keys and values are operators that have variables
defined on this domain.
If this node has no domain (ie. no input or output variables),
if fills the 'None' domain.
@@ -550,7 +561,7 @@ class ComputationalGraphNode(OperatorBase):
Returns all the backends used in this operator as a set.
"""
return self.get_topologies().keys()
-
+
@abstractmethod
def available_methods(self):
"""
@@ -561,7 +572,7 @@ class ComputationalGraphNode(OperatorBase):
class types. This is used to check user method input.
"""
pass
-
+
@abstractmethod
def default_method(self):
"""
@@ -571,20 +582,20 @@ class ComputationalGraphNode(OperatorBase):
a default value for this key will be extracted from the default one.
"""
pass
-
+
@debug
def handle_method(self, method):
"""
Method automatically called during initialization.
This allow to extract method values after method preprocessing.
Method preprocessing means:
- 1) complete user input with compatible top graph user inputs
+ 1) complete user input with compatible top graph user inputs
2) complete the resulting dictionnary with the node default_method
3) check method against available_methods.
The result of this process is fed as argument of this function.
"""
- self.method = {k:v for (k,v) in method.iteritems()}
-
+ self.method = {k: v for (k, v) in method.iteritems()}
+
@abstractmethod
@debug
def get_field_requirements(self):
@@ -593,7 +604,7 @@ class ComputationalGraphNode(OperatorBase):
Topology requirements are:
1) min and max ghosts for each input and output variables
2) allowed splitting directions for cartesian topologies
- 3) required local and global transposition state, if any.
+ 3) required local and global transposition state, if any.
and more
They are stored in self.input_field_requirements and
self.output_field_requirements.
@@ -608,7 +619,7 @@ class ComputationalGraphNode(OperatorBase):
def get_node_requirements(self):
"""Called after get_field_requirements to get global node requirements."""
return NodeRequirements(self)
-
+
@debug
def get_and_set_field_requirements(self):
"""
@@ -619,7 +630,7 @@ class ComputationalGraphNode(OperatorBase):
assert (field_requirements is not None)
self._field_requirements = field_requirements
- node_requirements = self.get_node_requirements()
+ node_requirements = self.get_node_requirements()
assert isinstance(node_requirements, NodeRequirements)
self._node_requirements = field_requirements
@@ -633,9 +644,9 @@ class ComputationalGraphNode(OperatorBase):
"""
freqs = self._field_requirements
if (freqs is None):
- msg='{}.get_and_set_field_requirements() has not been called yet '
- msg+='on node {}.'
- msg=msg.format(type(self).__name__, self.name)
+ msg = '{}.get_and_set_field_requirements() has not been called yet '
+ msg += 'on node {}.'
+ msg = msg.format(type(self).__name__, self.name)
raise RuntimeError(msg)
return self._field_requirements.input_field_requirements
@@ -645,22 +656,22 @@ class ComputationalGraphNode(OperatorBase):
"""
freqs = self._field_requirements
if (freqs is None):
- msg='{}.get_and_set_field_requirements() has not been called yet '
- msg+='on node {}.'
- msg=msg.format(type(self).__name__, self.name)
+ msg = '{}.get_and_set_field_requirements() has not been called yet '
+ msg += 'on node {}.'
+ msg = msg.format(type(self).__name__, self.name)
raise RuntimeError(msg)
return freqs.output_field_requirements
-
- input_field_requirements = property(get_input_field_requirements)
- output_field_requirements = property(get_output_field_requirements)
-
+
+ input_field_requirements = property(get_input_field_requirements)
+ output_field_requirements = property(get_output_field_requirements)
+
@debug
def handle_topologies(self, input_topology_states,
- output_topology_states):
+ output_topology_states):
"""
Called after all topologies have been set up.
- Topologies are available as values of self.input_fields
+ Topologies are available as values of self.input_fields
and self.output_fields and are mapped by continuous Field.
In addition input_topology_states are passed as argument
@@ -682,17 +693,22 @@ class ComputationalGraphNode(OperatorBase):
for tfield in tfields:
if field in tfield:
return variables[tfield]
- msg='Could not find any topology descriptor corresponding to field {}.'
- msg=msg.format(field.short_description())
+ msg = 'Could not find any topology descriptor corresponding to field {}.'
+ msg = msg.format(field.short_description())
raise KeyError(msg)
-
+
+ @classmethod
+ def get_topo_discretization(cls, variables, field):
+ topo = cls.get_topo_descriptor(variables=variables, field=field)
+ return get_topo_descriptor_discretization(topo)
+
@classmethod
def supports_multiple_topologies(cls):
"""
Should return True if this node supports multiple topologies.
"""
return True
-
+
@classmethod
def supports_multiple_field_topologies(cls):
"""
@@ -701,7 +717,7 @@ class ComputationalGraphNode(OperatorBase):
This is usefull in Redistribute like operators.
If this returns True this implies supports_multiple_topologies().
It also implies that self.variables[field] may return a set of topologies.
- In this case one can recover input and output topologies by using
+ In this case one can recover input and output topologies by using
self.input_fields[field] and self.output_fields[field].
In addition one can find such fields by using the list self.multi_topo_fields
which is set after ComputationalGraphNode.initialize() has been called.
@@ -714,7 +730,7 @@ class ComputationalGraphNode(OperatorBase):
Return True if this operator was implemented to support multiple mpi processes.
"""
return False
-
+
@debug
def pre_initialize(self, **kwds):
"""
@@ -725,7 +741,7 @@ class ComputationalGraphNode(OperatorBase):
"""
pass
- @debug
+ @debug
def post_initialize(self, **kwds):
"""
Function called after initialization,
@@ -738,11 +754,11 @@ class ComputationalGraphNode(OperatorBase):
def initialize(self, topgraph_method=None, **kwds):
"""
Initialize this node.
-
+
Initialization step sets the following variables:
- *self.method,
- *self.input_field_requirements
- *self.output_field_requirements
+ *self.method,
+ *self.input_field_requirements
+ *self.output_field_requirements
*self.initialized
It returns self.method.
@@ -753,25 +769,25 @@ class ComputationalGraphNode(OperatorBase):
self.get_field_requirements()
self._initialized = True
self.post_initialize()
-
+
See ComputationalGraphNode.handle_method() to see how user method is handled.
See ComputationalGraphNode.get_field_requirements() to see how topology requirements
are handled.
-
+
After this method has been handled by all operators, initialization collects min and max
ghosts required by each operators which will be usefull in the discretiezation step
to automatically build topologies or check against user supplied topologies.
- This function also sets the self.initialized flag to True (just before post
+ This function also sets the self.initialized flag to True (just before post
initialization).
Once this flag is set one may call ComputationalGraphNode.discretize().
"""
if self.initialized:
return
-
+
method = self._setup_method(topgraph_method)
self.handle_method(method)
- self.initialized=True
+ self.initialized = True
return method
@@ -781,11 +797,11 @@ class ComputationalGraphNode(OperatorBase):
"""
Discretize this operator.
By default this just sets the self.discretized flag to True.
- Once this flag is set one may call ComputationalGraphNode.get_work_properties() and
+ Once this flag is set one may call ComputationalGraphNode.get_work_properties() and
ComputationalGraphNode.setup().
"""
self.discretized = True
-
+
@discretized
def get_input_discrete_field(self, field):
"""
@@ -796,24 +812,24 @@ class ComputationalGraphNode(OperatorBase):
check_instance(field, Field)
if (self.input_discrete_fields is None):
- msg='{}(name={}) \n => Discretization did not set self.input_discrete_fields.'
- msg=msg.format(self.full_tag, self.name)
+ msg = '{}(name={}) \n => Discretization did not set self.input_discrete_fields.'
+ msg = msg.format(self.full_tag, self.name)
raise RuntimeError(msg)
if (self.input_discrete_tensor_fields is None):
- msg='{}(name={}) \n => Discretization did not set self.input_discrete_tensor_fields.'
- msg=msg.format(self.full_tag, self.name)
+ msg = '{}(name={}) \n => Discretization did not set self.input_discrete_tensor_fields.'
+ msg = msg.format(self.full_tag, self.name)
raise RuntimeError(msg)
if field.is_tensor:
if (field not in self.input_tensor_fields):
- msg="{} is not a registered input TensorField for graph node:\n{}"
- msg=msg.format(field.short_description(), self.long_description())
+ msg = "{} is not a registered input TensorField for graph node:\n{}"
+ msg = msg.format(field.short_description(), self.long_description())
raise RuntimeError(msg)
return self.input_discrete_tensor_fields[field]
else:
if (field not in self.input_fields):
- msg="{} is not a registered input ScalarField for graph node:\n{}"
- msg=msg.format(field.short_description(), self.long_description())
+ msg = "{} is not a registered input ScalarField for graph node:\n{}"
+ msg = msg.format(field.short_description(), self.long_description())
raise RuntimeError(msg)
return self.input_discrete_fields[field]
@@ -827,31 +843,31 @@ class ComputationalGraphNode(OperatorBase):
check_instance(field, Field)
if (self.output_discrete_fields is None):
- msg='{}(name={}) \n => Discretization did not set self.output_discrete_fields.'
- msg=msg.format(self.full_tag, self.name)
+ msg = '{}(name={}) \n => Discretization did not set self.output_discrete_fields.'
+ msg = msg.format(self.full_tag, self.name)
raise RuntimeError(msg)
if (self.output_discrete_tensor_fields is None):
- msg='{}(name={}) \n => Discretization did not set self.output_discrete_tensor_fields.'
- msg=msg.format(self.full_tag, self.name)
+ msg = '{}(name={}) \n => Discretization did not set self.output_discrete_tensor_fields.'
+ msg = msg.format(self.full_tag, self.name)
raise RuntimeError(msg)
if field.is_tensor:
if (field not in self.output_tensor_fields):
- msg="{} is not a registered output TensorField for graph node:\n{}"
- msg=msg.format(field.short_description(), self.long_description())
+ msg = "{} is not a registered output TensorField for graph node:\n{}"
+ msg = msg.format(field.short_description(), self.long_description())
raise RuntimeError(msg)
return self.output_discrete_tensor_fields[field]
else:
if (field not in self.output_fields):
- msg="{} is not a registered output ScalarField for graph node:\n{}"
- msg=msg.format(field.short_description(), self.long_description())
+ msg = "{} is not a registered output ScalarField for graph node:\n{}"
+ msg = msg.format(field.short_description(), self.long_description())
raise RuntimeError(msg)
return self.output_discrete_fields[field]
-
+
@base_initialized
- def iter_input_fields(self, with_scalars=True,
- with_tensors=True,
- as_scalars=False):
+ def iter_input_fields(self, with_scalars=True,
+ with_tensors=True,
+ as_scalars=False):
"""
Iterate over all input fields.
By default iterate over all tensors and scalars unless
@@ -861,8 +877,8 @@ class ComputationalGraphNode(OperatorBase):
"""
assert with_scalars or with_tensors, 'iterating over nothing'
input_scalar_fields_from_tensors = set(field
- for tfield in self.input_tensor_fields
- for field in tfield.fields)
+ for tfield in self.input_tensor_fields
+ for field in tfield.fields)
if with_tensors and (not as_scalars):
for tfield in self.input_tensor_fields:
@@ -879,9 +895,9 @@ class ComputationalGraphNode(OperatorBase):
yield field
@base_initialized
- def iter_output_fields(self, with_scalars=True,
- with_tensors=True,
- as_scalars=False):
+ def iter_output_fields(self, with_scalars=True,
+ with_tensors=True,
+ as_scalars=False):
"""
Iterate over all output fields.
By default iterate over all tensors and scalars unless
@@ -891,8 +907,8 @@ class ComputationalGraphNode(OperatorBase):
"""
assert with_scalars or with_tensors, 'iterating over nothing'
output_scalar_fields_from_tensors = set(field
- for tfield in self.output_tensor_fields
- for field in tfield.fields)
+ for tfield in self.output_tensor_fields
+ for field in tfield.fields)
if with_tensors and (not as_scalars):
for tfield in self.output_tensor_fields:
@@ -909,9 +925,9 @@ class ComputationalGraphNode(OperatorBase):
yield field
@discretized
- def iter_input_discrete_fields(self, with_scalars=True,
- with_tensors=True,
- as_scalars=False):
+ def iter_input_discrete_fields(self, with_scalars=True,
+ with_tensors=True,
+ as_scalars=False):
"""
Iterate over all input (field, discrete_field) pairs.
By default iterate over all tensors and scalars unless
@@ -921,8 +937,8 @@ class ComputationalGraphNode(OperatorBase):
"""
assert with_scalars or with_tensors, 'iterating over nothing'
input_scalar_fields_from_tensors = set(field
- for tfield in self.input_tensor_fields
- for field in tfield.fields)
+ for tfield in self.input_tensor_fields
+ for field in tfield.fields)
if with_tensors and (not as_scalars):
for (tfield, tdfield) in self.input_discrete_tensor_fields.iteritems():
@@ -939,9 +955,9 @@ class ComputationalGraphNode(OperatorBase):
yield (field, dfield)
@discretized
- def iter_output_discrete_fields(self, with_scalars=True,
- with_tensors=True,
- as_scalars=False):
+ def iter_output_discrete_fields(self, with_scalars=True,
+ with_tensors=True,
+ as_scalars=False):
"""
Iterate over all output (field, discrete_field) pairs.
By default iterate over all tensors and scalars unless
@@ -951,8 +967,8 @@ class ComputationalGraphNode(OperatorBase):
"""
assert with_scalars or with_tensors, 'iterating over nothing'
output_scalar_fields_from_tensors = set(field
- for tfield in self.output_tensor_fields
- for field in tfield.fields)
+ for tfield in self.output_tensor_fields
+ for field in tfield.fields)
if with_tensors and (not as_scalars):
for (tfield, tdfield) in self.output_discrete_tensor_fields.iteritems():
@@ -974,20 +990,20 @@ class ComputationalGraphNode(OperatorBase):
"""
Returns extra memory requirements of this node.
This allows operators to request for temporary buffers
- that will be shared between operators in a graph to reduce
+ that will be shared between operators in a graph to reduce
the memory footprint and the number of allocations.
By default this returns None, meanning that this node requires
no extra buffers.
"""
return None
-
+
@debug
@discretized
def setup(self, work):
"""
Setup temporary buffer that have been requested in get_work_properties().
This function may be used to execute post allocation routines.
- This sets self.ready flag to True.
+ This sets self.ready flag to True.
Once this flag is set one may call ComputationalGraphNode.apply() and
ComputationalGraphNode.finalize().
"""
@@ -1001,7 +1017,7 @@ class ComputationalGraphNode(OperatorBase):
Applies this node (operator, computational graph operator...).
"""
pass
-
+
@debug
@ready
def finalize(self, **kwds):
@@ -1011,13 +1027,13 @@ class ComputationalGraphNode(OperatorBase):
"""
self.ready = False
- def dump_inputs(self, fields=None, io_params=None,
- filename=None, frequency=None, fileformat=None, io_leader=None,
- **op_kwds):
+ def dump_inputs(self, fields=None, io_params=None,
+ filename=None, frequency=None, fileformat=None, io_leader=None,
+ **op_kwds):
"""
Tell this operator to dump some of its inputs before
apply is called.
-
+
Target folder, file, dump frequency and other io pameters
are passed trough io_params or as keywords.
"""
@@ -1025,46 +1041,46 @@ class ComputationalGraphNode(OperatorBase):
if (fields is not None):
if isinstance(fields, Field):
fields = (fields,)
- check_instance(fields, (set,list,tuple), values=Field)
+ check_instance(fields, (set, list, tuple), values=Field)
if self._base_initialized:
for field in fields:
- if ((field not in self.input_fields) and \
- (field not in self.input_tensor_fields)):
- msg='Field {} is not an input field of operator {}.'
- msg=msg.format(field.name, self.name)
+ if ((field not in self.input_fields) and
+ (field not in self.input_tensor_fields)):
+ msg = 'Field {} is not an input field of operator {}.'
+ msg = msg.format(field.name, self.name)
raise RuntimeError(msg)
else:
assert self._base_initialized, self.name
fields = self.all_input_fields
- fields = list(sorted(fields, key=lambda f:f.name))
+ fields = list(sorted(fields, key=lambda f: f.name))
if (io_params is None):
- io_params = self.io_params
-
+ io_params = self.io_params
+
if (io_params is None):
- msg='io_params was never set for operator {}.'.format(self.name)
+ msg = 'io_params was never set for operator {}, please pass io_params to dump_inputs().'.format(self.name)
raise RuntimeError(msg)
-
+
frequency = first_not_None(frequency, io_params.frequency)
fileformat = first_not_None(fileformat, io_params.fileformat)
io_leader = first_not_None(io_leader, io_params.io_leader)
-
+
if (filename is not None):
pass
elif (fields is None):
- filename='{}_in'.format(io_params.filename)
+ filename = '{}_in'.format(io_params.filename)
else:
- filename='{}_{}'.format(io_params.filename,
- '_'.join('{}in'.format(f.name) for f in fields))
+ filename = '{}_{}'.format(io_params.filename,
+ '_'.join('{}in'.format(f.name) for f in fields))
- io_params = IOParams(filename=filename, frequency=frequency,
- fileformat=fileformat, io_leader=io_leader)
+ io_params = IOParams(filename=filename, frequency=frequency,
+ fileformat=fileformat, io_leader=io_leader)
self._input_fields_to_dump.append((fields, io_params, op_kwds))
-
- def dump_outputs(self, fields=None, io_params=None,
- filename=None, frequency=None, fileformat=None, io_leader=None,
- **op_kwds):
+
+ def dump_outputs(self, fields=None, io_params=None,
+ filename=None, frequency=None, fileformat=None, io_leader=None,
+ **op_kwds):
"""
Tell this operator to dump some of its outputs after
apply is called.
@@ -1077,40 +1093,40 @@ class ComputationalGraphNode(OperatorBase):
if (fields is not None):
if isinstance(fields, Field):
fields = (fields,)
- check_instance(fields, (set,list,tuple), values=Field)
+ check_instance(fields, (set, list, tuple), values=Field)
if self._base_initialized:
for field in fields:
- if ((field not in self.output_fields) and \
- (field not in self.output_tensor_fields)):
- msg='Field {} is not an output field of operator {}.'
- msg=msg.format(field.name, self.name)
+ if ((field not in self.output_fields) and
+ (field not in self.output_tensor_fields)):
+ msg = 'Field {} is not an output field of operator {}.'
+ msg = msg.format(field.name, self.name)
raise RuntimeError(msg)
else:
fields = self.all_output_fields
- fields = list(sorted(fields, key=lambda f:f.name))
-
+ fields = list(sorted(fields, key=lambda f: f.name))
+
if (io_params is None):
- io_params = self.io_params
-
+ io_params = self.io_params
+
if (io_params is None):
- msg='io_params was never set for operator {}.'.format(self.name)
+ msg = 'io_params was never set for operator {}.'.format(self.name)
raise RuntimeError(msg)
-
- frequency = first_not_None(frequency, io_params.frequency)
+
+ frequency = first_not_None(frequency, io_params.frequency)
fileformat = first_not_None(fileformat, io_params.fileformat)
- io_leader = first_not_None(io_leader, io_params.io_leader)
-
+ io_leader = first_not_None(io_leader, io_params.io_leader)
+
if (filename is not None):
pass
elif (fields is None):
- filename='{}_out'.format(io_params.filename)
+ filename = '{}_out'.format(io_params.filename)
else:
- filename='{}_{}'.format(io_params.filename,
- '_'.join('{}out'.format(f.name) for f in fields))
+ filename = '{}_{}'.format(io_params.filename,
+ '_'.join('{}out'.format(f.name) for f in fields))
+
+ io_params = IOParams(filename=filename, frequency=frequency,
+ fileformat=fileformat, io_leader=io_leader)
- io_params = IOParams(filename=filename, frequency=frequency,
- fileformat=fileformat, io_leader=io_leader)
-
self._output_fields_to_dump.append((fields, io_params, op_kwds))
@property
@@ -1121,45 +1137,45 @@ class ComputationalGraphNode(OperatorBase):
some operators may have the same name.
"""
return '{}::{}'.format(self.__class__.__name__, self.name)
-
+
def long_description(self):
sep = '\n *'
- ss='{}[name={}, pname:{}]'
- ss=ss.format(self.full_tag, self.name, self.pretty_name)
- ss+='\n INPUT FIELDS:{}'
+ ss = '{}[name={}, pname:{}]'
+ ss = ss.format(self.full_tag, self.name, self.pretty_name)
+ ss += '\n INPUT FIELDS:{}'
if self.input_fields:
- ss = ss.format(sep + sep.join(f.short_description()
- for f in self.input_fields.keys()))
+ ss = ss.format(sep + sep.join(f.short_description()
+ for f in self.input_fields.keys()))
else:
ss = ss.format(' None')
- ss+='\n OUTPUT FIELDS:{}'
+ ss += '\n OUTPUT FIELDS:{}'
if self.output_fields:
- ss = ss.format(sep + sep.join(f.short_description()
- for f in self.output_fields.keys()))
+ ss = ss.format(sep + sep.join(f.short_description()
+ for f in self.output_fields.keys()))
else:
ss = ss.format(' None')
- ss+='\n INPUT TENSOR FIELDS:{}'
+ ss += '\n INPUT TENSOR FIELDS:{}'
if self.input_tensor_fields:
- ss = ss.format(sep + sep.join(f.short_description()
- for f in self.input_tensor_fields))
+ ss = ss.format(sep + sep.join(f.short_description()
+ for f in self.input_tensor_fields))
else:
ss = ss.format(' None')
- ss+='\n OUTPUT TENSOR FIELDS:{}'
+ ss += '\n OUTPUT TENSOR FIELDS:{}'
if self.output_tensor_fields:
- ss = ss.format(sep + sep.join(f.short_description()
- for f in self.output_tensor_fields))
+ ss = ss.format(sep + sep.join(f.short_description()
+ for f in self.output_tensor_fields))
else:
ss = ss.format(' None')
- ss+='\n INPUT PARAMS:{}'
+ ss += '\n INPUT PARAMS:{}'
if self.input_params:
- ss = ss.format(sep + sep.join(f.short_description()
- for f in self.input_params.values()))
+ ss = ss.format(sep + sep.join(f.short_description()
+ for f in self.input_params.values()))
else:
ss = ss.format(' None')
- ss+='\n OUTPUT PARAMS:{}'
+ ss += '\n OUTPUT PARAMS:{}'
if self.output_params:
- ss = ss.format(sep + sep.join(f.short_description()
- for f in self.output_params.values()))
+ ss = ss.format(sep + sep.join(f.short_description()
+ for f in self.output_params.values()))
else:
ss = ss.format(' None')
return ss
diff --git a/hysop/core/graph/computational_node_frontend.py b/hysop/core/graph/computational_node_frontend.py
index 77b14e2d7344eae4a725539ef6ef53f079c3a9e1..ab75850b0a4d96dbef14c94f604bf56e384cd85a 100644
--- a/hysop/core/graph/computational_node_frontend.py
+++ b/hysop/core/graph/computational_node_frontend.py
@@ -1,3 +1,4 @@
+import inspect
from hysop.constants import Implementation, Backend, implementation_to_backend
from hysop.tools.decorators import debug
from hysop.tools.types import check_instance, first_not_None
@@ -87,6 +88,12 @@ class ComputationalGraphNodeFrontend(ComputationalGraphNodeGenerator):
msg+= 'available implementations are:\n {}'
msg=msg.format(implementation, '\n '.join(simplementations))
raise ValueError(msg)
+ elif (self.implementations()[implementation] is None):
+ msg = 'Specified implementation \'{}\' is registered as an available implementation for operator \'{}\', '
+ msg+= 'but no underlying implementation was found. This may be due to missing dependency or a catched '
+ msg+= 'import error in file file://{}.'
+ msg=msg.format(implementation, self.__class__.__name__, inspect.getfile(self.__class__)[:-1])
+ raise ValueError(msg)
self.implementation = implementation
self.backend = implementation_to_backend(implementation)
@@ -96,6 +103,7 @@ class ComputationalGraphNodeFrontend(ComputationalGraphNodeGenerator):
self._input_fields_to_dump = []
self._output_fields_to_dump = []
+
@debug
def _generate(self):
try:
diff --git a/hysop/core/graph/computational_operator.py b/hysop/core/graph/computational_operator.py
index f9953e7fbc3a6c3f9d4489696aff9eedae4640da..cde43663565605c8fabd2cb2c8bba5dd31e34a32 100644
--- a/hysop/core/graph/computational_operator.py
+++ b/hysop/core/graph/computational_operator.py
@@ -105,6 +105,15 @@ class ComputationalGraphOperator(ComputationalGraphNode):
finalize() (requires self.ready to be set)
sets self.ready to False
+ Operators support checkpointing, ie. continuing a simulation state from a checkpoint stored on disk.
+ In order for this to work, some operators may store data during checkpoint export and reload data
+ during checkpoint import. In order for this to work, operators have to override the following methods:
+ checkpoint_required() should return True
+ save_checkpoint(self, datagroup, mpi_params, io_params, compressor)
+ load_checkpoint(self, datagroup, mpi_params, io_params, relax_constraints)
+ By default, datagroup are saved and retrieved based on operator name.
+ When this is not sufficient, operators can override checkpoint_datagroup_key() to pass a custom key.
+
Nothing besides __init__ should be called explicitely by the user as a
ComputationalGraphOperator should always be embedded into a hysop.problem.Problem,
or at least, a child class of hysop.core.graph.computational_graph.ComputationalGraph.
@@ -161,7 +170,7 @@ class ComputationalGraphOperator(ComputationalGraphNode):
is initialized.
"""
pass
-
+
@debug
def create_topology_descriptors(self):
"""
@@ -197,7 +206,7 @@ class ComputationalGraphOperator(ComputationalGraphNode):
Default is Backend.HOST, no min or max ghosts, MemoryOrdering.ANY
and no specific default transposition state for each input and output variables.
"""
-
+
# Create the topology descriptors
self.create_topology_descriptors()
@@ -540,6 +549,10 @@ class ComputationalGraphOperator(ComputationalGraphNode):
"""
self.allocate_tmp_fields(work)
super(ComputationalGraphOperator, self).setup(work)
+ for f in self.input_fields:
+ freq = self._field_requirements.get_input_requirement(f)[1]
+ assert freq.tstates is None or self.input_discrete_fields[f].topology_state.tstate in freq.tstates
+ assert freq.tstates is None or self.input_discrete_fields[f].topology_state.axes in freq.axes
def allocate_tmp_fields(self, work):
for dfield in self.discrete_fields:
@@ -550,7 +563,7 @@ class ComputationalGraphOperator(ComputationalGraphNode):
req_id = 'tmp_{}_{}'.format(dfield.name, dfield.tag)
data = work.get_buffer(self, req_id)
dfield.dfield.honor_memory_request(data)
-
+
@classmethod
def supported_backends(cls):
"""
@@ -665,6 +678,70 @@ class ComputationalGraphOperator(ComputationalGraphNode):
return ops
+ def checkpoint_required(self):
+ """
+ Should return True if this operator may export/import custom checkpoint data.
+ Can be overriden to enable operator checkpointing.
+ """
+ return False
+
+ def checkpoint_datagroup_key(self):
+ """
+ By default the checkpoint datagroup key is based on operator name.
+ This can be overriden to generate custom keys.
+ Note that all keys are post-processing by using CheckpointHandler._format_zarr_key.
+ """
+ return self.name
+
+ def save_checkpoint(self, datagroup, mpi_params, io_params, compressor):
+ """
+ Save custom operator data to a checkpoint.
+
+ Datagroup is a zarr.hierarchy.Datagroup object, see hysop.core.checkpoints.CheckpointHandler for example usage.
+ Parameters mpi_params and io_params are MPIParams and IOParams coming from the CheckpointHandler.
+ You can create numpy-like arrays with datagroup.create_dataset and subgroups with datagroup.create_group.
+ Compressor is the compressor that should be used when creating arrays with datagroup.create_dataset.
+
+ Each group or array can contain a json-serialisable dictionary of metadata.
+ Metadata can be set as the following:
+ group.attrs[key] = value
+ or
+ array.attrs[key] = value
+ where key is a string that does not contain '\' or '/', see hysop.core.checkpoints.CheckpointHandler._format_zarr_key.
+
+ Only io_leader should write metadata, io_leader can be determined as (mpi_params.rank == io_params.io_leader)
+ Multiple processes array writes should be synchronized unless they write to different blocks of data.
+ See https://zarr.readthedocs.io/en/stable/tutorial.html#parallel-computing-and-synchronization for more information.
+ """
+ if self.checkpoint_required():
+ msg='Operator {} does require checkpointing but {}.save_checkpoint() has not been overriden.'
+ raise NotImplementedError(msg.format(self.name, self.__class__.__name__))
+ else:
+ msg='{}.load_checkpoint() called but operator {} does not seem to require a checkpoint...'
+ raise RuntimeError(msg.format(self.__class__.__name__, self.name))
+
+ def load_checkpoint(self, datagroup, mpi_params, io_params, relax_constraints):
+ """
+ Reload custom operator data from a checkpoint.
+
+ Datagroup is a zarr.hierarchy.Datagroup object, see hysop.core.checkpoints.CheckpointHandler for example usage.
+ Parameters mpi_params and io_params are MPIParams and IOParams coming from the CheckpointHandler.
+ If relax_constraints is set, you can ignore data discreapencies such as datatype, else should an error should be raised.
+
+ Data arrays or subgroups can be accessed with the dict-like datagroup[key] syntax.
+ Group or array metadata can be retrieved by using the group.attrs[key] or array.attrs[key] syntax where key is a
+ string that does not contain '\' or '/', see hysop.core.checkpoints.CheckpointHandler._format_zarr_key.
+
+ As this operation read-only, there is no need to synchronize processes.
+ Also note that metadata type is not always the same when deserialized (for example tuples become lists).
+ """
+ if self.checkpoint_required():
+ msg='Operator {} does require checkpointing but {}.load_checkpoint() has not been overriden.'
+ raise NotImplementedError(msg.format(self.name, self.__class__.__name__))
+ else:
+ msg='{}.load_checkpoint() called but operator {} does not seem to require a checkpoint...'
+ raise RuntimeError(msg.format(self.__class__.__name__, self.name))
+
def _check_backend(self):
"""
Checks backend support and topologies.
@@ -714,8 +791,7 @@ class ComputationalGraphOperator(ComputationalGraphNode):
@classmethod
def default_method(cls):
return dict()
-
+
@property
def enable_opencl_host_buffer_mapping(self):
return False
-
diff --git a/hysop/core/graph/continuous.py b/hysop/core/graph/continuous.py
index e620e718e64747905772d63659d2a797e7872b60..ae2e358bc73b519e02a706555795024111979d3c 100755
--- a/hysop/core/graph/continuous.py
+++ b/hysop/core/graph/continuous.py
@@ -1,6 +1,7 @@
"""Common interface for all continuous operators.
"""
+import os
from abc import ABCMeta, abstractmethod
from hysop import __PROFILE__, vprint, dprint
@@ -25,7 +26,7 @@ class OperatorBase(TaggedObject):
@debug
def __init__(self, name, fields, tensor_fields, parameters,
mpi_params=None,
- io_params=True,
+ io_params=False,
**kwds):
"""
Parameters
@@ -85,7 +86,7 @@ class OperatorBase(TaggedObject):
if not __PROFILE__:
return
self._profiler.summarize()
- vprint(str(self._profiler))
+ print(str(self._profiler))
def _set_io(self):
"""
@@ -104,13 +105,12 @@ class OperatorBase(TaggedObject):
if (iopar is not None):
if isinstance(iopar, bool):
if (iopar is True):
- filename='{}/{}'.format(IO.default_path(), self.name)
+ filename=os.path.join(IO.default_path(), self.name)
self.io_params = IOParams(filename, fileformat=IO.HDF5)
else:
self.io_params = None
elif isinstance(iopar, IOParams):
- msg = 'Error, wrong file format for operator output.'
- assert self.io_params.fileformat is IO.HDF5, msg
+ pass
else:
raise TypeError('Error, wrong type for io_params.')
diff --git a/hysop/core/graph/graph.py b/hysop/core/graph/graph.py
index d002b2f9b541bf36c45416faa685f4f2b2a1f12f..886cbd11a2efc37eda32ec5f9833568a759fd1af 100644
--- a/hysop/core/graph/graph.py
+++ b/hysop/core/graph/graph.py
@@ -1,106 +1,335 @@
-
-import graph_tool as gt
-from graph_tool import Graph, GraphView
-from graph_tool import topology, stats, search
+import inspect, networkx
+from hysop import dprint
+from hysop.constants import MemoryOrdering
+from hysop.tools.types import check_instance, first_not_None
from hysop.tools.decorators import not_implemented, debug, wraps, profile
-try:
- from graph_tool.all import graph_draw as graph_draw
-except:
- graph_draw = None
+
+def is_directed_acyclic_graph(graph):
+ return networkx.algorithms.dag.is_directed_acyclic_graph(graph)
+
+def transitive_reduction(graph):
+ reduced_graph = networkx.algorithms.dag.transitive_reduction(graph)
+ # copy back edge attributes (node data is automatically transferred
+ # because nodes are the data (VertexAttributes))
+ for node in reduced_graph:
+ for out_node in reduced_graph[node]:
+ for (k,v) in graph[node][out_node].items():
+ reduced_graph[node][out_node][k] = v
+ return reduced_graph
+
+def all_simple_paths(graph, src, dst):
+ return tuple(networkx.algorithms.simple_paths.all_simple_paths(graph, src, dst))
+
+def lexicographical_topological_sort(graph):
+ # Lexicographical sort ensures a unique permutations of nodes
+ # such that they are in the same topological order on each
+ # MPI process. Else operators will not be executed in the same
+ # order and everything deadlocks on MPI synchronization.
+ topo_sort = tuple(networkx.algorithms.dag.lexicographical_topological_sort(
+ graph, key=lambda x: int(x)))
+ return topo_sort
+
+def new_directed_graph():
+ return networkx.DiGraph()
+
+def new_vertex(graph, *args, **kwds):
+ # /!\ We have to use networkx 2.2 which has a different interface for attributes
+ node = VertexAttributes(graph, *args, **kwds)
+ graph.add_node(node)
+ return node
+
+def new_edge(graph, u, v, *args, **kwds):
+ # /!\ We have to use networkx 2.2 which has a different interface for attributes
+ assert u in graph
+ assert v in graph
+ if v not in graph[u]:
+ data = EdgeAttributes(*args, **kwds)
+ graph.add_edge(u, v, data=data)
+ else:
+ edge = graph[u][v]
+ edge['data'].update(*args, **kwds)
+ return (u,v)
+
+def generate_vertex_colors():
+ try:
+ import matplotlib
+ except ImportError:
+ return None
+ from matplotlib import cm
+ c0 = cm.get_cmap('tab20c').colors
+ c1 = cm.get_cmap('tab20b').colors
+ colors = []
+ for i in (2,3,0,1):
+ colors += c0[i::4] + c1[i::4]
+ colors = tuple(map(matplotlib.colors.to_hex, colors))
+ return colors
+
+class VertexAttributes(object):
+ """Simple class to hold vertex data."""
+
+ colors = generate_vertex_colors()
+
+ def __init__(self, graph, operator=None):
+ if not hasattr(graph, '_hysop_node_counter'):
+ graph._hysop_node_counter = 0
+ node_id = graph._hysop_node_counter
+ graph._hysop_node_counter += 1
+
+ self.node_id = node_id
+ self.operator = operator
+
+ self.input_states = None
+ self.output_states = None
+ self.op_ordering = None
+ self.command_queue = None
+
+ def copy_attributes(self, other):
+ if (other is None):
+ return self
+ check_instance(other, VertexAttributes)
+ for vname in ('operator',
+ 'input_states', 'output_states',
+ 'op_ordering', 'command_queue'):
+ setattr(self, vname, first_not_None(getattr(self, vname),
+ getattr(other, vname)))
+ return self
+
+ def set_op_info(self, operator, input_states, output_states):
+ assert (self.operator is not None)
+ assert self.operator is operator
+ self.operator = operator
+ self.input_states = input_states
+ self.output_states = output_states
+ return self
+
+ # hashing for networkx
+ def hash(self):
+ return self.node_id
+ def __eq__(self, other):
+ return self.node_id == other.node_id
+ def __int__(self):
+ return self.node_id
+
+ # pyvis attributes for display
+ @property
+ def label(self):
+ s = '{}'.format(self.operator.pretty_name)
+ if (self.op_ordering is not None):
+ s = '({})\n{}'.format(self.op_ordering, s)
+ return s
+
+ @property
+ def title(self):
+ return self.node_info().replace('\n','<br>')
+ def shape(self, with_custom_nodes=True):
+ from hysop.operator.base.transpose_operator import TransposeOperatorBase
+ from hysop.operator.base.redistribute_operator import RedistributeOperatorBase
+ from hysop.operator.base.memory_reordering import MemoryReorderingBase
+ special_shapes = {
+ RedistributeOperatorBase: 'box',
+ TransposeOperatorBase: 'box',
+ MemoryReorderingBase: 'box'
+ }
+ if with_custom_nodes:
+ for (op_type, shape) in special_shapes.iteritems():
+ if isinstance(self.operator, op_type):
+ return shape
+ return 'circle'
+
+ @property
+ def color(self):
+ cq = self.command_queue
+ if (cq is None):
+ return None
+ assert isinstance(cq, int) and cq >= 0
+ colors = self.colors
+ ncolors = len(colors)
+ return colors[cq%ncolors]
+
+ def node_info(self):
+ op = self.operator
+ istates = self.input_states
+ ostates = self.output_states
+
+ ifields = op.input_fields
+ ofields = op.output_fields
+ iparams = op.input_params
+ oparams = op.output_params
+
+ memorder2str = {
+ MemoryOrdering.C_CONTIGUOUS: 'C',
+ MemoryOrdering.F_CONTIGUOUS: 'F',
+ }
+
+ def ifinfo(field, topo):
+ info = (field.pretty_name, topo.id)
+ if istates:
+ assert field in istates
+ istate = istates[field]
+ assert (istate is not None)
+ info+=(memorder2str[istate.memory_order],)
+ info+=(str(istate.tstate),)
+ return ', '.join(map(str,info))
+ def ofinfo(field, topo):
+ info = (field.pretty_name, topo.id)
+ if ostates:
+ assert field in ostates
+ ostate = ostates[field]
+ assert (ostate is not None)
+ info+=(memorder2str[ostate.memory_order],)
+ info+=(str(ostate.tstate),)
+ return ', '.join(map(str,info))
+ def ipinfo(param):
+ return param.pretty_name
+ def opinfo(param):
+ return param.pretty_name
+
+ prefix='  <b>'
+ suffix='</b>  '
+ sep = '\n'+' '*14
+
+ ss = '<h2>Operator {}</h2>{}{}{}{}{}\n{}'.format(op.name,
+ '{p}Rank:{s}{}\n\n'.format(self.op_ordering, p=prefix, s=suffix)
+ if self.op_ordering else '',
+ '{p}Pin:{s}{}\n'.format(sep.join(ipinfo(param)
+ for param in iparams.values()), p=prefix, s=suffix+'  ')
+ if iparams else '',
+ '{p}Fin:{s}{}\n'.format(sep.join([ifinfo(f,topo)
+ for (f,topo) in ifields.iteritems()]), p=prefix,
+ s=suffix+'  ')
+ if ifields else '',
+ '{p}Pout:{s}{}\n'.format(sep.join([opinfo(param)
+ for param in oparams.values()]), p=prefix, s=suffix)
+ if oparams else '',
+ '{p}Fout:{s}{}\n'.format(sep.join([ofinfo(f,topo)
+ for (f,topo) in ofields.iteritems()]), p=prefix, s=suffix)
+ if ofields else '',
+ '{p}Type:{s} {}'.format(
+ sep.join(map(lambda x: x.__name__, type(op).__mro__[:-2])),
+ p=prefix, s=suffix))
+ return ss
+
+
+class EdgeAttributes(object):
+ """Simple class to hold edge data."""
+ def __init__(self, *args, **kwds):
+ self.variables = {}
+ self.update(*args, **kwds)
+
+ def update(self, variable=None, topology=None):
+ if (variable is None):
+ assert topology is None
+ return
+ self.variables.setdefault(variable, set()).add(topology)
+
+ def __str__(self):
+ prefix='  <b>'
+ suffix='</b>  '
+ ss = '<h2>Variable dependencies</h2>{}'.format('\n'.join(
+ '{p}{}:{s}{}'.format(v.pretty_name,
+ ', '.join(v.pretty_name if (t is None) else
+ v[t].short_description() for t in self.variables[v]),
+ p=prefix,s=suffix) for v in self.variables))
+ return ss.replace('\n','<br>')
+
+
class ComputationalGraphNodeData(object):
"""
Simple class to hold some node data.
"""
+
def __init__(self, current_level, node_id):
self.current_level = current_level
- self.node_id = node_id
- self.apply_kargs = [] #list of dictionnary, last one has priority
+ self.node_id = node_id
+ self.apply_kargs = [] # list of dictionnary, last one has priority
+
def __str__(self):
return '(lvl={},id={})'.format(self.current_level, self.node_id)
+
if __debug__:
# python in debug mode, all decorators do check their target attribute
def not_initialized(f):
assert callable(f)
@wraps(f)
- def _not_initialized(*args,**kargs):
- return f(*args,**kargs)
+ def _not_initialized(*args, **kargs):
+ return f(*args, **kargs)
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if self.initialized:
- reason='this node has already been initialized.'
+ reason = 'this node has already been initialized.'
raise RuntimeError(msg.format(reason))
return _not_initialized
def initialized(f):
assert callable(f)
@wraps(f)
- def _initialized(*args,**kargs):
+ def _initialized(*args, **kargs):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self.initialized:
- reason='this node has not been initialized yet.'
+ reason = 'this node has not been initialized yet.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kargs)
+ return f(*args, **kargs)
return _initialized
def discretized(f):
assert callable(f)
@wraps(f)
- def _discretized(*args,**kargs):
+ def _discretized(*args, **kargs):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self.discretized:
- reason='this node has not been discretized yet.'
+ reason = 'this node has not been discretized yet.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kargs)
+ return f(*args, **kargs)
return _discretized
def ready(f):
assert callable(f)
@wraps(f)
- def _ready(*args,**kargs):
+ def _ready(*args, **kargs):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__, self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self.ready:
- reason='this node has not been set up.'
+ reason = 'this node has not been set up.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kargs)
+ return f(*args, **kargs)
return _ready
def graph_built(f):
assert callable(f)
@wraps(f)
- def _graph_built(*args,**kargs):
+ def _graph_built(*args, **kargs):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self.graph_built:
reason = 'the graph has not been built yet.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kargs)
+ return f(*args, **kargs)
return _graph_built
def generated(f):
assert callable(f)
@wraps(f)
- def _generated(*args,**kargs):
+ def _generated(*args, **kargs):
self = args[0]
msg = 'Cannot call {}.{}() on node \'{}\' because {}'\
- .format(self.__class__.__name__,f.__name__,self.name,'{}')
+ .format(self.__class__.__name__, f.__name__, self.name, '{}')
if not self.generated:
- reason='this node has not been generated yet.'
+ reason = 'this node has not been generated yet.'
raise RuntimeError(msg.format(reason))
- return f(*args,**kargs)
+ return f(*args, **kargs)
return _generated
-else: # not __debug__
+else: # not __debug__
# python optimized, no checks
def not_initialized(f):
return f
@@ -126,45 +355,53 @@ def op_apply(f):
@profile
@ready
def apply(*args, **kwds):
- #print u'APPLY {}'.format(args[0].name)
- dbg = ('dbg' in kwds)
+ dbg = ('dbg' in kwds)
dbg = dbg and (kwds['dbg'] is not None)
dbg = dbg and (kwds['dbg'].enable_on_op_apply)
- debug_dump = ('debug_dumper' in kwds)
+ debug_dump = ('debug_dumper' in kwds)
debug_dump = debug_dump and (kwds['debug_dumper'] is not None)
debug_dump = debug_dump and (kwds['debug_dumper'].enable_on_op_apply)
+ op = args[0]
if debug_dump:
assert 'simulation' in kwds
- op = args[0]
simu = kwds['simulation']
it = simu.current_iteration
t = simu.t()
+ _file = inspect.getsourcefile(f)
+ _, _line = inspect.getsourcelines(f)
+ description = '{}:{}'.format(_file, _line)
for param in sorted(op.input_params.values(), key=lambda x: x.name):
tag = 'pre_{}_{}'.format(op.name, param.name)
- kwds['debug_dumper'](it, t, tag,
- (param._value,))
+ kwds['debug_dumper'](it, t, tag,
+ (param._value,), description=description)
for dfield in sorted(op.input_discrete_fields.values(), key=lambda x: x.name):
tag = 'pre_{}_{}'.format(op.name, dfield.name)
- kwds['debug_dumper'](it, t, tag,
- tuple(df.sdata.get().handle[df.compute_slices] for df in dfield.dfields))
+ kwds['debug_dumper'](it, t, tag,
+ tuple(df.sdata.get().handle[df.compute_slices]
+ for df in dfield.dfields), description=description)
ret = f(*args, **kwds)
for param in sorted(op.output_params.values(), key=lambda x: x.name):
tag = 'post_{}_{}'.format(op.name, param.name)
- kwds['debug_dumper'](it, t, tag,
- (param._value,))
- for dfield in sorted(op.output_discrete_fields.values(), key=lambda x: x.name):
+ kwds['debug_dumper'](it, t, tag,
+ (param._value,), description=description)
+ for dfield in sorted(op.output_discrete_fields.values(),
+ key=lambda x: x.name):
tag = 'post_{}_{}'.format(op.name, dfield.name)
- kwds['debug_dumper'](it, t, tag,
- tuple(df.sdata.get().handle[df.compute_slices] for df in dfield.dfields))
+ kwds['debug_dumper'](it, t, tag,
+ tuple(df.sdata.get().handle[df.compute_slices]
+ for df in dfield.dfields), description=description)
return ret
elif dbg:
- import inspect
- msg=inspect.getsourcefile(f)
+ msg = inspect.getsourcefile(f)
kwds['dbg']('pre '+msg, nostack=True)
ret = f(*args, **kwds)
kwds['dbg']('post '+msg, nostack=True)
return ret
else:
- return f(*args, **kwds)
+ if not op.to_be_skipped(*args, **kwds):
+ return f(*args, **kwds)
+ else:
+ dprint("Skip {}".format(op.name))
+ return
return ret
return apply
diff --git a/hysop/core/graph/graph_builder.py b/hysop/core/graph/graph_builder.py
index 0ac98bd3366f127b26efeee21c9302b906142eed..f3810a432ef3f6c77644f83a826ca56d68f96dac 100644
--- a/hysop/core/graph/graph_builder.py
+++ b/hysop/core/graph/graph_builder.py
@@ -1,3 +1,4 @@
+
from hysop import vprint, dprint, Problem
from hysop.deps import np, __builtin__, print_function
from hysop.tools.types import check_instance
@@ -9,16 +10,21 @@ from hysop.constants import MemoryOrdering, Backend
from hysop.parameters.parameter import Parameter
from hysop.topology.cartesian_topology import CartesianTopologyState
+from hysop.core.graph.graph import (new_directed_graph, new_vertex, new_edge,
+ is_directed_acyclic_graph, transitive_reduction,
+ lexicographical_topological_sort, all_simple_paths)
from hysop.core.graph.computational_graph import ComputationalGraph
from hysop.core.graph.computational_node import ComputationalGraphNode
from hysop.core.graph.computational_operator import ComputationalGraphOperator
-from hysop.core.graph.graph import Graph, ComputationalGraphNodeData, gt, graph_draw
-from hysop.fields.field_requirements import DiscreteFieldRequirements, MultiFieldRequirements
+from hysop.fields.field_requirements import (DiscreteFieldRequirements,
+ MultiFieldRequirements)
-from hysop.operator.redistribute import Redistribute, RedistributeNotImplementedError
-from hysop.operator.transpose import Transpose, TranspositionNotImplementedError
-from hysop.operator.memory_reordering import MemoryReordering, MemoryReorderingNotImplementedError
+from hysop.operator.redistribute import (Redistribute,
+ RedistributeNotImplementedError)
+from hysop.operator.transpose import Transpose, TranspositionNotImplementedError
+from hysop.operator.memory_reordering import (MemoryReordering,
+ MemoryReorderingNotImplementedError)
# Debug level for graph building
# 0: no debug logs
@@ -35,57 +41,6 @@ def gprint2(*args, **kwds):
kwds['level'] = 2
gprint(*args, **kwds)
-def _op_info(op,
- istates=None, ostates=None,
- jmp=False):
- ifields = op.input_fields
- ofields = op.output_fields
- iparams = op.input_params
- oparams = op.output_params
-
- memorder2str = {
- MemoryOrdering.C_CONTIGUOUS: 'C',
- MemoryOrdering.F_CONTIGUOUS: 'F',
- }
-
- def ifinfo(field, topo):
- info = (field.name, topo.id)
- if istates:
- assert field in istates
- istate = istates[field]
- assert (istate is not None)
- info+=(memorder2str[istate.memory_order],)
- info+=(str(istate.tstate),)
- return info
- def ofinfo(field, topo):
- info = (field.name, topo.id)
- if ostates:
- assert field in ostates
- ostate = ostates[field]
- assert (ostate is not None)
- info+=(memorder2str[ostate.memory_order],)
- info+=(str(ostate.tstate),)
- return info
- def ipinfo(param):
- return param.name
- def opinfo(param):
- return param.name
-
- ss = 'Operator {} => \n {}{}{}{}\n {}'.format(op.name,
- 'Pin:{}\n '.format([ ipinfo(param) for param in iparams.values() ])
- if iparams else '',
- 'Fin:{}\n '.format([ ifinfo(f,topo) for (f,topo) in ifields.iteritems() ])
- if ifields else '',
- 'Pout:{}\n '.format([ opinfo(param) for param in oparams.values() ])
- if oparams else '',
- 'Fout:{}\n '.format([ ofinfo(f,topo) for (f,topo) in ofields.iteritems() ])
- if ofields else '',
- op.__class__)
- if jmp:
- return ss
- else:
- return ss.replace('\n',' ')
-
class GraphBuilder(object):
"""
@@ -126,21 +81,7 @@ class GraphBuilder(object):
gprint(msg)
def setup_graph(self):
- graph = Graph(directed=True)
-
- vertex_properties = {}
- vertex_properties['op_names'] = graph.new_vertex_property('string')
- vertex_properties['op_pnames'] = graph.new_vertex_property('string')
- vertex_properties['op_info'] = graph.new_vertex_property('string')
- vertex_properties['operators'] = graph.new_vertex_property('python::object')
-
- edge_properties = {}
- edge_properties['var_names'] = graph.new_edge_property('string')
- edge_properties['variables'] = graph.new_edge_property('python::object')
-
- self.graph = graph
- self.vertex_properties = vertex_properties
- self.edge_properties = edge_properties
+ self.graph = new_directed_graph()
def setup_variables(self):
self.input_fields = {}
@@ -160,40 +101,23 @@ class GraphBuilder(object):
self.target_node._input_fields_to_dump,
self.target_node.method)
- def new_node(self, opname, oppname, op, subgraph,
- current_level, node, node_id,
- extra_node_props, opvertex):
- graph = self.graph
- vertex_properties = self.vertex_properties
+ def new_node(self, op, subgraph,
+ current_level, node, node_id, opvertex):
- opnode = graph.add_vertex()
- vertex_properties['op_names'][opnode] = opname
- vertex_properties['op_pnames'][opnode] = oppname
- vertex_properties['operators'][opnode] = op
+ graph = self.graph
+ opnode = new_vertex(graph, op).copy_attributes(opvertex)
gprint(' *Created node is {}.'.format(int(opnode)))
-
- if opvertex:
- assert (extra_node_props is not None)
- assert 'op_info' in extra_node_props
- level = node.level + 1
- for enp in extra_node_props:
- vertex_properties[enp][opnode] = subgraph.vp[enp][opvertex]
- else:
- level = current_level
return opnode
def build_graph(self):
-
target_node = self.target_node
current_level = self.current_level
outputs_are_inputs = self.outputs_are_inputs
graph = self.graph
- vertex_properties = self.vertex_properties
- edge_properties = self.edge_properties
- parameter_handler = self.__ParameterHandler(graph, edge_properties, vertex_properties)
+ parameter_handler = self.__ParameterHandler(graph)
input_fields = self.input_fields
output_fields = self.output_fields
@@ -209,9 +133,10 @@ class GraphBuilder(object):
# check that all target nodes are unique to prevent conflicts
if len(set(target_node.nodes)) != len(target_node.nodes):
- duplicates = set([x for x in target_node.nodes if target_node.nodes.count(x) > 1])
- msg='\n\nFATAL ERROR: ComputationalGraph {} contains mutiple references to the '
- msg+='same nodes.\n'
+ duplicates = set([x for x in target_node.nodes
+ if target_node.nodes.count(x) > 1])
+ msg='\n\nFATAL ERROR: ComputationalGraph {} contains mutiple references to '
+ msg+='the same nodes.\n'
msg+='Concerned operators are:\n'
for op in duplicates:
msg0=' *Operator {:12s} (cls={:30s} | id={}): {} occurences\n'
@@ -223,14 +148,15 @@ class GraphBuilder(object):
# iterate over ComputationalNodes
for (node_id, node) in enumerate(target_node.nodes):
- gprint(' >Handling node {}: {} {}'.format(node_id, node.name, node.__class__) )
+ gprint(' >Handling node {}: {} {}'.format(
+ node_id, node.name, node.__class__) )
# Recursively build graph.
# If current node is a ComputationalGraph, we have to first
# build its own local graph and we extract all its operators (graph nodes).
# Else if node is a ComputationalGraphOperator, we just take the
# current node operator.
- subgraph, node_ops, node_vertices, from_subgraph, extra_node_props = \
+ subgraph, node_ops, node_vertices, from_subgraph = \
self.build_subgraph(node, current_level)
# iterate over subgraph operators
@@ -245,30 +171,33 @@ class GraphBuilder(object):
field_requirements = op._field_requirements
# add operator node and fill vertex properties
- opnode = self.new_node(opname, oppname, op, subgraph,
- current_level, node, node_id,
- extra_node_props, opvertex)
+ opnode = self.new_node(op, subgraph,
+ current_level, node, node_id, opvertex)
if not isinstance(op, Problem):
# try to fill in undertermined topologies (experimental feature)
backends = op.supported_backends()
- for (ifield, itopo) in sorted(ifields.iteritems(), key=lambda x: x[0].name):
+ for (ifield, itopo) in sorted(ifields.iteritems(),
+ key=lambda x: x[0].name):
if (itopo is not None):
continue
# look for ifield usage untill now
- if (ifield in ofields) and (ofields[ifield] is not None) and (ofields[ifield].backend.kind in backends):
+ if ((ifield in ofields) and (ofields[ifield] is not None)
+ and (ofields[ifield].backend.kind in backends)):
ifields[ifield] = ofields[ifield]
elif (ifield not in self.topology_states):
if outputs_are_inputs:
# we can try to push this operator after we're done
deferred_operators.append((op,opnode))
else:
- msg = '\nGraphBuilder {} could not automatically determine the '
- msg += 'topology of input field {} in operator {}.'
- msg += '\nTry to set a non empty TopologyDescriptor when passing '
- msg += 'the variable parameters, when creating the operator.'
- msg += '\nAutomatic topology detection is an experimental feature.'
- msg = msg.format(target_node.name, ifield.name, op.name)
+ msg = ('\nGraphBuilder {} could not automatically '
+ 'determine the topology of input field {} in '
+ 'operator {}.\nTry to set a non empty '
+ 'TopologyDescriptor when passing the variable '
+ 'parameters, when creating the operator.'
+ '\nAutomatic topology detection is an '
+ 'experimental feature.')
+ msg = msg.format(target_node.name, ifield.name, op.name)
raise RuntimeError(msg)
else:
cstate = self.topology_states[ifield]
@@ -278,18 +207,20 @@ class GraphBuilder(object):
backend = itopo.backend.any_backend_from_kind(*backends)
itopo = itopo.topology_like(backend=backend)
ifields[ifield] = itopo
- for (ofield, otopo) in sorted(ofields.iteritems(), key=lambda x: x[0].name):
+ for (ofield, otopo) in sorted(ofields.iteritems(),
+ key=lambda x: x[0].name):
if (otopo is not None):
continue
if (ofield in ifields) and (ifields[ofield] is not None):
ofields[ofield] = ifields[ofield]
elif (ofield not in self.topology_states):
- msg = '\nGraphBuilder {} could not automatically determine the '
- msg += 'topology of input field {} in operator {}.'
- msg += '\nTry to set a non empty TopologyDescriptor when passing '
- msg += 'the variable parameters, when creating the operator.'
- msg += '\nAutomatic topology detection is an experimental feature.'
- msg = msg.format(target_node.name, ofield.name, op.name)
+ msg = ('\nGraphBuilder {} could not automatically determine '
+ 'the topology of input field {} in operator {}.'
+ '\nTry to set a non empty TopologyDescriptor when '
+ 'passing the variable parameters, when creating the '
+ 'operator.\nAutomatic topology detection is an '
+ 'experimental feature.')
+ msg = msg.format(target_node.name, ofield.name, op.name)
raise RuntimeError(msg)
else:
cstate = self.topology_states[ofield]
@@ -319,10 +250,11 @@ class GraphBuilder(object):
input_states = {}
if ifields:
gprint(' >Input fields')
- for (ifield,itopo) in sorted(ifields.iteritems(), key=lambda x: x[0].name, reverse=True):
+ for (ifield,itopo) in sorted(ifields.iteritems(),
+ key=lambda x: x[0].name, reverse=True):
gprint(' *{}{}'.format(ifield.name,
- ' on an unknown topology (to be determined)' if (itopo is None) \
- else '.{}'.format(itopo.pretty_tag)))
+ ' on an unknown topology (to be determined)'
+ if (itopo is None) else '.{}'.format(itopo.pretty_tag)))
if (itopo is None):
continue
if isinstance(op, Problem):
@@ -331,34 +263,33 @@ class GraphBuilder(object):
else:
ifreqs = None
else:
- ifreqs = None if (current_level!=0 or isinstance(op, Problem)) \
- else field_requirements.get_input_requirement(ifield)[1]
+ if (current_level!=0 or isinstance(op, Problem)):
+ ifreqs = None
+ else:
+ ifreqs = \
+ field_requirements.get_input_requirement(ifield)[1]
if (ifield not in self.topology_states):
cstate = self.new_topology_state(ifield)
self.topology_states[ifield] = cstate
is_new = True
else:
cstate = self.topology_states[ifield]
- # Field is not new but has never been written
- is_new = False or not cstate.write_nodes
+ is_new = False
+
dstate = cstate.handle_input(opnode, itopo, ifreqs,
- graph, edge_properties, vertex_properties,
- is_new)
+ graph, is_new)
input_states[ifield] = dstate
if is_new:
- if ifield not in input_fields.keys():
- input_fields[ifield] = []
- input_topology_states[ifield] = []
- if itopo not in input_fields[ifield]:
- input_fields[ifield].append(itopo)
- input_topology_states[ifield].append((ifreqs, dstate))
+ input_fields[ifield] = itopo
+ input_topology_states[ifield] = (ifreqs, dstate)
# iterate over subgraph operator output fields
output_states = {}
if ofields:
gprint(' >Output fields')
- for (ofield,otopo) in sorted(ofields.iteritems(), key=lambda x: x[0].name, reverse=True):
+ for (ofield,otopo) in sorted(ofields.iteritems(),
+ key=lambda x: x[0].name, reverse=True):
assert (otopo is not None)
gprint(' *{}.{}'.format(ofield.name, otopo.pretty_tag))
if isinstance(op, Problem):
@@ -368,21 +299,21 @@ class GraphBuilder(object):
ofreqs = None
else:
ofreqs = None if (current_level!=0) \
- else field_requirements.get_output_requirement(ofield)[1]
+ else field_requirements.get_output_requirement(ofield)[1]
istates = None if (current_level!=0) else input_states
cstate = self.topology_states.setdefault(ofield,
self.new_topology_state(ofield))
- invalidate_field = (ofield not in op.get_preserved_input_fields())
+ invalidate_field = (ofield not in
+ op.get_preserved_input_fields())
dstate = cstate.handle_output(opnode, otopo, ofreqs,
- op, istates, invalidate_field,
- graph, edge_properties, vertex_properties)
+ op, istates, invalidate_field, graph)
output_fields[ofield] = otopo
output_states[ofield] = dstate
output_topology_states[ofield] = (None, dstate)
if (current_level==0) and ((op,opnode) not in deferred_operators):
- vertex_properties['op_info'][opnode] = _op_info(op, input_states,
- output_states)
+ opnode.set_op_info(op, input_states, output_states)
+
op_input_topology_states[op] = input_states
op_output_topology_states[op] = output_states
@@ -401,7 +332,7 @@ class GraphBuilder(object):
msg += '\nTry to set a non empty TopologyDescriptor when passing '
msg += 'the variable parameters, when creating the operator.'
msg += '\nAutomatic topology detection is an experimental feature.'
- msg = msg.format(target_node.name, ifield.name, op.name)
+ msg = msg.format(target_node.name, ifield.name, op.name)
if (ifield not in self.topology_states):
raise RuntimeError(msg)
cstate = self.topology_states[ifield]
@@ -411,17 +342,18 @@ class GraphBuilder(object):
ifields[ifield] = itopo
input_states[ifield] = dstate
field_requirements.update_inputs({ifield: ireqs})
- cstate.add_edge(graph, edge_properties, opnode, node, ifield, itopo)
+ cstate.add_edge(graph, opnode, node, ifield, itopo)
if current_level==0:
- vertex_properties['op_info'][opnode] = _op_info(op, input_states,
- output_states)
+ opnode.set_op_info(op, input_states, output_states)
if current_level==0:
msg='\nComputationalGraph {} inputs:\n'.format(target_node.name)
if input_fields:
for ifield in input_fields:
- for itopo, (_,ireqs) in zip(input_fields[ifield], input_topology_states[ifield]):
- msg+=' *Field {} on topo {}: {}\n'.format(ifield.name, itopo.id, ireqs)
+ itopo = input_fields[ifield]
+ _,ireqs = input_topology_states[ifield]
+ msg+=' *Field {} on topo {}: {}\n'.format(
+ ifield.name, itopo.id, ireqs)
else:
msg+= ' no inputs\n'
msg+='ComputationalGraph {} outputs:\n'.format(target_node.name)
@@ -429,7 +361,8 @@ class GraphBuilder(object):
for ofield in output_fields:
otopo = output_fields[ofield]
_,oreqs = output_topology_states[ofield]
- msg+=' *Field {} on topo {}: {}\n'.format(ofield.name, otopo.id, oreqs)
+ msg+=' *Field {} on topo {}: {}\n'.format(
+ ofield.name, otopo.id, oreqs)
else:
msg+= ' no outputs\n'
msg+='\n'
@@ -448,165 +381,104 @@ class GraphBuilder(object):
target_topo = self.output_fields[field]
variables = {field: target_topo}
- io_params = IOParams(
- filename='{}_{}_out'.format(io_params.filename, field.name),
- frequency=io_params.frequency,
- fileformat=io_params.fileformat,
- io_leader=io_params.io_leader)
- op = HDF_Writer(io_params=io_params, variables=variables,
- **op_kwds)
+ io_params = io_params.clone(filename='{}_{}_out'.format(io_params.filename, field.name))
+ op = HDF_Writer(io_params=io_params, variables=variables, **op_kwds)
op.initialize(topgraph_method=self.target_node.method)
op.get_and_set_field_requirements()
- opnode = self.new_node(opname, op, None,
- current_level, None, None, None, None)
+ opnode = self.new_node(op, None, current_level,
+ None, None, None, None)
ifreqs = None if (current_level!=0) \
else field_requirements.get_input_requirement(field)[1]
cstate = self.topology_states[field]
- state = cstate.handle_input(opnode, target_topo, ifreqs,
- graph, edge_properties, vertex_properties, False)
+ state = cstate.handle_input(opnode, target_topo, ifreqs, graph,False)
input_states = {field: state}
output_states = {}
self.op_input_topology_states[op] = input_states
self.op_output_topology_states[op] = output_states
if current_level==0:
- vertex_properties['op_info'][opnode] = _op_info(op, input_states,
- output_states)
+ opnode.set_op_info(op, input_states, output_states)
# Alter states such that output topology states match input topology states
# this is only done if required (outputs_are_inputs) and if we are
# processing the top level (root) graph
if (current_level==0) and outputs_are_inputs:
# identify variables that needs a closure
- redistribute_fields = set(input_fields.keys())#.intersection(output_fields.keys())
+ redistribute_fields = set(input_fields.keys())
for field in sorted(redistribute_fields, key=lambda x: x.name):
assert field in input_topology_states
- for target_topo, (input_dfield_requirements, input_topology_state) in \
- zip(input_fields[field], input_topology_states[field]):
- requirements = input_dfield_requirements.copy()
- requirements.axes = (input_topology_state.axes,)
- requirements.memory_order = input_topology_state.memory_order
+ target_topo = input_fields[field]
+ input_dfield_requirements, input_topology_state = \
+ input_topology_states[field]
- cstate = self.topology_states[field]
- cstate.output_as_input(target_topo, requirements,
- graph, edge_properties, vertex_properties)
+ requirements = input_dfield_requirements.copy()
+ requirements.axes = (input_topology_state.axes,)
+ requirements.memory_order = input_topology_state.memory_order
- # All input fields have been processed, replace list by first element
- for f in input_fields.keys():
- itopo = input_fields[f][0]
- ireq, istate = input_topology_states[f][0]
- input_fields[f] = itopo
- input_topology_states[f] = (ireq, istate)
+ cstate = self.topology_states[field]
+ cstate.output_as_input(target_topo, requirements, graph)
# Check that the generated graph is a directed acyclic graph
- if not gt.topology.is_DAG(graph):
+ if not is_directed_acyclic_graph(graph):
msg='\nGenerated operator graph is not acyclic.'
- print(msg)
-
- #display graph for debug purposes
- gt.stats.remove_parallel_edges(graph)
- for prop_name,edge_property in edge_properties.iteritems():
- graph.edge_properties[prop_name] = edge_property
- for prop_name,vertex_property in vertex_properties.iteritems():
- if prop_name != 'command_queues':
- graph.vertex_properties[prop_name] = vertex_property
- target_node.graph_built = True
- target_node.reduced_graph = graph
- target_node.display()
-
- # and finally raise error
raise RuntimeError(msg)
- # Transitive reduction of graph (remove parallel and unnecessary transitive edges)
+ # Transitive reduction of graph
+ # This removes parallel and unnecessary transitive edges
# ie. remove useless redondant dependencies
- transitive_reduction = gt.stats.label_parallel_edges(graph, mark_only=True,
- eprop = graph.new_edge_property('bool',val=False))
- for vertex in graph.vertices():
- for neighbor_vertex in vertex.out_neighbours():
- accessible_vertices = \
- [v for v in gt.search.dfs_iterator(graph, neighbor_vertex)]
- for edge in accessible_vertices:
- edge = graph.edge(vertex, edge.target())
- if edge is not None:
- transitive_reduction[edge] = True
- transitive_reduction.a = [ not val for val in transitive_reduction.get_array()]
- reduced_graph = gt.GraphView(graph, efilt = transitive_reduction)
-
- # Topological sort
- # ie. find out operator order for execution purposes
- sorted_nodes = gt.topology.topological_sort(reduced_graph)
- vertex_properties['op_ordering'] = reduced_graph.new_vertex_property('int')
- for i,node_id in enumerate(sorted_nodes):
- vertex = reduced_graph.vertex(node_id)
- vertex_properties['op_ordering'][vertex] = i
- if current_level==0:
- vertex_properties['op_names'][vertex] += ' ('+str(i)+')'
- vertex_properties['op_pnames'][vertex] += ' ('+str(i)+')'
+ reduced_graph = transitive_reduction(graph)
+
+ # Lexicographical topological sort
+ # => find out operator order for execution purposes
+ # => have to be exactly the same on each MPI process.
+ sorted_nodes = lexicographical_topological_sort(reduced_graph)
+ for (i, node) in enumerate(sorted_nodes):
+ node.op_ordering = i
# Command queues (each color represents a command queue)
# ie. try to find out data independent subgraphs
color = 0
queues = {}
- vertex_properties['command_queues'] = graph.new_vertex_property('int',val=-1)
- vertex_properties['active_ops'] = graph.new_vertex_property('string',val='darkgray')
- for vertex_id in sorted_nodes:
- vertex = reduced_graph.vertex(vertex_id)
- if (vertex_properties['command_queues'][vertex] >= 0):
+ for node in sorted_nodes:
+ if (node.command_queue is not None):
continue
- vertices = [vertex]
- uncolored_childs = [ v for v in vertex.out_neighbours() \
- if (vertex_properties['command_queues'][v] == -1) ]
+ nodes = [node]
+ uncolored_childs = tuple(filter(lambda n: n.command_queue is None,
+ reduced_graph.adj[node]))
while len(uncolored_childs)>0:
- vid = np.argmin( [vertex_properties['op_ordering'][v]
- for v in uncolored_childs] )
- vertex = uncolored_childs[vid]
- vertices.append(vertex)
- uncolored_childs = [ v for v in vertex.out_neighbours() \
- if (vertex_properties['command_queues'][v] == -1) ]
+ vid = np.argmin( [n.op_ordering for n in uncolored_childs] )
+ node = uncolored_childs[vid]
+ nodes.append(node)
+ uncolored_childs = tuple(filter(lambda n: n.command_queue is None,
+ reduced_graph.adj[node]))
- idx_range = (vertex_properties['op_ordering'][vertices[0]],
- vertex_properties['op_ordering'][vertices[-1]])
+ idx_range = (nodes[0].op_ordering, nodes[-1].op_ordering)
if queues:
color = queues.keys()[-1]+1
-
for k in queues.keys()[::-1]:
paths = queues[k]
if (paths[-1][1] < idx_range[0]):
- src = reduced_graph.vertex(sorted_nodes[paths[-1][1]])
- dst = reduced_graph.vertex(sorted_nodes[idx_range[0]])
- all_paths = gt.topology.all_paths(reduced_graph,src,dst)
- all_paths = [p for p in all_paths]
+ src = sorted_nodes[paths[-1][1]]
+ dst = sorted_nodes[idx_range[0]]
+ all_paths = all_simple_paths(reduced_graph,src,dst)
if len(all_paths)>0:
color = k
break
queues.setdefault(color,[]).append(idx_range)
- for vertex in vertices:
- vertex_properties['command_queues'][vertex] = color
-
- # bind all original graph properties to reduced graph
- for prop_name,edge_property in edge_properties.iteritems():
- reduced_graph.edge_properties[prop_name] = edge_property
- for prop_name,vertex_property in vertex_properties.iteritems():
- reduced_graph.vertex_properties[prop_name] = vertex_property
+ for node in nodes:
+ node.command_queue = color
self.reduced_graph = reduced_graph
- self.sorted_nodes = sorted_nodes
- self.nodes = self._gather_nodes()
-
- def _gather_nodes(self):
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
- nodes = [ operators[reduced_graph.vertex(vid)] for vid in self.sorted_nodes ]
- return nodes
+ self.sorted_nodes = sorted_nodes
+ self.nodes = tuple(map(lambda x: x.operator, sorted_nodes))
def build_subgraph(self, node, current_level, **kwds):
node_ops = []
node_vertices = []
- extra_node_props = []
subgraph = None
from_subgraph = False
@@ -618,21 +490,14 @@ class GraphBuilder(object):
node_vertices.append(None)
elif isinstance(node, ComputationalGraph):
node._build_graph(current_level=current_level+1, **kwds)
- node_ordering = node.sorted_nodes
- subgraph = node.reduced_graph
- from_subgraph = True
- subgraph_ops = subgraph.vertex_properties['operators']
- vertex_properties = None
+ node_ordering = node.sorted_nodes
+ subgraph = node.reduced_graph
+ from_subgraph = True
for nid in node_ordering:
- _node = subgraph.vertex(nid)
- op = subgraph_ops[_node]
+ _node = nid
+ op = _node.operator
node_vertices.append(_node)
node_ops.append(op)
- for prop_name,vp in subgraph.vertex_properties.iteritems():
- if prop_name not in self.vertex_properties:
- self.vertex_properties[prop_name] = \
- self.graph.new_vertex_property(vp.value_type())
- extra_node_props.append(prop_name)
elif isinstance(node, ComputationalGraphOperator):
node_operators = node.operators()
node_ops.extend(node_operators)
@@ -641,22 +506,19 @@ class GraphBuilder(object):
msg = 'Unknown node type {}.'
raise NotImplementedError(msg.format(node.__class__.__name__))
- return subgraph, node_ops, node_vertices, from_subgraph, extra_node_props
+ return subgraph, node_ops, node_vertices, from_subgraph
class __ParameterHandler(object):
- def __init__(self, graph, edge_properties, vertex_properties):
+ def __init__(self, graph):
self.graph = graph
- self.edge_properties = edge_properties
- self.vertex_properties = vertex_properties
self.last_write_node = {}
self.reading_nodes = {}
def add_edge(self, src_node, dst_node, parameter):
if (src_node is not None) and (dst_node is not None) \
and (src_node != dst_node):
- edge = self.graph.add_edge(src_node, dst_node)
- self.edge_properties['var_names'][edge] = parameter.pretty_name
+ edge = new_edge(self.graph, src_node, dst_node, parameter)
return edge
else:
return None
@@ -707,20 +569,18 @@ class GraphBuilder(object):
if (input_fields_to_dump is not None):
for (fields, io_params, op_kwds) in input_fields_to_dump:
if (not fields) or (field in fields):
- io_params = IOParams(
- filename='{}_{}_in'.format(io_params.filename,field.name),
- frequency=io_params.frequency,
- fileformat=io_params.fileformat,
- io_leader=io_params.io_leader)
+ io_params = io_params.clone(filename='{}_{}_in'.format(io_params.filename, field.name))
self.dump_ifield = (io_params, op_kwds)
break
# dictionnary (topology -> list of node) that are up to date (lastly written)
- # multiple fields can be up to date at the same time after a redistribute operator
- # or after an operator that implements the get_preserved_input_fields method.
+ # multiple fields can be up to date at the same time after a redistribute
+ # operator or after an operator that implements the
+ # get_preserved_input_fields method.
self.write_nodes = {}
- # dictionnary (topology -> list of nodes) that are currently reading field:topo
+ # dictionnary (topology -> list of nodes) that are currently reading
+ # field:topo
self.read_nodes = {}
# dictionnary (topology -> TopologyState)
@@ -728,30 +588,18 @@ class GraphBuilder(object):
self.method = topgraph_method
- def add_vertex(self, graph, vertex_properties, operator):
- vertex = graph.add_vertex()
- vertex_properties['operators'][vertex] = operator
- vertex_properties['op_names'][vertex] = operator.name
- vertex_properties['op_pnames'][vertex] = operator.pretty_name
- #gprint('Creating vertex {}.'.format(int(vertex)))
- return vertex
-
- def add_edge(self, graph, edge_properties,
- src_node, dst_node,
- field, topology):
+ def add_vertex(self, graph, operator):
+ return new_vertex(graph, operator)
+
+ def add_edge(self, graph, src_node, dst_node, field, topology):
if (src_node is not None) and (dst_node is not None) \
and (src_node != dst_node):
- edge = graph.add_edge(src_node, dst_node)
- edge_properties['var_names'][edge] = \
- '{}.{}'.format(field.pretty_name, topology.pretty_tag)
- #gprint('Adding edge between {} and {}.'.format(int(src_node), int(dst_node)))
- return edge
+ return new_edge(graph, src_node, dst_node, field, topology)
else:
return None
-
def push_generated_operators(self, op_generator, op_name_prefix,
- src_topo, graph, vertex_properties, edge_properties):
+ src_topo, graph):
field = self.field
read_nodes = self.read_nodes
@@ -775,21 +623,17 @@ class GraphBuilder(object):
assert op.input_fields.values()[0] == src_topo
dst_topo = op.output_fields.values()[0]
- op_node = self.add_vertex(graph, vertex_properties, op)
+ op_node = self.add_vertex(graph, op)
# handle input
if (src_topo in write_nodes):
src_node = write_nodes[src_topo]
- self.add_edge(graph, edge_properties,
- src_node, op_node,
- field, src_topo)
+ self.add_edge(graph, src_node, op_node, field, src_topo)
# handle output
ro_nodes = read_nodes.setdefault(dst_topo, [])
for ro_node in ro_nodes:
- self.add_edge(graph, edge_properties,
- ro_node, op_node,
- field, dst_topo)
+ self.add_edge(graph, ro_node, op_node, field, dst_topo)
read_nodes[dst_topo] = []
write_nodes[dst_topo] = op_node
@@ -806,66 +650,63 @@ class GraphBuilder(object):
op_input_topology_states[op] = istate
op_output_topology_states[op] = ostate
- vertex_properties['op_info'][op_node] = _op_info(op,
- istates=istate, ostates=ostate)
+ op_node.set_op_info(op, istate, ostate)
src_node = op_node
src_topo = dst_topo
return dst_topo
- def redistribute(self, target_topo,
- graph, vertex_properties, edge_properties,
- src_topo=None):
-
- field = self.field
- write_nodes = self.write_nodes
- dstates = self.discrete_topology_states
+ def redistribute(self, target_topo, graph, src_topo=None):
- #field has never been written
- if not write_nodes:
- return
+ field = self.field
+ write_nodes = self.write_nodes
+ dstates = self.discrete_topology_states
- src_topos = write_nodes.keys()
- if (src_topo is not None):
+ #field has never been written
+ if not write_nodes:
+ return
+
+ src_topos = write_nodes.keys()
+ if (src_topo is not None):
+ assert src_topo in src_topos
+ src_topos = (src_topo,)
+
+ if (target_topo in src_topos):
+ # topology is already up to date with lastest write, nothing to do
+ return
+
+ msg0='field {} from up to date topology:'
+ msg0+='\n |-{}\n to topology\n |>{}'
+ msg0=msg0.format(field.name,
+ '\n |-'.join(t.short_description() for t in src_topos),
+ target_topo.short_description())
+ gprint(' >Redistribute {}'.format(msg0))
+
+ # field is out of date on target topology, we should redistribute data
+ # from another topology
+ try:
+ redistribute_generator = Redistribute(
+ variables=field,
+ source_topos=src_topos,
+ target_topo=target_topo)
+ redistribute_generator.generate()
+ except RedistributeNotImplementedError:
+ msg='FATAL ERROR: Graph builder could not find suitable operator on '
+ msg+='backend {} to redistribute {}'
+ msg=msg.format(src_topo.backend.kind, msg0)
+ print('\n{}\n'.format(msg))
+ raise
+
+ src_topo = redistribute_generator.nodes[0].source_topo
assert src_topo in src_topos
- src_topos = (src_topo,)
-
- if (target_topo in src_topos):
- # topology is already up to date with lastest write, nothing to do
- return
- msg0='field {} from up to date topology:\n |-{}\n to topology\n |>{}'
- msg0=msg0.format(field.name,
- '\n |-'.join(t.short_description() for t in src_topos),
- target_topo.short_description())
- gprint(' >Redistribute {}'.format(msg0))
-
- # field is out of date on target topology, we should redistribute data
- # from another topology
- try:
- redistribute_generator = Redistribute(
- variables=field,
- source_topos=src_topos,
- target_topo=target_topo)
- redistribute_generator.generate()
- except RedistributeNotImplementedError:
- msg='FATAL ERROR: Graph builder could not find suitable operator on '
- msg+='backend {} to redistribute {}'
- msg=msg.format(src_topo.backend.kind, msg0)
- print('\n{}\n'.format(msg))
- raise
-
- src_topo = redistribute_generator.nodes[0].source_topo
- assert src_topo in src_topos
-
- dst_topo = self.push_generated_operators(redistribute_generator, 'R',
- src_topo, graph, vertex_properties, edge_properties)
- assert dst_topo == target_topo
-
- def transpose(self, topo, target_axes,
- graph, vertex_properties, edge_properties):
+ dst_topo = self.push_generated_operators(redistribute_generator, 'R',
+ src_topo, graph)
+ assert dst_topo == target_topo
+ def transpose(self, topo, target_axes, graph):
+
field = self.field
write_nodes = self.write_nodes
dstates = self.discrete_topology_states
@@ -879,7 +720,8 @@ class GraphBuilder(object):
if src_state.axes in target_axes:
return
- msg=' >Transpose from state {} to any of those transposition states [{},] '
+ msg=' >Transpose from state {} to any of those transposition states '
+ msg+='[{},] '
msg=msg.format(src_state.tstate,
', '.join([str(TranspositionState.axes_to_tstate(axes))
for axes in target_axes]))
@@ -904,8 +746,8 @@ class GraphBuilder(object):
transpose_generator.generate()
except TranspositionNotImplementedError:
msg='FATAL ERROR: Graph builder could not find suitable operator on '
- msg+='backend {} to transpose from state {} to any of those transposition '
- msg+='states [{},] for field {} on topology id {}.'
+ msg+='backend {} to transpose from state {} to any of those '
+ msg+='transposition states [{},] for field {} on topology id {}.'
msg=msg.format(topo.backend.kind,
src_state.tstate,
', '.join([TranspositionState.axes_to_tstate(axes)
@@ -914,12 +756,11 @@ class GraphBuilder(object):
print('\n{}\n'.format(msg))
raise
- dst_topo = self.push_generated_operators(transpose_generator, 'T', topo,
- graph, vertex_properties, edge_properties)
+ dst_topo = self.push_generated_operators(transpose_generator, 'T',
+ topo, graph)
assert dst_topo == topo
- def reorder(self, topo, target_memory_order,
- graph, vertex_properties, edge_properties):
+ def reorder(self, topo, target_memory_order, graph):
field = self.field
write_nodes = self.write_nodes
@@ -945,8 +786,8 @@ class GraphBuilder(object):
target_memory_order=target_memory_order)
reorder_generator.generate()
except MemoryReorderingNotImplementedError:
- msg='FATAL ERROR: Graph builder could not find suitable operator on backend {} '
- msg+='to reorder a field from order {} to order {} '
+ msg='FATAL ERROR: Graph builder could not find suitable operator on '
+ msg+='backend {} to reorder a field from order {} to order {} '
msg+='for field {} on topology id {}.'
msg=msg.format(topo.backend.kind,
src_state.memory_order, target_memory_order,
@@ -954,17 +795,18 @@ class GraphBuilder(object):
print('\n{}\n'.format(msg))
raise
- dst_topo = self.push_generated_operators(reorder_generator, 'MR', topo,
- graph, vertex_properties, edge_properties)
+ dst_topo = self.push_generated_operators(reorder_generator, 'MR',
+ topo, graph)
assert dst_topo == topo
def handle_input(self, opnode, target_topo, target_dfield_requirements,
- graph, edge_properties, vertex_properties, is_new):
+ graph, is_new):
ifield = self.field
write_nodes = self.write_nodes
read_nodes = self.read_nodes
dtopology_states = self.discrete_topology_states
+
is_root = (target_dfield_requirements is not None)
dim = target_topo.domain.dim
@@ -979,14 +821,11 @@ class GraphBuilder(object):
from hysop.operator.hdf_io import HDF_Writer
io_params, op_kwds = self.dump_ifield
variables = {ifield: target_topo}
- writer_op = HDF_Writer(io_params=io_params, variables=variables,
- **op_kwds)
+ writer_op = HDF_Writer(io_params=io_params, variables=variables, **op_kwds)
writer_op.initialize(topgraph_method=self.method)
writer_op.get_and_set_field_requirements()
- writer_opnode = self.add_vertex(graph, vertex_properties, writer_op)
- self.add_edge(graph, edge_properties,
- writer_opnode, opnode,
- ifield, target_topo)
+ writer_opnode = self.add_vertex(graph, writer_op)
+ self.add_edge(graph, writer_opnode, opnode, ifield, target_topo)
# we only handle input field requirements when we are root graph
# ie. target_dfield_requirements is None
@@ -1009,8 +848,10 @@ class GraphBuilder(object):
else:
istate.axes = allowed_axes[0]
- allowed_memory_order = target_dfield_requirements.memory_order
- default_memory_order = self.discrete_topology_states[target_topo].memory_order
+ allowed_memory_order = \
+ target_dfield_requirements.memory_order
+ default_memory_order = \
+ self.discrete_topology_states[target_topo].memory_order
assert (default_memory_order is not MemoryOrdering.ANY)
if (allowed_memory_order is MemoryOrdering.ANY):
istate.memory_order = default_memory_order
@@ -1026,53 +867,60 @@ class GraphBuilder(object):
target_memory_order = target_dfield_requirements.memory_order
def topology_affinity(candidate_topo):
candidate_state = self.discrete_topology_states[candidate_topo]
- score = (candidate_topo is target_topo) * 1000000 # skip redistribute
- score += (candidate_topo.grid_resolution
- == target_topo.grid_resolution).all()*100000 # skip multiresolution filter (not automatically handled yet)
+ # skip redistribute
+ score = (candidate_topo is target_topo) * 1000000
+ # skip multiresolution filter (not automatically handled yet)
+ score += (candidate_topo.grid_resolution
+ == target_topo.grid_resolution).all()*100000
+ # skip transpose
score += ((target_axes is not None) and
- (candidate_state.axes in target_axes))*10000 # skip transpose
- score += (candidate_topo.backend is target_topo.backend)*1000 # better bandwidth
- score += (candidate_topo.backend.kind is target_topo.backend.kind)*100 # better bandwidth
+ (candidate_state.axes in target_axes))*10000
+ # better bandwidth
+ score += (candidate_topo.backend
+ is target_topo.backend)*1000
+ # better bandwidth
+ score += (candidate_topo.backend.kind
+ is target_topo.backend.kind)*100
+ # memory reordering is a noop
score += ((target_memory_order is not MemoryOrdering.ANY) and
- (candidate_state.memory_order is target_memory_order))*1 # memory reordering is a noop
- score -= (np.prod(candidate_topo.ghosts)) # penalize number of ghosts
+ (candidate_state.memory_order is target_memory_order))*1
+ # penalize number of ghosts
+ score -= (np.prod(candidate_topo.ghosts))
return score
-
+
if (target_topo.backend.kind is Backend.HOST) and write_nodes:
# give source topo priority according to topology_affinity
src_topos = write_nodes.keys()
src_topos = sorted(src_topos, key=topology_affinity, reverse=True)
src_topo = src_topos[0]
if (src_topo is not target_topo):
- gprint(' >Redistributing field {} from up to date topologies {} to host topology {}.'.format(
- ifield.name, ' ,'.join(t.pretty_tag for t in src_topos), target_topo.pretty_tag))
- self.transpose(src_topo, target_axes,
- graph, vertex_properties, edge_properties)
- self.redistribute(target_topo, graph,
- vertex_properties, edge_properties, src_topo=src_topo)
+ msg=' >Redistributing field {} from up to date topologies {} '
+ msg+='to host topology {}.'
+ msg=msg.format(ifield.name, ' ,'.join(t.pretty_tag
+ for t in src_topos), target_topo.pretty_tag)
+ gprint(msg)
+ self.transpose(src_topo, target_axes, graph)
+ self.redistribute(target_topo, graph, src_topo=src_topo)
# we can always reorder target because this a host topology
- self.reorder(target_topo, target_memory_order,
- graph, vertex_properties, edge_properties)
+ self.reorder(target_topo, target_memory_order, graph)
elif (target_topo.backend.kind is Backend.OPENCL) and write_nodes:
# give source topo priority according to topology_affinity
src_topos = write_nodes.keys()
src_topos = sorted(src_topos, key=topology_affinity, reverse=True)
src_topo = src_topos[0]
if (src_topo is not target_topo):
- gprint(' >Redistributing field {} from up to date topologies {} to device topology {}.'.format(
- ifield.name, ' ,'.join(t.pretty_tag for t in src_topos), target_topo.pretty_tag))
- self.reorder(src_topo, target_memory_order,
- graph, vertex_properties, edge_properties)
- self.redistribute(target_topo, graph,
- vertex_properties, edge_properties, src_topo=src_topo)
+ msg=' >Redistributing field {} from up to date topologies {} '
+ msg+='to device topology {}.'
+ msg=msg.format(ifield.name, ' ,'.join(t.pretty_tag
+ for t in src_topos), target_topo.pretty_tag)
+ gprint(msg)
+ self.reorder(src_topo, target_memory_order, graph)
+ self.redistribute(target_topo, graph, src_topo=src_topo)
# target is always opencl so we transpose here
- self.transpose(target_topo, target_axes,
- graph, vertex_properties, edge_properties)
+ self.transpose(target_topo, target_axes, graph)
else:
- self.transpose(target_topo, target_axes,
- graph, vertex_properties, edge_properties)
- self.reorder(target_topo, target_memory_order,
- graph, vertex_properties, edge_properties)
+ self.transpose(target_topo, target_axes, graph)
+ self.reorder(target_topo, target_memory_order, graph)
istate = dtopology_states[target_topo]
gprint2(' >Input state is now {}'.format(istate))
@@ -1084,21 +932,16 @@ class GraphBuilder(object):
output_states = {}
self.op_input_topology_states[writer_op] = input_states
self.op_output_topology_states[writer_op] = output_states
- vertex_properties['op_info'][writer_opnode] = _op_info(writer_op,
- input_states, output_states)
+ writer_opnode.set_op_info(writer_op, input_states, output_states)
# add read dependency to last written node before current op
# (so that inputs are modified before actual call to the operator)
if (target_topo in write_nodes):
last_write_node = write_nodes[target_topo]
- self.add_edge(graph, edge_properties,
- last_write_node, opnode,
- ifield, target_topo)
+ self.add_edge(graph, last_write_node, opnode, ifield, target_topo)
elif (not is_root) and write_nodes:
for node in self.write_nodes.values():
- self.add_edge(graph, edge_properties,
- node, opnode,
- ifield, target_topo)
+ self.add_edge(graph, node, opnode, ifield, target_topo)
read_nodes.setdefault(target_topo, []).append(opnode)
if is_new:
@@ -1107,9 +950,8 @@ class GraphBuilder(object):
return istate
- def handle_output(self, opnode, output_topo, oreqs,
- operator, input_topology_states, invalidate_field,
- graph, edge_properties, vertex_properties):
+ def handle_output(self, opnode, output_topo, oreqs, operator,
+ input_topology_states, invalidate_field, graph):
ofield = self.field
write_nodes = self.write_nodes
@@ -1121,27 +963,33 @@ class GraphBuilder(object):
# add dependency to last node written to prevent
# concurent write-writes.
if (output_topo in write_nodes):
- self.add_edge(graph, edge_properties,
- write_nodes[output_topo], opnode,
- ofield, output_topo)
-
+ self.add_edge(graph, write_nodes[output_topo],
+ opnode, ofield, output_topo)
+
if invalidate_field:
- gprint(' >Invalidating output field {} on all topologies but {} because is has been freshly written.'.format(ofield.name, output_topo.pretty_tag))
+ msg=' >Invalidating output field {} on all topologies but {} '
+ msg+='because is has been freshly written.'
+ msg=msg.format(ofield.name, output_topo.pretty_tag)
+ gprint()
# add dependency to all operators that reads this field
# to prevent concurent read-writes.
if output_topo in read_nodes:
for ro_node in read_nodes[output_topo]:
- self.add_edge(graph, edge_properties,
- ro_node, opnode,
- ofield, output_topo)
+ self.add_edge(graph, ro_node, opnode, ofield, output_topo)
# remove read/write dependencies and states
write_nodes.clear()
dtopology_states.clear()
else:
- gprint(' >Keeping output field {} up to date on all topologies because is has been marked as preserved by operator.'.format(ofield.name))
- gprint(' >Up to date topologies for field {} are now {}, {}.'.format(ofield.name, output_topo.pretty_tag,
- ' ,'.join(t.pretty_tag for t in write_nodes)))
+ msg=' >Keeping output field {} up to date on all topologies because '
+ msg+='is has been marked as preserved by operator.'
+ msg=msg.format(ofield.name)
+ gprint(msg)
+
+ msg=' >Up to date topologies for field {} are now {}, {}.'
+ msg=msg.format(ofield.name, output_topo.pretty_tag,
+ ' ,'.join(t.pretty_tag for t in write_nodes))
+ gprint(msg)
# add the operator node as the one that lastly wrote this field.
# no other operators can be reading as this topology just been written.
@@ -1151,7 +999,8 @@ class GraphBuilder(object):
if isinstance(operator, Problem):
ostate = operator.final_output_topology_states[ofield][1]
else:
- ostate = operator.output_topology_state(ofield, input_topology_states)
+ ostate = operator.output_topology_state(ofield,
+ input_topology_states)
dtopology_states[output_topo] = ostate
gprint2(' >Output state is now {}'.format(ostate))
else:
@@ -1162,8 +1011,6 @@ class GraphBuilder(object):
return ostate
- def output_as_input(self, target_topo, dstate,
- graph, edge_properties, vertex_properties):
+ def output_as_input(self, target_topo, dstate, graph):
+ self.handle_input(None, target_topo, dstate, graph,False)
- self.handle_input(None, target_topo, dstate,
- graph, edge_properties, vertex_properties, False)
diff --git a/hysop/core/graph/node_generator.py b/hysop/core/graph/node_generator.py
index 67c26dfff3cbb9f492395e8bedcdd875135ab792..5404c4e9e95915c87f112fd3196b40c0cfa84397 100644
--- a/hysop/core/graph/node_generator.py
+++ b/hysop/core/graph/node_generator.py
@@ -80,7 +80,6 @@ class ComputationalGraphNodeGenerator(object):
msg='\nFailed to call generate() in class {}.\n'.format(self.__class__)
print msg
raise
- assert len(self.nodes)>=1
self.candidate_input_tensors = set(filter(lambda x: x.is_tensor,
self.candidate_input_tensors))
diff --git a/hysop/core/graph/node_requirements.py b/hysop/core/graph/node_requirements.py
index c3cc185de2c9733755af916e32f55ed04b49f8f1..243ec321728ad0f6290eab290710cb042058491b 100644
--- a/hysop/core/graph/node_requirements.py
+++ b/hysop/core/graph/node_requirements.py
@@ -202,6 +202,11 @@ class OperatorRequirements(NodeRequirements):
# enforce topology shape (indirectly by enforcing split directions)
if self.enforce_unique_topology_shape:
assert (can_split is not None)
+ if sum(can_split)>1:
+ i=0
+ while can_split[i]==0:
+ i+=1
+ can_split[i+1:] = 0
req.can_split = can_split
# enforce ghosts by setting min and max to the same
diff --git a/hysop/core/graph/tests/test_graph.py b/hysop/core/graph/tests/test_graph.py
index a359a69b1368d63ab28d1530216f5905673f8d10..52b0b754ea44e545b6063fc6bbcb6a0978a2e0e4 100644
--- a/hysop/core/graph/tests/test_graph.py
+++ b/hysop/core/graph/tests/test_graph.py
@@ -1,4 +1,5 @@
-from hysop.domain.box import Box
+import tempfile
+from hysop.domain.box import Box
from hysop.topology.cartesian_topology import CartesianTopology
from hysop.tools.parameters import CartesianDiscretization
from hysop.fields.continuous_field import Field
@@ -44,8 +45,10 @@ class TestGraph(object):
rho1g = Field(domain=box, name='rho1g')
rho1p = Field(domain=box, name='rho1p')
- d3d0 = CartesianDiscretization(resolution=(64,64,64), ghosts=None, default_boundaries=True)
- d3d1 = CartesianDiscretization(resolution=(128,128,128), ghosts=None, default_boundaries=True)
+ d3d0 = CartesianDiscretization(resolution=(64,64,64),
+ ghosts=None, default_boundaries=True)
+ d3d1 = CartesianDiscretization(resolution=(128,128,128),
+ ghosts=None, default_boundaries=True)
t0 = CartesianTopology(domain=box, discretization=d3d0)
t1 = CartesianTopology(domain=box, discretization=d3d1)
@@ -95,6 +98,9 @@ class TestGraph(object):
g.discretize()
g.setup(None)
g.apply()
+
+ with tempfile.NamedTemporaryFile(suffix='.html') as f:
+ g.to_html(f.name)
if display:
g.display()
diff --git a/hysop/core/memory/buffer.py b/hysop/core/memory/buffer.py
index 9014bb58bc2f23bb8fe2ff636a10097821ee1e3b..d84e41ff0f3255c0710b4435b5440432a7ce9800 100644
--- a/hysop/core/memory/buffer.py
+++ b/hysop/core/memory/buffer.py
@@ -26,7 +26,10 @@ class Buffer(object):
try:
super(Buffer, self).__init__(size=size, **kwds)
except TypeError:
- super(Buffer, self).__init__(**kwds)
+ try:
+ super(Buffer, self).__init__(**kwds)
+ except:
+ pass
def __del__(self):
if self._DEBUG:
print 'Releasing {}[{}].'.format(self.__class__.__name__, id(self))
@@ -92,7 +95,6 @@ class PooledBuffer(Buffer):
self._buf = buf
self._bufview = buf.aligned_view(size=size, alignment=alignment)
-
def get_buf(self):
"""
Get wrapped buffer handle.
diff --git a/hysop/core/memory/tests/test_buffer.py b/hysop/core/memory/tests/test_buffer.py
index abb00ff2d4b576a7d33ce724539a80fab01e5765..bb50c103f2c9782f26d206827c9c773ed9becc15 100644
--- a/hysop/core/memory/tests/test_buffer.py
+++ b/hysop/core/memory/tests/test_buffer.py
@@ -84,40 +84,30 @@ if __HAS_OPENCL_BACKEND__:
buf1 = OpenClBuffer(cl_env.context, size=size, mem_flags=mf.READ_WRITE)
assert buf1.int_ptr == buf1.get_int_ptr()
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf1,
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf1,
byte_count=size).wait()
assert buf1.ref_count() == 1
buf1.release()
buf1 = OpenClBuffer(cl_env.context, size=size, mem_flags=mf.READ_WRITE)
- assert buf1.ref_count() == 1
- buf2 = OpenClBuffer.from_cl_buffer(buf1)
- assert buf1.ref_count() == 2
- assert buf2.ref_count() == 2
- assert buf1.int_ptr == buf2.int_ptr
- buf3 = OpenClBuffer.from_int_ptr(buf1.int_ptr, retain=True)
- assert buf1.ref_count() == 3
- assert buf2.ref_count() == 3
- assert buf3.ref_count() == 3
- assert buf1.int_ptr == buf2.int_ptr
- assert buf1.int_ptr == buf3.int_ptr
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf1,
+ buf2 = buf1.get_sub_region(0, buf1.size, buf1.flags)
+ buf3 = buf1.get_sub_region(0, buf1.size, buf1.flags)
+ assert buf1.int_ptr != buf2.int_ptr
+ assert buf1.int_ptr != buf3.int_ptr
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf1,
byte_count=size).wait()
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf2,
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf2,
byte_count=size).wait()
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf3,
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf3,
byte_count=size).wait()
buf1.release()
- assert buf2.ref_count() == 2
- assert buf3.ref_count() == 2
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf2,
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf2,
byte_count=size).wait()
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf3,
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf3,
byte_count=size).wait()
buf3.release()
- assert buf2.ref_count() == 1
- cl.enqueue_copy_buffer(queue=cl_env.default_queue, src=buf, dst=buf2,
+ cl.enqueue_copy(queue=cl_env.default_queue, src=buf, dest=buf2,
byte_count=size).wait()
buf2.release()
diff --git a/hysop/core/memory/tests/test_mempool.py b/hysop/core/memory/tests/test_mempool.py
index ac43f5ee301aef79d4979afb4663b40d2c212704..2646442f55e4875757aa84f569eeaf987435413c 100644
--- a/hysop/core/memory/tests/test_mempool.py
+++ b/hysop/core/memory/tests/test_mempool.py
@@ -1,31 +1,37 @@
from hysop.deps import np
from hysop.testsenv import opencl_failed, iter_clenv, \
- __HAS_OPENCL_BACKEND__, __ENABLE_LONG_TESTS__
+ __HAS_OPENCL_BACKEND__, __ENABLE_LONG_TESTS__
from hysop.core.memory.mempool import MemoryPool
import random
max_bytes_per_alloc = 1024*1024*128 # 128MB
-free = lambda: bool(random.random()>0.1) # 80% probability of free
-nbytes = lambda: int(2.0**(np.log2(max_bytes_per_alloc)*random.random()))
+
+
+def free(): return bool(random.random() > 0.1) # 80% probability of free
+
+
+def nbytes(): return int(2.0**(np.log2(max_bytes_per_alloc)*random.random()))
+
def test_mempool_python_allocator():
from hysop.backend.host.host_allocator import HostAllocator
allocator = HostAllocator()
_test_mempool_allocator('python', allocator)
-@opencl_failed
-def test_mempool_opencl_immediate_allocator():
- from hysop.backend.device.opencl.opencl_allocator import OpenClImmediateAllocator
+# @opencl_failed
+# def test_mempool_opencl_immediate_allocator():
+# from hysop.backend.device.opencl.opencl_allocator import OpenClImmediateAllocator
+
+# for cl_env in iter_clenv():
+# allocator = OpenClImmediateAllocator(queue=cl_env.default_queue)
+# _test_mempool_allocator(cl_env.platform.name, allocator)
- for cl_env in iter_clenv():
- allocator = OpenClImmediateAllocator(queue=cl_env.default_queue)
- _test_mempool_allocator(cl_env.platform.name, allocator)
def _test_mempool_allocator(name, allocator):
pool = allocator.memory_pool(name=name)
buffers = []
try:
- while True:
+ for _ in range(10000):
size = nbytes()
buf = pool.allocate(size)
if not free():
@@ -33,7 +39,8 @@ def _test_mempool_allocator(name, allocator):
except MemoryError:
pass
+
if __name__ == '__main__':
test_mempool_python_allocator()
- if __HAS_OPENCL_BACKEND__:
- test_mempool_opencl_immediate_allocator()
+ # if __HAS_OPENCL_BACKEND__:
+ # test_mempool_opencl_immediate_allocator()
diff --git a/hysop/core/mpi/__init__.py b/hysop/core/mpi/__init__.py
index 083839c68ba246a89a2de51bb5f86cff3396e758..d268d085bed74b70b4149d155e0f3d53b8fbd537 100644
--- a/hysop/core/mpi/__init__.py
+++ b/hysop/core/mpi/__init__.py
@@ -44,19 +44,19 @@ shm_size = shm_comm.Get_size()
intershm_comm = main_comm.Split(color=int(shm_rank==0), key=main_rank)
"""Communicator between shared memory local master ranks"""
-if shm_rank!=0:
+if (shm_rank!=0):
intershm_comm.Free()
intershm_comm = None
intershm_rank = None
- intershm_size = None
+ intershm_size = shm_comm.bcast(None, root=0)
is_multishm = False
else:
intershm_rank = intershm_comm.Get_rank()
"""Communicator rank between shm masters"""
- intershm_size = intershm_comm.Get_size()
+ intershm_size = shm_comm.bcast(intershm_comm.Get_size(), root=0)
"""Communicator size between shm masters"""
- is_multishm = (intershm_size>1)
- """True if shm_rank=0 and the programm runs on different shared memory communicators"""
+is_multishm = (intershm_size>1)
+"""True if the programm runs on different shared memory communicators"""
host_comm = main_comm.Split(color=processor_hash, key=main_rank)
"""Intrahost communicator"""
@@ -68,19 +68,18 @@ host_size = host_comm.Get_size()
interhost_comm = main_comm.Split(color=int(host_rank==0), key=main_rank)
"""Interhost communicator (between each host local master rank)"""
-if host_rank!=0:
+if (host_rank!=0):
interhost_comm.Free()
interhost_comm = None
interhost_rank = None
- interhost_size = None
- is_multihost = False
+ interhost_size = main_comm.bcast(None, root=0)
else:
interhost_rank = interhost_comm.Get_rank()
"""Communicator rank between hosts"""
- interhost_size = interhost_comm.Get_size()
+ interhost_size = main_comm.bcast(interhost_comm.Get_size(), root=0)
"""Communicator size between hosts"""
- is_multihost = (interhost_size>1)
- """True if host_rank=0 and the programm runs on different hosts"""
+is_multihost = (interhost_size>1)
+"""True if the programm runs on different hosts"""
Wtime = MPI.Wtime
"""Function to return elapsed time since some time in the past.
@@ -101,3 +100,4 @@ def default_mpi_params():
from hysop.constants import HYSOP_DEFAULT_TASK_ID
return MPIParams(comm=main_comm,
task_id=HYSOP_DEFAULT_TASK_ID)
+
diff --git a/hysop/core/mpi/bridge.py b/hysop/core/mpi/bridge.py
index 536c3f48ccfc38b499845c90cbdceea65320e8b0..ad49e3bb85411ff622bb795ff37c0f30437d166b 100644
--- a/hysop/core/mpi/bridge.py
+++ b/hysop/core/mpi/bridge.py
@@ -21,7 +21,7 @@ class Bridge(object):
Intersection between two topologies.
"""
- def __init__(self, source, target, dtype):
+ def __init__(self, source, target, dtype, order):
"""Intersection between two topologies.
See users' manual for details
@@ -51,9 +51,10 @@ class Bridge(object):
self._source = source
self._target = target
self._dtype = dtype
+ self._order = order
self._check_topologies()
# nothing to be done ...
- if source == target:
+ if (source == target):
return
self._build_send_recv_dict()
@@ -79,7 +80,7 @@ class Bridge(object):
"""
# Get global indices of the mesh on source for all mpi processes.
indices_source = TopoTools.gather_global_indices(self._source)
-
+
# Get global indices of the mesh on target for all mpi processes.
indices_target = TopoTools.gather_global_indices(self._target)
# From now on, we have indices_source[rk] = global indices (slice)
@@ -95,13 +96,13 @@ class Bridge(object):
current = indices_source[self._rank]
for rk in indices_target:
inter = Utils.intersect_slices(current, indices_target[rk])
- if inter is not None:
+ if (inter is not None):
self._send_indices[rk] = inter
+
# Back to local indices
convert = self._source.mesh.global_to_local
self._send_indices = {rk: convert(self._send_indices[rk])
for rk in self._send_indices}
-
# Compute the intersections of the mesh on target with every mesh on
# source ---> find which part of the local mesh must recv something
# and from who,
@@ -112,7 +113,7 @@ class Bridge(object):
current = indices_target[self._rank]
for rk in indices_source:
inter = Utils.intersect_slices(current, indices_source[rk])
- if inter is not None:
+ if (inter is not None):
self._recv_indices[rk] = inter
convert = self._target.mesh.global_to_local
@@ -149,7 +150,7 @@ class Bridge(object):
if (self._recv_types is None):
data_shape = self._target.mesh.local_resolution
self._recv_types = TopoTools.create_subarray(self._recv_indices,
- data_shape, dtype=self._dtype)
+ data_shape, dtype=self._dtype, order=self._order)
return self._recv_types
def send_types(self):
@@ -158,7 +159,7 @@ class Bridge(object):
if (self._send_types is None):
data_shape = self._source.mesh.local_resolution
self._send_types = TopoTools.create_subarray(self._send_indices,
- data_shape, dtype=self._dtype)
+ data_shape, dtype=self._dtype, order=self._order)
return self._send_types
@@ -265,7 +266,7 @@ class BridgeInter(object):
current_task = self._topology.domain.current_task()
if current_task is self.source_id:
# Local 0 broadcast current_indices to remote comm
- if rank == 0:
+ if (rank == 0):
self.comm.bcast(current_indices.handle(), root=MPI.ROOT)
else:
self.comm.bcast(current_indices.handle(), root=MPI.PROC_NULL)
@@ -276,7 +277,7 @@ class BridgeInter(object):
# Get remote indices from remote comm
remote_indices = self.comm.bcast(remote_indices.handle(), root=0)
# Local 0 broadcast current_indices to remote comm
- if rank == 0:
+ if (rank == 0):
self.comm.bcast(current_indices.handle(), root=MPI.ROOT)
else:
self.comm.bcast(current_indices.handle(), root=MPI.PROC_NULL)
diff --git a/hysop/core/mpi/redistribute.py b/hysop/core/mpi/redistribute.py
index ef03ea822b10de5f3a7d720235d8eb494b0927eb..3bc69beff1911f69dcb268c30a99c71ec3e75f45 100644
--- a/hysop/core/mpi/redistribute.py
+++ b/hysop/core/mpi/redistribute.py
@@ -14,16 +14,19 @@ redistribute deployment.
inside the same mpi parent communicator and
with a different number of processes
"""
-
+
from hysop.constants import Backend, DirectionLabels
from hysop.tools.types import check_instance, to_set
from hysop.tools.decorators import debug, not_implemented
from hysop.tools.numpywrappers import npw, slices_empty
+from hysop.tools.mpi_utils import get_mpi_order
from hysop.topology.cartesian_topology import Topology, CartesianTopology
from hysop.core.mpi.topo_tools import TopoTools
from hysop.core.mpi.bridge import Bridge, BridgeOverlap, BridgeInter
from hysop.operator.base.redistribute_operator import RedistributeOperatorBase
-
+from hysop.core.graph.graph import op_apply
+
+DEBUG_REDISTRIBUTE=0
def _memcpy(dst, src, target_indices, source_indices):
def _runtime_error():
@@ -31,6 +34,7 @@ def _memcpy(dst, src, target_indices, source_indices):
msg=msg.format(src.__class__, dst.__class__)
raise RuntimeError(msg)
+ assert (src.dtype == dst.dtype)
skind = src.backend.kind
tkind = dst.backend.kind
@@ -41,9 +45,10 @@ def _memcpy(dst, src, target_indices, source_indices):
elif (tkind==Backend.OPENCL):
from hysop.backend.device.opencl.opencl_copy_kernel_launchers import \
OpenClCopyBufferRectLauncher
- knl = OpenClCopyBufferRectLauncher.from_slices(varname='redistribute',
- src=src, dst=dst,
- src_slices=source_indices, dst_slices=target_indices)
+ knl = OpenClCopyBufferRectLauncher.from_slices(
+ varname='redistribute',
+ src=src, dst=dst,
+ src_slices=source_indices, dst_slices=target_indices)
evt = knl(queue=dst.default_queue)
else:
_runtime_error()
@@ -51,15 +56,17 @@ def _memcpy(dst, src, target_indices, source_indices):
from hysop.backend.device.opencl.opencl_copy_kernel_launchers import \
OpenClCopyBufferRectLauncher
if (tkind==Backend.HOST):
- knl = OpenClCopyBufferRectLauncher.from_slices(varname='redistribute',
- src=src, dst=dst,
- src_slices=source_indices, dst_slices=target_indices)
+ knl = OpenClCopyBufferRectLauncher.from_slices(
+ varname='redistribute',
+ src=src, dst=dst,
+ src_slices=source_indices, dst_slices=target_indices)
evt = knl(queue=src.default_queue)
elif (tkind==Backend.OPENCL):
assert (src.backend.cl_env is dst.backend.cl_env)
- knl = OpenClCopyBufferRectLauncher.from_slices(varname='redistribute',
- src=src, dst=dst,
- src_slices=source_indices, dst_slices=target_indices)
+ knl = OpenClCopyBufferRectLauncher.from_slices(
+ varname='redistribute',
+ src=src, dst=dst,
+ src_slices=source_indices, dst_slices=target_indices)
evt = knl(queue=src.default_queue)
else:
_runtime_error()
@@ -67,6 +74,7 @@ def _memcpy(dst, src, target_indices, source_indices):
_runtime_error()
return evt
+
class RedistributeIntra(RedistributeOperatorBase):
"""Data transfer between two operators/topologies.
Source and target must:
@@ -77,7 +85,7 @@ class RedistributeIntra(RedistributeOperatorBase):
@classmethod
def can_redistribute(cls, source_topo, target_topo):
- tin = source_topo
+ tin = source_topo
tout = target_topo
# source and target must be CartesianTopology topology defined on HostArrayBackend
@@ -85,7 +93,7 @@ class RedistributeIntra(RedistributeOperatorBase):
return False
if not isinstance(target_topo, CartesianTopology):
return False
-
+
# source and target must have the same global resolution
source_res = tin.mesh.grid_resolution
target_res = tout.mesh.grid_resolution
@@ -123,9 +131,25 @@ class RedistributeIntra(RedistributeOperatorBase):
super(RedistributeIntra,self).discretize()
# we can create the bridge
- source_topo = self.input_fields[self.variable]
- target_topo = self.output_fields[self.variable]
- self.bridge = Bridge(source_topo, target_topo, self.dtype)
+ ifield = self.input_discrete_fields[self.variable]
+ ofield = self.output_discrete_fields[self.variable]
+ source_topo = ifield.topology
+ target_topo = ofield.topology
+ sstate = source_topo.topology_state
+ tstate = target_topo.topology_state
+ if (sstate.dim != tstate.dim) or (sstate.axes!=tstate.axes) \
+ or (sstate.memory_order!=tstate.memory_order):
+ msg='Topology state mismatch between source and target.'
+ msg+='\nSource topology state:'
+ msg+=str(sstate)
+ msg+='\nTarget topology state:'
+ msg+=str(tstate)
+ raise RuntimeError(msg)
+
+ assert all(source_topo.mesh.local_resolution == ifield.resolution)
+ assert all(target_topo.mesh.local_resolution == ofield.resolution)
+
+ self.bridge = Bridge(source_topo, target_topo, self.dtype, get_mpi_order(ifield.sdata))
self._rank = self.bridge._rank
# dictionnary which maps rank with mpi derived type
@@ -135,14 +159,18 @@ class RedistributeIntra(RedistributeOperatorBase):
# dictionnay which maps rank with mpi derived type
# for send operations
self._receive = self.bridge.recv_types()
-
+
self._has_requests = False
-
- @debug
+
+ self.dFin = ifield
+ self.dFout = ofield
+
+ @op_apply
def apply(self, **kwds):
# Try different way to send vars?
# - Buffered : copy all data into a buffer and send/recv
# - Standard : one send/recv
+ dFin, dFout = self.dFin, self.dFout
super(RedistributeIntra,self).apply(**kwds)
@@ -155,7 +183,7 @@ class RedistributeIntra(RedistributeOperatorBase):
self._s_request = {}
basetag = self.mpi_params.rank + 1
-
+
# Comm used for send/receive operations
# It must contains all proc. of source topo and
# target topo.
@@ -163,38 +191,42 @@ class RedistributeIntra(RedistributeOperatorBase):
v = self.variable
local_evts = ()
- for d in (0,): # now we work only with scalars
- v_name = v.name
-
- # Deal with local copies of data
- if br.has_local_inter():
- dst = self._vtarget[v].data[d]
- src = self._vsource[v].data[d]
- source_indices = br.local_source_ind()
- target_indices = br.local_target_ind()
- evt = _memcpy(dst, src, target_indices, source_indices)
- if (evt is not None):
- local_evts += (evt,)
-
- # Transfers to other mpi processes
- for rk in self._receive:
- if rk == self._rank:
- continue
- recvtag = basetag * 989 + (rk + 1) * 99 + (d + 1) * 88
- mpi_type = self._receive[rk]
- dst = self._vtarget[v].data[d]
- self._r_request[v_name + str(rk)] = \
- refcomm.Irecv([dst.handle, 1, mpi_type], source=rk, tag=recvtag)
- self._has_requests = True
- for rk in self._send:
- if rk == self._rank:
- continue
- sendtag = (rk + 1) * 989 + basetag * 99 + (d + 1) * 88
- mpi_type = self._send[rk]
- src = self._vsource[v].data[d]
- self._s_request[v_name + str(rk)] = \
- refcomm.Issend([src.handle, 1, mpi_type], dest=rk, tag=sendtag)
- self._has_requests = True
+ v_name = v.name
+
+ # Deal with local copies of data
+ if br.has_local_inter():
+ dst = self._vtarget[v].sdata
+ src = self._vsource[v].sdata
+ axes = self._vtarget[v].topology_state.axes
+ source_indices = br.local_source_ind()
+ target_indices = br.local_target_ind()
+ evt = _memcpy(dst, src,
+ target_indices,
+ source_indices)
+ if (evt is not None):
+ local_evts += (evt,)
+
+ # Transfers to other mpi processes
+ for rk in self._receive:
+ if (rk == self._rank):
+ continue
+ assert (src.backend.kind is Backend.HOST) and (dst.backend.kind is Backend.HOST)
+ recvtag = basetag * 989 + (rk + 1) * 99
+ mpi_type = self._receive[rk]
+ dst = self._vtarget[v].sdata
+ self._r_request[v_name + str(rk)] = \
+ refcomm.Irecv([dst.handle, 1, mpi_type], source=rk, tag=recvtag)
+ self._has_requests = True
+ for rk in self._send:
+ if (rk == self._rank):
+ continue
+ assert (src.backend.kind is Backend.HOST) and (dst.backend.kind is Backend.HOST)
+ sendtag = (rk + 1) * 989 + basetag * 99
+ mpi_type = self._send[rk]
+ src = self._vsource[v].sdata
+ self._s_request[v_name + str(rk)] = \
+ refcomm.Issend([src.handle, 1, mpi_type], dest=rk, tag=sendtag)
+ self._has_requests = True
for evt in local_evts:
evt.wait()
@@ -204,6 +236,22 @@ class RedistributeIntra(RedistributeOperatorBase):
self._r_request[rk].Wait()
for rk in self._s_request:
self._s_request[rk].Wait()
- for dfield in self.output_discrete_fields.values():
- dfield.exchange_ghosts()
self._has_requests = False
+
+ if DEBUG_REDISTRIBUTE:
+ print 'resolution, compute_resolution, ghosts, compute_slices'
+ print dFin.resolution, dFin.compute_resolution, dFin.ghosts, dFin.compute_slices
+ print dFout.resolution, dFout.compute_resolution, dFout.ghosts, dFout.compute_slices
+ print
+ print 'BEFORE'
+ dFout.print_with_ghosts()
+
+ dFout.exchange_ghosts()
+
+ if DEBUG_REDISTRIBUTE:
+ print 'AFTER'
+ dFout.print_with_ghosts()
+ mean_in = refcomm.allreduce(dFin.sdata[dFin.compute_slices].sum().get()) / float(refcomm.size)
+ mean_out = refcomm.allreduce(dFout.sdata[dFout.compute_slices].sum().get()) / float(refcomm.size)
+ assert npw.isclose(mean_in, mean_out), '{} != {}'.format(mean_in, mean_out)
+
diff --git a/hysop/core/mpi/topo_tools.py b/hysop/core/mpi/topo_tools.py
index 388adee1529333cbb9a433abeca62ea69752d53e..72905c7759ebd95df4d3b202853aecca13480967 100644
--- a/hysop/core/mpi/topo_tools.py
+++ b/hysop/core/mpi/topo_tools.py
@@ -8,14 +8,14 @@ from itertools import count
from abc import ABCMeta, abstractmethod
from hysop.constants import np, math, Backend
from hysop.constants import BoundaryCondition
-from hysop.constants import HYSOP_MPI_REAL, HYSOP_MPI_ORDER
+from hysop.constants import HYSOP_MPI_REAL
from hysop.mesh.mesh import Mesh
from hysop.core.mpi import MPI
from hysop.tools.types import check_instance, to_tuple, first_not_None
-from hysop.tools.mpi_utils import dtype_to_mpi_type
+from hysop.tools.mpi_utils import dtype_to_mpi_type, iter_mpi_requests, create_sized, get_mpi_order
from hysop.tools.parameters import MPIParams
from hysop.tools.misc import Utils
-from hysop.tools.decorators import debug
+from hysop.tools.decorators import debug
from hysop.tools.numpywrappers import npw
from hysop.tools.string_utils import prepend
@@ -61,13 +61,15 @@ class TopoTools(object):
# communicator that owns the topology
rank = comm.Get_rank()
dimension = topo.domain.dim
- iglob = npw.integer_zeros((dimension * 2, size))
- iglob_res = npw.integer_zeros((dimension * 2, size))
+ iglob = npw.integer_zeros((dimension * 2, size), order='F')
+ iglob_res = npw.integer_zeros((dimension * 2, size), order='F')
iglob[0::2, rank] = start
iglob[1::2, rank] = end
# iglob is saved as a numpy array and then transform into
# a dict of slices since mpi send operations are much
# more efficient with numpy arrays.
+ # iglob is stored in 'F' order in order to send contiguous buffers in
+ # the following gather operations
if root is None:
comm.Allgather([iglob[:, rank], MPI.INT], [iglob_res, MPI.INT])
else:
@@ -223,7 +225,7 @@ class TopoTools(object):
return {r_source[i]: res[i] for i in xrange(size_source)}
@staticmethod
- def create_subarray(sl_dict, data_shape,
+ def create_subarray(sl_dict, data_shape, order,
mpi_type=None, dtype=None):
"""Create a MPI subarray mask to be used in send/recv operations
between some topologies.
@@ -250,7 +252,7 @@ class TopoTools(object):
substep = tuple((slc[i][2] for i in xrange(dim)))
assert all(substep[i] == 1 for i in xrange(dim))
subtype = mpi_type.Create_subarray(data_shape, subvshape,
- substart, order=HYSOP_MPI_ORDER)
+ substart, order=order)
subtype.Commit()
return subtype
@@ -262,6 +264,30 @@ class TopoTools(object):
else:
return _create_subarray(sl_dict, data_shape)
+ @staticmethod
+ def create_subarray_from_buffer(data, slices):
+ from hysop.core.arrays.array import Array
+ dim = data.ndim
+ shape = data.shape
+ dtype = data.dtype
+ order = get_mpi_order(data)
+
+ assert len(slices)==dim
+ slices = tuple(slices[i].indices(shape[i]) for i in xrange(dim))
+ subshape = tuple((slices[i][1] - slices[i][0] for i in xrange(dim)))
+ substart = tuple((slices[i][0] for i in xrange(dim)))
+ substep = tuple((slices[i][2] for i in xrange(dim)))
+ assert all(0 <= substart[i] < shape[i] for i in xrange(dim))
+ assert all(0 < subshape[i] <= shape[i] for i in xrange(dim))
+ assert all(substep[i] == 1 for i in xrange(dim))
+
+ basetype = dtype_to_mpi_type(dtype)
+ subtype = basetype.Create_subarray(shape, subshape, substart, order=order)
+ subtype.Commit()
+ #print 'MPI_Create_subarray(shape={}, subshape={}, substart={}, order={})'.format(
+ #shape, subshape, substart, 'C' if order is MPI.ORDER_C else 'F')
+ return subtype
+
@staticmethod
def set_group_size(topo):
"""Set default size for groups of lines of particles,
diff --git a/hysop/core/tests/test_checkpoint.sh b/hysop/core/tests/test_checkpoint.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d6cfc4919b1901987aedf81742a1ac9bf1bfb687
--- /dev/null
+++ b/hysop/core/tests/test_checkpoint.sh
@@ -0,0 +1,179 @@
+#!/usr/bin/env bash
+set -feu -o pipefail
+PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE:-python2.7}
+MPIRUN_EXECUTABLE=${MPIRUN_EXECUTABLE:-mpirun --allow-run-as-root}
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+EXAMPLE_DIR="$(realpath ${SCRIPT_DIR}/../../../hysop_examples/examples)"
+
+function compare_files {
+ if [[ ! -f "$1" ]]; then
+ echo "File '${1}' does not exist."
+ exit 1
+ fi
+ if [[ ! -f "$2" ]]; then
+ echo "File '${2}' does not exist."
+ exit 1
+ fi
+
+ # see https://stackoverflow.com/questions/3679296/only-get-hash-value-using-md5sum-without-filename
+ # for the bash array assignment trick (solution proposed by Peter O.)
+ # we also remove signs in front of zeros
+ A=($(sha1sum <(sed 's/[+-]\(0\.0*\s\)/+\1/g' ${1})))
+ B=($(sha1sum <(sed 's/[+-]\(0\.0*\s\)/+\1/g' ${2})))
+ if [[ "${A}" != "${B}" ]]; then
+ echo "Could not match checksums between ${1} and ${2}."
+ exit 1
+ fi
+}
+
+#
+# Basic test with 2D diffusion (serial)
+#
+EXAMPLE_FILE="${EXAMPLE_DIR}/scalar_diffusion/scalar_diffusion.py"
+TEST_DIR='/tmp/hysop_tests/checkpoints/scalar_diffusion'
+COMMON_OPTIONS="-NC -impl opencl -cp fp32 -d64 --debug-dump-target dump -nu 0.02 -niter 20 -te 0.1 --dump-tstart 0.05 --dump-freq 1 "
+
+echo
+echo "TEST SCALAR DIFFUSION CHECKPOINT (SERIAL)"
+if [[ ! -f "${EXAMPLE_FILE}" ]]; then
+ echo "Cannot find example file '${EXAMPLE_FILE}'."
+ exit 1
+fi
+
+echo ' Running simulations...'
+"${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -S "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run0" --checkpoint-dump-time 0.05 --checkpoint-dump-freq 0
+"${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -S "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run1" --checkpoint-dump-time 0.05 --checkpoint-dump-freq 0
+
+echo ' Comparing solutions...'
+echo " >debug dumps match"
+compare_files "${TEST_DIR}/run0/dump/run.txt" "${TEST_DIR}/run1/dump/run.txt"
+for f0 in $(find "${TEST_DIR}/run0" -name '*.h5' | sort -n); do
+ f1=$(echo "${f0}" | sed 's/run0/run1/')
+ compare_files "${f0}" "${f1}"
+ echo " >$(basename ${f0}) match"
+done
+
+echo
+echo ' Running simulations from checkpoints...'
+"${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -L "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run2"
+"${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -L "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run3"
+
+echo ' Comparing solutions...'
+compare_files "${TEST_DIR}/run2/dump/run.txt" "${TEST_DIR}/run3/dump/run.txt"
+echo " >debug dumps match"
+for f0 in $(find "${TEST_DIR}/run2" -name '*.h5' | sort -n); do
+ f1=$(echo "${f0}" | sed 's/run2/run3/')
+ f2=$(echo "${f0}" | sed 's/run2/run0/')
+ f3=$(echo "${f0}" | sed 's/run2/run1/')
+ compare_files "${f0}" "${f1}"
+ compare_files "${f0}" "${f2}"
+ compare_files "${f0}" "${f3}"
+ echo " >$(basename ${f0}) match"
+done
+
+
+#
+# Basic test with 2D diffusion (MPI)
+#
+
+EXAMPLE_FILE="${EXAMPLE_DIR}/scalar_diffusion/scalar_diffusion.py"
+TEST_DIR='/tmp/hysop_tests/checkpoints/scalar_diffusion_mpi'
+COMMON_OPTIONS="-NC -impl opencl -cp fp32 -d64 --debug-dump-target dump -nu 0.02 -niter 20 -te 0.1 --dump-tstart 0.05 --dump-freq 1 "
+
+echo
+echo "TEST SCALAR DIFFUSION CHECKPOINT (MPI)"
+if [[ ! -f "${EXAMPLE_FILE}" ]]; then
+ echo "Cannot find example file '${EXAMPLE_FILE}'."
+ exit 1
+fi
+
+echo ' Running simulations...'
+${MPIRUN_EXECUTABLE} -np 4 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -S "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run0" --checkpoint-dump-time 0.05 --checkpoint-dump-freq 0
+${MPIRUN_EXECUTABLE} -np 4 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -S "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run1" --checkpoint-dump-time 0.05 --checkpoint-dump-freq 0
+
+echo ' Comparing solutions...'
+echo " >debug dumps match"
+compare_files "${TEST_DIR}/run0/dump/run.txt" "${TEST_DIR}/run1/dump/run.txt"
+for f0 in $(find "${TEST_DIR}/run0" -name '*.h5' | sort -n); do
+ f1=$(echo "${f0}" | sed 's/run0/run1/')
+ compare_files "${f0}" "${f1}"
+ echo " >$(basename ${f0}) match"
+done
+
+echo
+echo ' Running simulations from checkpoints...'
+${MPIRUN_EXECUTABLE} -np 4 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -L "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run2"
+${MPIRUN_EXECUTABLE} -np 4 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -L "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run3"
+
+echo ' Comparing solutions...'
+compare_files "${TEST_DIR}/run2/dump/run.txt" "${TEST_DIR}/run3/dump/run.txt"
+echo " >debug dumps match"
+for f0 in $(find "${TEST_DIR}/run2" -name '*.h5' | sort -n); do
+ f1=$(echo "${f0}" | sed 's/run2/run3/')
+ f2=$(echo "${f0}" | sed 's/run2/run0/')
+ f3=$(echo "${f0}" | sed 's/run2/run1/')
+ compare_files "${f0}" "${f1}"
+ compare_files "${f0}" "${f2}"
+ compare_files "${f0}" "${f3}"
+ echo " >$(basename ${f0}) match"
+done
+
+
+#
+# Test 3D with taylor green (Fortran MPI backend)
+#
+EXAMPLE_FILE="${EXAMPLE_DIR}/taylor_green/taylor_green.py"
+TEST_DIR='/tmp/hysop_tests/checkpoints/taylor_green'
+COMMON_OPTIONS="-NC -d24 --tend 0.3 --dump-tstart 0.15 --dump-freq 1 --hdf5-disable-slicing --hdf5-disable-compression"
+
+echo
+echo "TEST TAYLOR-GREEN CHECKPOINT (Fortran-MPI)"
+if [[ ! -f "${EXAMPLE_FILE}" ]]; then
+ echo "Cannot find example file '${EXAMPLE_FILE}'."
+ exit 1
+fi
+if [[ -d "${TEST_DIR}" ]]; then
+ rm -rf "${TEST_DIR}"
+fi
+
+# Fortran FFTW does not yield exactly the same results in parallel so we use h5diff with an absolute tolerance of 10^-12
+echo ' Running simulations...'
+${MPIRUN_EXECUTABLE} -np 1 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -impl fortran -cp fp64 -S "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run0" --checkpoint-dump-time 0.15 --checkpoint-dump-freq 0
+${MPIRUN_EXECUTABLE} -np 2 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -impl fortran -cp fp64 -S "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run1" --checkpoint-dump-time 0.15 --checkpoint-dump-freq 0
+${MPIRUN_EXECUTABLE} -np 3 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -impl fortran -cp fp64 -S "${TEST_DIR}/checkpoint2.tar" --dump-dir "${TEST_DIR}/run2" --checkpoint-dump-time 0.15 --checkpoint-dump-freq 0
+echo ' Comparing solutions...'
+for f0 in $(find "${TEST_DIR}/run0" -name '*.h5' | sort -n); do
+ f1=$(echo "${f0}" | sed 's/run0/run1/')
+ f2=$(echo "${f0}" | sed 's/run0/run2/')
+ h5diff -d '1e-12' "${f0}" "${f1}"
+ h5diff -d '1e-12' "${f0}" "${f2}"
+ echo " >$(basename ${f0}) match"
+done
+
+echo ' Running simulations from checkpoints using different MPI topologies...'
+COMMON_OPTIONS="-NC -d24 --tend 0.3 --dump-tstart 0.15 --dump-freq 1 --hdf5-disable-slicing --hdf5-disable-compression --checkpoint-relax-constraints"
+${MPIRUN_EXECUTABLE} -np 3 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -impl fortran -cp fp64 -L "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run3"
+${MPIRUN_EXECUTABLE} -np 2 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -impl fortran -cp fp64 -L "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run4"
+${MPIRUN_EXECUTABLE} -np 1 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -impl fortran -cp fp64 -L "${TEST_DIR}/checkpoint2.tar" --dump-dir "${TEST_DIR}/run5"
+echo ' Comparing solutions...'
+for f3 in $(find "${TEST_DIR}/run3" -name '*.h5' | sort -n); do
+ f0=$(echo "${f3}" | sed 's/run3/run0/')
+ f4=$(echo "${f3}" | sed 's/run3/run4/')
+ f5=$(echo "${f3}" | sed 's/run3/run5/')
+ h5diff -d '1e-12' "${f0}" "${f3}"
+ h5diff -d '1e-12' "${f0}" "${f4}"
+ h5diff -d '1e-12' "${f0}" "${f5}"
+ echo " >$(basename ${f0}) match"
+done
+
+echo ' Running simulations from checkpoints using OpenCL and different datatypes...'
+${MPIRUN_EXECUTABLE} -np 1 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -cp fp64 -impl opencl -L "${TEST_DIR}/checkpoint0.tar" --dump-dir "${TEST_DIR}/run6"
+${MPIRUN_EXECUTABLE} -np 1 "${PYTHON_EXECUTABLE}" "${EXAMPLE_FILE}" ${COMMON_OPTIONS} -cp fp32 -impl opencl -L "${TEST_DIR}/checkpoint1.tar" --dump-dir "${TEST_DIR}/run7"
+echo ' Comparing solutions...'
+for f6 in $(find "${TEST_DIR}/run6" -name '*.h5' | sort -n); do
+ f7=$(echo "${f6}" | sed 's/run0/run7/')
+ h5diff -d '5e-5' "${f6}" "${f7}"
+ echo " >$(basename ${f6}) match"
+done
+
diff --git a/hysop/deps.py b/hysop/deps.py
index 9b19e1e0d82fbb5be34734c58ca6156f700127d3..52a7937c227a56281ab6de18e5a45853fee08874 100644
--- a/hysop/deps.py
+++ b/hysop/deps.py
@@ -18,6 +18,7 @@ except ImportError as e:
msg = 'Warning: h5py not found, you may not be able to'
msg += ' use hdf5 I/O functionnalities.'
print(msg)
+ raise
import sys, os, subprocess, platform, warnings, traceback
import resource, psutil, tempfile, cpuinfo, time
diff --git a/hysop/domain/control_box.py b/hysop/domain/control_box.py
index 9e504a30b5eb97cf2cda0c8bf1bb935f8b87bb39..8707cfa3e79676dfe0aafa19c9e915a1488d4478 100644
--- a/hysop/domain/control_box.py
+++ b/hysop/domain/control_box.py
@@ -88,7 +88,7 @@ class ControlBox(SubBox):
msg = 'Control Box error : surface out of bounds.'
assert self._check_boundaries(surf, topo), msg
res += surf.integrate_field_on_proc(field, topo, component)
- if root is None:
+ if (root is None):
return topo.comm.allreduce(res)
else:
return topo.comm.reduce(res, root=root)
diff --git a/hysop/domain/domain.py b/hysop/domain/domain.py
index 1f0d43f01528a22d31b1846ac7a23639a90d72a7..faf00b76e4a449f26aa6e9e6ca24e1111b32a8c2 100644
--- a/hysop/domain/domain.py
+++ b/hysop/domain/domain.py
@@ -12,13 +12,15 @@ from hysop.tools.handle import RegisteredObject, TaggedObjectView
from hysop.tools.types import check_instance
from hysop.tools.numpywrappers import npw
from hysop.symbolic.frame import SymbolicFrame
+from hysop.deps import hashlib, np
+
class DomainView(TaggedObjectView):
"""Abstract base class for views on domains. """
__metaclass__ = ABCMeta
__slots__ = ('_domain', '_topology_state')
-
+
@debug
def __new__(cls, topology_state, domain=None, **kwds):
"""Create and initialize a DomainView."""
@@ -38,19 +40,23 @@ class DomainView(TaggedObjectView):
def _get_domain(self):
"""Return the domain on which the view is on."""
return self._domain
+
def _get_topology_state(self):
"""Return the topology state altering this domain view."""
return self._topology_state
-
+
def _get_dim(self):
"""Return the dimension of the domain."""
return self._domain._dim
+
def _get_parent_comm(self):
"""Return the parent communicator used to create this domain."""
return self._domain._parent_comm
+
def _get_parent_rank(self):
"""Return the rank of the process in the parent communicator."""
return self._domain._parent_rank
+
def _get_task_comm(self):
"""
Return the communicator that owns the current process.
@@ -58,45 +64,61 @@ class DomainView(TaggedObjectView):
the parent communicator by colors (proc_tasks).
"""
return self._domain._task_comm
+
def _get_task_rank(self):
"""Return the rank of the process in the task communicator."""
return self._domain._task_rank
+
+ def _get_machine_comm(self):
+ """
+ Return the communicator that owns the current process.
+ This is the sub-communicator which has been obtained by splitting.
+ the parent communicator by machine name.
+ """
+ return self._domain._machine_comm
+
+ def _get_machine_rank(self):
+ """Return the rank of the process in the machine communicator."""
+ return self._domain._machine_rank
+
def _get_proc_tasks(self):
"""Return mapping between mpi process rank and task identifier."""
return self._domain._proc_tasks
+
def _get_registered_topologies(self):
"""
Return the dictionary of all topologies already built on this domain,
with topology ids as keys and :class:`~hysop.topology.topology.Topology` as values.
"""
return self._domain._registered_topologies
+
def _get_frame(self):
"""Get symbolic frame associated to this domain."""
return self._domain._frame
-
+
def task_on_proc(self, parent_rank):
"""Get task identifier for a given mpi process (parent communicator rank)."""
if parent_rank >= len(self._domain._proc_tasks):
- msg='Unknown rank {} in parent communicator.'.format(parent_rank)
+ msg = 'Unknown rank {} in parent communicator.'.format(parent_rank)
raise ValueError(msg)
return self._domain._proc_tasks[parent_rank]
def current_task(self):
"""Get task number of the current mpi process."""
return self.task_on_proc(self._domain._parent_rank)
-
+
def is_on_task(self, params):
"""Test if the current process corresponds to param task."""
if isinstance(params, MPIParams):
task_id = params.task_id
- elif isinstance(params, (int,long,npw.integer)):
+ elif isinstance(params, (int, long, npw.integer)):
task_id = params
else:
- msg='Could not extract task_id from type {}.'
- msg=msg.format(type(params))
+ msg = 'Could not extract task_id from type {}.'
+ msg = msg.format(type(params))
raise TypeError(msg)
return (self.current_task() == task_id)
-
+
def print_topologies(self):
"""Print all topologies registered on the domain."""
print self.short_description() + ' defined the following topologies:'
@@ -116,24 +138,24 @@ class DomainView(TaggedObjectView):
def __eq__(self, other):
if not isinstance(other, DomainView):
return NotImplemented
- eq = (self._domain is other._domain)
+ eq = (self._domain is other._domain)
eq &= (self._topology_state == other._topology_state)
return eq
def __ne__(self, other):
if not isinstance(other, DomainView):
return NotImplemented
- eq = (self._domain is other._domain)
+ eq = (self._domain is other._domain)
eq &= (self._topology_state == other._topology_state)
return not eq
def __hash__(self):
return id(self._domain) ^ hash(self._topology_state)
-
+
def __str__(self):
"""Equivalent to self.long_description()"""
return self.long_description()
-
+
domain = property(_get_domain)
dim = property(_get_dim)
proc_tasks = property(_get_proc_tasks)
@@ -141,18 +163,20 @@ class DomainView(TaggedObjectView):
parent_rank = property(_get_parent_rank)
task_comm = property(_get_task_comm)
task_rank = property(_get_task_rank)
+ machine_comm = property(_get_machine_comm)
+ machine_rank = property(_get_machine_rank)
registered_topologies = property(_get_registered_topologies)
frame = property(_get_frame)
-
+
class Domain(RegisteredObject):
"""Abstract base class for the description of physical domains. """
__metaclass__ = ABCMeta
-
+
@debug
def __new__(cls, dim, parent_comm=None, proc_tasks=None, **kwds):
"""
- Create or get an existing physical domain of given dim on a specified MPI
+ Create or get an existing physical domain of given dim on a specified MPI
communicator and specific tasks.
Parameters
@@ -190,52 +214,62 @@ class Domain(RegisteredObject):
-----
*Parent communicator is split according to proc_tasks.
*About MPI Tasks
- proc_tasks[n] = 12 means that task 12 owns proc n
+ proc_tasks[n] = 12 means that task 12 owns proc n
or equivalently that proc n is dedicated to task 12.
- *A dupped parent_comm will return another idenpendent domain instance,
- because MPI communicators are hashed trough their python object id.
+ *A dupped parent_comm will return another idenpendent domain instance,
+ because MPI communicators are hashed trough their python object id.
"""
-
+
dim = int(dim)
parent_comm = parent_comm or main_comm
- proc_tasks = proc_tasks or [HYSOP_DEFAULT_TASK_ID,] * parent_comm.Get_size()
+ proc_tasks = proc_tasks or [HYSOP_DEFAULT_TASK_ID, ] * parent_comm.Get_size()
proc_tasks = npw.asdimarray(proc_tasks)
assert proc_tasks.size == parent_comm.Get_size()
-
+
npw.set_readonly(proc_tasks)
-
+
# double check types, to be sure RegisteredObject will work as expected
check_instance(dim, int)
check_instance(parent_comm, MPI.Intracomm)
check_instance(proc_tasks, npw.ndarray, dtype=HYSOP_DIM)
- obj = super(Domain,cls).__new__(cls, dim=dim, parent_comm=parent_comm,
- proc_tasks=proc_tasks, tag_prefix='d', **kwds)
+ obj = super(Domain, cls).__new__(cls, dim=dim, parent_comm=parent_comm,
+ proc_tasks=proc_tasks, tag_prefix='d', **kwds)
if not obj.obj_initialized:
obj.__initialize(dim, parent_comm, proc_tasks)
return obj
-
+
@debug
def __initialize(self, dim, parent_comm, proc_tasks):
parent_rank = parent_comm.Get_rank()
parent_size = parent_comm.Get_size()
- if proc_tasks is main_comm:
+ if len(set(proc_tasks)) == 1:
task_comm = parent_comm.Dup()
else:
assert len(proc_tasks) == parent_size
task_comm = parent_comm.Split(color=proc_tasks[parent_rank],
- key=parent_rank)
+ key=parent_rank)
task_rank = task_comm.Get_rank()
-
+
+ # Build a per-machine communicator in order to get a rank on local machines
+ # Split accoring to machine name hashed and converted to integer (strings generally differs only from a single character)
+ machine_comm = parent_comm.Split(
+ color=np.int32(int(hashlib.md5(MPI.Get_processor_name()).hexdigest(), 16) %
+ np.iinfo(np.int32).max),
+ key=parent_rank)
+ machine_rank = machine_comm.Get_rank()
+
self._dim = dim
self._parent_comm = parent_comm
self._parent_rank = parent_rank
self._task_comm = task_comm
self._task_rank = task_rank
+ self._machine_comm = machine_comm
+ self._machine_rank = machine_rank
self._proc_tasks = proc_tasks
self._registered_topologies = {}
self._frame = SymbolicFrame(dim=dim)
@@ -271,5 +305,3 @@ class Domain(RegisteredObject):
def view(self, topology_state):
"""Return a view of this domain altered by some topology_state."""
pass
-
-
diff --git a/hysop/fields/cartesian_discrete_field.py b/hysop/fields/cartesian_discrete_field.py
index 77c616e8189ae855aff246d16577cdd48ebc9998..f388b73eb2b142d0e7c2ccae4f6a9a599837ad5e 100644
--- a/hysop/fields/cartesian_discrete_field.py
+++ b/hysop/fields/cartesian_discrete_field.py
@@ -12,7 +12,7 @@ from hysop import vprint, dprint, MPI
from hysop.deps import np, hashlib
from hysop.core.arrays.all import HostArray, OpenClArray
from hysop.constants import Backend, DirectionLabels, GhostOperation, GhostMask, ExchangeMethod, \
- MemoryOrdering
+ MemoryOrdering
from hysop.topology.topology import Topology, TopologyView
from hysop.tools.decorators import debug, static_vars
from hysop.tools.types import check_instance, to_tuple, first_not_None, to_list
@@ -20,17 +20,18 @@ from hysop.tools.numpywrappers import npw
from hysop.tools.misc import prod
from hysop.tools.units import bytes2str
from hysop.fields.discrete_field import DiscreteScalarField, DiscreteScalarFieldView, \
- DiscreteScalarFieldViewContainerI, DiscreteTensorField
+ DiscreteScalarFieldViewContainerI, DiscreteTensorField
from hysop.topology.cartesian_topology import CartesianTopology, CartesianTopologyState, \
- CartesianTopologyView
+ CartesianTopologyView
from hysop.backend.device.opencl import cl, clArray
from hysop.core.mpi.topo_tools import TopoTools
+
class CartesianDiscreteScalarFieldViewContainerI(object):
- def initialize(self, formula, vectorize=False,
- without_ghosts=False, exchange_ghosts=True,
- exchange_kwds=None, only_finite=True,
- reorder=None, quiet=False, **kwds):
+ def initialize(self, formula, vectorize=False,
+ without_ghosts=True, exchange_ghosts=True,
+ exchange_kwds=None, only_finite=True,
+ reorder=None, quiet=False, components=None, **kwds):
"""
Initialize the cartesian field data.
@@ -43,173 +44,220 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
vectorize : bool, optional
True if formula must be vectorized
(i.e. is of type 'user_func_2', see :ref:`fields` for details)
- only_finite: bool, optional
- Check that initialized values are not +inf, -inf or NaN.
- Defaults to True.
+ without_ghosts: boolean, optional, defaults to False
+ Do not initialize ghosts using formula.
+ In this case, ghosts may be initialized by ghost exchange (see next parameter).
exchange_ghosts: bool, optional, defaults to True
Should we exchange ghosts after initialization ?
- without_ghosts: boolean, optional, defaults to False
- Do not initialize ghosts (only for formula init).
exchange_kwds: dict, optional,
Extra exchange keyword arguments passed to ghost exchange.
Only used if exchange_ghosts is set to True.
+ only_finite: bool, optional
+ Check that initialized values are not +inf, -inf or NaN.
+ Defaults to True.
reorder: str or tuple of str, optional
Reorder all kwd according to current topology state.
ie. kwd should be contained in kwds and kwds[kwd] should
be of length self.domain.dim.
kwds : dict
- Extra keyword arguments passed to formula, optional, depends on formula.
+ Extra keyword arguments passed to formula, optional, depends on passed formula.
"""
if (not self.has_unique_backend()):
- msg='Cannot initialize a tensor field defined on multiple backends at a time.'
+ msg = 'Cannot initialize a tensor field defined on multiple backends at a time.'
raise RuntimeError(msg)
backend = self.backend
-
+
+ check_instance(components, tuple, values=(int, tuple), allow_none=True)
+ components = self.ids_to_components(first_not_None(
+ components, tuple(range(self.nb_components))))
+ check_instance(components, tuple, values=int, minval=0, maxval=self.nb_components-1)
+ assert len(set(components)) == len(components), 'Repeated components: {}'.format(components)
+
+ def filter_components(x, components=components):
+ assert isinstance(x, tuple)
+ assert len(x) == self.nb_components
+ return tuple(x[i] if (i in components) else None for i in xrange(self.nb_components))
+
reorder = to_tuple(first_not_None(reorder, ()))
check_instance(reorder, tuple, values=str)
for kwd in reorder:
if (kwd not in kwds):
- msg='{} is not contained in passed keyword variables.'.format(kwd)
+ msg = '{} is not contained in passed keyword variables.'.format(kwd)
raise ValueError(msg)
vals = kwds[kwd]
- if isinstance(vals[0], (tuple, list, np.ndarray)):
- for (i,val) in enumerate(vals):
- if len(val)!=self.dim:
- msg='Value contained at keyword {} index {} is not of length '
- msg+='domain.dim={}, got {}, cannot reorder.'
- msg=msg.format(kwd, i, self.dim, val)
+ if isinstance(vals, npw.ndarray):
+ if vals.ndim != self.dim:
+ msg = 'Value contained at keyword {} index {} has incompatible dimension '
+ msg += 'with respect to domain.dim={}, got val.ndim={}, cannot reorder.'
+ msg = msg.format(kwd, self.dim, val.ndim)
+ raise ValueError(msg)
+ elif isinstance(vals[0], (tuple, list, npw.ndarray)):
+ for (i, val) in enumerate(vals):
+ if len(val) != self.dim:
+ msg = 'Value contained at keyword {} index {} is not of length '
+ msg += 'domain.dim={}, got {}, cannot reorder.'
+ msg = msg.format(kwd, i, self.dim, val)
raise ValueError(msg)
else:
- if len(kwds[kwd])!=self.dim:
- msg='Value contained at keyword {} is not of length domain.dim={}, '
- msg+='got {}, cannot reorder.'
- msg=msg.format(kwd, self.dim, val)
+ if len(kwds[kwd]) != self.dim:
+ msg = 'Value contained at keyword {} is not of length domain.dim={}, '
+ msg += 'got {}, cannot reorder.'
+ msg = msg.format(kwd, self.dim, val)
raise ValueError(msg)
(from_raw_data, from_formula) = (False, False)
if isinstance(formula, (np.ndarray, tuple)):
formula = to_tuple(formula)
- msg='\n>Initializing discrete field {} from raw array data.'
- msg=msg.format(self.name)
+ msg = '\n>Initializing discrete field {} from raw array data.'
+ msg = msg.format(self.name)
if not quiet:
vprint(msg)
from_raw_data = True
else:
- msg='\n>Initializing discrete field {} with formula {}.'
- msg=msg.format(self.pretty_name, formula.__name__)
+ msg = '\n>Initializing discrete field {} with formula {}.'
+ msg = msg.format(self.pretty_name, formula.__name__)
if not quiet:
vprint(msg)
from_formula = True
+ # buffers = backend dependent buffers of the current field
+ # data = host buffers corresponding to backend buffer shapes and dtype
+ dfields = ()
+ buffers = ()
+ coords = ()
+ for i in xrange(self.nb_components):
+ if (i not in components):
+ dfields += (None,)
+ buffers += (None,)
+ coords += (None,)
+ else:
+ # dfield may be read-only because of topology state, rediscretize with write access
+ dfield = self.dfields[i]
+ topo_view = dfield.topology
+ topo = topo_view.topology
+ wstate = topo_view.topology_state.copy(memory_order=MemoryOrdering.C_CONTIGUOUS,
+ is_read_only=False) # get a writtable state
+ dfield = dfield.field.discretize(topo, wstate)
+ dfields += (dfield,)
+ if without_ghosts:
+ buffers += (dfield.compute_data[0],)
+ coords += (dfield.compute_mesh_coords,)
+ else:
+ buffers += (dfield.sdata,)
+ coords += (dfield.mesh_coords,)
+
if (backend.kind == Backend.HOST):
- data = self.buffers
+ data = buffers
else:
# we are not on host, allocate temporary buffers
- msg=' *Allocating temporary buffers on host.'
+ msg = ' *Allocating temporary buffers on host.'
if not quiet:
vprint(msg)
host_backend = self.backend.host_array_backend
- data = tuple(host_backend.empty(shape=d.shape, dtype=d.dtype)
- for d in self.buffers)
-
- if without_ghosts:
- vdata = tuple(buf[df.compute_slices]
- for (buf,df) in zip(data, self.discrete_field_views()))
- else:
- vdata = data
+ data = tuple(host_backend.empty(shape=d.shape, dtype=d.dtype)
+ if (d is not None) else None for d in buffers)
if from_formula:
-
# initialize from a python method
- assert ('data' not in kwds), 'data is a reserved keyword.'
+ assert ('data' not in kwds), 'data is a reserved keyword.'
assert ('coords' not in kwds), 'coords is a reserved keyword.'
- coords = self.get_attributes('mesh_coords')
- formula_kwds = dict(data=vdata, coords=coords)
- formula_kwds.update(kwds)
- for kwd in reorder:
- vals = to_list(kwds[kwd])
- if isinstance(vals[0], (tuple, list, np.ndarray)):
- for (i,val) in enumerate(vals):
- vals[i] = self.topology_state.transposed(val)
- kwds[kwd] = vals
- else:
- formula_kwds[kwd] = self.topology_state.transposed(formula_kwds[kwd])
+ assert ('component' not in kwds), 'component is a reserved keyword.'
# vectorize formula if requested
if vectorize and not isinstance(formula, np.lib.function_base.vectorize):
formula = np.vectorize(formula)
- # call formula
- formula(**formula_kwds)
+ # call formula for each component
+ for i in components:
+ topology_state = dfields[i].topology_state
+ formula_kwds = dict(data=data[i], coords=coords[i], component=i)
+ formula_kwds.update(kwds)
+ for kwd in reorder:
+ vals = kwds[kwd]
+ if isinstance(vals[0], (tuple, list, np.ndarray)) and not isinstance(vals, np.ndarray):
+ vals = to_list(vals)
+ for (i, val) in enumerate(vals):
+ vals[i] = topology_state.transposed(val)
+ formula_kwds[kwd] = vals
+ else:
+ formula_kwds[kwd] = topology_state.transposed(vals)
+ # call formula
+ formula(**formula_kwds)
elif from_raw_data:
- # initialize from raw data
+ # initialize from raw data
assert len(formula) == len(data)
- all_src_slices = kwds.get('src_slices', (Ellipsis,)*len(formula))
+ all_src_slices = kwds.pop('src_slices', (Ellipsis,)*len(formula))
for i, (dsrc, ddst) in enumerate(zip(formula, data)):
+ if (ddst is None):
+ continue
src_slices = all_src_slices[i]
- dst_slices = kwds.get('dst_slices', self.discrete_fields()[i].compute_slices)
+ dst_slices = kwds.pop('dst_slices', Ellipsis)
check_instance(dsrc, (np.ndarray, HostArray))
check_instance(ddst, (np.ndarray, HostArray))
src_shape = dsrc[src_slices].shape
dst_shape = ddst[dst_slices].shape
if (src_shape != dst_shape):
- msg= 'Cannot initialize field from raw data because the shapes do not match.'
- msg+='\n'
- msg+='\n Destination field:'
- msg+='\n base_shape: {}'.format(ddst.shape)
- msg+='\n base_dtype: {}'.format(ddst.dtype)
- msg+='\n dst_slices: {}'.format(dst_slices)
- msg+='\n dst_shape: {}'.format(dst_shape)
- msg+='\n'
- msg+='\n Raw source data:'
- msg+='\n base_shape: {}'.format(dsrc.shape)
- msg+='\n base_dtype: {}'.format(dsrc.dtype)
- msg+='\n src_slices: {}'.format(src_slices)
- msg+='\n src_shape: {}'.format(src_shape)
- msg+='\n'
+ msg = 'Cannot initialize field from raw data because the shapes do not match.'
+ msg += '\n'
+ msg += '\n Destination field:'
+ msg += '\n base_shape: {}'.format(ddst.shape)
+ msg += '\n base_dtype: {}'.format(ddst.dtype)
+ msg += '\n dst_slices: {}'.format(dst_slices)
+ msg += '\n dst_shape: {}'.format(dst_shape)
+ msg += '\n'
+ msg += '\n Raw source data:'
+ msg += '\n base_shape: {}'.format(dsrc.shape)
+ msg += '\n base_dtype: {}'.format(dsrc.dtype)
+ msg += '\n src_slices: {}'.format(src_slices)
+ msg += '\n src_shape: {}'.format(src_shape)
+ msg += '\n'
raise RuntimeError(msg)
ddst[dst_slices] = dsrc[src_slices]
else:
- msg='Unknown initialization kind.'
+ msg = 'Unknown initialization kind.'
raise RuntimeError(msg)
- if __debug__:
- assert len(data) == len(self.data) == self.nb_components
- assert all((d0.size == d1.size)
- for (d0,d1) in zip(self.data, data)), 'Array size was altered.'
- assert all((d0.dtype == d1.dtype)
- for (d0,d1) in zip(self.data, data)), 'Array dtype was altered.'
- assert all((d0.shape == d1.shape)
- for (d0,d1) in zip(self.data, data)), 'Array shape was altered.'
+ assert len(data) == len(buffers) == self.nb_components
+ assert all(((d0 is None) and (d1 is None)) or (d0.size == d1.size)
+ for (d0, d1) in zip(buffers, data)), 'Array size was altered.'
+ assert all(((d0 is None) and (d1 is None)) or (d0.dtype == d1.dtype)
+ for (d0, d1) in zip(buffers, data)), 'Array dtype was altered.'
+ assert all(((d0 is None) and (d1 is None)) or (d0.shape == d1.shape)
+ for (d0, d1) in zip(buffers, data)), 'Array shape was altered.'
if only_finite:
- for (i,d) in enumerate(vdata):
+ for (i, d) in enumerate(data):
+ if (d is None):
+ continue
if np.isnan(d).any():
- msg='Initialization of {} on component {} failed, got NaNs.'
- msg=msg.format(self.pretty_name, i)
+ msg = 'Initialization of {} on component {} failed, got NaNs.'
+ msg = msg.format(self.pretty_name, i)
+ print d
raise RuntimeError(msg)
if not np.isfinite(d).all():
- msg=('Initialization of {} on component {} failed, '
- +'got values that are not finite.')
- msg=msg.format(self.pretty_name, i)
+ msg = ('Initialization of {} on component {} failed, '
+ + 'got values that are not finite.')
+ msg = msg.format(self.pretty_name, i)
raise RuntimeError(msg)
if (backend.kind != Backend.HOST):
- msg=' *Copying temporary buffers to backend {}.'
- msg=msg.format(backend.kind)
+ msg = ' *Copying temporary buffers to backend {}.'
+ msg = msg.format(backend.kind)
if not quiet:
vprint(msg)
- self.data = data
- msg=' *Exchanging ghosts on backend {}.'
- msg=msg.format(backend.kind)
+ for (b, d) in zip(buffers, data):
+ if (d is not None):
+ b[...] = d
+ if exchange_ghosts:
+ msg = ' *Exchanging ghosts on backend {}.'
+ msg = msg.format(backend.kind)
if not quiet:
vprint(msg)
- if exchange_ghosts:
exchange_kwds = first_not_None(exchange_kwds, {})
+ exchange_kwds['components'] = components
evt = self.exchange_ghosts(**exchange_kwds)
if (evt is not None):
evt.wait()
-
def norm(self, p=2, data=None, view=None):
"""
Compute a per-component Lp norm of the discrete field.
@@ -228,7 +276,7 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
data: tuple of Array, optional
Custom data to apply the norm to.
By default this is the local to field data.
- view:
+ view:
View on data.
"""
if (data is not None):
@@ -237,20 +285,20 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
else:
data = self.data
view = first_not_None(view, Ellipsis)
- check_instance(p, (int,float))
+ check_instance(p, (int, float))
check_instance(data, tuple)
nb_components = len(data)
- result = npw.zeros((nb_components,))
+ result = npw.zeros((nb_components,))
gresult = npw.zeros((nb_components,))
if (p == np.inf):
- for (i,d) in enumerate(data):
+ for (i, d) in enumerate(data):
result[i] = abs(d[view]).max().get()
self.topology.cart_comm.Allreduce(result, gresult, op=MPI.MAX)
norm = gresult
else:
- for (i,d) in enumerate(data):
+ for (i, d) in enumerate(data):
tmp = abs(d[view])**p
result[i] = tmp.sum().get() * npw.prod(self.space_step)
self.topology.cart_comm.Allreduce(result, gresult, op=MPI.SUM)
@@ -272,12 +320,29 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
sview = self.compute_slices
oview = other.compute_slices
data = ()
- for (lhs,rhs) in zip(self.data, other.data):
+ for (lhs, rhs) in zip(self.data, other.data):
data += (lhs[sview].get() - rhs[oview].get(),)
return self.norm(data=data, **kwds)
-
+
+ def collect_data(self, component=0):
+ """
+ Debug function to collect data across multiples processes.
+ """
+ data = self.data[component][self.compute_slices].get().handle
+ slcs = self.mesh.global_compute_slices
+ comm = self.topology.cart_comm
+ all_data = comm.gather(data, root=0)
+ all_slcs = comm.gather(slcs, root=0)
+ if (comm.rank == 0):
+ array = npw.full(dtype=data.dtype, shape=self.mesh.grid_resolution, fill_value=npw.nan)
+ for (d, view) in zip(all_data, all_slcs):
+ array[view] = d
+ return array
+ else:
+ return None
+
def print_with_ghosts(self, component=0, compute=None, data=None,
- inner_ghosts=None, outer_ghosts='X', **print_opts):
+ inner_ghosts=None, outer_ghosts='X', **print_opts):
"""
Print values with ghosts replaced by symbol.
Mainly for debug purposes.
@@ -303,9 +368,9 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
if (outer_ghosts is not None):
for ndir in self.all_outer_ghost_slices:
for directions in self.all_outer_ghost_slices[ndir]:
- for disp,(slc,_) in \
+ for disp, (slc, _) in \
self.all_outer_ghost_slices[ndir][directions].iteritems():
- if (sum(d!=0 for d in disp) == ndir) and ndir:
+ if (sum(d != 0 for d in disp) == ndir) and ndir:
if callable(outer_ghosts):
outer_ghosts = np.vectorize(outer_ghosts)
strarr[slc] = outer_ghosts(strarr[slc])
@@ -313,14 +378,14 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
strarr[slc] = outer_ghosts
_formatter = {
- object: lambda x: '{:^6}'.format(x)[:6],
- float: lambda x: '{:+6.2f}'.format(x)
+ object: lambda x: '{:^6}'.format(x)[:6],
+ float: lambda x: '{:+6.2f}'.format(x)
}
- _print_opts = dict(threshold=10000, linewidth=1000,
- nanstr='nan', infstr='inf',
- formatter={'object': lambda x: _formatter.get(type(x),
- _formatter[object])(x)})
+ _print_opts = dict(threshold=10000, linewidth=1000,
+ nanstr='nan', infstr='inf',
+ formatter={'object': lambda x: _formatter.get(type(x),
+ _formatter[object])(x)})
_print_opts.update(print_opts)
from hysop.tools.contexts import printoptions
@@ -331,13 +396,13 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
def compute_data(self):
"""Like data, but with a view on compute_slices."""
return tuple(df.sdata[df.compute_slices]
- for df in self.discrete_field_views())
-
+ for df in self.discrete_field_views())
+
@property
def compute_buffers(self):
"""Like buffers, but with a view on compute_slices."""
return tuple(df.sbuffer[df.compute_slices]
- for df in self.discrete_field_views())
+ for df in self.discrete_field_views())
def local_slices(self, ghosts):
"""
@@ -345,13 +410,13 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
number of ghosts on each axis.
"""
if not self.has_unique_compute_slices():
- msg='Field container does not have unique compute slices.'
+ msg = 'Field container does not have unique compute slices.'
raise RuntimeError(msg)
cslc = self.compute_slices
assert len(ghosts) == len(cslc)
-
+
gslc = ()
- for (slc,g) in zip(cslc, ghosts):
+ for (slc, g) in zip(cslc, ghosts):
(start, stop, step) = slc.start, slc.stop, slc.step
assert step in (1, None)
slc = slice(start-g, stop+g)
@@ -360,123 +425,177 @@ class CartesianDiscreteScalarFieldViewContainerI(object):
def has_unique_compute_resolution(self):
return self.has_unique_attribute('compute_resolution')
+
def has_unique_resolution(self):
return self.has_unique_attribute('resolution')
+
def has_unique_ghosts(self):
return self.has_unique_attribute('ghosts')
+
def has_unique_space_step(self):
return self.has_unique_attribute('space_step')
+
def has_unique_coords(self):
return self.has_unique_attribute('coords')
+
def has_unique_mesh_coords(self):
return self.has_unique_attribute('mesh_coords')
+
def has_unique_compute_slices(self):
return self.has_unique_attribute('compute_slices')
+
def has_unique_inner_ghost_slices(self):
return self.has_unique_attribute('inner_ghost_slices')
+
def has_unique_outer_ghost_slices(self):
return self.has_unique_attribute('outer_ghost_slices')
+
def has_unique_grid_npoints(self):
return self.has_unique_attribute('grid_npoints')
+
def has_unique_axes(self):
return self.has_unique_attribute('axes')
+
def has_unique_tstate(self):
- return self.has_unique_attribute('tstate')
+ return self.has_unique_attribute('tstate')
+
def has_unique_memory_order(self):
return self.has_unique_attribute('memory_order')
+
def has_unique_local_boundaries(self):
return self.has_unique_attribute('local_boundaries')
+
def has_unique_local_lboundaries(self):
return self.has_unique_attribute('local_lboundaries')
+
def has_unique_local_rboundaries(self):
return self.has_unique_attribute('local_rboundaries')
+
def has_unique_global_boundaries(self):
return self.has_unique_attribute('global_boundaries')
+
def has_unique_global_lboundaries(self):
return self.has_unique_attribute('global_lboundaries')
+
def has_unique_global_rboundaries(self):
return self.has_unique_attribute('global_rboundaries')
+
def has_unique_is_at_boundary(self):
return self.has_unique_attribute('is_at_boundary')
+
def has_unique_is_at_left_boundary(self):
return self.has_unique_attribute('is_at_left_boundary')
+
def has_unique_is_at_right_boundary(self):
return self.has_unique_attribute('is_at_right_boundary')
+
def has_unique_periodicity(self):
return self.has_unique_attribute('periodicity')
-
+
@property
def compute_resolution(self):
return self.get_unique_attribute('compute_resolution')
+
@property
def resolution(self):
return self.get_unique_attribute('resolution')
+
@property
def ghosts(self):
return self.get_unique_attribute('ghosts')
+
@property
def space_step(self):
return self.get_unique_attribute('space_step')
+
@property
def coords(self):
return self.get_unique_attribute('coords')
+
@property
def mesh_coords(self):
return self.get_unique_attribute('mesh_coords')
+
+ @property
+ def compute_coords(self):
+ return self.get_unique_attribute('compute_coords')
+
+ @property
+ def compute_mesh_coords(self):
+ return self.get_unique_attribute('compute_mesh_coords')
+
@property
def compute_slices(self):
return self.get_unique_attribute('compute_slices')
+
@property
def inner_ghost_slices(self):
return self.get_unique_attribute('inner_ghost_slices')
+
@property
def outer_ghost_slices(self):
return self.get_unique_attribute('outer_ghost_slices')
+
@property
def all_inner_ghost_slices(self):
return self.get_unique_attribute('all_inner_ghost_slices')
+
@property
def all_outer_ghost_slices(self):
return self.get_unique_attribute('all_outer_ghost_slices')
+
@property
def grid_npoints(self):
return self.get_unique_attribute('grid_npoints')
+
@property
def axes(self):
return self.get_unique_attribute('axes')
+
@property
def tstate(self):
- return self.get_unique_attribute('tstate')
+ return self.get_unique_attribute('tstate')
+
@property
def memory_order(self):
return self.get_unique_attribute('memory_order')
+
@property
def local_boundaries(self):
return self.get_unique_attribute('local_boundaries')
+
@property
def local_lboundaries(self):
return self.get_unique_attribute('local_lboundaries')
+
@property
def local_rboundaries(self):
return self.get_unique_attribute('local_rboundaries')
+
@property
def global_boundaries(self):
return self.get_unique_attribute('global_boundaries')
+
@property
def global_lboundaries(self):
return self.get_unique_attribute('global_lboundaries')
+
@property
def global_rboundaries(self):
return self.get_unique_attribute('global_rboundaries')
+
@property
def is_at_boundary(self):
return self.get_unique_attribute('is_at_boundary')
+
@property
def is_at_left_boundary(self):
return self.get_unique_attribute('is_at_left_boundary')
+
@property
def is_at_right_boundary(self):
return self.get_unique_attribute('is_at_right_boundary')
+
@property
def periodicity(self):
return self.get_unique_attribute('periodicity')
@@ -486,29 +605,28 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
"""
View over a CartesianDiscreteScalarField.
"""
-
__slots__ = ('_dfield', '_topology_state', '_topology_view', '_data_view')
@debug
def __new__(cls, dfield, topology_state, **kwds):
"""
- Initialize a CartesianDiscreteScalarFieldView on given discrete cartesian
+ Initialize a CartesianDiscreteScalarFieldView on given discrete cartesian
field with given cartesian topology state.
Parameters
----------
dfield: :class:`hysop.fields.cartesian_discrete_field.CartesianDiscreteScalarField`
The discrete field this view is on.
- topology_state: :class:`hysop.topology.cartesian.CartesianTopologyState`
+ topology_state: :class:`hysop.topology.cartesian.CartesianTopologyState`
The topology state of this view (optional).
kwds: dict
Base class arguments.
"""
- check_instance(dfield, CartesianDiscreteScalarField, allow_none=issubclass(cls,
- CartesianDiscreteScalarField))
+ check_instance(dfield, CartesianDiscreteScalarField, allow_none=issubclass(cls,
+ CartesianDiscreteScalarField))
check_instance(topology_state, CartesianTopologyState)
- obj = super(CartesianDiscreteScalarFieldView, cls).__new__(cls, dfield=dfield,
- topology_state=topology_state, **kwds)
+ obj = super(CartesianDiscreteScalarFieldView, cls).__new__(cls, dfield=dfield,
+ topology_state=topology_state, **kwds)
obj._data_view = None
return obj
@@ -516,24 +634,23 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
"""
Compute transposed views of underlying discrete field data
according to topology state.
-
+
This is called after the discrete field has allocated data.
Arrays are reshaped and set read-only if necessary.
This can also be called from an hysop.backend.host.host_operator.OpenClMappable object
- to map an opencl generated pointer to host (in this case custom data is passed
+ to map an opencl generated pointer to host (in this case custom data is passed
and self_data == False).
"""
self_data = (data is None)
data = first_not_None(data, self._dfield._data)
if (data is None):
if self_data:
- msg='{}::{} internal data has not been set yet.'
+ msg = '{}::{} internal data has not been set yet.'
else:
- msg='{}::{} cannot compute data view from external None data.'
- msg=msg.format(type(self._dfield).__name__, self._dfield.name)
+ msg = '{}::{} cannot compute data view from external None data.'
+ msg = msg.format(type(self._dfield).__name__, self._dfield.name)
raise RuntimeError(msg)
-
if (self.memory_order is MemoryOrdering.C_CONTIGUOUS):
dataview = data.reshape(self.resolution)
assert dataview.flags.c_contiguous
@@ -542,9 +659,9 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
dataview = dataview.T
assert dataview.flags.f_contiguous
else:
- msg='Unknown memory order {}.'.format(self.memory_order)
+ msg = 'Unknown memory order {}.'.format(self.memory_order)
raise NotImplementedError(msg)
-
+
assert all(dataview.shape == self.resolution)
if self.is_read_only:
@@ -565,7 +682,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
"""Prepare input data for copy or swap."""
if isinstance(data, tuple):
- assert len(data)==1
+ assert len(data) == 1
data = data[0]
backend = self.backend
@@ -573,20 +690,20 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
data = backend.wrap(data)
if (data.ndim != self.dim):
- msg='Array dimension {} is not compatible with discrete field dimension {}.'
- msg=msg.format(data.ndim, self.dim)
+ msg = 'Array dimension {} is not compatible with discrete field dimension {}.'
+ msg = msg.format(data.ndim, self.dim)
raise ValueError(msg)
elif (data.size != self.npoints):
- msg='Array size {} is not compatible with discrete field size {}.'
- msg=msg.format(data.size, self.size)
+ msg = 'Array size {} is not compatible with discrete field size {}.'
+ msg = msg.format(data.size, self.size)
raise ValueError(msg)
elif (data.dtype != self.dtype):
- msg='dtype {} is not compatible with discrete field dtype {}.'
- msg=msg.format(data.dtype, self.dtype)
+ msg = 'dtype {} is not compatible with discrete field dtype {}.'
+ msg = msg.format(data.dtype, self.dtype)
raise ValueError(msg)
elif any(data.shape != self.resolution):
- msg='shape {} is not compatible with discrete field resolution {}.'
- msg=msg.format(data.shape, self.resolution)
+ msg = 'shape {} is not compatible with discrete field resolution {}.'
+ msg = msg.format(data.shape, self.resolution)
raise ValueError(msg)
return data
@@ -598,11 +715,11 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def _set_data(self, copy_data):
""" Performs a copy from copy_data to self.data """
- msg='Discrete field {}::{}::set_data().'
- msg=msg.format(self.backend.kind, self.name)
+ msg = 'Discrete field {}::{}::set_data().'
+ msg = msg.format(self.backend.kind, self.name)
dprint(msg)
- msg='CartesianDiscreteScalarField {} is read-only.'.format(self.name)
+ msg = 'CartesianDiscreteScalarField {} is read-only.'.format(self.name)
assert not self.is_read_only, msg
src = self.__prepare_data(data=copy_data)
@@ -617,11 +734,12 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
return (d.handle.view(type=np.ndarray),)
else:
return (d.handle,)
-
+
def _get_sdata(self):
"""
Return contained array.
"""
+ assert self.is_scalar
return self._get_data()[0]
def _set_sdata(self, copy_data):
@@ -632,30 +750,14 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
"""
Return container buffer.
"""
+ assert self.is_scalar
return self._get_buffers()[0]
- def __getitem__(self, key):
- """
- Access to the content of the field as with self.data.
- Returns ArrayBackend.Array component(s) key of the field if key in an integer.
- Else if key is a slice, returns a tuple of slice Arrays.
- """
- msg='Getting data by using __getitem__ has been deprecated, '
- msg+='because this would clash with DiscreteTensorField. '
- msg+='\nAll fields are now scalar (one component only), '
- msg+='use the \'data\' attribute instead.'
- raise RuntimeError(msg)
-
def __call__(self, key):
- """
- Access to the content of the field as with self.buffers.
- Returns ArrayBackend.Array handle component(s) key of the field if key in an integer.
- Else if key is a slice, returns a tuple of slice Arrays.
- """
- msg='Getting buffers by using __call__ has been deprecated, '
- msg+='because this would clash with DiscreteTensorField. '
- msg+='\nAll fields are now scalar (one component only), '
- msg+='use the \'buffers\' attribute instead.'
+ msg = 'Getting buffers by using __getitem__ and __call__ has been deprecated, '
+ msg += 'because this would clash with the DiscreteTensorField interface.'
+ msg += '\nAll fields are now scalar (one component only), '
+ msg += 'use the \'buffers\' attribute instead.'
raise RuntimeError(msg)
def local_slices(self, ghosts):
@@ -666,93 +768,142 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
assert len(ghosts) == self.domain.dim
cslc = self.compute_slices
gslc = ()
- for (slc,g) in zip(cslc, ghosts):
+ for (slc, g) in zip(cslc, ghosts):
(start, stop, step) = slc.start, slc.stop, slc.step
assert step in (1, None)
slc = slice(start-g, stop+g)
gslc += (slc,)
return gslc
-
+
def _get_axes(self):
"""Return the permutation scheme in numpy notations."""
return self._topology_state.axes
+
def _get_tstate(self):
"""Return the permutation scheme as a hysop.constants.TranspositionState."""
return self._topology_state.tstate
+
def _get_memory_order(self):
"""Return the memory order of underlying data."""
return self._topology_state.memory_order
def _get_size(self):
"""Size of the underlying contiguous data arrays."""
- msg='size has been deprecated for ScalarDiscreteFields, use npoints instead.'
+ msg = 'size has been deprecated for ScalarDiscreteFields, use npoints instead.'
raise AttributeError(msg)
+
def _get_shape(self):
"""Alias for resolution."""
- msg='shape has been deprecated for ScalarDiscreteFields, use resolution instead.'
+ msg = 'shape has been deprecated for ScalarDiscreteFields, use resolution instead.'
raise AttributeError(msg)
def _get_compute_resolution(self):
"""Get compute resolution (mesh size without ghosts) on local discrete field mesh."""
return self.mesh.compute_resolution
+
def _get_resolution(self):
"""Get resolution (mesh size with ghosts) on local discrete field mesh."""
return self.mesh.local_resolution
+
def _get_npoints(self):
"""Get resolution (mesh size with ghosts) on local discrete field mesh."""
return self.mesh.local_npoints
+
def _get_ghosts(self):
"""Get the number of ghosts per direction on local discrete field mesh."""
return self.mesh.ghosts
+
def _get_compute_slices(self):
"""Return a tuple of slices indexing the local compute mesh."""
return self.mesh.local_compute_slices
+
def _get_grid_npoints(self):
"""Return the effective number of global computational points."""
return self.mesh.grid_npoints
+
def _get_space_step(self):
"""Get the space step of the discretized mesh grid."""
return self.mesh.space_step
+
def _get_coords(self):
- """Get local mesh physical coordinates in each direction."""
+ """Get local mesh physical coordinates in each direction (including ghosts)."""
return self.mesh.local_coords
+
def _get_mesh_coords(self):
- """Get local mesh physical coordinates in each direction."""
+ """
+ Get local mesh physical coordinates in each direction (including ghosts).
+ Same as self.coords but with all sequences as nd arrays and reversed.
+ Returned coordinates are x,y,z,...) instead of (...,z,y,x).
+ """
return self.mesh.local_mesh_coords
+
+ def _get_compute_coords(self):
+ """Get local mesh physical coordinates in each direction (excluding ghosts)."""
+ return self.mesh.local_compute_coords
+
+ def _get_compute_mesh_coords(self):
+ """
+ Get local mesh physical coordinates in each direction (excluding ghosts).
+ Same as self.compute_coords but with all sequences as nd arrays and reversed.
+ Returned coordinates are x,y,z,...) instead of (...,z,y,x).
+ """
+ return self.mesh.local_compute_mesh_coords
+
def _get_is_tmp(self):
"""Is this DiscreteScalarField temporary ?"""
return self._dfield.is_tmp
+
def _get_mem_tag(self):
return self._dfield.mem_tag
-
+
def _get_global_lboundaries(self):
"""Return global left boundaries."""
return self.mesh.global_lboundaries
+
def _get_global_rboundaries(self):
"""Return global right boundaries."""
return self.mesh.global_rboundaries
+
def _get_global_boundaries(self):
"""Return global boundaries as a tuple of left and right boundaries."""
return self.mesh.global_boundaries
def _get_local_lboundaries(self):
"""
- Return local left boundaries.
+ Return local left boundaries kind.
Boundaries on the interior of the global domain have value BoundaryCondition.NONE.
"""
return self.mesh.local_lboundaries
+
def _get_local_rboundaries(self):
"""
- Return local right boundaries.
+ Return local right boundaries kind.
Boundaries on the interior of the global domain have value BoundaryCondition.NONE.
"""
return self.mesh.local_rboundaries
+
def _get_local_boundaries(self):
"""
- Return local boundaries as a tuple of left and right boundaries.
+ Return local boundaries kind as a tuple of left and right boundaries.
Boundaries on the interior of the global domain have value BoundaryCondition.NONE.
"""
return self.mesh.local_boundaries
+
+ def _get_global_boundaries_config(self):
+ """
+ Return global boundaries configuration (boundary kind + attached data).
+ """
+ return tuple(self.global_lboundaries_config, self.global_rboundaries_config)
+ def _get_global_lboundaries_config(self):
+ """
+ Return global left boundaries configuration (boundary kind + attached data).
+ """
+ return self.topology_state.transposed(self.field.lboundaries)
+ def _get_global_rboundaries_config(self):
+ """
+ Return global right boundaries configuration (boundary kind + attached data).
+ """
+ return self.topology_state.transposed(self.field.rboundaries)
def _get_periodicity(self):
"""
@@ -760,7 +911,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
This is not to be confused with the cartesian communicator periodicity.
"""
return self.mesh.periodicity
-
+
def _get_is_at_left_boundary(self):
"""
Return a numpy boolean mask to identify processes that are on the left of the domain.
@@ -768,6 +919,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
on direction d: topology.proc_coords[d] == 0.
"""
return self.mesh.is_at_left_boundary
+
def _get_is_at_right_boundary(self):
"""
Return a numpy boolean mask to identify processes that are on the right of the domain.
@@ -775,6 +927,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
is the lastest on direction d: topology.proc_coords[d] == topology.proc_shape[d] - 1.
"""
return self.mesh.is_at_right_boundary
+
def _get_is_at_boundary(self):
"""
Return a numpy boolean mask to identify processes that are on either on the left or on
@@ -797,7 +950,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def get_inner_ghost_slices(self, *args, **kwds):
"""
Return a tuple of tuples of slices indexing the local inner ghosts.
- Those slices corresponds to neighbour processes overlap on local
+ Those slices corresponds to neighbour processes overlap on local
compute slices, EXCLUDING diagonal neighbour processes ghost
overlaps.
See CartesianMesh.get_local_inner_ghost_slices().
@@ -806,7 +959,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def get_all_outer_ghost_slices(self, *args, **kwds):
"""
- Return collection of slices and shapes describing all possible combinations
+ Return collection of slices and shapes describing all possible combinations
of outer ghosts slices in this array as local indices.
Those slices corresponds to local to process ghosts (ie. ghosts that may
@@ -822,7 +975,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def get_all_inner_ghost_slices(self, *args, **kwds):
"""
- Return collection of slices and shapes describing all possible
+ Return collection of slices and shapes describing all possible
combinations of inner ghosts slices in this array as local indices.
Those slices corresponds to local to process ghosts (ie. ghosts that may
@@ -838,8 +991,8 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def get_all_outer_ghost_slices_per_ncenters(self, *args, **kwds):
"""
- Compute the collection of slices describing all possible combinations
- of outer ghosts slice in this array as local indices like
+ Compute the collection of slices describing all possible combinations
+ of outer ghosts slice in this array as local indices like
self.get_all_local_outer_ghost_slices() and sort them by
number of centers (number of displacement == 0).
@@ -854,8 +1007,8 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def get_all_inner_ghost_slices_per_ncenters(self, *args, **kwds):
"""
- Compute the collection of slices describing all possible combinations
- of inner ghosts slice in this array as local indices like
+ Compute the collection of slices describing all possible combinations
+ of inner ghosts slice in this array as local indices like
self.get_all_local_inner_ghost_slices() and sort them by
number of centers (number of displacement == 0).
@@ -870,15 +1023,15 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def short_description(self):
"""Short description of this discrete field."""
- s = '{}[name={}, pname={}, dim={},'
+ s = '{}[name={}, pname={}, dim={},'
s += 'dtype={}, init_vals={}]'
- s = s.format(self.full_tag, self.name, self.pretty_name, self.dim,
+ s = s.format(self.full_tag, self.name, self.pretty_name, self.dim,
self.dtype, self.initial_values)
return s
def long_description(self):
"""Long description of this discrete field."""
- s='''\
+ s = '''\
{}
*name: {}
*pname: {}
@@ -890,60 +1043,63 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
*topology: {}
*topology_state: {}
'''.format(self.full_tag,
- self.name, self.pretty_name, self.dim,
- self.resolution, self.dtype, self.initial_values,
- self.domain.short_description(),
- self.topology.short_description(),
- self.topology_state.short_description())
+ self.name, self.pretty_name, self.dim,
+ self.resolution, self.dtype, self.initial_values,
+ self.domain.short_description(),
+ self.topology.short_description(),
+ self.topology_state.short_description())
return s
-
- def clone(self, name=None, pretty_name=None,
- var_name=None, latex_name=None, tstate=None):
+ def clone(self, name=None, pretty_name=None,
+ var_name=None, latex_name=None, tstate=None):
"""
- Create a new temporary DiscreteScalarField and allocate it
- like the current object, possibly on a different backend.
+ Create a DiscreteScalarField and allocate it
+ like the current object, possibly on a different backend.
This should only be used for debugging and testing purpose.
- The generated discrete field is not registered to the continuous
- field.
+ The generated discrete field is registered to a cloned continuous field.
"""
from hysop.tools.sympy_utils import subscript
- default_name='{}__{}'.format(self.name, self._dfield._clone_id)
- default_pname='{}__{}'.format(self.pretty_name,
- subscript(self._dfield._clone_id).encode('utf-8'))
- default_vname='{}__{}'.format(self.var_name, self._dfield._clone_id)
- default_lname='{}__{}'.format(self.latex_name, self._dfield._clone_id)
+ default_name = '{}__{}'.format(self.name, self._dfield._clone_id)
+ default_pname = '{}__{}'.format(self.pretty_name,
+ subscript(self._dfield._clone_id).encode('utf-8'))
+ default_vname = '{}__{}'.format(self.var_name, self._dfield._clone_id)
+ default_lname = '{}__{}'.format(self.latex_name, self._dfield._clone_id)
self._dfield._clone_id += 1
tstate = first_not_None(tstate, self.topology_state)
pretty_name = first_not_None(pretty_name, name, default_pname)
- var_name = first_not_None(var_name, name, default_vname)
- latex_name = first_not_None(latex_name, name, default_lname)
- name = first_not_None(name, default_name)
-
- dfield = CartesianDiscreteScalarField(name=name,
- pretty_name=pretty_name,
- latex_name=latex_name,
- var_name=var_name,
- field=self._dfield._field,
- topology=self._dfield._topology,
- init_topology_state=tstate,
- register_discrete_field=False)
+ var_name = first_not_None(var_name, name, default_vname)
+ latex_name = first_not_None(latex_name, name, default_lname)
+ name = first_not_None(name, default_name)
+
+ field = self._dfield._field
+ field = field.field_like(name=field.name+'__{}'.format(self._dfield._clone_id))
+
+ topology = self._dfield._topology.topology_like()
+
+ dfield = CartesianDiscreteScalarField(name=name,
+ pretty_name=pretty_name,
+ latex_name=latex_name,
+ var_name=var_name,
+ field=field,
+ topology=topology,
+ init_topology_state=tstate,
+ register_discrete_field=True)
dfield.copy(self)
return dfield
def tmp_dfield_like(self, name, pretty_name=None,
- var_name=None, latex_name=None,
- backend=None, is_read_only=None,
- initial_values=None, dtype=None,
- grid_resolution=None, ghosts=None, tstate=None,
- lboundaries=None, rboundaries=None,
- register_discrete_field=False, **kwds):
+ var_name=None, latex_name=None,
+ backend=None, is_read_only=None,
+ initial_values=None, dtype=None,
+ grid_resolution=None, ghosts=None, tstate=None,
+ lboundaries=None, rboundaries=None,
+ register_discrete_field=False, **kwds):
"""
Create a new Field and a new temporary CartesianDiscreteScalarField.
- like the current object, possibly on a different backend.
+ like the current object, possibly on a different backend.
/!\ The returned discrete field is not allocated.
"""
assert ('global_resolution' not in kwds), 'Specify grid_resolution instead.'
@@ -952,21 +1108,21 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
tstate._is_read_only = is_read_only
bfield = self._dfield._field
- btopo = self._dfield._topology
+ btopo = self._dfield._topology
field = bfield.field_like(name=name, pretty_name=pretty_name,
- latex_name=latex_name, var_name=var_name,
- initial_values=initial_values, dtype=dtype,
- lboundaries=lboundaries, rboundaries=rboundaries,
- register_object=register_discrete_field)
+ latex_name=latex_name, var_name=var_name,
+ initial_values=initial_values, dtype=dtype,
+ lboundaries=lboundaries, rboundaries=rboundaries,
+ register_object=register_discrete_field)
topology = btopo.topology_like(backend=backend,
- grid_resolution=grid_resolution, ghosts=ghosts,
- lboundaries=lboundaries, rboundaries=rboundaries)
+ grid_resolution=grid_resolution, ghosts=ghosts,
+ lboundaries=lboundaries, rboundaries=rboundaries)
- dfield = TmpCartesianDiscreteScalarField(field=field, topology=topology,
- init_topology_state=tstate, **kwds)
- request = dfield.memory_request
+ dfield = TmpCartesianDiscreteScalarField(field=field, topology=topology,
+ init_topology_state=tstate, **kwds)
+ request = dfield.memory_request
request_id = dfield.memory_request_id
return (dfield, request, request_id)
@@ -1008,10 +1164,10 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
for d in xrange(self.nb_components):
self.backend.rand(out=self.data[d], **kwds)
return self
-
+
def integrate(self, scale=True, data=None, components=None):
"""Sum all the values in the mesh."""
- result = npw.zeros((1,), dtype=np.float64)
+ result = npw.zeros((1,), dtype=np.float64)
gresult = npw.zeros((1,), dtype=np.float64)
if (data is None):
data = self.sdata
@@ -1027,7 +1183,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
def norm(self, p=2, normalize=True, data=None):
"""
Compute a Lp norm of the discrete field.
-
+
Lp-norm = sum(data[d]**p)**(1.0/p) for d = 1..nb_components
summed on all grid points excluding ghosts.
@@ -1045,10 +1201,10 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
Custom data to apply the norm to.
By default this is the local to field data.
"""
- check_instance(p, (int,float))
+ check_instance(p, (int, float))
check_instance(normalize, bool)
- result = npw.zeros((1,), dtype=self.dtype)
+ result = npw.zeros((1,), dtype=self.dtype)
gresult = npw.zeros((1,), dtype=self.dtype)
if (data is None):
data = self.data
@@ -1095,45 +1251,48 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
Defaults to ghost accumulation excluding diagonals.
"""
- return self.exchange_ghosts(ghost_op=GhostOperation.ACCUMULATE,
+ return self.exchange_ghosts(ghost_op=GhostOperation.ACCUMULATE,
ghost_mask=GhostMask.CROSS,
**kwds)
-
+
def exchange_ghosts(self, components=None, directions=None,
- ghosts=None, ghost_op=None, ghost_mask=None, exchange_method=None,
- evt=None, build_exchanger=False, build_launcher=False, **kwds):
+ ghosts=None, ghost_op=None, ghost_mask=None, exchange_method=None,
+ evt=None, build_exchanger=False, build_launcher=False, **kwds):
"""
Exchange ghosts using cached ghost exchangers which are built at first use.
ie. Exchange every ghosts components of self.data using current topology state.
-
+
Defaults to full ghosts exchange, including diagonals (ie. overwrite operation).
"""
assert ('data' not in kwds)
+ msg = 'Passing ghosts as an integer is not supported anymore, use a tuple of size dim instead.'
+ if isinstance(ghosts, (int, long)):
+ raise RuntimeError(msg)
directions = to_tuple(first_not_None(directions, range(self.dim)), cast=int)
components = to_tuple(first_not_None(components, range(self.nb_components)), cast=int)
- ghosts = to_tuple(first_not_None(ghosts, self.ghosts), cast=int)
+ ghosts = to_tuple(first_not_None(ghosts, self.ghosts), cast=int)
- ghost_op = first_not_None(ghost_op, GhostOperation.EXCHANGE)
- ghost_mask = first_not_None(ghost_mask, GhostMask.FULL)
+ ghost_op = first_not_None(ghost_op, GhostOperation.EXCHANGE)
+ ghost_mask = first_not_None(ghost_mask, GhostMask.FULL)
exchange_method = first_not_None(exchange_method, ExchangeMethod.ISEND_IRECV)
-
- assert len(directions) <= self.dim
- assert len(ghosts) in (1,self.dim), ghosts
- if len(ghosts)==1:
- ghosts *= self.dim
- assert all(g<=mg for (g,mg) in zip(ghosts, self.ghosts))
-
- if any(mg>0 for mg in ghosts):
+
+ assert len(ghosts) == self.dim, msg
+ assert all(g <= mg for (g, mg) in zip(ghosts, self.ghosts))
+ assert len(directions) == len(set(directions))
+ assert 0 < len(directions) <= self.dim
+
+ if any(ghosts[i] > 0 for i in directions):
topology_state = self.topology_state
- key = (topology_state, ghosts, ghost_op, ghost_mask,
- exchange_method, components, directions)
+ key = (topology_state, ghosts,
+ ghost_op, ghost_mask,
+ exchange_method, components, directions)
if (key not in self._dfield._ghost_exchangers):
self._dfield._ghost_exchangers[key] = \
- self.build_ghost_exchanger(ghosts=ghosts,
- ghost_op=ghost_op, ghost_mask=ghost_mask,
- components=components, directions=directions,
- exchange_method=exchange_method)
+ self.build_ghost_exchanger(ghosts=ghosts,
+ ghost_op=ghost_op, ghost_mask=ghost_mask,
+ components=components, directions=directions,
+ exchange_method=exchange_method)
ghost_exchanger = self._dfield._ghost_exchangers[key]
if build_exchanger:
assert (evt is None)
@@ -1152,21 +1311,37 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
new_evt = None
return first_not_None(new_evt, evt)
- def build_ghost_exchanger(self, name=None, components=None, directions=None,
- data=None, ghosts=None, ghost_op=None, ghost_mask=None, exchange_method=None):
+ def build_ghost_exchanger(self, name=None, components=None, directions=None,
+ data=None, ghosts=None,
+ ghost_op=None, ghost_mask=None, exchange_method=None):
"""
Build a ghost exchanger for cartesian discrete fields, possibly on different data.
"""
- ghost_op = first_not_None(ghost_op, GhostOperation.EXCHANGE)
- ghost_mask = first_not_None(ghost_mask, GhostMask.FULL)
+ msg = 'Passing ghosts as an integer is not supported anymore, use a tuple of size dim instead.'
+ if isinstance(ghosts, (int, long)):
+ raise RuntimeError(msg)
+
+ ghost_op = first_not_None(ghost_op, GhostOperation.EXCHANGE)
+ ghost_mask = first_not_None(ghost_mask, GhostMask.FULL)
exchange_method = first_not_None(exchange_method, ExchangeMethod.ISEND_IRECV)
check_instance(ghost_op, GhostOperation)
check_instance(exchange_method, ExchangeMethod)
- name = first_not_None(name, '{}_{}_{}'.format(self.name, ghosts, ghost_op))
- data = to_tuple(first_not_None(data, self.data))
+ name = first_not_None(name, '{}_{}_{}'.format(self.name, ghosts, ghost_op))
+ data = to_tuple(first_not_None(data, self.data))
+
directions = to_tuple(first_not_None(directions, range(self.dim)))
- ghosts = first_not_None(ghosts, self.ghosts)
-
+ ghosts = first_not_None(ghosts, self.ghosts)
+
+ assert len(ghosts) == self.dim, msg
+ assert all(g <= mg for (g, mg) in zip(ghosts, self.ghosts))
+ assert len(directions) == len(set(directions))
+ assert 0 < len(directions) <= self.dim
+
+ if all(ghosts[i] == 0 for i in directions):
+ return None
+ if not data:
+ return None
+
d0 = data[0]
if isinstance(d0, (np.ndarray, HostArray)):
kind = Backend.HOST
@@ -1176,10 +1351,12 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
kind = None
from hysop.fields.ghost_exchangers import CartesianDiscreteFieldGhostExchanger
- return CartesianDiscreteFieldGhostExchanger(name=name,
- topology=self.topology, data=data, kind=kind,
- ghosts=ghosts, directions=directions,
- ghost_op=ghost_op, ghost_mask=ghost_mask, exchange_method=exchange_method)
+ return CartesianDiscreteFieldGhostExchanger(name=name,
+ global_lboundaries_config=self.global_lboundaries_config,
+ global_rboundaries_config=self.global_rboundaries_config,
+ topology=self.topology, data=data, kind=kind,
+ ghosts=ghosts, directions=directions,
+ ghost_op=ghost_op, ghost_mask=ghost_mask, exchange_method=exchange_method)
def view(self, topology_state):
"""
@@ -1188,7 +1365,7 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
check_instance(topology_state, CartesianTopologyState)
return CartesianDiscreteScalarFieldView(dfield=self._dfield,
topology_state=topology_state)
-
+
def as_any_dfield(self, memory_order, **kwds):
"""
Quickly take a view on this DiscreteScalarFieldView using self topology state
@@ -1202,33 +1379,38 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
state.memory_order = memory_order
return self.view(state)
-
- size = property(_get_size)
- shape = property(_get_shape)
+ size = property(_get_size)
+ shape = property(_get_shape)
compute_resolution = property(_get_compute_resolution)
- resolution = property(_get_resolution)
- npoints = property(_get_npoints)
- ghosts = property(_get_ghosts)
- space_step = property(_get_space_step)
- is_tmp = property(_get_is_tmp)
- mem_tag = property(_get_mem_tag)
- coords = property(_get_coords)
- mesh_coords = property(_get_mesh_coords)
-
- local_boundaries = property(_get_local_boundaries)
+ resolution = property(_get_resolution)
+ npoints = property(_get_npoints)
+ ghosts = property(_get_ghosts)
+ space_step = property(_get_space_step)
+ is_tmp = property(_get_is_tmp)
+ mem_tag = property(_get_mem_tag)
+ coords = property(_get_coords)
+ mesh_coords = property(_get_mesh_coords)
+ compute_coords = property(_get_compute_coords)
+ compute_mesh_coords = property(_get_compute_mesh_coords)
+
+ local_boundaries = property(_get_local_boundaries)
local_lboundaries = property(_get_local_lboundaries)
local_rboundaries = property(_get_local_rboundaries)
- global_boundaries = property(_get_global_boundaries)
- global_lboundaries = property(_get_global_lboundaries)
- global_rboundaries = property(_get_global_rboundaries)
+ global_boundaries = property(_get_global_boundaries)
+ global_lboundaries = property(_get_global_lboundaries)
+ global_rboundaries = property(_get_global_rboundaries)
+
+ global_boundaries_config = property(_get_global_boundaries_config)
+ global_lboundaries_config = property(_get_global_lboundaries_config)
+ global_rboundaries_config = property(_get_global_rboundaries_config)
- is_at_boundary = property(_get_is_at_boundary)
- is_at_left_boundary = property(_get_is_at_left_boundary)
+ is_at_boundary = property(_get_is_at_boundary)
+ is_at_left_boundary = property(_get_is_at_left_boundary)
is_at_right_boundary = property(_get_is_at_right_boundary)
periodicity = property(_get_periodicity)
-
+
compute_slices = property(_get_compute_slices)
inner_ghost_slices = property(get_inner_ghost_slices)
outer_ghost_slices = property(get_outer_ghost_slices)
@@ -1239,30 +1421,30 @@ class CartesianDiscreteScalarFieldView(CartesianDiscreteScalarFieldViewContainer
grid_npoints = property(_get_grid_npoints)
- axes = property(_get_axes)
- tstate = property(_get_tstate)
+ axes = property(_get_axes)
+ tstate = property(_get_tstate)
memory_order = property(_get_memory_order)
- data = property(_get_data, _set_data)
- buffers = property(_get_buffers)
- sdata = property(_get_sdata, _set_sdata)
- sbuffer = property(_get_sbuffer)
+ data = property(_get_data, _set_data)
+ buffers = property(_get_buffers)
+ sdata = property(_get_sdata, _set_sdata)
+ sbuffer = property(_get_sbuffer)
class CartesianDiscreteScalarField(CartesianDiscreteScalarFieldView, DiscreteScalarField):
"""
Discrete representation of cartesian scalar or vector fields,
- handling distributed (mpi) data (hysop.core.arrays.array.Array)
- wich are numpy like multidimensional arrays defined on various
+ handling distributed (mpi) data (hysop.core.arrays.array.Array)
+ wich are numpy like multidimensional arrays defined on various
array backends (numpy, OpenCL, ...).
- A CartesianDiscreteScalarField is a Field discretized on a Box (on a
+ A CartesianDiscreteScalarField is a Field discretized on a Box (on a
regular multi-dimensional grid) trough a CartesianTopology.
"""
@debug
- def __new__(cls, field, topology, init_topology_state=None,
- allocate_data=True, **kwds):
+ def __new__(cls, field, topology, init_topology_state=None,
+ allocate_data=True, **kwds):
"""
Create and initialize a CartesianDiscreteScalarField from a
Field and a CartesianTopology.
@@ -1273,7 +1455,7 @@ class CartesianDiscreteScalarField(CartesianDiscreteScalarFieldView, DiscreteSca
The continuous field that is dicrerized.
topology: :class:`~hysop.topology.cartesian.CartesianTopology`
The topology where to allocate the discrete field.
- init_state: :class:`hysop.topology.cartesian_topology.CartesianTopologyState`
+ init_state: :class:`hysop.topology.cartesian_topology.CartesianTopologyState`
The init topology state (transposition state for field initialization, optional).
kwds: dict
Base class arguments.
@@ -1286,14 +1468,14 @@ class CartesianDiscreteScalarField(CartesianDiscreteScalarFieldView, DiscreteSca
The resolution of this field, excluding ghosts.
ghosts: tuple
The number of ghosts contained in this field.
-
+
shape: tuple
Alias for compute_resolution.
data: tuple of :class:`hysop.core.arrays.array.Array`
Actual n-dimensional arrays of data (immutable), one per component.
buffers: tuple of buffers, numpy.ndarray or pyopencl.buffers
Return Array's data buffers.
- buffers are the lower level representation of data without any
+ buffers are the lower level representation of data without any
hysop wrapping, usefull to use with external libraries.
May return the same a data().
@@ -1301,43 +1483,43 @@ class CartesianDiscreteScalarField(CartesianDiscreteScalarFieldView, DiscreteSca
-----
To modify data inplace use field.data[component_id][...] = ...
- DiscreteScalarField.data = (arr0,arr1,arr2,...), DiscreteScalarField.data[0] = arr0 and
+ DiscreteScalarField.data = (arr0,arr1,arr2,...), DiscreteScalarField.data[0] = arr0 and
DiscreteScalarField._set_data(...) are equivalent and will perfom a full
copy of the arrays..
There is currenltly no way to swap data between discrete fields.
- If topology state is read-only, data view may be a constant view
- depending on the backend view capabilities (this is the default
+ If topology state is read-only, data view may be a constant view
+ depending on the backend view capabilities (this is the default
state for operator input variables).
"""
- msg='Multi-component fields have been deprecated (see DiscreteTensorField).'
+ msg = 'Multi-component fields have been deprecated (see DiscreteTensorField).'
assert field.nb_components == 1, msg
init_state = init_topology_state or CartesianTopologyState(field.dim)
- obj = super(CartesianDiscreteScalarField, cls).__new__(cls, field=field, topology=topology,
- topology_state=init_state, dfield=None, **kwds)
+ obj = super(CartesianDiscreteScalarField, cls).__new__(cls, field=field, topology=topology,
+ topology_state=init_state, dfield=None, **kwds)
obj._data = None
- obj._has_ghosts = (topology.mesh.ghosts>0).any()
-
- if allocate_data:
- msg='\nAllocation of {} {} on {}'
- msg+='\n (compute_res={}, ghosts={}, dtype={}, size={})'
- msg=msg.format(obj.full_pretty_tag,
- obj.pretty_name,
- obj.topology.topology.full_pretty_tag,
- obj.compute_resolution, obj.ghosts, obj.dtype,
- bytes2str(npw.prod(obj.resolution,
- dtype=npw.int64)*obj.dtype.itemsize))
+ obj._has_ghosts = (topology.mesh.ghosts > 0).any()
+
+ if allocate_data:
+ msg = '\nAllocation of {} {} on {}'
+ msg += '\n (compute_res={}, ghosts={}, dtype={}, size={})'
+ msg = msg.format(obj.full_pretty_tag,
+ obj.pretty_name,
+ obj.topology.topology.full_pretty_tag,
+ obj.compute_resolution, obj.ghosts, obj.dtype,
+ bytes2str(npw.prod(obj.resolution,
+ dtype=npw.int64)*obj.dtype.itemsize))
vprint(msg)
data = obj.backend.empty(shape=obj.resolution, dtype=obj.dtype)
obj._handle_data(data)
else:
from hysop.core.memory.memory_request import MemoryRequest
- memory_request = MemoryRequest(backend=obj.backend,
- dtype=obj.dtype, shape=obj.resolution)
- obj._memory_request = memory_request
+ memory_request = MemoryRequest(backend=obj.backend,
+ dtype=obj.dtype, shape=obj.resolution)
+ obj._memory_request = memory_request
obj._memory_request_id = obj.name
obj._mem_tag = field.mem_tag
return obj
@@ -1346,21 +1528,21 @@ class CartesianDiscreteScalarField(CartesianDiscreteScalarFieldView, DiscreteSca
assert (self._data is None)
from hysop.core.arrays.array import Array
if isinstance(data, tuple):
- assert len(data)==1
+ assert len(data) == 1
data = data[0]
check_instance(data, Array)
# initial value on the compute domain and on ghosts:
- (vd,vg) = self.initial_values
- if (vd is not None):
+ (vd, vg) = self.initial_values
+ if (vd is not None):
data[self.mesh.local_compute_slices] = vd
- if (vg is not None):
- for (ls,rs,shape) in self.mesh.local_outer_ghost_slices:
+ if (vg is not None):
+ for (ls, rs, shape) in self.mesh.local_outer_ghost_slices:
if (shape is not None):
data[ls] = vg
data[rs] = vg
if self.topology_state.is_read_only:
- npw.set_readonly(data[i])
+ npw.set_readonly(data)
# Store read-only views that do not own memory to
# enforce the read-only initial parameter when specified.
@@ -1372,13 +1554,14 @@ class CartesianDiscreteScalarField(CartesianDiscreteScalarFieldView, DiscreteSca
@property
def is_tmp(self):
return False
-
+
@property
def mem_tag(self):
return self._field.mem_tag
def __eq__(self, other):
return id(self) == id(other)
+
def __hash__(self):
return id(self)
@@ -1387,14 +1570,13 @@ class TmpCartesianDiscreteScalarField(CartesianDiscreteScalarField):
@debug
def __new__(cls, **kwds):
obj = super(TmpCartesianDiscreteScalarField, cls).__new__(cls, allocate_data=False,
- register_discrete_field=False, **kwds)
+ register_discrete_field=True, **kwds)
return obj
@debug
def __init__(self, **kwds):
- super(TmpCartesianDiscreteScalarField, self).__init__(allocate_data=False,
- register_discrete_field=False, **kwds)
-
+ super(TmpCartesianDiscreteScalarField, self).__init__(allocate_data=False,
+ register_discrete_field=True, **kwds)
def honor_memory_request(self, work, op=None):
from hysop.core.memory.memory_request import MultipleOperatorMemoryRequests
@@ -1413,6 +1595,6 @@ class TmpCartesianDiscreteScalarField(CartesianDiscreteScalarField):
class CartesianDiscreteTensorField(CartesianDiscreteScalarFieldViewContainerI, DiscreteTensorField):
pass
+
CartesianDiscreteField = (CartesianDiscreteScalarField, CartesianDiscreteTensorField)
"""A CartesianDiscreteField is either of CartesianDiscreteScalarField or a CartesianDiscreteTensorField"""
-
diff --git a/hysop/fields/continuous_field.py b/hysop/fields/continuous_field.py
index 8b5eeca9d91589b80665cc0a822e09762145280d..8eb8e09c08b03a079bfcd7820f76ec50e03a95c1 100644
--- a/hysop/fields/continuous_field.py
+++ b/hysop/fields/continuous_field.py
@@ -8,9 +8,10 @@ Continuous fields description and containers.
import textwrap
import sympy as sm
+import numpy as np
from abc import ABCMeta, abstractmethod
-from hysop.constants import HYSOP_REAL, HYSOP_BOOL, BoundaryCondition
+from hysop.constants import HYSOP_REAL, HYSOP_BOOL, BoundaryCondition, BoundaryConditionConfig, DirectionLabels
from hysop.tools.decorators import debug
from hysop.tools.types import check_instance, first_not_None, to_tuple
from hysop.tools.warning import HysopWarning
@@ -30,7 +31,7 @@ class FieldContainerI(TaggedObject):
"""Common abstract interface for scalar and tensor-like fields."""
@debug
- def __new__(cls, domain,
+ def __new__(cls, domain,
name=None, nb_components=None, shape=None, is_vector=None, **kwds):
"""
Create a FieldContainer on a specific domain.
@@ -52,7 +53,7 @@ class FieldContainerI(TaggedObject):
((nb_components is not None) and (nb_components > 1))):
nb_components = first_not_None(nb_components, domain.dim)
assert (is_vector is not True) or (nb_components == domain.dim)
- return VectorField(domain=domain, name=name,
+ return VectorField(domain=domain, name=name,
nb_components=nb_components, **kwds)
else:
return ScalarField(domain=domain, name=name, **kwds)
@@ -63,23 +64,20 @@ class FieldContainerI(TaggedObject):
obj._dim = int(domain.dim)
return obj
- def __tuple__(self):
- """
- Fix hysop.tools/type.to_tuple for FieldContainers,
- because __iter__ has been redefined.
- """
- return (self,)
-
+ @property
+ def is_scalar(self):
+ return (not self.is_tensor)
+
@abstractmethod
def field_like(self, name, **kwds):
"""Create a ScalarField like this object, possibly altered."""
pass
-
+
@abstractmethod
def tmp_like(self, name, **kwds):
- """Create a temporaty field like self, possibly altered."""
+ """Create a temporary field like self, possibly altered."""
pass
-
+
@abstractmethod
def fields(self):
"""Return all unique scalar fields contained in this field container."""
@@ -92,7 +90,7 @@ class FieldContainerI(TaggedObject):
but including duplicate fields.
"""
pass
-
+
@abstractmethod
def discretize(self, topology, topology_state=None):
"""
@@ -106,17 +104,17 @@ class FieldContainerI(TaggedObject):
The topology state on which to discretize this ScalarField.
"""
pass
-
+
@classmethod
- def from_sympy_expressions(cls, name, exprs, space_symbols,
+ def from_sympy_expressions(cls, name, exprs, space_symbols,
scalar_name_prefix=None, scalar_pretty_name_prefix=None,
pretty_name=None, **kwds):
"""
Create a field wich has the same shape as exprs, with optional names.
Expressions should be of kind sympy.Expr and are converted to FieldExpression: this
means they all have to contain at least one FieldExpression.
- Note that field.symbol is always a SymbolicField which is a FieldExpression.
- FieldExpression make sure boundary conditions match between fields for derivatives
+ Note that field.symbol is always a SymbolicField which is a FieldExpression.
+ FieldExpression make sure boundary conditions match between fields for derivatives
and integrations.
"""
if isinstance(exprs, sm.Expr):
@@ -147,7 +145,7 @@ class FieldContainerI(TaggedObject):
sname = None
spname = None
- fields[idx] = cls.from_sympy_expression(expr=exprs[idx],
+ fields[idx] = cls.from_sympy_expression(expr=exprs[idx],
space_symbols=space_symbols,
name=sname, pretty_name=spname, **kwds)
return TensorField.from_field_array(name=name, pretty_name=pretty_name,
@@ -181,15 +179,15 @@ class FieldContainerI(TaggedObject):
# finally return create and return the ScalarField
return ScalarField(**kwds)
-
- def gradient(self, name=None, pretty_name=None,
+
+ def gradient(self, name=None, pretty_name=None,
scalar_name_prefix=None, scalar_pretty_name_prefix=None,
- directions=None, axis=-1,
+ directions=None, axis=-1,
space_symbols=None,
dtype=None, **kwds):
"""
- Create a field capable of storing the gradient of self,
+ Create a field capable of storing the gradient of self,
possibly altered.
"""
dim = self.dim # dimension of the domain
@@ -198,7 +196,7 @@ class FieldContainerI(TaggedObject):
directions = to_tuple(first_not_None(directions, range(dim)))
space_symbols = to_tuple(first_not_None(space_symbols, frame.coords))
- check_instance(directions, tuple, minval=0, maxval=self.dim-1, minsize=1, unique=True)
+ check_instance(directions, tuple, minval=0, maxval=self.dim-1, minsize=1, unique=True)
check_instance(axis, int, minval=-ndim, maxval=ndim-1)
check_instance(space_symbols, tuple, values=SpaceSymbol, size=dim, unique=True)
@@ -224,7 +222,7 @@ class FieldContainerI(TaggedObject):
i = idx[:axis+1] + idx[axis+2:]
d = directions[idx[axis+1]]
if self.is_tensor:
- exprs[idx] = self[i].symbol(frame.time,
+ exprs[idx] = self[i].symbol(frame.time,
*space_symbols).diff(space_symbols[d])
else:
assert i==(), i
@@ -236,7 +234,7 @@ class FieldContainerI(TaggedObject):
scalar_pretty_name_prefix=scalar_pretty_name_prefix,
dtype=dtype, **kwds)
- def laplacian(self, name=None, pretty_name=None,
+ def laplacian(self, name=None, pretty_name=None,
scalar_name_prefix=None, scalar_pretty_name_prefix=None,
dtype=None, **kwds):
from hysop.symbolic.field import laplacian
@@ -246,7 +244,7 @@ class FieldContainerI(TaggedObject):
name = first_not_None(name, 'laplacian_{}'.format(self.name))
pretty_name = first_not_None(pretty_name, u'\u0394{}'.format(
self.pretty_name.decode('utf-8')))
-
+
if isinstance(exprs, npw.ndarray):
if (exprs.size == 1):
expr = exprs.item()
@@ -267,11 +265,11 @@ class FieldContainerI(TaggedObject):
dtype=dtype, **kwds)
- def div(self, name=None, pretty_name=None,
+ def div(self, name=None, pretty_name=None,
scalar_name_prefix=None, scalar_pretty_name_prefix=None,
axis=-1, dtype=None, **kwds):
"""
- Create a field capable of storing the divergence of self,
+ Create a field capable of storing the divergence of self,
on chosen axis.
"""
from hysop.symbolic.field import div
@@ -281,7 +279,7 @@ class FieldContainerI(TaggedObject):
name = first_not_None(name, 'div_{}'.format(self.name))
pretty_name = first_not_None(pretty_name, u'{}\u22c5{}'.format(nabla,
self.pretty_name.decode('utf-8')))
-
+
if exprs.size in (0,1):
expr = npw.asscalar(exprs)
return self.from_sympy_expression(expr=expr, space_symbols=frame.coords,
@@ -294,23 +292,23 @@ class FieldContainerI(TaggedObject):
scalar_pretty_name_prefix=scalar_pretty_name_prefix,
dtype=dtype, **kwds)
- def curl(self, name=None, pretty_name=None,
+ def curl(self, name=None, pretty_name=None,
scalar_name_prefix=None, scalar_pretty_name_prefix=None,
dtype=None, **kwds):
"""
- Create a field capable of storing the curl of self,
+ Create a field capable of storing the curl of self,
- Only 2D and 3D fields are supported as the curl brings
+ Only 2D and 3D fields are supported as the curl brings
a 1-vector to a 2-vector:
-
- - A vector to a pseudoscalar or a pseudoscalar to a vector in 2D
+
+ - A vector to a pseudoscalar or a pseudoscalar to a vector in 2D
- A vector to a pseudovector or a pseudovector to a vector in 3D
In 1D the curl is 0, and in 4D the curl would be a 6D 'field'.
"""
from hysop.symbolic.field import curl
-
-
+
+
if (self.dim==2):
msg='Can only take curl for a 2D field with one or two components.'
assert self.nb_components in (1,2), msg
@@ -332,7 +330,7 @@ class FieldContainerI(TaggedObject):
return self.from_sympy_expressions(
exprs=exprs, space_symbols=frame.coords,
name=name, pretty_name=pretty_name,
- scalar_name_prefix=scalar_name_prefix,
+ scalar_name_prefix=scalar_name_prefix,
scalar_pretty_name_prefix=scalar_pretty_name_prefix,
dtype=dtype, **kwds)
else:
@@ -344,7 +342,7 @@ class FieldContainerI(TaggedObject):
"""See curl."""
return self.curl(*args, **kwds)
-
+
def get_attributes(self, *attrs):
"""
Return all matching attributes contained in self.fields,
@@ -394,7 +392,7 @@ class FieldContainerI(TaggedObject):
def get_unique_attribute(self, *attr):
"""
Try to return the unique attribute common to all contained fields.
- Raise an AttributeError if a attribute is not unique accross contained
+ Raise an AttributeError if a attribute is not unique accross contained
field views.
"""
if self.has_unique_attribute(*attr):
@@ -415,6 +413,15 @@ class FieldContainerI(TaggedObject):
def has_unique_boundaries(self):
"""Return true if all contained continuous fields share the same boundaries."""
return self.has_unique_attribute("boundaries")
+ def has_unique_lboundaries_kind(self):
+ """Return true if all contained continuous fields share the same lboundaries kind."""
+ return self.has_unique_attribute("lboundaries_kind")
+ def has_unique_rboundaries_kind(self):
+ """Return true if all contained continuous fields share the same rboundaries kind."""
+ return self.has_unique_attribute("rboundaries_kind")
+ def has_unique_boundaries_kind(self):
+ """Return true if all contained continuous fields share the same boundaries kind."""
+ return self.has_unique_attribute("boundaries_kind")
def has_unique_periodicity(self):
"""Return true if all contained continuous fields share the same periodicity."""
return self.has_unique_attribute("periodicity")
@@ -448,6 +455,27 @@ class FieldContainerI(TaggedObject):
"""
return self.get_unique_attribute("boundaries")
@property
+ def lboundaries_kind(self):
+ """
+ Try to return the unique lboundaries common to all contained fields,
+ else raise an AttributeError.
+ """
+ return self.get_unique_attribute("lboundaries_kind")
+ @property
+ def rboundaries_kind(self):
+ """
+ Try to return the unique rboundaries common to all contained fields,
+ else raise an AttributeError.
+ """
+ return self.get_unique_attribute("rboundaries_kind")
+ @property
+ def boundaries_kind(self):
+ """
+ Try to return the unique boundaries kind common to all contained fields,
+ else raise an AttributeError.
+ """
+ return self.get_unique_attribute("boundaries_kind")
+ @property
def periodicity(self):
"""
Try to return the unique periodicity common to all contained fields,
@@ -461,7 +489,7 @@ class FieldContainerI(TaggedObject):
return (self is not other)
def __hash__(self):
return id(self)
-
+
def _get_domain(self):
"""Return the physical domain where this field is defined."""
@@ -479,7 +507,7 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
This object handles a dictionnary of discrete fields
(from 0 to any number).
-
+
Each discrete field is uniquely defined by the topology used to
discretize it.
@@ -526,23 +554,23 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
Underlying data type of this field
initial_values: numeric value, or tuple of numeric values, optional
Fields are initialized to specified initial value everywhere in the domain
- on first discretization.
+ on first discretization.
The input values are cast to given dtype.
-
+
If None, leaves the memory uninitialized.
If a single value is given, the whole field is initialized to this value,
the default being None (ie. no initialization at all).
If tuple, computational mesh will be initialized with the first value,
and ghosts will be initialized with the second value.
- lboundaries: array_like of BoundaryCondition, optional
+ lboundaries: array_like of BoundaryCondition or BoundaryConditionConfig, optional
Left boundary conditions, defaults to PERIODIC on each axis.
- rboundaries: array_like of BoundaryCondition, optional
+ rboundaries: array_like of BoundaryCondition or BoundaryConditionConfig, optional
Right boundary conditions, defaults to PERIODIC on each axis.
is_tmp: bool
Specify that this field is a temporary continuous field.
Basically a ScalarField that yields a temporary discrete field upon discretization.
- /!\ ** WARNING *******************************************/!\
+ /!\ ** WARNING *******************************************/!\
TemporaryDiscreteFields are allocated during setup using
temporary work buffers. Those work buffers are only
available withing the scope of operators thats use
@@ -550,7 +578,7 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
/!\ ***************************************************** /!\
kwds: dict
Base class keyword arguments.
-
+
Attributes
----------
boundaries: tuple of numpy.ndarray of BoundaryCondition
@@ -575,44 +603,44 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
warnings.warn(msg, HysopWarning)
dtype = HYSOP_BOOL
dtype = npw.dtype(dtype)
-
+
# Name and pretty name
pretty_name = first_not_None(pretty_name, name)
if isinstance(pretty_name, unicode):
pretty_name = pretty_name.encode('utf-8')
check_instance(pretty_name, str)
-
+
# Initial values
if not isinstance(initial_values,(list,tuple)):
initial_values = (initial_values, initial_values)
assert len(initial_values)==2
initial_values = tuple(initial_values)
check_instance(initial_values, tuple, size=2)
-
+
# Field boundary conditions
- lboundaries = npw.asarray(first_not_None(lboundaries,
+ lboundaries = npw.asarray(first_not_None(lboundaries,
cls.default_boundaries_from_domain(domain.lboundaries)))
- rboundaries = npw.asarray(first_not_None(rboundaries,
+ rboundaries = npw.asarray(first_not_None(rboundaries,
cls.default_boundaries_from_domain(domain.rboundaries)))
- check_instance(lboundaries, npw.ndarray, values=BoundaryCondition,
+ check_instance(lboundaries, npw.ndarray, values=(BoundaryCondition, BoundaryConditionConfig),
ndim=1, size=domain.dim, dtype=object, allow_none=True)
- check_instance(rboundaries, npw.ndarray, values=BoundaryCondition,
+ check_instance(rboundaries, npw.ndarray, values=(BoundaryCondition, BoundaryConditionConfig),
ndim=1, size=domain.dim, dtype=object, allow_none=True)
assert lboundaries.size == rboundaries.size == domain.dim
for i,(lb,rb) in enumerate(zip(lboundaries,rboundaries)):
- if (lb==BoundaryCondition.PERIODIC) ^ (rb==BoundaryCondition.PERIODIC):
+ if (lb.bc==BoundaryCondition.PERIODIC) ^ (rb.bc==BoundaryCondition.PERIODIC):
msg='Periodic BoundaryCondition mismatch on axis {}.'.format(i)
raise ValueError(msg)
- check_instance(lboundaries, npw.ndarray, values=BoundaryCondition,
+ check_instance(lboundaries, npw.ndarray, values=(BoundaryCondition, BoundaryConditionConfig),
ndim=1, size=domain.dim, dtype=object)
- check_instance(rboundaries, npw.ndarray, values=BoundaryCondition,
+ check_instance(rboundaries, npw.ndarray, values=(BoundaryCondition, BoundaryConditionConfig),
ndim=1, size=domain.dim, dtype=object)
periodic = BoundaryCondition.PERIODIC
- periodicity = (lboundaries==periodic)
-
+ periodicity = np.asarray(map(lambda x: x.bc, lboundaries))==periodic
+
obj = super(ScalarField, cls).__new__(cls, domain=domain,
- name=name, pretty_name=pretty_name,
+ name=name, pretty_name=pretty_name,
var_name=var_name, latex_name=latex_name,
tag_prefix='f', tagged_cls=ScalarField, **kwds)
obj._dtype = dtype
@@ -622,7 +650,7 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
obj._lboundaries = lboundaries
obj._rboundaries = rboundaries
obj._periodicity = periodicity
-
+
# Symbolic representation of this field
from hysop.symbolic.field import SymbolicField
obj._symbol = SymbolicField(field=obj)
@@ -654,7 +682,7 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
raise NotImplementedError(msg)
field_boundaries[i] = fbd
return field_boundaries
-
+
@classmethod
def __check_vars(cls, obj):
"""Check properties and types."""
@@ -666,17 +694,17 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
check_instance(obj.nb_components, int, minval=1)
check_instance(obj.discrete_fields, dict)
check_instance(obj.initial_values, tuple, size=2)
- check_instance(obj.lboundaries, npw.ndarray, values=BoundaryCondition,
+ check_instance(obj.lboundaries, npw.ndarray, values=(BoundaryCondition, BoundaryConditionConfig),
ndim=1, size=obj.domain.dim, dtype=object)
- check_instance(obj.rboundaries, npw.ndarray, values=BoundaryCondition,
+ check_instance(obj.rboundaries, npw.ndarray, values=(BoundaryCondition, BoundaryConditionConfig),
ndim=1, size=obj.domain.dim, dtype=object)
- check_instance(obj.periodicity, npw.ndarray, dtype=bool,
+ check_instance(obj.periodicity, npw.ndarray, dtype=bool,
ndim=1, size=obj.domain.dim)
check_instance(obj.is_tmp, bool)
def field_like(self, name, pretty_name=None,
latex_name=None, var_name=None,
- domain=None, dtype=None, is_tmp=None,
+ domain=None, dtype=None, is_tmp=None,
lboundaries=None, rboundaries=None,
initial_values=None, **kwds):
"""Create a ScalarField like this object, possibly altered."""
@@ -689,23 +717,23 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
initial_values = first_not_None(initial_values, self.initial_values)
return ScalarField(name=name, pretty_name=pretty_name,
var_name=var_name, latex_name=latex_name,
- domain=domain, dtype=dtype, is_tmp=is_tmp,
- lboundaries=lboundaries, rboundaries=rboundaries,
+ domain=domain, dtype=dtype, is_tmp=is_tmp,
+ lboundaries=lboundaries, rboundaries=rboundaries,
initial_values=initial_values, **kwds)
def tmp_like(self, name, **kwds):
"""Create a TemporaryField like self, possibly altered."""
return self.field_like(name=name, is_tmp=True, **kwds)
-
+
def short_description(self):
"""Short description of this field."""
s = '{}[pname={}, dim={}, dtype={}, bc=[{}], iv={}]'
- s = s.format(self.full_tag, self.name, self.dim,
- self.dtype,
+ s = s.format(self.full_tag, self.name, self.dim,
+ self.dtype,
self.format_boundaries(),
self.initial_values)
return s
-
+
def format_boundaries(self):
from hysop.constants import format_boundaries as fb
return fb(*self.boundaries)
@@ -726,15 +754,15 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
*initial values: {}
*topology tags: [{}]
''').format(self.full_tag,
- self.name, self.pretty_name,
+ self.name, self.pretty_name,
self.var_name, self.latex_name,
self.dim, self.dtype,
- self.lboundaries.tolist(), self.rboundaries.tolist(),
+ self.lboundaries.tolist(), self.rboundaries.tolist(),
self.initial_values,
','.join([k.full_tag for k in self.discrete_fields.keys()]))
return s[1:]
-
-
+
+
@debug
def discretize(self, topology, topology_state=None):
"""
@@ -762,14 +790,14 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
check_instance(topology_state, TopologyState)
if (topology not in self.discrete_fields):
- field = topology.discretize(self)
- check_instance(field, DiscreteField)
+ dfield = topology.discretize(self)
+ check_instance(dfield, DiscreteField)
if not self.is_tmp:
assert (topology in self.discrete_fields)
- assert (self.discrete_fields[topology] is field)
+ assert (self.discrete_fields[topology] is dfield)
else:
- field = self.discrete_fields[topology]
- return field.view(topology_state)
+ dfield = self.discrete_fields[topology]
+ return dfield.view(topology_state)
def _get_dtype(self):
"""Return the default allocation dtype of this ScalarField."""
@@ -789,9 +817,18 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
def _get_rboundaries(self):
"""Right boundary conditions."""
return self._rboundaries
+ def _get_lboundaries_kind(self):
+ """Left boundary condition kind."""
+ return np.asarray(map(lambda x: x.bc, self._lboundaries))
+ def _get_rboundaries_kind(self):
+ """Right boundary condition kind."""
+ return np.asarray(map(lambda x: x.bc, self._rboundaries))
def _get_boundaries(self):
"""Left and right boundary conditions as a tuple."""
return (self._lboundaries, self._rboundaries)
+ def _get_boundaries_kind(self):
+ """Left and right boundary condition kind as a tuple."""
+ return (self.lboundaries_kind, self._get_lboundaries_kind)
def _get_periodicity(self):
"""Numpy array mask, True is axis is periodic, else False."""
return self._periodicity
@@ -800,25 +837,28 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
return self._is_tmp
def _get_mem_tag(self):
return self._mem_tag
-
+
dtype = property(_get_dtype)
initial_values = property(_get_initial_values)
discrete_fields = property(_get_discrete_fields)
lboundaries = property(_get_lboundaries)
rboundaries = property(_get_rboundaries)
boundaries = property(_get_boundaries)
+ lboundaries_kind = property(_get_lboundaries_kind)
+ rboundaries_kind = property(_get_rboundaries_kind)
+ boundaries_kind = property(_get_boundaries_kind)
periodicity = property(_get_periodicity)
is_tmp = property(_get_is_tmp)
mem_tag = property(_get_mem_tag)
-
+
@property
def is_tensor(self):
return False
-
+
@property
def fields(self):
return (self,)
-
+
@property
def nb_components(self):
return 1
@@ -835,13 +875,13 @@ class ScalarField(NamedScalarContainerI, FieldContainerI):
class TensorField(NamedTensorContainerI, FieldContainerI):
"""
- A continuous tensor field is a collection of scalar fields
+ A continuous tensor field is a collection of scalar fields
defined on a physical domain, organized as a multi-dimensional array..
This object handles a numpy.ndarray of continuous scalar fields,
- which may have different attributes (different data types for
+ which may have different attributes (different data types for
example). It is mainly a view on scalar fields with the FieldContainerI interface.
-
+
A tensor field garanties that each different field objects have
unique names and pretty names within the tensor field. A given
continuous scalar field may appear in at multiple indices (to allow
@@ -849,13 +889,13 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
(to allow upper triangular matrices for example). Is also garanties
that all fields shares the same domain.
"""
-
+
@property
def is_tensor(self):
return True
-
- def __new__(cls, domain, name, shape,
- pretty_name=None,
+
+ def __new__(cls, domain, name, shape,
+ pretty_name=None,
name_formatter=None,
pretty_name_formatter=None,
skip_field=None,
@@ -871,28 +911,28 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
check_instance(shape, tuple, values=int)
if (len(shape)==1) and not issubclass(cls, VectorField):
obj = VectorField(domain=domain, shape=shape,
- name=name,
+ name=name,
name_formatter=name_formatter,
- pretty_name=pretty_name,
+ pretty_name=pretty_name,
pretty_name_formatter=pretty_name_formatter,
skip_field=skip_field, make_field=make_field,
fields=fields, base_kwds=base_kwds, **kwds)
return obj
-
+
name_formatter = first_not_None(name_formatter, cls.default_name_formatter)
- pretty_name_formatter = first_not_None(pretty_name_formatter,
+ pretty_name_formatter = first_not_None(pretty_name_formatter,
cls.default_pretty_name_formatter)
skip_field = first_not_None(skip_field, cls.default_skip_field)
make_field = first_not_None(make_field, cls.default_make_field)
base_kwds = first_not_None(base_kwds, {})
-
+
check_instance(domain, Domain)
if npw.prod(shape)<=0:
msg='Invalid shape for a tensor-like field, got {}.'
msg=msg.format(shape)
raise ValueError(msg)
-
+
if (fields is None):
fields = ()
for idx in npw.ndindex(*shape):
@@ -901,29 +941,29 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
else:
fname = name_formatter(basename=name, idx=idx)
pfname = pretty_name_formatter(basename=pretty_name, idx=idx)
- field = make_field(idx, domain=domain, name=fname, pretty_name=pfname,
+ field = make_field(idx, domain=domain, name=fname, pretty_name=pfname,
**kwds)
fields += (field,)
cls._check_fields(*fields)
fields = npw.asarray(fields, dtype=object).reshape(shape)
else:
assert (not kwds)
-
+
check_instance(fields, npw.ndarray, dtype=object)
assert npw.array_equal(fields.shape, shape)
- obj = super(TensorField, cls).__new__(cls, domain=domain,
- name=name, pretty_name=pretty_name,
- tag_prefix='tf', tagged_cls=TensorField,
+ obj = super(TensorField, cls).__new__(cls, domain=domain,
+ name=name, pretty_name=pretty_name,
+ tag_prefix='tf', tagged_cls=TensorField,
contained_objects=fields, **base_kwds)
obj._fields = fields
obj._name_formatter = name_formatter
obj._pretty_name_formatter = pretty_name_formatter
obj._skip_field = skip_field
-
+
from hysop.symbolic.field import SymbolicFieldTensor
obj._symbol = SymbolicFieldTensor(field=obj)
-
+
obj._check_domains(domain)
obj._check_names()
return obj
@@ -932,7 +972,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
from hysop.fields.discrete_field import DiscreteTensorField
dfields = npw.empty(shape=self.shape, dtype=object)
for (idx, field) in self.nd_iter():
- dfields[idx] = field.discretize(topology=topology,
+ dfields[idx] = field.discretize(topology=topology,
topology_state=topology_state)
return DiscreteTensorField(field=self, dfields=dfields)
@@ -956,7 +996,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
return Field(domain=domain, name=name, shape=shape, pretty_name=pretty_name,
fields=fields, **kwds)
-
+
@classmethod
def from_field_array(cls, name, fields, pretty_name=None, **kwds):
"""Create a TensorField from numpy.ndarray of fields."""
@@ -965,7 +1005,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
check_instance(pretty_name, (str, unicode), allow_none=True)
check_instance(fields, npw.ndarray, dtype=object, values=ScalarField)
shape = fields.shape
-
+
_fields = tuple(fields.ravel().tolist())
cls._check_fields(*_fields)
@@ -974,7 +1014,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
return Field(domain=domain, name=name, pretty_name=pretty_name,
shape=shape, fields=fields, **kwds)
-
+
@classmethod
def _check_fields(cls, *fields):
"""Check that at least one field is specified."""
@@ -983,9 +1023,10 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
msg='Tensor field {} should at least contain a valid ScalarField.'
msg=msg.format(name)
raise ValueError(msg)
-
+
@classmethod
def default_name_formatter(cls, basename, idx):
+
assert len(basename)>0
if basename[-1] in '0123456789':
sep = '_'
@@ -1004,11 +1045,11 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
@classmethod
def default_make_field(cls, idx, **kwds):
return ScalarField(**kwds)
-
+
@classmethod
def default_skip_field(cls, idx):
return False
-
+
def _check_domains(self, domain):
"""Check that fields share a unique domain."""
for field in self:
@@ -1016,7 +1057,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
if (field.domain.domain is not domain):
msg='Domain mismatch for field {}.'.format(field.name)
raise ValueError(msg)
-
+
def _check_names(self):
"""Check that fields names are unique."""
names = {}
@@ -1034,7 +1075,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
raise ValueError(msg)
names[name] = field
pnames[name] = field
-
+
@property
def fields(self):
"""Return all unique scalar fields contained in this field-like interface."""
@@ -1048,18 +1089,18 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
if (field in fields) and (field not in unique_fields):
unique_fields += (field,)
return unique_fields
-
+
@property
def nb_components(self):
return len(self.fields)
-
+
def short_description(self):
"""Short description of this tensor field."""
s = '{}[name={}, pname={}, dim={}, shape={}]'
s = s.format(self.full_tag, self.name, self.pretty_name, self.dim,
self.shape)
return s
-
+
def long_description(self):
"""Long description of this tensor field as a string."""
s=textwrap.dedent(
@@ -1076,8 +1117,8 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
s+=' '+'\n '.join(str(self.symbol).split('\n'))
return s
- def field_like(self, name, pretty_name=None,
- shape=None, nb_components=None,
+ def field_like(self, name, pretty_name=None,
+ shape=None, nb_components=None,
fn='field_like', **kwds):
"""Create a TensorField like this object, possibly altered."""
if (shape is None) and (nb_components is not None):
@@ -1085,13 +1126,13 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
del nb_components
shape = first_not_None(shape, self.shape)
nb_components = npw.prod(shape, dtype=npw.int64)
-
+
pretty_name = first_not_None(pretty_name, name)
check_instance(name, str)
check_instance(pretty_name, (str,unicode))
if not isinstance(pretty_name, str):
pretty_name = pretty_name.encode('utf-8')
-
+
if (nb_components == 1):
return getattr(self.fields[0], fn)(name=name, pretty_name=pretty_name, **kwds)
else:
@@ -1108,7 +1149,7 @@ class TensorField(NamedTensorContainerI, FieldContainerI):
pfname = self._pretty_name_formatter(basename=pretty_name, idx=idx)
fields[idx] = getattr(field, fn)(name=fname, pretty_name=pfname, **kwds)
return self.from_field_array(name=name, pretty_name=pretty_name, fields=fields)
-
+
def tmp_like(self, name, **kwds):
"""Create a temporary field like self, possibly altered."""
return self.field_like(name=name, fn='tmp_like', **kwds)
@@ -1133,11 +1174,23 @@ class VectorField(TensorField):
check_instance(shape, tuple, values=int, size=1)
if shape[0]==1:
return ScalarField(domain=domain, name=name, **kwds)
-
- obj = super(VectorField, cls).__new__(cls, domain=domain, name=name,
+ obj = super(VectorField, cls).__new__(cls, domain=domain, name=name,
shape=shape, **kwds)
return obj
+ @classmethod
+ def default_name_formatter(cls, basename, idx):
+ assert len(basename)>0
+ if basename[-1] in '0123456789':
+ sep = '_'
+ else:
+ sep = ''
+ if len(idx)==1:
+ name = basename + sep + '_'.join(DirectionLabels[i] for i in idx)
+ else:
+ name = basename + sep + '_'.join(str(i) for i in idx)
+ return name
+
Field = FieldContainerI
"""A Field is just a alias of FieldContainerI"""
diff --git a/hysop/fields/discrete_field.py b/hysop/fields/discrete_field.py
index 91be593970a969dd2899374a7763a4172ac11b43..1490a15a88cf54eb1ce05e4d2a67137514ef9370 100644
--- a/hysop/fields/discrete_field.py
+++ b/hysop/fields/discrete_field.py
@@ -34,6 +34,10 @@ class DiscreteScalarFieldViewContainerI(object):
@debug
def __new__(cls, **kwds):
return super(DiscreteScalarFieldViewContainerI, cls).__new__(cls, **kwds)
+
+ @property
+ def is_scalar(self):
+ return (not self.is_tensor)
@abstractmethod
def discrete_field_views(self):
@@ -69,6 +73,22 @@ class DiscreteScalarFieldViewContainerI(object):
but including duplicate fields.
"""
return len(self.discrete_field_views())
+
+ def ids_to_components(self, ids):
+ """Convert tensor coordinates into 1d offsets."""
+ check_instance(ids, tuple, values=(int,tuple), allow_none=True)
+ return tuple(self.id_to_component(_) for _ in ids)
+
+ def id_to_component(self, val):
+ check_instance(val, (int,tuple))
+ if isinstance(val, int):
+ return val
+ elif len(val)==1:
+ return val[0]
+ else:
+ strides = np.empty(shape=self.shape, dtype=np.int8).strides
+ assert len(val)==len(stride)
+ return sum(i*stride for (i,stride) in zip(val, stride))
@abstractmethod
@@ -198,7 +218,7 @@ class DiscreteScalarFieldViewContainerI(object):
pass
@abstractmethod
- def _get_buffers():
+ def _get_buffers(self):
"""Return all array data as a buffers as a tuple."""
pass
@@ -213,10 +233,14 @@ class DiscreteScalarFieldViewContainerI(object):
pass
@abstractmethod
- def _get_sbuffer():
+ def _get_sbuffer(self):
"""Return contained buffer."""
pass
+ @abstractmethod
+ def __getitem__(self, key):
+ pass
+
def get_attributes(self, *attrs):
"""
Return all matching attributes contained in self.discrete_field_views(),
@@ -397,6 +421,10 @@ class DiscreteScalarFieldView(DiscreteScalarFieldViewContainerI, TaggedObjectVie
__slots__ = ('_dfield', '_topology_state', '_topology_view', '_symbol')
+ @property
+ def is_tensor(self):
+ return False
+
@debug
def __new__(cls, dfield, topology_state, **kwds):
check_instance(dfield, DiscreteScalarField, allow_none=issubclass(cls, DiscreteScalarField))
@@ -434,7 +462,24 @@ class DiscreteScalarFieldView(DiscreteScalarFieldViewContainerI, TaggedObjectVie
def ndim(self):
"""Number of dimensions of this this tensor."""
return 0
-
+ def nd_iter(self):
+ """Return an nd-indexed iterator of contained objects."""
+ yield ((0,), self)
+ def __iter__(self):
+ """Return an iterator on unique scalar objects."""
+ return (self,).__iter__()
+ def __tuple__(self):
+ """
+ Fix hysop.tools/type.to_tuple for FieldContainers,
+ because __iter__ has been redefined.
+ """
+ return (self,)
+ def __contains__(self, obj):
+ """Check if a scalar object is contained in self."""
+ return (obj is self)
+ def __getitem__(self, slc):
+ return self
+
def discrete_field_views(self):
return (self,)
@@ -589,6 +634,8 @@ class DiscreteScalarField(NamedScalarContainerI, TaggedObject):
The continuous field that is dicrerized.
topology: :class:`~hysop.topology.topology.Topology`
The topology where to allocate the discrete field.
+ register_discrete_field: bool, defaults to True
+ If set register input topology to input continuous field.
name : string, optional
A name for the field.
pretty_name: string or unicode, optional.
@@ -681,6 +728,10 @@ class DiscreteTensorField(NamedTensorContainerI, DiscreteScalarFieldViewContaine
Is also garanties that all fields shares the same domain, but contained
discrete fields may be defined on different topologies.
"""
+
+ @property
+ def is_tensor(self):
+ return True
def __new__(cls, field, dfields, name=None,
pretty_name=None, latex_name=None, **kwds):
@@ -1002,12 +1053,16 @@ class DiscreteTensorField(NamedTensorContainerI, DiscreteScalarFieldViewContaine
assert (evt is None), 'Cannot spevify event while building a launcher.'
from hysop.fields.ghost_exchangers import MultiGhostExchanger
ghost_exchangers = MultiGhostExchanger(name='{}_ghost_exchange'.format(self.name))
+ all_none = True
for (idx, dfield) in self.nd_iter():
ge = dfield.exchange_ghosts(
build_launcher=False, build_exchanger=True,
**kwds)
+ all_none &= (ge is None)
ghost_exchangers += ge
- if (build_exchanger):
+ if all_none:
+ return None
+ elif (build_exchanger):
return ghost_exchangers
else:
return ghost_exchangers._build_launcher()
@@ -1028,12 +1083,16 @@ class DiscreteTensorField(NamedTensorContainerI, DiscreteScalarFieldViewContaine
assert (evt is None), 'Cannot spevify event while building a launcher.'
from hysop.fields.ghost_exchangers import MultiGhostExchanger
ghost_exchangers = MultiGhostExchanger(name='{}_ghost_exchange'.format(self.name))
+ all_none = True
for (idx, dfield) in self.nd_iter():
ge = dfield.accumulate_ghosts(
build_launcher=False, build_exchanger=True,
**kwds)
+ all_none &= (ge is None)
ghost_exchangers += ge
- if (build_exchanger):
+ if all_none:
+ return None
+ elif (build_exchanger):
return ghost_exchangers
else:
return ghost_exchangers._build_launcher()
@@ -1051,10 +1110,15 @@ class DiscreteTensorField(NamedTensorContainerI, DiscreteScalarFieldViewContaine
"""
from hysop.fields.ghost_exchangers import MultiGhostExchanger
ghost_exchangers = MultiGhostExchanger(name='{}_ghost_exchange'.format(self.name))
+ all_none = True
for (idx, dfield) in self.nd_iter():
ge = dfield.build_ghost_exchanger(**kwds)
+ all_none &= (ge is None)
ghost_exchangers += ge
- return ghost_exchangers
+ if all_none:
+ return None
+ else:
+ return ghost_exchangers
def __getitem__(self, slc):
dfields = self._dfields.__getitem__(slc)
diff --git a/hysop/fields/field_requirements.py b/hysop/fields/field_requirements.py
index 8a449863fef1bfb3b34cd318abb47b89429e0349..7d619d65a8a7a44bf346982ddf293fcf76b7ef38 100644
--- a/hysop/fields/field_requirements.py
+++ b/hysop/fields/field_requirements.py
@@ -15,7 +15,8 @@ from hysop.fields.discrete_field import DiscreteScalarField
# 0: no debug logs
# 1: topo creation summary for each field
# 2: topo creation details for all discrete field requirements
-TOPO_CREATION_DEBUG_LEVEL=0
+TOPO_CREATION_DEBUG_LEVEL = 0
+
def gprint(*args, **kwds):
level = kwds.pop('level', 2)
@@ -33,33 +34,33 @@ class DiscreteFieldRequirements(object):
_registered_requirements = set()
def __init__(self, operator, variables, field,
- min_ghosts=None,
- max_ghosts=None,
- can_split=None,
- memory_order=None,
- axes=None,
- _register=True,
- **kwds):
+ min_ghosts=None,
+ max_ghosts=None,
+ can_split=None,
+ memory_order=None,
+ axes=None,
+ _register=True,
+ **kwds):
if _register:
key = (id(operator), id(variables), id(field))
if key in self._registered_requirements:
- msg='Operator {} has already registered requirements for field {} '
- msg+='to variables id {}.'
- msg=msg.format(operator.name, field.name, id(variables))
+ msg = 'Operator {} has already registered requirements for field {} '
+ msg += 'to variables id {}.'
+ msg = msg.format(operator.name, field.name, id(variables))
raise RuntimeError(msg)
else:
if __DEBUG__:
- msg='Operator {} registered requirements of field {} to variables id {}.'
- msg=msg.format(operator.name, field.name, id(variables))
+ msg = 'Operator {} registered requirements of field {} to variables id {}.'
+ msg = msg.format(operator.name, field.name, id(variables))
print(msg)
self._registered_requirements.update(key)
super(DiscreteFieldRequirements, self).__init__(**kwds)
check_instance(field, ScalarField)
check_instance(operator, ComputationalGraphNode, allow_none=(not _register))
- check_instance(variables, dict, keys=ScalarField,
- values=(Topology,TopologyDescriptor), allow_none=(not _register))
+ check_instance(variables, dict, keys=ScalarField,
+ values=(Topology, TopologyDescriptor), allow_none=(not _register))
self._operator = operator
self._field = field
@@ -82,24 +83,24 @@ class DiscreteFieldRequirements(object):
def copy(self):
return DiscreteFieldRequirements(operator=self._operator,
- variables=self._variables, field=self._field,
- min_ghosts = self._min_ghosts,
- max_ghosts = self._max_ghosts,
- can_split = self._can_split,
- memory_order = self._memory_order,
- axes = self._axes)
+ variables=self._variables, field=self._field,
+ min_ghosts=self._min_ghosts,
+ max_ghosts=self._max_ghosts,
+ can_split=self._can_split,
+ memory_order=self._memory_order,
+ axes=self._axes)
def is_default(self):
return (self == self._default())
def _default(self):
return DiscreteFieldRequirements(self._operator, self._variables, self._field,
- _register=False)
+ _register=False)
def __eq__(self, other):
- eq = (self.operator is other.operator)
+ eq = (self.operator is other.operator)
eq &= (self.variables is other.variables)
- eq &= (self.field is other.field)
+ eq &= (self.field is other.field)
eq &= (self.min_ghosts == other.min_ghosts).all()
eq &= (self.max_ghosts == other.max_ghosts).all()
eq &= (self.can_split == other.can_split).all()
@@ -109,8 +110,8 @@ class DiscreteFieldRequirements(object):
def __hash__(self):
return id(self.operator) ^ id(self.variables) ^ id(self.field) ^ \
- hash((to_tuple(self.min_ghosts), to_tuple(self.max_ghosts),
- self.memory_order, self.tstates))
+ hash((to_tuple(self.min_ghosts), to_tuple(self.max_ghosts),
+ self.memory_order, self.tstates))
def ghost_str(self, array):
inf = u'+\u221e'
@@ -120,18 +121,23 @@ class DiscreteFieldRequirements(object):
def __str__(self):
return u'{:15s} {:>10s}<=ghosts<{:<10s} memory_order={} can_split={} tstates={}'.format(
u'{}::{}'.format(getattr(self.operator, 'name', u'UnknownOperator'),
- getattr(self.field, 'name', u'UnknownField')),
+ getattr(self.field, 'name', u'UnknownField')),
self.ghost_str(self.min_ghosts),
self.ghost_str(self.max_ghosts+1),
self.memory_order,
- u''+str(self.can_split.view(np.int8)),
- u'[{}]'.format(u','.join(u''+str(ts) for ts in self.tstates)) \
- if self.tstates else u'ANY').encode('utf-8')
+ u''+str(self.can_split.view(np.int8)),
+ u'[{}]'.format(u','.join(u''+str(ts) for ts in self.tstates))
+ if self.tstates else u'ANY').encode('utf-8')
def get_axes(self):
return self._axes
+
def set_axes(self, axes):
check_instance(axes, tuple, values=tuple, allow_none=True)
+ if axes:
+ if not all([len(_) == self._dim for _ in axes]):
+ msg = 'all given axis should be of length {}, given {}'.format(self._dim, axes)
+ assert False, msg
self._axes = axes
def get_tstates(self):
@@ -143,94 +149,109 @@ class DiscreteFieldRequirements(object):
def get_memory_order(self):
return self._memory_order
+
def set_memory_order(self, memory_order):
check_instance(memory_order, MemoryOrdering, allow_none=True)
if (memory_order is None):
- memory_order = MemoryOrdering.ANY
- assert memory_order in (MemoryOrdering.C_CONTIGUOUS,
+ memory_order = MemoryOrdering.ANY
+ assert memory_order in (MemoryOrdering.C_CONTIGUOUS,
MemoryOrdering.F_CONTIGUOUS,
MemoryOrdering.ANY), memory_order
self._memory_order = memory_order
def get_min_ghosts(self):
return self._min_ghosts
+
def set_min_ghosts(self, min_ghosts):
self._min_ghosts = np.asarray(to_list(min_ghosts)
- if (min_ghosts is not None) else [0]*self.workdim)
+ if (min_ghosts is not None) else [0]*self.workdim)
assert self.min_ghosts.size == self.workdim
def get_max_ghosts(self):
return self._max_ghosts
+
def set_max_ghosts(self, max_ghosts):
self._max_ghosts = np.asarray(to_list(max_ghosts)
- if (max_ghosts is not None) else [np.inf]*self.workdim)
+ if (max_ghosts is not None) else [np.inf]*self.workdim)
assert self.max_ghosts.size == self.workdim
def get_can_split(self):
return self._can_split
+
def set_can_split(self, can_split):
- self._can_split = np.asarray(to_list(can_split)
- if (can_split is not None) else [1]*self.workdim, dtype=np.bool_)
- assert self.can_split.size == self.workdim
+ self._can_split = np.asarray(to_list(can_split)
+ if (can_split is not None) else [1]*self.workdim, dtype=np.bool_)
+ assert self.can_split.size == self.workdim
def get_work_dim(self):
return self._work_dim
+
def get_operator(self):
return self._operator
+
def get_field(self):
return self._field
+
def get_variables(self):
return self._variables
+
def get_topology_descriptor(self):
return self._topology_descriptor
- can_split = property(get_can_split, set_can_split)
+ can_split = property(get_can_split, set_can_split)
min_ghosts = property(get_min_ghosts, set_min_ghosts)
max_ghosts = property(get_max_ghosts, set_max_ghosts)
- axes = property(get_axes, set_axes)
- tstates = property(get_tstates)
+ axes = property(get_axes, set_axes)
+ tstates = property(get_tstates)
memory_order = property(get_memory_order, set_memory_order)
- workdim = property(get_work_dim)
- operator = property(get_operator)
- field = property(get_field)
+ workdim = property(get_work_dim)
+ operator = property(get_operator)
+ field = property(get_field)
variables = property(get_variables)
topology_descriptor = property(get_topology_descriptor)
- def is_compatible_with(self, other):
+ def is_compatible_with(self, other, i=None):
assert self.field == other.field, 'field mismatch.'
if isinstance(other, DiscreteFieldRequirements):
- others=set([other])
+ others = set([other])
elif isinstance(other, MultiFieldRequirements):
if self.topology_descriptor in other.requirements.keys():
- others=other.requirements[self.topology_descriptor]
+ others = other.requirements[self.topology_descriptor]
else:
return True
else:
- msg='Unknown type {}.'.format(other.__class__)
+ msg = 'Unknown type {}.'.format(other.__class__)
raise TypeError(msg)
for other in others:
assert self.workdim == other.workdim, 'workdim mismatch.'
assert self.topology_descriptor == other.topology_descriptor, \
- 'topology_descriptor mismatch.'
+ 'topology_descriptor mismatch.'
if (self.field.lboundaries != other.field.lboundaries).any():
- gprint(" ->lboundaries mismatch")
+ if (i is not None):
+ gprint(" => lboundaries mismatch with subgroup {}".format(i))
return False
if (self.field.rboundaries != other.field.rboundaries).any():
- gprint(" ->rboundaries mismatch")
+ if (i is not None):
+ gprint(" => rboundaries mismatch with subgroup {}".format(i))
return False
if (other.max_ghosts < self.min_ghosts).any():
- gprint(" ->ghosts incompatibility")
+ if (i is not None):
+ gprint(" => ghosts incompatibility with subgroup {}".format(i))
return False
if (other.min_ghosts > self.max_ghosts).any():
- gprint(" ->ghosts incompatibility")
+ if (i is not None):
+ gprint(" => ghosts incompatibility with subgroup {}".format(i))
return False
- multiprocess = (main_size>1)
- if multiprocess and (other.can_split * self.can_split).any():
- gprint(" ->splitting incompatibility")
+ multiprocess = (main_size > 1)
+ if multiprocess and not (other.can_split * self.can_split).any():
+ if (i is not None):
+ gprint(" => splitting incompatibility with subgroup {}".format(i))
return False
+ if (i is not None):
+ gprint(" => compatible with subgroup {}".format(i))
return True
def update_requirements(self, other):
@@ -249,30 +270,30 @@ class DiscreteFieldRequirements(object):
topology = topology or self.variables[self.field]
check_instance(topology, Topology)
if topology.domain.dim != self.field.dim:
- msg='{} Dimension mismatch between field and topology.\n field={}d, topology={}d.'
- msg=msg.format(self._header, self.field.dim, topology.domain.dim)
+ msg = '{} Dimension mismatch between field and topology.\n field={}d, topology={}d.'
+ msg = msg.format(self._header, self.field.dim, topology.domain.dim)
raise RuntimeError(msg)
if (topology.grid_resolution != self.topology_descriptor.grid_resolution).any():
- msg='{} Grid resolution mismatch between requirement and topology.\n '
- msg+=' requirement={}\n topology={}'
- msg=msg.format(self._header,
- self.topology_descriptor.grid_resolution,
- topology.grid_resolution)
+ msg = '{} Grid resolution mismatch between requirement and topology.\n '
+ msg += ' requirement={}\n topology={}'
+ msg = msg.format(self._header,
+ self.topology_descriptor.grid_resolution,
+ topology.grid_resolution)
raise RuntimeError(msg)
if (topology.global_resolution != self.topology_descriptor.global_resolution).any():
- msg='{} Global resolution mismatch between requirement and topology.\n '
- msg+=' requirement={}\n topology={}'
- msg=msg.format(self._header,
- self.topology_descriptor.global_resolution,
- topology.global_resolution)
+ msg = '{} Global resolution mismatch between requirement and topology.\n '
+ msg += ' requirement={}\n topology={}'
+ msg = msg.format(self._header,
+ self.topology_descriptor.global_resolution,
+ topology.global_resolution)
raise RuntimeError(msg)
if (topology.ghosts < self.min_ghosts).any():
- msg='{} min ghosts constraint was not met.\n min={}, actual={}.'
- msg=msg.format(self._header, self.min_ghosts, topology.ghosts)
+ msg = '{} min ghosts constraint was not met.\n min={}, actual={}.'
+ msg = msg.format(self._header, self.min_ghosts, topology.ghosts)
raise RuntimeError(msg)
if (topology.ghosts > self.max_ghosts).any():
- msg='{} max ghosts constraint was not met.\n max={}, actual={}.'
- msg=msg.format(self._header, self.max_ghosts, topology.ghosts)
+ msg = '{} max ghosts constraint was not met.\n max={}, actual={}.'
+ msg = msg.format(self._header, self.max_ghosts, topology.ghosts)
raise RuntimeError(msg)
def check_discrete_topology_state(self, state):
@@ -281,16 +302,16 @@ class DiscreteFieldRequirements(object):
if (self.memory_order is not None) and \
(self.memory_order is not MemoryOrdering.ANY) and \
(self.memory_order != state.memory_order):
- msg='{} memory_order mismatch between requirement and topology state.\n reqs={}, state={}.'
- msg=msg.format(self._header, self.memory_order, state.memory_order)
+ msg = '{} memory_order mismatch between requirement and topology state.\n reqs={}, state={}.'
+ msg = msg.format(self._header, self.memory_order, state.memory_order)
raise RuntimeError(msg)
if (self.tstates is not None) and \
(state.tstate not in self.tstates):
- msg='{} Transposition state mismatch between requirement and topology state.\n'
- msg+=' reqs=[{}], state={}.'
- msg=msg.format(self._header,
- ','.join([str(x) for x in self.tstates]),
- state.tstate)
+ msg = '{} Transposition state mismatch between requirement and topology state.\n'
+ msg += ' reqs=[{}], state={}.'
+ msg = msg.format(self._header,
+ ','.join([str(x) for x in self.tstates]),
+ state.tstate)
raise RuntimeError(msg)
def check_state(self, dfield):
@@ -305,23 +326,22 @@ class DiscreteFieldRequirements(object):
"""
assert isinstance(topology, Topology)
assert not isinstance(self.variables[self.field], Topology) \
- or (self.variables[self.field] == topology)
+ or (self.variables[self.field] == topology)
self.check_topology(topology)
self.variables[self.field] = topology
class MultiFieldRequirements(object):
-
- __slots__ = ('field', 'requirements', 'built')
+ __slots__ = ('field', 'requirements', 'built', 'common_can_split')
def __init__(self, field):
self.field = field
self.requirements = {}
self.built = False
+ self.common_can_split = None
def copy(self):
- requirements = { k:v.copy() for (k,v) in self.requirements.items() }
-
+ requirements = {k: v.copy() for (k, v) in self.requirements.items()}
obj = MultiFieldRequirements(field=self.field)
obj.built = self.built
obj.requirements = requirements
@@ -343,10 +363,10 @@ class MultiFieldRequirements(object):
if (update_req is None):
continue
if isinstance(update_req, MultiFieldRequirements):
- tds = update_req.requirements.keys()
+ tds = update_req.requirements.keys()
reqs = update_req.requirements.values()
else:
- tds = [update_req.topology_descriptor]
+ tds = [update_req.topology_descriptor]
reqs = [[update_req]]
for td, req in zip(tds, reqs):
@@ -358,40 +378,82 @@ class MultiFieldRequirements(object):
return
gprint(" 1) SPLITTING REQUIREMENTS IN COMPATIBLE SUBGROUPS:")
- splitted_reqs = self._split()
+ multi_process = (self.requirements.keys()[0].mpi_params.size > 1)
+ splitted_reqs = self._split(multi_process)
+
+ gprint(" 2) DETERMINING COMMON CARTESIAN TOPOLOGY SPLITTING AXES (if possible):")
+ can_split = 1
+ for (i, compatible_reqs) in enumerate(splitted_reqs):
+ subgroup_can_split = compatible_reqs.common_can_split
+ can_split *= subgroup_can_split
+ gprint(' *subgroup{}.can_split = {}'.format(i, subgroup_can_split))
+ gprint(' => Global available split directions for field {} are {}'.format(
+ self.field.name, can_split))
+ if can_split.any():
+ gprint(' => Enforcing this configuration for Cartesian topology creation.')
+ for compatible_reqs in splitted_reqs:
+ compatible_reqs.common_can_split = can_split
+ else:
+ gprint(' => No common splitting axes found between all subgroups.')
- gprint(" 2) BUILDING TOPOLOGIES:")
- for (i,compatible_reqs) in enumerate(splitted_reqs):
+ gprint(" 3) BUILDING TOPOLOGIES:")
+ all_topologies = set()
+ for (i, compatible_reqs) in enumerate(splitted_reqs):
gprint(" *building topology for requirement group {}".format(i))
- compatible_reqs._build_compatible_topologies()
+ subgroup_topologies = compatible_reqs._build_compatible_topologies()
+ all_topologies.update(subgroup_topologies)
+ gprint(" Summary of topologies for field {}, subgroup {}:".format(self.field.name, i))
+ for topo in subgroup_topologies:
+ gprint(" *{}".format(topo.short_description()))
+ gprint("", level=1)
+ gprint(" Summary of topologies for field {}:".format(self.field.name))
+ for topo in all_topologies:
+ gprint(" *{}".format(topo.short_description()))
+ gprint("", level=1)
+
self.built = True
def all_compatible(self):
for topology_descriptor in self.requirements:
requirements = self.requirements[topology_descriptor]
- assert len(requirements)>0
+ assert len(requirements) > 0
for req0, req1 in it.combinations(requirements, 2):
if not req0.is_compatible_with(req1):
return False
return True
- def _split(self):
+ def _split(self, multi_process):
sub_field_requirements = []
for lreq in self.requirements.values():
- for req in lreq:
- gprint(" {}".format(req))
+ for req in sorted(lreq, key=lambda x: str(x)):
+ gprint(" *Requirement {}".format(req))
ok = False
- for multi_reqs in sub_field_requirements:
- if req.is_compatible_with(multi_reqs):
+ for (i, multi_reqs) in enumerate(sub_field_requirements):
+ if req.is_compatible_with(multi_reqs, i):
multi_reqs.update(req)
- ok=True
+ ok = True
break
if not ok:
- gprint(" => this requirement is not compatible with any existing requirement group, creating a new one.")
+ gprint(" => this requirement is not compatible with any existing requirement group, creating a new one (subgroup {}).".format(
+ len(sub_field_requirements)))
new_group = MultiFieldRequirements(self.field)
new_group.update(req)
sub_field_requirements.append(new_group)
assert self.nrequirements() == sum(sf.nrequirements() for sf in sub_field_requirements)
+ for multi_reqs in sub_field_requirements:
+ for topology_descriptor, reqs in multi_reqs.requirements.iteritems():
+ if isinstance(topology_descriptor, Topology):
+ dim = topology_descriptor.domain_dim
+ else:
+ dim = topology_descriptor.dim
+ can_split = npw.integer_ones(shape=(dim,))
+ for req in reqs:
+ if isinstance(req.topology_descriptor, Topology):
+ can_split *= (req.topology_descriptor.proc_shape > 1)
+ else:
+ can_split *= req.can_split
+ assert (not multi_process) or can_split.any()
+ multi_reqs.common_can_split = can_split
return sub_field_requirements
def _build_compatible_topologies(self):
@@ -408,7 +470,7 @@ class MultiFieldRequirements(object):
known_topologies = set()
unknown_topologies = set()
- ghosts = npw.integer_zeros(shape=(dim,))
+ ghosts = npw.integer_zeros(shape=(dim,))
can_split = npw.integer_ones(shape=(dim,))
for req in reqs:
@@ -421,9 +483,10 @@ class MultiFieldRequirements(object):
unknown_topologies.add(req)
for req in unknown_topologies:
- gprint(' >choose or create topology from {} existing topologies:'.format(len(known_topologies)), end='')
+ gprint(' >choose or create topology from {} existing topologies:'.format(
+ len(known_topologies)), end='')
topo = req.topology_descriptor.choose_or_create_topology(known_topologies,
- ghosts=ghosts, cutdirs=can_split)
+ ghosts=ghosts, cutdirs=self.common_can_split)
if (topo in known_topologies):
gprint(" choosed existing topology {}.".format(topo.pretty_tag))
else:
@@ -431,11 +494,8 @@ class MultiFieldRequirements(object):
known_topologies.add(topo)
req.set_and_check_topology(topo)
all_topologies.update(known_topologies)
-
- gprint("SUMMARY OF CREATED TOPOLOGIES FOR FIELD {}:".format(self.field.name), level=1)
- for topo in all_topologies:
- gprint(" *{}".format(topo.short_description()), level=1)
- gprint("")
+
+ return all_topologies
class OperatorFieldRequirements(object):
@@ -443,24 +503,25 @@ class OperatorFieldRequirements(object):
__slots__ = ('_input_field_requirements', '_output_field_requirements')
def __init__(self, input_field_requirements=None,
- output_field_requirements=None,
- **kwds):
+ output_field_requirements=None,
+ **kwds):
super(OperatorFieldRequirements, self).__init__(**kwds)
-
- check_instance(input_field_requirements, dict, keys=ScalarField,
- values=MultiFieldRequirements, allow_none=True)
+
+ check_instance(input_field_requirements, dict, keys=ScalarField,
+ values=MultiFieldRequirements, allow_none=True)
self._input_field_requirements = input_field_requirements or dict()
-
- check_instance(output_field_requirements, dict, keys=ScalarField,
- values=MultiFieldRequirements, allow_none=True)
+
+ check_instance(output_field_requirements, dict, keys=ScalarField,
+ values=MultiFieldRequirements, allow_none=True)
self._output_field_requirements = output_field_requirements or dict()
def get_input_field_requirements(self):
return self._input_field_requirements
+
def get_output_field_requirements(self):
return self._output_field_requirements
- input_field_requirements = property(get_input_field_requirements)
+ input_field_requirements = property(get_input_field_requirements)
output_field_requirements = property(get_output_field_requirements)
def update(self, requirements):
@@ -469,9 +530,9 @@ class OperatorFieldRequirements(object):
self.update_outputs(requirements._output_field_requirements)
def update_inputs(self, input_field_requirements):
- check_instance(input_field_requirements, dict, keys=ScalarField,
- values=(DiscreteFieldRequirements,MultiFieldRequirements,type(None)))
- for ifield,ireqs in input_field_requirements.iteritems():
+ check_instance(input_field_requirements, dict, keys=ScalarField,
+ values=(DiscreteFieldRequirements, MultiFieldRequirements, type(None)))
+ for ifield, ireqs in input_field_requirements.iteritems():
if (ireqs is not None):
ireqs = ireqs.copy()
if not isinstance(ireqs, MultiFieldRequirements):
@@ -484,9 +545,9 @@ class OperatorFieldRequirements(object):
self._input_field_requirements[ifield] = ireqs
def update_outputs(self, output_field_requirements):
- check_instance(output_field_requirements, dict, keys=ScalarField,
- values=(DiscreteFieldRequirements,MultiFieldRequirements))
- for ofield,oreqs in output_field_requirements.iteritems():
+ check_instance(output_field_requirements, dict, keys=ScalarField,
+ values=(DiscreteFieldRequirements, MultiFieldRequirements))
+ for ofield, oreqs in output_field_requirements.iteritems():
oreqs = oreqs.copy()
if not isinstance(oreqs, MultiFieldRequirements):
_oreqs = oreqs
@@ -502,9 +563,9 @@ class OperatorFieldRequirements(object):
"""
Iterates over (field, topology_descriptor, field_requirement) for all input requirements.
"""
- for (field,freqs) in self.input_field_requirements.iteritems():
+ for (field, freqs) in self.input_field_requirements.iteritems():
freqs = freqs.requirements
- for (td,reqs) in freqs.iteritems():
+ for (td, reqs) in freqs.iteritems():
for req in reqs:
yield field, td, req
@@ -512,9 +573,9 @@ class OperatorFieldRequirements(object):
"""
Iterates over (field, topology_descriptor, field_requirement) for all output requirements.
"""
- for (field,freqs) in self.output_field_requirements.iteritems():
+ for (field, freqs) in self.output_field_requirements.iteritems():
freqs = freqs.requirements
- for (td,reqs) in freqs.iteritems():
+ for (td, reqs) in freqs.iteritems():
for req in reqs:
yield (field, td, req)
@@ -539,31 +600,32 @@ class OperatorFieldRequirements(object):
"""
check_instance(field, ScalarField)
if field not in field_requirements:
- msg='No requirements found for field {}.'.format(field.name)
+ msg = 'No requirements found for field {}.'.format(field.name)
raise AttributeError(msg)
freqs = field_requirements[field].requirements
- if len(freqs.keys())>1:
- msg='Multiple topology descriptors are present for field {}.'.format(field.name)
+ if len(freqs.keys()) > 1:
+ msg = 'Multiple topology descriptors are present for field {}.'.format(field.name)
raise RuntimeError(msg)
- if len(freqs.keys())==0:
- msg='No topology descriptors are present for field {}.'.format(field.name)
+ if len(freqs.keys()) == 0:
+ msg = 'No topology descriptors are present for field {}.'.format(field.name)
raise RuntimeError(msg)
td = freqs.keys()[0]
reqs = freqs[td]
- if len(reqs)>1:
- msg='Multiple requirements are present for field {}.'.format(field.name)
+ if len(reqs) > 1:
+ msg = 'Multiple requirements are present for field {}.'.format(field.name)
raise RuntimeError(msg)
return (td, next(iter(reqs)))
def get_input_requirement(self, field):
return self._get_requirement(field, self._input_field_requirements)
+
def get_output_requirement(self, field):
return self._get_requirement(field, self._output_field_requirements)
@debug
def build_topologies(self):
- fields = set(self._input_field_requirements.keys()
- + self._output_field_requirements.keys())
+ fields = set(self._input_field_requirements.keys()
+ + self._output_field_requirements.keys())
# enforce deterministic iteration
for field in sorted(fields, key=lambda x: '{}::{}'.format(x.name, x.short_description())):
reqs = MultiFieldRequirements(field)
diff --git a/hysop/fields/ghost_exchangers.py b/hysop/fields/ghost_exchangers.py
index 321595dbd575bb07732f41f6590684cafd1652ec..66ecc18ad97f524792528c17e7fcd9ad46a5cbc2 100644
--- a/hysop/fields/ghost_exchangers.py
+++ b/hysop/fields/ghost_exchangers.py
@@ -1,6 +1,5 @@
-
from abc import ABCMeta, abstractmethod
-from hysop.deps import np, hashlib
+from hysop.deps import np, hashlib, __builtin__, print_function
from hysop.tools.types import check_instance, to_tuple, first_not_None
from hysop.tools.numerics import default_invalid_value
from hysop.tools.mpi_utils import iter_mpi_requests, dtype_to_mpi_type
@@ -13,13 +12,30 @@ from hysop.core.mpi import MPI
from hysop.core.mpi.topo_tools import TopoTools
from hysop.backend.device.opencl import cl, clArray
from hysop.backend.device.opencl.opencl_kernel_launcher import HostLauncherI
-from hysop.constants import BoundaryCondition
-
+from hysop.constants import BoundaryCondition, BoundaryConditionConfig
+
+GHOST_EXCHANGE_DEBUG_LEVEL=0
+def gprint(*args, **kwds):
+ level = kwds.pop('level', 2)
+ if GHOST_EXCHANGE_DEBUG_LEVEL >= level:
+ __builtin__.print(*args, **kwds)
+def gprint_buffer(msg, buf, *args, **kwds):
+ no_data = kwds.pop('no_data', False)
+ if isinstance(buf, list):
+ mpi_type = buf[1]
+ buf = buf[0]
+ else:
+ mpi_type=None
+ gprint('{}: mpi_type={}, shape={}, dtype={}, c_contiguous={}, f_contiguous={}'.format(msg,
+ mpi_type, buf.shape, buf.dtype, buf.flags['C_CONTIGUOUS'], buf.flags['F_CONTIGUOUS']))
+ if no_data:
+ return
+ gprint(' ' + '\n '.join(str(buf).split('\n')))
class LocalBoundaryExchanger(object):
"""
Helper class to generate symmetric and antisymmetric local ghost exchangers.
-
+
This is used for non-periodic boundary conditions:
HOMOGENEOUS_DIRICHLET: antisymmetric ghost exchange
HOMOGENEOUS_NEUMANN: symmetric ghost exchange
@@ -47,7 +63,7 @@ class LocalBoundaryExchanger(object):
slices = [slice(None,None)]*ndim
slices[direction] = slice(*args)
return tuple(slices)
-
+
if to_left:
src_slc = mk_slc(G, S, +1)
dst_slc = mk_slc(0, G+1, +1)
@@ -58,10 +74,10 @@ class LocalBoundaryExchanger(object):
dst_slc = mk_slc(G, S, +1)
islc = mk_slc(None, None, -1)
oslc = mk_slc(None, None, None)
-
+
hslc = mk_slc(0, H.size, 1, extend=True)
H = H[hslc]
-
+
def exchange_ghosts(X):
assert (X is not None)
assert (X.shape == shape)
@@ -74,13 +90,20 @@ class LocalBoundaryExchanger(object):
H = (1,)*S
return cls.build_exchanger(shape=shape, direction=direction,
H=H, to_left=to_left)
-
+
@classmethod
def build_antisymmetric_exchanger(cls, shape, direction, to_left):
S = (shape[direction]+1)//2
H = (0,)+(-1,)*(S-1)
return cls.build_exchanger(shape=shape, direction=direction,
H=H, to_left=to_left)
+
+ @classmethod
+ def build_scalar_exchanger(cls, value, shape, direction, to_left):
+ def exchange_ghosts(X, value=value):
+ assert (X is not None)
+ X[...] = value
+ return exchange_ghosts
class GhostExchangerI(object):
@@ -134,16 +157,16 @@ class MultiGhostExchanger(GhostExchangerI):
if (self.kind is Backend.OPENCL):
kwds.setdefault('queue', self._exchangers[0].cl_env.default_queue)
return self._launcher(**kwds)
-
+
def _build_launcher(self):
if (self._launcher is not None):
return self._launcher
elif (not self._exchangers):
return None
-
+
for g in self._exchangers:
g._build_launcher()
-
+
if (self.kind is Backend.HOST):
def _launcher(**kwds):
for g in self._exchangers:
@@ -166,7 +189,7 @@ class MultiGhostExchanger(GhostExchangerI):
class GhostExchanger(GhostExchangerI):
"""Prepare a backend specific ghost exchange, possibly on multiple data."""
- def __init__(self, name, topology, data,
+ def __init__(self, name, topology, data,
exchange_method, ghost_op, ghost_mask):
check_instance(name, str)
check_instance(topology, TopologyView)
@@ -203,11 +226,11 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
def __init__(self, name, topology, data,
kind=None, directions=None,
ghosts=None, ghost_op=None, ghost_mask=None,
- exchange_method=None):
+ exchange_method=None, global_lboundaries_config=None, global_rboundaries_config=None):
"""
By default, we exchange all ghosts, including diagonals.
This is done by setting ghost_mask to GhostMask.FULL.
-
+
Just Cartesian Communicator neighbours are
considered here (there is no direct communication
between diagonal processes).
@@ -220,8 +243,8 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
Diagonal ghosts are exchanged by chaining exchanges on two
or more axes.
-
- If ghost_mask is set to GhostMask.CROSS, diagonal ghosts
+
+ If ghost_mask is set to GhostMask.CROSS, diagonal ghosts
are set to NAN to ensure they are not used.
Boundary conditions are hidden in the topology parameter:
@@ -231,6 +254,9 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
ghost accumulation is a noop
Here XXX and YYY are either HOMOGENEOUS_DIRICHLET or HOMOGENEOUS_NEUMANN.
"""
+ gprint('CartesianGhostExchanger.__init__(name={}, \n topology={}, kind={}, directions={}, ghosts={}, exchange_method={}, ghost_op={}, ghost_mask={}]'.format(
+ name, topology.full_tag, kind, directions, ghosts, exchange_method, ghost_op, ghost_mask))
+
ghost_op = first_not_None(ghost_op, GhostOperation.EXCHANGE)
check_instance(ghost_op, GhostOperation)
@@ -240,9 +266,9 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
exchange_method = first_not_None(exchange_method,
ExchangeMethod.NEIGHBOR_ALL_TO_ALL_V)
check_instance(exchange_method, ExchangeMethod)
-
+
super(CartesianDiscreteFieldGhostExchanger, self).__init__(topology=topology,
- data=data, name=name, exchange_method=exchange_method,
+ data=data, name=name, exchange_method=exchange_method,
ghost_op=ghost_op, ghost_mask=ghost_mask)
mesh = self.mesh
@@ -255,15 +281,16 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
check_instance(directions, tuple, values=int)
check_instance(ghosts, tuple, values=int, minval=0)
+ assert len(directions)>0
assert len(set(directions)) == len(directions)
assert len(set(id(d) for d in data)) == len(data)
assert all(0<=d<dim for d in directions)
assert len(ghosts)==dim or len(ghosts)==1
if len(ghosts)==1:
- ghosts*=dim
+ ghosts = tuple(ghosts[0] if (i in directions) else 0 for i in xrange(dim))
- self.directions = directions
- self.outer_ghosts = mesh.get_local_outer_ghost_slices(ghosts=ghosts,
+ self.directions = directions
+ self.outer_ghosts = mesh.get_local_outer_ghost_slices(ghosts=ghosts,
ghost_mask=ghost_mask)
self.inner_ghosts = mesh.get_local_inner_ghost_slices(ghosts=ghosts,
ghost_mask=ghost_mask)
@@ -271,8 +298,18 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
ghost_mask=ghost_mask)
self.all_inner_ghost_slices = mesh.get_all_local_inner_ghost_slices(ghosts=ghosts)
self.all_outer_ghost_slices = mesh.get_all_local_outer_ghost_slices(ghosts=ghosts)
- self.dim = dim
- self.ghosts = ghosts
+ self.dim = dim
+ self.ghosts = ghosts
+
+ # check that enforced boundaries kind matches topology boundaries
+ if (global_lboundaries_config is not None):
+ global_lboundaries = np.asarray(map(lambda x: x.bc, global_lboundaries_config))
+ assert (global_lboundaries == mesh.global_lboundaries).all(), (global_lboundaries, mesh.global_lboundaries)
+ if (global_rboundaries_config is not None):
+ global_rboundaries = np.asarray(map(lambda x: x.bc, global_rboundaries_config))
+ assert (global_rboundaries == mesh.global_rboundaries).all(), (global_rboundaries, mesh.global_rboundaries)
+ self.global_lboundaries_config = global_lboundaries_config
+ self.global_rboundaries_config = global_rboundaries_config
kind = first_not_None(kind, topology.backend.kind)
if (kind == Backend.HOST):
@@ -288,6 +325,36 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
self._launcher = None
+ def fmt_slices(slices, prefix='\n '):
+ s=''
+ for i, (lslcs,rslcs,shape) in enumerate(slices):
+ s+='{}direction {} || LEFT: {} || RIGHT: {} || SHAPE: {}'.format(prefix, i, lslcs, rslcs, shape)
+ return s
+
+ msg=\
+'''
+ TOPOLOGY INFO:
+ dim: {}
+ topology.shape: {}
+ topology.coords: {}
+ topology.lboundary: {}
+ topology.rboundary: {}
+ EXCHANGE INFO
+ kind: {}
+ directions: {}
+ ghosts: {}
+ outer_ghosts: {}
+ inner_ghosts: {}
+ boundary_layers: {}
+ global lboundaries: {}
+ global rboundaries: {}
+'''.format(self.dim, topology.proc_shape, topology.proc_coords,
+ mesh.is_at_left_boundary, mesh.is_at_right_boundary,
+ self.kind, self.directions, self.ghosts,
+ fmt_slices(self.outer_ghosts), fmt_slices(self.inner_ghosts),
+ self.boundary_layers, global_lboundaries_config, global_rboundaries_config)
+ gprint(msg)
+
def exchange_ghosts(self, **kwds):
"""Exchange ghosts on specified data."""
if (self._launcher is None):
@@ -352,13 +419,27 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
def setup(self):
local_symmetries = []
for ls in self.local_symmetries:
- (buf, slices, shape, d, to_left, bc) = ls
+ (buf, slices, shape, d, to_left, boundary) = ls
+ bc = boundary.bc
if (bc is BoundaryCondition.HOMOGENEOUS_DIRICHLET):
- fn = LocalBoundaryExchanger.build_antisymmetric_exchanger(
- shape=shape, direction=d, to_left=to_left)
+ if isinstance(boundary, BoundaryConditionConfig) and (boundary.data is not None):
+ msg='Boundary of type HOMOGENEOUS_DIRICHLET does not handle custom boundary data, got {}.'
+ raise RuntimeError(msg, type(boundary.data).__name__)
+ else:
+ fn = LocalBoundaryExchanger.build_antisymmetric_exchanger(
+ shape=shape, direction=d, to_left=to_left)
elif (bc is BoundaryCondition.HOMOGENEOUS_NEUMANN):
- fn = LocalBoundaryExchanger.build_symmetric_exchanger(
- shape=shape, direction=d, to_left=to_left)
+ if isinstance(boundary, BoundaryConditionConfig) and (boundary.data is not None):
+ # allow to force boundary ghosts to a specific scalar value
+ if isinstance(boundary.data, (int,long,float,np.number)):
+ fn = LocalBoundaryExchanger.build_scalar_exchanger(value=boundary.data,
+ shape=shape, direction=d, to_left=to_left)
+ else:
+ msg='Boundary of type HOMOGENEOUS_NEUMANN only handle custom scalar boundary data, got {}.'
+ raise RuntimeError(msg, type(boundary.data).__name__)
+ else:
+ fn = LocalBoundaryExchanger.build_symmetric_exchanger(
+ shape=shape, direction=d, to_left=to_left)
else:
msg='Unknown boundary condition {}.'.format(bc)
local_symmetries.append((fn, buf, slices, shape, d, to_left, bc))
@@ -373,7 +454,6 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
tag += (d + 1) * 97
tag += (direction+1)*17
return tag
-
dim = self.dim
ghosts = self.ghosts
ghost_op = self.ghost_op
@@ -384,12 +464,14 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
base_dtype = self.base_dtype
base_mpi_type = self.base_mpi_type
exchange_method = self.exchange_method
-
+ global_lboundaries_config = self.global_lboundaries_config
+ global_rboundaries_config = self.global_rboundaries_config
+
mesh = self.topology.mesh
is_at_left_boundary = mesh.is_at_left_boundary
is_at_right_boundary = mesh.is_at_right_boundary
- left_boundaries = mesh.local_lboundaries
- right_boundaries = mesh.local_rboundaries
+ left_boundaries_kind = mesh.local_lboundaries
+ right_boundaries_kind = mesh.local_rboundaries
src_data_on_device = (self.kind is not Backend.HOST)
dst_data_on_device = (self.kind is not Backend.HOST)
@@ -397,6 +479,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
all_outer_ghost_slices = self.all_outer_ghost_slices
lp = _LauncherParameters()
+ assert self.data
for (i,buf) in enumerate(self.data):
lp.w_send_requests = {}
lp.w_recv_requests = {}
@@ -413,13 +496,15 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
slc, shape = all_outer_ghost_slices[dim][directions][displacements]
value = default_invalid_value(dtype=base_dtype)
lp.diagonal_ghosts.append((buf,slc,shape,value))
-
+
+ assert self.directions
+ assert any(ghosts[d]>0 for d in self.directions)
for d in self.directions:
if ghosts[d]==0:
continue
- lboundary = left_boundaries[d]
- rboundary = right_boundaries[d]
+ lboundary = left_boundaries_kind[d]
+ rboundary = right_boundaries_kind[d]
at_left = is_at_left_boundary[d]
at_right = is_at_right_boundary[d]
lnone = (lboundary is BoundaryCondition.NONE)
@@ -437,7 +522,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
left_boundary_layer, right_boundary_layer, bl_shape = self.boundary_layers[d]
assert (left_boundary_layer is None) ^ (at_left and not lperiodic)
assert (right_boundary_layer is None) ^ (at_right and not rperiodic)
-
+
left_rank = neighbour_ranks[0,d]
right_rank = neighbour_ranks[1,d]
@@ -445,10 +530,38 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.has_mpi_exchanges |= (nprocs > 1)
assert (nprocs==1) or should_exchange_to_left or should_exchange_to_right
+ msg=\
+''' DATA {} EXCHANGES FOR DIRECTION {}:
+ nprocs (directional procs): {}
+ src_data_on_device: {}
+ dst_data_on_device: {}
+ local_rank: {}
+ left_rank / right_rank: {} / {}
+ at_left / at_right: {} / {}
+ lboundary / rboundary: {} / {}
+ xchg_to_left / xchg_to_right: {} / {}
+ inner_left / inner_right: {} / {}
+ outer_left / outer_right: {} / {}
+ associated_shape: {}
+ left_blayer / right_blayer: {} / {}
+ boundary_layer_shape: {}
+ Send/Receive:'''.format(i, d, nprocs,
+ src_data_on_device, dst_data_on_device,
+ local_rank, left_rank, right_rank,
+ at_left, at_right, lboundary, rboundary,
+ should_exchange_to_left, should_exchange_to_right,
+ inner_left, inner_right, outer_left, outer_right, shape,
+ left_boundary_layer, right_boundary_layer, bl_shape)
+ gprint(msg)
+
if not should_exchange_to_left:
- lp.local_symmetries.append((buf, left_boundary_layer, bl_shape, d, 1, lboundary))
+ glboundary = global_lboundaries_config[d] if (global_lboundaries_config is not None) else lboundary
+ assert glboundary.bc is lboundary
+ lp.local_symmetries.append((buf, left_boundary_layer, bl_shape, d, 1, glboundary))
if not should_exchange_to_right:
- lp.local_symmetries.append((buf, right_boundary_layer, bl_shape, d, 0, rboundary))
+ grboundary = global_rboundaries_config[d] if (global_rboundaries_config is not None) else rboundary
+ assert grboundary.bc is rboundary
+ lp.local_symmetries.append((buf, right_boundary_layer, bl_shape, d, 0, grboundary))
if (nprocs == 1):
# We need to exchange with ourselves (by periodicity)
@@ -458,6 +571,8 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
if should_exchange:
lp.local_exchanges.append((buf,outer_right,inner_left,shape,d))
lp.local_exchanges.append((buf,outer_left,inner_right,shape,d))
+ lp.from_buffer = first_not_None(lp.from_buffer, False)
+ lp.to_buffer = first_not_None(lp.to_buffer, False)
elif (ghost_op is GhostOperation.EXCHANGE):
# SEND DIRECTION IS
# INNER GHOSTS ---> OUTER GHOSTS
@@ -513,13 +628,16 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.i_src_buffers += ((tmp,buf,inner_left),)
else:
send_buf = buf.handle
- mpi_type = TopoTools.create_subarray(inner_left, buf.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(send_buf, inner_left)
send_kwds = {'buf':[send_buf, mpi_type],
'dest':left_rank,
'tag':sendtag}
lp.isend_kwds.append(send_kwds)
+ msg='\t\t>P{}.ISend(shape={}, dtype={}, tag={}) inner left data to left neighbour process P{}.'
+ msg=msg.format(local_rank, shape, buf.dtype, sendtag, left_rank)
+ gprint(msg)
+
# receive outer right from left rank
recvtag = msg_tag(i, left_rank, local_rank, d, 1)
if dst_data_on_device:
@@ -530,13 +648,16 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.i_dst_buffers += ((tmp,buf,outer_left),)
else:
recv_buf = buf.handle
- mpi_type = TopoTools.create_subarray(outer_left, buf.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(recv_buf, outer_left)
recv_kwds = {'buf':[recv_buf, mpi_type],
'source':left_rank,
'tag':recvtag}
lp.irecv_kwds.append(recv_kwds)
-
+
+ msg='\t\t>P{}.IRecv(shape={}, dtype={}, tag={}) outer left data from left neighbour process P{}.'
+ msg=msg.format(local_rank, shape, buf.dtype, recvtag, left_rank)
+ gprint(msg)
+
if should_exchange_to_right:
# Exchanges with right neighour
assert (right_rank != local_rank) and (right_rank != -1)
@@ -551,12 +672,15 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.i_src_buffers += ((tmp,buf,inner_right),)
else:
send_buf = buf.handle
- mpi_type = TopoTools.create_subarray(inner_right, buf.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(send_buf, inner_right)
send_kwds = {'buf':[send_buf, mpi_type],
'dest':right_rank,
'tag':sendtag}
lp.isend_kwds.append(send_kwds)
+
+ msg='\t\t>P{}.ISend(shape={}, dtype={}, tag={}) inner right data to right neighbour process P{}.'
+ msg=msg.format(local_rank, shape, buf.dtype, sendtag, right_rank)
+ gprint(msg)
# receive outer left from right rank
recvtag = msg_tag(i, right_rank, local_rank, d, 0)
@@ -568,12 +692,16 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.i_dst_buffers += ((tmp,buf,outer_right),)
else:
recv_buf = buf.handle
- mpi_type = TopoTools.create_subarray(outer_right, buf.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(recv_buf, outer_right)
recv_kwds = {'buf':[recv_buf, mpi_type],
'source':right_rank,
'tag':recvtag}
lp.irecv_kwds.append(recv_kwds)
+
+ msg='\t\t>P{}.IRecv(shape={}, dtype={}, tag={}) outer right data from right neighbour process P{}.'
+ msg=msg.format(local_rank, shape, buf.dtype, recvtag, right_rank)
+ gprint(msg)
+
lp.from_buffer = src_data_on_device
lp.to_buffer = dst_data_on_device
else:
@@ -643,23 +771,29 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.i_src_buffers += ((tmp,buf,outer_left),)
else:
send_buf = buf.handle
- mpi_type = TopoTools.create_subarray(outer_left, buf.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(send_buf, outer_left)
+ assert all(send_buf[outer_left].shape==shape)
send_kwds = {'buf':[send_buf, mpi_type],
'dest':left_rank,
'tag':sendtag}
lp.isend_kwds.append(send_kwds)
+ msg='\t\t>P{}.ISend(shape={}, dtype={}, tag={}) outer left data to left neighbour process P{}.'
+ msg=msg.format(local_rank, shape, send_buf.dtype, sendtag, left_rank)
+ gprint(msg)
# receive outer right ghosts data from left rank in a tmp buffer
recvtag = msg_tag(i, left_rank, local_rank, d, 1)
mpi_type = base_mpi_type.Create_contiguous(buf[inner_left].size)
mpi_type.Commit()
- tmp = self.host_backend.empty(shape=shape, dtype=base_dtype)
+ tmp = self.host_backend.empty_like(send_buf, shape=shape, dtype=base_dtype)
recv_kwds = {'buf':[tmp.handle, mpi_type],
'source':left_rank,
'tag':recvtag}
lp.irecv_kwds.append(recv_kwds)
lp.i_dst_buffers.append((tmp, buf, inner_left))
+ msg='\t\t>P{}.IRecv(shape={}, dtype={}, tag={}) inner left data from left neighbour process P{}.'
+ msg=msg.format(local_rank, shape, tmp.dtype, recvtag, left_rank)
+ gprint(msg)
if should_exchange_to_right:
# Exchanges with right neighour
@@ -676,12 +810,15 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp.i_src_buffers += ((tmp,buf,outer_right),)
else:
send_buf = buf.handle
- mpi_type = TopoTools.create_subarray(outer_right, buf.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(send_buf, outer_right)
+ assert all(send_buf[outer_right].shape==shape)
send_kwds = {'buf':[send_buf, mpi_type],
'dest':right_rank,
'tag':sendtag}
lp.isend_kwds.append(send_kwds)
+ msg='\t\t>P{}.ISend(shape={}, dtype={}, tag={}) outer right data to right neighbour process P{}.'
+ msg=msg.format(local_rank, shape, send_buf.dtype, sendtag, right_rank)
+ gprint(msg)
# receive outer left ghosts data from right rank in a tmp buffer
recvtag = msg_tag(i, right_rank, local_rank, d, 0)
@@ -693,7 +830,10 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
'tag':recvtag}
lp.irecv_kwds.append(recv_kwds)
lp.i_dst_buffers.append((tmp, buf, inner_right))
-
+ msg='\t\t>P{}.IRecv(shape={}, dtype={}, tag={}) inner right data from right neighbour process P{}.'
+ msg=msg.format(local_rank, shape, tmp.dtype, recvtag, right_rank)
+ gprint(msg)
+
lp.from_buffer = src_data_on_device
lp.to_buffer = True
else:
@@ -702,6 +842,11 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
else:
msg='Unknown GhostOperation {}.'.format(ghost_op)
raise NotImplementedError(msg)
+
+ msg='Something went wrong while initializing LauncherParameters::{}::{}, got value {{}}.'
+ msg=msg.format(ghost_op, exchange_method)
+ assert (lp.from_buffer is not None), msg.format(lp.from_buffer)
+ assert (lp.to_buffer is not None), msg.format(lp.to_buffer)
# handle all_to_all_w kwds (one call for all neighbours per buffer)
if (exchange_method is ExchangeMethod.NEIGHBOR_ALL_TO_ALL_W):
@@ -728,8 +873,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
vslc = slice(scount, scount+send_count)
src_buffers += ((src[slc],vslc),)
else:
- mpi_type = TopoTools.create_subarray(slc, src.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(src, slc)
send_count = 1
else:
mpi_type = base_mpi_type
@@ -754,8 +898,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
vslc = slice(rcount, rcount+recv_count)
dst_buffers += ((dst[slc],vslc),)
else:
- mpi_type = TopoTools.create_subarray(slc, dst.shape,
- mpi_type=base_mpi_type)
+ mpi_type = TopoTools.create_subarray_from_buffer(dst, slc)
recv_count = 1
else:
mpi_type = base_mpi_type
@@ -850,19 +993,22 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
lp = self._prepare_launcher()
if (ghost_op is GhostOperation.EXCHANGE):
- def local_exchanges():
+ def local_exchanges(lp=lp):
for (fn, buf, slices, _, _, _, _) in lp.local_symmetries:
+ gprint(' local_symmetry')
fn(buf[slices])
for (buf,outer,inner,shape,direction) in lp.local_exchanges:
+ gprint(' local_exchange')
buf[outer] = buf[inner]
for (buf,slc,shape,val) in lp.diagonal_ghosts:
+ gprint(' diagonal ghosts')
buf[slc] = val
if lp.has_mpi_exchanges:
if exchange_method is ExchangeMethod.NEIGHBOR_ALL_TO_ALL_W:
assert len(lp.w_kwds)>0
assert (lp.from_buffer is False)
assert (lp.to_buffer is False)
- def python_launcher():
+ def python_launcher(lp=lp):
evts = []
for kwds in lp.w_kwds:
evt = comm.Ineighbor_alltoallw(**kwds)
@@ -871,9 +1017,9 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
MPI.Request.Waitall(evts)
elif exchange_method is ExchangeMethod.NEIGHBOR_ALL_TO_ALL_V:
assert lp.v_kwds
- assert (lp.from_buffer is True)
- assert (lp.to_buffer is True)
- def python_launcher():
+ assert (lp.from_buffer is True), lp.from_buffer
+ assert (lp.to_buffer is True), lp.to_buffer
+ def python_launcher(lp=lp):
for (src,slc) in lp.v_src_buffers:
lp.v_send_buffer[slc] = src.ravel()
evt = comm.Ineighbor_alltoallv(**lp.v_kwds)
@@ -886,12 +1032,14 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
assert lp.isend_kwds
assert (lp.from_buffer is False)
assert (lp.to_buffer is False)
- def python_launcher():
+ def python_launcher(lp=lp):
evts = []
for recv_kwds in lp.irecv_kwds:
+ gprint(' Irecv(source={}, tag={})'.format(recv_kwds['source'], recv_kwds['tag']))
evt = comm.Irecv(**recv_kwds)
evts.append(evt)
for send_kwds in lp.isend_kwds:
+ gprint(' Isend(dest={}, tag={})'.format(send_kwds['dest'], send_kwds['tag']))
evt = comm.Isend(**send_kwds)
evts.append(evt)
local_exchanges()
@@ -900,10 +1048,9 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
msg='Unknown MPI exchange method {}.'.format(exchange_method)
raise NotImplementedError(msg)
else:
- def python_launcher():
- local_exchanges()
+ python_launcher = local_exchanges
elif ghost_op is GhostOperation.ACCUMULATE:
- def local_exchanges():
+ def local_exchanges(lp=lp):
for (buf,outer,inner,shape,direction) in lp.local_exchanges:
buf[inner] += buf[outer]
if lp.has_mpi_exchanges:
@@ -911,7 +1058,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
assert len(lp.w_kwds)>0
assert (lp.from_buffer is False)
assert (lp.to_buffer is True)
- def python_launcher():
+ def python_launcher(lp=lp):
evts = []
for (kwds,send_buffer,src_buffers) in \
zip(lp.w_kwds, lp.w_send_buffer, lp.w_src_buffers):
@@ -927,7 +1074,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
assert lp.v_kwds
assert (lp.from_buffer is True)
assert (lp.to_buffer is True)
- def python_launcher():
+ def python_launcher(lp=lp):
for (src,slc) in lp.v_src_buffers:
lp.v_send_buffer[slc] = src.ravel()
evt = comm.Ineighbor_alltoallv(**lp.v_kwds)
@@ -939,26 +1086,32 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
assert (lp.from_buffer is False)
assert (lp.to_buffer is True)
assert len(lp.irecv_kwds)==len(lp.isend_kwds)>0
- def python_launcher():
+ def python_launcher(lp=lp):
send_evts = []
recv_evts = []
for recv_kwds in lp.irecv_kwds:
+ gprint(' Irecv(source={}, tag={})'.format(recv_kwds['source'], recv_kwds['tag']))
+ gprint_buffer(' >receiving', recv_kwds['buf'], no_data=True)
evt = comm.Irecv(**recv_kwds)
recv_evts.append(evt)
for send_kwds in lp.isend_kwds:
+ gprint(' Isend(dest={}, tag={})'.format(send_kwds['dest'], send_kwds['tag']))
+ gprint_buffer(' >sending', send_kwds['buf'])
evt = comm.Isend(**send_kwds)
send_evts.append(evt)
local_exchanges()
for idx in iter_mpi_requests(recv_evts):
(tmp, buf, inner) = lp.i_dst_buffers[idx]
+ gprint_buffer(' Received', tmp)
+ gprint_buffer(' Summing to', buf[inner])
buf[inner] += tmp
+ gprint_buffer(' Result is', buf[inner])
MPI.Request.Waitall(send_evts)
else:
msg='Unknown MPI exchange method {}.'.format(exchange_method)
raise NotImplementedError(msg)
else:
- def python_launcher():
- local_exchanges()
+ python_launcher = local_exchanges
else:
msg='Unknown GhostOperation {}.'.format(ghost_op)
raise NotImplementedError(msg)
@@ -979,7 +1132,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
def __call__(self, *args, **kwds):
super(FunctionLauncher, self).__call__()
return self._fn(*args, **kwds)
-
+
class MPIGhostExchangeLauncher(FunctionLauncher):
def __init__(self, fn):
super(MPIGhostExchangeLauncher, self).__init__(name='MPI_Ghost_Exchange_Launcher', fn=fn)
@@ -1013,17 +1166,17 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
for (fn, buf, slices, shape, direction, to_left, bc) in lp.local_symmetries:
# SYMMETRIC OR ANTISYMMETRIC LOCAL EXCHANGE
dirlabel = DirectionLabels[dim-direction-1]
- vname = '{}_{}_{}_{}'.format(self.name,
+ vname = '{}_{}_{}_{}'.format(self.name,
dirlabel,
- 'left' if to_left else 'right',
- str(bc).lower())
+ 'left' if to_left else 'right',
+ str(bc.bc).lower())
tmp = mk_tmp(shape=shape, dtype=base_dtype, host=True)
-
+
k0 = OpenClCopyBufferRectLauncher.from_slices(
varname=vname+'_boundary_layer',
src=buf, src_slices=slices, dst=tmp)
-
+
k1 = OpenClCopyBufferRectLauncher.from_slices(
varname=vname+'_boundary_layer',
src=tmp, dst=buf, dst_slices=slices)
@@ -1042,7 +1195,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
dirlabel = DirectionLabels[dim-direction-1]
vname = '{}_{}_{}'.format(self.name, i, dirlabel)
- # some opencl platforms reject inplace buffer copies
+ # some opencl platforms reject inplace buffer copies
# so we use a tmp buffer to perform local ghost exchanges
tmp = mk_tmp(shape=shape, dtype=base_dtype)
@@ -1061,7 +1214,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
local_kl += OpenClCopyBufferRectLauncher.from_slices(
varname=vname, src=tmp, dst=buf, dst_slices=slc)
- kl = OpenClKernelListLauncher(name='exchange_ghosts_{}'.format(self.name))
+ kl = OpenClKernelListLauncher(name='exchange_ghosts_{}'.format(self.name))
if lp.has_mpi_exchanges:
assert (lp.from_buffer is True)
assert (lp.to_buffer is True)
@@ -1209,7 +1362,7 @@ class CartesianDiscreteFieldGhostExchanger(GhostExchanger):
varname=vname+'_accumulation_to_inner',
src=ltmp, dst=buf, dst_slices=inner_slc)
- kl = OpenClKernelListLauncher(name='accumulate_ghosts_{}'.format(self.name))
+ kl = OpenClKernelListLauncher(name='accumulate_ghosts_{}'.format(self.name))
if lp.has_mpi_exchanges:
if exchange_method is ExchangeMethod.NEIGHBOR_ALL_TO_ALL_W:
assert len(lp.w_kwds)>0
diff --git a/hysop/fields/tests/test_cartesian.py b/hysop/fields/tests/test_cartesian.py
index 499b37484ce0bd0b85e7000a9a41528473d6e7c2..43a947fd7c8c49fe8e4cdc6e6298ccbe1b64e1b8 100644
--- a/hysop/fields/tests/test_cartesian.py
+++ b/hysop/fields/tests/test_cartesian.py
@@ -12,27 +12,23 @@ from hysop.topology.cartesian_topology import CartesianTopology, CartesianTopolo
from hysop.testsenv import iter_clenv, test_context, domain_boundary_iterator
from hysop.tools.numerics import is_fp, is_integer
-def __random_init(data, coords):
- shape = data[0].shape
- dtype = data[0].dtype
+def __random_init(data, coords, component):
+ shape = data.shape
+ dtype = data.dtype
if is_integer(dtype):
- for d in data:
- d[...] = npw.random.random_integers(low=0, high=255, size=shape)
+ data[...] = npw.random.random_integers(low=0, high=255, size=shape)
elif is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape)
+ data[...] = npw.random.random(size=shape)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
-def __zero_init(data, coords):
- for d in data:
- d[...] = 0
+def __zero_init(data, coords, component):
+ data[...] = 0
def __cst_init(cst):
- def __init(data,coords):
- for d in data:
- d[...] = cst
+ def __init(data,coords,component):
+ data[...] = cst
return __init
def test_serial_initialization_1d():
@@ -501,7 +497,7 @@ def test_mpi_ghost_exchange_periodic(comm=None):
print msg
print '*'*len(msg)
print 'test_mpi_ghost_exchange_periodic()'.format(size)
- for dim in xrange(1,2+__ENABLE_LONG_TESTS__):
+ for dim in xrange(1,3+__ENABLE_LONG_TESTS__):
if rank==0:
print(' >DIM={}'.format(dim))
@@ -614,7 +610,7 @@ def test_mpi_ghost_exchange_runtime(comm=None):
print '*'*len(msg)
print 'test_mpi_ghost_exchange_runtime()'.format(size)
- for dim in xrange(1,2+__ENABLE_LONG_TESTS__):
+ for dim in xrange(1,3+__ENABLE_LONG_TESTS__):
if rank==0:
sys.stdout.write('>DIM={}\n'.format(dim))
@@ -698,7 +694,7 @@ def test_mpi_ghost_accumulate_periodic(comm=None):
np.int16, np.int32, np.int64,
np.uint16, np.uint32, np.uint64)
assert size-1 < len(dtypes)
- for dim in xrange(1,2+__ENABLE_LONG_TESTS__):
+ for dim in xrange(1,3+__ENABLE_LONG_TESTS__):
if rank==0:
print(' >DIM={}'.format(dim))
@@ -765,7 +761,7 @@ def test_mpi_ghost_accumulate_periodic(comm=None):
# test one direction at a time
max_displacements = 1
- for ndirections in xrange(0,dim+1):
+ for ndirections in xrange(1,dim+1):
all_displacements = tuple(it.product((-1,0,+1), repeat=ndirections))
all_directions = tuple(it.combinations(range(dim), ndirections))
masks = tuple(it.product((0,1), repeat=ndirections))
diff --git a/hysop/fields/tests/test_cartesian.sh b/hysop/fields/tests/test_cartesian.sh
index a2d07fa443880376327908629c58f0caf7d94c6b..f73967d46af4fe6601d2b2e1ffda51363cdd7d71 100755
--- a/hysop/fields/tests/test_cartesian.sh
+++ b/hysop/fields/tests/test_cartesian.sh
@@ -1,25 +1,13 @@
#!/usr/bin/env bash
+set -feu -o pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+TEST_FILE=${SCRIPT_DIR}/test_cartesian.py
export HYSOP_VERBOSE=0
export HYSOP_DEBUG=0
export KERNEL_DEBUG=0
-set -e
-
-pushd . > /dev/null
-SCRIPT_PATH="${BASH_SOURCE[0]}"
-if [ -h "${SCRIPT_PATH}" ]; then
- while [ -h "${SCRIPT_PATH}" ];
- do cd $(dirname "$SCRIPT_PATH");
- SCRIPT_PATH=$(readlink "${SCRIPT_PATH}");
- done
-fi
-cd $(dirname ${SCRIPT_PATH}) > /dev/null
-SCRIPT_PATH=$(pwd)
-popd > /dev/null
-
-TEST_FILE=$SCRIPT_PATH/test_cartesian.py
-
for i in 2; do
- mpirun --allow-run-as-root --oversubscribe -np $i python2 $TEST_FILE
+ mpirun -np $i --allow-run-as-root python2.7 ${TEST_FILE}
done
diff --git a/hysop/fields/tests/test_fields.py b/hysop/fields/tests/test_fields.py
index e4bb0f94d412a516a24cf319c9a5519773e19b5f..76ad49e456743df0f228c9681a18b5b4f4dfcbcb 100644
--- a/hysop/fields/tests/test_fields.py
+++ b/hysop/fields/tests/test_fields.py
@@ -2,16 +2,17 @@ import numpy as np
from hysop import Box, CartesianTopology, CartesianDiscretization
from hysop.constants import HYSOP_REAL
-from hysop.fields.continuous_field import Field, ScalarField,TensorField
+from hysop.fields.continuous_field import Field, ScalarField, TensorField
from hysop.fields.discrete_field import DiscreteField, \
- DiscreteTensorField, \
- DiscreteScalarFieldView
+ DiscreteTensorField, \
+ DiscreteScalarFieldView
from hysop.fields.cartesian_discrete_field import CartesianDiscreteField, \
- CartesianDiscreteScalarFieldView
+ CartesianDiscreteScalarFieldView
from hysop.defaults import VelocityField, VorticityField
from hysop.tools.types import check_instance
from hysop.testsenv import domain_boundary_iterator
+
def test_field():
domain = Box(dim=3)
F0 = Field(domain, 'F0')
@@ -23,7 +24,7 @@ def test_field():
F6 = F0.gradient()
F7 = F5.field_like('F7')
- D0 = CartesianDiscretization(resolution=(5,5,5), default_boundaries=True)
+ D0 = CartesianDiscretization(resolution=(5, 5, 5), default_boundaries=True)
T0 = CartesianTopology(domain=domain, discretization=D0)
DF0 = F0.discretize(T0)
@@ -35,10 +36,10 @@ def test_field():
DF6 = F6.discretize(T0)
DF7 = F7.discretize(T0)
- requests = DF5._dfield.memory_request(op=DF5.name,
- request_identifier=DF5.memory_request_id)
+ requests = DF5._dfield.memory_request(op=DF5.name,
+ request_identifier=DF5.memory_request_id)
requests += DF7._dfield.memory_request(op=DF7.name,
- request_identifier=DF7.memory_request_id)
+ request_identifier=DF7.memory_request_id)
work = requests.allocate(True)
DF5.honor_memory_request(work)
DF7.honor_memory_request(work)
@@ -90,10 +91,9 @@ def test_field():
assert F4.name == 'F4'
assert F4.pretty_name == 'F4'
- def func(data, coords):
- for (d, coord) in zip(data, coords):
- x,y,z = coord
- d[...] = x*y*z
+ def func(data, coords, component):
+ (x, y, z) = coords
+ data[...] = x*y*z
DF7.initialize(func)
DF7.initialize(DF5.data)
@@ -106,7 +106,10 @@ def test_field():
DF7.exchange_ghosts()
DF7.accumulate_ghosts()
exchanger = DF7.build_ghost_exchanger()
- exchanger()
+ try:
+ exchanger()
+ except TypeError:
+ assert exchanger is None
DF7.match(DF5)
DF7 == DF5
@@ -118,16 +121,17 @@ def test_field():
DF7.long_description()
str(DF7)
+
def test_tensor_field():
domain = Box(dim=3)
- T0 = TensorField(domain, 'T0', (3,3))
- T0_bis = Field(domain, 'T0b', shape=(3,3))
+ T0 = TensorField(domain, 'T0', (3, 3))
+ T0_bis = Field(domain, 'T0b', shape=(3, 3))
T1 = T0.field_like('T1', dtype=np.float16)
- T2 = T0[1:,1:]
+ T2 = T0[1:, 1:]
T2.rename(name='T2')
- T3 = T0[1,1]
+ T3 = T0[1, 1]
T4 = TensorField.from_fields(name='T4',
- fields=(T0[0,0], T0[1,1], T1[0,1], T1[1,0]), shape=(2,2))
+ fields=(T0[0, 0], T0[1, 1], T1[0, 1], T1[1, 0]), shape=(2, 2))
T5 = TensorField.from_field_array('T5', T0._fields)
T6 = T5.field_like(name='T6')
T7 = T6.field_like(name='T7', is_tmp=True)
@@ -146,28 +150,28 @@ def test_tensor_field():
assert T4.name == 'T4'
assert T5.name == 'T5'
assert T6.name == 'T6'
- assert np.array_equal(T0.shape, (3,3))
- assert np.array_equal(T1.shape, (3,3))
+ assert np.array_equal(T0.shape, (3, 3))
+ assert np.array_equal(T1.shape, (3, 3))
for (idx, t0) in T0.nd_iter():
t1 = T1[idx]
assert t0.domain is domain
assert t1.domain is domain
assert t1.dtype != t0.dtype
- assert t1.name.replace('1','0', 1) == t0.name
- assert t1.pretty_name.replace('1','0', 1) == t0.pretty_name
+ assert t1.name.replace('1', '0', 1) == t0.name
+ assert t1.pretty_name.replace('1', '0', 1) == t0.pretty_name
assert t0.dim is 3
assert t1.dim is 3
- assert np.array_equal(T0._fields[1:,1:], T2._fields)
- assert T0._fields[1,1] is T3
- assert T0._fields[0,0] is T4[0,0]
- assert T0._fields[1,1] is T4[0,1]
- assert T1._fields[0,1] is T4[1,0]
- assert T1._fields[1,0] is T4[1,1]
+ assert np.array_equal(T0._fields[1:, 1:], T2._fields)
+ assert T0._fields[1, 1] is T3
+ assert T0._fields[0, 0] is T4[0, 0]
+ assert T0._fields[1, 1] is T4[0, 1]
+ assert T1._fields[0, 1] is T4[1, 0]
+ assert T1._fields[1, 0] is T4[1, 1]
assert np.array_equal(T0._fields, T5._fields)
for f in T0:
assert f in T0
- D0 = CartesianDiscretization(resolution=(5,5,5), default_boundaries=True)
+ D0 = CartesianDiscretization(resolution=(5, 5, 5), default_boundaries=True)
topo = CartesianTopology(domain=domain, discretization=D0)
DT0 = T0.discretize(topo)
@@ -180,16 +184,31 @@ def test_tensor_field():
DT7 = T7.discretize(topo)
DT8 = DiscreteTensorField.from_dfields(name='DT8',
- dfields=(DT0.dfields[0],
- DT1.dfields[0],
- DT2.dfields[0],
- DT3.dfields[0]),
- shape=(2,2))
- DT9 = DT0[:2,:2]
+ dfields=(DT0.dfields[0],
+ DT1.dfields[0],
+ DT2.dfields[0],
+ DT3.dfields[0]),
+ shape=(2, 2))
+ DT9 = DT0[:2, :2]
DT10 = DT9.clone()
- DT11, requests = DT10.tmp_dfield_like(name='DT11')
- work = requests().allocate(True)
+ DT11, requests11 = DT10.tmp_dfield_like(name='DT11')
+ DT12, requests12 = DT10.tmp_dfield_like(name='DT11')
+
+ work = requests11().allocate(True)
DT11.honor_memory_request(work)
+
+ work = requests12().allocate(True)
+ DT12.honor_memory_request(work)
+
+ for df in DT11.data:
+ df[...] = 11
+ for df in DT12.data:
+ df[...] = 12
+ for df in DT11.data:
+ assert np.all(df == 11)
+ for df in DT12.data:
+ assert np.all(df == 12)
+
str(DT0)
DT0.short_description()
@@ -197,23 +216,25 @@ def test_tensor_field():
for df in DT0:
assert df in DT0
- def func(data, coords):
- for (d, coord) in zip(data, coords):
- x,y,z = coord
- d[...] = x*y*z
+ def func(data, coords, component):
+ (x, y, z) = coords
+ data[...] = x*y*z
DT9.rename('foo')
DT9.initialize(func)
DT9.initialize(DT10.data)
DT9.fill(4)
DT9.randomize()
- DT9.copy(DT0[1:,1:])
+ DT9.copy(DT0[1:, 1:])
DT9.has_ghosts()
DT9.exchange_ghosts()
DT9.accumulate_ghosts()
exchanger = DT9.build_ghost_exchanger()
- exchanger()
+ try:
+ exchanger()
+ except TypeError:
+ assert exchanger is None
DT9.match(DT10)
DT9 == DT10
@@ -227,7 +248,8 @@ def test_tensor_field():
DT9.integrate()
assert DT0.nb_components == 9
- check_instance(DT0.discrete_field_views(), tuple, values=CartesianDiscreteScalarFieldView, size=9)
+ check_instance(DT0.discrete_field_views(), tuple,
+ values=CartesianDiscreteScalarFieldView, size=9)
check_instance(DT0.dfields, tuple, values=CartesianDiscreteScalarFieldView, size=9)
check_instance(DT0.discrete_fields(), tuple, values=CartesianDiscreteField, size=9)
check_instance(DT0.continuous_fields(), tuple, values=Field, size=9)
@@ -262,7 +284,7 @@ def test_tensor_field():
assert DT0.has_unique_is_at_left_boundary()
assert DT0.has_unique_is_at_right_boundary()
- dfield = DT0[1,0]
+ dfield = DT0[1, 0]
assert DT0.backend == dfield.backend
assert DT0.backend_kind == dfield.backend_kind
assert DT0.domain == dfield.domain
@@ -326,18 +348,19 @@ def test_tensor_field():
except AttributeError:
pass
+
def test_boundaries():
"""This test checks that all boundaries are compatible for velocity and vorticity."""
- for dim in (1,2,):
- i=0
+ for dim in (1, 2,):
+ i = 0
for (lbd, rbd) in domain_boundary_iterator(dim):
domain = Box(dim=dim, lboundaries=lbd,
- rboundaries=rbd)
+ rboundaries=rbd)
V = VelocityField(domain)
S = ScalarField(name='S0', domain=domain)
- divV = V.div()
+ divV = V.div()
gradV = V.gradient()
- lapV = V.laplacian()
+ lapV = V.laplacian()
print
print 'DOMAIN BOUNDARIES:'
print ' *boundaries=[{}]'.format(domain.format_boundaries())
@@ -354,15 +377,14 @@ def test_boundaries():
print '{} BOUNDARIES:'.format(lapV.pretty_name)
for lVi in lapV.fields:
print ' *{} boundaries=[{}]'.format(lVi.pretty_name, lVi.format_boundaries())
- if (dim>1):
+ if (dim > 1):
rotV = V.curl()
print '{} (VORTICITY) BOUNDARIES:'.format(rotV.pretty_name)
for Wi in rotV.fields:
print ' *{} boundaries=[{}]'.format(Wi.pretty_name, Wi.format_boundaries())
-
if __name__ == '__main__':
- #test_field()
- #test_tensor_field()
+ test_field()
+ test_tensor_field()
test_boundaries()
diff --git a/hysop/iterative_method.py b/hysop/iterative_method.py
index 6bd0b554fc55180834682a5f28ac0d4fb98caee9..2550ae9ae4d39b87e5c85e4ec89b233d347864c1 100644
--- a/hysop/iterative_method.py
+++ b/hysop/iterative_method.py
@@ -2,13 +2,16 @@
from hysop import Simulation, Problem
from hysop.parameters.scalar_parameter import ScalarParameter
+from hysop.tools.contexts import Timer
from hysop import dprint, vprint
-from hysop.tools.decorators import debug
+from hysop.tools.decorators import debug
from hysop.core.graph.graph import ready
from hysop.constants import HYSOP_REAL, HYSOP_INTEGER
-from hysop.simulation import eps
-from hysop.tools.string_utils import vprint
+from hysop.tools.numpywrappers import npw
+from hysop.core.mpi import main_rank, main_size, main_comm
import numpy as np
+import datetime
+
class PseudoSimulation(Simulation):
"""Pseudo time-iterations for iterative method"""
@@ -53,18 +56,17 @@ class PseudoSimulation(Simulation):
"""Print current iteration parameters
"""
if isinstance(self.stop_criteria, ScalarParameter):
- crit = "{0:6.5g}".format(self.stop_criteria.value)
+ crit = "{:.8g}".format(self.stop_criteria.value)
else:
- crit = str(self.stop_criteria.value)
- msg = "=== PseudoSimulation : {0:3d}, criteria = {1} =="
+ crit = np.array2string(self.stop_criteria.value,
+ formatter={'float_kind': lambda x: '{:.8g}'.format(x)})
+ msg = "=== PseudoSimulation : {0:6d}, criteria = {1} =="
if verbose:
print msg.format(self.current_iteration, crit)
else:
vprint(msg.format(self.current_iteration, crit))
-
-
class IterativeMethod(Problem):
"""Overriding a Problem to enfoce a PseudoSimulation for iterative method loop.
@@ -78,17 +80,20 @@ class IterativeMethod(Problem):
override Problem class in a proper way. Here only a pseudo-timestep is
used together with a maximal number of iteration to compute a pseudo-final time.
"""
+
def __init__(self, stop_criteria, tolerance=1e-8, state_print=100, max_iter=10000,
- dt0=None, dt=None, reinit_op=[], **kwargs):
+ dt0=None, dt=None, configsimu=None, **kwargs):
super(IterativeMethod, self).__init__(**kwargs)
self.stop_criteria, self.tolerance = stop_criteria, tolerance
# create a pseudo-time step parameter if not given.
if (dt is None):
- dt = ScalarParameter(name='pseudo-dt', dtype=HYSOP_REAL, min_value=eps,
- initial_value=eps, quiet=True)
+ dt = ScalarParameter(name='pseudo-dt', dtype=HYSOP_REAL,
+ min_value=np.finfo(HYSOP_REAL).eps,
+ initial_value=np.finfo(HYSOP_REAL).eps,
+ quiet=True)
else:
- dt.value = eps
+ dt.value = np.finfo(HYSOP_REAL).eps
self.dt0, self.dt = dt0, dt
self.state_print = state_print
self.max_iter = max_iter
@@ -98,16 +103,22 @@ class IterativeMethod(Problem):
initial_value=0, quiet=True)
# stop_criteria reset value
- self._stop_criteria_reset = np.ones(self.stop_criteria.shape)
- self._stop_criteria_reset *= np.finfo(self.stop_criteria.dtype).max
+ self._stop_criteria_reset = npw.ones(self.stop_criteria.shape,
+ dtype=self.stop_criteria.dtype)
+ self._stop_criteria_reset[...] = 1e10
- # Method to be called to reset iterative method
- self._to_reinit_op = reinit_op
+ self.configsimu = self._default_configsimu
+ if not configsimu is None:
+ self.configsimu = configsimu
+ def _default_configsimu(self, l, s):
+ pass
@debug
@ready
- def apply(self, simulation, **kwds):
+ def apply(self, simulation, report_freq=0, dbg=None, **kwds):
+ if self.to_be_skipped(simulation, **kwds):
+ return
vprint('=== Entering iterative method...')
self.stop_criteria.value = self._stop_criteria_reset
@@ -120,21 +131,37 @@ class IterativeMethod(Problem):
dt0=self.dt0, dt=self.dt,
t=ScalarParameter(name='dummy-t',
dtype=HYSOP_REAL,
- quiet=True))
+ quiet=True),
+ mpi_params=self.mpi_params)
+ self.configsimu(loop, simulation)
# Usual initialize-loop-finalize sequence :
- loop.initialize()
- for op in self._to_reinit_op:
- op.nodes[0].reinit()
- while not loop.is_over:
- if loop.current_iteration % self.state_print ==0:
- loop.print_state()
- super(IterativeMethod, self).apply(simulation=loop, **kwds)
- loop.advance(dbg=kwds['dbg'])
- vprint("=== Leaving iterative method ({0} iterations, criteria = {1} )".format(
- loop.current_iteration, loop.stop_criteria.value))
+ if not loop._is_ready:
+ loop.initialize()
+ with Timer() as tm:
+ while not loop.is_over:
+ if loop.current_iteration % self.state_print == 0:
+ loop.print_state()
+ super(IterativeMethod, self).apply(simulation=loop, dbg=dbg, **kwds)
+ loop.advance(dbg=dbg)
+ if report_freq > 0 and (loop.current_iteration % report_freq) == 0:
+ self.profiler_report()
+
+ avg_time = main_comm.allreduce(tm.interval) / main_size
+ msg = "=== Leaving iterative method ({0} iterations, criteria = {1} in {2} ({3}s) {4})"
+ vprint(msg.format(
+ loop.current_iteration,
+ np.array2string(loop.stop_criteria.value,
+ formatter={'float_kind': lambda x: '{:8.8f}'.format(x)}),
+ datetime.timedelta(seconds=round(avg_time)),
+ avg_time,
+ '' if main_size == 1 else ', averaged over {} ranks. '.format(main_size)))
+
self.it_num.value = loop.current_iteration
loop.finalize()
+ self.final_report()
def get_preserved_input_fields(self):
- """See computational_operator:get_preserved_input_fields(). """
return set()
+
+ def final_report(self):
+ pass
diff --git a/hysop/mesh/cartesian_mesh.py b/hysop/mesh/cartesian_mesh.py
index 9b6a6fc69df31c494539451ca192b733be89eb75..dbeb0ba105f3c31d595ceaefe7f08547f43e4e1d 100644
--- a/hysop/mesh/cartesian_mesh.py
+++ b/hysop/mesh/cartesian_mesh.py
@@ -826,6 +826,64 @@ class CartesianMeshView(MeshView):
slc[i].step )
for i in xrange(self.dim) )
+ def local_shift(self, indices):
+ """Shift input indices (tuple of integer array as obtained from np.where)
+ with ghost layer size
+ """
+ shift = [self.local_start[d] for d in xrange(self.dim)]
+ return tuple([indices[d] + shift[d] for d in xrange(self.dim)])
+
+ def compute_integ_point(self, is_last, ic, n_dir=None):
+ """Compute indices corresponding to integration points
+ Parameters
+ ----------
+ is_last : numpy array of bool
+ is_last[d] = True means the process is on the top
+ boundary of the mesh, in direction d.
+ ic : tuple of indices
+ indices of the mesh
+ n_dir : array of int
+ direction where lengthes of the mesh are null.
+ """
+ dim = len(ic)
+ # We must find which points must be used
+ # when we integrate on this submesh
+ stops = npw.asdimarray([ic[d].stop for d in xrange(dim)])
+ # when 'is_last', the last point must be removed for integration
+ stops[is_last] -= 1
+ # and finally, for direction where subset length is zero,
+ # we must increase stop, else integral will always be zero!
+ if n_dir is not None:
+ stops[n_dir] = npw.asdimarray([ic[d].start + 1 for d in n_dir])
+
+ return [slice(ic[d].start, stops[d]) for d in xrange(dim)]
+
+ def reduce_coords(self, coords, reduced_index):
+ """Compute a reduced set of coordinates
+
+ Parameters
+ ----------
+ coords : tuple of arrays
+ the original coordinates
+ reduce : list of slices
+ indices of points for which reduced coordinates
+ are required.
+
+ Returns a tuple-like set of coordinates.
+
+ """
+ assert isinstance(coords, tuple)
+ assert isinstance(reduced_index, tuple)
+ dim = len(coords)
+ shapes = [list(coords[i].shape) for i in xrange(dim)]
+ res = [reduced_index[i].stop - reduced_index[i].start
+ for i in xrange(dim)]
+ for i in xrange(dim):
+ shapes[i][i] = res[i]
+ shapes = tuple(shapes)
+ return [coords[i].flat[reduced_index[i]].reshape(shapes[i])
+ for i in xrange(dim)]
+
def short_description(self):
"""
Short description of this mesh as a string.
diff --git a/hysop/methods.py b/hysop/methods.py
index 02542aec2a198048a99111d4f297bff811cd2165..741c3f0202945299dab06c5ee1ec2b914fea2a98 100644
--- a/hysop/methods.py
+++ b/hysop/methods.py
@@ -33,6 +33,7 @@ from hysop.constants import Backend, Precision, BoundaryCondition, \
from hysop.operator.spatial_filtering import FilteringMethod
from hysop.numerics.interpolation.interpolation import Interpolation, MultiScaleInterpolation
+from hysop.numerics.interpolation.polynomial import PolynomialInterpolator, PolynomialInterpolation
from hysop.numerics.odesolvers.runge_kutta import TimeIntegrator
from hysop.numerics.remesh.remesh import Remesh
from hysop.numerics.splitting.strang import StrangOrder
diff --git a/hysop/numerics/fft/_mkl_fft.py b/hysop/numerics/fft/_mkl_fft.py
new file mode 100644
index 0000000000000000000000000000000000000000..a095dfa05644a2400b13ad1a485efe401cfe4bff
--- /dev/null
+++ b/hysop/numerics/fft/_mkl_fft.py
@@ -0,0 +1,595 @@
+"""
+FFT interface for fast Fourier Transforms using Intel MKL (numpy interface).
+:class:`~hysop.numerics.MklFFT`
+:class:`~hysop.numerics.MklFFTPlan`
+
+/!\ -- OPENMP CONFLICT WITH GRAPHTOOLS --
+/!\ Only works if MKL_THREADING_LAYER is set to OMP if some
+ dependencies are compiled against GNU OpenMP.
+/!\ May also work with MKL_THREADING_LAYER=TBB and SEQUENCIAL but not INTEL.
+
+Required version of mkl_fft is: https://gitlab.com/keckj/mkl_fft
+If MKL_THREADING_LAYER is not set, or is set to INTEL, FFT tests will fail.
+"""
+
+import functools, warnings
+import numpy as np
+import numba as nb
+from mkl_fft import (ifft as mkl_ifft,
+ fft as mkl_fft,
+ rfft_numpy as mkl_rfft,
+ irfft_numpy as mkl_irfft)
+
+from hysop.numerics.fft.host_fft import HostFFTPlanI, HostFFTI, HostArray
+from hysop.numerics.fft.fft import \
+ complex_to_float_dtype, float_to_complex_dtype, \
+ mk_view, mk_shape, simd_alignment
+
+from hysop import __DEFAULT_NUMBA_TARGET__
+from hysop.numerics.fft.fft import HysopFFTWarning, bytes2str
+from hysop.tools.numba_utils import make_numba_signature, prange
+from hysop.tools.warning import HysopWarning
+from hysop.tools.numerics import get_itemsize
+from hysop.tools.types import first_not_None
+
+class HysopMKLFftWarning(HysopWarning):
+ pass
+
+def setup_transform(x, axis, transform, inverse, type):
+ shape = x.shape
+ dtype = x.dtype
+ N = shape[axis]
+ if inverse:
+ type = [1,3,2,4][type-1]
+ if (transform == 'dct'):
+ ctype = float_to_complex_dtype(x.dtype)
+ if (type==1):
+ sin = mk_shape(shape, axis, 2*N-2)
+ din = dtype
+ sout = mk_shape(shape, axis, N)
+ dout = ctype
+ elif (type==2):
+ sin = mk_shape(shape, axis, N)
+ din = dtype
+ sout = mk_shape(shape, axis, N//2+1)
+ dout = ctype
+ elif (type==3):
+ sin = mk_shape(shape, axis, N//2+1)
+ din = ctype
+ sout = mk_shape(shape, axis, N)
+ dout = dtype
+ else:
+ raise NotImplementedError
+ elif (transform is 'dst'):
+ ctype = float_to_complex_dtype(x.dtype)
+ if (type==1):
+ sin = mk_shape(shape, axis, 2*N+2)
+ din = dtype
+ sout = mk_shape(shape, axis, N+2)
+ dout = ctype
+ elif (type==2):
+ sin = mk_shape(shape, axis, N)
+ din = dtype
+ sout = mk_shape(shape, axis, N//2+1)
+ dout = ctype
+ elif (type==3):
+ sin = mk_shape(shape, axis, N//2+1)
+ din = ctype
+ sout = mk_shape(shape, axis, N)
+ dout = dtype
+ else:
+ raise NotImplementedError
+ else:
+ sin = None
+ din = None
+ sout = None
+ dout = None
+
+ return (sin,din,sout,dout)
+
+def fft(out=None, **kwds):
+ if (out is None):
+ out = mkl_fft(**kwds)
+ else:
+ out[...] = mkl_fft(**kwds)
+ return out
+def ifft(out=None, **kwds):
+ if (out is None):
+ out = mkl_ifft(**kwds)
+ else:
+ out[...] = mkl_ifft(**kwds)
+ return out
+def rfft(out=None, **kwds):
+ if (out is None):
+ out = mkl_rfft(**kwds)
+ else:
+ out[...] = mkl_rfft(**kwds)
+ return out
+def irfft(out=None, **kwds):
+ if (out is None):
+ out = mkl_irfft(**kwds)
+ else:
+ out[...] = mkl_irfft(**kwds)
+ return out
+
+
+def dct(x, out=None, type=2, axis=-1, input_tmp=None, output_tmp=None):
+ ndim = x.ndim
+ shape = x.shape
+ N = x.shape[axis]
+ (sin, din, sout, dout) = setup_transform(x, axis, 'dct', False, type)
+ if (type==1):
+ # O(sqrt(log(N))) error, O(2N) complexity, O(4*N) memory
+ if (input_tmp is None):
+ input_tmp = np.empty(shape=sin, dtype=din)
+ if (output_tmp is None):
+ output_tmp = np.empty(shape=sout, dtype=dout)
+ assert input_tmp.shape == sin
+ assert input_tmp.dtype == din
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+ slc0 = mk_view(ndim, axis, 1, -1)
+ slc1 = mk_view(ndim, axis, None, None, -1)
+ np.concatenate((x, x[slc0][slc1]), axis=axis, out=input_tmp)
+ rfft(x=input_tmp, out=output_tmp, axis=axis)
+ res = output_tmp.real
+ if (out is None):
+ out = res
+ else:
+ assert out.shape == res.shape
+ assert out.dtype == res.dtype
+ out[...] = res
+ elif (type==2):
+ # O(sqrt(log(N))) error, O(N) complexity, O(3N) memory
+ n0 = N//2 + 1
+ n1 = (N-1)//2 + 1
+ slc0 = mk_view(ndim, axis, 1, None, None)
+ slc1 = mk_view(ndim, axis, None, None, +2)
+ slc2 = mk_view(ndim, axis, 1, None, +2)
+ slc3 = mk_view(ndim, axis, None, None, -1)
+ slc4 = mk_view(ndim, axis, None, None, None, default=None)
+ slc5 = mk_view(ndim, axis, None, n1, None)
+ slc6 = mk_view(ndim, axis, n1, None, None)
+
+ if (input_tmp is None):
+ input_tmp = np.empty(shape=sin, dtype=din)
+ if (output_tmp is None):
+ output_tmp = np.empty(shape=sout, dtype=dout)
+ assert input_tmp.shape == sin
+ assert input_tmp.dtype == din
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+
+ np.concatenate((x[slc1], x[slc2][slc3]), axis=axis, out=input_tmp)
+ rfft(x=input_tmp, out=output_tmp, axis=axis)
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+ output_tmp *= (2*np.exp(-1j*np.pi*np.arange(n0)/(2*N)))[slc4]
+
+ if (out is None):
+ out = np.empty_like(x)
+ else:
+ assert out.shape == x.shape
+ assert out.dtype == x.dtype
+ out[slc5] = +output_tmp.real[slc5]
+ out[slc6] = -output_tmp.imag[slc0][slc3]
+ elif (type==3):
+ # O(sqrt(log(N))) error, O(N) complexity, O(3N) memory
+ n0 = N//2 + 1
+ n1 = (N-1)//2 + 1
+ slc0 = mk_view(ndim, axis, None, n0, None)
+ slc1 = mk_view(ndim, axis, 1 , None, None)
+ slc2 = mk_view(ndim, axis, n1 , None, None)
+ slc3 = mk_view(ndim, axis, None, None, -1)
+ slc4 = mk_view(ndim, axis, None, None, +2)
+ slc5 = mk_view(ndim, axis, None, n1, None)
+ slc6 = mk_view(ndim, axis, 1, None, +2)
+ slc7 = mk_view(ndim, axis, None, None, None, default=None)
+ slc8 = mk_view(ndim, axis, n0 , None, None)
+ slc9 = mk_view(ndim, axis, None, 1 , None)
+
+ if (input_tmp is None):
+ input_tmp = np.empty(shape=sin, dtype=din)
+ if (output_tmp is None):
+ output_tmp = np.empty(shape=sout, dtype=dout)
+ assert input_tmp.shape == sin
+ assert input_tmp.dtype == din
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+ input_tmp.real[slc0] = +x[slc0]
+ input_tmp.real[slc8] = 0.0
+ input_tmp.imag[slc1] = -x[slc2][slc3]
+ input_tmp.imag[slc9] = 0.0
+ input_tmp *= np.exp(+1j*np.pi*np.arange(n0)/(2*N))[slc7]
+ output_tmp = irfft(x=input_tmp, out=output_tmp, axis=axis, n=N)
+ output_tmp *= N
+
+ if (out is None):
+ out = np.empty_like(x)
+ else:
+ assert out.shape == x.shape
+ assert out.dtype == x.dtype
+ out[slc4] = output_tmp[slc5]
+ out[slc6] = output_tmp[slc2][slc3]
+ else:
+ stypes=['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII']
+ msg='DCT-{} has not been implemented yet.'
+ msg=msg.format(stypes[type-1])
+ raise NotImplementedError(msg)
+ return out
+
+def dst(x, out=None, type=2, axis=-1, input_tmp=None, output_tmp=None):
+ (sin, din, sout, dout) = setup_transform(x, axis, 'dst', False, type)
+ ndim = x.ndim
+ shape = x.shape
+ N = x.shape[axis]
+ if (type==1):
+ # O(sqrt(log(N))) error, O(2N) complexity, O(4*N) memory
+ slc0 = mk_view(ndim, axis, None, None, -1)
+ slc1 = mk_view(ndim, axis, 1, -1, None)
+ s1 = mk_shape(shape, axis, 1)
+ if (input_tmp is None):
+ input_tmp = np.empty(shape=sin, dtype=din)
+ if (output_tmp is None):
+ output_tmp = np.empty(shape=sout, dtype=dout)
+ assert input_tmp.shape == sin
+ assert input_tmp.dtype == din
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+
+ Z = np.zeros(shape=s1, dtype=x.dtype)
+ np.concatenate((Z, -x, Z, x[slc0]), axis=axis, out=input_tmp)
+ rfft(x=input_tmp, out=output_tmp, axis=axis)
+ res = output_tmp.imag
+ if (out is None):
+ out = np.empty_like(x)
+ else:
+ assert out.shape == x.shape
+ assert out.dtype == x.dtype
+ out[...] = res[slc1]
+ elif (type==2):
+ # O(sqrt(log(N))) error, O(N) complexity, O(3N) memory
+ n0 = N//2 + 1
+ n1 = (N-1)//2 + 1
+ slc0 = mk_view(ndim, axis, 1, None, None)
+ slc1 = mk_view(ndim, axis, None, None, +2)
+ slc2 = mk_view(ndim, axis, 1, None, +2)
+ slc3 = mk_view(ndim, axis, None, None, -1)
+ slc4 = mk_view(ndim, axis, None, None, None, default=None)
+ slc5 = mk_view(ndim, axis, None, n1-1, None)
+ slc6 = mk_view(ndim, axis, n1-1, None, None)
+ slc7 = mk_view(ndim, axis, 1, n1, None)
+
+ if (input_tmp is None):
+ input_tmp = np.empty(shape=sin, dtype=din)
+ if (output_tmp is None):
+ output_tmp = np.empty(shape=sout, dtype=dout)
+ assert input_tmp.shape == sin
+ assert input_tmp.dtype == din
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+
+ np.concatenate((x[slc1], -x[slc2][slc3]), axis=axis, out=input_tmp)
+ rfft(x=input_tmp, out=output_tmp, axis=axis)
+ output_tmp *= (2*np.exp(-1j*np.pi*np.arange(n0)/(2*N)))[slc4]
+
+ if (out is None):
+ out = np.empty_like(x)
+ else:
+ assert out.shape == x.shape
+ assert out.dtype == x.dtype
+ out[slc5] = -output_tmp.imag[slc7]
+ out[slc6] = +output_tmp.real[slc3]
+ elif (type==3):
+ # O(sqrt(log(N))) error, O(N) complexity, O(3N) memory
+ ctype = float_to_complex_dtype(x.dtype)
+ n0 = N//2 + 1
+ n1 = (N-1)//2 + 1
+ slc0 = mk_view(ndim, axis, None, n0, None)
+ slc1 = mk_view(ndim, axis, None, None, -1)
+ slc2 = mk_view(ndim, axis, 1, None, None)
+ slc3 = mk_view(ndim, axis, None, N-n1, None)
+ slc4 = mk_view(ndim, axis, None, None, None, default=None)
+ slc5 = mk_view(ndim, axis, None, None, 2)
+ slc6 = mk_view(ndim, axis, None, n1, None)
+ slc7 = mk_view(ndim, axis, 1, None, 2)
+ slc8 = mk_view(ndim, axis, n1, None, None)
+ slc9 = mk_view(ndim, axis, n0, None, None)
+ slc10 = mk_view(ndim, axis, 0, 1, None)
+ s0 = mk_shape(shape, axis, n0)
+
+ if (input_tmp is None):
+ input_tmp = np.empty(shape=sin, dtype=din)
+ if (output_tmp is None):
+ output_tmp = np.empty(shape=sout, dtype=dout)
+ assert input_tmp.shape == sin
+ assert input_tmp.dtype == din
+ assert output_tmp.shape == sout
+ assert output_tmp.dtype == dout
+
+ input_tmp.real[slc0] = +x[slc1][slc0]
+ input_tmp.real[slc9] = 0.0
+ input_tmp.imag[slc2] = -x[slc3]
+ input_tmp.imag[slc10] = 0.0
+ input_tmp *= np.exp(+1j*np.pi*np.arange(n0)/(2*N))[slc4]
+ irfft(x=input_tmp, out=output_tmp, axis=axis, n=N)
+ output_tmp[...] *= N
+
+ if (out is None):
+ out = np.empty_like(x)
+ else:
+ assert out.shape == x.shape
+ assert out.dtype == x.dtype
+ out[slc5] = +output_tmp[slc6]
+ out[slc7] = -output_tmp[slc8][slc1]
+ else:
+ stypes=['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII']
+ msg='DCT-{} has not been implemented yet.'
+ msg=msg.format(stypes[type-1])
+ raise NotImplementedError(msg)
+ return out
+
+def idct(x, out=None, type=2, axis=-1, **kwds):
+ itype = [1,3,2,4][type-1]
+ return dct(x=x, out=out, type=itype, axis=axis, **kwds)
+
+def idst(x, out=None, type=2, axis=-1, **kwds):
+ itype = [1,3,2,4][type-1]
+ return dst(x=x, out=out, type=itype, axis=axis, **kwds)
+
+
+
+class MklFFTPlan(HostFFTPlanI):
+ """
+ Wrap a mkl fft call (mkl.fft does not offer real planning capabilities).
+ """
+
+ def __init__(self, planner, fn, a, out, axis, scaling=None, **kwds):
+ super(MklFFTPlan, self).__init__()
+
+ self.planner = planner
+ self.fn = fn
+ self.a = a
+ self.out = out
+ self.scaling = scaling
+
+ (sin, din, sout, dout) = setup_transform(a, axis,
+ 'dct' if fn in (dct, idct) else 'dst' if fn in (dst, idst) else None,
+ fn in (idct, idst),
+ kwds.get('type', None))
+
+ if (sin is None):
+ self._required_input_tmp = None
+ else:
+ self._required_input_tmp = {'size': np.prod(sin, dtype=np.int64), 'shape':sin, 'dtype':din}
+
+ if (sout is None):
+ self._required_output_tmp = None
+ else:
+ self._required_output_tmp = {'size': np.prod(sout, dtype=np.int64), 'shape':sout, 'dtype':dout}
+
+ self._allocated = False
+
+ if isinstance(a, HostArray):
+ a = a.handle
+ if isinstance(out, HostArray):
+ out = out.handle
+
+ self.rescale = self.bake_scaling_plan(out, scaling)
+
+
+ kwds = kwds.copy()
+ kwds['x'] = a
+ kwds['out'] = out
+ kwds['axis'] = axis
+ self.kwds = kwds
+
+ def bake_scaling_plan(self, x, scaling):
+ if (scaling is None):
+ def _rescale():
+ pass
+ return _rescale
+ target = __DEFAULT_NUMBA_TARGET__
+ signature, layout = make_numba_signature(x, scaling)
+ if (x.ndim == 1):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def scale(x, scaling):
+ for i in xrange(0, x.shape[0]):
+ x[i] *= scaling
+ elif (x.ndim == 2):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def scale(x, scaling):
+ for i in prange(0, x.shape[0]):
+ for j in xrange(0, x.shape[1]):
+ x[i,j] *= scaling
+ elif (x.ndim == 3):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def scale(x, scaling):
+ for i in prange(0, x.shape[0]):
+ for j in prange(0, x.shape[1]):
+ for k in xrange(0, x.shape[2]):
+ x[i,j,k] *= scaling
+ elif (x.ndim == 4):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def scale(x, scaling):
+ for i in prange(0, x.shape[0]):
+ for j in prange(0, x.shape[1]):
+ for k in prange(0, x.shape[2]):
+ for l in xrange(0, x.shape[3]):
+ x[i,j,k,l] *= scaling
+ else:
+ raise NotImplementedError(x.ndim)
+ def _rescale(scale=scale, x=x, scaling=scaling):
+ scale(x,scaling)
+ return _rescale
+
+ @property
+ def input_array(self):
+ return self.a
+
+ @property
+ def output_array(self):
+ return self.out
+
+ def execute(self):
+ if not self._allocated:
+ self.allocate()
+ self.fn(**self.kwds)
+ self.rescale()
+
+
+ @property
+ def required_buffer_size(self):
+ alignment = simd_alignment
+ if self._required_input_tmp:
+ sin, din = self._required_input_tmp['size'], self._required_input_tmp['dtype']
+ sin *= get_itemsize(din)
+ Bin = ((sin+alignment-1)//alignment)*alignment
+ else:
+ Bin = 0
+ if self._required_output_tmp:
+ sout, dout = self._required_output_tmp['size'], self._required_output_tmp['dtype']
+ sout *= get_itemsize(dout)
+ Bout = ((sout+alignment-1)//alignment)*alignment
+ else:
+ Bout = 0
+ return Bin+Bout
+
+ def allocate(self, buf=None):
+ """Allocate plan extra memory, possibly with a custom buffer."""
+ if self._allocated:
+ msg='Plan was already allocated.'
+ raise RuntimeError(msg)
+
+ if (buf is not None):
+ alignment = simd_alignment
+ if self._required_input_tmp:
+ sin, din, ssin = self._required_input_tmp['size'], self._required_input_tmp['dtype'], self._required_input_tmp['shape']
+ sin *= get_itemsize(din)
+ Bin = ((sin+alignment-1)//alignment)*alignment
+ else:
+ Bin = 0
+ if self._required_output_tmp:
+ sout, dout, ssout = self._required_output_tmp['size'], self._required_output_tmp['dtype'], self._required_output_tmp['shape']
+ sout *= get_itemsize(dout)
+ Bout = ((sout+alignment-1)//alignment)*alignment
+ else:
+ Bout = 0
+ assert buf.dtype.itemsize == 1
+ assert buf.size == Bin+Bout
+ input_buf = buf[:sin].view(dtype=din).reshape(ssin) if Bin else None
+ output_buf = buf[Bin:Bin+sout].view(dtype=dout).reshape(ssout) if Bout else None
+ else:
+ input_buf = None
+ output_buf = None
+
+ for (k, buf, required_tmp) in zip(('input', 'output'),
+ (input_buf, output_buf),
+ (self._required_input_tmp, self._required_output_tmp)):
+ if (required_tmp is None):
+ assert buf is None
+ continue
+ size = required_tmp['size']
+ shape = required_tmp['shape']
+ dtype = required_tmp['dtype']
+ if (size>0):
+ if (buf is None):
+ if self.planner.warn_on_allocation or self.planner.error_on_allocation:
+ msg='Allocating temporary buffer of size {} for clFFT::{}.'
+ msg=msg.format(bytes2str(size), id(self))
+ if self.planner.error_on_allocation:
+ raise RuntimeError(msg)
+ else:
+ warnings.warn(msg, HysopMKLFftWarning)
+ buf = self.planner.backend.empty(shape=shape,
+ dtype=dtype)
+ elif (buf.shape != shape) or (buf.dtype != dtype):
+ msg='Buffer does not match required shape: {} != {}'
+ msg=msg.format(buf.shape, shape)
+ msg='Buffer does not match required dtype: {} != {}'
+ msg=msg.format(buf.dtype, dtype)
+ raise ValueError(msg)
+ if isinstance(buf, HostArray):
+ buf = buf.handle
+ setattr(self, '{}_tmp_buffer'.format(k), buf)
+ if (buf is not None):
+ self.kwds['{}_tmp'.format(k)] = buf
+ self._allocated = True
+ return self
+
+
+class MklFFT(HostFFTI):
+ """
+ Interface to compute local to process FFT-like transforms using the mkl fft backend.
+
+ Mkl fft backend has some disadvantages:
+ - creates intermediate temporary buffers at each call (out and tmp for real-to-real transforms)
+ - no planning capabilities (mkl.fft methods are just wrapped into fake plans)
+ """
+
+ def __init__(self, backend=None, allocator=None,
+ warn_on_allocation=True, error_on_allocation=False,
+ destroy_input=None, **kwds):
+ super(MklFFT, self).__init__(backend=backend, allocator=allocator,
+ warn_on_allocation=warn_on_allocation, error_on_allocation=error_on_allocation, **kwds)
+ self.supported_ftypes = (np.float32, np.float64,)
+ self.supported_ctypes = (np.complex64, np.complex128,)
+
+ def fft(self, a, out=None, axis=-1, **kwds):
+ (shape, dtype) = super(MklFFT, self).fft(a=a, out=out, axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=fft, a=a, out=out, axis=axis, **kwds)
+ return plan
+
+ def ifft(self, a, out=None, axis=-1, **kwds):
+ (shape, dtype, s) = super(MklFFT, self).ifft(a=a, out=out, axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=ifft, a=a, out=out, axis=axis, **kwds)
+ return plan
+
+ def rfft(self, a, out=None, axis=-1, **kwds):
+ (shape, dtype) = super(MklFFT, self).rfft(a=a, out=out, axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=rfft, a=a, out=out, axis=axis,
+ **kwds)
+ return plan
+
+ def irfft(self, a, out=None, n=None, axis=-1, **kwds):
+ (shape, dtype, s) = super(MklFFT, self).irfft(a=a, out=out, n=n, axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=irfft, a=a, out=out, axis=axis,
+ n=shape[axis], **kwds)
+ return plan
+
+ def dct(self, a, out=None, type=2, axis=-1, **kwds):
+ (shape, dtype) = super(MklFFT, self).dct(a=a, out=out, type=type, axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=dct, a=a, out=out, axis=axis, type=type, **kwds)
+ return plan
+
+ def idct(self, a, out=None, type=2, axis=-1, scaling=None, **kwds):
+ (shape, dtype, _, s) = super(MklFFT, self).idct(a=a, out=out, type=type,
+ axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=idct, a=a, out=out, axis=axis, type=type,
+ scaling=first_not_None(scaling, 1.0/s), **kwds)
+ return plan
+
+ def dst(self, a, out=None, type=2, axis=-1, **kwds):
+ (shape, dtype) = super(MklFFT, self).dst(a=a, out=out, type=type, axis=axis, **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=dst, a=a, out=out, axis=axis, type=type, **kwds)
+ return plan
+
+ def idst(self, a, out=None, type=2, axis=-1, scaling=None, **kwds):
+ (shape, dtype, _, s) = super(MklFFT, self).idst(a=a, out=out, type=type, axis=axis,
+ **kwds)
+ out = self.allocate_output(out, shape, dtype)
+ plan = MklFFTPlan(self, fn=idst, a=a, out=out, axis=axis, type=type,
+ scaling=first_not_None(scaling, 1.0/s), **kwds)
+ return plan
+
diff --git a/hysop/numerics/fft/gpyfft_fft.py b/hysop/numerics/fft/gpyfft_fft.py
index 341a449fc614670874cc635047dd2c4b79905542..ef74d4ade5e3e61b577076571bde9cbd9a87340a 100644
--- a/hysop/numerics/fft/gpyfft_fft.py
+++ b/hysop/numerics/fft/gpyfft_fft.py
@@ -26,8 +26,9 @@ from hysop.tools.types import first_not_None
from hysop.tools.numerics import is_complex, is_fp
from hysop.tools.string_utils import framed_str
-from hysop.backend.device.opencl import cl, clArray
+from hysop.backend.device.opencl import cl, clArray, __OPENCL_PROFILE__
from hysop.backend.device.codegen.base.variables import dtype_to_ctype
+from hysop.backend.device.opencl.opencl_kernel_launcher import trace_kernel, profile_kernel
class HysopGpyFftWarning(HysopWarning):
@@ -42,12 +43,13 @@ class GpyFFTPlan(OpenClFFTPlanI):
DEBUG=False
- def __init__(self, cl_env, in_array, out_array, axes,
+ def __init__(self, cl_env, queue,
+ in_array, out_array, axes,
scaling=None, scale_by_size=None,
fake_input=None, fake_output=None,
callback_kwds=None,
direction_forward=True,
- hardcode_twiddles=True,
+ hardcode_twiddles=False,
warn_on_unaligned_output_offset=True,
warn_on_allocation=True,
error_on_allocation=False,
@@ -60,6 +62,8 @@ class GpyFFTPlan(OpenClFFTPlanI):
----------
cl_env: OpenClEnvironment
OpenCL environment that will provide a context and a default queue.
+ queue:
+ OpenCL queue that will be used by default.
in_array: cl.Array or OpenClArray
Real input array for this transform.
out_array: cl.Array or OpenClArray
@@ -83,7 +87,7 @@ class GpyFFTPlan(OpenClFFTPlanI):
Only used by R2R transforms.
direction_forward: bool, optional, defaults to True
The direction of the transform. True <=> forward transform.
- hardcode_twiddles: bool, optional, defaults to True
+ hardcode_twiddles: bool, optional, defaults to False
Hardcode twiddles as a __constant static array of complex directly
in the opencl code. Only used by DCT-II, DCT-III, DST-II and DST-III.
If set to False, the twiddles will be computed by the device on the
@@ -98,15 +102,20 @@ class GpyFFTPlan(OpenClFFTPlanI):
"""
super(GpyFFTPlan, self).__init__(**kwds)
- if self.DEBUG:
- # disable hardcoded twiddles generation to reduce callback sizes
- hardcode_twiddles=False
-
fake_input = first_not_None(fake_input, in_array)
fake_output = first_not_None(fake_output, out_array)
callback_kwds = first_not_None(callback_kwds, {})
- self.cl_env = cl_env
+ if (queue is None):
+ queue = cl_env.default_queue
+ if (queue.context != cl_env.context):
+ msg = 'Queue does not match context:'
+ msg += '\n *Given context is {}.'.format(cl_env.context)
+ msg += '\n *Command queue context is {}.'.format(queue.context)
+ raise ValueError(msg)
+ self.cl_env = cl_env
+ self._queue = queue
+
self.warn_on_unaligned_output_offset = warn_on_unaligned_output_offset
self.warn_on_allocation = warn_on_allocation
self.error_on_allocation = error_on_allocation
@@ -358,6 +367,7 @@ Post callback source code:
plan.scale_forward, plan.scale_backward,
self.pre_callback_src, self.post_callback_src)
print msg
+
if (scaling is 'DEFAULT'):
pass
elif (scaling is not None):
@@ -366,6 +376,17 @@ Post callback source code:
else:
plan.scale_forward = 1.0
plan.scale_backward = 1.0
+
+ # profiling info is delegated to this class, inform the KernelListLauncher
+ self._show_profiling_info = False
+
+ # custom apply msg
+ self._apply_msg_template = ' fft_{}2{}_{}_{}_{{}}<<<>>>'.format(
+ 'C' if is_complex(in_array) else 'R',
+ 'C' if is_complex(out_array) else 'R',
+ 'forward' if direction_forward else 'backward',
+ self.__class__.__name__.replace('Gpy','').replace('Plan','_plan').replace('FFT','DFT'))
+
def set_callbacks(self, plan, axes, N,
in_array, out_array, fake_input, fake_output,
@@ -640,7 +661,6 @@ Post callback source code:
if self.verbose:
print
print framed_str(title, msg, c='*')
- self.plan.bake(self.queue)
queue = first_not_None(queue, self.queue)
self.plan.bake(queue)
self._baked = True
@@ -674,19 +694,27 @@ Post callback source code:
self._allocated = True
return self
+
+ def profile(self, events):
+ for (i,evt) in enumerate(events):
+ profile_kernel(None, evt, self._apply_msg_template.format(i))
+ return evt
+
def enqueue(self, queue=None, wait_for=None):
"""
Enqueue transform with array base_data.
"""
queue = first_not_None(queue, self.queue)
if not self._baked:
- self.bake(queue)
+ self.bake(queue=queue)
if not self._allocated:
self.allocate()
in_data, out_data = self.in_data, self.out_data
direction_forward = self.direction_forward
+ trace_kernel(self._apply_msg_template.format('kernels'))
+
if self.is_inplace:
events = self.plan.enqueue_transform((queue,),
(in_data,),
@@ -699,7 +727,7 @@ Post callback source code:
direction_forward=direction_forward,
temp_buffer=self.temp_buffer,
wait_for_events=wait_for)
- evt, = events
+ evt = self.profile(events)
return evt
def enqueue_arrays(self, *args, **kwds):
@@ -707,8 +735,6 @@ Post callback source code:
raise NotImplementedError(msg)
def execute(self, **kwds):
- if __KERNEL_DEBUG__ or __TRACE_KERNELS__:
- print ' {}<<<>>>()'.format(self.__class__.__name__)
return self.enqueue(**kwds)
@property
@@ -722,7 +748,7 @@ Post callback source code:
@property
def queue(self):
- return self.cl_env.default_queue
+ return self._queue
@property
def context(self):
@@ -1322,6 +1348,7 @@ class GpyFFT(OpenClFFTI):
plan_kwds['scale_by_size'] = kwds.pop('scale_by_size', None)
plan_kwds['axes'] = kwds.pop('axes', (kwds.pop('axis'),))
plan_kwds['cl_env'] = kwds.pop('cl_env', self.cl_env)
+ plan_kwds['queue'] = kwds.pop('queue', self.queue)
plan_kwds['verbose'] = kwds.pop('verbose', __VERBOSE__)
plan_kwds['warn_on_allocation'] = kwds.pop('warn_on_allocation', self.warn_on_allocation)
plan_kwds['error_on_allocation'] = kwds.pop('error_on_allocation', self.error_on_allocation)
diff --git a/hysop/numerics/fft/host_fft.py b/hysop/numerics/fft/host_fft.py
index 15e1cb03cb550e900f3a7aec20a1bae4f2b24c87..ceb5c70e65751bbfde54060854c52b9f11302580 100644
--- a/hysop/numerics/fft/host_fft.py
+++ b/hysop/numerics/fft/host_fft.py
@@ -11,13 +11,19 @@ import numpy as np
import numba as nb
from hysop import __FFTW_NUM_THREADS__, __FFTW_PLANNER_EFFORT__, __FFTW_PLANNER_TIMELIMIT__, \
- __DEFAULT_NUMBA_TARGET__
+ __DEFAULT_NUMBA_TARGET__
from hysop.tools.types import first_not_None, check_instance
-from hysop.tools.numba_utils import make_numba_signature
+from hysop.tools.numba_utils import HAS_NUMBA, bake_numba_copy, bake_numba_accumulate, bake_numba_transpose
+from hysop.tools.hptt_utils import HAS_HPTT, hptt, can_exec_hptt, array_share_data
+from hysop.tools.decorators import static_vars
from hysop.backend.host.host_array_backend import HostArrayBackend
from hysop.backend.host.host_array import HostArray
from hysop.numerics.fft.fft import FFTQueueI, FFTPlanI, FFTI
+# Currently there is a bug for non contiguous arrays
+# in numba so we disable it
+HAS_NUMBA=False
+
class DummyEvent(object):
@classmethod
def wait(cls):
@@ -74,22 +80,31 @@ class HostFFTI(FFTI):
error_on_allocation=False,
**kwds):
"""
- Get the default host FFT interface which is a multithreaded FFTW interface with
- ESTIMATE planning effort.
+ Get the default host FFT interface.
+ Preferred interface is multithreaded MKL FFT with the TBB threading layer (does not work with Intel threading layer).
+ On import error the interface falls back to a multithreaded FFTW interface with ESTIMATE planning effort.
"""
- threads = first_not_None(threads, __FFTW_NUM_THREADS__)
- planner_effort = first_not_None(planner_effort, __FFTW_PLANNER_EFFORT__)
- planning_timelimit = first_not_None(planning_timelimit, __FFTW_PLANNER_TIMELIMIT__)
- from hysop.numerics.fft.fftw_fft import FftwFFT
- return FftwFFT(threads=threads,
- planner_effort=planner_effort,
- planning_timelimit=planning_timelimit,
- backend=backend, allocator=allocator,
- destroy_input=destroy_input,
- warn_on_allocation=warn_on_allocation,
- warn_on_misalignment=warn_on_misalignment,
- error_on_allocation=error_on_allocation,
- **kwds)
+ try:
+ from hysop.numerics.fft._mkl_fft import MklFFT
+ return MklFFT(backend=backend, allocator=allocator,
+ destroy_input=destroy_input,
+ warn_on_allocation=warn_on_allocation,
+ error_on_allocation=error_on_allocation,
+ **kwds)
+ except ImportError:
+ from hysop.numerics.fft.fftw_fft import FftwFFT
+ threads = first_not_None(threads, __FFTW_NUM_THREADS__)
+ planner_effort = first_not_None(planner_effort, __FFTW_PLANNER_EFFORT__)
+ planning_timelimit = first_not_None(planning_timelimit, __FFTW_PLANNER_TIMELIMIT__)
+ return FftwFFT(threads=threads,
+ planner_effort=planner_effort,
+ planning_timelimit=planning_timelimit,
+ backend=backend, allocator=allocator,
+ destroy_input=destroy_input,
+ warn_on_allocation=warn_on_allocation,
+ warn_on_misalignment=warn_on_misalignment,
+ error_on_allocation=error_on_allocation,
+ **kwds)
def new_queue(self, tg, name):
return HostFFTQueue(name=name)
@@ -97,22 +112,55 @@ class HostFFTI(FFTI):
def plan_copy(self, tg, src, dst):
src = self.ensure_callable(src)
dst = self.ensure_callable(dst)
+
+ @static_vars(numba_copy=None)
def exec_copy(src=src, dst=dst):
- dst()[...] = src()
+ src, dst = src(), dst()
+ if can_exec_hptt(src, dst):
+ hptt.tensorTransposeAndUpdate(perm=range(src.ndim),
+ alpha=1.0, A=src, beta=0.0, B=dst)
+ elif HAS_NUMBA:
+ if (exec_copy.numba_copy is None):
+ exec_copy.numba_copy = bake_numba_copy(src=src, dst=dst)
+ exec_copy.numba_copy()
+ else:
+ dst[...] = src
return exec_copy
def plan_accumulate(self, tg, src, dst):
src = self.ensure_callable(src)
dst = self.ensure_callable(dst)
- def exec_copy(src=src, dst=dst):
- dst()[...] += src()
- return exec_copy
+
+ @static_vars(numba_accumulate=None)
+ def exec_accumulate(src=src, dst=dst):
+ src, dst = src(), dst()
+ if can_exec_hptt(src, dst):
+ hptt.tensorTransposeAndUpdate(perm=range(src.ndim),
+ alpha=1.0, A=src, beta=1.0, B=dst)
+ elif HAS_NUMBA:
+ if (exec_accumulate.numba_accumulate is None):
+ exec_accumulate.numba_accumulate = bake_numba_accumulate(src=src, dst=dst)
+ exec_accumulate.numba_accumulate()
+ else:
+ dst[...] += src
+ return exec_accumulate
def plan_transpose(self, tg, src, dst, axes):
src = self.ensure_callable(src)
dst = self.ensure_callable(dst)
+
+ @static_vars(numba_transpose=None)
def exec_transpose(src=src, dst=dst, axes=axes):
- dst()[...] = np.transpose(a=src(), axes=axes)
+ src, dst = src(), dst()
+ if can_exec_hptt(src, dst):
+ hptt.tensorTransposeAndUpdate(perm=axes,
+ alpha=1.0, A=src, beta=0.0, B=dst)
+ elif HAS_NUMBA:
+ if (exec_transpose.numba_transpose is None):
+ exec_transpose.numba_transpose = bake_numba_transpose(src=src, dst=dst, axes=axes)
+ exec_transpose.numba_transpose()
+ else:
+ dst[...] = np.transpose(a=src, axes=axes)
return exec_transpose
def plan_fill_zeros(self, tg, a, slices):
diff --git a/hysop/numerics/fft/opencl_fft.py b/hysop/numerics/fft/opencl_fft.py
index 5f93ec4354a4b17b4f13fa0f167f0614d1e29d4e..08841d3e5b01d2c509192a176e167d2efc03557e 100644
--- a/hysop/numerics/fft/opencl_fft.py
+++ b/hysop/numerics/fft/opencl_fft.py
@@ -59,22 +59,30 @@ class OpenClFFTI(FFTI):
"""
Abstract base for FFT interfaces targetting OpenCL backends.
"""
- def __init__(self, cl_env, backend=None, allocator=None, **kwds):
+ def __init__(self, cl_env, backend=None, allocator=None, queue=None, **kwds):
from hysop.backend.device.opencl.opencl_array_backend import OpenClArrayBackend
from hysop.backend.device.opencl.opencl_env import OpenClEnvironment
if (backend is None):
+ if (queue is None):
+ queue = cl_env.default_queue
backend = OpenClArrayBackend.get_or_create(cl_env=cl_env,
- queue=cl_env.default_queue, allocator=allocator)
+ queue=queue, allocator=allocator)
else:
msg='OpenCl environment does not match the one of the backend.'
assert (backend.cl_env is cl_env), msg
if (allocator is not None):
msg='OpenCl allocator does not match the one of the backend.'
assert (backend.allocator is allocator), msg
+ if (queue.context != cl_env.context):
+ msg = 'Queue does not match context:'
+ msg += '\n *Given context is {}.'.format(cl_env.context)
+ msg += '\n *Command queue context is {}.'.format(queue.context)
+ raise ValueError(msg)
check_instance(cl_env, OpenClEnvironment)
check_instance(backend, OpenClArrayBackend)
super(OpenClFFTI, self).__init__(backend=backend, **kwds)
self.cl_env = cl_env
+ self.queue = queue
self.kernel_generator = OpenClElementwiseKernelGenerator(cl_env=cl_env)
@classmethod
@@ -94,7 +102,7 @@ class OpenClFFTI(FFTI):
**kwds)
def new_queue(self, tg, name):
- return OpenClFFTQueue(queue=tg.backend.cl_env.default_queue, name=name)
+ return OpenClFFTQueue(queue=self.queue, name=name)
def plan_copy(self, tg, src, dst):
src = self.ensure_buffer(src)
@@ -193,7 +201,7 @@ class OpenClFFTI(FFTI):
# this kernel is not optimized (we use a __global mutex for each wavenumber for now)
launcher, _ = self.kernel_generator.elementwise_kernel('compute_energy', *exprs,
- force_volatile=(dst,), debug=False)
+ force_volatile=(dst,), max_candidates=1, debug=False)
return launcher
@classmethod
diff --git a/hysop/numerics/fftw_f/fft2d.f90 b/hysop/numerics/fftw_f/fft2d.f90
index 98f79f55ee20467eef16980b1ea6848bbda1a9ce..806d3969508226e33dc8e92c846af42820c18fd5 100755
--- a/hysop/numerics/fftw_f/fft2d.f90
+++ b/hysop/numerics/fftw_f/fft2d.f90
@@ -569,8 +569,8 @@ contains
integer(C_INTPTR_T) :: offsetx = 0
datashape = (/fft_resolution(c_X), local_resolution(c_Y)/)
offset = (/ offsetx, local_offset(c_Y)/)
-
end subroutine getParamatersTopologyFFTW2d
+
!> Initialisation of the fftw context for real to complex transforms (forward and backward)
!! @param[in] resolution global domain resolution
subroutine init_r2c_2dBIS(resolution,lengths)
diff --git a/hysop/numerics/fftw_f/fft3d.f90 b/hysop/numerics/fftw_f/fft3d.f90
index c87435d7f02e4a842cdd3da3290d14a0f587bc23..be54dacf7d3a19e7154d39469f0849fd6b479f0d 100755
--- a/hysop/numerics/fftw_f/fft3d.f90
+++ b/hysop/numerics/fftw_f/fft3d.f90
@@ -30,7 +30,7 @@ module fft3d
init_r2c_3d_many, r2c_3d_many, c2r_3d_many, filter_diffusion_3d_many,&
filter_poisson_3d_many, filter_diffusion_3d, filter_curl_3d, filter_projection_om_3d,&
filter_multires_om_3d, filter_pressure_3d, r2c_3d_scal, filter_spectrum_3d, &
- filter_laplace_3d
+ filter_laplace_3d, filter_diffusion_scalar_3d
!> plan for fftw "c2c" forward or r2c transform
type(C_PTR) :: plan_forward1, plan_forward2, plan_forward3
@@ -750,6 +750,27 @@ contains
end subroutine filter_diffusion_3d
+ !> Solve diffusion problem in the Fourier space :
+ !! \f{eqnarray*} \frac{\partial f}{\partial t} &=& \nu \Delta f \f}
+ !! @param[in] nudt \f$ \nu\times dt\f$, diffusion coefficient times current time step
+ subroutine filter_diffusion_scalar_3d(nudt)
+
+ real(C_DOUBLE), intent(in) :: nudt
+ integer(C_INTPTR_T) :: i,j,k
+ complex(C_DOUBLE_COMPLEX) :: coeff
+
+ !! mind the transpose -> index inversion between y and z
+ do j = 1,local_resolution(c_Y)
+ do k = 1, fft_resolution(c_Z)
+ do i = 1, local_resolution(c_X)
+ coeff = one/(one + nudt * (kx(i)**2+ky(j)**2+kz(k)**2))
+ dataout1(i,k,j) = coeff*dataout1(i,k,j)
+ end do
+ end do
+ end do
+
+ end subroutine filter_diffusion_scalar_3d
+
subroutine filter_laplace_3d()
integer(C_INTPTR_T) :: i, j, k
@@ -758,7 +779,7 @@ contains
do k = 1, fft_resolution(c_Z)
do i = 1, local_resolution(c_X)
coeff = one/((kx(i)**2+ky(j)**2+kz(k)**2))
- dataout1(i,k,j) = coeff*dataout1(i,k,j)
+ dataout1(i,k,j) = -coeff*dataout1(i,k,j)
end do
end do
end do
diff --git a/hysop/numerics/fftw_f/fftw2py.f90 b/hysop/numerics/fftw_f/fftw2py.f90
index d0168991bb0c357033db2589ca78303c23d9d09e..72a6625ec71e09a16d6ecbb5a5441fe4d2f5af7d 100755
--- a/hysop/numerics/fftw_f/fftw2py.f90
+++ b/hysop/numerics/fftw_f/fftw2py.f90
@@ -242,13 +242,26 @@ contains
!f2py intent(in,out) :: omega_x,omega_y,omega_z
call r2c_3d(omega_x,omega_y,omega_z, ghosts)
-
call filter_diffusion_3d(nudt)
-
call c2r_3d(omega_x,omega_y,omega_z, ghosts)
end subroutine solve_diffusion_3d
+ !> Solve
+ !! \f{eqnarray*} \frac{\partial f}{\partial t} &=& \nu \Delta f \f}
+ !! f being 3D scalar field.
+ subroutine solve_diffusion_scalar_3d(nudt, f, ghosts)
+ real(wp), intent(in) :: nudt
+ real(wp),dimension(:,:,:),intent(inout):: f
+ integer(kind=ip), dimension(3), intent(in) :: ghosts
+ !f2py intent(in,out) :: f
+
+ call r2c_scalar_3d(f, ghosts)
+ call filter_diffusion_scalar_3d(nudt)
+ call c2r_scalar_3d(f, ghosts)
+
+ end subroutine solve_diffusion_scalar_3d
+
!> Perform solenoidal projection to ensure divergence free vorticity field
!! \f{eqnarray*} \omega ' &=& \omega - \nabla\pi \f}
!! omega being a 3D vector field.
diff --git a/hysop/numerics/fftw_f/fftw2py.pyf b/hysop/numerics/fftw_f/fftw2py.pyf
index d4d907e6aa254fe71caed87b5d0e926cec370484..e70d1771e412a027a658e05281afdedb87eb933a 100644
--- a/hysop/numerics/fftw_f/fftw2py.pyf
+++ b/hysop/numerics/fftw_f/fftw2py.pyf
@@ -91,6 +91,11 @@ module fftw2py ! in fftw2py.f90
real(kind=wp) dimension(:,:,:),intent(in,out) :: omega_z
integer(kind=ip) dimension(3),intent(in) :: ghosts
end subroutine solve_diffusion_3d
+ subroutine solve_diffusion_scalar_3d(nudt, f, ghosts)
+ real(kind=wp), intent(in) :: nudt
+ real(kind=wp),dimension(:,:,:),intent(in,out):: f
+ integer(kind=ip), dimension(3), intent(in) :: ghosts
+ end subroutine solve_diffusion_scalar_3d
subroutine projection_om_3d(omega_x,omega_y,omega_z,ghosts) ! in fftw2py.f90:fftw2py
real(kind=wp) dimension(:,:,:),intent(in,out) :: omega_x
real(kind=wp) dimension(:,:,:),intent(in,out) :: omega_y
diff --git a/hysop/numerics/interpolation/interpolation.py b/hysop/numerics/interpolation/interpolation.py
index 0a5bd47e1adccceb976bcccabac856ef1d4f0487..b6fb6bfcba10fd540df8381ce9393cc05d7f6ef0 100644
--- a/hysop/numerics/interpolation/interpolation.py
+++ b/hysop/numerics/interpolation/interpolation.py
@@ -2,8 +2,7 @@
from hysop.tools.enum import EnumFactory
Interpolation = EnumFactory.create('Interpolation',
- ['LINEAR', 'CUBIC', 'CHEBYSHEV',
- 'L4_4', 'M4', 'Mp4'])
+ ['LINEAR', 'L4_4', 'M4', 'Mp4']) # scales interpolators
class MultiScaleInterpolation(object):
pass
diff --git a/hysop/numerics/interpolation/polynomial.py b/hysop/numerics/interpolation/polynomial.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f088ee4b8036d9d9287d039f626175c019c5184
--- /dev/null
+++ b/hysop/numerics/interpolation/polynomial.py
@@ -0,0 +1,841 @@
+import itertools as it
+import numpy as np
+import scipy as sp
+import sympy as sm
+import warnings
+
+try:
+ import flint
+ has_flint = True
+except ImportError:
+ import warnings
+ from hysop.tools.warning import HysopPerformanceWarning
+ msg='Failed to import python-flint module, falling back to slow sympy solver.'
+ warnings.warn(msg, HysopPerformanceWarning)
+
+ flint = None
+ has_flint = False
+
+from hysop.tools.enum import EnumFactory
+from hysop.tools.types import check_instance, InstanceOf, to_tuple
+from hysop.tools.cache import update_cache, load_data_from_cache
+from hysop.tools.io_utils import IO
+from hysop.tools.sympy_utils import tensor_xreplace, tensor_symbol
+from hysop.tools.decorators import debug
+from hysop.tools.warning import HysopCacheWarning
+from hysop.numerics.stencil.stencil_generator import CenteredStencilGenerator, MPQ
+from hysop.numerics.interpolation.interpolation import MultiScaleInterpolation
+
+def _check_matrices(*x):
+ return all(_check_matrix(xi) for xi in x)
+
+def _check_matrix(x):
+ return np.isfinite(np.asarray(x).astype(np.float64)).all()
+
+PolynomialInterpolation = EnumFactory.create('PolynomialInterpolation',
+ ['LINEAR', # requires 0 ghosts (no derivatives required)
+ 'CUBIC', # derivatives order is specified with SpaceDiscretization
+ 'QUINTIC', # derivatives order is specified with SpaceDiscretization
+ 'SEPTIC', # derivatives order is specified with SpaceDiscretization
+ 'NONIC', # derivatives order is specified with SpaceDiscretization
+ 'CUBIC_FDC2', # requires 1 ghosts (estimate derivatives with 2nd order centered fd)
+ 'CUBIC_FDC4', # requires 2 ghosts (estimate derivatives with 4th order centered fd)
+ 'CUBIC_FDC6', # requires 3 ghosts (estimate derivatives with 6th order centered fd)
+ 'QUINTIC_FDC2', # requires 1 ghosts
+ 'QUINTIC_FDC4', # requires 2 ghosts
+ 'QUINTIC_FDC6', # requires 3 ghosts
+ 'SEPTIC_FDC2', # requires 2 ghosts
+ 'SEPTIC_FDC4', # requires 3 ghosts
+ 'SEPTIC_FDC6', # requires 4 ghosts
+ 'NONIC_FDC2', # requires 2 ghosts
+ 'NONIC_FDC4', # requires 3 ghosts
+ 'NONIC_FDC6' # requires 4 ghosts
+ ])
+
+
+class PolynomialInterpolator(object):
+ @classmethod
+ def build_interpolator(cls, pi, dim, fd=None,
+ verbose=False, approximative=False):
+ check_instance(pi, PolynomialInterpolation)
+ kwds = {'dim':dim, 'verbose': verbose, 'approximative': approximative}
+ spi = str(pi)
+ if spi.startswith('LINEAR'):
+ deg=1
+ fd = 2
+ elif spi.startswith('CUBIC'):
+ deg=3
+ elif spi.startswith('QUINTIC'):
+ deg=5
+ elif spi.startswith('SEPTIC'):
+ deg=7
+ elif spi.startswith('NONIC'):
+ deg=9
+ else:
+ msg='Unknown PolynomialInterpolation value {}.'.format(pi)
+ raise NotImplementedError(msg)
+ for i in xrange(1,5):
+ if spi.endswith(str(2*i)):
+ fd=2*i
+ break
+ if (fd is None):
+ msg='Could not determine finite differences order.'
+ raise RuntimeError(msg)
+ obj = cls(deg=deg, fd=fd, **kwds)
+ obj.spi = spi
+ return obj
+
+ @classmethod
+ def cache_file(cls):
+ _cache_dir = IO.cache_path() + '/numerics'
+ _cache_file = _cache_dir + '/polynomial.pklz'
+ return _cache_file
+
+ def __init__(self, dim, deg, fd, approximative=False, verbose=False):
+ """
+ Create a PolynomialInterpolator.
+
+ Parameters
+ ----------
+ dim: int
+ Number of dimensions to interpolate.
+ deg: int or tuple of ints
+ Polynomial degree (1=linear, 3=cubic, 5=quintic, 7=septic, ...)
+ Degree should be odd on each axis.
+ fd: int or tuple of ints
+ Order of centered finite differences used to compute derivatives in each direction.
+ Will affect the number of ghosts of the method.
+ Should be even because this interpolator only use centered dinite differences.
+ approximative: bool
+ Use np.float64 instead of exact fractions to compute weights.
+ verbose: bool
+ Enable or disabled verbosity, default to False.
+
+ Attributes
+ ----------
+ dim: int
+ Number of dimensions to interpolate.
+ deg: tuple of ints
+ Polynomial degree (1=linear, 3=cubic, 5=quintic, 7=septic, ...)
+ Degree should be odd: deg=2k+1
+ fd: tuple of ints
+ Order of centered finite differences stencils used to compute derivatives for
+ each direction.
+ p: tuple of ints
+ Corresponds to deg+1.
+ The total number of polynomial coefficients corresponds to P=p0*p1*...*p(dim-1).
+ P: int
+ The total number of polynomial coefficients P=p0*p1*...*p(dim-1)
+ k: tuple of ints
+ Max derivative order required to compute the polynomial interpolator coefficients
+ in each direction.
+ Also the regularity of the resulting interpolant. Corresponds to (deg-1)/2.
+ ghosts: tuple of ints
+ Return the number of ghosts required by the interpolator on each axis.
+ Corresponds to (k>0)*[fd//2 - 1 + (k+1)//2]
+ deg k (k+1)/2 | FDC2 FDC4 FDC6
+ linear: 1 0 0 | 0 0 0
+ cubic: 3 1 1 | 1 2 3
+ quintic: 5 2 1 | 1 2 3
+ septic: 7 3 2 | 2 3 4
+ nonic: 9 4 2 | 2 3 4
+ n: tuple of ints
+ Corresponds to 2*(ghosts+1), the number of required nodes to generate the
+ polynomial coefficients (in each direction).
+ In total we have N=n0*n1*...*n(dim-1) input nodes.
+
+ G1 G1
+ <-> <->
+ X X X X
+ X P P X
+ X P P X
+ X X X X
+ <----->
+ n1
+ N: int
+ Total number of input nodes N=n0*n1*...*n(dim-1).
+ M: np.ndarray
+ Grid values to polynomial coefficient matrix:
+ M.dot(F.ravel()) will give C.ravel(), coefficients of P(x0,x1,...)
+ N
+ <--------->
+ X X X X X X ^ |f0| ^ |c0| ^
+ X X X X X X | |f1| | |c1| |
+ M = X X X X X X | P F = |f2| | N C = M*F = |c2| | P
+ X X X X X X | |f3| | |c3| |
+ X X X X X X v |f4| | |c4| v
+ |f5| v
+
+ If approximative is set to True, M will contain np.float64
+ Else is will contain rationals.
+
+ See Also
+ --------
+ :class:`PolynomialSubgridInterpolator`: Precompute weights for fixed subgrid
+ interpolation.
+ """
+
+ assert dim>0, 'dim<=0'
+
+ deg = to_tuple(deg)
+ if len(deg)==1:
+ deg*=dim
+ check_instance(deg, tuple, values=int, size=dim)
+
+ fd = to_tuple(fd)
+ if len(fd)==1:
+ fd*=dim
+ check_instance(fd, tuple, values=int, size=dim)
+
+ p = tuple(degi+1 for degi in deg)
+ k = tuple((degi-1)/2 for degi in deg)
+
+ ghosts = ()
+ n = ()
+ for (fdi,ki) in zip(fd,k):
+ if (ki>0):
+ gi = (fdi/2) - 1 + (ki+1)/2
+ else:
+ gi = 0
+ ni = 2*(gi+1)
+ ghosts += (gi,)
+ n += (ni,)
+
+ check_instance(deg, tuple, values=int, size=dim)
+ check_instance(fd, tuple, values=int, size=dim)
+ check_instance(p, tuple, values=int, size=dim)
+ check_instance(k, tuple, values=int, size=dim)
+ check_instance(n, tuple, values=int, size=dim)
+ check_instance(ghosts,tuple, values=int, size=dim)
+ assert all(fdi%2==0 for fdi in fd), 'fd % 2 != 0'
+ assert all(degi%2==1 for degi in deg), 'deg % 2 != 1'
+ assert all(pi%2==0 for pi in p), 'p % 2 != 0'
+ assert all(ni%2==0 for ni in n), 'n % 2 != 0'
+
+ P = np.prod(p, dtype=np.int32)
+ N = np.prod(n, dtype=np.int32)
+
+ self.dim = dim
+ self.deg = deg
+ self.p = p
+ self.P = P
+ self.k = k
+ self.n = n
+ self.N = N
+ self.fd = fd
+ self.ghosts = ghosts
+ self.approximative = approximative
+ self.verbose = verbose
+ self.key = ('PolynomialInterpolator', dim, deg, fd, approximative)
+ self._build_interpolator()
+
+ def _collect_stencils(self):
+ dim = self.dim
+ ghosts = self.ghosts
+ verbose = self.verbose
+ fd = self.fd
+ approximative = self.approximative
+
+ k = self.k
+ n = self.n
+ ghosts = self.ghosts
+
+ if verbose:
+ print '\nCollecting 1D stencils:'
+
+ SG = CenteredStencilGenerator()
+ SG.configure(dim=1, dtype=np.float64)
+ S = {}
+ for direction in xrange(dim):
+ if verbose:
+ print ' Direction {}'.format(direction)
+ Sd = S.setdefault(direction, [])
+ nd = n[direction]
+ kd = k[direction]
+ fdd = fd[direction]
+ gd = ghosts[direction]
+ for i in xrange(kd+1):
+ msg='Failed to compute stencil derivative={}, order={}, origin={}'
+ msg=msg.format(i, fdd, gd)
+ try:
+ if approximative:
+ Si = SG.generate_approximative_stencil(order=fdd, derivative=i)
+ else:
+ Si = SG.generate_exact_stencil(order=fdd, derivative=i)
+ Si.replace_symbols({Si.dx:1})
+ except:
+ print msg
+ raise
+ msg+=' got {}.'.format(Si.coeffs)
+ assert (not Si.is_symbolic()), msg
+ Si = Si.reshape((nd-1,))
+ assert Si.origin == gd
+ Si = Si.coeffs
+ Sd.append(Si)
+ if verbose:
+ print ' {}-th derivative: {}'.format(i,Si)
+ return S
+
+ def _build_stencil(self, dvec):
+ dvec = np.asarray(dvec)
+ k = self.k
+ S = self.S
+ assert dvec.size == self.dim, 'dvec.size != dim'
+ assert all(dvec>=0), 'dvec < 0 => {}'.format(dvec)
+ assert all(di<=ki for (di,ki) in zip(dvec,k)), 'dvec > dmax => {}'.format(dvec)
+
+ Sd = S[0][dvec[0]].copy()
+ for (d,i) in enumerate(dvec[1:],1):
+ Sd = np.tensordot(Sd, S[d][i], axes=0)
+ return Sd
+
+ def _build_interpolator(self):
+ dim = self.dim
+ deg = self.deg
+ k = self.k
+ n = self.n
+ p = self.p
+ ghosts = self.ghosts
+ approximative = self.approximative
+ verbose = self.verbose
+
+ xvals, xvars = tensor_symbol('x', shape=(dim,))
+ fvals, fvars = tensor_symbol('F', n, ghosts)
+ pvals, pvars = tensor_symbol('C', p)
+
+ self.xvals, self.xvars = xvals, xvars
+ self.fvals, self.fvars = fvals, fvars
+ self.pvals, self.pvars = pvals, pvars
+
+ try:
+ data = load_data_from_cache(self.cache_file(), self.key)
+ if (data is not None):
+ (P0, S, M) = data
+ if _check_matrix(M):
+ self.P0 = P0
+ self.S = S
+ self.M = M
+ return
+ except Exception as e:
+ msg='Failed to load data from cache because:\n{}'.format(e)
+ warnings.warn(msg, HysopCacheWarning)
+
+ P0 = 0
+ for idx in it.product(*tuple(range(0,pi) for pi in p)):
+ P0 += pvals[idx] * np.prod(np.power(xvals, idx))
+ self.P0 = P0
+
+ S = self._collect_stencils()
+ self.S = S
+
+ if verbose:
+ print '\nGenerating variables:'
+ print ' *space vars: '
+ print xvals
+ print ' *grid values:'
+ print fvals
+ print ' *polynomial coefficients:'
+ print pvals
+ print ' *polynomial patch:'
+ print P0
+ print '\nBuilding system...'
+
+ eqs = []
+ for dvec in it.product(*tuple(range(0,ki+1) for ki in k)):
+ if verbose:
+ print ' => derivative {}'.format(dvec)
+
+ dP0 = P0
+ for i,deg in enumerate(dvec):
+ dP0 = sm.diff(dP0, xvals[i], deg)
+
+ stencil = self._build_stencil(dvec)
+ if verbose:
+ print ' stencil:'
+ print stencil
+
+ for idx in it.product(*tuple(range(gi,gi+2) for gi in ghosts)):
+ if verbose:
+ print ' -> point {}'.format(idx)
+
+ pos = np.asarray(idx)-ghosts
+ pos = dict(zip(xvals, pos))
+ eq = dP0.xreplace(pos)
+
+ for offset in it.product(*tuple(range(-gi, gi+1) for gi in ghosts)):
+ fidx = tuple(np.add(idx, offset))
+ sidx = tuple(np.add(offset, ghosts))
+ eq -= fvals[fidx]*stencil[sidx]
+
+ eqs.append(eq)
+ if verbose:
+ print ' {}'.format(eq)
+
+ # Build system such that A*c = B*f where c are the polynomial coefficients and
+ # f the node values
+ dtype = (np.float64 if approximative else object)
+ A = np.empty((self.P,self.P), dtype=dtype)
+ B = np.empty((self.P,self.N), dtype=dtype)
+ assert len(eqs)==self.P
+ for (i,eq) in enumerate(eqs):
+ for (j,ci) in enumerate(pvars):
+ A[i,j] = +eq.coeff(ci)
+ for (j,fi) in enumerate(fvars):
+ B[i,j] = -eq.coeff(fi)
+
+ # C = Ainv*B*f = M*f
+ if verbose:
+ print '\nSolving system...'
+
+ if approximative:
+ Ainv = np.linalg.inv(A)
+ elif has_flint:
+ coeffs = list(flint.fmpq(x.p, x.q) for x in A.ravel())
+ Afmpq = flint.fmpq_mat(*(A.shape+(coeffs,)))
+ Afmpq_inv = Afmpq.inv()
+ coeffs = list(sm.Rational(sm.Integer(x.p), sm.Integer(x.q)) for x in Afmpq_inv.entries())
+ Ainv = np.asarray(coeffs).reshape(A.shape)
+ else:
+ # /!\ sympy is really slow
+ Ainv = np.asarray(sm.Matrix(A).inv())
+
+ if verbose:
+ print '\nBuilding matrix...'
+ M = Ainv.dot(B)
+ self.M = M
+ update_cache(self.cache_file(), self.key, (P0,S,M))
+
+
+ def interpolate(self, fvals):
+ """Return the polynomial interpolating input node values"""
+ fvals = np.asarray(fvals)
+ assert fvals.shape == self.fvals.shape
+ pvals = self.M.dot(fvals.ravel())
+ P0 = self.P0.xreplace(dict(zip(self.pvars, pvals)))
+ return sm.utilities.lambdify(self.xvars, P0)
+
+ def generate_subgrid_interpolator(self, grid_ratio, dtype=None):
+ return PolynomialSubgridInterpolator(interpolator=self,
+ grid_ratio=grid_ratio, dtype=dtype)
+
+ def __hash__(self):
+ objs = (self.dim, self.deg, self.fd, self.approximative)
+ return hash(objs)
+
+
+class PolynomialSubgridInterpolator(object):
+ def __init__(self, interpolator, grid_ratio, dtype=None):
+ """
+ Create a PolynomialSubgridInterpolator from a PolynomialInterpolator and a number of
+ subrid points.
+
+ Parameters
+ ----------
+ interpolator: PolynomialInterpolator
+ Interpolant used to compute weights.
+ grid_ratio: tuple of int
+ Tuple of integers representing the ratio between the coarse and the fine grid.
+ dtype: np.dtype
+ Force to cast dtype for all matrices (interpolator.M may contain rationals).
+
+ Attributes
+ ----------
+ dim: int
+ Number of dimensions to interpolate (same as interpolator.dim).
+ ghosts: tuple of int
+ Number of required ghosts.
+ n: tuple of int
+ Corresponds to 2*(ghosts+1), the number of required nodes to generate the
+ polynomial coefficients (same as interpolator.n).
+ N: int
+ Total number of input nodes N including ghosts (same as interpolator.N).
+ N = n0*n1*...*n[dim-1]
+ s: tuple of int
+ Corresponds to grid_ratio + 1, number of points of the subgrid in each directions.
+ Example for a grid ratio=(3,3), we have s=(4,4):
+ O=coarse grid nodes, X=fine grid nodes
+
+ Coarse grid: Fine grid:
+
+ ^ O-----O ^ O X X O
+ | | | | X X X X
+ 1 | | | 4 | X X X X
+ v O-----O v O X X O
+ <-----> <----->
+ 1 4
+ S: int
+ Represents the number of fine grid points contained in a coarse grid cell.
+ S = s0*s1*...*s[dim-1]
+ gr: tuple of int
+ Corresponds to grid_ratio, number of points of the subgrid in each directions,
+ minus one.
+ Example for a grid ratio=(3,3), we have gr=(3,3) and s=(4,4):
+ O=coarse grid nodes, X=fine grid nodes, -=excluded find grid nodes
+
+ Coarse grid: Fine grid:
+
+ ^ O-----O ^ O X X O ^
+ | | | gr0 | X X X - | s0
+ 1 | | | v X X X - |
+ v O-----O O - - O v
+ <-----> <--->
+ 1 gr1
+ GR: int
+ Represents the number of fine grid points contained in a coarse grid cell exluding
+ right most points.
+ GR = gr0*gr1*...*gr[dim-1]
+ W: np.ndarray
+ Pre computed weights to interpolate directly from coarse to fine grid.
+ Let F be the vector of N known coarse grid node values (including required
+ ghosts).
+ Let G be the vector of S unknown fine grid node values.
+
+ N
+ <--------->
+ X X X X X X ^ |g0| ^
+ X X X X X X | |f0| ^ |g1| |
+ X X X X X X | |f1| | |g2| |
+ X X X X X X | |f2| | |g3| |
+ W = X X X X X X | S F= |f3| | N G = W*F = |g4| | S
+ X X X X X X | |f4| | |g5| |
+ X X X X X X | |f5| v |g6| |
+ X X X X X X | |g7| |
+ X X X X X X v |g8| v
+
+ Will contain the same data type as intepolator.M if dtype is not passed,
+ else W will be computed from user given dtype.
+
+ Wr: np.ndarray
+ Reduced W that exludes rightmost output points of ndimensional output vector.
+
+ Pre computed weights to interpolate directly from coarse to inner fine grid.
+ Let F be the vector of N known coarse grid node values (including required ghosts).
+ Let G be the vector of GR unknown fine inner grid node values (see gr attribute).
+
+ N
+ <--------->
+ X X X X X X ^ |g0| ^
+ X X X X X X | |f0| ^ |g1| |
+ X X X X X X | |f1| | |g2| |
+ X X X X X X | |f2| | |g3| |
+ Wr = X X X X X X | GR F= |f3| | N G = W*F = |g4| | GR
+ X X X X X X | |f4| | |g5| |
+ X X X X X X | |f5| v |g6| |
+ X X X X X X | |g7| |
+ X X X X X X v |g8| v
+
+ Same data type as W.
+ """
+ check_instance(interpolator, PolynomialInterpolator)
+ check_instance(grid_ratio, tuple, values=int, size=interpolator.dim, minval=1)
+
+ p = interpolator.p
+ n = interpolator.n
+ P = interpolator.P
+ N = interpolator.N
+ M = interpolator.M
+ ghosts = interpolator.ghosts
+
+ gr = grid_ratio
+ GR = np.prod(gr, dtype=np.int32)
+ del grid_ratio
+
+ s = tuple(gri+1 for gri in gr)
+ S = np.prod(s, dtype=np.int32)
+
+ dim = interpolator.dim
+ key = ('PolynomialSubgridInterpolator', interpolator.key, gr, str(dtype))
+
+ self.p = p
+ self.P = p
+ self.s = s
+ self.S = S
+ self.n = n
+ self.N = N
+ self.gr = gr
+ self.GR = GR
+ self.ghosts = interpolator.ghosts
+ self.dim = dim
+ self.interpolator = interpolator
+ self.key = key
+
+ cache_file = interpolator.cache_file()
+ try:
+ data = load_data_from_cache(cache_file, key)
+ if (data is not None):
+ W = data
+ if _check_matrix(W):
+ self.W = data
+ return
+ except Exception as e:
+ msg='Failed to load data from cache because:\n{}'.format(e)
+ warnings.warn(msg, HysopCacheWarning)
+
+ X = tuple(np.asarray(tuple(sm.Rational(j,gr) for j in xrange(0,si)))
+ for i,(gr,si) in enumerate(zip(gr, s)))
+ V = np.vander(X[0], N=p[0], increasing=True)
+ for i in xrange(1, dim):
+ Vi = np.vander(X[i], N=p[i], increasing=True)
+ V = np.multiply.outer(V,Vi)
+
+ even_axes = range(0,V.ndim,2)
+ odd_axes = range(1,V.ndim,2)
+ axes = even_axes + odd_axes
+
+ V = np.transpose(V, axes=axes).copy()
+ assert V.shape[:dim] == s
+ assert V.shape[dim:] == p
+ V = V.reshape((S,P))
+ W = V.dot(M)
+ assert W.shape == (S,N)
+
+ if (dtype is not None):
+ W = W.astype(dtype)
+
+ update_cache(cache_file, key, W)
+ self.W = W
+
+ def __call__(self, F):
+ return self.W.dot(F.ravel()).reshape(self.s)
+
+ def generate_subgrid_restrictor(self):
+ return PolynomialSubgridRestrictor(subgrid_interpolator=self)
+
+ @property
+ def Wr(self):
+ assert self.W.shape == (self.S, self.N)
+ view = (slice(0,-1,None),)*self.dim + (slice(None, None, None),)*self.dim
+ Wr = self.W.reshape(self.s+self.n)[view].reshape(self.GR, self.N).copy()
+ return Wr
+
+ def __hash__(self):
+ objs = (self.interpolator, self.gr)
+ return hash(objs)
+
+
+class PolynomialSubgridRestrictor(object):
+ def __init__(self, subgrid_interpolator):
+ """
+ Create a PolynomialSubgridRestrictor from a PolynomialSubgridInterpolator.
+
+ Parameters
+ ----------
+ subgrid_interpolator: PolynomialSubgridInterpolator
+ Interpolant used to compute restrictor weights.
+
+ Attributes
+ ----------
+ g: tuple of int
+ Corresponds to (n+1)*s
+ G: int
+ Corresponds to g[0]*g[1]*...g[dim-1]
+ R: np.ndarray
+ Restrictor weights.
+ origin: tuple of int
+ Origin of the generated stencil.
+ Rr: np.ndarray
+ Restrictor weights excluding leftmost and rightmost points.
+ ghosts:
+ Corresponds to origin - 1, which is also Rr origin.
+ """
+ check_instance(subgrid_interpolator, PolynomialSubgridInterpolator)
+ dim = subgrid_interpolator.dim
+ n = subgrid_interpolator.n
+ s = subgrid_interpolator.s
+ gr = subgrid_interpolator.gr
+ GR = subgrid_interpolator.GR
+ W = subgrid_interpolator.W
+ g = tuple(ni*gri+1 for (ni,gri) in zip(n,gr))
+ G = np.prod(g, dtype=np.int64)
+ assert all(gi%2==1 for gi in g)
+ origin = tuple(gi/2 for gi in g)
+ gvals, gvars = tensor_symbol('g',g,origin)
+ I = 0
+ for idx in np.ndindex(*gr):
+ mask = tuple(slice(i, max(2,i+ni*gri), gri) for (i,ni,gri) in zip(idx, n, gr))
+ target = tuple(gri-i for (i,gri) in zip(idx,gr))
+ F = gvals[mask]
+ Ii = W.dot(F.ravel()).reshape(s)[target]
+ I += Ii
+ R = np.ndarray(shape=g, dtype=object)
+ for idx in np.ndindex(*g):
+ R[idx] = I.coeff(gvals[idx])
+
+ view = (slice(1,-1,None),)*dim
+ Rr = R[view]
+ ghosts = tuple(oi-1 for oi in origin)
+
+ self.g = g
+ self.G = G
+ self.R = R
+ self.Rr = Rr
+ self.origin = origin
+ self.ghosts = ghosts
+ self.n = n
+ self.s = s
+ self.GR = GR
+ self.gr = gr
+ self.subgrid_interpolator = subgrid_interpolator
+
+
+if __name__ == '__main__':
+ np.set_printoptions(precision=4, linewidth=1e8, threshold=1e8,
+ formatter={'float': lambda x: "{0:+0.3f}".format(x)})
+
+ # 2D tests
+ grid_ratio = (2,2)
+ F = [[1,1],
+ [1,1]]
+ F = np.asarray(F)
+
+ #print 'Solving bilinear...'
+ #PI = PolynomialInterpolator(dim=2, deg=1, fd=2, verbose=False)
+ #GI0 = PI.generate_subgrid_interpolator(grid_ratio=grid_ratio)
+ #GI1 = PI.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Bilinear (Rational)'
+ #print GI0(F)
+ #print
+ #print 'Bilinear (np.float64)'
+ #print GI1(F)
+ #print
+
+ #F = [[0,0,0,0],
+ #[0,1,1,0],
+ #[0,1,1,0],
+ #[0,0,0,0]]
+ #F = np.asarray(F)
+
+ #print 'Solving bicubic2...'
+ #PI0 = PolynomialInterpolator(dim=2, deg=3, fd=2, verbose=False)
+ #GI0 = PI0.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Bicubic (FDC2)'
+ #print GI0(F)
+ #print
+
+ #print 'Solving biquintic2...'
+ #PI1 = PolynomialInterpolator(dim=2, deg=5, fd=2, verbose=False)
+ #GI1 = PI1.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Biquintic (FDC2)'
+ #print GI1(F)
+ #print
+
+ #F = [[0,1,1,0],
+ #[0,1,1,0]]
+ #F = np.asarray(F)
+
+ #print 'Solving linear/cubic...'
+ #PI0 = PolynomialInterpolator(dim=2, deg=(1,3), fd=2, verbose=False)
+ #GI0 = PI0.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Linear/Cubic (FDC2)'
+ #print GI0(F)
+ #print
+
+ #F = [[0,0],
+ #[1,1],
+ #[1,1],
+ #[0,0]]
+ #F = np.asarray(F)
+
+ #print 'Solving cubic/linear...'
+ #PI0 = PolynomialInterpolator(dim=2, deg=(3,1), fd=2, verbose=False)
+ #GI0 = PI0.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Cubic/Linear (FDC2)'
+ #print GI0(F)
+ #print
+
+
+ #F = [[0,0,0,0,0,0],
+ #[0,0,0,0,0,0],
+ #[0,0,1,1,0,0],
+ #[0,0,1,1,0,0],
+ #[0,0,0,0,0,0],
+ #[0,0,0,0,0,0]]
+ #F = np.asarray(F)
+
+ #print 'Solving bicubic4...'
+ #PI0 = PolynomialInterpolator(dim=2, deg=3, fd=4, verbose=False)
+ #GI0 = PI0.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Bicubic (FDC4)'
+ #print GI0(F)
+ #print
+
+ #print 'Solving biquintic4...'
+ #PI1 = PolynomialInterpolator(dim=2, deg=5, fd=4, verbose=False)
+ #GI1 = PI1.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Biquintic (FDC4)'
+ #print GI1(F)
+ #print
+
+ #print 'Solving biseptic2...'
+ #PI2 = PolynomialInterpolator(dim=2, deg=7, fd=2, verbose=False,
+ #approximative=(not has_flint))
+ #GI2 = PI2.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Biseptic (FDC2)'
+ #print GI2(F)
+ #print
+
+ #print 'Solving binonic2...'
+ #PI3 = PolynomialInterpolator(dim=2, deg=9, fd=2, verbose=False,
+ #approximative=(not has_flint))
+ #GI3 = PI3.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'Binonic (FDC2)'
+ #print GI3(F)
+ #print
+
+ #print 'Solving septic2/nonic2 ...'
+ #PI4 = PolynomialInterpolator(dim=2, deg=(7,9), fd=2, verbose=False,
+ #approximative=(not has_flint))
+ #GI4 = PI4.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'septic/nonic (FDC2)'
+ #print GI4(F)
+ #print
+
+ #print 'Solving septic2/quintic4 ...'
+ #PI5 = PolynomialInterpolator(dim=2, deg=(7,5), fd=(2,4), verbose=False,
+ #approximative=(not has_flint))
+ #GI5 = PI5.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print 'septic/nonic (FDC2/FDC4)'
+ #print GI5(F)
+ #print
+
+ # 3D test
+ #grid_ratio = (2,2,2)
+ #print 'Solving trilinear...'
+ #PI = PolynomialInterpolator(dim=3, deg=1, fd=2, verbose=False)
+ #GI0 = PI.generate_subgrid_interpolator(grid_ratio=grid_ratio)
+ #print
+
+ #print 'Solving tricubic2...'
+ #PI0 = PolynomialInterpolator(dim=3, deg=3, fd=2, verbose=False)
+ #GI0 = PI0.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print
+
+ #print 'Solving triquintic2...'
+ #PI0 = PolynomialInterpolator(dim=3, deg=5, fd=2, verbose=False,
+ #approximative=(not has_flint))
+ #GI0 = PI0.generate_subgrid_interpolator(grid_ratio=grid_ratio, dtype=np.float64)
+ #print
+
+ # Delaurier-Dubuc interpolating wavelets
+ from matplotlib import pyplot as plt
+ grid_ratio = (32,)
+ fig, axes = plt.subplots(ncols=2, nrows=1)
+ #for k,(deg, sdeg) in enumerate(zip((1,3,5,7),('cubic','quintic','septic','nonic'))):
+ #print k, deg, sdeg
+ for k,(deg, sdeg) in enumerate(zip((1,3,),('linear','cubic'))):
+ ax = axes[k]
+ for fd in (2,4,6):
+ PI = PolynomialInterpolator(dim=1, deg=deg, fd=fd, verbose=False)
+ SI = PI.generate_subgrid_interpolator(grid_ratio=grid_ratio)
+ SR = SI.generate_subgrid_restrictor()
+ X = np.linspace(-SR.n[0]/2, +SR.n[0]/2, SR.g[0])
+ if (k==0):
+ ax.plot(X, SR.R, label='{}'.format(sdeg))
+ break
+ else:
+ ax.plot(X, SR.R, label='{}_fdc{}'.format(sdeg, fd))
+ ax.legend()
+
+ ax.plot(X, np.zeros(SR.g[0]), '--')
+ plt.show()
+
diff --git a/hysop/numerics/remesh/remesh.py b/hysop/numerics/remesh/remesh.py
index bf2c38bd199f757eb93eb1be004ff448814a2da7..c830e0d1dbce0a9c7e844a4b25693e1987a28a3e 100644
--- a/hysop/numerics/remesh/remesh.py
+++ b/hysop/numerics/remesh/remesh.py
@@ -1,87 +1,101 @@
from hysop.constants import __VERBOSE__, __DEBUG__
-from hysop.tools.enum import EnumFactory
+from hysop.tools.enum import EnumFactory
from hysop.tools.types import check_instance
from hysop.numerics.remesh.kernel_generator import Kernel, SymmetricKernelGenerator
-Remesh = EnumFactory.create('Remesh',
- ['L1_0', 'L2_1','L2_2','L4_2','L4_4','L6_4','L6_6','L8_4', # lambda remesh kernels
- 'L2_1s','L2_2s','L4_2s','L4_4s','L6_4s','L6_6s','L8_4s', # splitted lambda remesh kernels
- 'Mp4', 'Mp6', 'Mp8', # Mprimes kernels: Mp4 = M'4 = L2_1 and Mp6 = M'6 = L4_2
+Remesh = EnumFactory.create(
+ 'Remesh',
+ ['L1_0', 'L2_1', 'L2_2', 'L4_2', 'L4_4', 'L6_4', 'L6_6', 'L8_4', # lambda remesh kernels
+ 'L2_1s', 'L2_2s', 'L4_2s', 'L4_4s', 'L6_4s', 'L6_6s', 'L8_4s', # splitted lambda remesh kernels
+ 'Mp4', 'Mp6', 'Mp8', # Mprimes kernels: Mp4 = M'4 = L2_1 and Mp6 = M'6 = L4_2
+ 'M4', 'M8', # M kernels
'O2', 'O4', # Corrected kernels, allow a large CFL number
'L2', # Corrected and limited lambda 2
])
+
class RemeshKernelGenerator(SymmetricKernelGenerator):
- def configure(self,n):
- return super(RemeshKernelGenerator,self).configure(n=n, H=None)
+ def configure(self, n):
+ return super(RemeshKernelGenerator, self).configure(n=n, H=None)
+
class RemeshKernel(Kernel):
def __init__(self, moments, regularity,
- verbose = __DEBUG__,
- split_polys=False,
- override_cache=False):
+ verbose=__DEBUG__,
+ split_polys=False,
+ override_cache=False):
generator = RemeshKernelGenerator(verbose=verbose)
generator.configure(n=moments)
kargs = generator.solve(r=regularity, override_cache=override_cache,
- split_polys=split_polys, no_wrap=True)
+ split_polys=split_polys, no_wrap=True)
- super(RemeshKernel,self).__init__(**kargs)
+ super(RemeshKernel, self).__init__(**kargs)
@staticmethod
def from_enum(remesh):
check_instance(remesh, Remesh)
remesh = str(remesh)
- assert remesh[0]=='L' and (remesh!='L2'), \
- 'Only lambda remesh kernels are supported.'
- remesh=remesh[1:]
- if remesh[-1] == 's':
- remesh = remesh[:-1]
- split_polys=True
+ assert remesh[0] == 'L' and (remesh != 'L2') or (remesh in ('M4', 'M8')), \
+ 'Only lambda remesh kernels are supported.'
+ if remesh in ('M4', 'M8'):
+ # given M4 or M8 kernels
+ from hysop.deps import sm
+ x = sm.abc.x
+ if remesh == 'M4':
+ M4 = (sm.Poly((1/sm.Rational(6))*((2-x)**3-4*(1-x)**3), x),
+ sm.Poly((1/sm.Rational(6))*((2-x)**3), x))
+ return Kernel(n=2, r=4, deg=3, Ms=2, Mh=None, H=None, remesh=True,
+ P=(M4[1].subs(x, -x), M4[0].subs(x, -x), M4[0], M4[1]))
else:
- split_polys=False
- remesh = [int(x) for x in remesh.split('_')]
- assert len(remesh) == 2
- assert remesh[0] >= 1
- assert remesh[1] >= 0
- return RemeshKernel(remesh[0], remesh[1], split_polys=split_polys)
+ remesh = remesh[1:]
+ if remesh[-1] == 's':
+ remesh = remesh[:-1]
+ split_polys = True
+ else:
+ split_polys = False
+ remesh = [int(x) for x in remesh.split('_')]
+ assert len(remesh) == 2
+ assert remesh[0] >= 1
+ assert remesh[1] >= 0
+ return RemeshKernel(remesh[0], remesh[1], split_polys=split_polys)
def __str__(self):
return 'RemeshKernel(n={}, r={}, split={})'.format(self.n, self.r, self.poly_splitted)
-if __name__=='__main__':
+if __name__ == '__main__':
import numpy as np
from matplotlib import pyplot as plt
- for i in xrange(1,5):
+ for i in xrange(1, 5):
p = 2*i
kernels = []
- for r in [1,2,4,8]:
+ for r in [1, 2, 4, 8]:
try:
- kernel = RemeshKernel(p,r)
+ kernel = RemeshKernel(p, r)
kernels.append(kernel)
except RuntimeError:
- print 'Solver failed for p={} and r={}.'.format(p,r)
+ print 'Solver failed for p={} and r={}.'.format(p, r)
- if len(kernels)==0:
+ if len(kernels) == 0:
continue
k0 = kernels[0]
fig = plt.figure()
plt.xlabel(r'$x$')
- plt.ylabel(r'$\Lambda_{'+'{},{}'.format(p,'r')+'}$')
- X = np.linspace(-k0.Ms-1,+k0.Ms+1,1000)
- s = plt.subplot(1,1,1)
- for i,k in enumerate(kernels):
- s.plot(X,k(X),label=r'$\Lambda_{'+'{},{}'.format(p,k.r)+'}$')
- s.plot(k0.I,k0.H,'or')
+ plt.ylabel(r'$\Lambda_{'+'{},{}'.format(p, 'r')+'}$')
+ X = np.linspace(-k0.Ms-1, +k0.Ms+1, 1000)
+ s = plt.subplot(1, 1, 1)
+ for i, k in enumerate(kernels):
+ s.plot(X, k(X), label=r'$\Lambda_{'+'{},{}'.format(p, k.r)+'}$')
+ s.plot(k0.I, k0.H, 'or')
axe_scaling = 0.10
ylim = s.get_ylim()
Ly = ylim[1] - ylim[0]
- s.set_ylim(ylim[0]-axe_scaling*Ly,ylim[1]+axe_scaling*Ly)
+ s.set_ylim(ylim[0]-axe_scaling*Ly, ylim[1]+axe_scaling*Ly)
s.legend()
plt.show(block=True)
diff --git a/hysop/numerics/splitting/strang.py b/hysop/numerics/splitting/strang.py
index 4f47d4c197ad214110b99ad0efbdc4c3aa2d5556..3d9fbec979d86687ae6ec43c3d5000e9d166326f 100644
--- a/hysop/numerics/splitting/strang.py
+++ b/hysop/numerics/splitting/strang.py
@@ -14,10 +14,10 @@ class StrangSplitting(DirectionalSplitting):
extra_kwds=extra_kwds, **kargs)
self.spatial_order = order
- check_instance(order, StrangOrder)
- if order == StrangOrder.STRANG_FIRST_ORDER:
+ check_instance(order, (StrangOrder, int))
+ if (order==1) or (order==StrangOrder.STRANG_FIRST_ORDER):
order = 1
- elif order == StrangOrder.STRANG_SECOND_ORDER:
+ elif (order==2) or (order==StrangOrder.STRANG_SECOND_ORDER):
order = 2
else:
msg='Unsupported spatial order requested {}.'
diff --git a/hysop/numerics/splitting/test/test_strang.py b/hysop/numerics/splitting/test/test_strang.py
index ac6048a007526bf67185159abb49987678dbf953..b6c543fb082f7523ca16d127dc3dc88b3f9c51cf 100644
--- a/hysop/numerics/splitting/test/test_strang.py
+++ b/hysop/numerics/splitting/test/test_strang.py
@@ -81,8 +81,6 @@ class TestStrang(object):
problem.insert(splitting)
problem.insert(poisson)
problem.build()
-
- problem.display()
problem.finalize()
def test_strang_2d(self, n=33):
diff --git a/hysop/numerics/stencil/stencil.py b/hysop/numerics/stencil/stencil.py
index d88df37cadddfd9a3ebfc8a4926e8226e8f16635..5cbb22ca253901e3cd0afac320507d5023b7dc94 100644
--- a/hysop/numerics/stencil/stencil.py
+++ b/hysop/numerics/stencil/stencil.py
@@ -17,7 +17,8 @@ class Stencil(object):
"""
def __init__(self, coeffs, origin, order,
- dx=sm.Symbol('dx'), factor=1, error=None):
+ dx=sm.Symbol('dx'), factor=1, error=None,
+ delete_zeros=True):
"""
Stencil used for finite differences schemes (n-dimensional).
@@ -87,10 +88,31 @@ class Stencil(object):
self.origin = origin[0] if origin.size==1 else origin
self.order = order[0] if order.size==1 else order
self.factor = factor
- self.coeffs = self._delete_zeros(coeffs)
+ if delete_zeros:
+ coeffs = self._delete_zeros(coeffs)
+
+ self.coeffs = coeffs
self._update_attributes()
+ def reshape(self, new_shape):
+ """Reshape a stencil by adding zeros."""
+ new_shape = np.asarray(new_shape)
+ shape = np.asarray(self.shape)
+ assert (new_shape.ndim==shape.ndim)
+ assert (new_shape>=shape).all()
+ assert ((new_shape-shape)%2 == 0).all()
+ zeros = (new_shape-shape)/2
+ slc = tuple(slice(z,z+s,1) for (z,s) in zip(zeros, shape))
+
+ new_origin = zeros + self.origin
+ new_coeffs = np.zeros(shape=new_shape, dtype=self.coeffs.dtype)
+ new_coeffs[slc] = self.coeffs
+ return self.__class__(coeffs=new_coeffs, origin=new_origin,
+ order=self.order, dx=self.dx, factor=self.factor, error=self.error,
+ delete_zeros=False)
+
+
def has_factor(self):
return (self.factor!=1)
@@ -117,7 +139,7 @@ class Stencil(object):
sdim = self.dim
assert sdim<=adim, 'Stencil dimension greater than array dimension.'
assert set(symbols.keys())==self.variables(), 'Missing symbols {}.'.format(self.variables()-set(symbols.keys()))
- out = first_not_None(out, np.empty_like(a))
+ out = first_not_None(out, np.empty_like(a[iview]))
axis = first_not_None(to_tuple(axis), range(adim)[-sdim:])
assert len(axis) == sdim
assert out.ndim == a.ndim
@@ -169,7 +191,7 @@ class Stencil(object):
ldel = mask[laccess].all()
rdel = mask[raccess].all()
if ldel:
- keep_mask[laccess] = False
+ keep_mask[tuple(laccess)] = False
if dim==1:
self.origin-=1
else:
@@ -177,7 +199,7 @@ class Stencil(object):
shape[d]-=1
if rdel:
shape[d]-=1
- keep_mask[raccess] = False
+ keep_mask[tuple(raccess)] = False
coeffs = coeffs[keep_mask].reshape(shape)
return coeffs
@@ -392,7 +414,7 @@ class CenteredStencil(Stencil):
"""
def __init__(self, coeffs, origin, order,
- dx=sm.Symbol('dx'), factor=1, error=None):
+ dx=sm.Symbol('dx'), factor=1, error=None, **kwds):
"""
Centered stencil used for finite abitrary dimension differences.
@@ -407,7 +429,7 @@ class CenteredStencil(Stencil):
print origin
print (shape-1)/2
raise ValueError('Origin is not centered!')
- super(CenteredStencil,self).__init__(coeffs, origin, order, dx, factor, error)
+ super(CenteredStencil,self).__init__(coeffs, origin, order, dx, factor, error, **kwds)
def is_centered(self):
return True
diff --git a/hysop/numerics/stencil/stencil_generator.py b/hysop/numerics/stencil/stencil_generator.py
index 2e38546b61e6f1125ef6b1f35c7c5f3849eca855..7bd1e91f5e42fc32a65e4db2ee940d6417690cd5 100644
--- a/hysop/numerics/stencil/stencil_generator.py
+++ b/hysop/numerics/stencil/stencil_generator.py
@@ -4,11 +4,11 @@
* :class:`~hysop.numerics.stencil.StencilGenerator`
"""
-
+import fractions
from hysop.deps import it, np, sp, sm, os, copy, math, gzip, pickle
from hysop.tools.misc import prod
from hysop.tools.io_utils import IO
-from hysop.tools.numerics import MPQ, MPZ, MPFR, F2Q, mpqize
+from hysop.tools.numerics import MPQ, MPZ, MPFR, F2Q, mpqize, mpq, mpz
from hysop.tools.types import extend_array
from hysop.tools.cache import update_cache, load_data_from_cache
from hysop.tools.sympy_utils import tensor_symbol, tensor_xreplace, \
@@ -16,6 +16,13 @@ from hysop.tools.sympy_utils import tensor_symbol, tensor_xreplace, \
from hysop.numerics.stencil.stencil import Stencil, CenteredStencil
+try:
+ import flint
+ has_flint = True
+except ImportError:
+ flint = None
+ has_flint = False
+
class StencilGeneratorConfiguration(object):
def __init__(self):
@@ -41,7 +48,7 @@ class StencilGeneratorConfiguration(object):
def configure(self, dim=None, dtype=None, dx=None, user_eqs=None,
derivative=None, order=None,
- mask=None,mask_type=None):
+ mask=None, mask_type=None):
"""
Configure the stencil generator.
"""
@@ -121,8 +128,8 @@ class StencilGeneratorConfiguration(object):
for k in self.user_eqs:
if not isinstance(k,sm.Symbol):
raise TypeError('Invalid type for key {} in user_eqs!'.format(k))
- if (self.derivative<1).any():
- raise ValueError('derivative < 1!')
+ if (self.derivative<0).any():
+ raise ValueError('derivative < 0!')
if (self.order<1).any():
raise ValueError('order < 1!')
@@ -162,6 +169,24 @@ class StencilGeneratorConfiguration(object):
raise NotImplementedError('Mask not implemented yet!')
return mask
+ def __str__(self):
+ ss=\
+'''
+StencilGeneratorConfiguration
+ dim: {}
+ dtype: {}
+ dx: {}
+ user_eqs: {}
+ derivative: {}
+ order: {}
+ mask_type: {}
+ mask: {}
+ shape: {}
+'''.format(self.dim, self.dtype, self.dx, self.user_eqs,
+ self.derivative, self.order, self.mask_type, self._mask,
+ self.shape())
+ return ss
+
class StencilGenerator(object):
"""
@@ -312,42 +337,67 @@ class StencilGenerator(object):
if (dim!=1):
raise ValueError('Bad dimension for approximation stencil generation!')
- if dtype not in [np.float16, np.float32, np.float64]:
+
+ if (has_flint):
+ solve_dtype = flint.fmpq
+ elif dtype not in [np.float16, np.float32, np.float64]:
solve_dtype = np.float64
else:
solve_dtype = dtype
-
+
dx = config.dx[0]
k = config.derivative[0]
order = config.order[0]
-
+
N = config.shape()[0]
origin = StencilGenerator._format_origin(origin,N)
L = config.L(origin)
R = config.R(origin)
-
- A = np.zeros((N,N),dtype=solve_dtype)
- b = np.zeros(N,dtype=solve_dtype)
+
+ if k == 0:
+ return Stencil([1],[0],0,dx=dx,error=None)
+
+ A = np.empty((N,N),dtype=solve_dtype)
+ b = np.empty(N,dtype=solve_dtype)
for i in xrange(N):
- b[i] = solve_dtype(i==k)
+ b[i] = solve_dtype(long(i==k))
for j in xrange(N):
- A[i,j] = solve_dtype(j-origin)**i
+ A[i,j] = solve_dtype(long((j-origin)**i))
try:
- S = sp.linalg.solve(A,b,overwrite_a=True,overwrite_b=True)
- S *= math.factorial(k)
+ if has_flint:
+ coeffs = A.ravel()
+ Afmpq = flint.fmpq_mat(*(A.shape+(coeffs,)))
+ Afmpq_inv = Afmpq.inv()
+ Ainv = np.asarray(Afmpq_inv.entries()).reshape(A.shape)
+ S = Ainv.dot(b)
+ else:
+ S = sp.linalg.solve(A,b,overwrite_a=True,overwrite_b=True)
except:
print '\nError: Cannot generate stencil (singular system).\n'
raise
- if dtype!=solve_dtype:
- if dtype==MPQ:
- import fractions
- from hysop.tools.numerics import mpq
- def convert(x):
- frac = fractions.Fraction(x).limit_denominator((1<<32)-1)
- return mpq(frac.numerator, frac.denominator)
+ S *= math.factorial(k)
+
+ actual_dtype = type(S.ravel()[0])
+ target_dtype = dtype
+ if actual_dtype != target_dtype:
+ if target_dtype in [np.float16, np.float32, np.float64]:
+ if has_flint and (actual_dtype is flint.fmpq):
+ def convert(x):
+ return target_dtype(float(long(x.p)) / float(long(x.q)))
+ S = np.vectorize(convert)(S)
+ else:
+ S = S.astype(target_dtype)
+ elif target_dtype==MPQ:
+ if has_flint and (actual_dtype is flint.fmpq):
+ def convert(x):
+ return mpq(mpz(x.p.str()), mpz(x.q.str()))
+ else:
+ def convert(x):
+ frac = fractions.Fraction(x).limit_denominator((1<<32)-1)
+ return mpq(frac.numerator, frac.denominator)
S = np.vectorize(convert)(S)
else:
RuntimeError('Type conversion not implemented yet.')
@@ -364,6 +414,7 @@ class StencilGenerator(object):
"""
config = self._config.copy()
config.configure(**kargs)
+ config._check_and_raise()
dx = config.dx
dim = config.dim
@@ -382,11 +433,15 @@ class StencilGenerator(object):
user_eqs = config.user_eqs
+ if all(derivative == 0):
+ return Stencil([1],[0],0,dx=dx,error=None)
+
if len(user_eqs)==0:
for i,d in enumerate(derivative):
if dim>1:
access = [slice(0,1) for _ in xrange(dim)]
access[i] = slice(d,d+1)
+ access = tuple(access)
user_eqs[df[access].ravel()[0]]=1
else:
user_eqs[df[d]] = 1
@@ -456,10 +511,9 @@ class StencilGenerator(object):
stencil = Stencil(S,origin,order,dx=dx,error=err)
- if (dx==dx[0]).all():
+ if (dx==dx[0]).all() and dx[0]!=1:
stencil.refactor(dx[0]**(-derivative[0]))
-
return stencil
@staticmethod
@@ -495,14 +549,14 @@ class CenteredStencilGenerator(StencilGenerator):
config = self._config.copy()
config.configure(**kargs)
shape = config.shape()
-
+
origin = (shape-1)/2
stencil = super(CenteredStencilGenerator,self)\
.generate_approximative_stencil(origin, **kargs)
if stencil.is_centered():
return CenteredStencil.from_stencil(stencil)
else:
- raise RuntimeError('Generated stencil is not centered!')
+ raise RuntimeError('Generated stencil is not centered: {}'.format(stencil.coeffs))
@@ -511,16 +565,34 @@ if __name__ == '__main__':
from hysop.tools.contexts import printoptions
sg = StencilGenerator()
- sg.configure(dim=1, derivative=2, order=2, dtype=np.float64)
with printoptions(precision=4):
+ sg.configure(dim=1, derivative=0, order=2, dtype=np.float64)
+ print '\ndim=1, 0th derivative, np.float64, approximative, shape=(5,):'
+ for i in xrange(sg.get_config().shape()):
+ stencil = sg.generate_approximative_stencil(origin=i).reshape((5,))
+ print ' origin: {} => {} . {}'.format(i, stencil.factor, stencil.coeffs)
+
+ sg.configure(dim=1, derivative=1, order=2, dtype=np.float64)
+ print '\ndim=1, 1st order first derivative, np.float64, approximative, shape=(5,):'
+ for i in xrange(sg.get_config().shape()):
+ stencil = sg.generate_approximative_stencil(origin=i).reshape((5,))
+ print ' origin: {} => {} . {}'.format(i, stencil.factor, stencil.coeffs)
+
+ sg.configure(dim=1, derivative=2, order=2, dtype=np.float64)
print '\ndim=1, 2nd order first derivative, np.float64, approximative:'
for i in xrange(sg.get_config().shape()):
stencil = sg.generate_approximative_stencil(origin=i)
print ' origin: {} => {} . {}'.format(i, stencil.factor, stencil.coeffs)
+
+ print '\ndim=1, 2nd order first derivative, exact:'
+ sg.configure(dtype=MPQ, derivative=1)
+ for i in xrange(sg.get_config().shape()):
+ stencil = sg.generate_exact_stencil(origin=i)
+ print ' origin: {} => {} . {}'.format(i, stencil.factor, stencil.coeffs)
- print '\ndim=1, 2nd order first derivative, np.float64, exact:'
- sg.configure(dtype=MPQ)
+ print '\ndim=1, 2nd order second derivative, exact:'
+ sg.configure(dtype=MPQ, derivative=2)
for i in xrange(sg.get_config().shape()):
stencil = sg.generate_exact_stencil(origin=i)
print ' origin: {} => {} . {}'.format(i, stencil.factor, stencil.coeffs)
diff --git a/hysop/numerics/tests/bench_fft.py b/hysop/numerics/tests/bench_fft.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a38d06c520f94a0ff9b670c780b43a0d94a1c4a
--- /dev/null
+++ b/hysop/numerics/tests/bench_fft.py
@@ -0,0 +1,176 @@
+"""
+Test of fields defined with an analytic formula.
+"""
+import os
+import random
+import gc
+import pyfftw
+import gpyfft
+
+import numpy as np
+import itertools as it
+import pyopencl as cl
+
+from hysop.deps import it, sm, random
+from hysop.constants import Implementation, Backend, HYSOP_REAL
+from hysop.testsenv import __ENABLE_LONG_TESTS__, __HAS_OPENCL_BACKEND__
+from hysop.testsenv import opencl_failed, iter_clenv
+from hysop.tools.contexts import printoptions, Timer, stderr_redirected
+from hysop.tools.numerics import float_to_complex_dtype
+from hysop.tools.types import check_instance, first_not_None
+
+from hysop.numerics.fft.fft import mk_shape, HysopFFTDataLayoutError
+from hysop.numerics.fft.numpy_fft import NumpyFFT
+from hysop.numerics.fft.scipy_fft import ScipyFFT
+from hysop.numerics.fft.fftw_fft import FftwFFT
+from hysop.numerics.fft.gpyfft_fft import GpyFFT
+
+from hysop.backend.device.opencl.opencl_kernel_statistics import OpenClKernelStatistics
+
+devnull = open(os.devnull, 'w')
+
+class BenchFFT(object):
+
+ implementations = {
+ Implementation.PYTHON: {
+ #'numpy': NumpyFFT(warn_on_allocation=False),
+ #'scipy': ScipyFFT(warn_on_allocation=False),
+ 'fftw': FftwFFT(warn_on_allocation=False,
+ warn_on_misalignment=True)
+ },
+ Implementation.OPENCL: {}
+ }
+ nruns = 2
+
+ print
+ print ':: STARTING FFT BENCH ::'
+ for (i,cl_env) in enumerate(iter_clenv(all_platforms=True)):
+ print '> Registering opencl backend {} as:\n{}'.format(
+ i, cl_env)
+ print
+ name = 'clfft{}'.format(i)
+ queue = cl.CommandQueue(cl_env.context,
+ properties=cl.command_queue_properties.PROFILING_ENABLE)
+ cl_env.disable_default_queue()
+ implementations[Implementation.OPENCL][name] = \
+ GpyFFT(cl_env=cl_env, queue=queue,
+ warn_on_allocation=False,
+ warn_on_unaligned_output_offset=True)
+
+ def _bench_1d(self, dtype):
+ print
+ print '::Benching 1D transforms, precision {}::'.format(dtype.__name__)
+ nruns = self.nruns
+ ctype = float_to_complex_dtype(dtype)
+
+ types = ['I','II','III']
+ IMPLEMENTATION_ERROR='impl'
+ DATA_LAYOUT_ERROR='lay'
+ ALLOCATION_ERROR='mem'
+ UNKNOWN_ERROR='err'
+
+ bench = [
+ (' C2C: complex to complex forward transform', ('fft',{}), ('shape','ctype'), ('shape', 'ctype'), {}),
+ (' R2C: real to hermitian complex transform', ('rfft',{}), ('shape','dtype'), ('cshape', 'ctype'), {}),
+ (' C2R: hermitian complex to real transform', ('irfft',{}), ('cshape','ctype'), ('rshape', 'dtype'), {}),
+ ]
+ for (itype,stype) in enumerate(types, 1):
+ b = (' DCT-{}: real to real discrete cosine transform {}'.format(stype, itype),
+ ('dct',{'type':itype}), ('shape','dtype'), ('shape','dtype'), {'offset':+(itype==1)})
+ bench.append(b)
+ for (itype,stype) in enumerate(types, 1):
+ b = (' DST-{}: real to real discrete sine transform {}'.format(stype, itype),
+ ('dst',{'type':itype}), ('shape','dtype'), ('shape','dtype'), {'offset':-(itype==1)})
+ bench.append(b)
+
+ results = {}
+ for (descr, fn, Bi, Bo, it_kwds) in bench:
+ print descr
+ for (kind, implementations) in self.implementations.iteritems():
+ for (name, impl) in implementations.iteritems():
+ results[name] = ()
+ if dtype not in impl.supported_ftypes:
+ continue
+ print ' {:<8}: '.format(name),
+ for (shape, cshape, rshape, N, Nc, Nr, mk_buffer) in self.iter_shapes(**it_kwds):
+ print '.',
+ with stderr_redirected(devnull): # get rid of Intel opencl warnings
+ try:
+ Bin = mk_buffer(backend=impl.backend, shape=locals()[Bi[0]], dtype=locals()[Bi[1]]).handle
+ Bout = mk_buffer(backend=impl.backend, shape=locals()[Bo[0]], dtype=locals()[Bo[1]]).handle
+ plan = getattr(impl,fn[0])(a=Bin, out=Bout, **fn[1]).setup()
+ gc.disable() # disable garbage collector for timing (like timeit)
+ if (kind==Implementation.OPENCL):
+ for i in xrange(nruns):
+ _ = plan.execute()
+ _.wait()
+ evt = plan.execute()
+ evts = (evt,)
+ for i in xrange(nruns-1):
+ evt = plan.execute(wait_for=[evt])
+ evts += (evt,)
+ evt.wait()
+ res = OpenClKernelStatistics(events=evts).mean/1e6 # ms
+ else:
+ plan.execute()
+ with Timer() as t:
+ for i in xrange(nruns):
+ plan.execute()
+ res = (1e3*t.interval) / float(nruns) # ms
+ res = round(res, 2)
+ gc.enable()
+ except HysopFFTDataLayoutError as e:
+ res = DATA_LAYOUT_ERROR
+ print e
+ except MemoryError as e:
+ print e
+ res = ALLOCATION_ERROR
+ except gpyfft.gpyfftlib.GpyFFT_Error as e:
+ if str(e)=='MEM_OBJECT_ALLOCATION_FAILURE':
+ res = ALLOCATION_ERROR
+ else:
+ res = UNKNOWN_ERROR
+ print e
+ except Exception as e:
+ print e
+ res = UNKNOWN_ERROR
+ results[name] += (res,)
+ print results[name]
+
+
+ def iter_shapes(self, offset=0):
+ minj=12
+ maxj=27
+ for j in xrange(minj,maxj):
+ shape = (2**j+offset,)
+ cshape = list(shape)
+ cshape[-1] = cshape[-1]//2 + 1
+ cshape = tuple(cshape)
+ rshape = list(shape)
+ rshape[-1] = (rshape[-1]//2) * 2
+ rshape = tuple(rshape)
+ N = np.prod(shape, dtype=np.int64)
+ Nc = np.prod(cshape, dtype=np.int64)
+ Nr = np.prod(rshape, dtype=np.int64)
+ def mk_buffer(backend, shape, dtype):
+ buf = backend.empty(shape=shape, dtype=dtype, min_alignment=128)
+ assert buf.shape == shape
+ assert buf.dtype == dtype
+ return buf
+ yield (shape, cshape, rshape, N, Nc, Nr, mk_buffer)
+
+ def perform_benchs(self):
+ if __ENABLE_LONG_TESTS__:
+ dtypes = (np.float32, np.float64,)
+ else:
+ dtypes = (HYSOP_REAL,)
+ for dtype in dtypes:
+ self._bench_1d(dtype=dtype)
+
+if __name__ == '__main__':
+ bench = BenchFFT()
+
+ with printoptions(threshold=10000, linewidth=240,
+ nanstr='nan', infstr='inf',
+ formatter={'float': lambda x: '{:>0.2f}'.format(x)}):
+ bench.perform_benchs()
diff --git a/hysop/numerics/tests/test_fft.py b/hysop/numerics/tests/test_fft.py
index 58f4112b21ea92ac1bf0900a2e5fcaa086cc7b6c..e20e217817a24d0908773c471ae192339ac8afa8 100644
--- a/hysop/numerics/tests/test_fft.py
+++ b/hysop/numerics/tests/test_fft.py
@@ -20,7 +20,13 @@ from hysop.numerics.fft.numpy_fft import NumpyFFT
from hysop.numerics.fft.scipy_fft import ScipyFFT
from hysop.numerics.fft.fftw_fft import FftwFFT
from hysop.numerics.fft.gpyfft_fft import GpyFFT
+try:
+ from hysop.numerics.fft._mkl_fft import MklFFT
+ HAS_MKLFFT=True
+except ImportError:
+ HAS_MKLFFT=False
+raise_on_failure = False
class TestFFT(object):
@@ -29,22 +35,25 @@ class TestFFT(object):
'numpy': NumpyFFT(warn_on_allocation=False),
'scipy': ScipyFFT(warn_on_allocation=False),
'fftw': FftwFFT(warn_on_allocation=False,
- warn_on_misalignment=False)
+ warn_on_misalignment=False),
},
Implementation.OPENCL: {}
}
+
+ if HAS_MKLFFT:
+ implementations[Implementation.PYTHON]['mkl'] = MklFFT(warn_on_allocation=False)
print
print ':: STARTING FFT BACKEND TESTS ::'
- for (i,cl_env) in enumerate(iter_clenv()):
- print '> Registering opencl backend {} as:\n{}'.format(
- i, cl_env)
- print
- name = 'clfft{}'.format(i)
- implementations[Implementation.OPENCL][name] = \
- GpyFFT(cl_env=cl_env,
- warn_on_allocation=False,
- warn_on_unaligned_output_offset=False)
+ #for (i,cl_env) in enumerate(iter_clenv()):
+ #print '> Registering opencl backend {} as:\n{}'.format(
+ #i, cl_env)
+ #print
+ #name = 'clfft{}'.format(i)
+ #implementations[Implementation.OPENCL][name] = \
+ #GpyFFT(cl_env=cl_env,
+ #warn_on_allocation=False,
+ #warn_on_unaligned_output_offset=False)
msg_shape = 'Expected output array shape to be {} but got {} for implementation {}.'
msg_dtype = 'Expected output array dtype to be {} but got {} for implementation {}.'
@@ -54,6 +63,8 @@ class TestFFT(object):
report_eps = 10
fail_eps = 100
+ stop_on_error = True
+
def _test_1d(self, dtype, failures):
print
print '::Testing 1D transform, precision {}::'.format(dtype.__name__)
@@ -95,6 +106,8 @@ class TestFFT(object):
shape=results[r0].shape
failures.setdefault(tag, []).append((r0, r1, shape, Einf, Eeps))
print ', '.join(ss)
+ if failed and raise_on_failure:
+ raise RuntimeError
print '\n FORWARD C2C: complex to complex forward transform'
@@ -116,7 +129,7 @@ class TestFFT(object):
assert Bout.dtype == ctype, self.msg_dtype.format(ctype, Bout.dtype,
name)
Bin[...] = Href
- plan.execute()
+ evt = plan.execute()
H0 = Bin.get()
H1 = Bout.get()
assert np.array_equal(Href, H0), self.msg_input_modified.format(name)
@@ -464,7 +477,8 @@ class TestFFT(object):
if failed:
print
msg='Some implementations failed !'
- raise RuntimeError(msg)
+ if raise_on_failure:
+ raise RuntimeError(msg)
print '\n C2C-C2C transform'
for (shape, cshape, rshape, N, Nc, Nr,
@@ -570,7 +584,7 @@ class TestFFT(object):
check_distances(results)
for (itype,stype) in enumerate(types, 1):
- print '\n DST-{}: real to real discrete sinine transform {}'.format(
+ print '\n DST-{}: real to real discrete sine transform {}'.format(
stype.strip(), itype)
ttype = 'SIN{}'.format(itype)
for (shape, cshape, rshape, N, Nc, Nr,
diff --git a/hysop/operator/adapt_timestep.py b/hysop/operator/adapt_timestep.py
index fe66e08ecc75672920b7ce16ad8d20e1c7ef8e2e..b547e65382a45d6e81a66643352508259ae367b2 100755
--- a/hysop/operator/adapt_timestep.py
+++ b/hysop/operator/adapt_timestep.py
@@ -13,12 +13,13 @@ from hysop.core.graph.computational_operator import ComputationalGraphOperator
from hysop.core.graph.graph import op_apply
from hysop.fields.continuous_field import Field
from hysop.parameters import ScalarParameter, TensorParameter
+from hysop.core.mpi import MPI
class TimestepCriteria(ComputationalGraphOperator):
__metaclass__ = ABCMeta
-
+
@debug
- def __init__(self, parameter, input_params, output_params,
+ def __init__(self, parameter, input_params, output_params,
dt_coeff=None, min_dt=None, max_dt=None, **kwds):
"""
Initialize an AdaptiveTimeStep operator.
@@ -50,24 +51,47 @@ class TimestepCriteria(ComputationalGraphOperator):
assert (min_dt is None) or (max_dt is None) or (max_dt >= min_dt)
assert (dt_coeff is None) or (dt_coeff > 0.0)
assert parameter.name in output_params
-
- super(TimestepCriteria,self).__init__(input_params=input_params,
+
+ super(TimestepCriteria,self).__init__(input_params=input_params,
output_params=output_params, **kwds)
self.min_dt = 0.0 if (min_dt is None) else min_dt
self.max_dt = 1e8 if (max_dt is None) else max_dt
- self.dt_coeff = 1.0 if (dt_coeff is None) else dt_coeff
+ self.dt_coeff = 1.0 if (dt_coeff is None) else dt_coeff
self.dt = parameter
+ # Collect values from all MPI process
+ if self.mpi_params.size == 1:
+ self._collect_min = lambda e: e
+ self._collect_max = lambda e: e
+ else:
+ comm = self.mpi_params.comm
+ self._sendbuff = npw.zeros((1, ))
+ self._recvbuff = npw.zeros((1, ))
+ def _collect_max(val):
+ self._sendbuff[0] = val
+ comm.Allreduce(self._sendbuff, self._recvbuff, op=MPI.MAX)
+ return self._recvbuff[0]
+ def _collect_min(val):
+ self._sendbuff[0] = val
+ comm.Allreduce(self._sendbuff, self._recvbuff, op=MPI.MIN)
+ return self._recvbuff[0]
+ self._collect_max = _collect_max
+ self._collect_min = _collect_min
+
@op_apply
def apply(self, **kwds):
dt = self.compute_criteria(**kwds)
dt *= self.dt_coeff
- dt = npw.maximum(dt, self.min_dt)
- dt = npw.minimum(dt, self.max_dt)
+ dt = self._collect_max(npw.maximum(dt, self.min_dt))
+ dt = self._collect_min(npw.minimum(dt, self.max_dt))
assert (dt > 0.0), 'negative or zero timestep encountered.'
self.dt.set_value(dt)
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
@abstractmethod
def compute_criteria(**kwds):
pass
@@ -83,7 +107,7 @@ class ConstantTimestepCriteria(TimestepCriteria):
Compute a timestep criteria for an arbitrary field F.
- dt = cst / Max_i(|Fi|inf)
+ dt = cst / Max_i(|Fi|inf)
where i in [0, F.nb_components-1]
Parameters
@@ -145,12 +169,12 @@ class ConstantTimestepCriteria(TimestepCriteria):
class CflTimestepCriteria(TimestepCriteria):
-
+
@debug
def __init__(self, cfl, parameter,
- Finf=None, Fmin=None, Fmax=None,
- dx=None,
- name=None, pretty_name=None,
+ Finf=None, Fmin=None, Fmax=None,
+ dx=None,
+ name=None, pretty_name=None,
relative_velocities=None, **kwds):
"""
Initialize a CflTimestepCriteria.
@@ -188,7 +212,7 @@ class CflTimestepCriteria(TimestepCriteria):
check_instance(Fmin, TensorParameter)
check_instance(Fmax, TensorParameter)
assert Fmin.shape == Fmax.shape
- input_params={ Fmin.name: Fmin, Fmax.name: Fmax }
+ input_params={ Fmin.name: Fmin, Fmax.name: Fmax }
dtype = Fmin.dtype
shape = Fmin.shape
size = Fmin.size
@@ -197,7 +221,7 @@ class CflTimestepCriteria(TimestepCriteria):
msg='Cannot specify (Fmin,Fmax) and Finf at the same time.'
assert (Fmin is None), msg
assert (Fmax is None), msg
- input_params={ Finf.name: Finf }
+ input_params={ Finf.name: Finf }
dtype = Finf.dtype
shape = Finf.shape
size = Finf.size
@@ -268,16 +292,21 @@ class CflTimestepCriteria(TimestepCriteria):
cdt = cfl / npw.max(npw.divide(Vinf, dx))
dt = min(dt, cdt)
return dt
-
+
def compute_cfl(self, dt):
mdt = self.compute_criteria()
return (dt / mdt) * self.cfl
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
+
class AdvectionTimestepCriteria(TimestepCriteria):
@debug
def __init__(self, lcfl, parameter, criteria,
- Finf=None, gradFinf=None,
+ Finf=None, gradFinf=None,
name=None, pretty_name=None, **kwds):
"""
Initialize a AdvectionTimestepCriteria.
@@ -301,7 +330,7 @@ class AdvectionTimestepCriteria(TimestepCriteria):
A tensor parameter that contains |W|inf for every components.
of the vorticity.
gradFinf: TensorParameter
- A tensor parameter that contains |gradF|inf for every components
+ A tensor parameter that contains |gradF|inf for every components
in every directions, ie. the inf. norm of the gradient of velocity.
parameter: ScalarParameter
The output parameter that will store the computed timestep.
@@ -358,10 +387,11 @@ class AdvectionTimestepCriteria(TimestepCriteria):
msg='Unsupported stretching criteria {}.'.format(criteria)
raise RuntimeError(msg)
+
class StretchingTimestepCriteria(TimestepCriteria):
-
+
@debug
- def __init__(self, gradFinf, parameter,
+ def __init__(self, gradFinf, parameter,
cst=1.0, criteria=StretchingCriteria.GRAD_U,
name=None, pretty_name=None,
**kwds):
@@ -394,11 +424,11 @@ class StretchingTimestepCriteria(TimestepCriteria):
check_instance(parameter, ScalarParameter)
check_instance(criteria, StretchingCriteria)
assert gradFinf().ndim == 2, 'gradFinf should be a 2D tensor.'
-
+
name = first_not_None(name, 'STRETCH')
pretty_name = first_not_None(pretty_name, name)
super(StretchingTimestepCriteria, self).__init__(name=name, pretty_name=pretty_name,
- input_params={gradFinf.name: gradFinf},
+ input_params={gradFinf.name: gradFinf},
output_params={parameter.name: parameter},
parameter=parameter, **kwds)
self.cst = cst
@@ -417,9 +447,9 @@ class StretchingTimestepCriteria(TimestepCriteria):
class MergeTimeStepCriterias(TimestepCriteria):
@debug
- def __init__(self, parameter, criterias,
- equivalent_CFL=None, cfl_criteria=None,
- **kwds):
+ def __init__(self, parameter, criterias,
+ equivalent_CFL=None, cfl_criteria=None, start_time=None,
+ **kwds):
check_instance(parameter, ScalarParameter)
check_instance(criterias, dict, keys=str, values=TimestepCriteria)
check_instance(equivalent_CFL, ScalarParameter, allow_none=True)
@@ -427,11 +457,12 @@ class MergeTimeStepCriterias(TimestepCriteria):
input_params = {}
for criteria in criterias.values():
input_params.update(criteria.output_params)
-
+
assert not ((equivalent_CFL is not None) ^ (cfl_criteria is not None))
self.equivalent_CFL = equivalent_CFL
self.cfl_criteria = cfl_criteria
-
+ self._start_time = start_time
+
super(MergeTimeStepCriterias, self).__init__(parameter=parameter,
input_params=input_params,
output_params=output_params,
@@ -443,11 +474,13 @@ class MergeTimeStepCriterias(TimestepCriteria):
cfl = self.cfl_criteria.compute_cfl(dt)
self.equivalent_CFL.set_value(cfl)
return dt
-
+
@debug
def apply(self, simulation, **kwds):
assert simulation.dt is self.dt, 'Parameter mismatch between Simulation and AdaptiveTimeStep.'
- super(MergeTimeStepCriterias, self).apply(simulation=simulation, **kwds)
+ if self._start_time is None or simulation.t() > self._start_time:
+ super(MergeTimeStepCriterias, self).apply(simulation=simulation, **kwds)
+
class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
"""
@@ -458,8 +491,9 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
"""
@debug
- def __init__(self, dt, min_dt=None, max_dt=None, dt_coeff=None,
- equivalent_CFL=False, base_kwds=None, **kwds):
+ def __init__(self, dt, min_dt=None, max_dt=None, dt_coeff=None,
+ equivalent_CFL=False, base_kwds=None, start_time=None,
+ **kwds):
"""
Initialize an AdaptiveTimeStep operator.
@@ -474,12 +508,14 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
dt_coeff: double, optional
Constant coefficient applied to resulting dt
after resolving min and max values.
+ start_time: double, optional
+ Simulation time when starting to adapt timestep
param_name: str, optional
Output dt parameter name (default is 'dt').
base_kwds: dict
Base kwds of this class.
- kwds :
- Additional keywords arguments that will be passed
+ kwds :
+ Additional keywords arguments that will be passed
to MergeTimeStepCriterias.
Notes
@@ -491,12 +527,13 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
candidate_input_tensors=(),
candidate_output_tensors=(),
**base_kwds)
-
+
# tuple of criterias used to compute dt
self.criterias = {}
self.merge_kwds = { 'min_dt': min_dt,
'max_dt': max_dt,
- 'dt_coeff': dt_coeff }
+ 'dt_coeff': dt_coeff,
+ 'start_time': start_time}
self.merge_kwds.update(**kwds)
self.equivalent_CFL = None
self.cfl_criteria = None
@@ -505,33 +542,33 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
def push_cst_criteria(self, cst, Finf=None,
name=None, pretty_name=None,
param_name=None, param_pretty_name=None,
- parameter=None, quiet=False, **kwds):
-
+ parameter=None, quiet=False, dtype=None, **kwds):
+
parameter = self._build_parameter(parameter=parameter, quiet=quiet,
- name=param_name, pretty_name=param_pretty_name,
- basename=name.replace('dt_', ''))
+ name=param_name, pretty_name=param_pretty_name,
+ basename=name.replace('dt_', ''), dtype=dtype)
criteria = ConstantTimestepCriteria(cst=cst, Finf=Finf,
parameter=parameter, name=name, pretty_name=pretty_name, **kwds)
self._push_criteria(parameter.name, criteria)
def push_cfl_criteria(self, cfl, Fmin=None, Fmax=None, Finf=None,
dx=None,
- name=None, pretty_name=None,
+ name=None, pretty_name=None,
param_name=None, param_pretty_name=None,
parameter=None, quiet=False,
relative_velocities=None,
- equivalent_CFL=None, **kwds):
+ equivalent_CFL=None, dtype=None, **kwds):
"""
See hysop.operator.adapt_timpestep.CflTimestepCriteria.
"""
parameter = self._build_parameter(parameter=parameter, quiet=quiet,
- name=param_name, pretty_name=param_pretty_name, basename='cfl')
+ name=param_name, pretty_name=param_pretty_name, basename='cfl', dtype=dtype)
criteria = CflTimestepCriteria(cfl=cfl, Fmin=Fmin, Fmax=Fmax, Finf=Finf,
- dx=dx, parameter=parameter,
- name=name, pretty_name=pretty_name,
+ dx=dx, parameter=parameter,
+ name=name, pretty_name=pretty_name,
relative_velocities=relative_velocities, **kwds)
self._push_criteria(parameter.name, criteria)
-
+
if isinstance(equivalent_CFL, ScalarParameter):
cfl_criteria = criteria
elif (equivalent_CFL is True):
@@ -544,21 +581,21 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
self.cfl_criteria = cfl_criteria
return criteria.dt
- def push_advection_criteria(self, lcfl, criteria, Finf=None, gradFinf=None,
- name=None, pretty_name=None,
+ def push_advection_criteria(self, lcfl, criteria, Finf=None, gradFinf=None,
+ name=None, pretty_name=None,
param_name=None, param_pretty_name=None,
- parameter=None, quiet=False, **kwds):
+ parameter=None, quiet=False, dtype=None, **kwds):
"""
See hysop.operator.adapt_timpestep.AdvectionTimestepCriteria.
"""
- parameter = self._build_parameter(parameter=parameter, quiet=quiet,
+ parameter = self._build_parameter(parameter=parameter, quiet=quiet, dtype=dtype,
name=param_name, pretty_name=param_pretty_name, basename='lcfl_{}'.format(str(criteria).lower()))
criteria = AdvectionTimestepCriteria(lcfl=lcfl, Finf=Finf, gradFinf=gradFinf,
- parameter=parameter, criteria=criteria,
+ parameter=parameter, criteria=criteria,
name=name, pretty_name=pretty_name, **kwds)
self._push_criteria(parameter.name, criteria)
return criteria.dt
-
+
def push_lcfl_criteria(self, *args, **kwds):
"""
See hysop.operator.adapt_timpestep.AdvectionTimestepCriteria.
@@ -566,24 +603,25 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
return self.push_advection_criteria(*args, **kwds)
def push_stretching_criteria(self, criteria, gradFinf, cst=1.0,
- name=None, pretty_name=None, parameter=None, quiet=False, **kwds):
+ name=None, pretty_name=None, parameter=None, quiet=False, dtype=None, **kwds):
"""
See hysop.operator.adapt_timpestep.StretchingTimestepCriteria.
"""
parameter = self._build_parameter(parameter=parameter, quiet=quiet,
- name=name, pretty_name=pretty_name, basename='stretch')
+ name=name, pretty_name=pretty_name, basename='stretch', dtype=dtype)
criteria = StretchingTimestepCriteria(cst=cst, parameter=parameter,
gradFinf=gradFinf, criteria=criteria, **kwds)
self._push_criteria(parameter.name, criteria)
return criteria.dt
- def _build_parameter(self, name=None, pretty_name=None, quiet=None,
- basename=None, parameter=None):
+ def _build_parameter(self, name=None, pretty_name=None, quiet=None,
+ basename=None, parameter=None, dtype=None):
if (parameter is None):
name = first_not_None(name,'dt_{}'.format(basename))
pretty_name = first_not_None(pretty_name, name)
- parameter = ScalarParameter(name=name, pretty_name=pretty_name,
- quiet=quiet, dtype=HYSOP_REAL)
+ dtype = first_not_None(dtype, HYSOP_REAL)
+ parameter = ScalarParameter(name=name, pretty_name=pretty_name,
+ quiet=quiet, dtype=dtype)
return parameter
def _push_criteria(self, name, criteria):
@@ -603,7 +641,7 @@ class AdaptiveTimeStep(ComputationalGraphNodeGenerator):
# we need to compute the minimum timestep of all criterias
# through a new operator.
self.merge_kwds.setdefault('name', 'DT')
- merge = MergeTimeStepCriterias(parameter=self.parameter,
+ merge = MergeTimeStepCriterias(parameter=self.parameter,
equivalent_CFL=self.equivalent_CFL,
cfl_criteria=self.cfl_criteria,
criterias=self.criterias, **self.merge_kwds)
diff --git a/hysop/operator/analytic.py b/hysop/operator/analytic.py
index d1f4a38ce2b029359154abad29af0ce88493950b..7d243477ddde545c38b655a4f62eed8fae8b604f 100644
--- a/hysop/operator/analytic.py
+++ b/hysop/operator/analytic.py
@@ -2,12 +2,107 @@
"""
from hysop.constants import Backend, Implementation
from hysop.fields.continuous_field import Field
-from hysop.tools.types import check_instance
+from hysop.tools.types import check_instance, first_not_None, to_tuple
from hysop.tools.decorators import debug
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.core.graph.computational_node_frontend import ComputationalGraphNodeFrontend
+from hysop.core.graph.node_generator import ComputationalGraphNodeGenerator
-class AnalyticField(ComputationalGraphNodeFrontend):
+class AnalyticField(ComputationalGraphNodeGenerator):
+ """
+ Applies an analytic formula, given by user, on all contained scalar fields.
+ Formula may be given in different formats depending on the
+ chosen implementation backend.
+ """
+
+ @debug
+ def __init__(self, field, formula, variables, extra_input_kwds=None,
+ implementation=None, base_kwds=None, **kwds):
+ """
+ AnalyticField operator frontend.
+
+ Apply a user-defined formula onto a field, possibly
+ dependent on space variables and external fields/parameters.
+
+ Parameters
+ ----------
+ field: hysop.field.continuous_field.Field
+ Continuous field to be modified.
+ formula : python function or sympy expression or tupe
+ The formula to be applied onto the scalar fields.
+ If the formula is a tuple of the length of the number of scalar fields,
+ fomula[component] is used instead.
+ variables: dict
+ Dictionary of fields as keys and topology descriptors as values.
+ implementation: Implementation, optional, defaults to None
+ target implementation, should be contained in available_implementations().
+ If None, implementation will be set to default_implementation().
+ extra_input_kwds: dict, optional
+ Extra inputs that will be forwarded to the formula.
+ Fields and Parameters are handled correctly as input requirements.
+ Only used for Implementation.PYTHON, discarded for other implementations.
+ base_kwds: dict, optional
+ Base class keyword arguments.
+ kwds: dict, optional
+ Extra parameters passed towards operator implementation.
+ """
+ check_instance(field, Field)
+ check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
+ extra_input_kwds = first_not_None(extra_input_kwds, {})
+ base_kwds = first_not_None(base_kwds, {})
+
+ assert 'extra_input_kwds' not in kwds
+ assert 'component' not in kwds
+ assert 'coords' not in kwds
+
+ if (implementation is Implementation.PYTHON) and (extra_input_kwds is not None):
+ candidate_input_tensors = filter(lambda f: isinstance(f, Field), extra_input_kwds.values())
+ else:
+ extra_input_kwds = {}
+ candidate_input_tensors = ()
+ candidate_output_tensors = (field,)
+
+ formula = to_tuple(formula)
+ if len(formula) == 1:
+ formula = formula*field.nb_components
+ check_instance(formula, tuple, size=field.nb_components)
+
+ super(AnalyticField, self).__init__(
+ candidate_input_tensors=candidate_input_tensors,
+ candidate_output_tensors=candidate_output_tensors,
+ **base_kwds)
+
+ self._fields = field.fields
+ self._formula = formula
+ self._variables = variables
+ self._extra_input_kwds = extra_input_kwds
+ self._implementation = implementation
+ self._kwds = kwds
+
+ @debug
+ def _generate(self):
+ nodes = []
+ impl = self._implementation
+ variables = self._variables
+ assert len(self._formula)==len(self._fields)
+ for component, (formula, field) in enumerate(zip(self._formula, self._fields)):
+ if (formula is None):
+ continue
+ kwds = self._kwds.copy()
+ extra_input_kwds = self._extra_input_kwds.copy()
+ extra_input_kwds['component'] = component
+ node = AnalyticScalarField(
+ field=field,
+ formula=formula,
+ variables=variables,
+ implementation=impl,
+ extra_input_kwds=extra_input_kwds,
+ **kwds)
+ nodes.append(node)
+ return nodes
+
+
+class AnalyticScalarField(ComputationalGraphNodeFrontend):
"""
Applies an analytic formula, given by user, on its field.
Formula may be given in different formats depending on the
@@ -63,6 +158,6 @@ class AnalyticField(ComputationalGraphNodeFrontend):
if (implementation is Implementation.PYTHON):
kwds['extra_input_kwds'] = extra_input_kwds
- super(AnalyticField, self).__init__(field=field, formula=formula,
+ super(AnalyticScalarField, self).__init__(field=field, formula=formula,
variables=variables, implementation=implementation,
base_kwds=base_kwds, **kwds)
diff --git a/hysop/operator/base/advection_dir.py b/hysop/operator/base/advection_dir.py
index 6c2fa4579fcae5e59d6d6aed55f2eef75d7a2dd0..10026cad40c8fe3155f6e3dcec578f7c71446195 100644
--- a/hysop/operator/base/advection_dir.py
+++ b/hysop/operator/base/advection_dir.py
@@ -85,10 +85,12 @@ class DirectionalAdvectionBase(object):
check_instance(advected_fields_in, tuple, values=Field)
check_instance(advected_fields_out, tuple, values=Field)
check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
- check_instance(velocity_cfl, float)
+ check_instance(velocity_cfl, (float,int))
check_instance(dt, ScalarParameter)
check_instance(relative_velocity, tuple, values=(str,float), size=velocity.nb_components)
+ velocity_cfl = float(velocity_cfl)
+
assert (len(advected_fields_in)==len(advected_fields_out)), '|inputs| != |outputs|'
assert (velocity_cfl>0.0), 'velocity_cfl cfl <= 0'
diff --git a/hysop/operator/base/custom_symbolic_operator.py b/hysop/operator/base/custom_symbolic_operator.py
index 50b8396321ec7b5c53d891499f1de7c9119edfc5..f3f42c9f33eb22e25ced23e79327b8078105b9e1 100644
--- a/hysop/operator/base/custom_symbolic_operator.py
+++ b/hysop/operator/base/custom_symbolic_operator.py
@@ -29,7 +29,7 @@ from hysop.symbolic.parameter import SymbolicScalarParameter
from hysop.constants import ComputeGranularity, SpaceDiscretization, TranspositionState, \
DirectionLabels, SymbolicExpressionKind
from hysop.numerics.odesolvers.runge_kutta import TimeIntegrator, ExplicitRungeKutta, Euler, RK2, RK3, RK4
-from hysop.numerics.interpolation.interpolation import Interpolation
+from hysop.numerics.interpolation.interpolation import MultiScaleInterpolation, Interpolation
from hysop.numerics.stencil.stencil_generator import StencilGenerator, CenteredStencilGenerator, MPQ
ValidExpressions = (Assignment,)
@@ -192,7 +192,8 @@ class SymbolicExpressionInfo(object):
"""Helper class store information about parsed symbolic expressions."""
def __init__(self, name, exprs,
- dt=None, dt_coeff=None, **kwds):
+ dt=None, dt_coeff=None,
+ compute_resolution=None, **kwds):
super(SymbolicExpressionInfo, self).__init__(**kwds)
self.name = name
@@ -238,7 +239,15 @@ class SymbolicExpressionInfo(object):
self.discretization_info = None
self.stencils = None
self.tmp_vars = None
- self._dim = None
+
+ if (compute_resolution is None):
+ self.compute_resolution = None
+ self._dim = None
+ else:
+ compute_resolution = to_tuple(compute_resolution)
+ check_instance(compute_resolution, tuple, values=(int,long))
+ self._dim = len(compute_resolution)
+ self.compute_resolution = compute_resolution
def _is_discretized(self):
"""Return true if the SymbolicExpressionInfo was discretized."""
@@ -360,7 +369,7 @@ class SymbolicExpressionInfo(object):
dfields = set(f for f in (self.input_dfields.values() + self.output_dfields.values()))
if len(dfields)>0:
dfield0 = next(iter(dfields))
- compute_resolution = dfield0.compute_resolution
+ compute_resolution = first_not_None(self.compute_resolution, dfield0.compute_resolution)
for dfield in dfields:
if (dfield.compute_resolution != compute_resolution).any():
msg='Mismatching compute resolution {}::{} vs {}::{}.'
@@ -368,10 +377,7 @@ class SymbolicExpressionInfo(object):
dfield0.name, dfield0.compute_resolution)
raise ValueError(msg)
compute_resolution = tuple(compute_resolution)
- else:
- # will be determined at setup
- compute_resolution = None
- self.compute_resolution = compute_resolution
+ self.compute_resolution = compute_resolution
def check_arrays(self):
compute_resolution = self.compute_resolution
@@ -601,7 +607,7 @@ class SymbolicExpressionParser(object):
cls.parse_one(variables, info, expr)
if (info._dim is None):
msg='\n\nFATAL ERROR: Neither SymbolicFields nor SymbolicArrays were present in parsed '
- msg+='symbolic expressions.'
+ msg+='symbolic expressions and compute_resolution has not been specified.'
msg+='\nAt least one is needed to deduce the shape of the compute kernel.'
msg+='\n'
msg+='\nExpressions were:'
@@ -632,6 +638,8 @@ class SymbolicExpressionParser(object):
if isinstance(lhs, (AppliedSymbolicField, SymbolicArray, IndexedBuffer, TmpScalar)):
cls.write(variables, info, lhs)
cls.parse_subexpr(variables, info, rhs)
+ if isinstance(lhs, IndexedBuffer):
+ cls.parse_subexpr(lhs.index, info, rhs)
elif isinstance(lhs, sm.Derivative):
f = lhs.args[0]
cls.read(variables, info, f)
@@ -645,7 +653,7 @@ class SymbolicExpressionParser(object):
@classmethod
def parse_subexpr(cls, variables, info, expr):
if isinstance(expr, npw.ndarray):
- assert expr.ndim == 0
+ assert expr.ndim == 0, expr
expr = expr.tolist()
if isinstance(expr, (str, int,long,float,complex,npw.number)):
@@ -902,10 +910,9 @@ class SymbolicExpressionParser(object):
for (i, fname) in enumerate(ro_objects, start=nlhsobjects):
all_objects[fname] = i
nobjects = len(all_objects)
- assert (nobjects > 0)
assert (nobjects == len(ro_fields)+len(ro_arrays)+len(lhs_fields)+len(lhs_arrays))
info.nobjects = nobjects
-
+
expr_ghost_map = npw.int_zeros(shape=(nlhsobjects, nobjects))
for (fi_name, i) in lhs_objects.iteritems():
min_ghosts = min_ghosts_per_expr[i]
@@ -1091,6 +1098,9 @@ class SymbolicExpressionParser(object):
cls.write_discrete(info, lhs, dfield, di)
elif isinstance(lhs, IndexedBuffer):
di.write(lhs.indexed_object)
+ index, edi = cls.discretize_subexpr(info, lhs.index)
+ di.update(edi)
+ lhs = lhs.func(lhs.indexed_object, index)
elif isinstance(lhs, TmpScalar):
info.scalars[lhs.varname] = lhs
else:
@@ -1112,7 +1122,6 @@ class SymbolicExpressionParser(object):
@classmethod
def discretize_subexpr(cls, info, expr):
di = ExprDiscretizationInfo()
-
if isinstance(expr, (list, tuple, set, npw.ndarray)):
texpr = type(expr)
@@ -1265,14 +1274,14 @@ class CustomSymbolicOperatorBase(DirectionalOperatorBase):
ComputeGranularity: 0,
SpaceDiscretization: 2,
TimeIntegrator: Euler,
- Interpolation: Interpolation.LINEAR,
+ MultiScaleInterpolation: Interpolation.LINEAR,
}
__available_methods = {
ComputeGranularity: InstanceOf(int),
SpaceDiscretization: InstanceOf(int),
TimeIntegrator: InstanceOf(ExplicitRungeKutta),
- Interpolation: Interpolation.LINEAR,
+ MultiScaleInterpolation: Interpolation.LINEAR
}
@classmethod
@@ -1293,7 +1302,7 @@ class CustomSymbolicOperatorBase(DirectionalOperatorBase):
cr = method.pop(ComputeGranularity)
space_discretization = method.pop(SpaceDiscretization)
time_integrator = method.pop(TimeIntegrator)
- interpolation = method.pop(Interpolation)
+ interpolation = method.pop(MultiScaleInterpolation)
assert (0 <= cr <= self.expr_info.max_granularity), cr
assert (2 <= space_discretization), space_discretization
diff --git a/hysop/operator/base/enstrophy.py b/hysop/operator/base/enstrophy.py
index ff33a805bb226e3cd1dd69c145d39f8dfef8b3c8..1305461cad775707c2b004c18d5b7ad629306b41 100644
--- a/hysop/operator/base/enstrophy.py
+++ b/hysop/operator/base/enstrophy.py
@@ -78,9 +78,11 @@ class EnstrophyBase(object):
self.WdotW = WdotW
self.enstrophy = enstrophy
- super(EnstrophyBase, self).__init__(input_fields=input_fields,
- output_fields=output_fields, output_params=output_params,
- name=name, pretty_name=pretty_name, **kwds)
+ super(EnstrophyBase, self).__init__(
+ input_fields=input_fields,
+ output_fields=output_fields,
+ output_params=output_params,
+ name=name, pretty_name=pretty_name, **kwds)
@debug
def discretize(self):
@@ -93,3 +95,21 @@ class EnstrophyBase(object):
self.coeff = npw.prod(self.dWdotW.space_step)
self.coeff /= (self.rho_0 * npw.prod(self.dWdotW.domain.length))
+ # Collect values from all MPI process
+ if self.mpi_params.size == 1:
+ self._collect = lambda e: e
+ else:
+ comm = self.mpi_params.comm
+ self._sendbuff = npw.zeros((1,))
+ self._recvbuff = npw.zeros((1,))
+
+ def _collect(local_enstrophy):
+ self._sendbuff[0] = local_enstrophy
+ comm.Allreduce(self._sendbuff, self._recvbuff)
+ return self._recvbuff[0]
+ self._collect = _collect
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
diff --git a/hysop/operator/base/integrate.py b/hysop/operator/base/integrate.py
index 710ee46fe76c9320e56849f7542330235ed5e218..bfbda81770bf998931a54c9d320c2cfd6534721e 100644
--- a/hysop/operator/base/integrate.py
+++ b/hysop/operator/base/integrate.py
@@ -1,9 +1,7 @@
-
-
from abc import ABCMeta
-from hysop.tools.types import check_instance, to_tuple, first_not_None
-from hysop.tools.decorators import debug
+from hysop.tools.types import check_instance, to_tuple, first_not_None
+from hysop.tools.decorators import debug
from hysop.tools.numpywrappers import npw
from hysop.fields.continuous_field import Field
@@ -11,6 +9,7 @@ from hysop.core.memory.memory_request import MemoryRequest
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.parameters.scalar_parameter import ScalarParameter, TensorParameter
+
class IntegrateBase(object):
"""
Common implementation interface for field integration.
@@ -19,9 +18,9 @@ class IntegrateBase(object):
__metaclass__ = ABCMeta
@debug
- def __init__(self, field, variables,
- name=None, pretty_name=None, cst=1,
- parameter=None, scaling=None, **kwds):
+ def __init__(self, field, variables,
+ name=None, pretty_name=None, cst=1,
+ parameter=None, scaling=None, expr=None, **kwds):
"""
Initialize a Integrate operator base.
@@ -33,7 +32,7 @@ class IntegrateBase(object):
P = scaling * integral_V(field)
where V is the field domain volume
and scaling depends on specified scaling method.
-
+
parameter
----------
field: Field
@@ -42,43 +41,43 @@ class IntegrateBase(object):
dictionary of fields as keys and topologies as values.
parameter: ScalarParameter or TensorParameter
The output parameter that will contain the integral.
- Should match field.nb_components.
+ Should match field.nb_components.
A default parameter will be created if not specified.
scaling: None, float, str or array-like of str, optional
Scaling method used after integration.
'volumic': scale by domain size (product of mesh space steps)
- 'normalize': scale by first integration (first value will be 1.0)
+ 'normalize': scale by first integration (first value will be 1.0)
Can also be a custom float value of tuple of float values.
Defaults to volumic integration.
cst: float, optional
Extra scaling constant for volumic mode.
kwds:
- Extra keywords arguments that will be passed towards implementation
+ Extra keywords arguments that will be passed towards implementation
enstrophy operator __init__.
"""
-
+
check_instance(field, Field)
check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
scaling = first_not_None(scaling, 'volumic')
if isinstance(scaling, float):
scaling = (scaling,)*field.nb_components
-
+
# Generate parameter if not supplied.
if (parameter is None):
parameter = VolumicIntegrationParameter(field=field)
if (parameter.size != field.nb_components):
- msg='Expected a parameter of size {} but got a parameter of size {}.'
- msg=msg.format(field.nb_components, parameter.size)
+ msg = 'Expected a parameter of size {} but got a parameter of size {}.'
+ msg = msg.format(field.nb_components, parameter.size)
raise RuntimeError(msg)
-
+
check_instance(parameter, (ScalarParameter, TensorParameter))
- check_instance(scaling, (str,tuple))
+ check_instance(scaling, (str, tuple))
if isinstance(scaling, tuple):
- check_instance(tuple, values=float, size=field.nb_components)
-
- input_fields = { field: variables[field] }
- output_params = { parameter.name: parameter }
+ check_instance(scaling, tuple, values=float, size=field.nb_components)
+
+ input_fields = {field: variables[field]}
+ output_params = {parameter.name: parameter}
default_name = 'integrate_{}'.format(field.name)
default_pname = u'\u222b{}'.format(field.pretty_name.decode('utf-8')).encode('utf-8')
@@ -86,15 +85,16 @@ class IntegrateBase(object):
pretty_name = first_not_None(pretty_name, name, default_pname)
name = first_not_None(name, default_name)
- self.field = field
+ self.field = field
self.parameter = parameter
- self.scaling = scaling
+ self.scaling = scaling
+ self.expr = expr
self.cst = cst
self.scaling_coeff = None
-
+
super(IntegrateBase, self).__init__(name=name, pretty_name=pretty_name,
- input_fields=input_fields, output_params=output_params, **kwds)
-
+ input_fields=input_fields, output_params=output_params, **kwds)
+
@debug
def discretize(self):
if self.discretized:
@@ -107,15 +107,32 @@ class IntegrateBase(object):
scaling_coeff = self.cst*npw.prod(dF.space_step) / npw.prod(dF.domain.length)
scaling_coeff = (scaling_coeff,)*dF.nb_components
elif (scaling == 'normalize'):
- scaling_coeff = [None,]*dF.nb_components
+ scaling_coeff = [None, ]*dF.nb_components
elif isinstance(scaling, tuple):
scaling_coeff = tuple(scaling)
else:
- msg='Unknown scaling method {}'.format(self.scaling)
+ msg = 'Unknown scaling method {}'.format(self.scaling)
raise ValueError(msg)
- assert len(scaling_coeff)==dF.nb_components
+ assert len(scaling_coeff) == dF.nb_components
self.dF = dF
self.scaling_coeff = scaling_coeff
+ # Collect values from all MPI process
+ if self.mpi_params.size == 1:
+ self._collect = lambda e: e
+ else:
+ comm = self.mpi_params.comm
+ self._sendbuff = npw.zeros(shape=(self.parameter.size,), dtype=self.parameter.dtype)
+ self._recvbuff = npw.zeros(shape=(self.parameter.size,), dtype=self.parameter.dtype)
+
+ def _collect(v):
+ self._sendbuff[...] = v
+ comm.Allreduce(self._sendbuff, self._recvbuff)
+ return self._recvbuff
+ self._collect = _collect
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
diff --git a/hysop/operator/base/memory_reordering.py b/hysop/operator/base/memory_reordering.py
index 70a43ab34ba5ad8e4071a80a59e2490333a127f7..1d6c4c9019a52a33181979a02bce56115b58830c 100644
--- a/hysop/operator/base/memory_reordering.py
+++ b/hysop/operator/base/memory_reordering.py
@@ -1,4 +1,3 @@
-
from abc import ABCMeta
from hysop.tools.types import check_instance, to_tuple, first_not_None
@@ -17,12 +16,12 @@ class MemoryReorderingBase(object):
__metaclass__ = ABCMeta
@debug
- def __init__(self, input_field, output_field, variables,
+ def __init__(self, input_field, output_field, variables,
target_memory_order, name=None, pretty_name=None,
**kwds):
"""
Initialize a memory reordering operator operating on CartesianTopologyDescriptors.
-
+
Parameters
----------
input_field: ScalarField
@@ -49,7 +48,7 @@ class MemoryReorderingBase(object):
input_fields = { input_field: variables[input_field] }
output_fields = { output_field: variables[output_field] }
-
+
if (target_memory_order is MemoryOrdering.C_CONTIGUOUS):
mr = 'F2C'
elif (target_memory_order is MemoryOrdering.F_CONTIGUOUS):
@@ -65,17 +64,17 @@ class MemoryReorderingBase(object):
name = first_not_None(name, default_name)
pname = first_not_None(pretty_name, default_pname)
-
+
super(MemoryReorderingBase, self).__init__(
input_fields=input_fields,
- output_fields=output_fields,
+ output_fields=output_fields,
name=name, pretty_name=pname,
**kwds)
self.input_field = input_field
self.output_field = output_field
self.target_memory_order = target_memory_order
-
+
@debug
def get_field_requirements(self):
requirements = super(MemoryReorderingBase, self).get_field_requirements()
@@ -88,19 +87,23 @@ class MemoryReorderingBase(object):
else:
req.memory_order = self.target_memory_order
return requirements
-
+
@debug
def get_node_requirements(self):
from hysop.core.graph.node_requirements import OperatorRequirements
reqs = super(MemoryReorderingBase, self).get_node_requirements()
reqs.enforce_unique_memory_order=False
return reqs
-
+
def output_topology_state(self, output_field, input_topology_states):
ostate = super(MemoryReorderingBase, self).output_topology_state(
- output_field=output_field,
+ output_field=output_field,
input_topology_states=input_topology_states)
assert len(input_topology_states)==1
istate = input_topology_states.values()[0]
ostate.memory_order = self.target_memory_order
return ostate
+
+ @classmethod
+ def supports_mpi(cls):
+ return True
diff --git a/hysop/operator/base/min_max.py b/hysop/operator/base/min_max.py
index 964e2fcf83ed6d462ee1e3dca751ce362421cd3a..2ec39a464b69f1803725ca5a87b23e10c55884f3 100644
--- a/hysop/operator/base/min_max.py
+++ b/hysop/operator/base/min_max.py
@@ -1,7 +1,7 @@
"""
@file min_max.py
MinMaxFieldStatisticsBase: compute min(F), max(F) and/or max(|F|) for a given field
-MinMaxGradientStatisticsBase: compute min(gradF), max(gradF) and/or max(|gradF|) for a given field, component and direction-wise.
+MinMaxGradientStatisticsBase: compute min(gradF), max(gradF) and/or max(|gradF|) for a given field, component and direction-wise.
"""
from abc import abstractmethod
from hysop.tools.types import check_instance, first_not_None, to_tuple
@@ -14,13 +14,14 @@ from hysop.parameters.tensor_parameter import TensorParameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.core.graph.computational_operator import ComputationalGraphOperator
from hysop.parameters.scalar_parameter import ScalarParameter
+from hysop.core.mpi import MPI
class MinMaxFieldStatisticsBase(object):
"""
Abstract operator base to compute min and max statistics on a specific field.
"""
-
+
@classmethod
def supports_multiple_topologies(cls):
return True
@@ -28,7 +29,7 @@ class MinMaxFieldStatisticsBase(object):
@classmethod
def build_parameters(cls, field, components, all_quiet,
Fmin, Fmax, Finf, pbasename, ppbasename, dtype=None):
- if ( ((Fmin is None) or (Fmin is False))
+ if ( ((Fmin is None) or (Fmin is False))
and ((Fmax is None) or (Fmax is False))
and ((Finf is None) or (Finf is False))):
msg='No statistics were requested.'
@@ -36,12 +37,12 @@ class MinMaxFieldStatisticsBase(object):
msg+=' their value to True, or by by passing an already existing '
msg+=' tensor parameter.'
raise ValueError(msg)
-
+
if (field is not None):
dtype = first_not_None(dtype, field.dtype)
pbasename = first_not_None(pbasename, field.name)
ppbasename = first_not_None(ppbasename, field.pretty_name.decode('utf-8'))
-
+
def make_param(k, quiet):
return TensorParameter(name=names[k], pretty_name=pretty_names[k],
dtype=field.dtype, shape=(nb_components,), quiet=quiet)
@@ -57,7 +58,7 @@ class MinMaxFieldStatisticsBase(object):
'Fmax': u'{}\u208a'.format(ppbasename),
'Finf': u'|{}|\u208a'.format(ppbasename),
}
-
+
if (field is not None):
components = first_not_None(components, range(field.nb_components))
components = to_tuple(components)
@@ -78,9 +79,9 @@ class MinMaxFieldStatisticsBase(object):
if (param is not None):
assert npw.prod(param.shape) == nb_components
parameters[k] = param
- return parameters
+ return parameters
+
-
@debug
def __init__(self, field, components=None, coeffs=None,
Fmin=None, Fmax=None, Finf=None, all_quiet=None,
@@ -94,13 +95,13 @@ class MinMaxFieldStatisticsBase(object):
MinMaxFieldStatistics can compute some commonly required Field statistics:
Fmin: component-wise min values of the field.
Fmax: component-wise max values of the field.
- Finf: component-wise max values of the absolute value of
+ Finf: component-wise max values of the absolute value of
the field (computed using Fmin and Fmax).
All statistics are only computed if explicitely requested by user,
unless required to compute another user-required statistic, see Notes.
- All statistics may also be additionaly scaled by a coefficient.
-
+ All statistics may also be additionaly scaled by a coefficient.
+
Parameters
----------
field: Field
@@ -134,10 +135,10 @@ class MinMaxFieldStatisticsBase(object):
variables: dict
Dictionary of fields as keys and topologies as values.
implementation: hysop.constants.Implementation, optional
-
+
base_kwds: dict, optional
Base class keyword arguments as a dictionnary.
- kwds:
+ kwds:
Extra keyword arguments passed towards operator backend implementation.
Attributes:
@@ -149,7 +150,7 @@ class MinMaxFieldStatisticsBase(object):
Notes
-----
nb_components = min(field.nb_components, len(components)).
-
+
About statistics:
Finf requires to compute Fmin and Fmax and will have value:
Finf = Sinf * max( abs(Smin*Fmin), abs(Smax*Fmax))
@@ -157,10 +158,10 @@ class MinMaxFieldStatisticsBase(object):
"""
components = to_tuple(first_not_None(components, range(field.nb_components)))
check_instance(field, Field)
- check_instance(components, tuple, values=int,
+ check_instance(components, tuple, values=int,
allow_none=True, minval=0, maxval=field.nb_components-1)
check_instance(coeffs, dict, keys=str, values=(int, float, npw.number), allow_none=True)
- check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors,
+ check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors,
allow_none=True)
check_instance(name, str, allow_none=True)
check_instance(pbasename, str, allow_none=True)
@@ -173,13 +174,13 @@ class MinMaxFieldStatisticsBase(object):
field.pretty_name.decode('utf-8')))
variables = first_not_None(variables, {field: None})
all_quiet = first_not_None(all_quiet, False)
-
- parameters = self.build_parameters(field=field, components=components,
+
+ parameters = self.build_parameters(field=field, components=components,
all_quiet=all_quiet, Fmin=Fmin, Fmax=Fmax, Finf=Finf,
- pbasename=pbasename, ppbasename=ppbasename)
+ pbasename=pbasename, ppbasename=ppbasename)
output_params = { p.name: p for p in parameters.values() if (p is not None) }
-
+
if MinMaxDerivativeStatisticsBase in self.__class__.__mro__:
super(MinMaxFieldStatisticsBase, self).__init__(
name=name, pretty_name=pretty_name,
@@ -218,34 +219,50 @@ class MinMaxFieldStatisticsBase(object):
if (param is not None):
param.min_max_dfield = self._dfield
+ # Collect values from all MPI process
+ if self.mpi_params.size == 1:
+ self._collect_min = lambda e: e
+ self._collect_max = lambda e: e
+ else:
+ comm = self.mpi_params.comm
+ Fmin, Fmax = self.Fmin, self.Fmax
+ if (self.Fmax is not None):
+ sendbuff = npw.zeros_like(Fmax.value)
+ recvbuff = npw.zeros_like(Fmax.value)
+ def _collect_max(val, sendbuff=sendbuff, recvbuff=recvbuff):
+ sendbuff[...] = val
+ comm.Allreduce(sendbuff, recvbuff, op=MPI.MAX)
+ return recvbuff.copy()
+ else:
+ _collect_max = None
+ if (self.Fmin is not None):
+ sendbuff = npw.zeros_like(Fmin.value)
+ recvbuff = npw.zeros_like(Fmin.value)
+ def _collect_min(val, sendbuff=sendbuff, recvbuff=recvbuff):
+ sendbuff[...] = val
+ comm.Allreduce(sendbuff, recvbuff, op=MPI.MIN)
+ return recvbuff.copy()
+ else:
+ _collect_min = None
+ self._collect_max = _collect_max
+ self._collect_min = _collect_min
def compute_statistics(self, **kwds):
"""Backend agnostic computation of min and max parameters."""
dfield, components, coeffs = self._dfield, self._components, self._coeffs
Fmin, Fmax, Finf = self.Fmin, self.Fmax, self.Finf
if (Fmin is not None):
- fmin = Fmin().copy()
+ fmin = Fmin.tensor_value
for i in components:
fmin[i] = dfield.data[i].min().get()
- Fmin.value = fmin * coeffs['Fmin']
+ Fmin.value = self._collect_min(fmin * coeffs['Fmin'])
if (Fmax is not None):
- fmax = Fmax().copy()
+ fmax = Fmax.tensor_value
for i in components:
fmax[i] = dfield.data[i].max().get()
- Fmax.value = fmax * coeffs['Fmax']
+ Fmax.value = self._collect_max(fmax * coeffs['Fmax'])
if (Finf is not None):
self.Finf.value = npw.maximum(npw.abs(Fmin()), npw.abs(Fmax())) * coeffs['Finf']
- # TODO mpi reduce
-
- @debug
- def get_node_requirements(self):
- """Called after get_field_requirements to get global node requirements."""
- reqs = super(MinMaxFieldStatisticsBase, self).get_node_requirements()
- reqs.enforce_unique_transposition_state = False
- reqs.enforce_unique_topology_shape = False
- reqs.enforce_unique_memory_order = False
- reqs.enforce_unique_ghosts = False
- return reqs
class MinMaxDerivativeStatisticsBase(MinMaxFieldStatisticsBase):
@@ -253,31 +270,31 @@ class MinMaxDerivativeStatisticsBase(MinMaxFieldStatisticsBase):
Abstract operator base to compute min and max statistics on the derivative
of a specific field component.
"""
-
+
@debug
- def __init__(self, F, dF=None, A=None,
+ def __init__(self, F, dF=None, A=None,
derivative=None, component=None, direction=None,
- out_component=None, scaling_view=None,
- Fmin=None, Fmax=None, Finf=None, coeffs=None,
+ out_component=None, scaling_view=None,
+ Fmin=None, Fmax=None, Finf=None, coeffs=None,
all_quiet=False,
name=None, pretty_name=None,
pbasename=None, ppbasename=None,
variables=None, **kwds):
"""
Initialize an MinMaxDerivativeStatisticsBase.
-
+
MinMaxDerivativeStatistics can compute some commonly required Field derivative statistics:
Fmin: min value of a derivative of the field.
Fmax: max value of a derivative of the field.
Finf: max value of the absolute value of a
derivative of the field (computed using Fmin and Fmax).
-
+
First compute the derivative of a component of a field F in a given direction
- at a given order and on a given backend out of place in a specific output component of dF.
+ at a given order and on a given backend out of place in a specific output component of dF.
The derivative is then possibly scaled by another field/parameter/value A.
After the scaled derivative has been computed, compute user requested statistics
- (min and max values) on this new field and scale those statistics by other scaling
+ (min and max values) on this new field and scale those statistics by other scaling
parameters stored in coeffs.
1) Compute derivative
@@ -305,7 +322,7 @@ class MinMaxDerivativeStatisticsBase(MinMaxFieldStatisticsBase):
Statistics are only computed if explicitely requested by user,
unless required to compute another user-required statistic, see Notes.
-
+
Parameters
----------
F: hysop.field.continuous_field.Field
@@ -373,7 +390,7 @@ class MinMaxDerivativeStatisticsBase(MinMaxFieldStatisticsBase):
If None, implementation will be set to default_implementation().
base_kwds: dict, optional
Base class keyword arguments as a dictionnary.
- kwds:
+ kwds:
Extra keyword arguments passed towards operator backend implementation.
Attributes:
@@ -401,9 +418,9 @@ class MinMaxDerivativeStatisticsBase(MinMaxFieldStatisticsBase):
variables.setdefault(dF, variables[F])
super(MinMaxDerivativeStatisticsBase, self).__init__(field=dF,
- coeffs=coeffs, Fmin=Fmin, Fmax=Fmax, Finf=Finf,
+ coeffs=coeffs, Fmin=Fmin, Fmax=Fmax, Finf=Finf,
name=name, pretty_name=pretty_name,
pbasename=pbasename, variables=variables,
- F=F, dF=dF, A=A,
+ F=F, dF=dF, A=A,
derivative=derivative, component=component, direction=direction,
out_component=out_component, scaling_view=scaling_view, **kwds)
diff --git a/hysop/operator/base/poisson_curl.py b/hysop/operator/base/poisson_curl.py
index 2492d5f278296bef5471a762394db250d16f2555..0f95a700bb64db93d708bf72be2e7c39d476c9d2 100644
--- a/hysop/operator/base/poisson_curl.py
+++ b/hysop/operator/base/poisson_curl.py
@@ -24,8 +24,10 @@ class PoissonCurlOperatorBase(object):
@debug
def __init__(self, vorticity, velocity, variables,
diffusion=None, dt=None, projection=None,
- dump_energy=None, dump_velocity_energy=None, dump_input_vorticity_energy=None, dump_output_vorticity_energy=None,
- plot_energy=None, plot_velocity_energy=None, plot_input_vorticity_energy=None, plot_output_vorticity_energy=None, plot_inout_vorticity_energy=None,
+ dump_energy=None, dump_velocity_energy=None,
+ dump_input_vorticity_energy=None, dump_output_vorticity_energy=None,
+ plot_energy=None, plot_velocity_energy=None,
+ plot_input_vorticity_energy=None, plot_output_vorticity_energy=None, plot_inout_vorticity_energy=None,
**kwds):
"""
PoissonCurl operator to solve incompressible flows using various fft backends.
diff --git a/hysop/operator/base/spatial_filtering.py b/hysop/operator/base/spatial_filtering.py
index 0ef4c363950ce7240da247e38b474580dc5cc576..ff79da9c0b4e8a31565994d5311c29b29b10d112 100644
--- a/hysop/operator/base/spatial_filtering.py
+++ b/hysop/operator/base/spatial_filtering.py
@@ -1,7 +1,10 @@
+# coding: utf-8
+
"""
@file advection.py
-LowpassFilter operator generator.
+RestrictionFilter operator generator.
"""
+import numpy as np
from hysop.constants import Implementation
from hysop.methods import Remesh
from hysop.numerics.remesh.remesh import RemeshKernel
@@ -9,7 +12,9 @@ from hysop.tools.io_utils import IOParams
from hysop.tools.types import check_instance, to_list, first_not_None, InstanceOf
from hysop.tools.numpywrappers import npw
from hysop.tools.decorators import debug
+from hysop.tools.numerics import find_common_dtype
from hysop.tools.spectral_utils import SpectralTransformUtils
+from hysop.tools.method_utils import PolynomialInterpolationMethod
from hysop.fields.continuous_field import Field, ScalarField
from hysop.parameters.scalar_parameter import ScalarParameter
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
@@ -19,7 +24,7 @@ from hysop.core.memory.memory_request import MemoryRequest
from hysop.operator.base.spectral_operator import SpectralOperatorBase
-class LowpassFilterBase(object):
+class SpatialFilterBase(object):
"""
Common base implementation for lowpass spatial filtering: small grid -> coarse grid
"""
@@ -33,23 +38,35 @@ class LowpassFilterBase(object):
check_instance(input_topo, CartesianTopologyDescriptors)
check_instance(output_topo, CartesianTopologyDescriptors)
- super(LowpassFilterBase, self).__init__(
+ super(SpatialFilterBase, self).__init__(
input_fields={input_field: input_topo},
output_fields={output_field: output_topo},
**kwds)
- self.Fin = input_field
- self.Fout = output_field
+ Fin = input_field
+ Fout = output_field
+ assert (Fin.dim == Fout.dim)
+ assert (Fin.lboundaries == Fout.lboundaries).all()
+ assert (Fin.rboundaries == Fout.rboundaries).all()
+ assert (Fin.periodicity == Fout.periodicity).all()
+ self.Fin = Fin
+ self.Fout = Fout
+ self.dim = Fin.dim
+ self.dtype = find_common_dtype(Fin.dtype, Fout.dtype)
+ self.iratio = None # will be set in get_field_requirements
+ self.grid_ratio = None # will be set in discretize
@debug
def discretize(self):
if self.discretized:
return
- super(LowpassFilterBase, self).discretize()
+ super(SpatialFilterBase, self).discretize()
dFin = self.get_input_discrete_field(self.Fin)
dFout = self.get_output_discrete_field(self.Fout)
+ grid_ratio = dFin.topology_state.transposed(self.iratio)
self.dFin = dFin
self.dFout = dFout
+ self.grid_ratio = grid_ratio
@classmethod
def supports_multiple_field_topologies(cls):
@@ -63,7 +80,67 @@ class LowpassFilterBase(object):
return {self.Fin}
-class SpectralLowpassFilterBase(LowpassFilterBase, SpectralOperatorBase):
+class RestrictionFilterBase(SpatialFilterBase):
+ @debug
+ def get_field_requirements(self):
+ requirements = super(RestrictionFilterBase, self).get_field_requirements()
+ dim = self.Fin.dim
+
+ Fin_topo, Fin_requirements = requirements.get_input_requirement(self.Fin)
+ try:
+ Fin_dx = Fin_topo.space_step
+ except AttributeError:
+ Fin_dx = Fin_topo.mesh.space_step
+
+ Fout_topo, Fout_requirements = requirements.get_output_requirement(self.Fout)
+ try:
+ Fout_dx = Fout_topo.space_step
+ except AttributeError:
+ Fout_dx = Fout_topo.mesh.space_step
+
+ ratio = Fout_dx / Fin_dx
+ msg='Destination grid is finer than source grid: {}'.format(ratio)
+ assert (ratio>=1.0).all(), msg
+
+ iratio = ratio.astype(npw.int32)
+ msg='Grid ratio is not an integer on at least one axis: {}'.format(ratio)
+ assert (ratio==iratio).all(), msg
+
+ self.iratio = tuple(iratio.tolist())
+ return requirements
+
+
+class InterpolationFilterBase(SpatialFilterBase):
+ @debug
+ def get_field_requirements(self):
+ requirements = super(InterpolationFilterBase, self).get_field_requirements()
+ dim = self.Fin.dim
+
+ Fin_topo, Fin_requirements = requirements.get_input_requirement(self.Fin)
+ try:
+ Fin_dx = Fin_topo.space_step
+ except AttributeError:
+ Fin_dx = Fin_topo.mesh.space_step
+
+ Fout_topo, Fout_requirements = requirements.get_output_requirement(self.Fout)
+ try:
+ Fout_dx = Fout_topo.space_step
+ except AttributeError:
+ Fout_dx = Fout_topo.mesh.space_step
+
+ ratio = Fin_dx / Fout_dx
+ msg='Source grid is finer than destination grid: {}'.format(ratio)
+ assert (ratio>=1.0).all(), msg
+
+ iratio = ratio.astype(npw.int32)
+ msg='Grid ratio is not an integer on at least one axis: {}'.format(ratio)
+ assert (ratio==iratio).all(), msg
+
+ self.iratio = tuple(iratio.tolist())
+ return requirements
+
+
+class SpectralRestrictionFilterBase(RestrictionFilterBase, SpectralOperatorBase):
"""
Base implementation for lowpass spatial filtering: small grid -> coarse grid
using the spectral method.
@@ -73,7 +150,7 @@ class SpectralLowpassFilterBase(LowpassFilterBase, SpectralOperatorBase):
plot_output_energy=None,
**kwds):
"""
- Initialize a SpectralLowpassFilterBase.
+ Initialize a SpectralRestrictionFilterBase.
Parameters
----------
@@ -92,7 +169,7 @@ class SpectralLowpassFilterBase(LowpassFilterBase, SpectralOperatorBase):
check_instance(plot_input_energy, IOParams, allow_none=True)
check_instance(plot_output_energy, IOParams, allow_none=True)
- super(SpectralLowpassFilterBase, self).__init__(**kwds)
+ super(SpectralRestrictionFilterBase, self).__init__(**kwds)
Fin, Fout = self.Fin, self.Fout
@@ -119,7 +196,7 @@ class SpectralLowpassFilterBase(LowpassFilterBase, SpectralOperatorBase):
def discretize(self):
if self.discretized:
return
- super(SpectralLowpassFilterBase, self).discretize()
+ super(SpectralRestrictionFilterBase, self).discretize()
dFin, dFout = self.dFin, self.dFout
msg = 'Compute resolution of coarse mesh {}::{} is greater than compute resolution of fine mesh {}::{}.'
@@ -127,7 +204,7 @@ class SpectralLowpassFilterBase(LowpassFilterBase, SpectralOperatorBase):
assert (dFin.compute_resolution >= dFout.compute_resolution).all(), msg
def setup(self, work):
- super(SpectralLowpassFilterBase, self).setup(work)
+ super(SpectralRestrictionFilterBase, self).setup(work)
self.FIN = self.Ft.output_buffer
self.FOUT = self.Bt.input_buffer
self.fslices = self._generate_filter_slices()
@@ -176,7 +253,7 @@ class SpectralLowpassFilterBase(LowpassFilterBase, SpectralOperatorBase):
raise NotImplementedError(msg.format(type(self)))
-class RemeshLowpassFilterBase(LowpassFilterBase):
+class RemeshRestrictionFilterBase(RestrictionFilterBase):
"""
Base implementation for lowpass spatial filtering: small grid -> coarse grid
using remeshing kernels.
@@ -192,19 +269,19 @@ class RemeshLowpassFilterBase(LowpassFilterBase):
@classmethod
def default_method(cls):
- dm = super(RemeshLowpassFilterBase, cls).default_method()
+ dm = super(RemeshRestrictionFilterBase, cls).default_method()
dm.update(cls.__default_method)
return dm
@classmethod
def available_methods(cls):
- am = super(RemeshLowpassFilterBase, cls).available_methods()
+ am = super(RemeshRestrictionFilterBase, cls).available_methods()
am.update(cls.__available_methods)
return am
@debug
def handle_method(self,method):
- super(RemeshLowpassFilterBase, self).handle_method(method)
+ super(RemeshRestrictionFilterBase, self).handle_method(method)
remesh_kernel = method.pop(Remesh)
if isinstance(remesh_kernel, Remesh):
remesh_kernel = RemeshKernel.from_enum(remesh_kernel)
@@ -221,28 +298,11 @@ class RemeshLowpassFilterBase(LowpassFilterBase):
@debug
def get_field_requirements(self):
- requirements = super(RemeshLowpassFilterBase, self).get_field_requirements()
- dim = self.Fin.dim
-
- Fin_topo, Fin_requirements = requirements.get_input_requirement(self.Fin)
- try:
- Fin_dx = Fin_topo.space_step
- except AttributeError:
- Fin_dx = Fin_topo.mesh.space_step
-
- Fout_topo, Fout_requirements = requirements.get_output_requirement(self.Fout)
- try:
- Fout_dx = Fout_topo.space_step
- except AttributeError:
- Fout_dx = Fout_topo.mesh.space_step
-
- ratio = Fout_dx / Fin_dx
- msg='Destination grid is finer than source grid: {}'.format(ratio)
- assert (ratio>=1.0).all(), msg
- iratio = ratio.astype(npw.int32)
-
+ requirements = super(RemeshRestrictionFilterBase, self).get_field_requirements()
+ iratio = self.iratio
remesh_ghosts = self.remesh_ghosts(self.remesh_kernel)
- fine_grid_ghosts = iratio*remesh_ghosts - 1
+ fine_grid_ghosts = tuple(np.multiply(iratio, remesh_ghosts) - 1)
+ Fin_topo, Fin_requirements = requirements.get_input_requirement(self.Fin)
Fin_requirements.min_ghosts = fine_grid_ghosts
self.remesh_ghosts = remesh_ghosts
@@ -251,14 +311,15 @@ class RemeshLowpassFilterBase(LowpassFilterBase):
return requirements
def compute_weights(self, iratio, product=True):
- assert (iratio>=1).all()
+ iratio_np = np.asarray(iratio)
+ assert (iratio_np>=1).all()
remesh_kernel = self.remesh_kernel
p = remesh_kernel.n//2 + 1
- shape = 2*p*iratio-1
+ shape = 2*p*iratio_np-1
weights = npw.zeros(dtype=npw.float64, shape=shape)
nz_weights = {}
for idx in npw.ndindex(*shape):
- X = (npw.asarray(idx, dtype=npw.float64)+1) / iratio - p
+ X = (npw.asarray(idx, dtype=npw.float64)+1) / iratio_np - p
if product:
W = npw.prod(remesh_kernel(X))
else:
@@ -275,7 +336,6 @@ class RemeshLowpassFilterBase(LowpassFilterBase):
assert abs(weights.sum() - 1.0) < 1e-8, weights.sum()
assert abs(npw.sum(nz_weights.values()) - 1.0) < 1e-8, npw.sum(nz_weights.values())
- self.iratio = iratio
self.weights = weights
self.nz_weights = nz_weights
@@ -283,64 +343,35 @@ class RemeshLowpassFilterBase(LowpassFilterBase):
def discretize(self):
if self.discretized:
return
- super(RemeshLowpassFilterBase, self).discretize()
+ super(RemeshRestrictionFilterBase, self).discretize()
dFin, dFout = self.dFin, self.dFout
- iratio = dFin.compute_resolution / dFout.compute_resolution
- self.compute_weights(iratio)
+ grid_ratio = self.grid_ratio
+ self.compute_weights(grid_ratio)
remesh_ghosts = self.remesh_ghosts
- fine_grid_ghosts = iratio*remesh_ghosts - 1
+ fine_grid_ghosts = np.multiply(grid_ratio, remesh_ghosts) - 1
fin = dFin.sdata[dFin.local_slices(ghosts=fine_grid_ghosts)]
fout = dFout.compute_buffers[0]
self.fin, self.fout = fin, fout
-class SubgridLowpassFilterBase(LowpassFilterBase):
+class SubgridRestrictionFilterBase(RestrictionFilterBase):
"""
Base implementation for lowpass spatial filtering: small grid -> coarse grid
- using remeshing kernels.
+ using subgrid
"""
- @debug
- def get_field_requirements(self):
- requirements = super(SubgridLowpassFilterBase, self).get_field_requirements()
- dim = self.Fin.dim
-
- Fin_topo, Fin_requirements = requirements.get_input_requirement(self.Fin)
- try:
- Fin_dx = Fin_topo.space_step
- except AttributeError:
- Fin_dx = Fin_topo.mesh.space_step
-
- Fout_topo, Fout_requirements = requirements.get_output_requirement(self.Fout)
- try:
- Fout_dx = Fout_topo.space_step
- except AttributeError:
- Fout_dx = Fout_topo.mesh.space_step
-
- ratio = Fout_dx / Fin_dx
- msg='Destination grid is finer than source grid: {}'.format(ratio)
- assert (ratio>=1.0).all(), msg
-
- iratio = ratio.astype(npw.int32)
- msg='Grid ratio is not an integer on at least one axis: {}'.format(ratio)
- assert (ratio==iratio).all(), msg
-
- self.iratio = iratio
-
- return requirements
-
@debug
def discretize(self):
if self.discretized:
return
- super(SubgridLowpassFilterBase, self).discretize()
+ super(SubgridRestrictionFilterBase, self).discretize()
dFin, dFout = self.dFin, self.dFout
- iratio = dFin.compute_resolution / dFout.compute_resolution
- view = tuple(slice(None,None,r) for r in iratio)
+ grid_ratio = self.grid_ratio
+ view = tuple(slice(None,None,r) for r in grid_ratio)
fin = dFin.compute_buffers[0][view]
fout = dFout.compute_buffers[0]
@@ -348,5 +379,63 @@ class SubgridLowpassFilterBase(LowpassFilterBase):
msg='Something went wrong during slicing: fin.shape={}, fout.shape={}'
msg=msg.format(fin.shape, fout.shape)
assert (fin.shape == fout.shape), msg
+ assert npw.prod(grid_ratio) == npw.prod(self.iratio), msg
self.fin, self.fout = fin, fout
+
+
+class PolynomialInterpolationFilterBase(PolynomialInterpolationMethod, InterpolationFilterBase):
+ """
+ Base implementation for polynomial interpolation.
+ """
+ @debug
+ def get_field_requirements(self):
+ reqs = super(PolynomialInterpolationFilterBase, self).get_field_requirements()
+ required_input_ghosts = np.add(self.polynomial_interpolator.ghosts, self.Fin.periodicity)
+ Fin_topo, Fin_requirements = reqs.get_input_requirement(self.Fin)
+ Fin_requirements.min_ghosts = required_input_ghosts
+ self.required_input_ghosts = required_input_ghosts
+ return reqs
+
+ def discretize(self):
+ if self.discretized:
+ return
+ super(PolynomialInterpolationFilterBase, self).discretize()
+ dFin, dFout = self.dFin, self.dFout
+ ghosts = self.dFin.topology_state.transposed(self.required_input_ghosts)
+ psi = self.polynomial_interpolator.generate_subgrid_interpolator(
+ grid_ratio=self.grid_ratio)
+ self.subgrid_interpolator = psi
+ self.fin = dFin.sdata[dFin.local_slices(ghosts=ghosts)].handle
+ self.fout = dFout.sdata[dFout.compute_slices].handle
+ self.iter_shape = self.dFin.compute_resolution + 1 - self.dFin.periodicity
+
+
+class PolynomialRestrictionFilterBase(PolynomialInterpolationMethod, RestrictionFilterBase):
+ """
+ Base implementation for polynomial interpolation.
+ """
+ @debug
+ def get_field_requirements(self):
+ reqs = super(PolynomialRestrictionFilterBase, self).get_field_requirements()
+ iratio = self.iratio
+ pghosts = self.polynomial_interpolator.ghosts
+ ghosts = np.add(np.multiply(iratio, np.add(pghosts,1)), -1)
+ Fin_topo, Fin_requirements = reqs.get_input_requirement(self.Fin)
+ Fin_requirements.min_ghosts = ghosts
+ self.required_input_ghosts = ghosts
+ return reqs
+
+ def discretize(self):
+ if self.discretized:
+ return
+ super(PolynomialRestrictionFilterBase, self).discretize()
+ dFin, dFout = self.dFin, self.dFout
+ ghosts = self.dFin.topology_state.transposed(self.required_input_ghosts)
+ psr = self.polynomial_interpolator.generate_subgrid_interpolator(
+ grid_ratio=self.grid_ratio).generate_subgrid_restrictor()
+ assert all(psr.ghosts == ghosts)
+ self.subgrid_restrictor = psr
+ self.fin = dFin.sdata[dFin.local_slices(ghosts=ghosts)].handle
+ self.fout = dFout.sdata[dFout.compute_slices].handle
+ self.iter_shape = self.dFout.compute_resolution
diff --git a/hysop/operator/base/spectral_operator.py b/hysop/operator/base/spectral_operator.py
index 5b5779eebf97228147854d355b78325ee09b0f0a..d3d3396b37d7c5ea436f53cfa63144711736b9e9 100644
--- a/hysop/operator/base/spectral_operator.py
+++ b/hysop/operator/base/spectral_operator.py
@@ -1,27 +1,27 @@
-
-import warnings, math, os
+import warnings
+import math
+import os
import sympy as sm
import numpy as np
-from hysop.constants import BoundaryCondition, BoundaryExtension, TransformType, \
- MemoryOrdering, TranspositionState, Backend, \
- SpectralTransformAction, Implementation
-from hysop.tools.misc import compute_nbytes
-from hysop.tools.types import check_instance, to_tuple, first_not_None, to_set
-from hysop.tools.decorators import debug
-from hysop.tools.units import bytes2str
+from hysop.constants import BoundaryCondition, BoundaryExtension, TransformType, \
+ MemoryOrdering, TranspositionState, Backend, \
+ SpectralTransformAction, Implementation
+from hysop.tools.misc import compute_nbytes
+from hysop.tools.types import check_instance, to_tuple, first_not_None, to_set
+from hysop.tools.decorators import debug
+from hysop.tools.units import bytes2str
from hysop.tools.numerics import is_fp, is_complex, complex_to_float_dtype, \
- float_to_complex_dtype, determine_fp_types
+ float_to_complex_dtype, determine_fp_types
from hysop.tools.io_utils import IOParams
from hysop.tools.spectral_utils import SpectralTransformUtils as STU, EnergyPlotter, EnergyDumper
-from hysop.core.mpi import main_rank
from hysop.core.arrays.array_backend import ArrayBackend
from hysop.core.arrays.array import Array
from hysop.core.memory.memory_request import MemoryRequest, OperatorMemoryRequests
from hysop.core.graph.graph import not_initialized as _not_initialized, \
- initialized as _initialized, \
- discretized as _discretized, \
- ready as _ready
+ initialized as _initialized, \
+ discretized as _discretized, \
+ ready as _ready
from hysop.core.graph.computational_node_frontend import ComputationalGraphNodeFrontend
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.parameters.buffer_parameter import BufferParameter
@@ -30,21 +30,21 @@ from hysop.symbolic.array import SymbolicArray
from hysop.symbolic.spectral import WaveNumber, SpectralTransform, AppliedSpectralTransform
from hysop.numerics.fft.fft import FFTI, simd_alignment, is_byte_aligned, HysopFFTWarning
+
class SpectralComputationalGraphNodeFrontend(ComputationalGraphNodeFrontend):
-
+
def __init__(self, implementation, **kwds):
impl, extra_kwds = self.get_actual_implementation(implementation=implementation, **kwds)
for k in extra_kwds.keys():
assert k not in kwds
kwds.update(extra_kwds)
super(SpectralComputationalGraphNodeFrontend, self).__init__(
- implementation=impl, **kwds)
+ implementation=impl, **kwds)
-
@classmethod
- def get_actual_implementation(cls, implementation,
- enforce_implementation=True, cl_env=None,
- **kwds):
+ def get_actual_implementation(cls, implementation,
+ enforce_implementation=True, cl_env=None,
+ **kwds):
"""
Parameters
----------
@@ -69,26 +69,26 @@ class SpectralComputationalGraphNodeFrontend(ComputationalGraphNodeFrontend):
Notes
-----
clFFT (gpyFFT) support for OpenCL CPU devices is a bit neglected.
- This function allows to override the implementation target from
+ This function allows to override the implementation target from
OPENCL to PYTHON when a CPU OpenCL environment is given as input.
- By default, the CPU FFT target is FFTW (pyFFTW) which has much
+ By default, the CPU FFT target is FFTW (pyFFTW) which has much
better support (multithreaded fftw + multithreaded numba).
-
- OpenCL buffers are mapped to host memory with enqueue_map_buffer
- (this makes the assumption thal all OpenCL buffers have been allocated
+
+ OpenCL buffers are mapped to host memory with enqueue_map_buffer
+ (this makes the assumption thal all OpenCL buffers have been allocated
with zero-copy capability in the target OpenCL platform).
"""
implementation = first_not_None(implementation, cls.default_implementation())
assert implementation in cls.implementations()
- extra_kwds = { 'enable_opencl_host_buffer_mapping': False }
+ extra_kwds = {'enable_opencl_host_buffer_mapping': False}
if (enforce_implementation):
return (implementation, extra_kwds)
if (implementation == Implementation.OPENCL):
if (cl_env is None):
- msg='enforce_implementation was set to False, '
- msg+='implementation is OPENCL, but no cl_env was passed '
- msg+='to check if the device is of type CPU.'
+ msg = 'enforce_implementation was set to False, '
+ msg += 'implementation is OPENCL, but no cl_env was passed '
+ msg += 'to check if the device is of type CPU.'
raise RuntimeError(msg)
from hysop.backend.device.opencl import cl
if (cl_env.device.type == cl.device_type.CPU):
@@ -97,30 +97,29 @@ class SpectralComputationalGraphNodeFrontend(ComputationalGraphNodeFrontend):
from hysop.backend.host.host_operator import HostOperator, OpenClMappable
op_cls = cls.implementations()[Implementation.PYTHON]
if not issubclass(op_cls, HostOperator):
- msg='Operator {} is not a HostOperator.'
- msg=msg.format(op_cls)
+ msg = 'Operator {} is not a HostOperator.'
+ msg = msg.format(op_cls)
raise TypeError(msg)
if not issubclass(op_cls, OpenClMappable):
- msg='Operator {} does not support host to device opencl buffer mapping.'
- msg=msg.format(op_cls)
+ msg = 'Operator {} does not support host to device opencl buffer mapping.'
+ msg = msg.format(op_cls)
raise TypeError(msg)
- assert Backend.HOST in op_cls.supported_backends()
+ assert Backend.HOST in op_cls.supported_backends()
assert Backend.OPENCL in op_cls.supported_backends()
return (Implementation.PYTHON, extra_kwds)
return (implementation, extra_kwds)
-
class SpectralOperatorBase(object):
"""
Common implementation interface for spectral based operators.
"""
-
- min_fft_alignment = simd_alignment #FFTW SIMD.
-
+
+ min_fft_alignment = simd_alignment # FFTW SIMD.
+
@debug
- def __init__(self, fft_interface=None, fft_interface_kwds=None,
- **kwds):
+ def __init__(self, fft_interface=None, fft_interface_kwds=None,
+ **kwds):
"""
Initialize a spectral operator base.
kwds: dict
@@ -131,20 +130,20 @@ class SpectralOperatorBase(object):
check_instance(fft_interface, FFTI, allow_none=True)
check_instance(fft_interface_kwds, dict, allow_none=True)
- self.transform_groups = {} # dict[tag] -> SpectralTransformGroup
-
+ self.transform_groups = {} # dict[tag] -> SpectralTransformGroup
+
# those values will be deleted at discretization
self._fft_interface = fft_interface
self._fft_interface_kwds = fft_interface_kwds
@property
def backend(self):
- msg='FFT array backend depends on the transform group. Please use op.transform_group[key].backend instead.'
+ msg = 'FFT array backend depends on the transform group. Please use op.transform_group[key].backend instead.'
raise AttributeError(msg)
@property
def FFTI(self):
- msg='FFT interface depends on the transform group. Please use op.transform_group[key].FFTI instead.'
+ msg = 'FFT interface depends on the transform group. Please use op.transform_group[key].FFTI instead.'
raise AttributeError(msg)
def new_transform_group(self, tag=None, mem_tag=None):
@@ -154,9 +153,9 @@ class SpectralOperatorBase(object):
backward field transforms as well as symbolic expressions and
wave_numbers symbols.
"""
- n = len(self.transform_groups)
- tag = first_not_None(tag, 'transform_group_{}'.format(n))
- msg = 'Tag "{}" has already been registered.'
+ n = len(self.transform_groups)
+ tag = first_not_None(tag, 'transform_group_{}'.format(n))
+ msg = 'Tag "{}" has already been registered.'
assert (tag not in self.transform_groups), msg.format(tag)
trg = SpectralTransformGroup(op=self, tag=tag, mem_tag=mem_tag)
self.transform_groups[tag] = trg
@@ -173,29 +172,38 @@ class SpectralOperatorBase(object):
super(SpectralOperatorBase, self).initialize(**kwds)
for tg in self.transform_groups.values():
tg.initialize(**kwds)
-
+
def get_field_requirements(self):
requirements = super(SpectralOperatorBase, self).get_field_requirements()
-
+
for is_input, (field, td, req) in requirements.iter_requirements():
req.memory_order = MemoryOrdering.C_CONTIGUOUS
req.axes = (TranspositionState[field.dim].default_axes(),)
can_split = req.can_split
- can_split[-1] = False
+ can_split[-1] = False
can_split[:-1] = True
req.can_split = can_split
return requirements
-
+
@debug
def get_node_requirements(self):
node_reqs = super(SpectralOperatorBase, self).get_node_requirements()
node_reqs.enforce_unique_topology_shape = True
return node_reqs
-
-
+
def discretize(self, **kwds):
super(SpectralOperatorBase, self).discretize(**kwds)
-
+
+ comm = self.mpi_params.comm
+ size = self.mpi_params.size
+ if (size > 1):
+ msg = '\n[FATAL ERROR] Spectral operators do not support the MPI interface yet.'
+ msg += '\nPlease use the Fortran FFTW interface if possible or '
+ msg += 'use another discretization method for operator {}.\n'
+ msg = msg.format(self.node_tag)
+ print msg
+ raise NotImplementedError
+
for tg in self.transform_groups.values():
tg.discretize(fft_interface=self._fft_interface,
fft_interface_kwds=self._fft_interface_kwds,
@@ -203,14 +211,14 @@ class SpectralOperatorBase(object):
**kwds)
del self._fft_interface
del self._fft_interface_kwds
-
+
def get_mem_requests(self, **kwds):
memory_requests = {}
for tg in self.transform_groups.values():
- for (k,v) in tg.get_mem_requests(**kwds).iteritems():
- check_instance(k, str) # temporary buffer name
- check_instance(v, int) # nbytes
- K = (k,tg.backend)
+ for (k, v) in tg.get_mem_requests(**kwds).iteritems():
+ check_instance(k, str) # temporary buffer name
+ check_instance(v, int) # nbytes
+ K = (k, tg.backend)
if K in memory_requests:
memory_requests[K] = max(memory_requests[K], v)
else:
@@ -219,16 +227,15 @@ class SpectralOperatorBase(object):
def get_work_properties(self, **kwds):
requests = super(SpectralOperatorBase, self).get_work_properties(**kwds)
- for ((k,backend),v) in self.get_mem_requests(**kwds).iteritems():
+ for ((k, backend), v) in self.get_mem_requests(**kwds).iteritems():
check_instance(k, str)
check_instance(v, (int, long))
- if (v>0):
- mrequest = MemoryRequest(backend=backend, size=v,
- alignment=self.min_fft_alignment)
+ if (v > 0):
+ mrequest = MemoryRequest(backend=backend, size=v,
+ alignment=self.min_fft_alignment)
requests.push_mem_request(request_identifier=k, mem_request=mrequest)
return requests
-
def setup(self, work):
self.allocate_tmp_fields(work)
for tg in self.transform_groups.values():
@@ -236,25 +243,24 @@ class SpectralOperatorBase(object):
super(SpectralOperatorBase, self).setup(work=work)
-
class SpectralTransformGroup(object):
"""
- Build and check a FFT transform group.
-
- This object tells the planner to build a full forward transform for all given
- forward_fields. The planner will also build backward transforms for all specified
+ Build and check a FFT transform group.
+
+ This object tells the planner to build a full forward transform for all given
+ forward_fields. The planner will also build backward transforms for all specified
backward_fields.
-
+
The object will also automatically build per-axis wavenumbers up to certain powers,
extracted from user provided sympy expressions.
- Finally boundary condition (ie. transform type) compability will be checked by
+ Finally boundary condition (ie. transform type) compability will be checked by
using user provided sympy expressions.
-
+
Calling a forward transform ensures that forward source field is read-only
and not destroyed.
"""
- DEBUG=False
+ DEBUG = False
def __init__(self, op, tag, mem_tag, **kwds):
"""
@@ -265,7 +271,7 @@ class SpectralTransformGroup(object):
tag: str
A tag to identify this transform group.
Each tag can only be registered once in a SpectralOperatorBase instance.
-
+
Attributes:
-----------
tag: str
@@ -276,7 +282,7 @@ class SpectralTransformGroup(object):
Forward fields to be planned for transform, according to Field boundary conditions.
backward_fields: list of backward SpectralTransform
Backward fields to be planned for transform, according to Field boundary conditions.
-
+
Notes
-----
All forward_fields and backward_fields have to live on the same domain and
@@ -297,21 +303,24 @@ class SpectralTransformGroup(object):
self._wave_numbers = set()
self._indexed_wave_numbers = {}
self._expressions = ()
-
+
self._discrete_wave_numbers = None
def indexed_wavenumbers(self, *wave_numbers):
return tuple(self._indexed_wave_numbers[Wi] for Wi in wave_numbers)
-
+
@property
def op(self):
return self._op
+
@property
def tag(self):
return self._tag
+
@property
def mem_tag(self):
return self._mem_tag
+
@property
def name(self):
return self._tag
@@ -319,9 +328,11 @@ class SpectralTransformGroup(object):
@property
def initialized(self):
return self._op.initialized
+
@property
def discretized(self):
return self._op.discretized
+
@property
def ready(self):
return self._op.ready
@@ -329,26 +340,29 @@ class SpectralTransformGroup(object):
@property
def forward_fields(self):
return map(lambda x: x[0], self._forward_transforms.keys())
+
@property
def backward_fields(self):
return map(lambda x: x[0], self._backward_transforms.keys())
+
@property
def forward_transforms(self):
return self._forward_transforms
+
@property
def backward_transforms(self):
return self._backward_transforms
-
+
@_not_initialized
- def initialize(self,
- fft_granularity=None,
- fft_concurrent_plans=1,
- fft_plan_workload=1,
- **kwds):
+ def initialize(self,
+ fft_granularity=None,
+ fft_concurrent_plans=1,
+ fft_plan_workload=1,
+ **kwds):
"""
Should be called after all require_forward_transform and require_backward_transform
calls.
-
+
Parameters
----------
fft_granularity: int, optional
@@ -358,37 +372,37 @@ class SpectralTransformGroup(object):
3: iterate over 3d blocks (slices of dimension 3)
n-1: iterate over hyperplans (slices of dimension n-1)
n : no iteration, the plan will handle the whole domain.
- Contiguous buffers with sufficient alignement are allocated.
+ Contiguous buffers with sufficient alignement are allocated.
Default value is: 1 in 1D else n-1 (ie. hyperplans)
fft_plan_workload: int, optional, defaults to 1
- The number of blocks of dimension fft_granularity that a
+ The number of blocks of dimension fft_granularity that a
single plan will handle at once. Default is one block.
fft_concurrent_plans: int, optional, defaults to 1
- Number of concurrent plans.
+ Number of concurrent plans.
Should be 1 for HOST based FFT interfaces.
Should be at least 3 for DEVICE based FFT interface if the device
has two async copy engine (copy, transform, copy).
"""
- (domain, dim) = self.check_fields(self.forward_fields, self.backward_fields)
+ (domain, dim) = self.check_fields(self.forward_fields, self.backward_fields)
- fft_granularity = first_not_None(fft_granularity, max(1,dim-1))
+ fft_granularity = first_not_None(fft_granularity, max(1, dim-1))
check_instance(fft_granularity, int, minval=1, maxval=dim)
check_instance(fft_concurrent_plans, int, minval=1)
check_instance(fft_plan_workload, int, minval=1)
- self._fft_granularity = fft_granularity
+ self._fft_granularity = fft_granularity
self._fft_concurrent_plans = fft_concurrent_plans
- self._fft_plan_workload = fft_plan_workload
+ self._fft_plan_workload = fft_plan_workload
self._domain = domain
self._dim = dim
-
+
@_initialized
- def discretize(self, fft_interface, fft_interface_kwds,
- enable_opencl_host_buffer_mapping, **kwds):
+ def discretize(self, fft_interface, fft_interface_kwds,
+ enable_opencl_host_buffer_mapping, **kwds):
backends = set()
grid_resolutions = set()
- compute_axes = set()
+ compute_axes = set()
compute_shapes = set()
compute_dtypes = set()
for fwd in self.forward_transforms.values():
@@ -407,87 +421,88 @@ class SpectralTransformGroup(object):
compute_dtypes.add(bwd.input_dtype)
def format_error(data):
- return '\n *'+ '\n *'.join(str(x) for x in data)
- msg='Fields do not live on the same backend:'+format_error(backends)
- assert len(backends)==1, msg
- msg='Fields grid size mismatch:'+format_error(grid_resolutions)
- assert len(grid_resolutions)==1, msg
- assert len(compute_axes)==1, 'Fields axes mismatch:'+format_error(compute_axes)
- assert len(compute_shapes)==1, 'Fields shape mismatch:'+format_error(compute_shapes)
- assert len(compute_dtypes)==1, 'Fields data type mismatch.'+format_error(compute_dtypes)
-
- backend = next(iter(backends))
+ return '\n *' + '\n *'.join(str(x) for x in data)
+ msg = 'Fields do not live on the same backend:'+format_error(backends)
+ assert len(backends) == 1, msg
+ msg = 'Fields grid size mismatch:'+format_error(grid_resolutions)
+ assert len(grid_resolutions) == 1, msg
+ assert len(compute_axes) == 1, 'Fields axes mismatch:'+format_error(compute_axes)
+ assert len(compute_shapes) == 1, 'Fields shape mismatch:'+format_error(compute_shapes)
+ assert len(compute_dtypes) == 1, 'Fields data type mismatch.'+format_error(compute_dtypes)
+
+ backend = next(iter(backends))
grid_resolution = next(iter(grid_resolutions))
- compute_axes = next(iter(compute_axes))
- compute_shape = next(iter(compute_shapes))
- compute_dtype = next(iter(compute_dtypes))
-
+ compute_axes = next(iter(compute_axes))
+ compute_shape = next(iter(compute_shapes))
+ compute_dtype = next(iter(compute_dtypes))
+
if enable_opencl_host_buffer_mapping:
- msg='Trying to enable opencl device to host buffer mapping on {} target.'
+ msg = 'Trying to enable opencl device to host buffer mapping on {} target.'
assert (backend.kind is Backend.OPENCL), msg.format(backend.kind)
if (fft_interface is None):
fft_interface_kwds = first_not_None(fft_interface_kwds, {})
- fft_interface = FFTI.default_interface_from_backend(backend,
- enable_opencl_host_buffer_mapping=enable_opencl_host_buffer_mapping,
- **fft_interface_kwds)
+ fft_interface = FFTI.default_interface_from_backend(backend,
+ enable_opencl_host_buffer_mapping=enable_opencl_host_buffer_mapping,
+ **fft_interface_kwds)
else:
assert not interface_kwds, 'FFT interface has already been built.'
-
+
check_instance(fft_interface, FFTI)
- fft_interface.check_backend(backend,
- enable_opencl_host_buffer_mapping=enable_opencl_host_buffer_mapping)
+ fft_interface.check_backend(backend,
+ enable_opencl_host_buffer_mapping=enable_opencl_host_buffer_mapping)
buffer_backend = backend
- host_backend = backend.host_array_backend
- backend = fft_interface.backend
-
+ host_backend = backend.host_array_backend
+ backend = fft_interface.backend
+
discrete_wave_numbers = {}
for wn in self._wave_numbers:
(idx, freqs, nd_freqs) = self.build_wave_number(self._domain, grid_resolution,
- backend, wn,
- compute_dtype, compute_axes, compute_shape)
- self._indexed_wave_numbers[wn].indexed_object.to_backend(backend.kind).bind_memory_object(freqs)
+ backend, wn,
+ compute_dtype, compute_axes, compute_shape)
+ self._indexed_wave_numbers[wn].indexed_object.to_backend(
+ backend.kind).bind_memory_object(freqs)
self._indexed_wave_numbers[wn].index.bind_axes(compute_axes)
discrete_wave_numbers[wn] = (idx, freqs, nd_freqs)
self._discrete_wave_numbers = discrete_wave_numbers
self.buffer_backend = buffer_backend
- self.host_backend = host_backend
- self.backend = backend
- self.FFTI = fft_interface
-
+ self.host_backend = host_backend
+ self.backend = backend
+ self.FFTI = fft_interface
+
self.grid_resolution = grid_resolution
- self.compute_axes = compute_axes
+ self.compute_axes = compute_axes
self.compute_shape = compute_shape
self.compute_dtype = compute_dtype
-
+
@classmethod
def build_wave_number(cls, domain, grid_resolution,
- backend, wave_number,
- compute_dtype, compute_axes,
- compute_resolution):
+ backend, wave_number,
+ compute_dtype, compute_axes,
+ compute_resolution):
- dim = domain.dim
+ dim = domain.dim
length = domain.length
ftype, ctype = determine_fp_types(compute_dtype)
-
- axis = wave_number.axis
+
+ axis = wave_number.axis
transform = wave_number.transform
- exponent = wave_number.exponent
-
+ exponent = wave_number.exponent
+
idx = compute_axes.index(axis)
L = domain.length[axis]
N = grid_resolution[axis]
-
+
freqs = STU.compute_wave_numbers(transform=transform, N=N, L=L, ftype=ftype)
freqs = freqs**exponent
if STU.is_R2R(transform):
sign_offset = STU.is_cosine(transform)
freqs *= (-1)**((exponent+sign_offset)//2)
-
+
assert exponent != 0, 'exponent cannot be zero.'
assert exponent > 0, 'negative powers not implemented yet.'
if is_complex(freqs.dtype) and (exponent % 2 == 0):
@@ -498,14 +513,14 @@ class SpectralTransformGroup(object):
backend_freqs[...] = freqs
freqs = backend_freqs
- nd_shape = [1,]*dim
+ nd_shape = [1, ]*dim
nd_shape[idx] = freqs.size
nd_shape = tuple(nd_shape)
nd_freqs = freqs.reshape(nd_shape)
if cls.DEBUG:
print
- print 'BUILD WAVENUMBER'
+ print 'BUILD WAVENUMBER'
print 'backend: {}'.format(backend.kind)
print 'grid_shape: {}'.format(grid_resolution)
print 'length: {}'.format(length)
@@ -528,40 +543,40 @@ class SpectralTransformGroup(object):
print '----'
return (idx, freqs, nd_freqs)
-
+
@_discretized
def get_mem_requests(self, **kwds):
memory_requests = {}
for fwd in self.forward_transforms.values():
mem_requests = fwd.get_mem_requests(**kwds)
- check_instance(mem_requests, dict, keys=str, values=(int,long))
- for (k,v) in mem_requests.iteritems():
+ check_instance(mem_requests, dict, keys=str, values=(int, long))
+ for (k, v) in mem_requests.iteritems():
if k in memory_requests:
memory_requests[k] = max(memory_requests[k], v)
else:
memory_requests[k] = v
for bwd in self.backward_transforms.values():
mem_requests = bwd.get_mem_requests(**kwds)
- check_instance(mem_requests, dict, keys=str, values=(int,long))
- for (k,v) in mem_requests.iteritems():
+ check_instance(mem_requests, dict, keys=str, values=(int, long))
+ for (k, v) in mem_requests.iteritems():
if k in memory_requests:
memory_requests[k] = max(memory_requests[k], v)
else:
memory_requests[k] = v
return memory_requests
-
+
@_discretized
def setup(self, work):
for fwd in self.forward_transforms.values():
- fwd.setup(work=work)
+ fwd.setup(work=work)
for bwd in self.backward_transforms.values():
- bwd.setup(work=work)
+ bwd.setup(work=work)
@_not_initialized
def require_forward_transform(self, field, axes=None, transform_tag=None,
- custom_output_buffer=None, action=None,
- dump_energy=None, plot_energy=None,
- **kwds):
+ custom_output_buffer=None, action=None,
+ dump_energy=None, plot_energy=None,
+ **kwds):
"""
Tells this SpectralTransformGroup to build a forward SpectralTransform
on given field. Only specified axes are transformed.
@@ -570,8 +585,8 @@ class SpectralTransformGroup(object):
Periodic: Periodic extension
Homogeneous Dirichlet: Odd extension
Homogeneous Neumann: Even extension
-
- This leads to 5 possible transforms for each axis (periodic-periodic, even-even,
+
+ This leads to 5 possible transforms for each axis (periodic-periodic, even-even,
odd-odd, even-odd, odd-even).
Forward transforms used for each axis per extension pair:
@@ -582,15 +597,15 @@ class SpectralTransformGroup(object):
*Neumann-Neumann (EVEN-EVEN): DCT-I
This method will return the SpectralTransform object associated to field.
-
+
Parameters
----------
- field: ScalarField
+ field: ScalarField
The source field to be transformed.
axes: array-like of integers
The axes to be transformed.
transform_tag: str
- Extra tag to register the forward transform (a single scalar field can be
+ Extra tag to register the forward transform (a single scalar field can be
transformed multiple times). Default tag is 'default'.
custom_output_buffer: None or str, optional
Force this transform to output in one of the two common transform group buffers.
@@ -601,7 +616,7 @@ class SpectralTransformGroup(object):
FFT operators to save one buffer for the last forward transform.
Specifying 'auto' will tell the planner to choose either 'B0' or 'B1'.
action: BackwardTransfromAction, optional
- Defaults to SpectralTransformAction.OVERWRITE which will overwrite the
+ Defaults to SpectralTransformAction.OVERWRITE which will overwrite the
compute slices of the output buffer.
SpectralTransformAction.ACCUMULATE will sum the current content of the buffer
with the result of the forward transform.
@@ -621,7 +636,7 @@ class SpectralTransformGroup(object):
dump_energy plot_energy result
- None None nothing
+ None None nothing
iop0 0 energy is computed and dumped every iop0.frequency iterations
0 iop1 energy is computed and dumped every iop1.frequency iterations
iop0 iop1 energy is computed every iop1.frequency and iop2.frequency iterations
@@ -629,7 +644,7 @@ class SpectralTransformGroup(object):
plotted every iop1.frequency
About frequency:
- if (frequency<0) no dump
+ if (frequency<0) no dump
if (frequency==0) dump at time of interests and last iteration
if (frequency>=0) dump at time of interests, last iteration and every freq iterations
@@ -641,50 +656,52 @@ class SpectralTransformGroup(object):
check_instance(transform_tag, str)
check_instance(action, SpectralTransformAction)
transforms = SpectralTransform(field=field, axes=axes, forward=True)
- msg='Field {} with axes {} and transform_tag "{}" has already been registered for forward transform.'
+ msg = 'Field {} with axes {} and transform_tag "{}" has already been registered for forward transform.'
if field.is_tensor:
planned_transforms = field.new_empty_array()
for (idx, f) in field.nd_iter():
- assert (f,axes,transform_tag) not in self._forward_transforms, msg.format(f.name, axes, transform_tag)
+ assert (f, axes, transform_tag) not in self._forward_transforms, msg.format(
+ f.name, axes, transform_tag)
assert f in self._op.input_fields
assert f is transforms[idx].field
assert transforms[idx].is_forward
planned_transforms[idx] = PlannedSpectralTransform(transform_group=self,
- tag=self.tag + '_' + transform_tag + '_' + f.name,
- symbolic_transform=transforms[idx],
- custom_output_buffer=custom_output_buffer,
- action=action,
- dump_energy=dump_energy,
- plot_energy=plot_energy,
- **kwds)
- self._forward_transforms[(f,axes,transform_tag)] = planned_transforms[idx]
+ tag=self.tag + '_' + transform_tag + '_' + f.name,
+ symbolic_transform=transforms[idx],
+ custom_output_buffer=custom_output_buffer,
+ action=action,
+ dump_energy=dump_energy,
+ plot_energy=plot_energy,
+ **kwds)
+ self._forward_transforms[(f, axes, transform_tag)] = planned_transforms[idx]
else:
- assert (field,axes,transform_tag) not in self._forward_transforms, msg.format(field.name, axes, transform_tag)
+ assert (field, axes, transform_tag) not in self._forward_transforms, msg.format(
+ field.name, axes, transform_tag)
assert field in self._op.input_fields
assert field is transforms.field
assert transforms.is_forward
planned_transforms = PlannedSpectralTransform(transform_group=self,
- tag=self.tag + '_' + transform_tag + '_' + field.name,
- symbolic_transform=transforms,
- custom_output_buffer=custom_output_buffer,
- action=action,
- dump_energy=dump_energy,
- plot_energy=plot_energy,
- **kwds)
- self._forward_transforms[(field,axes,transform_tag)] = planned_transforms
+ tag=self.tag + '_' + transform_tag + '_' + field.name,
+ symbolic_transform=transforms,
+ custom_output_buffer=custom_output_buffer,
+ action=action,
+ dump_energy=dump_energy,
+ plot_energy=plot_energy,
+ **kwds)
+ self._forward_transforms[(field, axes, transform_tag)] = planned_transforms
return planned_transforms
-
+
@_not_initialized
def require_backward_transform(self, field, axes=None, transform_tag=None,
- custom_input_buffer=None,
- matching_forward_transform=None,
- action=None,
- dump_energy=None, plot_energy=None,
- **kwds):
+ custom_input_buffer=None,
+ matching_forward_transform=None,
+ action=None,
+ dump_energy=None, plot_energy=None,
+ **kwds):
"""
Same as require_forward_transform but for backward transforms.
This corresponds to the following backward transform mappings:
-
+
if order[axis] is 0:
*no transform -> no transform
else, if order[axis] is even:
@@ -701,7 +718,7 @@ class SpectralTransformGroup(object):
*DCT-III -> DST-II
*DST-I -> DCT-I
*DST-III -> DCT-II
-
+
For backward transforms, boundary compatibility for output_fields is thus the following:
if axis is even:
Boundary should be exactly the same on the axis.
@@ -713,15 +730,15 @@ class SpectralTransformGroup(object):
*(Dirichlet-Dirichlet) ODD-ODD -> EVEN-EVEN (Neumann-Neumann)
Order and boundary conditions are decuded from field.
-
+
Parameters
----------
- field: ScalarField
+ field: ScalarField
The target field where the result of the inverse transform will be stored.
axes: array-like of integers
The axes to be transformed.
transform_tag: str
- Extra tag to register the backward transform (a single scalar field can be
+ Extra tag to register the backward transform (a single scalar field can be
transformed multiple times). Default tag is 'default'.
custom_input_buffer: None or str or F, optional
Force this transform to take as input one of the two common transform group buffers.
@@ -733,7 +750,7 @@ class SpectralTransformGroup(object):
Specifying 'auto' will tell the planner to use the matching
transform output buffer.
action: BackwardTransfromAction, optional
- Defaults to SpectralTransformAction.OVERWRITE which will overwrite the
+ Defaults to SpectralTransformAction.OVERWRITE which will overwrite the
compute slices of the given output field.
SpectralTransformAction.ACCUMULATE will sum the current content of the field
with the result of the backward transform.
@@ -753,16 +770,16 @@ class SpectralTransformGroup(object):
{ite} is replaced with simulation iteration id for plotting and '' for file dumping.
- dump_energy plot_energy result
- None None nothing
- iop0 0 energy is computed and dumped every iop0.frequency iterations
- 0 iop1 energy is computed and dumped every iop1.frequency iterations
- iop0 iop1 energy is computed every iop1.frequency and iop2.frequency iterations
+ dump_energy plot_energy result
+ None None nothing
+ iop0 0 energy is computed and dumped every iop0.frequency iterations
+ 0 iop1 energy is computed and dumped every iop1.frequency iterations
+ iop0 iop1 energy is computed every iop1.frequency and iop2.frequency iterations
dumped every iop0.frequency
plotted every iop1.frequency
About frequency:
- if (frequency<0) no dump
+ if (frequency<0) no dump
if (frequency==0) dump at time of interests and last iteration
if (frequency>=0) dump at time of interests, last iteration and every freq iterations
@@ -773,39 +790,41 @@ class SpectralTransformGroup(object):
check_instance(transform_tag, str)
check_instance(action, SpectralTransformAction)
transforms = SpectralTransform(field=field, axes=axes, forward=False)
- msg='Field {} with axes {} and transform_tag "{}" has already been registered for backward transform.'
+ msg = 'Field {} with axes {} and transform_tag "{}" has already been registered for backward transform.'
if field.is_tensor:
planned_transforms = field.new_empty_array()
for (idx, f) in field.nd_iter():
- assert (f,axes,transform_tag) not in self._backward_transforms, msg.format(f.name, axes, transform_tag)
+ assert (f, axes, transform_tag) not in self._backward_transforms, msg.format(
+ f.name, axes, transform_tag)
assert f in self._op.output_fields
assert not transforms[idx].is_forward
planned_transforms[idx] = PlannedSpectralTransform(transform_group=self,
- tag=self.tag + '_' + transform_tag + '_' + f.name,
- symbolic_transform=transforms[idx],
- custom_input_buffer=custom_input_buffer,
- matching_forward_transform=matching_forward_transform,
- action=action,
- dump_energy=dump_energy,
- plot_energy=plot_energy,
- **kwds)
- self._backward_transforms[(f,axes,transform_tag)] = planned_transforms[idx]
+ tag=self.tag + '_' + transform_tag + '_' + f.name,
+ symbolic_transform=transforms[idx],
+ custom_input_buffer=custom_input_buffer,
+ matching_forward_transform=matching_forward_transform,
+ action=action,
+ dump_energy=dump_energy,
+ plot_energy=plot_energy,
+ **kwds)
+ self._backward_transforms[(f, axes, transform_tag)] = planned_transforms[idx]
else:
- assert (field,axes,transform_tag) not in self._backward_transforms, msg.format(field.name, axes, transform_tag)
+ assert (field, axes, transform_tag) not in self._backward_transforms, msg.format(
+ field.name, axes, transform_tag)
assert field in self._op.output_fields
assert not transforms.is_forward
planned_transforms = PlannedSpectralTransform(transform_group=self,
- tag=self.tag + '_' + transform_tag + '_' + field.name,
- symbolic_transform=transforms,
- custom_input_buffer=custom_input_buffer,
- matching_forward_transform=matching_forward_transform,
- action=action,
- dump_energy=dump_energy,
- plot_energy=plot_energy,
- **kwds)
- self._backward_transforms[(field,axes,transform_tag)] = planned_transforms
+ tag=self.tag + '_' + transform_tag + '_' + field.name,
+ symbolic_transform=transforms,
+ custom_input_buffer=custom_input_buffer,
+ matching_forward_transform=matching_forward_transform,
+ action=action,
+ dump_energy=dump_energy,
+ plot_energy=plot_energy,
+ **kwds)
+ self._backward_transforms[(field, axes, transform_tag)] = planned_transforms
return planned_transforms
-
+
@property
def output_parameters(self):
parameters = set()
@@ -818,10 +837,10 @@ class SpectralTransformGroup(object):
assert self.discretized
discrete_wave_numbers = self._discrete_wave_numbers
if (discrete_wave_numbers is None):
- msg='discrete_wave_numbers has not been set yet.'
+ msg = 'discrete_wave_numbers has not been set yet.'
raise AttributeError(msg)
return self._discrete_wave_numbers
-
+
@_not_initialized
def push_expressions(self, *exprs):
exprs_wave_numbers = set()
@@ -841,42 +860,40 @@ class SpectralTransformGroup(object):
print ' wave_numbers: {}'.format(wn)
return tuple(exprs_wave_numbers)
-
-
+
@classmethod
def check_fields(cls, forward_fields, backward_fields):
all_fields = tuple(set(forward_fields+backward_fields))
if not all_fields:
- msg='At least one field is required.'
+ msg = 'At least one field is required.'
raise ValueError(msg)
domain = cls.determine_domain(*all_fields)
- dim = domain.dim
+ dim = domain.dim
return (domain, dim)
- @classmethod
+ @classmethod
def determine_domain(cls, *fields):
domain = fields[0].domain
for field in fields[1:]:
if (field.domain is not domain):
- msg='Domain mismatch between fields:\n{}\nvs.\n{}\n'
- msg=msg.format(domain, field.domain)
+ msg = 'Domain mismatch between fields:\n{}\nvs.\n{}\n'
+ msg = msg.format(domain, field.domain)
raise ValueError(msg)
return domain
-
class PlannedSpectralTransform(object):
"""
A planned spectral transform is an AppliedSpectralTransform wrapper.
This object will be handled by the transform planner.
"""
- DEBUG=False
+ DEBUG = False
def __init__(self, transform_group, tag, symbolic_transform, action,
- custom_input_buffer=None, custom_output_buffer=None,
- matching_forward_transform=None,
- dump_energy=None, plot_energy=None,compute_energy_frequencies=None):
-
+ custom_input_buffer=None, custom_output_buffer=None,
+ matching_forward_transform=None,
+ dump_energy=None, plot_energy=None, compute_energy_frequencies=None):
+
check_instance(transform_group, SpectralTransformGroup)
check_instance(transform_group.op, SpectralOperatorBase)
check_instance(tag, str)
@@ -884,48 +901,48 @@ class PlannedSpectralTransform(object):
check_instance(action, SpectralTransformAction)
check_instance(dump_energy, IOParams, allow_none=True)
check_instance(plot_energy, IOParams, allow_none=True)
- assert custom_input_buffer in (None, 'B0', 'B1', 'auto'), custom_input_buffer
+ assert custom_input_buffer in (None, 'B0', 'B1', 'auto'), custom_input_buffer
assert custom_output_buffer in (None, 'B0', 'B1', 'auto'), custom_output_buffer
- field = symbolic_transform.field
+ field = symbolic_transform.field
is_forward = symbolic_transform.is_forward
-
+
self._transform_group = transform_group
self._tag = tag
self._symbol = symbolic_transform
self._queue = None
- self._custom_input_buffer = custom_input_buffer
+ self._custom_input_buffer = custom_input_buffer
self._custom_output_buffer = custom_output_buffer
self._matching_forward_transform = matching_forward_transform
self._action = action
- self._do_dump_energy = (dump_energy is not None) and (dump_energy.frequency>=0)
- self._do_plot_energy = (plot_energy is not None) and (plot_energy.frequency>=0)
-
+ self._do_dump_energy = (dump_energy is not None) and (dump_energy.frequency >= 0)
+ self._do_plot_energy = (plot_energy is not None) and (plot_energy.frequency >= 0)
+
compute_energy_frequencies = to_set(first_not_None(compute_energy_frequencies, set()))
if self._do_dump_energy:
compute_energy_frequencies.add(dump_energy.frequency)
if self._do_plot_energy:
compute_energy_frequencies.add(plot_energy.frequency)
- compute_energy_frequencies = set(filter(lambda f: f>=0, compute_energy_frequencies))
- do_compute_energy = (len(compute_energy_frequencies)>0)
-
+ compute_energy_frequencies = set(filter(lambda f: f >= 0, compute_energy_frequencies))
+ do_compute_energy = (len(compute_energy_frequencies) > 0)
+
self._do_compute_energy = do_compute_energy
self._compute_energy_frequencies = compute_energy_frequencies
self._plot_energy_ioparams = plot_energy
self._dump_energy_ioparams = dump_energy
if self._do_compute_energy:
- ename = 'E{}_{}'.format('f' if is_forward else 'b', field.name)
+ ename = 'E{}_{}'.format('f' if is_forward else 'b', field.name)
pename = 'E{}_{}'.format('f' if is_forward else 'b', field.pretty_name)
vename = 'E{}_{}'.format('f' if is_forward else 'b', field.var_name)
self._energy_parameter = BufferParameter(name=ename, pretty_name=pename, var_name=vename,
- shape=None, dtype=None, initial_value=None)
+ shape=None, dtype=None, initial_value=None)
else:
self._energy_parameter = None
- self._energy_dumper = None
+ self._energy_dumper = None
self._energy_plotter = None
-
+
if is_forward:
msg = "Cannot specify 'custom_input_buffer' for a forward transform."
assert (custom_input_buffer is None), msg
@@ -935,75 +952,76 @@ class PlannedSpectralTransform(object):
msg = "Cannot specify 'custom_output_buffer' for a backward transform."
assert (self._custom_output_buffer is None), msg
if (self._custom_input_buffer == 'auto'):
- msg="Using 'auto' as 'custom_output_buffer' of a backward transform implies "
- msg+="to specify a 'matching_forward_transform' to choose the buffer from."
+ msg = "Using 'auto' as 'custom_output_buffer' of a backward transform implies "
+ msg += "to specify a 'matching_forward_transform' to choose the buffer from."
assert (matching_forward_transform is not None), msg
assert isinstance(matching_forward_transform, PlannedSpectralTransform), msg
assert matching_forward_transform.is_forward, msg
else:
- msg="Using 'custom_output_buffer' different than 'auto' for a backward "
- msg+="transform implies to set 'matching_forward_transform' to None."
+ msg = "Using 'custom_output_buffer' different than 'auto' for a backward "
+ msg += "transform implies to set 'matching_forward_transform' to None."
assert (matching_forward_transform is None), msg
# reorder transforms in execution order (contiguous axe first)
- transforms = self.s.transforms[::-1]
+ transforms = self.s.transforms[::-1]
- if len(transforms)!=field.dim:
- msg='Number of transforms does not match field dimension.'
+ if len(transforms) != field.dim:
+ msg = 'Number of transforms does not match field dimension.'
raise ValueError(msg)
if all((tr is TransformType.NONE) for tr in transforms):
- msg='All transforms are of type NONE.'
+ msg = 'All transforms are of type NONE.'
raise ValueError(msg)
-
+
if is_forward:
- input_dtype = field.dtype
+ input_dtype = field.dtype
output_dtype = STU.determine_output_dtype(
- field.dtype, *transforms)
+ field.dtype, *transforms)
else:
- input_dtype = STU.determine_input_dtype(
- field.dtype, *transforms)
+ input_dtype = STU.determine_input_dtype(
+ field.dtype, *transforms)
output_dtype = field.dtype
- self._input_dtype = np.dtype(input_dtype)
+ self._input_dtype = np.dtype(input_dtype)
self._output_dtype = np.dtype(output_dtype)
- self._input_shape = None
+ self._input_shape = None
self._output_shape = None
- self._input_buffer = None
+ self._input_buffer = None
self._output_buffer = None
self._dfield = None
- self._input_symbolic_arrays = set()
+ self._input_symbolic_arrays = set()
self._output_symbolic_arrays = set()
self._ready = False
@property
def output_parameters(self):
return {self._energy_parameter} - {None}
-
+
def input_symbolic_array(self, name, **kwds):
"""Create a symbolic array that will be bound to input transform array."""
assert ('memory_object' not in kwds)
assert ('dim' not in kwds)
- obj = SymbolicArray(name=name, memory_object=None,
- dim=self.field.dim, **kwds)
+ obj = SymbolicArray(name=name, memory_object=None,
+ dim=self.field.dim, **kwds)
self._input_symbolic_arrays.add(obj)
return obj
-
+
def output_symbolic_array(self, name, **kwds):
"""Create a symbolic array that will be bound to output transform array."""
assert ('memory_object' not in kwds)
assert ('dim' not in kwds)
- obj = SymbolicArray(name=name, memory_object=None,
- dim=self.field.dim, **kwds)
+ obj = SymbolicArray(name=name, memory_object=None,
+ dim=self.field.dim, **kwds)
self._output_symbolic_arrays.add(obj)
return obj
@property
def transform_group(self):
return self._transform_group
+
@property
def op(self):
return self._transform_group.op
@@ -1011,6 +1029,7 @@ class PlannedSpectralTransform(object):
@property
def tag(self):
return self._tag
+
@property
def name(self):
return self._tag
@@ -1018,19 +1037,23 @@ class PlannedSpectralTransform(object):
@property
def symbol(self):
return self._symbol
+
@property
def s(self):
return self._symbol
-
+
@property
def field(self):
return self._symbol.field
+
@property
def is_forward(self):
return self._symbol.is_forward
+
@property
def is_backward(self):
return not self.is_forward
+
@property
def transforms(self):
return self._symbol.transforms
@@ -1038,24 +1061,25 @@ class PlannedSpectralTransform(object):
@property
def input_dtype(self):
return self._input_dtype
+
@property
def output_dtype(self):
return self._output_dtype
-
@property
def backend(self):
assert self.discretized
backend = self._backend
if (backend is None):
- msg='backend has not been set yet.'
+ msg = 'backend has not been set yet.'
raise AttributeError(msg)
return backend
+
@property
def dfield(self):
assert self.discretized
if (self._dfield is None):
- msg='dfield has not been set.'
+ msg = 'dfield has not been set.'
raise AttributeError(msg)
return self._dfield
@@ -1063,114 +1087,120 @@ class PlannedSpectralTransform(object):
def input_shape(self):
assert self.discretized
if (self._input_shape is None):
- msg='input_shape has not been set.'
+ msg = 'input_shape has not been set.'
raise AttributeError(msg)
return self._input_shape
+
@property
def output_shape(self):
assert self.discretized
if (self._output_shape is None):
- msg='output_shape has not been set.'
+ msg = 'output_shape has not been set.'
raise AttributeError(msg)
return self._output_shape
-
+
@property
def input_transform_shape(self):
assert self.discretized
if (self._input_transform_shape is None):
- msg='input_transform_shape has not been set.'
+ msg = 'input_transform_shape has not been set.'
raise AttributeError(msg)
return self._input_transform_shape
+
@property
def output_transform_shape(self):
assert self.discretized
if (self._output_transform_shape is None):
- msg='output_transform_shape has not been set.'
+ msg = 'output_transform_shape has not been set.'
raise AttributeError(msg)
return self._output_transform_shape
-
+
@property
def input_axes(self):
assert self.discretized
if (self._input_axes is None):
- msg='input_axes has not been set.'
+ msg = 'input_axes has not been set.'
raise AttributeError(msg)
return self._input_axes
+
@property
def output_axes(self):
assert self.discretized
if (self._output_axes is None):
- msg='output_axes has not been set.'
+ msg = 'output_axes has not been set.'
raise AttributeError(msg)
return self._output_axes
-
+
@property
def input_slices(self):
assert self.discretized
buf = self._input_slices
if (buf is None):
- msg='input_slices has not been set yet.'
+ msg = 'input_slices has not been set yet.'
raise AttributeError(msg)
return buf
+
@property
def output_slices(self):
assert self.discretized
buf = self._output_slices
if (buf is None):
- msg='output_slices has not been set yet.'
+ msg = 'output_slices has not been set yet.'
raise AttributeError(msg)
return buf
-
+
@property
def input_buffer(self):
assert self.discretized
buf = self._input_buffer
if (buf is None):
- msg='input_buffer has not been set yet.'
+ msg = 'input_buffer has not been set yet.'
raise AttributeError(msg)
return buf
+
@property
def output_buffer(self):
assert self.discretized
buf = self._output_buffer
if (buf is None):
- msg='output_buffer has not been set yet.'
+ msg = 'output_buffer has not been set yet.'
raise AttributeError(msg)
return buf
-
+
@property
def full_input_buffer(self):
assert self.discretized
buf = self._full_input_buffer
if (buf is None):
- msg='full_input_buffer has not been set yet.'
+ msg = 'full_input_buffer has not been set yet.'
raise AttributeError(msg)
return buf
+
@property
def full_output_buffer(self):
assert self.discretized
buf = self._full_output_buffer
if (buf is None):
- msg='full_output_buffer has not been set yet.'
+ msg = 'full_output_buffer has not been set yet.'
raise AttributeError(msg)
return buf
-
+
@property
def initialized(self):
return self.op.initialized
+
@property
def discretized(self):
return self.op.discretized
+
@property
def ready(self):
return self._ready
-
@_not_initialized
def initialize(self, **kwds):
pass
-
-
+
@_initialized
def discretize(self, **kwds):
is_forward = self.is_forward
@@ -1180,65 +1210,66 @@ class PlannedSpectralTransform(object):
if is_forward:
(dfield, transform_info, transpose_info, transform_offsets) = \
- self._discretize_forward(field_axes, **kwds)
+ self._discretize_forward(field_axes, **kwds)
assert transpose_info[0][1] == field_axes
else:
(dfield, transform_info, transpose_info, transform_offsets) = \
- self._discretize_backward(field_axes, **kwds)
+ self._discretize_backward(field_axes, **kwds)
assert transpose_info[-1][2] == field_axes
- assert dfield.dim==len(transform_info)==len(transpose_info)==dim
- assert transform_info[0][2][1] == self._input_dtype
+ assert dfield.dim == len(transform_info) == len(transpose_info) == dim
+ assert transform_info[0][2][1] == self._input_dtype
assert transform_info[-1][3][1] == self._output_dtype
-
+
# filter out untransformed axes
tidx = tuple(filter(lambda i: not STU.is_none(transform_info[i][1]), xrange(dim)))
assert tidx, 'Could not determine any transformed axe.'
ntransforms = len(tidx)
transform_info = tuple(map(transform_info.__getitem__, tidx))
transpose_info = tuple(map(transpose_info.__getitem__, tidx))
- assert len(transform_info)==len(transpose_info)==ntransforms
+ assert len(transform_info) == len(transpose_info) == ntransforms
# determine input and output shapes
- input_axes = transpose_info[0][1]
+ input_axes = transpose_info[0][1]
output_axes = transpose_info[-1][2]
if is_forward:
- assert (field_axes==input_axes), (field_axes, input_axes)
- input_transform_shape = transpose_info[0][3]
+ assert (field_axes == input_axes), (field_axes, input_axes)
+ input_transform_shape = transpose_info[0][3]
output_transform_shape = transform_info[-1][3][0]
- input_shape, input_slices, _ = \
- self.determine_buffer_shape(input_transform_shape, False,
- transform_offsets, input_axes)
+ input_shape, input_slices, _ = \
+ self.determine_buffer_shape(input_transform_shape, False,
+ transform_offsets, input_axes)
output_shape, output_slices, zfos = \
- self.determine_buffer_shape(output_transform_shape, True,
- transform_offsets, output_axes)
+ self.determine_buffer_shape(output_transform_shape, True,
+ transform_offsets, output_axes)
# We have a situation where we should impose zeros:
# 1) output transform ghosts (when there are transform sizes mismatch DXT-I variants)
zero_fill_output_slices = zfos
else:
- assert (field_axes==output_axes), (field_axes, output_axes)
- input_transform_shape = transform_info[0][2][0]
+ assert (field_axes == output_axes), (field_axes, output_axes)
+ input_transform_shape = transform_info[0][2][0]
output_transform_shape = transpose_info[-1][4]
- input_shape, input_slices, _ = \
- self.determine_buffer_shape(input_transform_shape, True,
- transform_offsets, input_axes)
+ input_shape, input_slices, _ = \
+ self.determine_buffer_shape(input_transform_shape, True,
+ transform_offsets, input_axes)
output_shape, output_slices, zfos = \
- self.determine_buffer_shape(output_transform_shape, False,
- transform_offsets, output_axes)
+ self.determine_buffer_shape(output_transform_shape, False,
+ transform_offsets, output_axes)
# We have a situation where we should impose zeros:
- # 1) impose homogeneous dirichlet conditions on output
+ # 1) impose homogeneous dirichlet conditions on output
# (implicit 0's are not part of the transform output).
zero_fill_output_slices = zfos
-
- axes = (output_axes if is_forward else input_axes)
+
+ axes = (output_axes if is_forward else input_axes)
ptransforms = tuple(self.transforms[i] for i in axes)
self._permuted_transforms = ptransforms
-
+
if self._do_compute_energy:
- shape = (output_shape if is_forward else input_shape)
+ shape = (output_shape if is_forward else input_shape)
#view = (output_slices if is_forward else input_slices)
assert len(shape) == ntransforms
- shape = tuple(Si-2 if sum(transform_offsets[i])==2 else Si for i,Si in zip(axes, shape))
+ shape = tuple(Si-2 if sum(transform_offsets[i])
+ == 2 else Si for i, Si in zip(axes, shape))
K2 = ()
for (tr, Ni) in zip(ptransforms, shape):
Ki = Ni//2 if STU.is_C2C(tr) else Ni-1
@@ -1250,75 +1281,76 @@ class PlannedSpectralTransform(object):
else:
mutexes_nbytes = 0
self._max_wavenumber = max_wavenumber
- self._energy_nbytes = energy_nbytes
+ self._energy_nbytes = energy_nbytes
self._mutexes_nbytes = mutexes_nbytes
-
+
Ep = self._energy_parameter
Ep.reallocate_buffer(shape=(max_wavenumber+1,), dtype=dfield.dtype)
-
- fname = fname='{}{}'.format(dfield.name, '_in' if is_forward else '_out')
-
+
+ fname = fname = '{}{}'.format(dfield.name, '_in' if is_forward else '_out')
+
# build txt dumper
if self._do_dump_energy:
diop = self._dump_energy_ioparams
assert (diop is not None)
- self._energy_dumper = EnergyDumper(energy_parameter=Ep,
- io_params=self._dump_energy_ioparams, fname=fname)
+ self._energy_dumper = EnergyDumper(energy_parameter=Ep,
+ io_params=self._dump_energy_ioparams, fname=fname)
# build plotter if required
if self._do_plot_energy:
piop = self._plot_energy_ioparams
assert (piop is not None)
- pname = u'{}.{}.{}'.format(self.op.__class__.__name__,
- 'forward'if is_forward else 'backward',
- dfield.pretty_name.decode('utf-8'))
- energy_parameters = { pname: self._energy_parameter}
+ pname = u'{}.{}.{}'.format(self.op.__class__.__name__,
+ 'forward'if is_forward else 'backward',
+ dfield.pretty_name.decode('utf-8'))
+ energy_parameters = {pname: self._energy_parameter}
self._energy_plotter = EnergyPlotter(energy_parameters=energy_parameters,
- io_params=self._plot_energy_ioparams,
- fname=fname)
+ io_params=self._plot_energy_ioparams,
+ fname=fname)
else:
self._max_wavenumber = None
- self._energy_nbytes = None
+ self._energy_nbytes = None
self._mutexes_nbytes = None
self._dfield = dfield
self._transform_info = transform_info
self._transpose_info = transpose_info
- self._ntransforms = ntransforms
-
- self._input_axes = input_axes
- self._input_shape = input_shape
- self._input_slices = input_slices
+ self._ntransforms = ntransforms
+
+ self._input_axes = input_axes
+ self._input_shape = input_shape
+ self._input_slices = input_slices
self._input_transform_shape = input_transform_shape
- self._output_axes = output_axes
- self._output_shape = output_shape
- self._output_slices = output_slices
+ self._output_axes = output_axes
+ self._output_shape = output_shape
+ self._output_slices = output_slices
self._output_transform_shape = output_transform_shape
-
+
self._zero_fill_output_slices = zero_fill_output_slices
self._backend = dfield.backend
if self.DEBUG:
def axis_format(info):
- prefix='\n'+' '*4
- ss=''
- for (i,data) in enumerate(info):
- ss+=prefix+'{}/ '.format(i)+str(data)
+ prefix = '\n'+' '*4
+ ss = ''
+ for (i, data) in enumerate(info):
+ ss += prefix+'{}/ '.format(i)+str(data)
return ss
+
def slc_format(slices):
if (slices is None):
return 'NONE'
else:
- prefix='\n'+' '*4
- ss=''
+ prefix = '\n'+' '*4
+ ss = ''
for slc in slices:
- ss+=prefix+str(slc)
+ ss += prefix+str(slc)
return ss
print '\n\n== SPECTRAL PLANNING INFO OF FIELD {} =='.format(dfield.pretty_name)
- print 'transform direction: {}'.format('FORWARD' if self.is_forward
- else 'BACKWARD')
+ print 'transform direction: {}'.format('FORWARD' if self.is_forward
+ else 'BACKWARD')
print 'transforms: {}'.format(self.transforms)
print ':CARTESIAN INFO:'
print 'cart shape: {}'.format(dfield.topology.cart_shape)
@@ -1343,50 +1375,51 @@ class PlannedSpectralTransform(object):
print ':ZERO FILL:'
print 'zero_fill_output_slices: {}'.format(slc_format(self._zero_fill_output_slices))
-
-
def get_mapped_input_buffer(self):
return self.get_mapped_full_input_buffer()[self.input_slices]
+
def get_mapped_output_buffer(self):
return self.get_mapped_full_output_buffer()[self.output_slices]
+
def get_mapped_full_input_buffer(self):
dfield = self._dfield
- if (self.is_forward
- and dfield.backend.kind == Backend.OPENCL
- and self.transform_group._op.enable_opencl_host_buffer_mapping):
+ if (self.is_forward
+ and dfield.backend.kind == Backend.OPENCL
+ and self.transform_group._op.enable_opencl_host_buffer_mapping):
return self.transform_group._op.get_mapped_object(dfield)[dfield.compute_slices]
else:
return self.full_input_buffer
+
def get_mapped_full_output_buffer(self):
dfield = self._dfield
if (self.is_backward
- and dfield.backend.kind == Backend.OPENCL
- and self.transform_group._op.enable_opencl_host_buffer_mapping):
+ and dfield.backend.kind == Backend.OPENCL
+ and self.transform_group._op.enable_opencl_host_buffer_mapping):
return self.transform_group._op.get_mapped_object(dfield)[dfield.compute_slices]
else:
return self.full_output_buffer
- def determine_buffer_shape(cls, transform_shape, target_is_buffer, offsets, axes):
+ def determine_buffer_shape(cls, transform_shape, target_is_buffer, offsets, axes):
offsets = tuple(offsets[ai] for ai in axes)
slices = []
shape = []
zero_fill_slices = []
dim = len(axes)
- for i,((lo,ro),si) in enumerate(zip(offsets, transform_shape)):
- if (lo^ro) and target_is_buffer:
+ for i, ((lo, ro), si) in enumerate(zip(offsets, transform_shape)):
+ if (lo ^ ro) and target_is_buffer:
Si = si
slc = slice(0, si)
else:
Si = si+lo+ro
slc = slice(lo, Si-ro)
- if (lo>0):
- zfill = [slice(None,None,None)]*dim
- zfill[i] = slice(0,lo)
+ if (lo > 0):
+ zfill = [slice(None, None, None)]*dim
+ zfill[i] = slice(0, lo)
zfill = tuple(zfill)
zero_fill_slices.append(zfill)
- if (ro>0):
- zfill = [slice(None,None,None)]*dim
- zfill[i] = slice(Si-ro,Si)
+ if (ro > 0):
+ zfill = [slice(None, None, None)]*dim
+ zfill[i] = slice(Si-ro, Si)
zfill = tuple(zfill)
zero_fill_slices.append(zfill)
shape.append(Si)
@@ -1395,196 +1428,194 @@ class PlannedSpectralTransform(object):
def configure_input_buffer(self, buf):
input_dtype, input_shape = self.input_dtype, self.input_shape
- buf_nbytes = compute_nbytes(buf.shape, buf.dtype)
- input_nbytes = compute_nbytes(input_shape, input_dtype)
+ buf_nbytes = compute_nbytes(buf.shape, buf.dtype)
+ input_nbytes = compute_nbytes(input_shape, input_dtype)
assert buf_nbytes >= input_nbytes, (buf_nbytes, input_nbytes)
- if (buf.shape!=input_shape) or (buf.dtype!=input_dtype):
- buf = buf.view(dtype=np.int8)[:input_nbytes].view(dtype=input_dtype).reshape(input_shape)
+ if (buf.shape != input_shape) or (buf.dtype != input_dtype):
+ buf = buf.view(dtype=np.int8)[:input_nbytes].view(
+ dtype=input_dtype).reshape(input_shape)
if isinstance(buf, Array):
buf = buf.handle
input_buffer = buf[self.input_slices]
assert input_buffer.shape == self.input_transform_shape
self._full_input_buffer = buf
- self._input_buffer = input_buffer
+ self._input_buffer = input_buffer
for symbol in self._input_symbolic_arrays:
symbol.to_backend(self.backend.kind).bind_memory_object(buf)
return input_buffer
-
def configure_output_buffer(self, buf):
output_dtype, output_shape = self.output_dtype, self.output_shape
- buf_nbytes = compute_nbytes(buf.shape, buf.dtype)
- output_nbytes = compute_nbytes(output_shape, output_dtype)
+ buf_nbytes = compute_nbytes(buf.shape, buf.dtype)
+ output_nbytes = compute_nbytes(output_shape, output_dtype)
assert buf_nbytes >= output_nbytes, (buf_nbytes, output_nbytes)
- if (buf.shape!=output_shape) or (buf.dtype!=output_dtype):
- buf = buf.view(dtype=np.int8)[:output_nbytes].view(dtype=output_dtype).reshape(output_shape)
+ if (buf.shape != output_shape) or (buf.dtype != output_dtype):
+ buf = buf.view(dtype=np.int8)[:output_nbytes].view(
+ dtype=output_dtype).reshape(output_shape)
if isinstance(buf, Array):
buf = buf.handle
output_buffer = buf[self.output_slices]
assert output_buffer.shape == self.output_transform_shape
self._full_output_buffer = buf
- self._output_buffer = output_buffer
+ self._output_buffer = output_buffer
for symbol in self._output_symbolic_arrays:
symbol.to_backend(self.backend.kind).bind_memory_object(buf)
return output_buffer
def _discretize_forward(self, field_axes, **kwds):
dfield = self.op.input_discrete_fields[self.field]
-
- grid_resolution = dfield.mesh.grid_resolution
+
+ grid_resolution = dfield.mesh.grid_resolution
local_resolution = dfield.compute_resolution
input_dtype = dfield.dtype
- dim = dfield.dim
-
- forward_transforms = self.transforms[::-1]
+ dim = dfield.dim
+
+ forward_transforms = self.transforms[::-1]
backward_transforms = STU.get_inverse_transforms(*forward_transforms)
-
+
(resolution, transform_offsets) = \
- STU.get_transform_resolution(local_resolution, *forward_transforms)
+ STU.get_transform_resolution(local_resolution, *forward_transforms)
local_transform_info = self._determine_transform_info(forward_transforms,
resolution, input_dtype)
- local_transpose_info = self._determine_transpose_info(field_axes,
+ local_transpose_info = self._determine_transpose_info(field_axes,
local_transform_info)
-
- local_transform_info = self._permute_transform_info(local_transform_info,
+
+ local_transform_info = self._permute_transform_info(local_transform_info,
local_transpose_info)
transform_info = local_transform_info
transpose_info = local_transpose_info
- return (dfield, transform_info, transpose_info,
+ return (dfield, transform_info, transpose_info,
transform_offsets)
-
def _discretize_backward(self, field_axes, **kwds):
-
- forward_transforms = self.transforms[::-1]
+
+ forward_transforms = self.transforms[::-1]
backward_transforms = STU.get_inverse_transforms(*forward_transforms)
def reverse_transform_info(transform_info):
transform_info = list(transform_info)
- for (i,d) in enumerate(transform_info):
+ for (i, d) in enumerate(transform_info):
d = list(d)
d[1] = forward_transforms[i]
- d2,d3 = d[2:4]
- d[2:4] = d3,d2
+ d2, d3 = d[2:4]
+ d[2:4] = d3, d2
transform_info[i] = tuple(d)
transform_info = tuple(transform_info)
return transform_info[::-1]
def reverse_transpose_info(transpose_info):
transpose_info = list(transpose_info)
- for (i,d) in enumerate(transpose_info):
+ for (i, d) in enumerate(transpose_info):
if (d[0] is not None):
d = list(d)
- d1,d2,d3,d4 = d[1:5]
- d[1:5] = d2,d1,d4,d3
+ d1, d2, d3, d4 = d[1:5]
+ d[1:5] = d2, d1, d4, d3
d[0] = tuple(d[1].index(ai) for ai in d[2])
d = tuple(d)
else:
# no permutation
- assert d[1]==d[2]
- assert d[3]==d[4]
+ assert d[1] == d[2]
+ assert d[3] == d[4]
transpose_info[i] = d
return transpose_info[::-1]
dfield = self.op.output_discrete_fields[self.field]
- grid_resolution = dfield.mesh.grid_resolution
+ grid_resolution = dfield.mesh.grid_resolution
local_resolution = dfield.compute_resolution
output_dtype = dfield.dtype
- dim = dfield.dim
-
+ dim = dfield.dim
+
(resolution, transform_offsets) = \
- STU.get_transform_resolution(local_resolution, *backward_transforms)
+ STU.get_transform_resolution(local_resolution, *backward_transforms)
- local_backward_transform_info = self._determine_transform_info(backward_transforms,
- resolution, output_dtype)
- local_backward_transpose_info = self._determine_transpose_info(field_axes,
- local_backward_transform_info)
+ local_backward_transform_info = self._determine_transform_info(backward_transforms,
+ resolution, output_dtype)
+ local_backward_transpose_info = self._determine_transpose_info(field_axes,
+ local_backward_transform_info)
local_backward_transform_info = self._permute_transform_info(
- local_backward_transform_info,
- local_backward_transpose_info)
-
- local_forward_transform_info = reverse_transform_info(local_backward_transform_info)
- local_forward_transpose_info = reverse_transpose_info(local_backward_transpose_info)
-
+ local_backward_transform_info,
+ local_backward_transpose_info)
+
+ local_forward_transform_info = reverse_transform_info(local_backward_transform_info)
+ local_forward_transpose_info = reverse_transpose_info(local_backward_transpose_info)
+
transform_info = local_forward_transform_info
transpose_info = local_forward_transpose_info
- return (dfield, transform_info, transpose_info,
- transform_offsets)
-
-
+ return (dfield, transform_info, transpose_info,
+ transform_offsets)
+
@classmethod
def _determine_transform_info(cls, transforms, src_shape, src_dtype):
transform_info = []
dim = len(transforms)
dst_shape, dst_dtype = src_shape, src_dtype
- dst_view = [slice(0,si) for si in src_shape]
- for (i,tr) in enumerate(transforms):
+ dst_view = [slice(0, si) for si in src_shape]
+ for (i, tr) in enumerate(transforms):
axis = i
src_shape = dst_shape
src_dtype = dst_dtype
- src_view = dst_view
+ src_view = dst_view
if STU.is_none(tr):
pass
elif STU.is_backward(tr):
- msg='{} is not a forward transform.'
- msg=msg.format(tr)
+ msg = '{} is not a forward transform.'
+ msg = msg.format(tr)
raise ValueError(msg)
elif STU.is_R2R(tr):
- msg='Expected a floating point data type but got {}.'.format(src_dtype)
+ msg = 'Expected a floating point data type but got {}.'.format(src_dtype)
assert is_fp(src_dtype), msg
# data type and shape does not change
elif STU.is_R2C(tr):
- msg='Expected a floating point data type but got {}.'.format(src_dtype)
+ msg = 'Expected a floating point data type but got {}.'.format(src_dtype)
assert is_fp(src_dtype), msg
- dst_shape = list(src_shape)
+ dst_shape = list(src_shape)
dst_shape[dim-axis-1] = dst_shape[dim-axis-1]//2 + 1
dst_shape = tuple(dst_shape)
dst_dtype = float_to_complex_dtype(src_dtype)
elif STU.is_C2C(tr):
- msg='Expected a complex data type but got {}.'.format(src_dtype)
+ msg = 'Expected a complex data type but got {}.'.format(src_dtype)
assert is_complex(src_dtype), msg
# data type and shape does not change
else:
- msg='Unknown transform type {}.'.format(tr)
+ msg = 'Unknown transform type {}.'.format(tr)
raise ValueError(msg)
-
-
- (lo,ro) = STU.get_transform_offsets(tr)
- src_view = src_view[:]
+
+ (lo, ro) = STU.get_transform_offsets(tr)
+ src_view = src_view[:]
src_view[dim-axis-1] = slice(lo, src_shape[dim-axis-1]-ro)
-
+
dst_view = src_view[:]
dst_view[dim-axis-1] = slice(lo, dst_shape[dim-axis-1]-ro)
src_dtype = np.dtype(src_dtype)
dst_dtype = np.dtype(dst_dtype)
- data = (axis, tr, (src_shape, src_dtype, tuple(src_view)),
- (dst_shape, dst_dtype, tuple(dst_view)))
+ data = (axis, tr, (src_shape, src_dtype, tuple(src_view)),
+ (dst_shape, dst_dtype, tuple(dst_view)))
transform_info.append(data)
transform_info = tuple(transform_info)
return transform_info
-
+
@classmethod
def _determine_transpose_info(cls, src_axes, transform_info):
transpose_info = []
dim = len(src_axes)
- for (axis, tr, (src_shape, src_dtype, src_view),
- (dst_shape, dst_dtype, dst_view)) in transform_info:
+ for (axis, tr, (src_shape, src_dtype, src_view),
+ (dst_shape, dst_dtype, dst_view)) in transform_info:
dst_axis = dim - 1 - axis
if (not STU.is_none(tr)) and (dst_axis != src_axes[-1]):
idx = src_axes.index(dst_axis)
dst_axes = list(src_axes)
dst_axes[idx] = src_axes[-1]
- dst_axes[-1] = dst_axis
- dst_axes = tuple(dst_axes)
+ dst_axes[-1] = dst_axis
+ dst_axes = tuple(dst_axes)
permutation = tuple(src_axes.index(ai) for ai in dst_axes)
else:
dst_axes = src_axes
@@ -1599,32 +1630,32 @@ class PlannedSpectralTransform(object):
src_axes = dst_axes
transpose_info = tuple(transpose_info)
return transpose_info
-
+
@classmethod
def _permute_transform_info(cls, transform_info, transpose_info):
- assert len(transform_info)==len(transpose_info)
+ assert len(transform_info) == len(transpose_info)
transform_info = list(transform_info)
- for i,(transpose, transform) in enumerate(zip(transpose_info, transform_info)):
+ for i, (transpose, transform) in enumerate(zip(transpose_info, transform_info)):
(_, _, dst_axes, _, transpose_out_shape) = transpose
- (_1,_2,(src_shape,_3,src_view), (dst_shape,_4,dst_view)) = transform
+ (_1, _2, (src_shape, _3, src_view), (dst_shape, _4, dst_view)) = transform
permuted_src_shape = tuple(src_shape[ai] for ai in dst_axes)
- permuted_src_view = tuple(src_view[ai] for ai in dst_axes)
+ permuted_src_view = tuple(src_view[ai] for ai in dst_axes)
permuted_dst_shape = tuple(dst_shape[ai] for ai in dst_axes)
- permuted_dst_view = tuple(dst_view[ai] for ai in dst_axes)
+ permuted_dst_view = tuple(dst_view[ai] for ai in dst_axes)
assert (permuted_src_shape == transpose_out_shape)
- transform = (_1,_2,(permuted_src_shape,_3,permuted_src_view),
- (permuted_dst_shape,_4,permuted_dst_view))
+ transform = (_1, _2, (permuted_src_shape, _3, permuted_src_view),
+ (permuted_dst_shape, _4, permuted_dst_view))
transform_info[i] = transform
transform_info = tuple(transform_info)
return transform_info
-
+
@_discretized
def get_mem_requests(self, **kwds):
# first we need to find out src and dst buffers for transforms (B0 and B1)
nbytes = 0
- for (_, _, (src_shape, src_dtype, src_view),
- (dst_shape, dst_dtype, dst_view)) in self._transform_info:
+ for (_, _, (src_shape, src_dtype, src_view),
+ (dst_shape, dst_dtype, dst_view)) in self._transform_info:
nbytes = max(nbytes, compute_nbytes(src_shape, src_dtype))
nbytes = max(nbytes, compute_nbytes(dst_shape, dst_dtype))
nbytes = max(nbytes, compute_nbytes(self.input_shape, self.input_dtype))
@@ -1634,73 +1665,77 @@ class PlannedSpectralTransform(object):
# we can only do it by creating temporary plans prior to setup
# with temporary buffers.
tmp_nbytes = 0
- tg = self.transform_group
- src = tg.FFTI.backend.empty(shape=(nbytes,), dtype=np.uint8, min_alignment=tg.op.min_fft_alignment)
- dst = tg.FFTI.backend.empty(shape=(nbytes,), dtype=np.uint8, min_alignment=tg.op.min_fft_alignment)
+ tg = self.transform_group
+ src = tg.FFTI.backend.empty(shape=(nbytes,), dtype=np.uint8,
+ min_alignment=tg.op.min_fft_alignment)
+ dst = tg.FFTI.backend.empty(shape=(nbytes,), dtype=np.uint8,
+ min_alignment=tg.op.min_fft_alignment)
queue = tg.FFTI.new_queue(tg=tg, name='tmp_queue')
- for (_, tr, (src_shape, src_dtype, src_view),
- (dst_shape, dst_dtype, dst_view)) in self._transform_info:
+ for (_, tr, (src_shape, src_dtype, src_view),
+ (dst_shape, dst_dtype, dst_view)) in self._transform_info:
src_nbytes = compute_nbytes(src_shape, src_dtype)
dst_nbytes = compute_nbytes(dst_shape, dst_dtype)
b0 = src[:src_nbytes].view(dtype=src_dtype).reshape(src_shape)
b1 = dst[:dst_nbytes].view(dtype=dst_dtype).reshape(dst_shape)
- fft_plan = tg.FFTI.get_transform(tr)(a=b0.handle, out=b1.handle,
- axis=self.field.dim-1,
- verbose=False)
+ fft_plan = tg.FFTI.get_transform(tr)(a=b0.handle, out=b1.handle,
+ axis=self.field.dim-1,
+ verbose=False)
fft_plan.setup(queue=queue)
tmp_nbytes = max(tmp_nbytes, fft_plan.required_buffer_size)
+ del src
+ del dst
+
if (tmp_nbytes > nbytes):
- msg='Planner claims to need more than buffer bytes as temporary buffer:'
- msg+='\n *Buffer bytes: {}'.format(bytes2str(nbytes))
- msg+='\n *Tmp bytes: {}'.format(bytes2str(tmp_nbytes))
+ msg = 'Planner claims to need more than buffer bytes as temporary buffer:'
+ msg += '\n *Buffer bytes: {}'.format(bytes2str(nbytes))
+ msg += '\n *Tmp bytes: {}'.format(bytes2str(tmp_nbytes))
warnings.warn(msg, HysopFFTWarning)
- backend = self.transform_group.backend
- mem_tag = self.transform_group.mem_tag
+ backend = self.transform_group.backend
+ mem_tag = self.transform_group.mem_tag
field_tag = self.dfield.name
- kind = backend.kind
-
- B0_tag = '{}_{}_B0'.format(mem_tag, kind)
- B1_tag = '{}_{}_B1'.format(mem_tag, kind)
- TMP_tag = '{}_{}_TMP'.format(mem_tag, kind)
+ kind = backend.kind
+
+ B0_tag = '{}_{}_B0'.format(mem_tag, kind)
+ B1_tag = '{}_{}_B1'.format(mem_tag, kind)
+ TMP_tag = '{}_{}_TMP'.format(mem_tag, kind)
ENERGY_tag = '{}_{}_ENERGY'.format(mem_tag, kind)
MUTEXES_tag = '{}_{}_MUTEXES'.format(mem_tag, kind)
self.B0_tag, self.B1_tag, self.TMP_tag, self.ENERGY_tag, self.MUTEXES_tag = B0_tag, B1_tag, TMP_tag, ENERGY_tag, MUTEXES_tag
- requests = {B0_tag: nbytes,
- B1_tag: nbytes,
- TMP_tag: tmp_nbytes}
+ requests = {B0_tag: nbytes,
+ B1_tag: nbytes,
+ TMP_tag: tmp_nbytes}
- if (self._energy_nbytes>0):
- requests[ENERGY_tag] = self._energy_nbytes
- if (self._mutexes_nbytes>0):
+ if (self._energy_nbytes > 0):
+ requests[ENERGY_tag] = self._energy_nbytes
+ if (self._mutexes_nbytes > 0):
requests[MUTEXES_tag] = self._mutexes_nbytes
return requests
-
@_discretized
def setup(self, work):
SETUP_DEBUG = False
assert not self.ready
-
- dim = self.field.dim
- op = self.op
- tg = self.transform_group
+
+ dim = self.field.dim
+ op = self.op
+ tg = self.transform_group
FFTI = tg.FFTI
-
- is_forward = self.is_forward
+
+ is_forward = self.is_forward
is_backward = self.is_backward
- ntransforms = self._ntransforms
+ ntransforms = self._ntransforms
transform_info = self._transform_info
transpose_info = self._transpose_info
B0_tag, B1_tag = self.B0_tag, self.B1_tag
- TMP_tag = self.TMP_tag
- ENERGY_tag = self.ENERGY_tag
- MUTEXES_tag = self.MUTEXES_tag
+ TMP_tag = self.TMP_tag
+ ENERGY_tag = self.ENERGY_tag
+ MUTEXES_tag = self.MUTEXES_tag
# get temporary buffers
B0, = work.get_buffer(op, B0_tag, handle=True)
@@ -1709,26 +1744,26 @@ class PlannedSpectralTransform(object):
assert is_byte_aligned(B1)
try:
- TMP, = work.get_buffer(op, TMP_tag, handle=True)
+ TMP, = work.get_buffer(op, TMP_tag, handle=True)
except ValueError:
TMP = None
-
- if (self._energy_nbytes>0):
+
+ if (self._energy_nbytes > 0):
ENERGY, = work.get_buffer(op, ENERGY_tag, handle=True)
energy_buffer = ENERGY[:self._energy_nbytes].view(dtype=self.dfield.dtype)
assert energy_buffer.size == self._max_wavenumber+1
else:
- ENERGY = None
- energy_buffer = None
+ ENERGY = None
+ energy_buffer = None
- if (self._mutexes_nbytes>0):
+ if (self._mutexes_nbytes > 0):
MUTEXES, = work.get_buffer(op, MUTEXES_tag, handle=True)
mutexes_buffer = MUTEXES[:self._mutexes_nbytes].view(dtype=np.int32)
assert mutexes_buffer.size == self._max_wavenumber+1
else:
MUTEXES = None
mutexes_buffer = None
-
+
# bind field buffer to input or output
dfield = self.dfield
if is_forward:
@@ -1737,34 +1772,35 @@ class PlannedSpectralTransform(object):
self.configure_output_buffer(dfield.sbuffer[dfield.compute_slices])
# bind group buffer to input or output if required.
- custom_input_buffer = self._custom_input_buffer
+ custom_input_buffer = self._custom_input_buffer
custom_output_buffer = self._custom_output_buffer
if (is_forward and custom_output_buffer):
- if (custom_output_buffer=='auto'):
+ if (custom_output_buffer == 'auto'):
# will be determined and set later
pass
- elif (custom_output_buffer=='B0'):
+ elif (custom_output_buffer == 'B0'):
self.configure_output_buffer(B0)
- elif (custom_output_buffer=='B1'):
+ elif (custom_output_buffer == 'B1'):
self.configure_output_buffer(B1)
else:
- msg='Unknown custom output buffer {}.'.format(custom_output_buffer)
+ msg = 'Unknown custom output buffer {}.'.format(custom_output_buffer)
raise NotImplementedError(msg)
if (is_backward and custom_input_buffer):
- if (custom_input_buffer=='auto'):
+ if (custom_input_buffer == 'auto'):
assert self._matching_forward_transform.ready
custom_input_buffer = self._matching_forward_transform._custom_output_buffer
assert custom_input_buffer in ('B0', 'B1')
- if (custom_input_buffer=='B0'):
+ if (custom_input_buffer == 'B0'):
self.configure_input_buffer(B0)
- elif (custom_input_buffer=='B1'):
+ elif (custom_input_buffer == 'B1'):
self.configure_input_buffer(B1)
else:
- msg='Unknown custom input buffer {}.'.format(custom_input_buffer)
+ msg = 'Unknown custom input buffer {}.'.format(custom_input_buffer)
raise NotImplementedError(msg)
-
+
# define input and output buffer, as well as tmp buffers
src_buffer, dst_buffer = B0, B1
+
def nameof(buf):
assert (buf is B0) or (buf is B1)
if (buf is B0):
@@ -1774,26 +1810,27 @@ class PlannedSpectralTransform(object):
def check_size(buf, nbytes, name):
if (buf.nbytes < nbytes):
- msg='Insufficient buffer size for buffer {} (shape={}, dtype={}).'.format(name, buf.shape, buf.dtype)
- msg+='\nExpected at least {} bytes but got {}.'.format(nbytes, buf.nbytes)
+ msg = 'Insufficient buffer size for buffer {} (shape={}, dtype={}).'.format(
+ name, buf.shape, buf.dtype)
+ msg += '\nExpected at least {} bytes but got {}.'.format(nbytes, buf.nbytes)
try:
bname = nameof(buf)
- msg+='\nThis buffer has been identified as {}.'.format(bname)
+ msg += '\nThis buffer has been identified as {}.'.format(bname)
except:
pass
raise RuntimeError(msg)
-
+
# build spectral transform execution queue
- qname = 'fft_planner_{}_{}'.format(self.field.name,
- 'forward' if is_forward else 'backward')
+ qname = 'fft_planner_{}_{}'.format(self.field.name,
+ 'forward' if is_forward else 'backward')
queue = FFTI.new_queue(tg=self, name=qname)
if SETUP_DEBUG:
def print_op(description, category):
prefix = ' |> '
print '{}{: <40}[{}]'.format(prefix, description, category)
-
- msg='''
+
+ msg = '''
SPECTRAL TRANSFORM SETUP
op: {}
dim: {}
@@ -1801,9 +1838,9 @@ SPECTRAL TRANSFORM SETUP
group_tag: {}
is_forward: {}
is_backward: {}'''.format(
- op.pretty_tag,
- dim, ntransforms, self.tag,
- is_forward, is_backward)
+ op.pretty_tag,
+ dim, ntransforms, self.tag,
+ is_forward, is_backward)
print msg
fft_plans = ()
@@ -1811,31 +1848,31 @@ SPECTRAL TRANSFORM SETUP
transpose = transpose_info[i]
transform = transform_info[i]
(permutation, _, _, input_shape, output_shape) = transpose
- (_, tr, (src_shape, src_dtype, src_view),
- (dst_shape, dst_dtype, dst_view)) = transform
+ (_, tr, (src_shape, src_dtype, src_view),
+ (dst_shape, dst_dtype, dst_view)) = transform
assert not STU.is_none(tr), 'Got a NONE transform type.'
-
- is_first = (i==0)
- is_last = (i==ntransforms-1)
- should_forward_permute = (is_forward and (permutation is not None))
+ is_first = (i == 0)
+ is_last = (i == ntransforms-1)
+
+ should_forward_permute = (is_forward and (permutation is not None))
should_backward_permute = (is_backward and (permutation is not None))
-
+
if SETUP_DEBUG:
- msg=' TRANSFORM INDEX {}:'.format(i)
+ msg = ' TRANSFORM INDEX {}:'.format(i)
if (permutation is not None):
- msg+='''
- Transpose Info:
+ msg += '''
+ Transpose Info:
permutation: {}
input_shape: {}
output_shape: {}
forward_permute: {}
backward_permute: {}'''.format(
- permutation, input_shape, output_shape,
- should_forward_permute, should_backward_permute)
+ permutation, input_shape, output_shape,
+ should_forward_permute, should_backward_permute)
- msg+='''
+ msg += '''
Custom buffers:
custom_input: {}
custom output: {}
@@ -1843,18 +1880,18 @@ SPECTRAL TRANSFORM SETUP
SRC: shape {} and type {}, view {}
DST: shape {} and type {}, view {}
Planned Operations:'''.format(
- custom_input_buffer, custom_output_buffer,
- src_shape, src_dtype, src_view,
- dst_shape, dst_dtype, dst_view)
+ custom_input_buffer, custom_output_buffer,
+ src_shape, src_dtype, src_view,
+ dst_shape, dst_dtype, dst_view)
print msg
-
+
src_nbytes = compute_nbytes(src_shape, src_dtype)
dst_nbytes = compute_nbytes(dst_shape, dst_dtype)
- # build forward permutation if required
+ # build forward permutation if required
# (forward transforms transpose before actual transforms)
if should_forward_permute:
- input_nbytes = compute_nbytes(input_shape, src_dtype)
+ input_nbytes = compute_nbytes(input_shape, src_dtype)
output_nbytes = compute_nbytes(output_shape, src_dtype)
assert output_shape == src_shape, 'Transpose to Transform shape mismatch.'
assert input_nbytes == output_nbytes, 'Transpose input and output size mismatch.'
@@ -1869,8 +1906,8 @@ SPECTRAL TRANSFORM SETUP
b1 = dst_buffer[:output_nbytes].view(dtype=src_dtype).reshape(output_shape)
queue += FFTI.plan_transpose(tg=tg, src=b0, dst=b1, axes=permutation)
if SETUP_DEBUG:
- sfrom='input_buffer' if is_first else nameof(src_buffer)
- sto=nameof(dst_buffer)
+ sfrom = 'input_buffer' if is_first else nameof(src_buffer)
+ sto = nameof(dst_buffer)
print_op('PlanTranspose(src={}, dst={})'.format(sfrom, sto, permutation),
'forward permute')
src_buffer, dst_buffer = dst_buffer, src_buffer
@@ -1878,14 +1915,14 @@ SPECTRAL TRANSFORM SETUP
assert (self.input_buffer.shape == src_shape), 'input buffer shape mismatch.'
assert (self.input_buffer.dtype == src_dtype), 'input buffer dtype mismatch.'
assert src_buffer.nbytes >= src_nbytes, 'Insufficient buffer size for src buf.'
- if ((custom_input_buffer is not None) and
+ if ((custom_input_buffer is not None) and
(nameof(src_buffer) == custom_input_buffer)):
src_buffer, dst_buffer = dst_buffer, src_buffer
b0 = src_buffer[:src_nbytes].view(dtype=src_dtype).reshape(src_shape)
queue += FFTI.plan_copy(tg=tg, src=self.get_mapped_input_buffer, dst=b0)
if SETUP_DEBUG:
- sfrom='input_buffer'
- sto=nameof(src_buffer)
+ sfrom = 'input_buffer'
+ sto = nameof(src_buffer)
print_op('PlanCopy(src={}, dst={})'.format(sfrom, sto),
'pre-transform copy')
@@ -1899,15 +1936,15 @@ SPECTRAL TRANSFORM SETUP
fft_plans += (fft_plan,)
queue += fft_plan
if SETUP_DEBUG:
- sfrom=nameof(src_buffer)
- sto=nameof(dst_buffer)
+ sfrom = nameof(src_buffer)
+ sto = nameof(dst_buffer)
print_op('PlanTransform(src={}, dst={})'.format(sfrom, sto), tr)
src_buffer, dst_buffer = dst_buffer, src_buffer
-
- # build backward permutation if required
+
+ # build backward permutation if required
# (backward transforms transpose after actual transforms)
if should_backward_permute:
- input_nbytes = compute_nbytes(input_shape, dst_dtype)
+ input_nbytes = compute_nbytes(input_shape, dst_dtype)
output_nbytes = compute_nbytes(output_shape, dst_dtype)
assert input_shape == dst_shape, 'Transform to Transpose shape mismatch.'
assert input_nbytes == output_nbytes, 'Transpose input and output size mismatch.'
@@ -1916,58 +1953,59 @@ SPECTRAL TRANSFORM SETUP
b0 = src_buffer[:input_nbytes].view(dtype=dst_dtype).reshape(input_shape)
if is_last and (self._action is SpectralTransformAction.OVERWRITE):
assert (self.output_buffer.shape == output_shape), \
- 'output buffer shape mismatch.'
+ 'output buffer shape mismatch.'
assert (self.output_buffer.dtype == dst_dtype), \
- 'output buffer dtype mismatch.'
+ 'output buffer dtype mismatch.'
b1 = self.get_mapped_output_buffer
else:
b1 = dst_buffer[:output_nbytes].view(dtype=dst_dtype).reshape(output_shape)
queue += FFTI.plan_transpose(tg=tg, src=b0, dst=b1, axes=permutation)
if SETUP_DEBUG:
- sfrom=nameof(src_buffer)
- sto='output_buffer' if is_last else nameof(dst_buffer)
+ sfrom = nameof(src_buffer)
+ sto = 'output_buffer' if is_last else nameof(dst_buffer)
print_op('PlanTranspose(src={}, dst={})'.format(sfrom, sto),
'backward permute')
src_buffer, dst_buffer = dst_buffer, src_buffer
if is_last and (self._action is not SpectralTransformAction.OVERWRITE):
if (self._action is SpectralTransformAction.ACCUMULATE):
assert (self.output_buffer.shape == output_shape), \
- 'output buffer shape mismatch.'
+ 'output buffer shape mismatch.'
assert (self.output_buffer.dtype == dst_dtype), \
- 'output buffer dtype mismatch.'
- queue += FFTI.plan_accumulate(tg=tg, src=b1, dst=self.get_mapped_output_buffer)
+ 'output buffer dtype mismatch.'
+ queue += FFTI.plan_accumulate(tg=tg, src=b1,
+ dst=self.get_mapped_output_buffer)
if SETUP_DEBUG:
- sfrom=nameof(dst_buffer)
- sto='output_buffer'
+ sfrom = nameof(dst_buffer)
+ sto = 'output_buffer'
print_op('PlanAccumulate(src={}, dst={})'.format(sfrom, sto),
'post-transform accumulate')
else:
- msg='Unsupported action {}.'.format(self._action)
+ msg = 'Unsupported action {}.'.format(self._action)
raise NotImplementedError(msg)
elif is_last:
- if (custom_output_buffer is not None):
+ if (custom_output_buffer is not None):
if custom_output_buffer not in ('B0', 'B1', 'auto'):
- msg='Unknown custom output buffer {}.'.format(custom_output_buffer)
+ msg = 'Unknown custom output buffer {}.'.format(custom_output_buffer)
raise NotImplementedError(msg)
- elif (custom_output_buffer=='auto'):
+ elif (custom_output_buffer == 'auto'):
custom_output_buffer = nameof(dst_buffer)
self._custom_output_buffer = custom_output_buffer
- if (custom_output_buffer=='B0'):
+ if (custom_output_buffer == 'B0'):
self.configure_output_buffer(B0)
- elif (custom_output_buffer=='B1'):
+ elif (custom_output_buffer == 'B1'):
self.configure_output_buffer(B1)
else:
raise RuntimeError
elif (nameof(src_buffer) == custom_output_buffer):
- # This is a special case where we need to copy back and forth
+ # This is a special case where we need to copy back and forth
# (because of offsets)
b0 = src_buffer[:dst_nbytes].view(dtype=dst_dtype).reshape(dst_shape)
b1 = dst_buffer[:dst_nbytes].view(dtype=dst_dtype).reshape(dst_shape)
queue += FFTI.plan_copy(tg=tg, src=b0, dst=b1)
if SETUP_DEBUG:
- sfrom=nameof(src_buffer)
- sto=nameof(dst_buffer)
+ sfrom = nameof(src_buffer)
+ sto = nameof(dst_buffer)
print_op('PlanCopy(src={}, dst={})'.format(sfrom, sto),
'post-transform copy')
src_buffer, dst_buffer = dst_buffer, src_buffer
@@ -1976,25 +2014,25 @@ SPECTRAL TRANSFORM SETUP
assert src_buffer.nbytes >= dst_nbytes, 'Insufficient buffer size for src buf.'
b0 = src_buffer[:dst_nbytes].view(dtype=dst_dtype).reshape(dst_shape)
if self._action is SpectralTransformAction.OVERWRITE:
- pname='PlanCopy'
- pdes='post-transform-copy'
+ pname = 'PlanCopy'
+ pdes = 'post-transform-copy'
queue += FFTI.plan_copy(tg=tg, src=b0, dst=self.get_mapped_output_buffer)
elif self._action is SpectralTransformAction.ACCUMULATE:
- pname='PlanAccumulate'
- pdes='post-transform-accumulate'
+ pname = 'PlanAccumulate'
+ pdes = 'post-transform-accumulate'
queue += FFTI.plan_accumulate(tg=tg, src=b0, dst=self.get_mapped_output_buffer)
else:
- msg='Unsupported action {}.'.format(self._action)
+ msg = 'Unsupported action {}.'.format(self._action)
raise NotImplementedError(msg)
if SETUP_DEBUG:
- sfrom=nameof(src_buffer)
- sto='output_buffer' if (custom_output_buffer is None) \
- else custom_output_buffer
+ sfrom = nameof(src_buffer)
+ sto = 'output_buffer' if (custom_output_buffer is None) \
+ else custom_output_buffer
print_op('{}(src={}, dst={})'.format(pname, sfrom, sto),
pdes)
-
+
if self._zero_fill_output_slices:
- buf = self.get_mapped_full_output_buffer
+ buf = self.get_mapped_full_output_buffer
slcs = self._zero_fill_output_slices
queue += FFTI.plan_fill_zeros(tg=tg, a=buf, slices=slcs)
if SETUP_DEBUG:
@@ -2003,23 +2041,24 @@ SPECTRAL TRANSFORM SETUP
# allocate fft plans
FFTI.allocate_plans(op, fft_plans, tmp_buffer=TMP)
-
+
# build kernels to compute energy if required
if self._do_compute_energy:
- field_buffer = self.input_buffer if self.is_forward else self.output_buffer
+ field_buffer = self.input_buffer if self.is_forward else self.output_buffer
spectral_buffer = self.output_buffer if self.is_forward else self.input_buffer
- compute_energy_queue = FFTI.new_queue(tg=self, name='dump_energy')
+ compute_energy_queue = FFTI.new_queue(tg=self, name='dump_energy')
compute_energy_queue += FFTI.plan_fill_zeros(tg=tg, a=energy_buffer, slices=(Ellipsis,))
if (mutexes_buffer is not None):
unlock_mutexes = FFTI.plan_fill_zeros(tg=tg, a=mutexes_buffer, slices=(Ellipsis,))
compute_energy_queue += unlock_mutexes
compute_energy_queue().wait() # we need this before compute energy to unlock mutexes
compute_energy_queue += FFTI.plan_compute_energy(tg=tg,
- fshape=field_buffer.shape,
- src=spectral_buffer, dst=energy_buffer,
- transforms=self._permuted_transforms,
- mutexes=mutexes_buffer)
- compute_energy_queue += FFTI.plan_copy(tg=tg, src=energy_buffer, dst=self._energy_parameter._value)
+ fshape=field_buffer.shape,
+ src=spectral_buffer, dst=energy_buffer,
+ transforms=self._permuted_transforms,
+ mutexes=mutexes_buffer)
+ compute_energy_queue += FFTI.plan_copy(tg=tg,
+ src=energy_buffer, dst=self._energy_parameter._value)
else:
compute_energy_queue = None
@@ -2034,7 +2073,7 @@ SPECTRAL TRANSFORM SETUP
evt = self._queue.execute(wait_for=evt)
evt = self._post_transform_actions(wait_for=evt, **kwds)
return evt
-
+
def _pre_transform_actions(self, simulation=None, wait_for=None, **kwds):
evt = wait_for
if (simulation is False):
@@ -2054,23 +2093,22 @@ SPECTRAL TRANSFORM SETUP
if self._do_plot_energy:
evt = self.plot_energy(simulation=simulation, wait_for=evt)
return evt
-
+
def compute_energy(self, simulation, wait_for):
- msg='No simulation was passed in {}.__call__().'.format(type(self))
+ msg = 'No simulation was passed in {}.__call__().'.format(type(self))
assert (simulation is not None), msg
evt = wait_for
- should_compute_energy = any(simulation.should_dump(frequency=f, with_last=True) for f in self._compute_energy_frequencies)
+ should_compute_energy = any(simulation.should_dump(frequency=f, with_last=True)
+ for f in self._compute_energy_frequencies)
if should_compute_energy:
evt = self._compute_energy_queue(wait_for=evt)
if self._do_dump_energy:
self._energy_dumper.update(simulation=simulation, wait_for=evt)
return evt
-
+
def plot_energy(self, simulation, wait_for):
- msg='No simulation was passed in {}.__call__().'.format(type(self))
+ msg = 'No simulation was passed in {}.__call__().'.format(type(self))
assert (simulation is not None), msg
evt = wait_for
self._energy_plotter.update(simulation=simulation, wait_for=evt)
return wait_for
-
-
diff --git a/hysop/operator/custom.py b/hysop/operator/custom.py
index a5277da052e8965cb856ecb55e28d92ed273360c..e4aa9bf824fb76ff37d3da544b1c5c6d1fffb190 100755
--- a/hysop/operator/custom.py
+++ b/hysop/operator/custom.py
@@ -8,13 +8,21 @@ from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
class CustomOperator(ComputationalGraphNodeFrontend):
+ """
+ Function should take parameters in the following order:
+ 1. all input fields
+ 2. all input parameters
+ 3. all output fields
+ 4. all output parameters
+ Note that discrete fields are passed as arguments to the custom function.
+ """
@classmethod
def implementations(cls):
from hysop.backend.host.python.operator.custom import PythonCustomOperator
__implementations = {
- Implementation.PYTHON: PythonCustomOperator,
+ Implementation.PYTHON: PythonCustomOperator,
}
return __implementations
@@ -23,11 +31,34 @@ class CustomOperator(ComputationalGraphNodeFrontend):
return Implementation.PYTHON
@debug
- def __init__(self, func, invars=None, outvars=None, **kwds):
+ def __init__(self, func, invars=None, outvars=None, extra_args=None, ghosts=None, **kwds):
check_instance(invars, (tuple, list), values=(Field, Parameter),
allow_none=True)
check_instance(outvars, (tuple, list), values=(Field, Parameter),
allow_none=True)
+ check_instance(extra_args, tuple, allow_none=True)
+ check_instance(ghosts, int, allow_none=True)
+ from inspect import getargspec as signature # should be inspect.signature in python 3
+ nb_args = len(signature(func).args)
+ nb_in_f, nb_in_p, nb_out_f, nb_out_p, nb_extra = 0, 0, 0, 0, 0
+ if invars is not None:
+ for v in invars:
+ if isinstance(v, Field):
+ nb_in_f += v.nb_components
+ elif isinstance(v, Parameter):
+ nb_in_p += 1
+ if outvars is not None:
+ for v in outvars:
+ if isinstance(v, Field):
+ nb_out_f += v.nb_components
+ elif isinstance(v, Parameter):
+ nb_out_p += 1
+ if not extra_args is None:
+ nb_extra = len(extra_args)
+ msg = "function arguments ({}) did not match given in/out ".format(signature(func))
+ msg += "fields and parameters ({} input fields, {} input params,".format(nb_in_f, nb_in_p)
+ msg += " {} output fields, {} output params).".format(nb_out_f, nb_out_p)
+ assert nb_args == nb_in_f + nb_in_p + nb_out_f + nb_out_p + nb_extra, msg
super(CustomOperator, self).__init__(
- func=func, invars=invars, outvars=outvars, **kwds)
+ func=func, invars=invars, outvars=outvars, extra_args=extra_args, ghosts=ghosts, **kwds)
diff --git a/hysop/operator/diffusion.py b/hysop/operator/diffusion.py
index 95a313f0ee1fdd9852a6e5767f4f4984b23ac849..41da64275095239442a9ee5cb9d8d41e594490d9 100644
--- a/hysop/operator/diffusion.py
+++ b/hysop/operator/diffusion.py
@@ -12,8 +12,14 @@ from hysop.parameters.scalar_parameter import ScalarParameter
from hysop.operator.base.spectral_operator import SpectralComputationalGraphNodeFrontend
from hysop.backend.host.python.operator.diffusion import PythonDiffusion
-from hysop.backend.device.opencl.operator.diffusion import OpenClDiffusion
-from hysop.backend.host.fortran.operator.diffusion import DiffusionFFTW
+try:
+ from hysop.backend.device.opencl.operator.diffusion import OpenClDiffusion
+except ImportError:
+ OpenClDiffusion = None
+try:
+ from hysop.backend.host.fortran.operator.diffusion import DiffusionFFTW
+except ImportError:
+ DiffusionFFTW = None
class Diffusion(SpectralComputationalGraphNodeFrontend):
"""
@@ -86,7 +92,6 @@ class Diffusion(SpectralComputationalGraphNodeFrontend):
nu = ScalarParameter(name='nu', dtype=HYSOP_REAL,
initial_value=nu, quiet=True)
-
super(Diffusion, self).__init__(Fin=Fin, Fout=Fout,
variables=variables, nu=nu, dt=dt,
implementation=implementation,
diff --git a/hysop/operator/dummy.py b/hysop/operator/dummy.py
index c58ed2946e05e600c6105085be2cb7714cdadba5..e2b91c1671f8006a907d5ca922777f243d616614 100644
--- a/hysop/operator/dummy.py
+++ b/hysop/operator/dummy.py
@@ -31,7 +31,7 @@ class PythonDummy(HostOperator):
if (reqs is None):
continue
(field, td, req) = reqs
- req.axes = ((0, 1, 2), )
+ req.axes = (tuple(range(field.dim)), )
return requirements
@op_apply
@@ -39,11 +39,15 @@ class PythonDummy(HostOperator):
super(PythonDummy, self).apply(**kwds)
# Here doing nothing
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
class Dummy(ComputationalGraphNodeFrontend):
__implementations = {
- Implementation.PYTHON: PythonDummy
+ Implementation.PYTHON: PythonDummy
}
@classmethod
diff --git a/hysop/operator/flowrate_correction.py b/hysop/operator/flowrate_correction.py
old mode 100755
new mode 100644
diff --git a/hysop/operator/gradient.py b/hysop/operator/gradient.py
index 5614f5c70f4d8e2f08696f7e3aee4977f9e387d4..1837d9704c748ddfd79705e63c35547a1ff7a21b 100644
--- a/hysop/operator/gradient.py
+++ b/hysop/operator/gradient.py
@@ -1,7 +1,7 @@
"""
@file gradient.py
Gradient: compute dFi/dXj for a given field, up to all components in all directions.
-MinMaxGradientStatistics: compute min(dFi/dXj), max(dFi/dXj) and/or max(|dFi/dXj|)
+MinMaxGradientStatistics: compute min(dFi/dXj), max(dFi/dXj) and/or max(|dFi/dXj|)
for a given field, up to all components in all directions.
"""
from hysop import vprint
@@ -34,26 +34,26 @@ class Gradient(MultiSpaceDerivatives):
return SpaceDerivative.implementations()
@debug
- def __init__(self, F, gradF, directions=None, implementation=None,
- cls=FiniteDifferencesSpaceDerivative,
+ def __init__(self, F, gradF, directions=None, implementation=None,
+ cls=FiniteDifferencesSpaceDerivative,
base_kwds=None, **kwds):
"""
Create an operator generator that yields a sequence of operators
that compute the gradient of an input field F.
- Given F, a scalar, vector or tensor field of dimension n,
+ Given F, a scalar, vector or tensor field of dimension n,
compute the field of dimension n+1 that is the gradient of F:
ScalarField: F -> gradF[j] = dF/dxj
VectorField: F -> gradF[i,j] = dFi/dxj
TensorField: F -> gradF[i0,...,in,j] = dF[i0,...,in]/dxj
-
- Derivatives can be computed with respect to specific directions and not necessarily
+
+ Derivatives can be computed with respect to specific directions and not necessarily
in all directions.
To restrict the number of components, take a tensor view on F (and gradF).
Example: if F is a VectorField of m components (F0, ..., Fm) in a domain of dimension n,
this operator will compute gradF[i,j] = dF[i]/dx[j].
-
+
================================
dF0/dx0 ... dF0/dxn
. . .
@@ -101,7 +101,7 @@ class Gradient(MultiSpaceDerivatives):
else:
nfields = 1
oshape = (ndirections,)
-
+
if (gradF.is_tensor):
if (gradF.shape != oshape):
msg='Gradient field shape mismatch, expected {} but got {}.'
@@ -118,11 +118,11 @@ class Gradient(MultiSpaceDerivatives):
dFs = gradF.fields
directions = tuple(d for _ in xrange(nfields) for d in directions)
derivatives = (1,)*len(directions)
-
+
base_kwds.update(dict(
candidate_input_tensors=(F,),
candidate_output_tensors=(gradF,)))
-
+
if not issubclass(cls, (SpaceDerivative, MinMaxDerivativeStatistics)) or \
(cls in (SpaceDerivative, MinMaxDerivativeStatistics)):
msg="cls should be a subclass of SpaceDerivative or MinMaxSpaceDerivativeStatistics, got {}."
@@ -135,8 +135,8 @@ class Gradient(MultiSpaceDerivatives):
super(Gradient, self).__init__(Fs=Fs, dFs=dFs, cls=cls,
candidate_input_tensors=(F,),
candidate_output_tensors=(gradF,),
- derivatives=derivatives, directions=directions,
- implementation=implementation,
+ derivatives=derivatives, directions=directions,
+ implementation=implementation,
base_kwds=base_kwds, **kwds)
@@ -146,28 +146,28 @@ class MinMaxGradientStatistics(Gradient):
one component at a time to limit memory usage.
This will generate multiple MinMaxDerivativeStatistics operators.
"""
-
+
@debug
def __init__(self, F, gradF=None, directions=None, coeffs=None,
- Fmin=None, Fmax=None, Finf=None,
+ Fmin=None, Fmax=None, Finf=None,
all_quiet=True, print_tensors=True,
name=None, pretty_name=None, pbasename=None, ppbasename=None,
- variables=None, implementation=None, base_kwds=None,
+ variables=None, implementation=None, base_kwds=None,
cls=MinMaxFiniteDifferencesDerivativeStatistics,
**kwds):
"""
Create an operator generator that yields a sequence of operators
that compute statistics on the gradient of an input field F.
-
+
MinMaxGradientStatistics can compute some commonly used Field statistics:
Fmin: component-wise and direction-wise min values of the gradient of the field.
Fmax: component-wise and direction-wise max values of the gradient of the field.
- Finf: component-wise and direction-wise max values of the absolute value of the
+ Finf: component-wise and direction-wise max values of the absolute value of the
gradient of the field (computed using Fmin and Fmax).
- Derivatives can be computed with respect to specific directions and not necessarily in
+ Derivatives can be computed with respect to specific directions and not necessarily in
all directions. To restrict the number of components, take a tensor view on F (and gradF).
-
+
----------------------------------------------
Let k = idx + (j,)
gradF[k] = dF[idx]/dXd
@@ -192,7 +192,7 @@ class MinMaxGradientStatistics(Gradient):
All statistics are only computed if explicitely required by user,
unless required to compute another required statistic, see Notes.
-
+
Parameters
----------
F: Field
@@ -201,7 +201,7 @@ class MinMaxGradientStatistics(Gradient):
gradF: Field, optional
Optional output field for the gradient.
If the gradient is required as an output, one can also use MinMaxStatistics
- on a precomputed gradient (using the Gradient operator) instead of
+ on a precomputed gradient (using the Gradient operator) instead of
MinMaxGradientStatistics.
directions: array like of ints, optional
The directions in which the statistics are computed,
@@ -220,7 +220,7 @@ class MinMaxGradientStatistics(Gradient):
of this object.
all_quiet: bool, optional, defaults to True
Set all generated params to be quiet, even the ones that are requested
- explicitely.
+ explicitely.
print_tensors: bool, optional, defaults to True
Should the phony operator print the tensor parameters during apply ?
name: str, optional
@@ -239,9 +239,9 @@ class MinMaxGradientStatistics(Gradient):
Dictionary of fields as keys and topologies as values.
implementation: hysop.constants.Implementation, optional
Specify generated operator underlying backend implementation.
- Target implementation, should be contained in
+ Target implementation, should be contained in
MinMaxDerivativeStatistics.available_implementations().
- If None, implementation will be set to
+ If None, implementation will be set to
MinMaxDerivativeStatistics.default_implementation().
base_kwds: dict
Base class keyword arguments.
@@ -258,7 +258,7 @@ class MinMaxGradientStatistics(Gradient):
-----
nb_components = F.nb_components
nb_directions = min(F.dim, len(directions)).
-
+
About statistics:
Finf requires to compute Fmin and Fmax.
Finf = Sinf * max( abs(Smin*Fmin), abs(Smax*Fmax))
@@ -267,10 +267,10 @@ class MinMaxGradientStatistics(Gradient):
check_instance(F, Field)
check_instance(gradF, Field, allow_none=True)
- check_instance(directions, tuple, values=int, allow_none=True,
+ check_instance(directions, tuple, values=int, allow_none=True,
minval=0, maxval=F.dim-1, minsize=1, unique=True)
check_instance(coeffs, dict, keys=str, values=(int, float, npw.number), allow_none=True)
- check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors,
+ check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors,
allow_none=True)
check_instance(name, str, allow_none=True)
check_instance(pbasename, str, allow_none=True)
@@ -279,7 +279,7 @@ class MinMaxGradientStatistics(Gradient):
check_instance(base_kwds, dict, allow_none=True)
check_instance(all_quiet, bool, allow_none=True)
- if ( ((Fmin is None) or (Fmin is False))
+ if ( ((Fmin is None) or (Fmin is False))
and ((Fmax is None) or (Fmax is False))
and ((Finf is None) or (Finf is False))):
msg='No statistics were requested.'
@@ -287,25 +287,25 @@ class MinMaxGradientStatistics(Gradient):
msg+=' their value to True, or by by passing an already existing '
msg+=' tensor parameter.'
raise ValueError(msg)
-
+
coeffs = first_not_None(coeffs, {})
variables = first_not_None(variables, {F: None})
all_quiet = first_not_None(all_quiet, False)
-
+
directions = to_tuple(first_not_None(directions, range(F.dim)))
nb_directions = len(directions)
-
+
if F.is_tensor:
oshape = F.shape + (nb_directions,)
else:
oshape = (nb_directions,)
-
+
if (gradF is None):
gradF = F.gradient(directions=directions, is_tmp=True)
assert (gradF.shape == oshape), gradF.shape
-
+
variables.setdefault(gradF, variables[F])
-
+
_names = {
'Fmin': '{}_min',
'Fmax': '{}_max',
@@ -320,9 +320,9 @@ class MinMaxGradientStatistics(Gradient):
pbasename = first_not_None(pbasename, gradF.name)
ppbasename = first_not_None(ppbasename, gradF.pretty_name)
-
+
names = { k: v.format(pbasename) for (k,v) in _names.iteritems() }
- pretty_names = { k: v.format(ppbasename.decode('utf-8'))
+ pretty_names = { k: v.format(ppbasename.decode('utf-8'))
for (k,v) in _pretty_names.iteritems() }
def make_param(k, quiet):
@@ -353,13 +353,13 @@ class MinMaxGradientStatistics(Gradient):
msg='The following coefficients are not needed: {}'
msg=msg.format(unused_coeffs)
raise ValueError(unused_coeffs)
-
+
name = first_not_None(name, 'MinMax({})')
pretty_name = first_not_None(pretty_name, u'|\u00b1{}|')
- extra_params = { 'name': gradF.new_empty_array(),
- 'pretty_name': gradF.new_empty_array(),
- 'coeffs': coeffs,
+ extra_params = { 'name': gradF.new_empty_array(),
+ 'pretty_name': gradF.new_empty_array(),
+ 'coeffs': coeffs,
'implementation': implementation }
for (idx, Fi) in gradF.nd_iter():
@@ -381,6 +381,9 @@ class MinMaxGradientStatistics(Gradient):
# add a phony operator to gather parameter views
class MergeTensorViewsOperator(ComputationalGraphOperator):
+ @classmethod
+ def supports_mpi(cls):
+ return True
@op_apply
def apply(self, **kwds):
super(MergeTensorViewsOperator, self).apply(**kwds)
@@ -400,9 +403,9 @@ class MinMaxGradientStatistics(Gradient):
param = parameters[pname]
_phony_input_params.update({p.name:p for p in extra_params[pname].ravel()})
_phony_output_params[param.name] = param
- op = MergeTensorViewsOperator(name=name.format(gradF.name),
+ op = MergeTensorViewsOperator(name=name.format(gradF.name),
pretty_name=pretty_name.format(gradF.pretty_name.decode('utf-8')),
- input_params=_phony_input_params,
+ input_params=_phony_input_params,
output_params=_phony_output_params)
self._phony_op = op
@@ -412,7 +415,7 @@ class MinMaxGradientStatistics(Gradient):
operators = super(MinMaxGradientStatistics, self)._generate()
operators += (self._phony_op,)
return operators
-
+
@debug
def generate_direction(self, i, dt_coeff):
# See MultiSpaceDerivatives for the directional interface
diff --git a/hysop/operator/hdf_io.py b/hysop/operator/hdf_io.py
index 89992407bc89a4db28015a0c101f8ff5bbb0975d..c249f2335d9061139d019491fe5854c160b29785 100755
--- a/hysop/operator/hdf_io.py
+++ b/hysop/operator/hdf_io.py
@@ -7,8 +7,12 @@
* :class:`~HDF_IO` abstract interface for hdf io classes
"""
+import subprocess
+import sys
+import os
import functools
from abc import ABCMeta, abstractmethod
+from hysop import __H5PY_PARALLEL_COMPRESSION_ENABLED__, vprint
from hysop.deps import h5py, sys
from hysop.core.graph.graph import discretized
from hysop.constants import DirectionLabels, HYSOP_REAL, Backend, TranspositionState, MemoryOrdering
@@ -23,6 +27,7 @@ from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.core.memory.memory_request import MemoryRequest
from hysop.topology.topology_descriptor import TopologyDescriptor
+
class HDF_IO(ComputationalGraphOperator):
"""
Abstract interface to read/write from/to hdf files, for
@@ -76,7 +81,7 @@ class HDF_IO(ComputationalGraphOperator):
super(HDF_IO, self).__init__(**kwds)
- self.name_prefix = name_prefix
+ self.name_prefix = name_prefix
self.name_postfix = name_postfix
if (h5py is None):
@@ -112,6 +117,8 @@ class HDF_IO(ComputationalGraphOperator):
self.topology = None
self._local_compute_slices = None
self._global_grid_resolution = None
+ self._local_grid_resolution = None
+ self._all_local_grid_resolution = None
self._global_slices = None
# Dictionnary of discrete fields. Key = name in hdf file,
# Value = discrete field
@@ -137,22 +144,24 @@ class HDF_IO(ComputationalGraphOperator):
1) min and max ghosts for each input and output variables
2) allowed splitting directions for cartesian topologies
"""
- # by default we create HOST (cpu) TopologyDescriptors
+ # Here we recreate TopologyDescriptors to allow a forced backend
+ # like a OpenCL mapped memory backend or when we do not want
+ # to allocate memory for a topology that is just used for I/O.
td_kwds = self._td_kwds
for (field, topo_descriptor) in self.input_fields.iteritems():
topo_descriptor = TopologyDescriptor.build_descriptor(
- backend=self._force_backend,
- operator=self,
- field=field,
- handle=topo_descriptor, **td_kwds)
+ backend=self._force_backend,
+ operator=self,
+ field=field,
+ handle=topo_descriptor, **td_kwds)
self.input_fields[field] = topo_descriptor
for (field, topo_descriptor) in self.output_fields.iteritems():
topo_descriptor = TopologyDescriptor.build_descriptor(
- backend=self._force_backend,
- operator=self,
- field=field,
- handle=topo_descriptor, **td_kwds)
+ backend=self._force_backend,
+ operator=self,
+ field=field,
+ handle=topo_descriptor, **td_kwds)
self.output_fields[field] = topo_descriptor
@debug
@@ -170,90 +179,124 @@ class HDF_IO(ComputationalGraphOperator):
def get_node_requirements(self):
node_reqs = super(HDF_IO, self).get_node_requirements()
node_reqs.enforce_unique_transposition_state = True
- node_reqs.enforce_unique_topology_shape = True
- node_reqs.enforce_unique_memory_order = False
- node_reqs.enforce_unique_ghosts = False
+ node_reqs.enforce_unique_topology_shape = True
+ node_reqs.enforce_unique_memory_order = True
+ node_reqs.enforce_unique_ghosts = False
return node_reqs
def discretize(self):
super(HDF_IO, self).discretize()
- self.topology = self.input_fields.values()[0]
+ topo = self.input_fields.values()[0]
+ use_local_hdf5 = (topo.cart_size == 1)
+ use_local_hdf5 |= (topo.proc_shape[0] == topo.cart_size) and (topo.cart_size <= 16) and (not self.io_params.hdf5_disable_slicing)
+ # XDMF JOIN do not support more than 16 arguments
+
+ self.topology = topo
+ self.use_local_hdf5 = use_local_hdf5
+ self.use_parallel_hdf5 = not use_local_hdf5
- refmesh = self.topology.mesh
+ refmesh = topo.mesh
# Global resolution for hdf5 output
self._global_grid_resolution = refmesh.grid_resolution
+ # Local resolution for hdf5 output
+ self._local_grid_resolution = refmesh.compute_resolution
+
+ assert self.io_params.io_leader < topo.cart_comm.size
+ self._all_local_grid_resolution = topo.cart_comm.gather(
+ self._local_grid_resolution, root=self.io_params.io_leader)
+
local_compute_slices = {}
global_compute_slices = {}
for (field, itopo) in self.input_fields.iteritems():
mesh = itopo.mesh
- assert (self.topology.domain._domain is itopo.domain._domain), 'domain mismatch'
+ assert (topo.domain._domain is itopo.domain._domain), 'domain mismatch'
assert npw.array_equal(refmesh.grid_resolution, mesh.grid_resolution), 'global grid resolution mismatch'
assert (mesh.on_proc == refmesh.on_proc)
if mesh.on_proc:
- local_compute_slices[field] = mesh.local_compute_slices
+ local_compute_slices[field] = mesh.local_compute_slices
global_compute_slices[field] = mesh.global_compute_slices
else:
- local_compute_slices[field] = tuple(slice(0, 0) for _ in xrange(self.domain.dim))
+ local_compute_slices[field] = tuple(slice(0, 0) for _ in xrange(self.domain.dim))
global_compute_slices[field] = tuple(slice(0, 0) for _ in xrange(self.domain.dim))
self._local_compute_slices = local_compute_slices
self._global_compute_slices = global_compute_slices
self.refmesh = refmesh
- #def setup(self, work=None):
- #super(HDF_IO, self).setup(work=work)
- #No list of hdf dataset names provided by user ...
-
name_prefix, name_postfix = self.name_prefix, self.name_postfix
if (self.var_names is None):
var_names = {}
# Get field names and initialize dataset dict.
for df in self.discrete_fields:
for d in xrange(df.nb_components):
- name = name_prefix + df.name + '_' + DirectionLabels[d] + name_postfix
+ if df.nb_components == 1:
+ name = name_prefix + df.name + name_postfix
+ else:
+ name = name_prefix + df.name + "_{}".format(d) + name_postfix
self.dataset[name] = df.data[d]
var_names[df.field] = name
self.var_names = var_names
else:
for var in self.var_names:
# Discrete field associated to var
- var_d = var.discretize(self.topology)
+ var_d = var.discretize(topo)
for d in xrange(var_d.nb_components):
name = name_prefix + self.var_names[var]
name += '_' + DirectionLabels[d] + name_postfix
self.dataset[name] = var_d.data[d]
- for (f,name) in self.var_names.iteritems():
+ for (f, name) in self.var_names.iteritems():
assert f in self._local_compute_slices
assert f in self._global_compute_slices
- self._local_compute_slices[name] = self._local_compute_slices[f]
+ self._local_compute_slices[name] = self._local_compute_slices[f]
self._global_compute_slices[name] = self._global_compute_slices[f]
- def open_hdf(self, count, mode):
+ def open_hdf(self, count, mode, compression='gzip'):
filename = self._get_filename(count)
- if self.topology.cart_size == 1:
+ if (self.topology.cart_size == 1):
self._hdf_file = h5py.File(filename, mode)
- compression = 'gzip'
- else:
+ elif self.use_parallel_hdf5:
self._hdf_file = h5py.File(filename, mode, driver='mpio',
comm=self.topology.comm)
+ # disable compression if hdf5 library version is less than 1.10.2 (checked in CMakeList.txt).
+ if not __H5PY_PARALLEL_COMPRESSION_ENABLED__:
+ compression = None
+ else:
+ filename = filename.format(rk=self.topology.cart_rank)
+ self._hdf_file = h5py.File(filename, mode)
+
+ if self.io_params.hdf5_disable_compression:
compression = None
- return compression
+ return (filename, compression)
@classmethod
def supports_multiple_topologies(cls):
return True
+
@classmethod
def supports_mpi(cls):
return True
+
class HDF_Writer(HDF_IO):
"""
Print field(s) values on a given topo, in HDF5 format.
"""
- def __init__(self, variables, xmfalways=True,
+
+ __xmf_header = """<?xml version=\"1.0\" ?>
+<!DOCTYPE Xdmf SYSTEM \"Xdmf.dtd\">
+<Xdmf Version=\"2.0\">
+ <Domain>
+ <Grid Name=\"CellTime\" GridType=\"Collection\" CollectionType=\"Temporal\">
+"""
+ __xmf_footer = """ </Grid>
+ </Domain>
+</Xdmf>
+"""
+
+ def __init__(self, variables,
name=None, pretty_name=None, **kwds):
"""
Write some fields data into hdf/xmdf files.
@@ -261,10 +304,6 @@ class HDF_Writer(HDF_IO):
Parameters
----------
- xmfalways : boolean, optional
- true if xmf output must be updated at the same time
- an hdf5 file is created (i.e. at each time step),
- default=True
kwds : base class arguments
"""
@@ -272,18 +311,15 @@ class HDF_Writer(HDF_IO):
vnames = ['{}'.format(field.name) for field in variables.keys()]
vpnames = [field.pretty_name.decode('utf-8') for field in variables.keys()]
- name = first_not_None(name, 'write_{}'.format('_'.join(vnames)))
- pname = first_not_None(pretty_name, u'write_{}'.format(u'_'.join(vpnames)))
+ name = first_not_None(name, 'write_{}'.format('_'.join(vnames)))
+ pname = first_not_None(pretty_name, u'write_{}'.format(u'_'.join(vpnames)))
super(HDF_Writer, self).__init__(input_fields=variables, output_fields=None,
- name=name, pretty_name=pname, **kwds)
+ name=name, pretty_name=pname, **kwds)
# count the number of calls
self._count = 0
- if xmfalways:
- self.step = self._step_HDF5_XMF
- else:
- self.step = self._step_HDF5
+ self.step = self._step_HDF5
self._xdmf_data_files = []
# filename = prefix_N, N = counter value
self._get_filename = self._input_fname
@@ -293,6 +329,8 @@ class HDF_Writer(HDF_IO):
# if that happens.
self._last_written_time = None
self._xmf_file = None
+ if self.io_params.append:
+ self.openXMFFile()
self._data_getters = {}
def get_work_properties(self, **kwds):
@@ -330,7 +368,7 @@ class HDF_Writer(HDF_IO):
if (data.backend.device.type == cl.device_type.CPU):
def get_data(data=data.handle, queue=data.backend.cl_env.default_queue):
buf = data.map_to_host(queue=queue,
- is_blocking=True, flags=cl.map_flags.READ)
+ is_blocking=True, flags=cl.map_flags.READ)
return buf
# unmap is called when buf is destroyed
else:
@@ -340,30 +378,38 @@ class HDF_Writer(HDF_IO):
buf = buf[:data.nbytes].view(dtype=data.dtype).reshape(data.shape)
cpy = OpenClCopyBufferRectLauncher.from_slices(varname=name, src=data, dst=buf)
cpy = functools.partial(cpy, queue=data.backend.cl_env.default_queue)
+
def get_data(cpy=cpy, buf=buf):
cpy().wait()
return buf
else:
- msg='Data type not understood or unknown array backend.'
+ msg = 'Data type not understood or unknown array backend.'
raise NotImplementedError(msg)
self._data_getters[name] = get_data
def finalize(self):
if self._xmf_file:
- self.updateXMFFile()
+ filename = self._xmf_file.name
self._xmf_file.close()
+ if self.io_params.dump_is_temporary:
+ vprint('>Deleting XMF file {}...'.format(filename))
+ os.remove(filename)
def _input_fname(self, i):
"""Set output file name for current iteration"""
msg = 'count < 0, simu must be initialized.'
assert i >= 0, msg
- return self.io_params.filename + "_{0:05d}".format(i) + '.h5'
+ if (self.topology.cart_size == 1) or self.use_parallel_hdf5:
+ return self.io_params.filename + "_{0:06d}".format(i) + '.h5'
+ else:
+ assert self.use_local_hdf5
+ return self.io_params.filename + "_{0:06d}".format(i) + "_rk{rk:04d}.h5"
@op_apply
def apply(self, simulation=None, **kwds):
if (simulation is None):
raise ValueError("Missing simulation value for monitoring.")
- if simulation.should_dump(frequency=self.io_params.frequency):
+ if self.io_params.should_dump(simulation=simulation):
if (self._xmf_file is None):
self.createXMFFile()
self.step(simulation)
@@ -374,11 +420,11 @@ class HDF_Writer(HDF_IO):
dim = topo.domain.dim
dx = list(topo.mesh.space_step)
mesh = self.refmesh
- res = list(mesh.grid_resolution)
+ res = list(mesh.grid_resolution)
orig = list(topo.domain.origin)
- resolution = [1,]*3
- origin = [0.0,]*3
- step = [0.0,]*3
+ resolution = [1, ]*3
+ origin = [0.0, ]*3
+ step = [0.0, ]*3
idim = 3-dim
resolution[idim:] = res
@@ -390,26 +436,31 @@ class HDF_Writer(HDF_IO):
write_step = tuple(step)
ds_names = self.dataset.keys()
+ joinrkfiles = None
+ if self.use_local_hdf5 and (self.topology.cart_size > 1):
+ joinrkfiles = range(self.topology.cart_size)
grid_attributes = XMF.prepare_grid_attributes(
- ds_names,
- resolution, origin, step)
+ ds_names,
+ resolution, origin, step, joinrkfiles=joinrkfiles)
self.grid_attributes_template = grid_attributes
-
def createXMFFile(self):
"""Create and fill the header of the xdmf file."""
if (self.mpi_params.rank == self.io_params.io_leader):
f = open(self.io_params.filename + '.xmf', 'w')
- f.write("<?xml version=\"1.0\" ?>\n")
- f.write("<!DOCTYPE Xdmf SYSTEM \"Xdmf.dtd\">\n")
- f.write("<Xdmf Version=\"2.0\">\n")
- f.write(" <Domain>\n")
- f.write(" <Grid Name=\"CellTime\" GridType=\"Collection\" ")
- f.write("CollectionType=\"Temporal\">\n")
+ f.write(HDF_Writer.__xmf_header)
self._last_xmf_pos = f.tell()
self._xmf_file = f
f.flush()
+ def openXMFFile(self):
+ """Open an existing xdmf file."""
+ if (self.mpi_params.rank == self.io_params.io_leader):
+ f = open(self.io_params.filename + '.xmf', 'r+')
+ f.seek(-len(HDF_Writer.__xmf_footer), 2) # Read from file end
+ self._last_xmf_pos = f.tell()
+ self._xmf_file = f
+
def updateXMFFile(self):
"""Update xdmf file."""
if (self.mpi_params.rank == self.io_params.io_leader):
@@ -418,20 +469,27 @@ class HDF_Writer(HDF_IO):
assert (f is not None)
assert (lastp is not None)
for (i, t) in self._xdmf_data_files:
- filename = self._get_filename(i).split('/')[-1]
+ if (self.topology.cart_size == 1) or self.use_parallel_hdf5:
+ filenames = {'filename': self._get_filename(i).split('/')[-1]}
+ else:
+ filenames = dict(('filename'+str(r), self._get_filename(i).format(rk=r).split('/')[-1]) for r in range(self.topology.cart_size))
+ filenames.update(('resolution'+str(r), XMF._list_format(self._all_local_grid_resolution[r])) for r in range(self.topology.cart_size))
grid_attrs = self.grid_attributes_template.format(
- niteration=i, time=t, filename=filename)
+ niteration=i, time=t, **filenames)
f.seek(lastp)
f.write(grid_attrs)
self._last_xmf_pos = f.tell()
- f.write(" </Grid>\n")
- f.write(" </Domain>\n")
- f.write("</Xdmf>\n")
+ f.write(HDF_Writer.__xmf_footer)
f.flush()
self._xdmf_data_files = []
def _step_HDF5(self, simu):
"""Write an h5 file with data on each mpi process.
+
+ If parallel interface of HDF5 is not enabled, each rank is
+ writing its own h5 file. All files are concatenated in the xmf
+ part with a 'JOIN' function. If parallel interface enabled,
+ only one h5 file is written by all ranks.
"""
# Remarks:
# - force np.float64, ParaView seems unable to read float32
@@ -442,17 +500,37 @@ class HDF_Writer(HDF_IO):
# of the current output (count) and on the current process
# rank.
self._count = simu.current_iteration
- compression = self.open_hdf(self._count, mode='w')
+ (filename, compression) = self.open_hdf(self._count, mode='w')
+ vprint('>Dumping {} HDF5 data to {}...'.format(
+ 'compressed' if compression else 'uncompressed',
+ filename))
# Get the names of output input_fields and create the corresponding
# datasets
- for name in self.dataset:
- ds = self._hdf_file.create_dataset(name,
- self._global_grid_resolution,
- dtype=npw.float64,
- compression=compression)
- # In parallel, each proc must write at the right place of the dataset
- ds[self._global_compute_slices[name]] = self._data_getters[name]()
+ if self.use_local_hdf5:
+ for name in self.dataset:
+ ds = self._hdf_file.create_dataset(name,
+ self._local_grid_resolution,
+ dtype=npw.float64,
+ compression=compression,
+ track_times=False) # required if we want to compare checksums in tests
+ ds[...] = self._data_getters[name]().astype(npw.float64)
+ elif self.use_parallel_hdf5:
+ for name in self.dataset:
+ ds = self._hdf_file.create_dataset(name,
+ self._global_grid_resolution,
+ dtype=npw.float64,
+ compression=compression,
+ track_times=False) # required if we want to compare checksums in tests
+ if (compression is None):
+ # no need for collective here because we do not use any filter
+ ds[self._global_compute_slices[name]] = self._data_getters[name]().astype(npw.float64)
+ else:
+ with ds.collective:
+ ds[self._global_compute_slices[name]] = self._data_getters[name]().astype(npw.float64)
+ else:
+ msg = 'Unknown HDF5 mode.'
+ raise RuntimeError(msg)
# Collect datas required to write the xdmf file
# --> add tuples (counter, time).
@@ -466,16 +544,57 @@ class HDF_Writer(HDF_IO):
self._last_written_time = simu.t()
self._hdf_file.close()
-
- def _step_HDF5_XMF(self, simu):
- self._step_HDF5(simu)
self.updateXMFFile()
+ if self.io_params.postprocess_dump:
+ postprocess_cmd = self.io_params.postprocess_dump
+ op_name = self.name
+ actual_filepath = self.io_params.filepath
+ disk_filepath = self.io_params.disk_filepath
+ xmf_file = self._xmf_file.name
+ hdf_file = filename
+ hdf_is_tmp = self.io_params.dump_is_temporary
+ iteration = self._count
+ time = self._last_written_time
+
+ vprint('>Executing postprocessing script: {}'.format(postprocess_cmd))
+
+ # execute command OP_NAME ACTUAL_FILEPATH DISK_FILEPATH XMF_FILE HDF5_FILE IS_TMP
+ command = [str(postprocess_cmd),
+ str(op_name), str(actual_filepath), str(disk_filepath),
+ str(xmf_file), str(hdf_file),
+ '1' if hdf_is_tmp else '0',
+ str(iteration), str(time)]
+ try:
+ subprocess.check_call(command)
+ except OSError as e:
+ msg = "\nFATAL ERROR: Could not find or execute postprocessing script '{}'.".format(command[0])
+ print msg
+ print
+ raise
+ except subprocess.CalledProcessError as e:
+ if (e.returncode == 10):
+ msg = "Postprocessing script has requested to stop the simulation (return code 10), exiting."
+ vprint(msg)
+ sys.exit(0)
+ else:
+ msg = '\nFATAL ERROR: Failed to call I/O postprocessing command.\n{}\n'
+ msg = msg.format(' '.join(command))
+ print(msg)
+ print
+ raise
+
+ if self.io_params.dump_is_temporary:
+ vprint('>Deleting HDF5 data {}...'.format(filename))
+ os.remove(filename)
+ del self._xdmf_data_files[:]
+
class HDF_Reader(HDF_IO):
"""
Parallel reading of hdf/xdmf files to fill some fields in.
"""
+
def __init__(self, variables, restart=None, name=None, **kwds):
"""Read some fields data from hdf/xmdf files.
Parallel readings.
diff --git a/hysop/operator/integrate.py b/hysop/operator/integrate.py
index 4c0a8e646e01f32b3d05f95766bc213bd01365c6..8bc7db166c65e7f14beea8ffb6f83aa613feb1e7 100644
--- a/hysop/operator/integrate.py
+++ b/hysop/operator/integrate.py
@@ -1,13 +1,11 @@
-
-
"""
@file enstrophy.py
Enstrophy solver frontend.
"""
-from hysop.constants import Implementation
-from hysop.tools.types import check_instance
-from hysop.tools.enum import EnumFactory
-from hysop.tools.decorators import debug
+from hysop.constants import Implementation
+from hysop.tools.types import check_instance
+from hysop.tools.enum import EnumFactory
+from hysop.tools.decorators import debug
from hysop.fields.continuous_field import Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.core.graph.computational_node_frontend import ComputationalGraphNodeFrontend
@@ -18,26 +16,28 @@ from hysop.parameters.default_parameters import VolumicIntegrationParameter
class Integrate(ComputationalGraphNodeFrontend):
"""
Interface for integrating fields on their domain
- Available implementations are:
+ Available implementations are:
*OPENCL (gpu based implementation)
"""
-
+
@classmethod
def implementations(cls):
from hysop.backend.device.opencl.operator.integrate import OpenClIntegrate
+ from hysop.backend.host.python.operator.integrate import PythonIntegrate
implementations = {
- Implementation.OPENCL: OpenClIntegrate
+ Implementation.OPENCL: OpenClIntegrate,
+ Implementation.PYTHON: PythonIntegrate
}
return implementations
-
+
@classmethod
def default_implementation(cls):
- return Implementation.OPENCL
-
+ return Implementation.PYTHON
+
@debug
def __init__(self, field, variables,
- parameter=None, scaling=None,
- implementation=None, base_kwds=None, **kwds):
+ parameter=None, scaling=None,
+ base_kwds=None, expr=None, **kwds):
"""
Initialize a Integrate operator frontend.
@@ -49,7 +49,7 @@ class Integrate(ComputationalGraphNodeFrontend):
P = scaling * integral_V(field)
where V is the field domain volume
and scaling depends on specified scaling method.
-
+
parameter
----------
field: Field
@@ -58,13 +58,15 @@ class Integrate(ComputationalGraphNodeFrontend):
dictionary of fields as keys and topologies as values.
parameter: ScalarParameter or TensorParameter
The output parameter that will contain the integral.
- Should match field.nb_components.
+ Should match field.nb_components.
A default parameter will be created if not specified.
scaling: None, float, str or array-like of str, optional
Scaling method used after integration.
'volumic': scale by domain size (product of mesh space steps)
- 'normalize': scale by first integration (first value will be 1.0)
+ 'normalize': scale by first integration (first value will be 1.0)
Defaults to volumic integration.
+ expr: None, str, optional
+ expression performed on each entry of the array before sum, elements are referenced as `x[i]`
implementation: Implementation, optional, defaults to None
target implementation, should be contained in available_implementations().
If None, implementation will be set to default_implementation().
@@ -72,29 +74,34 @@ class Integrate(ComputationalGraphNodeFrontend):
Base class keywords arguments.
If None, an empty dict will be passed.
kwds:
- Extra keywords arguments that will be passed towards implementation
+ Extra keywords arguments that will be passed towards implementation
enstrophy operator __init__.
Notes
-----
- An Integrate operator implementation should at least support
+ An Integrate operator implementation should at least support
the hysop.operator.base.integrate.IntegrateBase interface.
"""
base_kwds = base_kwds or dict()
-
+
check_instance(field, Field)
check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
check_instance(parameter, (ScalarParameter, TensorParameter), allow_none=True)
- check_instance(scaling, str, allow_none=True)
+ check_instance(scaling, (str, float), allow_none=True)
+ check_instance(expr, str, allow_none=True)
check_instance(base_kwds, dict, keys=str)
-
+
+ if expr is not None:
+ assert expr.find('x[i]') >= 0, "expression '{}' does not contain x[i]".format(expr)
+
# Pregenerate parameter so that we can directly store it in self.
if (parameter is None):
parameter = VolumicIntegrationParameter(field=field)
if (parameter.size != field.nb_components):
- msg='Expected a parameter of size {} but got a parameter of size {}.'
- msg=msg.format(field.nb_components, parameter.size)
+ msg = 'Expected a parameter of size {} but got a parameter of size {}.'
+ msg = msg.format(field.nb_components, parameter.size)
raise RuntimeError(msg)
-
+
super(Integrate, self).__init__(field=field, variables=variables,
- parameter=parameter, scaling=scaling, base_kwds=base_kwds, **kwds)
+ parameter=parameter, scaling=scaling, expr=expr,
+ base_kwds=base_kwds, **kwds)
diff --git a/hysop/operator/mean_field.py b/hysop/operator/mean_field.py
index f4c2cfc805e33713c82e031886db78fde6a8364a..e48595100424c2e5d92ccf3ca75b282ba8d2e560 100644
--- a/hysop/operator/mean_field.py
+++ b/hysop/operator/mean_field.py
@@ -115,7 +115,7 @@ class ComputeMeanField(ComputationalGraphOperator):
def apply(self, simulation, **kwds):
if (simulation is None):
raise ValueError("Missing simulation value for monitoring.")
- if simulation.should_dump(frequency=self.io_params.frequency):
+ if self.io_params.should_dump(simulation=simulation):
for (dfield, (view, axes)) in self.averaged_dfields.iteritems():
filename = self.filename(dfield, self.write_counter)
arrays = {}
diff --git a/hysop/operator/min_max.py b/hysop/operator/min_max.py
index c9533bbb1e13c92a3d32aabca7d53395ff8a0753..c15b66cf2a1abb12f421f825e2434e8367f60679 100644
--- a/hysop/operator/min_max.py
+++ b/hysop/operator/min_max.py
@@ -3,7 +3,7 @@
MinMaxFieldStatistics: compute min(f), max(f) and/or max(|f|) for a given field f.
MinMaxDerivativeStatistics: compute min(d^k(Fi)/dXj^k), max(d^kFi/dXj^k) and/or max(|dFi/dXj|)
for a given field, component, direction and order.
-MinMaxGradientStatistics: compute min(dFi/dXj), max(dFi/dXj) and/or max(|dFi/dXj|)
+MinMaxGradientStatistics: compute min(dFi/dXj), max(dFi/dXj) and/or max(|dFi/dXj|)
for a given field, up to all components in all directions.
"""
from hysop import vprint
@@ -26,7 +26,7 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
"""
Operator frontend to compute min and max statistics on the specific field.
"""
-
+
@classmethod
def implementations(cls):
from hysop.backend.host.python.operator.min_max import PythonMinMaxFieldStatistics
@@ -36,11 +36,11 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
Implementation.OPENCL: OpenClMinMaxFieldStatistics
}
return implementations
-
+
@classmethod
def default_implementation(cls):
return Implementation.PYTHON
-
+
@debug
def __init__(self, field, components=None, coeffs=None,
Fmin=None, Fmax=None, Finf=None, all_quiet=False,
@@ -49,7 +49,7 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
"""
Initialize a MinMaxFieldStatistics operator frontend.
Available operator backends are PYTHON and OPENCL.
-
+
MinMaxFieldStatistics can compute some commonly required Field statistics:
Fmin: component-wise min values of the field.
Fmax: component-wise max values of the field.
@@ -58,13 +58,13 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
All statistics are only computed if explicitely requested by user,
unless required to compute another user-required statistic, see Notes.
- All statistics may also be additionaly scaled by a coefficient.
-
+ All statistics may also be additionaly scaled by a coefficient.
+
Compute vectorized statistics:
Fmin = Smin * min(F[components])
Fmax = Smax * max(F[components])
Finf = Sinf * max(|Fmin|, |Fmax|)
-
+
where F is an input field
Fmin = created or supplied TensorParameter.
Fmax = created or supplied TensorParameter.
@@ -72,7 +72,7 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
Smin = coeffs['Fmin']
Smax = coeffs['Fmax']
Sinf = coeffs['Finf']
-
+
Parameters
----------
field: Field
@@ -109,7 +109,7 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
If None, implementation will be set to default_implementation().
base_kwds: dict, optional
Base class keyword arguments as a dictionnary.
- kwds:
+ kwds:
Extra keyword arguments passed towards operator backend implementation.
Attributes:
@@ -121,25 +121,25 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
Notes
-----
nb_components = min(field.nb_components, len(components)).
-
+
About statistics:
Finf requires to compute Fmin and Fmax and will have value:
Finf = Sinf * max( abs(Smin*Fmin), abs(Smax*Fmax))
where Sinf, Smin and Smax are the scaling coefficients defined in coeffs.
"""
check_instance(field, Field)
- check_instance(components, (tuple,list,npw.ndarray), values=int,
+ check_instance(components, (tuple,list,npw.ndarray), values=int,
allow_none=True, min_value=0, max_value=field.nb_components-1)
check_instance(coeffs, dict, keys=str, values=(tuple,list,npw.ndarray), allow_none=True)
- check_instance(variables, dict, keys=Field,
+ check_instance(variables, dict, keys=Field,
values=CartesianTopologyDescriptors, allow_none=True)
check_instance(name, str, allow_none=True)
check_instance(pbasename, str, allow_none=True)
check_instance(ppbasename, (str, unicode), allow_none=True)
check_instance(implementation, Implementation, allow_none=True)
check_instance(base_kwds, dict, keys=str, allow_none=True)
-
- if ( ((Fmin is None) or (Fmin is False))
+
+ if ( ((Fmin is None) or (Fmin is False))
and ((Fmax is None) or (Fmax is False))
and ((Finf is None) or (Finf is False))):
msg='No statistics were requested.'
@@ -147,11 +147,11 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
msg+=' their value to True, or by by passing an already existing '
msg+=' tensor parameter.'
raise ValueError(msg)
-
+
# Pregenerate parameters so that we can directly store them in self.
- parameters = MinMaxFieldStatisticsBase.build_parameters(field=field,
+ parameters = MinMaxFieldStatisticsBase.build_parameters(field=field,
components=components, all_quiet=all_quiet,
- Fmin=Fmin, Fmax=Fmax, Finf=Finf,
+ Fmin=Fmin, Fmax=Fmax, Finf=Finf,
pbasename=pbasename, ppbasename=ppbasename)
(Fmin, Fmax, Finf) = tuple(parameters[k] for k in ('Fmin', 'Fmax', 'Finf'))
@@ -168,10 +168,10 @@ class MinMaxFieldStatistics(ComputationalGraphNodeFrontend):
class MinMaxDerivativeStatistics(ComputationalGraphNodeFrontend):
"""
- Operator frontend to compute min and max statistics on a specific
+ Operator frontend to compute min and max statistics on a specific
derivative of a field component, without keeping its output.
"""
-
+
@classmethod
def implementations(cls):
raise NotImplementedError
@@ -179,30 +179,30 @@ class MinMaxDerivativeStatistics(ComputationalGraphNodeFrontend):
@classmethod
def default_implementation(cls):
raise NotImplementedError
-
+
@debug
- def __init__(self, F, dF=None, A=None,
+ def __init__(self, F, dF=None, A=None,
derivative=None, component=None, direction=None,
- out_component=None, scaling_view=None,
+ out_component=None, scaling_view=None,
Fmin=None, Fmax=None, Finf=None, coeffs=None, all_quiet=False,
name=None, pbasename=None, ppbasename=None,
variables=None, implementation=None, base_kwds=None, **kwds):
"""
Initialize a MinMaxDerivativeStatistics operator frontend.
Available operator backends are PYTHON and OPENCL.
-
+
MinMaxDerivativeStatistics can compute some commonly required Field derivative statistics:
Fmin: min value of a derivative of the field.
Fmax: max value of a derivative of the field.
Finf: max value of the absolute value of a
derivative of the field (computed using Fmin and Fmax).
-
+
First compute the derivative of a component of a field F in a given direction
- at a given order and on a given backend out of place in a specific output component of
+ at a given order and on a given backend out of place in a specific output component of
dF. The derivative is then possibly scaled by another field/parameter/value A.
After the scaled derivative has been computed, compute user requested statistics
- (min and max values) on this new field and scale those statistics by other scaling
+ (min and max values) on this new field and scale those statistics by other scaling
parameters stored in coeffs.
1) Compute derivative
@@ -230,7 +230,7 @@ class MinMaxDerivativeStatistics(ComputationalGraphNodeFrontend):
Statistics are only computed if explicitely requested by user,
unless required to compute another user-required statistic, see Notes.
-
+
Parameters
----------
F: hysop.field.continuous_field.Field
@@ -296,7 +296,7 @@ class MinMaxDerivativeStatistics(ComputationalGraphNodeFrontend):
If None, implementation will be set to default_implementation().
base_kwds: dict, optional
Base class keyword arguments as a dictionnary.
- kwds:
+ kwds:
Extra keyword arguments passed towards operator backend implementation.
Attributes:
@@ -326,8 +326,8 @@ class MinMaxDerivativeStatistics(ComputationalGraphNodeFrontend):
check_instance(ppbasename, (str, unicode), allow_none=True)
check_instance(implementation, Implementation, allow_none=True)
check_instance(base_kwds, dict, keys=str, allow_none=True)
-
- if ( ((Fmin is None) or (Fmin is False))
+
+ if ( ((Fmin is None) or (Fmin is False))
and ((Fmax is None) or (Fmax is False))
and ((Finf is None) or (Finf is False))):
msg='No statistics were requested.'
@@ -337,26 +337,26 @@ class MinMaxDerivativeStatistics(ComputationalGraphNodeFrontend):
raise ValueError(msg)
# Pregenerate parameters so that we can directly store them in self.
- parameters = MinMaxDerivativeStatisticsBase.build_parameters(field=F,
+ parameters = MinMaxDerivativeStatisticsBase.build_parameters(field=F,
components=(component,), all_quiet=all_quiet,
- Fmin=Fmin, Fmax=Fmax, Finf=Finf,
+ Fmin=Fmin, Fmax=Fmax, Finf=Finf,
pbasename=pbasename, ppbasename=ppbasename)
(Fmin, Fmax, Finf) = tuple(parameters[k] for k in ('Fmin', 'Fmax', 'Finf'))
- super(MinMaxDerivativeStatistics, self).__init__(F=F, dF=dF, A=A,
+ super(MinMaxDerivativeStatistics, self).__init__(F=F, dF=dF, A=A,
derivative=derivative, component=component, direction=direction,
- out_component=out_component, scaling_view=scaling_view,
+ out_component=out_component, scaling_view=scaling_view,
Fmin=Fmin, Fmax=Fmax, Finf=Finf, coeffs=coeffs, all_quiet=all_quiet,
name=name, pbasename=pbasename, ppbasename=ppbasename,
- variables=variables, implementation=implementation,
+ variables=variables, implementation=implementation,
base_kwds=base_kwds, **kwds)
-
+
self.Fmin, self.Fmax, self.Finf = (Fmin, Fmax, Finf)
class MinMaxSpectralDerivativeStatistics(MinMaxDerivativeStatistics):
"""
- Operator frontend to compute min and max statistics on a specific
+ Operator frontend to compute min and max statistics on a specific
derivative of a field component using the spectral method.
"""
@classmethod
@@ -368,6 +368,7 @@ class MinMaxSpectralDerivativeStatistics(MinMaxDerivativeStatistics):
implementations = {
Implementation.PYTHON: PythonMinMaxSpectralDerivativeStatistics,
Implementation.OPENCL: OpenClMinMaxSpectralDerivativeStatistics
+
}
return implementations
@@ -378,7 +379,7 @@ class MinMaxSpectralDerivativeStatistics(MinMaxDerivativeStatistics):
class MinMaxFiniteDifferencesDerivativeStatistics(MinMaxDerivativeStatistics):
"""
- Operator frontend to compute min and max statistics on a specific
+ Operator frontend to compute min and max statistics on a specific
derivative of a field component using finite differences.
"""
@classmethod
@@ -396,4 +397,3 @@ class MinMaxFiniteDifferencesDerivativeStatistics(MinMaxDerivativeStatistics):
@classmethod
def default_implementation(cls):
return Implementation.PYTHON
-
diff --git a/hysop/operator/misc.py b/hysop/operator/misc.py
index 13254bb1cb1d451f60540f0e98fd9241403510de..3f715b906a0cf289efa2c5e1c91ef1686cccd54e 100644
--- a/hysop/operator/misc.py
+++ b/hysop/operator/misc.py
@@ -9,7 +9,7 @@ from hysop.fields.continuous_field import Field
class Noop(ComputationalGraphOperator):
"""An operator that does nothing and implements apply as noop."""
- def apply(self):
+ def apply(self, **kwds):
"""This is a noop."""
pass
@@ -56,7 +56,9 @@ class ForceTopologyState(Noop):
@debug
def __init__(self, fields, variables,
tstate=None, memorder=None,
- backend=None, extra_kwds=None, mpi_params=None, **kwds):
+ backend=None, extra_kwds=None,
+ mpi_params=None, cl_env=None,
+ **kwds):
extra_kwds = first_not_None(extra_kwds, {})
fields = to_tuple(fields)
@@ -77,11 +79,16 @@ class ForceTopologyState(Noop):
input_fields = { k:variables[k] for k in fields }
output_fields = { k:variables[k] for k in fields }
- if (mpi_params is None) and ('cl_env' in extra_kwds):
- mpi_params = extra_kwds['cl_env'].mpi_params
+ cl_env = first_not_None(cl_env, extra_kwds.get('cl_env', None))
+ mpi_params = first_not_None(mpi_params, extra_kwds.get('mpi_params', None), getattr(cl_env, 'mpi_params', None))
+
+ extra_kwds.setdefault('cl_env', cl_env)
+ extra_kwds.setdefault('mpi_params', mpi_params)
+ kwds.setdefault('cl_env', cl_env)
+ kwds.setdefault('mpi_params', mpi_params)
super(ForceTopologyState, self).__init__(input_fields=input_fields,
- output_fields=output_fields, mpi_params=mpi_params, **kwds)
+ output_fields=output_fields, **kwds)
self.tstate = tstate
self.memorder = memorder
self.backend = first_not_None(backend, Backend.HOST)
diff --git a/hysop/operator/parameter_plotter.py b/hysop/operator/parameter_plotter.py
index 8a1abda648860aa6cdd03a39698c8797506efd84..d41ce08b44e4b447249dec8f8ae4b185e044a18b 100644
--- a/hysop/operator/parameter_plotter.py
+++ b/hysop/operator/parameter_plotter.py
@@ -1,7 +1,4 @@
-import matplotlib
-import matplotlib.pyplot as plt
from abc import abstractmethod
-from hysop.core.mpi import main_rank
from hysop.tools.types import to_tuple, check_instance, first_not_None
from hysop.tools.numpywrappers import npw
from hysop.tools.io_utils import IO
@@ -9,20 +6,29 @@ from hysop.core.graph.computational_graph import ComputationalGraphOperator
from hysop.parameters.scalar_parameter import ScalarParameter
from hysop.parameters.tensor_parameter import TensorParameter
+
class PlottingOperator(ComputationalGraphOperator):
"""
Base operator for plotting.
"""
- def __init__(self, name,
- dump_dir=None,
- update_frequency=1,
- save_frequency=100,
- axes_shape=(1,),
- figsize=(30,18),
- visu_rank=0,
- fig=None,
- axes=None,
- **kwds):
+ @classmethod
+ def supports_mpi(cls):
+ return True
+
+ def __init__(self, name=None,
+ dump_dir=None,
+ update_frequency=1,
+ save_frequency=100,
+ axes_shape=(1,),
+ figsize=(30, 18),
+ visu_rank=0,
+ fig=None,
+ axes=None,
+ **kwds):
+
+ import matplotlib
+ import matplotlib.pyplot as plt
+
check_instance(name, str)
check_instance(update_frequency, int, minval=0)
check_instance(save_frequency, int, minval=0)
@@ -30,33 +36,34 @@ class PlottingOperator(ComputationalGraphOperator):
super(PlottingOperator, self).__init__(**kwds)
if (fig is None) ^ (axes is None):
- msg='figure and axes should be specified at the same time.'
+ msg = 'figure and axes should be specified at the same time.'
raise RuntimeError(msg)
-
+
dump_dir = first_not_None(dump_dir, IO.default_path())
imgpath = '{}/{}.png'.format(dump_dir, name)
-
+
if (fig is None):
fig, axes = plt.subplots(*axes_shape, figsize=figsize)
fig.canvas.mpl_connect('key_press_event', self.on_key_press)
fig.canvas.mpl_connect('close_event', self.on_close)
-
+
axes = npw.asarray(axes).reshape(axes_shape)
- self.fig = fig
+ self.fig = fig
self.axes = axes
self.update_frequency = update_frequency
self.save_frequency = save_frequency
self.imgpath = imgpath
- self.should_draw = (visu_rank == main_rank)
+ self.should_draw = (visu_rank == self.mpi_params.rank)
self.running = True
+ self.plt = plt
def draw(self):
if (not self.running):
return
self.fig.canvas.draw()
self.fig.show()
- plt.pause(0.001)
+ self.plt.pause(0.001)
def apply(self, **kwds):
self._update(**kwds)
@@ -71,36 +78,38 @@ class PlottingOperator(ComputationalGraphOperator):
def _save(self, simulation, **kwds):
if simulation.should_dump(frequency=self.save_frequency, with_last=True):
self.save(simulation=simulation, **kwds)
-
+
@abstractmethod
def update(self, **kwds):
pass
def save(self, **kwds):
self.fig.savefig(self.imgpath, dpi=self.fig.dpi,
- bbox_inches='tight')
-
+ bbox_inches='tight')
+
def on_close(self, event):
- self.running = False
+ self.running = False
def on_key_press(self, event):
key = event.key
if key == 'q':
- plt.close(self.fig)
+ self.plt.close(self.fig)
self.running = False
class ParameterPlotter(PlottingOperator):
"""
- Base operator to plot parameters during runtime.
+ Base operator to plot parameters during runtime.
"""
-
- def __init__(self, name, parameters, alloc_size=128,
- fig=None, axes=None, shape=None, **kwds):
+
+ def __init__(self, name, parameters, alloc_size=128,
+ fig=None, axes=None, shape=None, **kwds):
+
input_params = {}
if (fig is not None) and (axes is not None):
+ import matplotlib
custom_axes = True
- axes_shape=None
+ axes_shape = None
check_instance(parameters, dict, keys=matplotlib.axes.Axes, values=dict)
for params in parameters.values():
check_instance(params, dict, keys=str, values=ScalarParameter)
@@ -110,36 +119,37 @@ class ParameterPlotter(PlottingOperator):
_parameters = {}
if isinstance(parameters, TensorParameter):
_parameters[0] = parameters
- elif isinstance(parameters, (list,tuple)):
- for (i,p) in enumerate(parameters):
+ elif isinstance(parameters, (list, tuple)):
+ for (i, p) in enumerate(parameters):
_parameters[i] = parameters
elif isinstance(parameters, dict):
_parameters = parameters.copy()
else:
raise TypeError(type(parameters))
- check_instance(_parameters, dict, keys=(int,tuple,list), values=(TensorParameter,list,tuple,dict))
-
+ check_instance(_parameters, dict, keys=(int, tuple, list),
+ values=(TensorParameter, list, tuple, dict))
+
parameters = {}
axes_shape = (1,)*2
- for (pos,params) in _parameters.iteritems():
+ for (pos, params) in _parameters.iteritems():
pos = to_tuple(pos)
pos = (2-len(pos))*(0,) + pos
check_instance(pos, tuple, values=int)
- axes_shape=tuple(max(p0,p1+1) for (p0,p1) in zip(axes_shape, pos))
+ axes_shape = tuple(max(p0, p1+1) for (p0, p1) in zip(axes_shape, pos))
if isinstance(params, dict):
- input_params.update({p.name:p for p in params.values()})
+ input_params.update({p.name: p for p in params.values()})
elif isinstance(params, TensorParameter):
input_params[params.name] = params
params = {params.name: params}
- elif isinstance(params, (list,tuple)):
+ elif isinstance(params, (list, tuple)):
for p in params:
input_params[p.name] = p
- params = {p.name:p for p in params}
+ params = {p.name: p for p in params}
else:
raise TypeError(type(params))
check_instance(params, dict, keys=str, values=TensorParameter)
_params = {}
- for (pname,p) in params.iteritems():
+ for (pname, p) in params.iteritems():
if isinstance(p, ScalarParameter):
_params[pname] = p
else:
@@ -149,22 +159,23 @@ class ParameterPlotter(PlottingOperator):
_params[_pname] = _p
parameters[pos] = _params
- super(ParameterPlotter, self).__init__(name=name, input_params=input_params,
- axes_shape=axes_shape, axes=axes, fig=fig, **kwds)
+ super(ParameterPlotter, self).__init__(name=name, input_params=input_params,
+ axes_shape=axes_shape, axes=axes, fig=fig, **kwds)
+
self.custom_axes = custom_axes
- data = {}
+ data = {}
lines = {}
times = npw.empty(shape=(alloc_size,), dtype=npw.float32)
- for (pos,params) in parameters.iteritems():
- params_data = {}
+ for (pos, params) in parameters.iteritems():
+ params_data = {}
params_lines = {}
- for (pname,p) in params.iteritems():
+ for (pname, p) in params.iteritems():
pdata = npw.empty(shape=(alloc_size,), dtype=p.dtype)
pline = self.get_axes(pos).plot([], [], label=pname)[0]
- params_data[p] = pdata
+ params_data[p] = pdata
params_lines[p] = pline
- data[pos] = params_data
+ data[pos] = params_data
lines[pos] = params_lines
self.fig.canvas.set_window_title('HySoP Parameter Plotter')
@@ -182,16 +193,15 @@ class ParameterPlotter(PlottingOperator):
else:
return axes[pos]
-
def __getitem__(self, i):
if self.custom_axes:
return self.axes[i]
else:
return self.axes.flatten()[i]
-
+
def update(self, simulation, **kwds):
# expand memory if required
- if (self.counter+1>self.times.size):
+ if (self.counter+1 > self.times.size):
times = npw.empty(shape=(2*self.times.size,), dtype=self.times.dtype)
times[:self.times.size] = self.times
self.times = times
@@ -203,10 +213,9 @@ class ParameterPlotter(PlottingOperator):
times, data, lines = self.times, self.data, self.lines
times[self.counter] = simulation.t()
- for (pos,params) in self.parameters.iteritems():
- for (pname,p) in params.iteritems():
+ for (pos, params) in self.parameters.iteritems():
+ for (pname, p) in params.iteritems():
data[pos][p][self.counter] = p()
lines[pos][p].set_xdata(times[:self.counter])
lines[pos][p].set_ydata(data[pos][p][:self.counter])
self.counter += 1
-
diff --git a/hysop/operator/penalization.py b/hysop/operator/penalization.py
old mode 100755
new mode 100644
index 6907e10930870b6e6994fa179a74bccc93fe6a9f..94d750e7392f588948447ad1f053fdb54d3541c4
--- a/hysop/operator/penalization.py
+++ b/hysop/operator/penalization.py
@@ -7,12 +7,13 @@
See details in :ref:`penalisation` section of HySoP user guide.
"""
-from hysop.constants import Implementation
+from hysop.constants import Implementation, PenalizationFormulation
from hysop.tools.types import check_instance, to_list
from hysop.tools.decorators import debug
from hysop.fields.continuous_field import Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.parameters.scalar_parameter import ScalarParameter
+from hysop.parameters.tensor_parameter import TensorParameter
from hysop.core.graph.computational_node_frontend import ComputationalGraphNodeFrontend
from hysop.backend.host.python.operator.penalization import PythonPenalizeVorticity
@@ -26,7 +27,7 @@ class PenalizeVorticity(ComputationalGraphNodeFrontend):
using penalization.
"""
__implementations = {
- Implementation.PYTHON: PythonPenalizeVorticity
+ Implementation.PYTHON: PythonPenalizeVorticity
}
@classmethod
@@ -40,7 +41,7 @@ class PenalizeVorticity(ComputationalGraphNodeFrontend):
@debug
def __init__(self, obstacles, variables,
velocity, vorticity,
- dt, coeff=None,
+ dt, coeff=None, ubar=None, formulation=None,
implementation=None, **kwds):
"""
Parameters
@@ -53,6 +54,10 @@ class PenalizeVorticity(ComputationalGraphNodeFrontend):
output vorticity
coeff : ScalarParameter, optional
penalization factor (\f\lambda\f) applied to all geometries.
+ ubar : TensorParameter, optional
+ Solid velocity (default to 0)
+ formulation: PenalizationFormulation
+ Solving penalization either with IMPLICIT scheme or EXACT solution
variables: dict
dictionary of fields as keys and topologies as values.
dt: ScalarParameter
@@ -82,24 +87,29 @@ class PenalizeVorticity(ComputationalGraphNodeFrontend):
Warning : coeff as a function is not yet implemented!!
"""
- obstacles = to_list(obstacles)
- assert len(set(obstacles)) == len(obstacles)
- obstacles = tuple(obstacles)
+ if not isinstance(obstacles, dict):
+ obstacles = to_list(obstacles)
+ assert len(set(obstacles)) == len(obstacles)
+ obstacles = tuple(obstacles)
check_instance(velocity, Field)
check_instance(vorticity, Field)
check_instance(variables, dict, keys=Field,
values=CartesianTopologyDescriptors)
check_instance(dt, ScalarParameter)
- check_instance(coeff, (ScalarParameter, float), allow_none=True)
+ check_instance(coeff, (ScalarParameter, float, type(lambda x: x)), allow_none=True)
+ check_instance(formulation, PenalizationFormulation, allow_none=True)
+ check_instance(ubar, TensorParameter, allow_none=True)
check_instance(obstacles, (tuple, dict), values=Field,
- keys=(ScalarParameter, float), check_kwds=False)
+ keys=(ScalarParameter, float, type(lambda x: x)), check_kwds=False)
super(PenalizeVorticity, self).__init__(
velocity=velocity,
vorticity=vorticity,
coeff=coeff,
+ ubar=ubar,
obstacles=obstacles,
dt=dt,
+ formulation=formulation,
variables=variables,
implementation=implementation,
**kwds)
diff --git a/hysop/operator/poisson.py b/hysop/operator/poisson.py
index 91208a94ee07199afda36c22ca9a9b356103aef0..a5a87dd5d238543852e69605666bc2b0ebb41ac2 100644
--- a/hysop/operator/poisson.py
+++ b/hysop/operator/poisson.py
@@ -11,8 +11,14 @@ from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.operator.base.spectral_operator import SpectralComputationalGraphNodeFrontend
from hysop.backend.host.python.operator.poisson import PythonPoisson
-from hysop.backend.device.opencl.operator.poisson import OpenClPoisson
-from hysop.backend.host.fortran.operator.poisson import PoissonFFTW
+try:
+ from hysop.backend.device.opencl.operator.poisson import OpenClPoisson
+except ImportError:
+ OpenClPoisson = None
+try:
+ from hysop.backend.host.fortran.operator.poisson import PoissonFFTW
+except ImportError:
+ PoissonFFTW = None
class Poisson(SpectralComputationalGraphNodeFrontend):
"""
diff --git a/hysop/operator/poisson_curl.py b/hysop/operator/poisson_curl.py
index 1fc61f707f56139b36095f62772627d54c62a0bb..5937836288ba6ca9034ffd19cd035cb9e46eca8f 100644
--- a/hysop/operator/poisson_curl.py
+++ b/hysop/operator/poisson_curl.py
@@ -10,9 +10,15 @@ from hysop.fields.continuous_field import Field
from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
from hysop.operator.base.spectral_operator import SpectralComputationalGraphNodeFrontend
-from hysop.backend.host.fortran.operator.poisson_curl import FortranPoissonCurl
from hysop.backend.host.python.operator.poisson_curl import PythonPoissonCurl
-from hysop.backend.device.opencl.operator.poisson_curl import OpenClPoissonCurl
+try:
+ from hysop.backend.device.opencl.operator.poisson_curl import OpenClPoissonCurl
+except ImportError:
+ OpenClPoissonCurl = None
+try:
+ from hysop.backend.host.fortran.operator.poisson_curl import FortranPoissonCurl
+except ImportError:
+ FortranPoissonCurl = None
class PoissonCurl(SpectralComputationalGraphNodeFrontend):
"""
diff --git a/hysop/operator/spatial_filtering.py b/hysop/operator/spatial_filtering.py
index 3e567de066ffec29bbd46ac4b9a89039bfe55c29..7facb047c99ba255df3341420c0151904e414def 100644
--- a/hysop/operator/spatial_filtering.py
+++ b/hysop/operator/spatial_filtering.py
@@ -1,6 +1,6 @@
"""
@file advection.py
-LowpassFilter operator generator.
+RestrictionFilter operator generator.
"""
from hysop.constants import Implementation
from hysop.tools.types import check_instance, to_list, first_not_None
@@ -14,60 +14,22 @@ from hysop.core.graph.node_generator import ComputationalGraphNodeGenerator
from hysop.core.graph.computational_node_frontend import MultiComputationalGraphNodeFrontend
FilteringMethod = EnumFactory.create('FilteringMethod',
-['SPECTRAL', 'REMESH', 'SUBGRID'])
+['SPECTRAL', 'REMESH', 'POLYNOMIAL', 'SUBGRID'])
-class LowpassFilterFrontend(MultiComputationalGraphNodeFrontend):
- """
- Interface for lowpass spatial filtering: small grid -> coarse grid
- Available implementations are:
- *Python/OpenCL using spectral filtering
- *Python using remeshing kernels
- *Python by just taking a subgrid (compatibility with deprecated MultiresolutionFilter)
- """
-
- @classmethod
- def all_implementations(cls):
- from hysop.backend.host.python.operator.spatial_filtering import \
- PythonRemeshLowpassFilter, PythonSpectralLowpassFilter, PythonSubgridLowpassFilter
- from hysop.backend.device.opencl.operator.spatial_filtering import \
- OpenClSpectralLowpassFilter
- ai = {
- FilteringMethod.SPECTRAL: {
- Implementation.PYTHON: PythonSpectralLowpassFilter,
- Implementation.OPENCL: OpenClSpectralLowpassFilter
- },
- FilteringMethod.REMESH: {
- Implementation.PYTHON: PythonRemeshLowpassFilter
- },
- FilteringMethod.SUBGRID: {
- Implementation.PYTHON: PythonSubgridLowpassFilter
- },
- }
- return ai
-
- @classmethod
- def all_default_implementations(cls):
- adi = {
- FilteringMethod.REMESH: Implementation.PYTHON,
- FilteringMethod.SPECTRAL: Implementation.PYTHON,
- FilteringMethod.SUBGRID: Implementation.PYTHON
- }
- return adi
-
-
+class SpatialFilterFrontend(MultiComputationalGraphNodeFrontend):
def __init__(self, input_variable, output_variable,
filtering_method, implementation=None,
base_kwds=None,
**kwds):
"""
- Initialize a LowpassFilter operator.
+ Initialize a SpatialFilter operator.
Parameters
----------
input_variable: ScalarField
- Input field on fine grid as a tuple (ScalarField, CartesianTopologyDescriptor).
+ Input field as a tuple (ScalarField, CartesianTopologyDescriptor).
output_variable: ScalarField
- Output field on coarse grid as a tuple (ScalarField, CartesianTopologyDescriptor).
+ Output field as a tuple (ScalarField, CartesianTopologyDescriptor).
filtering_method: FilteringMethod
Specify the lowpass filter type (either spectral or with remeshing kernels).
implementation: implementation, optional, defaults to None
@@ -81,7 +43,7 @@ class LowpassFilterFrontend(MultiComputationalGraphNodeFrontend):
Notes
-----
- An implementation should at least support the LowpassFilterBase interface.
+ An implementation should at least support the SpatialFilterBase interface.
"""
check_instance(input_variable, tuple, size=2)
check_instance(output_variable, tuple, size=2)
@@ -96,17 +58,92 @@ class LowpassFilterFrontend(MultiComputationalGraphNodeFrontend):
check_instance(base_kwds, dict, keys=str, allow_none=True)
assert (input_topo != output_topo), "Same topology for input and output."
- super(LowpassFilterFrontend, self).__init__(input_field=input_field, input_topo=input_topo,
+ super(SpatialFilterFrontend, self).__init__(input_field=input_field, input_topo=input_topo,
output_field=output_field, output_topo=output_topo,
implementation_key=filtering_method,
implementation=implementation,
base_kwds=base_kwds, **kwds)
+class RestrictionFilterFrontend(SpatialFilterFrontend):
+ """
+ Interface for restriction filtering: fine grid -> coarse grid
+ Available implementations are:
+ *Python/OpenCL using spectral filtering
+ *Python using remeshing kernels
+ *Python by just taking a subgrid (compatibility with deprecated MultiresolutionFilter)
+ """
+
+ @classmethod
+ def all_implementations(cls):
+ from hysop.backend.host.python.operator.spatial_filtering import \
+ PythonRemeshRestrictionFilter, PythonSpectralRestrictionFilter, \
+ PythonSubgridRestrictionFilter, PythonPolynomialRestrictionFilter
+ from hysop.backend.device.opencl.operator.spatial_filtering import \
+ OpenClSpectralRestrictionFilter, OpenClSubgridRestrictionFilter, \
+ OpenClPolynomialRestrictionFilter
+ ai = {
+ FilteringMethod.SUBGRID: {
+ Implementation.PYTHON: PythonSubgridRestrictionFilter,
+ Implementation.OPENCL: OpenClSubgridRestrictionFilter,
+ },
+ FilteringMethod.POLYNOMIAL: {
+ Implementation.PYTHON: PythonPolynomialRestrictionFilter,
+ Implementation.OPENCL: OpenClPolynomialRestrictionFilter,
+ },
+ FilteringMethod.SPECTRAL: {
+ Implementation.PYTHON: PythonSpectralRestrictionFilter,
+ Implementation.OPENCL: OpenClSpectralRestrictionFilter,
+ },
+ FilteringMethod.REMESH: {
+ Implementation.PYTHON: PythonRemeshRestrictionFilter,
+ },
+ }
+ return ai
+
+ @classmethod
+ def all_default_implementations(cls):
+ adi = {
+ FilteringMethod.SUBGRID: Implementation.PYTHON,
+ FilteringMethod.POLYNOMIAL: Implementation.PYTHON,
+ FilteringMethod.SPECTRAL: Implementation.PYTHON,
+ FilteringMethod.REMESH: Implementation.PYTHON,
+ }
+ return adi
+
-class LowpassFilter(ComputationalGraphNodeGenerator):
+class InterpolationFilterFrontend(SpatialFilterFrontend):
"""
- Graphnode generator to lowpass filter multiple fields at once.
+ Interface for interpolation filtering: coarse grid -> fine grid
+ Available implementations are:
+ *Python using polynomials (linear, cubic, quintic, ...)
+ """
+
+ @classmethod
+ def all_implementations(cls):
+ from hysop.backend.host.python.operator.spatial_filtering import \
+ PythonPolynomialInterpolationFilter
+ from hysop.backend.device.opencl.operator.spatial_filtering import \
+ OpenClPolynomialInterpolationFilter
+ ai = {
+ FilteringMethod.POLYNOMIAL: {
+ Implementation.PYTHON: PythonPolynomialInterpolationFilter,
+ Implementation.OPENCL: OpenClPolynomialInterpolationFilter,
+ },
+ }
+ return ai
+
+ @classmethod
+ def all_default_implementations(cls):
+ adi = {
+ FilteringMethod.POLYNOMIAL: Implementation.PYTHON,
+ }
+ return adi
+
+
+class SpatialFilter(ComputationalGraphNodeGenerator):
+ """
+ Graphnode generator to generate interpolation or restriction filter for multiple fields at once.
"""
@debug
def __init__(self, input_variables, output_variables,
@@ -114,7 +151,7 @@ class LowpassFilter(ComputationalGraphNodeGenerator):
base_kwds=None,
**kwds):
"""
- Initialize a LowpassFilter operator generator.
+ Initialize a RestrictionFilter/InterpolationFilter operator generator.
Parameters
----------
@@ -155,7 +192,7 @@ class LowpassFilter(ComputationalGraphNodeGenerator):
check_instance(filtering_method, FilteringMethod)
check_instance(implementation, Implementation)
- super(LowpassFilter, self).__init__(
+ super(SpatialFilter, self).__init__(
candidate_input_tensors=None,
candidate_output_tensors=None,
**base_kwds)
@@ -172,8 +209,12 @@ class LowpassFilter(ComputationalGraphNodeGenerator):
def _generate(self):
nodes = []
for (ifield, ofield) in zip(self._input_fields, self._output_fields):
- stopo = ComputationalGraphNode.get_topo_descriptor(self._input_variables, ifield)
- ttopo = ComputationalGraphNode.get_topo_descriptor(self._output_variables, ofield)
+ stopo = ComputationalGraphNode.get_topo_discretization(self._input_variables, ifield)
+ ttopo = ComputationalGraphNode.get_topo_discretization(self._output_variables, ofield)
+ check_instance(stopo, tuple, values=(int,long))
+ check_instance(ttopo, tuple, values=(int,long))
+ assert len(stopo)==len(ttopo)
+
fm = self._fm
impl = self._impl
kwds = self._kwds.copy()
@@ -181,12 +222,27 @@ class LowpassFilter(ComputationalGraphNodeGenerator):
# if source topology is destination topology there is nothing to be done
if (ttopo == stopo):
continue
-
- # else we build a lowpass filter operator
- node = LowpassFilterFrontend(input_variable=(ifield,stopo),
- output_variable=(ofield,ttopo),
- filtering_method=fm,
- implementation=impl,
- **kwds)
+ elif all(ns <= nt for (ns, nt) in zip(stopo, ttopo)):
+ # here we build an interpolation filter operator
+ node = InterpolationFilterFrontend(
+ input_variable=(ifield,stopo),
+ output_variable=(ofield,ttopo),
+ filtering_method=fm,
+ implementation=impl,
+ **kwds)
+ elif all(ns >= nt for (ns, nt) in zip(stopo, ttopo)):
+ # here we build a restriction filter operator
+ node = RestrictionFilterFrontend(
+ input_variable=(ifield,stopo),
+ output_variable=(ofield,ttopo),
+ filtering_method=fm,
+ implementation=impl,
+ **kwds)
+ else:
+ msg='Inconsistant topology descriptors {} and {} for field {} and {}, '
+ msg+='cannot interpolate and restrict at the same time.'
+ msg=msg.format(stopo, ttopo, ifield.name, ofield.name)
+ raise RuntimeError(msg)
nodes.append(node)
return nodes
+
diff --git a/hysop/operator/tests/test_absorption.py b/hysop/operator/tests/test_absorption.py
old mode 100755
new mode 100644
index 2b184eefa8b2623be4993bca8cc5727ea5b0ea3e..0e0f20c5d1343797123dae94f53c314fff196849
--- a/hysop/operator/tests/test_absorption.py
+++ b/hysop/operator/tests/test_absorption.py
@@ -47,20 +47,17 @@ class TestVorticityAbsorption(object):
pass
@staticmethod
- def __random_init(data, coords):
- dtype = data[0].dtype
+ def __random_init(data, coords, component):
+ dtype = data.dtype
if is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@staticmethod
- def __velo_init(data, coords):
- data[0][...] = 1.
- data[1][...] = 0.
- data[2][...] = 0.
+ def __velo_init(data, coords, component):
+ data[...] = [1,0,0][component]
def _test(self, dim, dtype,
size_min=None, size_max=None):
@@ -81,7 +78,7 @@ class TestVorticityAbsorption(object):
self._test_one(shape=shape, dim=dim, dtype=dtype,
domain=domain, velo=velo, vorti=vorti,
- start_coord=random.random()*.8+.1)
+ start_coord=random.random()*.7+.1)
def _test_one(self, shape, dim, dtype,
domain, velo, vorti, start_coord):
@@ -182,7 +179,7 @@ class TestVorticityAbsorption(object):
dist = npw.abs(fout-fref)
dinf = npw.max(dist)
deps = int(npw.ceil(dinf/eps))
- if (deps < 100):
+ if (deps < 200):
print '{}eps, '.format(deps),
continue
has_nan = npw.any(npw.isnan(fout))
diff --git a/hysop/operator/tests/test_analytic.py b/hysop/operator/tests/test_analytic.py
index 47b66cd7e059252f98f42af617768e832b8cc876..83e39704728eec7b00a00ca6d9be03f601961ded 100644
--- a/hysop/operator/tests/test_analytic.py
+++ b/hysop/operator/tests/test_analytic.py
@@ -12,7 +12,7 @@ from hysop.tools.types import check_instance, first_not_None
from hysop.tools.io_utils import IO
from hysop.tools.numpywrappers import npw
from hysop.parameters.scalar_parameter import ScalarParameter
-from hysop.operator.analytic import AnalyticField, Implementation
+from hysop.operator.analytic import AnalyticField, AnalyticScalarField, Implementation
from hysop import Field, Box
@@ -87,20 +87,18 @@ class TestAnalyticField(object):
pass
@staticmethod
- def __random_init(data, coords):
- dtype = data[0].dtype
+ def __random_init(data, coords, component):
+ dtype = data.dtype
if is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
- @classmethod
- def __analytic_init(cls, data, coords, fns, t):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- d[...] = npw.asarray(fn(*(coord+(t(),)))).astype(d.dtype)
+ @staticmethod
+ def __analytic_init(data, coords, fns, t, component):
+ fn = fns[component]
+ data[...] = npw.asarray(fn(*(coords+(t(),)))).astype(data.dtype)
def _test(self, dim, dtype,
size_min=None, size_max=None):
@@ -131,7 +129,7 @@ class TestAnalyticField(object):
print ' >Parameter t has been set to {}.'.format(self.t())
print ' >Testing all implementations:'
- implementations = AnalyticField.implementations()
+ implementations = AnalyticScalarField.implementations()
variables = { F:shape }
fns = self.analytic_functions[dim]['F']
@@ -177,7 +175,7 @@ class TestAnalyticField(object):
dF.initialize(self.__random_init)
op.apply()
- Fout = tuple( data.get().handle.copy() for data in dF.data )
+ Fout = tuple( data.get().handle.copy() for data in dF.data )
self._check_output(impl, op, Fref, Fout)
@classmethod
@@ -215,7 +213,7 @@ class TestAnalyticField(object):
print
print
- print 'Test output comparisson for {} failed for component {}:'.format(name, i)
+ print 'Test output comparisson for {} failed for component {}:'.format(iname, i)
print ' *has_nan: {}'.format(has_nan)
print ' *has_inf: {}'.format(has_inf)
print ' *dinf={} ({} eps)'.format(dinf, deps)
@@ -247,7 +245,7 @@ class TestAnalyticField(object):
print
print
- msg = 'Test failed for {} on component {} for implementation {}.'.format(name, i, impl)
+ msg = 'Test failed for {} on component {} for implementation {}.'.format(iname, i, impl)
raise RuntimeError(msg)
diff --git a/hysop/operator/tests/test_bilevel_advection.py b/hysop/operator/tests/test_bilevel_advection.py
index 9e5297c2dd53b9b730e440f6d29a47325d1a2c7f..12de79395a90865c5399ebb14c7cb64b001dda07 100644
--- a/hysop/operator/tests/test_bilevel_advection.py
+++ b/hysop/operator/tests/test_bilevel_advection.py
@@ -12,12 +12,13 @@ from hysop.parameters.scalar_parameter import ScalarParameter
from hysop.operator.advection import Advection
from hysop import Field, Box
-from hysop.methods import Remesh, TimeIntegrator
+from hysop.methods import Remesh, TimeIntegrator, Interpolation
from hysop.constants import Implementation, DirectionLabels, Backend, \
HYSOP_REAL, Implementation
from hysop.numerics.splitting.strang import StrangSplitting, StrangOrder
from hysop.numerics.odesolvers.runge_kutta import Euler, RK2, RK4
from hysop.numerics.remesh.remesh import RemeshKernel
+from hysop.numerics.interpolation.polynomial import PolynomialInterpolation
class TestBilevelAdvectionOperator(object):
@@ -40,7 +41,7 @@ class TestBilevelAdvectionOperator(object):
size_min=None, size_max=None):
assert dim > 0
- shape = npw.asarray((16,32,64))
+ shape = npw.asarray((16,32,64))[:dim]
npw.random.shuffle(shape)
shape = tuple(shape.tolist())
shape_s = tuple(2*s for s in shape)
@@ -74,20 +75,19 @@ class TestBilevelAdvectionOperator(object):
Vin=Vin, Sin=Sin, Sout=Sout, velocity_cfl=velocity_cfl)
@classmethod
- def __velocity_init(cls, data, coords, axes):
- for i,d in enumerate(data):
- if i in axes:
- d[...] = +1.0
- else:
- d[...] = 0.0
+ def __velocity_init(cls, data, coords, component, axes):
+ if component in axes:
+ data[...] = +1.0
+ else:
+ data[...] = 0.0
@classmethod
- def __scalar_init(cls, data, coords, offsets=None):
- offsets = first_not_None(offsets, (0.0,)*len(coords[0]))
- for i,(d,coord) in enumerate(zip(data, coords)):
- d[...] = 1.0/(i+1)
- for (c, o) in zip(coord, offsets):
- d[...] *= npw.cos(c+o)
+ def __scalar_init(cls, data, coords, component, offsets=None):
+ offsets = first_not_None(offsets, (0.0,)*len(coords))
+ assert len(coords)==len(offsets)
+ data[...] = 1.0/(component+1)
+ for (c, o) in zip(coords, offsets):
+ data[...] *= npw.cos(c+o)
def _test_one(self, time_integrator, remesh_kernel,
shape, shape_s, dim,
@@ -114,35 +114,43 @@ class TestBilevelAdvectionOperator(object):
implementations = DirectionalAdvection.implementations().keys()
implementations += Advection.implementations().keys()
implementations = list(set(implementations))
- assert ref_impl in implementations
+ assert (ref_impl in implementations)
implementations.remove(ref_impl)
implementations = [ref_impl] + implementations
implementations.remove(Implementation.PYTHON) # no bilevel support in python
- method = {TimeIntegrator: time_integrator, Remesh: remesh_kernel}
+ method = {
+ TimeIntegrator: time_integrator,
+ Remesh: remesh_kernel,
+ }
- def iter_impl(impl):
+ def iter_impl(impl, method=method):
graph = ComputationalGraph(name='test_graph')
+ method[Interpolation] = Interpolation.LINEAR
if (impl is Implementation.OPENCL):
- for cl_env in iter_clenv():
- msg='platform {}, device {}'.format(cl_env.platform.name.strip(),
- cl_env.device.name.strip())
- da = DirectionalAdvection(
- velocity=vin, advected_fields=sin, advected_fields_out=sout, dt=dt,
- velocity_cfl=velocity_cfl, variables=variables, implementation=impl,
- method=method, name='advection_{}'.format(str(impl).lower()))
- split = StrangSplitting(
- splitting_dim=dim,
- extra_kwds=dict(cl_env=cl_env),
- order=StrangOrder.STRANG_SECOND_ORDER)
- force_tstate = ForceTopologyState(fields=variables.keys(),
- variables=variables,
- backend=Backend.OPENCL,
- extra_kwds={'cl_env': cl_env})
- split.push_operators(da)
- graph.push_nodes(split, force_tstate)
- yield msg, graph
+ for interp_method in (Interpolation.LINEAR, ): # PolynomialInterpolation.LINEAR):
+ graph = ComputationalGraph(name='test_graph')
+ method[Interpolation] = interp_method
+ for cl_env in iter_clenv():
+ msg='platform {}, device {}, {}::{}'.format(cl_env.platform.name.strip(),
+ cl_env.device.name.strip(),
+ type(interp_method), interp_method)
+ da = DirectionalAdvection(velocity=vin,
+ advected_fields=sin, advected_fields_out=sout, dt=dt,
+ velocity_cfl=velocity_cfl, variables=variables, implementation=impl,
+ method=method, name='advection_{}'.format(str(impl).lower()))
+ split = StrangSplitting(
+ splitting_dim=dim,
+ extra_kwds=dict(cl_env=cl_env),
+ order=StrangOrder.STRANG_SECOND_ORDER)
+ force_tstate = ForceTopologyState(fields=variables.keys(),
+ variables=variables,
+ backend=Backend.OPENCL,
+ extra_kwds={'cl_env': cl_env})
+ split.push_operators(da)
+ graph.push_nodes(split, force_tstate)
+ yield msg, graph
elif impl is Implementation.FORTRAN:
assert dim==3, "Scales is only 3D"
adv = Advection(velocity=vin, advected_fields=sin, advected_fields_out=sout, dt=dt,
@@ -264,14 +272,14 @@ class TestBilevelAdvectionOperator(object):
sys.stdout.flush()
raise
+ def test_3D(self):
+ self._test(dim=3, is_inplace=True)
+
def perform_tests(self):
# Scales is only 3D
self._test(dim=3, is_inplace=True)
print
- def test_3D(self):
- self._test(dim=3, is_inplace=True)
-
if __name__ == '__main__':
import hysop
diff --git a/hysop/operator/tests/test_custom_symbolic.py b/hysop/operator/tests/test_custom_symbolic.py
index 40bc7073f1a5bce803aca984b775b491213ccff4..49d8e4287bd376c5a28363e8c134651d73039821 100644
--- a/hysop/operator/tests/test_custom_symbolic.py
+++ b/hysop/operator/tests/test_custom_symbolic.py
@@ -34,9 +34,9 @@ class TestCustomSymbolic(object):
cls.size_min = 4
cls.size_max = 6
else:
- cls.size_min0 = 6
- cls.size_max0 = 4096
- cls.size_min = 3
+ cls.size_min0 = 16
+ cls.size_max0 = 16
+ cls.size_min = 16
cls.size_max = 16
cls.enable_extra_tests = enable_extra_tests
@@ -51,17 +51,15 @@ class TestCustomSymbolic(object):
pass
@staticmethod
- def __field_init(data, coords, dtype, pollute=False):
+ def __field_init(data, coords, dtype, component, pollute=False):
shape = data[0].shape
if is_integer(dtype):
- for d in data:
- d[...] = np.random.random_integers(low=0, high=255, size=shape)
+ data[...] = np.random.random_integers(low=0, high=255, size=shape)
elif is_fp(dtype):
- for d in data:
- if pollute:
- d[...] = np.nan
- else:
- d[...] = np.random.random(size=d.shape)
+ if pollute:
+ data[...] = np.nan
+ else:
+ data[...] = np.random.random(size=data.shape)
else:
msg='Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@@ -794,7 +792,7 @@ class TestCustomSymbolic(object):
if __name__ == '__main__':
TestCustomSymbolic.setup_class(enable_extra_tests=False,
- enable_debug_mode=False)
+ enable_debug_mode=False)
enable_pretty_printing()
diff --git a/hysop/operator/tests/test_diffusion.py b/hysop/operator/tests/test_diffusion.py
index a0e95366a5e7abf211f4ce8c04926588f8d25fe3..d399f128e14f1a288dc16d98ae173b51049cf9c1 100644
--- a/hysop/operator/tests/test_diffusion.py
+++ b/hysop/operator/tests/test_diffusion.py
@@ -37,10 +37,8 @@ class TestDiffusionOperator(object):
size_min=None, size_max=None):
assert dim > 0
- # periodic boundaries removes one computational point
- # so we add one here.
- size_min = first_not_None(size_min, self.size_min) + 1
- size_max = first_not_None(size_max, self.size_max) + 1
+ size_min = first_not_None(size_min, self.size_min)
+ size_max = first_not_None(size_max, self.size_max)
shape = tuple(npw.random.randint(low=size_min, high=size_max, size=dim).tolist())
@@ -60,26 +58,24 @@ class TestDiffusionOperator(object):
self._test_one(shape=shape, dim=dim, dtype=dtype,
is_inplace=is_inplace, domain=domain,
Fin=Fin, Fout=Fout, nu=nu)
-
+
@staticmethod
- def __random_init(data, coords, dtype):
+ def __random_init(data, coords, dtype, component):
+ shape = data.shape
if is_integer(dtype):
- for d in data:
- d[...] = npw.random.random_integers(low=0, high=255, size=shape)
+ data[...] = npw.random.random_integers(low=0, high=255, size=shape)
elif is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape)
+ data[...] = npw.random.random(size=data.shape)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@staticmethod
- def __scalar_init(data, coords, dtype):
+ def __scalar_init(data, coords, dtype, component):
if is_fp(dtype):
- for i,(d,c) in enumerate(zip(data,coords)):
- d[...] = 1
- for xi in c:
- d[...] *= npw.cos(xi*(i+1))
+ data[...] = 1
+ for xi in coords:
+ data[...] *= npw.cos(xi*(component+1))
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@@ -269,14 +265,12 @@ class TestDiffusionOperator(object):
def test_diffusion_2D_inplace(self):
self._test(dim=2, is_inplace=True)
def test_diffusion_3D_inplace(self):
- if __ENABLE_LONG_TESTS__:
- self._test(dim=3, is_inplace=True)
+ self._test(dim=3, is_inplace=True)
def perform_tests(self):
self.test_diffusion_1D_inplace()
self.test_diffusion_2D_inplace()
- if __ENABLE_LONG_TESTS__:
- self.test_diffusion_3D_inplace()
+ self.test_diffusion_3D_inplace()
print
diff --git a/hysop/operator/tests/test_directional_advection.py b/hysop/operator/tests/test_directional_advection.py
index 05e81ccff195130237328d68888f2b34d5cd4271..307fb45dd53b86ef981c31f8da1cba65e31d0b3c 100644
--- a/hysop/operator/tests/test_directional_advection.py
+++ b/hysop/operator/tests/test_directional_advection.py
@@ -1,3 +1,4 @@
+import numpy as np
from hysop.deps import sys
from hysop.testsenv import __ENABLE_LONG_TESTS__
from hysop.testsenv import iter_clenv
@@ -81,20 +82,19 @@ class TestDirectionalAdvectionOperator(object):
Vin=Vin, Sin=Sin, Sout=Sout, velocity_cfl=velocity_cfl)
@classmethod
- def __velocity_init(cls, data, coords, axes):
- for i,d in enumerate(data):
- if i in axes:
- d[...] = +1.0
- else:
- d[...] = 0.0
+ def __velocity_init(cls, data, coords, component, axes):
+ if component in axes:
+ data[...] = +1.0
+ else:
+ data[...] = 0.0
@classmethod
- def __scalar_init(cls, data, coords, offsets=None):
- offsets = first_not_None(offsets, (0.0,)*len(coords[0]))
- for i,(d,coord) in enumerate(zip(data, coords)):
- d[...] = 1.0/(i+1)
- for (c, o) in zip(coord, offsets):
- d[...] *= npw.cos(c+o)
+ def __scalar_init(cls, data, coords, component, offsets=None):
+ offsets = first_not_None(offsets, (0.0,)*len(coords))
+ assert len(coords)==len(offsets)
+ data[...] = 1.0/(component+1)
+ for (c, o) in zip(coords, offsets):
+ data[...] *= npw.cos(c+o)
def _test_one(self, time_integrator, remesh_kernel,
shape, dim,
@@ -114,10 +114,10 @@ class TestDirectionalAdvectionOperator(object):
variables = { vin: shape, sin: shape, sout: shape }
# Use optimal timestep, ||Vi||_inf is 1 on a per-axis basis
- dt = ScalarParameter('dt', initial_value=npw.nan)
- dt.value = (0.99 * velocity_cfl) / (max(shape)-1)
+ dt = velocity_cfl * np.divide(domain.length, shape).min()
+ dt = ScalarParameter('dt', initial_value=dt, constant=True)
- ref_impl = Implementation.OPENCL
+ ref_impl = Implementation.PYTHON
implementations = DirectionalAdvection.implementations().keys()
assert ref_impl in implementations
implementations.remove(ref_impl)
@@ -129,8 +129,8 @@ class TestDirectionalAdvectionOperator(object):
base_kwds = dict(velocity=vin, advected_fields=sin, advected_fields_out=sout, dt=dt,
velocity_cfl=velocity_cfl, variables=variables, implementation=impl,
method=method, name='advection_{}'.format(str(impl).lower()))
- da = DirectionalAdvection(**base_kwds)
if impl is Implementation.PYTHON:
+ da = DirectionalAdvection(**base_kwds)
split = StrangSplitting(splitting_dim=dim,
order=StrangOrder.STRANG_SECOND_ORDER)
split.push_operators(da)
@@ -138,22 +138,22 @@ class TestDirectionalAdvectionOperator(object):
variables=variables,
backend=Backend.HOST)
graph = ComputationalGraph(name='test_graph')
- graph.push_nodes(split, force_tstate)
- yield 'default', graph
+ graph.push_nodes(split)
+ yield 'Python', graph
elif impl is Implementation.OPENCL:
for cl_env in iter_clenv():
msg='platform {}, device {}'.format(cl_env.platform.name.strip(),
cl_env.device.name.strip())
+ da = DirectionalAdvection(cl_env=cl_env, **base_kwds)
split = StrangSplitting(splitting_dim=dim,
- extra_kwds=dict(cl_env=cl_env),
order=StrangOrder.STRANG_SECOND_ORDER)
split.push_operators(da)
force_tstate = ForceTopologyState(fields=variables.keys(),
variables=variables,
backend=Backend.OPENCL,
- extra_kwds={'cl_env': cl_env})
+ cl_env=cl_env)
graph = ComputationalGraph(name='test_graph')
- graph.push_nodes(split, force_tstate)
+ graph.push_nodes(split)
yield msg, graph
else:
msg='Unknown implementation to test {}.'.format(impl)
@@ -196,8 +196,7 @@ class TestDirectionalAdvectionOperator(object):
S0 = dsin.integrate()
for k in xrange(napplies+1):
- if (k>0):
- graph.apply()
+ graph.apply()
output = tuple(dsout.data[i].get().handle.copy()
for i in xrange(dsout.nb_components))
@@ -211,11 +210,13 @@ class TestDirectionalAdvectionOperator(object):
raise RuntimeError(msg)
if is_ref:
- dxk = -Vi*(k+0)*dt()
+ dxk = -Vi*(k+1)*dt()
+ dsref[0].sdata[...] = npw.nan
+ dsref[1].sdata[...] = npw.inf
dsref.initialize(self.__scalar_init, offsets=dxk.tolist())
d = dsout.distance(dsref, p=2)
if npw.any(d > 1e-1):
- print 'FATAL ERROR: Could not match analytic advection.'
+ print '\nFATAL ERROR: Could not match analytic advection.'
print 'DSOUT'
for output in dsout:
print output.sdata[output.compute_slices]
@@ -235,12 +236,12 @@ class TestDirectionalAdvectionOperator(object):
for i in xrange(dsout.nb_components):
di = npw.abs(reference[i] - output[i])
max_di = npw.max(di)
- neps = 500
+ neps = 1000
max_tol = neps*npw.finfo(dsout.dtype).eps
if (max_di>max_tol):
- print 'FATAL ERROR: Could not match other implementation results.'
+ print '\nFATAL ERROR: Could not match other implementation results.'
print '\nComparisson failed at step {} and component {}:'.format(k,i)
- for (j,dv) in dvin.iter_fields():
+ for (j,dv) in enumerate(dvin):
print 'VELOCITY INPUT {}'.format(DirectionLabels[j])
print dv.sdata[dv.compute_slices]
print 'SCALAR INPUT'
@@ -272,13 +273,6 @@ class TestDirectionalAdvectionOperator(object):
sys.stdout.flush()
raise
- # def test_advec_1D_out_of_place(self):
- # self._test(dim=1, is_inplace=False)
- # def test_advec_2D_out_of_place(self):
- # self._test(dim=2, is_inplace=False)
- # def test_advec_3D_out_of_place(self):
- # self._test(dim=3, is_inplace=False)
-
def test_advec_1D_inplace(self):
self._test(dim=1, is_inplace=True)
def test_advec_2D_inplace(self):
@@ -290,17 +284,13 @@ class TestDirectionalAdvectionOperator(object):
self.test_advec_1D_inplace()
self.test_advec_2D_inplace()
self.test_advec_3D_inplace()
-
- #self.test_advec_1D_out_of_place()
- #self.test_advec_2D_out_of_place()
- #self.test_advec_3D_out_of_place()
print
if __name__ == '__main__':
import hysop
TestDirectionalAdvectionOperator.setup_class(enable_extra_tests=False,
- enable_debug_mode=False)
+ enable_debug_mode=True)
test = TestDirectionalAdvectionOperator()
diff --git a/hysop/operator/tests/test_directional_diffusion.py b/hysop/operator/tests/test_directional_diffusion.py
index 4949daad99774bbfb3261ceb694c8b2828041bcb..62619260403598dfd1db2df06aa874e306242ed4 100644
--- a/hysop/operator/tests/test_directional_diffusion.py
+++ b/hysop/operator/tests/test_directional_diffusion.py
@@ -77,25 +77,22 @@ class TestDirectionalDiffusionOperator(object):
Fin=Fin, Fout=Fout, coeffs=coeffs)
@staticmethod
- def __random_init(data, coords, dtype):
- shape = data[0].shape
+ def __random_init(data, coords, dtype, component):
+ shape = data.shape
if is_integer(dtype):
- for d in data:
- d[...] = npw.random.random_integers(low=0, high=255, size=shape)
+ data[...] = npw.random.random_integers(low=0, high=255, size=shape)
elif is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape)
+ data[...] = npw.random.random(size=data.shape)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@staticmethod
- def __scalar_init(data, coords, dtype):
+ def __scalar_init(data, coords, dtype, component):
if is_fp(dtype):
- for i,(d,coord) in enumerate(zip(data,coords)):
- d[...] = 1
- for xi in coord:
- d[...] *= npw.cos(xi*(i+1))
+ data[...] = 1
+ for xi in coords:
+ data[...] *= npw.cos(xi*(component+1))
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
diff --git a/hysop/operator/tests/test_directional_stretching.py b/hysop/operator/tests/test_directional_stretching.py
index 326327d3acf0c7ce3945347ea431ee5b211f064e..48e40dcf9f87fcd3d7a68d77c76819743a0d801d 100644
--- a/hysop/operator/tests/test_directional_stretching.py
+++ b/hysop/operator/tests/test_directional_stretching.py
@@ -85,15 +85,13 @@ class TestDirectionalStretchingOperator(object):
C=C, A=A, formulation=formulation)
@staticmethod
- def __random_init(data, coords):
- shape = data[0].shape
- dtype = data[0].dtype
+ def __random_init(data, coords, component):
+ shape = data.shape
+ dtype = data.dtype
if is_integer(dtype):
- for d in data:
- d[...] = npw.random.random_integers(low=0, high=255, size=shape)
+ data[...] = npw.random.random_integers(low=0, high=255, size=shape)
elif is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape)
+ data[...] = npw.random.random(size=shape)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
diff --git a/hysop/operator/tests/test_fd_derivative.py b/hysop/operator/tests/test_fd_derivative.py
index 6bca7fbe37e20fb9af0b529a08e95b6cfccf175a..036e75cc0e7039479d40fcdbf8d03faa17acfc0a 100644
--- a/hysop/operator/tests/test_fd_derivative.py
+++ b/hysop/operator/tests/test_fd_derivative.py
@@ -93,20 +93,17 @@ class TestFiniteDifferencesDerivative(object):
pass
@staticmethod
- def __random_init(data, coords):
- dtype = data[0].dtype
+ def __random_init(data, coords, component):
+ dtype = data.dtype
if is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@classmethod
- def __analytic_init(cls, data, coords, fns, t):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- d[...] = fn(*(coord+(t(),))).astype(d.dtype)
+ def __analytic_init(cls, data, coords, component, fns, t):
+ data[...] = fns[component](*(coords+(t(),))).astype(data.dtype)
def _test(self, dim, dtype,
size_min=None, size_max=None):
@@ -190,7 +187,6 @@ class TestFiniteDifferencesDerivative(object):
for impl in implementations:
for op in iter_impl(impl):
op.build(outputs_are_inputs=True)
- #op.display()
dF = op.get_input_discrete_field(F)
dgradF = op.get_output_discrete_field(gradF)
diff --git a/hysop/operator/tests/test_penalization.py b/hysop/operator/tests/test_penalization.py
index 85c06b0cb9d55d79f754c6a704599f0f29aaa433..e3e02ca68d523207d23f3a6a53cffd994a407434 100644
--- a/hysop/operator/tests/test_penalization.py
+++ b/hysop/operator/tests/test_penalization.py
@@ -45,26 +45,28 @@ class TestPenalizeVorticity(object):
pass
@staticmethod
- def __velo_init(data, coords):
- data[0][...] = 1.
- data[1][...] = 1.
- data[2][...] = 1.
+ def __velo_init(data, coords, component):
+ data[...] = 1.
@staticmethod
- def __zero_init(data, coords):
- (x, y, z) = coords[0]
- data[0][...] = np.cos(x) + np.sin(y) + np.cos(z)
- data[1][...] = np.sin(x) + np.cos(y)
- data[2][...] = np.cos(z) + np.sin(y) + np.cos(x)
+ def __zero_init(data, coords, component):
+ (x, y, z) = coords
+ if component == 0:
+ data[...] = np.cos(x) + np.sin(y) + np.cos(z)
+ if component == 1:
+ data[...] = np.sin(x) + np.cos(y)
+ if component == 2:
+ data[...] = np.cos(z) + np.sin(y) + np.cos(x)
@staticmethod
- def __sphere_init(data, coords):
- (x, y, z) = coords[0]
- data[0][...] = 0.
+ def __sphere_init(data, coords, component):
+ assert component == 0
+ (x, y, z) = coords
+ data[...] = 0.
pos = (random.random(), random.random(), random.random())
radius = random.random()
rr = np.sqrt((x-pos[0])*(x-pos[0])+(y-pos[1])*(y-pos[1])+(z-pos[2])*(z-pos[2]))
- data[0][rr<=radius] = 1.
+ data[rr<=radius] = 1.
def _test(self, dim, dtype,
diff --git a/hysop/operator/tests/test_poisson.py b/hysop/operator/tests/test_poisson.py
index 4a5a04d719cd5aab16b1740ad683169419cca24e..8d9406699d7a6cd2751fb55c8fba1c4bed894d23 100644
--- a/hysop/operator/tests/test_poisson.py
+++ b/hysop/operator/tests/test_poisson.py
@@ -1,4 +1,5 @@
-import random, primefac
+import random
+import primefac
from hysop.deps import it, sm, random
from hysop.constants import HYSOP_REAL, BoundaryCondition
from hysop.testsenv import __ENABLE_LONG_TESTS__, __HAS_OPENCL_BACKEND__
@@ -11,17 +12,18 @@ from hysop.tools.io_utils import IO
from hysop.tools.numpywrappers import npw
from hysop.tools.sympy_utils import truncate_expr, round_expr
from hysop.tools.spectral_utils import make_multivariate_trigonometric_polynomial, \
- make_multivariate_polynomial
+ make_multivariate_polynomial
from hysop.operator.poisson import Poisson, Implementation
from hysop import Field, Box
+
class TestPoissonOperator(object):
@classmethod
def setup_class(cls,
- enable_extra_tests=__ENABLE_LONG_TESTS__,
- enable_debug_mode=False):
+ enable_extra_tests=__ENABLE_LONG_TESTS__,
+ enable_debug_mode=False):
IO.set_default_path('/tmp/hysop_tests/test_poisson')
@@ -29,7 +31,7 @@ class TestPoissonOperator(object):
cls.size_max = 16
cls.enable_extra_tests = enable_extra_tests
- cls.enable_debug_mode = enable_debug_mode
+ cls.enable_debug_mode = enable_debug_mode
from hysop.tools.sympy_utils import enable_pretty_printing
enable_pretty_printing()
@@ -40,10 +42,10 @@ class TestPoissonOperator(object):
@classmethod
def build_analytic_solutions(cls, polynomial,
- dim, nb_components,
- lboundaries, rboundaries,
- origin, end):
- from hysop.symbolic.base import TensorBase
+ dim, nb_components,
+ lboundaries, rboundaries,
+ origin, end):
+ from hysop.symbolic.base import TensorBase
from hysop.symbolic.frame import SymbolicFrame
from hysop.symbolic.field import laplacian
@@ -55,60 +57,56 @@ class TestPoissonOperator(object):
for i in xrange(nb_components):
if polynomial:
psi, y = make_multivariate_polynomial(origin, end,
- lboundaries, rboundaries,
- 10, 4)
+ lboundaries, rboundaries,
+ 10, 4)
else:
psi, y = make_multivariate_trigonometric_polynomial(origin, end,
- lboundaries, rboundaries, 2)
- psi = psi.xreplace({yi: xi for (yi,xi) in zip(y, frame.coords)})
+ lboundaries, rboundaries, 2)
+ psi = psi.xreplace({yi: xi for (yi, xi) in zip(y, frame.coords)})
psis += (psi,)
return npw.asarray(psis).view(TensorBase)
- Psis = gen_psi()
- Ws = npw.atleast_1d(laplacian(Psis, frame))
+ Psis = gen_psi()
+ Ws = npw.atleast_1d(laplacian(Psis, frame))
- fWs = tuple(sm.lambdify(coords, W) for W in Ws)
+ fWs = tuple(sm.lambdify(coords, W) for W in Ws)
fPsis = tuple(sm.lambdify(coords, Psi) for Psi in Psis)
- analytic_expressions = {'Psi':Psis, 'W':Ws}
- analytic_functions = {'Psi':fPsis, 'W':fWs}
+ analytic_expressions = {'Psi': Psis, 'W': Ws}
+ analytic_functions = {'Psi': fPsis, 'W': fWs}
return (analytic_expressions, analytic_functions)
@staticmethod
- def __random_init(data, coords, dtype):
- for d in data:
- if is_fp(d.dtype):
- d[...] = npw.random.random(size=d.shape).astype(dtype=d.dtype)
- else:
- msg = 'Unknown dtype {}.'.format(d.dtype)
- raise NotImplementedError(msg)
+ def __random_init(data, coords, component, dtype):
+ if is_fp(dtype):
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
+ else:
+ msg = 'Unknown dtype {}.'.format(dtype)
+ raise NotImplementedError(msg)
@staticmethod
- def __analytic_init(data, coords, dtype, fns):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- coord = tuple(c.astype(d.dtype) for c in coord)
- d[...] = fn(*coord).astype(d.dtype)
-
+ def __analytic_init(data, coords, fns, component, dtype):
+ fn = fns[component]
+ data[...] = fn(*coords).astype(data.dtype)
def _test(self, dim, dtype, max_runs=5,
- polynomial=False, size_min=None, size_max=None):
+ polynomial=False, size_min=None, size_max=None):
if (dtype == HYSOP_REAL):
- nb_components = 1 # enable fortran poisson test
+ nb_components = 1 # enable fortran poisson test
else:
nb_components = 2
size_min = first_not_None(size_min, self.size_min)
size_max = first_not_None(size_max, self.size_max)
- valid_factors = {2,3,5,7,11,13}
+ valid_factors = {2, 3, 5, 7, 11, 13}
factors = {1}
while (factors-valid_factors):
factors.clear()
shape = tuple(npw.random.randint(low=size_min, high=size_max+1, size=dim).tolist())
for Si in shape:
- factors.update( set(primefac.primefac(int(Si))) )
+ factors.update(set(primefac.primefac(int(Si))))
domain_boundaries = list(domain_boundary_iterator(dim=dim))
periodic = domain_boundaries[0]
@@ -119,39 +117,39 @@ class TestPoissonOperator(object):
for i, (lboundaries, rboundaries) in enumerate(domain_boundaries, 1):
domain = Box(origin=(npw.random.rand(dim)-0.5),
length=(npw.random.rand(dim)+0.5)*2*npw.pi,
- lboundaries=lboundaries,
- rboundaries=rboundaries)
+ lboundaries=lboundaries,
+ rboundaries=rboundaries)
Psi = Field(domain=domain, name='Psi', dtype=dtype,
- nb_components=nb_components, register_object=False)
+ nb_components=nb_components, register_object=False)
W = Field(domain=domain, name='W', dtype=dtype,
- nb_components=nb_components, register_object=False)
+ nb_components=nb_components, register_object=False)
self._test_one(shape=shape, dim=dim, dtype=dtype,
- domain=domain, Psi=Psi, W=W,
- polynomial=polynomial, nb_components=nb_components)
- if (max_runs is not None) and (i==max_runs):
+ domain=domain, Psi=Psi, W=W,
+ polynomial=polynomial, nb_components=nb_components)
+ if (max_runs is not None) and (i == max_runs):
missing = ((4**(dim+1) - 1) / 3) - i
print
- print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(dim, missing)
+ print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(
+ dim, missing)
print
print
break
else:
- assert (i==(4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
+ assert (i == (4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
print
print '>> TESTED ALL {}D BOUNDARY CONDITIONS <<'.format(dim)
print
print
-
def _test_one(self, shape, dim, dtype,
- domain, Psi, W, polynomial, nb_components):
+ domain, Psi, W, polynomial, nb_components):
(analytic_expressions, analytic_functions) = \
self.build_analytic_solutions(
dim=dim, nb_components=nb_components, polynomial=polynomial,
- lboundaries=W.lboundaries[::-1], # => boundaries in variable order x0,...,xn
+ lboundaries=W.lboundaries[::-1], # => boundaries in variable order x0,...,xn
rboundaries=W.rboundaries[::-1],
origin=domain.origin[::-1],
end=domain.end[::-1])
@@ -159,82 +157,84 @@ class TestPoissonOperator(object):
def format_expr(e):
return truncate_expr(round_expr(e, 3), 80)
- msg='\nTesting {}D Poisson: dtype={} nb_components={} shape={} polynomial={}, bc=[{}]'.format(
- dim, dtype.__name__, nb_components, shape, polynomial, W.domain.format_boundaries())
- msg+='\n >Corresponding field boundary conditions are [{}].'.format(W.fields[0].format_boundaries())
- msg+='\n >Input analytic functions are (truncated):'
+ msg = '\nTesting {}D Poisson: dtype={} nb_components={} shape={} polynomial={}, bc=[{}]'.format(
+ dim, dtype.__name__, nb_components, shape, polynomial, W.domain.format_boundaries())
+ msg += '\n >Corresponding field boundary conditions are [{}].'.format(
+ W.fields[0].format_boundaries())
+ msg += '\n >Input analytic functions are (truncated):'
for (Wi, Wis) in zip(W.fields, analytic_expressions['W']):
- msg+='\n *{}(x,t) = {}'.format(Wi.pretty_name, format_expr(Wis))
- msg+='\n >Expected output solutions:'
+ msg += '\n *{}(x,t) = {}'.format(Wi.pretty_name, format_expr(Wis))
+ msg += '\n >Expected output solutions:'
for (Psi_i, Psis_i) in zip(Psi.fields, analytic_expressions['Psi']):
- msg+='\n *{}(x,t) = {}'.format(Psi_i.pretty_name, format_expr(Psis_i))
- msg+='\n >Testing all implementations:'
+ msg += '\n *{}(x,t) = {}'.format(Psi_i.pretty_name, format_expr(Psis_i))
+ msg += '\n >Testing all implementations:'
print msg
implementations = Poisson.implementations()
- variables = { Psi:shape, W:shape }
+ variables = {Psi: shape, W: shape}
+
def iter_impl(impl):
base_kwds = dict(Fout=Psi, Fin=W, variables=variables,
implementation=impl,
name='poisson_{}'.format(str(impl).lower()))
if impl is Implementation.FORTRAN:
- msg=' *Fortran FFTW: '
+ msg = ' *Fortran FFTW: '
print msg,
yield Poisson(**base_kwds)
elif impl is Implementation.PYTHON:
- msg=' *Python FFTW: '
+ msg = ' *Python FFTW: '
print msg,
yield Poisson(**base_kwds)
elif impl is Implementation.OPENCL:
from hysop.backend.device.opencl import cl
- msg=' *OpenCl CLFFT: '
+ msg = ' *OpenCl CLFFT: '
print msg
for cl_env in iter_clenv():
- msg=' |platform {}, device {}'.format(cl_env.platform.name.strip(),
- cl_env.device.name.strip())
+ msg = ' |platform {}, device {}'.format(cl_env.platform.name.strip(),
+ cl_env.device.name.strip())
print msg,
yield Poisson(cl_env=cl_env, **base_kwds)
- msg=' *OpenCl FFTW: '
+ msg = ' *OpenCl FFTW: '
print msg
cpu_envs = tuple(iter_clenv(device_type='cpu'))
if cpu_envs:
for cl_env in cpu_envs:
- msg=' |platform {}, device {}'.format(cl_env.platform.name.strip(),
- cl_env.device.name.strip())
+ msg = ' |platform {}, device {}'.format(cl_env.platform.name.strip(),
+ cl_env.device.name.strip())
print msg,
yield Poisson(cl_env=cl_env, enforce_implementation=False, **base_kwds)
else:
- msg='Unknown implementation to test {}.'.format(impl)
+ msg = 'Unknown implementation to test {}.'.format(impl)
raise NotImplementedError(msg)
- #Compare to analytic solution
+ # Compare to analytic solution
Psiref = None
Wref = None
for impl in implementations:
if (impl is Implementation.FORTRAN):
- if ((nb_components>1) or (dim!=3) or (not dtype is HYSOP_REAL)
+ if ((nb_components > 1) or (dim != 3) or (not dtype is HYSOP_REAL)
or any((bd != BoundaryCondition.PERIODIC) for bd in W.lboundaries)
or any((bd != BoundaryCondition.PERIODIC) for bd in W.rboundaries)):
print ' *Fortran FFTW: NO SUPPORT'
continue
for op in iter_impl(impl):
- op = op.build()
- dw = op.get_input_discrete_field(W).as_contiguous_dfield()
+ op = op.build()
+ dw = op.get_input_discrete_field(W).as_contiguous_dfield()
dpsi = op.get_output_discrete_field(Psi).as_contiguous_dfield()
dw.initialize(self.__analytic_init, dtype=dtype,
fns=analytic_functions['W'])
if (Psiref is None):
dpsi.initialize(self.__analytic_init, dtype=dtype,
- fns=analytic_functions['Psi'])
- Wref = tuple( data.get().handle.copy() for data in dw.data )
- Psiref = tuple( data.get().handle.copy() for data in dpsi.data )
+ fns=analytic_functions['Psi'])
+ Wref = tuple(data.get().handle.copy() for data in dw.data)
+ Psiref = tuple(data.get().handle.copy() for data in dpsi.data)
dpsi.initialize(self.__random_init, dtype=dtype)
op.apply(simulation=None)
- Wout = tuple( data.get().handle.copy() for data in dw.data )
- Psiout = tuple( data.get().handle.copy() for data in dpsi.data )
+ Wout = tuple(data.get().handle.copy() for data in dw.data)
+ Psiout = tuple(data.get().handle.copy() for data in dpsi.data)
self._check_output(impl, op, Wref, Psiref, Wout, Psiout)
if (impl is Implementation.FORTRAN):
op.finalize(clean_fftw_solver=True)
@@ -248,9 +248,9 @@ class TestPoissonOperator(object):
check_instance(Psiout, tuple, values=npw.ndarray, size=len(Wref))
msg0 = 'Reference field {} is not finite.'
- for (fields, name) in zip((Wref, Psiref),('Wref', 'Psiref')):
- for (i,field) in enumerate(fields):
- iname = '{}{}'.format(name,i)
+ for (fields, name) in zip((Wref, Psiref), ('Wref', 'Psiref')):
+ for (i, field) in enumerate(fields):
+ iname = '{}{}'.format(name, i)
mask = npw.isfinite(field)
if not mask.all():
print
@@ -262,9 +262,9 @@ class TestPoissonOperator(object):
raise ValueError(msg)
for (out_buffers, ref_buffers, name) in zip((Wout, Psiout),
- (Wref, Psiref), ('W', 'Psi')):
- for i, (fout,fref) in enumerate(zip(out_buffers, ref_buffers)):
- iname = '{}{}'.format(name,i)
+ (Wref, Psiref), ('W', 'Psi')):
+ for i, (fout, fref) in enumerate(zip(out_buffers, ref_buffers)):
+ iname = '{}{}'.format(name, i)
assert fout.dtype == fref.dtype, iname
assert fout.shape == fref.shape, iname
assert fout.flags.c_contiguous
@@ -277,7 +277,7 @@ class TestPoissonOperator(object):
elif has_inf:
deps = 'inf'
else:
- eps = npw.finfo(fout.dtype).eps
+ eps = npw.finfo(fout.dtype).eps
dist = npw.abs(fout-fref)
dinf = npw.max(dist)
deps = int(npw.ceil(dinf/eps))
@@ -294,53 +294,66 @@ class TestPoissonOperator(object):
print
if cls.enable_debug_mode:
print 'REFERENCE INPUTS:'
- for (i,w) in enumerate(Wref):
+ for (i, w) in enumerate(Wref):
print 'W{}'.format(i)
print w
print
if (name == 'Psi'):
print 'REFERENCE OUTPUT:'
- for (i,u) in enumerate(Psiref):
+ for (i, u) in enumerate(Psiref):
print 'Psi{}'.format(i)
print u
print
print
print 'OPERATOR {} OUTPUT:'.format(op.name.upper())
print
- for (i,u) in enumerate(Psiout):
+ for (i, u) in enumerate(Psiout):
print 'Psi{}'.format(i)
print u
print
else:
print 'MODIFIED INPUTS:'
- for (i,w) in enumerate(Wout):
+ for (i, w) in enumerate(Wout):
print 'W{}'.format(i)
print w
print
print
msg = 'Test failed for {} on component {} for implementation {}.'
- msg=msg.format(name, i, impl)
+ msg = msg.format(name, i, impl)
raise RuntimeError(msg)
-
def test_1d_float32(self, **kwds):
- self._test(dim=1, dtype=npw.float32, **kwds)
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=1, dtype=npw.float32, **kwds)
+
def test_2d_float32(self, **kwds):
- self._test(dim=2, dtype=npw.float32, **kwds)
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=2, dtype=npw.float32, **kwds)
+
def test_3d_float32(self, **kwds):
- self._test(dim=3, dtype=npw.float32, **kwds)
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=3, dtype=npw.float32, **kwds)
+
def test_4d_float32(self, **kwds):
- self._test(dim=4, dtype=npw.float32, **kwds)
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=4, dtype=npw.float32, **kwds)
def test_1d_float64(self, **kwds):
- self._test(dim=1, dtype=npw.float64, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=1, dtype=npw.float64, **kwds)
+
def test_2d_float64(self, **kwds):
- self._test(dim=2, dtype=npw.float64, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=2, dtype=npw.float64, **kwds)
+
def test_3d_float64(self, **kwds):
- self._test(dim=3, dtype=npw.float64, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=3, dtype=npw.float64, **kwds)
+
def test_4d_float64(self, **kwds):
- self._test(dim=4, dtype=npw.float64, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=4, dtype=npw.float64, **kwds)
# def test_polynomial_1d_float32(self, **kwds):
# self._test(dim=1, dtype=npw.float32, polynomial=True, **kwds)
@@ -349,26 +362,26 @@ class TestPoissonOperator(object):
# def test_polynomial_3d_float32(self, **kwds):
# self._test(dim=3, dtype=npw.float32, polynomial=True, **kwds)
-
def perform_tests(self):
max_1d_runs = None
max_2d_runs = 2
max_3d_runs = 2
max_4d_runs = 2
- if __ENABLE_LONG_TESTS__ or (HYSOP_REAL==npw.float32):
+ if __ENABLE_LONG_TESTS__ or (HYSOP_REAL == npw.float32):
self.test_1d_float32(max_runs=max_1d_runs)
self.test_2d_float32(max_runs=max_2d_runs)
if __ENABLE_LONG_TESTS__:
self.test_3d_float32(max_runs=max_3d_runs)
self.test_4d_float32(max_runs=max_4d_runs)
- if __ENABLE_LONG_TESTS__ or (HYSOP_REAL==npw.float64):
+ if __ENABLE_LONG_TESTS__ or (HYSOP_REAL == npw.float64):
self.test_1d_float64(max_runs=max_1d_runs)
self.test_2d_float64(max_runs=max_2d_runs)
if __ENABLE_LONG_TESTS__:
self.test_3d_float64(max_runs=max_3d_runs)
self.test_4d_float32(max_runs=max_4d_runs)
+
if __name__ == '__main__':
TestPoissonOperator.setup_class(enable_extra_tests=False,
enable_debug_mode=False)
diff --git a/hysop/operator/tests/test_poisson_curl.py b/hysop/operator/tests/test_poisson_curl.py
index 82d7bdd3de2bdee6dc3949c98cb527056dbcbb44..30ec59dae044816fae324ae289e1526127e4055b 100644
--- a/hysop/operator/tests/test_poisson_curl.py
+++ b/hysop/operator/tests/test_poisson_curl.py
@@ -84,22 +84,17 @@ class TestPoissonCurlOperator(object):
@staticmethod
- def __random_init(data, coords, dtype):
- for d in data:
- if is_fp(d.dtype):
- d[...] = npw.random.random(size=d.shape).astype(dtype=d.dtype)
- else:
- msg = 'Unknown dtype {}.'.format(d.dtype)
- raise NotImplementedError(msg)
+ def __random_init(data, coords, component, dtype):
+ if is_fp(dtype):
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
+ else:
+ msg = 'Unknown dtype {}.'.format(dtype)
+ raise NotImplementedError(msg)
@staticmethod
- def __analytic_init(data, coords, dtype, fns):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- coord = tuple(c.astype(d.dtype) for c in coord)
- d[...] = fn(*coord).astype(d.dtype)
-
-
+ def __analytic_init(data, coords, fns, component, dtype):
+ fn = fns[component]
+ data[...] = fn(*coords).astype(data.dtype)
def _test(self, dim, dtype, max_runs=5,
polynomial=False, size_min=None, size_max=None):
diff --git a/hysop/operator/tests/test_lowpass_filter.py b/hysop/operator/tests/test_restriction_filter.py
similarity index 92%
rename from hysop/operator/tests/test_lowpass_filter.py
rename to hysop/operator/tests/test_restriction_filter.py
index f5cd46c10a4733944da4adae80369a63962d128f..744351cc905caf7ae23a79ff516b79cac84309a2 100755
--- a/hysop/operator/tests/test_lowpass_filter.py
+++ b/hysop/operator/tests/test_restriction_filter.py
@@ -5,7 +5,7 @@ from hysop.testsenv import __ENABLE_LONG_TESTS__
from hysop.tools.io_utils import IO
from hysop.tools.numpywrappers import npw
from hysop.tools.types import first_not_None
-from hysop.operator.spatial_filtering import LowpassFilter
+from hysop.operator.spatial_filtering import SpatialFilter
from hysop.methods import FilteringMethod
from hysop.topology.cartesian_topology import CartesianTopology
from hysop.constants import implementation_to_backend, Implementation, HYSOP_REAL
@@ -18,17 +18,16 @@ from hysop import Field, Box, MPIParams
class TestMultiresolutionFilter(object):
@staticmethod
- def __f_init(data, coords):
+ def __f_init(data, coords, component):
from numpy import sin, cos
- (x, y, z) = coords[0]
- data[0][...] = - cos(x) * sin(y) * sin(z)
+ (x, y, z) = coords
+ data[...] = - cos(x) * sin(y) * sin(z)
@staticmethod
- def __random_init(data, coords):
- dtype = data[0].dtype
+ def __random_init(data, coords, component):
+ dtype = data.dtype
if is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@@ -93,7 +92,9 @@ class TestMultiresolutionFilter(object):
if impl is Implementation.PYTHON:
msg=' *Python: '
print msg,
- yield LowpassFilter(input_variables={f: topo_f}, output_variables={f: topo_c}, **base_kwds)
+ yield SpatialFilter(input_variables={f: topo_f},
+ output_variables={f: topo_c},
+ **base_kwds)
print
else:
msg='Unknown implementation to test {}.'.format(impl)
diff --git a/hysop/operator/tests/test_scales_advection.py b/hysop/operator/tests/test_scales_advection.py
index 3b69adde2a16a9de2a0f3087bd300ac9f18a7b19..10e40fd71a51e9600033dd6cb0f3135999271752 100644
--- a/hysop/operator/tests/test_scales_advection.py
+++ b/hysop/operator/tests/test_scales_advection.py
@@ -18,12 +18,13 @@ from hysop.numerics.splitting.strang import StrangSplitting, StrangOrder
from hysop.numerics.odesolvers.runge_kutta import Euler, RK2, RK4
from hysop.numerics.remesh.remesh import RemeshKernel
+
class TestScalesAdvectionOperator(object):
@classmethod
def setup_class(cls,
- enable_extra_tests=__ENABLE_LONG_TESTS__,
- enable_debug_mode=False):
+ enable_extra_tests=__ENABLE_LONG_TESTS__,
+ enable_debug_mode=False):
IO.set_default_path('/tmp/hysop_tests/test_scales_advection')
@@ -35,15 +36,14 @@ class TestScalesAdvectionOperator(object):
cls.size_max = 23
cls.enable_extra_tests = enable_extra_tests
- cls.enable_debug_mode = enable_debug_mode
+ cls.enable_debug_mode = enable_debug_mode
@classmethod
def teardown_class(cls):
pass
-
def _test(self, dim, is_inplace,
- size_min=None, size_max=None):
+ size_min=None, size_max=None):
assert dim > 0
# periodic boundaries removes one computational point
@@ -56,7 +56,7 @@ class TestScalesAdvectionOperator(object):
if self.enable_extra_tests:
flt_types = (HYSOP_REAL, )
time_integrators = (RK2, )
- remesh_kernels = (Remesh.L2_1, Remesh.L4_2, Remesh.L6_4)
+ remesh_kernels = (Remesh.L2_1, Remesh.L4_2, Remesh.L6_4)
velocity_cfls = (0.62, 1.89)
else:
flt_types = (HYSOP_REAL,)
@@ -66,63 +66,59 @@ class TestScalesAdvectionOperator(object):
domain = Box(length=(2*npw.pi,)*dim)
for dtype in flt_types:
- Vin = Field(domain=domain, name='Vin', dtype=dtype,
- nb_components=dim, register_object=False)
- Sin = Field(domain=domain, name='Sin', dtype=dtype,
- nb_components=5, register_object=False)
+ Vin = Field(domain=domain, name='Vin', dtype=dtype,
+ nb_components=dim, register_object=False)
+ Sin = Field(domain=domain, name='Sin', dtype=dtype,
+ nb_components=5, register_object=False)
Sout = Field(domain=domain, name='Sout', dtype=dtype,
- nb_components=5, register_object=False)
+ nb_components=5, register_object=False)
for time_integrator in time_integrators:
for remesh_kernel in remesh_kernels:
for velocity_cfl in velocity_cfls:
print
self._test_one(time_integrator=time_integrator, remesh_kernel=remesh_kernel,
- shape=shape, dim=dim, dtype=dtype,
- is_inplace=is_inplace, domain=domain,
- Vin=Vin, Sin=Sin, Sout=Sout, velocity_cfl=velocity_cfl)
+ shape=shape, dim=dim, dtype=dtype,
+ is_inplace=is_inplace, domain=domain,
+ Vin=Vin, Sin=Sin, Sout=Sout, velocity_cfl=velocity_cfl)
@classmethod
- def __velocity_init(cls, data, coords, axes):
- for i,d in enumerate(data):
- if i in axes:
- d[...] = +1.0
- else:
- d[...] = 0.0
+ def __velocity_init(cls, data, coords, component, axes):
+ if component in axes:
+ data[...] = +1.0
+ else:
+ data[...] = 0.0
@classmethod
- def __scalar_init(cls, data, coords, offsets=None):
- offsets = first_not_None(offsets, (0.0,)*len(coords[0]))
- for i,(d,coord) in enumerate(zip(data, coords)):
- d[...] = 1.0/(i+1)
- for (c, o) in zip(coord, offsets):
- d[...] *= npw.cos(c+o)
+ def __scalar_init(cls, data, coords, component, offsets=None):
+ offsets = first_not_None(offsets, (0.0,)*len(coords))
+ assert len(coords) == len(offsets)
+ data[...] = 1.0/(component+1)
+ for (c, o) in zip(coords, offsets):
+ data[...] *= npw.cos(c+o)
def _test_one(self, time_integrator, remesh_kernel,
- shape, dim,
- dtype, is_inplace, domain, velocity_cfl,
- Vin, Sin, Sout):
+ shape, dim,
+ dtype, is_inplace, domain, velocity_cfl,
+ Vin, Sin, Sout):
print '\nTesting {}D ScalesAdvection_{}_{}: inplace={} dtype={} shape={}, cfl={}'.format(
- dim, time_integrator.name(), remesh_kernel,
- is_inplace, dtype.__name__, shape, velocity_cfl),
+ dim, time_integrator.name(), remesh_kernel,
+ is_inplace, dtype.__name__, shape, velocity_cfl),
if is_inplace:
vin = Vin
sin, sout = Sin, Sin
- variables = { vin : shape, sin: shape }
+ variables = {vin: shape, sin: shape}
else:
vin = Vin
sin, sout = Sin, Sout
- variables = { vin: shape, sin: shape, sout: shape }
+ variables = {vin: shape, sin: shape, sout: shape}
# Use optimal timestep, ||Vi||_inf is 1 on a per-axis basis
dt = ScalarParameter('dt', initial_value=npw.nan)
dt.value = (0.99 * velocity_cfl) / (max(shape)-1)
- ref_impl = Implementation.PYTHON
- implementations = Advection.implementations().keys()
- msg='Python implementation is currently treated as a directional operator.'
- assert (ref_impl not in implementations), msg
- implementations = [ref_impl] + implementations
+ implementations = [Implementation.FORTRAN, ]
+ ref_impl = implementations[0]
method = {TimeIntegrator: time_integrator, Remesh: remesh_kernel}
@@ -131,8 +127,8 @@ class TestScalesAdvectionOperator(object):
variables=variables, implementation=impl,
method=method, name='advection_{}'.format(str(impl).lower()))
force_tstate = ForceTopologyState(fields=variables.keys(),
- variables=variables,
- backend=Backend.HOST)
+ variables=variables,
+ backend=Backend.HOST)
graph = ComputationalGraph(name='test_graph')
if impl is Implementation.PYTHON:
da = DirectionalAdvection(velocity_cfl=velocity_cfl, **base_kwds)
@@ -142,18 +138,18 @@ class TestScalesAdvectionOperator(object):
graph.push_nodes(split, force_tstate)
yield 'default', graph
elif impl is Implementation.FORTRAN:
- assert dim==3, "Scales is only 3D"
+ assert dim == 3, "Scales is only 3D"
adv = Advection(**base_kwds)
graph.push_nodes(adv, force_tstate)
yield 'SCALES', graph
else:
- msg='Unknown implementation to test {}.'.format(impl)
+ msg = 'Unknown implementation to test {}.'.format(impl)
raise NotImplementedError(msg)
# Compare to other implementations
advec_axes = (tuple(),)
advec_axes += tuple((x,) for x in xrange(dim))
- if (dim>1):
+ if (dim > 1):
advec_axes += (tuple(xrange(dim)),)
reference_fields = {}
@@ -164,16 +160,15 @@ class TestScalesAdvectionOperator(object):
print '\n *{}: '.format(sop),
graph.build()
-
for axes in advec_axes:
- #print 'SWITCHING TO AXES {}'.format(axes)
+ # print 'SWITCHING TO AXES {}'.format(axes)
ref_outputs = reference_fields.setdefault(axes, {})
napplies = 10
Vi = npw.asarray([+1.0 if (i in axes) else +0.0
- for i in xrange(dim)], dtype=dtype)
+ for i in xrange(dim)], dtype=dtype)
- dvin = graph.get_input_discrete_field(vin).as_contiguous_dfield()
- dsin = graph.get_input_discrete_field(sin).as_contiguous_dfield()
+ dvin = graph.get_input_discrete_field(vin).as_contiguous_dfield()
+ dsin = graph.get_input_discrete_field(sin).as_contiguous_dfield()
dsout = graph.get_output_discrete_field(sout).as_contiguous_dfield()
dsref = dsout.clone()
@@ -182,27 +177,31 @@ class TestScalesAdvectionOperator(object):
try:
dvin.initialize(self.__velocity_init, axes=axes)
dsin.initialize(self.__scalar_init)
+ dsout.initialize(self.__scalar_init)
+
_input = tuple(dsin.data[i].get().handle.copy()
- for i in xrange(dsin.nb_components))
+ for i in xrange(dsin.nb_components))
S0 = dsin.integrate()
for k in xrange(napplies+1):
- if (k>0):
+ if (k > 0):
graph.apply()
output = tuple(dsout.data[i].get().handle.copy()[dsout.compute_slices]
- for i in xrange(dsout.nb_components))
+ for i in xrange(dsout.nb_components))
for i in xrange(dsout.nb_components):
mask = npw.isfinite(output[i][dsout.compute_slices])
if not mask.all():
- msg='\nFATAL ERROR: Output is not finite on axis {}.\n'.format(i)
+ msg = '\nFATAL ERROR: Output is not finite on axis {}.\n'.format(
+ i)
print msg
- npw.fancy_print(output[i], replace_values={(lambda a: npw.isfinite(a)): '.'})
+ npw.fancy_print(output[i], replace_values={
+ (lambda a: npw.isfinite(a)): '.'})
raise RuntimeError(msg)
if is_ref:
- dxk = -Vi*(k+0)*dt()
+ dxk = -Vi*(k)*dt()
dsref.initialize(self.__scalar_init, offsets=dxk.tolist())
d = dsout.distance(dsref, p=2)
if npw.any(d > 1e-1):
@@ -212,9 +211,11 @@ class TestScalesAdvectionOperator(object):
print 'DSREF'
print dsref.sdata[dsref.compute_slices]
print 'DSREF - DSOUT'
- print (dsout.sdata[dsout.compute_slices].get() - dsref.sdata[dsref.compute_slices].get())
- msg='Test failed with V={}, k={}, dxk={}, inter-field L2 distances are {}.'
- msg=msg.format(Vi, k, to_tuple(dxk, cast=float), to_tuple(d, cast=float))
+ print (dsout.sdata[dsout.compute_slices].get(
+ ) - dsref.sdata[dsref.compute_slices].get())
+ msg = 'Test failed with V={}, k={}, dxk={}, inter-field L2 distances are {}.'
+ msg = msg.format(Vi, k, to_tuple(
+ dxk, cast=float), to_tuple(d, cast=float))
raise RuntimeError(msg)
ref_outputs[k] = output
else:
@@ -225,10 +226,11 @@ class TestScalesAdvectionOperator(object):
max_di = npw.max(di)
neps = 10000
max_tol = neps*npw.finfo(dsout.dtype).eps
- if (max_di>max_tol):
+ if (max_di > max_tol):
print 'FATAL ERROR: Could not match other implementation results.'
- print '\nComparisson failed at step {} and component {}:'.format(k,i)
- for (j,dv) in dvin.iter_fields():
+ print '\nComparisson failed at step {} and component {}:'.format(
+ k, i)
+ for (j, dv) in dvin.iter_fields():
print 'VELOCITY INPUT {}'.format(DirectionLabels[j])
print dv.sdata[dv.compute_slices]
print 'SCALAR INPUT'
@@ -238,22 +240,24 @@ class TestScalesAdvectionOperator(object):
print 'SCALAR OUTPUT'
print output[i]
print 'ABS(REF - OUT)'
- npw.fancy_print(di, replace_values={(lambda a: a<max_tol): '.'})
+ npw.fancy_print(di, replace_values={
+ (lambda a: a < max_tol): '.'})
print
- msg='Output did not match reference output for component {} at time step {}.'
- msg+='\n > max computed distance was {}.'.format(max_di)
- msg+='\n > max tolerence was set to {} ({} eps).'.format(max_tol, neps)
- msg=msg.format(i, k)
+ msg = 'Output did not match reference output for component {} at time step {}.'
+ msg += '\n > max computed distance was {}.'.format(max_di)
+ msg += '\n > max tolerence was set to {} ({} eps).'.format(
+ max_tol, neps)
+ msg = msg.format(i, k)
raise RuntimeError(msg)
Si = dsout.integrate()
if not npw.all(npw.isfinite(Si)):
- msg='Integral is not finite. Got {}.'.format(Si)
+ msg = 'Integral is not finite. Got {}.'.format(Si)
raise RuntimeError(msg)
- if (npw.abs(Si-S0)>1e-3).any():
- msg='Scalar was not conserved on iteration {}, expected {} but got {}.'
- msg=msg.format(k,
- to_tuple(S0, cast=float),
- to_tuple(Si, cast=float))
+ if (npw.abs(Si-S0) > 1e-3).any():
+ msg = 'Scalar was not conserved on iteration {}, expected {} but got {}.'
+ msg = msg.format(k,
+ to_tuple(S0, cast=float),
+ to_tuple(Si, cast=float))
raise RuntimeError(msg)
except:
sys.stdout.write('\bx\n\n')
@@ -272,7 +276,7 @@ class TestScalesAdvectionOperator(object):
if __name__ == '__main__':
import hysop
TestScalesAdvectionOperator.setup_class(enable_extra_tests=False,
- enable_debug_mode=False)
+ enable_debug_mode=False)
test = TestScalesAdvectionOperator()
diff --git a/hysop/operator/tests/test_solenoidal_projection.py b/hysop/operator/tests/test_solenoidal_projection.py
index 234a1e8459a7459b8b8fa9b201627ab092d3930c..e9eed17478d3f24080c09ce27a7b11b3b6a5e499 100644
--- a/hysop/operator/tests/test_solenoidal_projection.py
+++ b/hysop/operator/tests/test_solenoidal_projection.py
@@ -149,28 +149,24 @@ class TestSolenoidalProjectionOperator(object):
print '>> TESTED ALL {}D BOUNDARY CONDITIONS <<'.format(dim)
print
print
-
- @classmethod
- def __analytic_init(cls, data, coords, dtype, fns):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- d[...] = npw.asarray(fn(*coord)).astype(dtype)
-
- @classmethod
- def __zero_init(cls, data, coords, dtype):
- for d in data:
- d[...] = 0
-
+
@staticmethod
- def __random_init(data, coords, dtype):
- shape = data[0].shape
+ def __random_init(data, coords, component, dtype):
if is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
+ @staticmethod
+ def __analytic_init(data, coords, fns, component, dtype):
+ fn = fns[component]
+ data[...] = npw.asarray(fn(*coords)).astype(dtype)
+
+ @classmethod
+ def __zero_init(cls, data, coords, dtype, component):
+ data[...] = 0
+
def _test_one(self, shape, dtype, polynomial,
domain, U, U0, U1, divU, divU0, divU1):
diff --git a/hysop/operator/tests/test_spectral_curl.py b/hysop/operator/tests/test_spectral_curl.py
index 3407397bd8ab9496da1f1fe72c32c75055b776dc..577b997340689a40b4209af5d917a585f7ac05be 100644
--- a/hysop/operator/tests/test_spectral_curl.py
+++ b/hysop/operator/tests/test_spectral_curl.py
@@ -1,4 +1,5 @@
-import random, primefac
+import random
+import primefac
from hysop.deps import it, sm, random
from hysop.constants import HYSOP_REAL, BoxBoundaryCondition
from hysop.defaults import VelocityField, VorticityField
@@ -11,18 +12,19 @@ from hysop.tools.io_utils import IO
from hysop.tools.numpywrappers import npw
from hysop.tools.sympy_utils import truncate_expr, round_expr
from hysop.tools.spectral_utils import make_multivariate_trigonometric_polynomial, \
- make_multivariate_polynomial
+ make_multivariate_polynomial
from hysop.operator.curl import SpectralCurl, Implementation
from hysop.defaults import VorticityField, VelocityField
from hysop import Field, Box
+
class TestSpectralCurl(object):
@classmethod
def setup_class(cls,
- enable_extra_tests=__ENABLE_LONG_TESTS__,
- enable_debug_mode=False):
+ enable_extra_tests=__ENABLE_LONG_TESTS__,
+ enable_debug_mode=False):
IO.set_default_path('/tmp/hysop_tests/test_spectral_curl')
@@ -30,89 +32,82 @@ class TestSpectralCurl(object):
cls.size_max = 16
cls.enable_extra_tests = enable_extra_tests
- cls.enable_debug_mode = enable_debug_mode
-
+ cls.enable_debug_mode = enable_debug_mode
+
from hysop.tools.sympy_utils import enable_pretty_printing
enable_pretty_printing()
-
+
@classmethod
def teardown_class(cls):
pass
-
@classmethod
- def build_analytic_solutions(cls, polynomial,
- dim, nb_components,
- lboundaries, rboundaries,
- origin, end):
- from hysop.symbolic.base import TensorBase
+ def build_analytic_solutions(cls, polynomial,
+ dim, nb_components,
+ lboundaries, rboundaries,
+ origin, end):
+ from hysop.symbolic.base import TensorBase
from hysop.symbolic.frame import SymbolicFrame
from hysop.symbolic.field import laplacian, curl
- assert len(lboundaries)==nb_components
- assert len(rboundaries)==nb_components
-
- frame = SymbolicFrame(dim=dim)
+ assert len(lboundaries) == nb_components
+ assert len(rboundaries) == nb_components
+
+ frame = SymbolicFrame(dim=dim)
coords = frame.coords
-
+
def gen_Fin():
Fins = ()
for i in xrange(nb_components):
if polynomial:
fin, y = make_multivariate_polynomial(origin, end,
- lboundaries[i], rboundaries[i],
- 10, 4)
+ lboundaries[i], rboundaries[i],
+ 10, 4)
else:
fin, y = make_multivariate_trigonometric_polynomial(origin, end,
- lboundaries[i], rboundaries[i], 2)
- fin = fin.xreplace({yi: xi for (yi,xi) in zip(y, coords)})
+ lboundaries[i], rboundaries[i], 2)
+ fin = fin.xreplace({yi: xi for (yi, xi) in zip(y, coords)})
Fins += (fin,)
return npw.asarray(Fins).view(TensorBase)
-
- Fins = gen_Fin()
+
+ Fins = gen_Fin()
Fouts = npw.atleast_1d(curl(Fins, frame))
- fFins = tuple(sm.lambdify(coords, Fin) for Fin in Fins)
+ fFins = tuple(sm.lambdify(coords, Fin) for Fin in Fins)
fFouts = tuple(sm.lambdify(coords, Fout) for Fout in Fouts)
- analytic_expressions = {'Fin':Fins, 'Fout':Fouts}
- analytic_functions = {'Fin':fFins, 'Fout':fFouts}
+ analytic_expressions = {'Fin': Fins, 'Fout': Fouts}
+ analytic_functions = {'Fin': fFins, 'Fout': fFouts}
return (analytic_expressions, analytic_functions)
-
@staticmethod
- def __random_init(data, coords, dtype):
- for d in data:
- if is_fp(d.dtype):
- d[...] = npw.random.random(size=d.shape).astype(dtype=d.dtype)
- else:
- msg = 'Unknown dtype {}.'.format(d.dtype)
- raise NotImplementedError(msg)
-
- @staticmethod
- def __analytic_init(data, coords, dtype, fns):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- coord = tuple(c.astype(d.dtype) for c in coord)
- d[...] = fn(*coord).astype(d.dtype)
-
+ def __random_init(data, coords, component, dtype):
+ if is_fp(dtype):
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
+ else:
+ msg = 'Unknown dtype {}.'.format(dtype)
+ raise NotImplementedError(msg)
+ @staticmethod
+ def __analytic_init(data, coords, fns, component, dtype):
+ fn = fns[component]
+ data[...] = npw.asarray(fn(*coords)).astype(dtype)
def _test(self, dim, dtype, nb_components, max_runs=5,
- polynomial=False, size_min=None, size_max=None):
+ polynomial=False, size_min=None, size_max=None):
enable_extra_tests = self.enable_extra_tests
size_min = first_not_None(size_min, self.size_min)
size_max = first_not_None(size_max, self.size_max)
- valid_factors = {2,3,5,7,11,13}
+ valid_factors = {2, 3, 5, 7, 11, 13}
factors = {1}
while (factors-valid_factors):
factors.clear()
shape = tuple(npw.random.randint(low=size_min, high=size_max+1, size=dim).tolist())
for Si in shape:
- factors.update( set(primefac.primefac(int(Si))) )
-
+ factors.update(set(primefac.primefac(int(Si))))
+
domain_boundaries = list(domain_boundary_iterator(dim=dim))
periodic = domain_boundaries[0]
domain_boundaries = domain_boundaries[1:]
@@ -120,51 +115,53 @@ class TestSpectralCurl(object):
domain_boundaries.insert(0, periodic)
for i, (lboundaries, rboundaries) in enumerate(domain_boundaries, 1):
-
+
domain = Box(origin=(npw.random.rand(dim)-0.5),
length=(0.5+npw.random.rand(dim)*2*npw.pi),
- lboundaries=lboundaries,
- rboundaries=rboundaries)
-
- if (dim==nb_components):
- Fin = VelocityField(name='Fin', domain=domain)
+ lboundaries=lboundaries,
+ rboundaries=rboundaries)
+
+ if (dim == nb_components):
+ Fin = VelocityField(name='Fin', domain=domain)
Fout = VorticityField(name='Fout', velocity=Fin)
else:
- Fin = Field(name='Fin', domain=domain, dtype=dtype, nb_components=nb_components)
+ Fin = Field(name='Fin', domain=domain, dtype=dtype, nb_components=nb_components)
Fout = Fin.curl(name='Fout')
- self._test_one(shape=shape, dim=dim, dtype=dtype,
- domain=domain, Fin=Fin, Fout=Fout, polynomial=polynomial)
- if (max_runs is not None) and (i==max_runs):
+ self._test_one(shape=shape, dim=dim, dtype=dtype,
+ domain=domain, Fin=Fin, Fout=Fout, polynomial=polynomial)
+ if (max_runs is not None) and (i == max_runs):
missing = ((4**(dim+1) - 1) / 3) - i
print
- print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(dim, missing)
+ print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(
+ dim, missing)
print
print
break
else:
- assert (i==(4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
+ assert (i == (4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
print
print '>> TESTED ALL {}D BOUNDARY CONDITIONS <<'.format(dim)
print
print
def _test_one(self, shape, dim, dtype,
- domain, Fout, Fin, polynomial):
-
+ domain, Fout, Fin, polynomial):
+
(analytic_expressions, analytic_functions) = \
self.build_analytic_solutions(
- dim=dim, nb_components=Fin.nb_components, polynomial=polynomial,
- lboundaries=[fin.lboundaries[::-1] for fin in Fin.fields], # => boundaries in variable order x0,...,xn
+ dim=dim, nb_components=Fin.nb_components, polynomial=polynomial,
+ lboundaries=[fin.lboundaries[::-1]
+ for fin in Fin.fields], # => boundaries in variable order x0,...,xn
rboundaries=[fin.rboundaries[::-1] for fin in Fin.fields],
origin=domain.origin[::-1],
end=domain.end[::-1])
-
+
def format_expr(e):
return truncate_expr(round_expr(e, 3), 80)
- msg='\nTesting {}D Curl: dtype={} shape={} polynomial={}, bc=[{}]'.format(
- dim, dtype.__name__, shape, polynomial, domain.format_boundaries())
+ msg = '\nTesting {}D Curl: dtype={} shape={} polynomial={}, bc=[{}]'.format(
+ dim, dtype.__name__, shape, polynomial, domain.format_boundaries())
print msg
print ' >Input analytic field is (truncated):'
for (fin, fins) in zip(Fin.fields, analytic_expressions['Fin']):
@@ -175,55 +172,55 @@ class TestSpectralCurl(object):
print ' >Testing all implementations:'
implementations = SpectralCurl.implementations().keys()
- variables = { Fout:shape, Fin:shape }
+ variables = {Fout: shape, Fin: shape}
def iter_impl(impl):
base_kwds = dict(Fin=Fin, Fout=Fout, variables=variables,
implementation=impl,
name='curl_{}'.format(str(impl).lower()))
if impl is Implementation.PYTHON:
- msg=' *Python FFTW: '
+ msg = ' *Python FFTW: '
print msg,
yield SpectralCurl(**base_kwds)
elif impl is Implementation.OPENCL:
- msg=' *OpenCl CLFFT: '
+ msg = ' *OpenCl CLFFT: '
print msg
for cl_env in iter_clenv():
- msg=' |platform {}, device {}'.format(cl_env.platform.name.strip(),
- cl_env.device.name.strip())
+ msg = ' |platform {}, device {}'.format(cl_env.platform.name.strip(),
+ cl_env.device.name.strip())
print msg,
yield SpectralCurl(cl_env=cl_env, **base_kwds)
else:
- msg='Unknown implementation to test {}.'.format(impl)
+ msg = 'Unknown implementation to test {}.'.format(impl)
raise NotImplementedError(msg)
# Compare to analytic solution
Fout_ref = None
Fin_ref = None
for impl in implementations:
- for (i,op) in enumerate(iter_impl(impl)):
+ for (i, op) in enumerate(iter_impl(impl)):
from hysop.tools.debug_dumper import DebugDumper
- name='{}_{}'.format(impl, i)
+ name = '{}_{}'.format(impl, i)
op = op.build()
-
+
dFin = op.get_input_discrete_field(Fin).as_contiguous_dfield()
dFout = op.get_output_discrete_field(Fout).as_contiguous_dfield()
-
+
dFin.initialize(self.__analytic_init, dtype=dtype,
- fns=analytic_functions['Fin'])
+ fns=analytic_functions['Fin'])
if (Fout_ref is None):
dFout.initialize(self.__analytic_init, dtype=dtype,
- fns=analytic_functions['Fout'])
- Fin_ref = tuple( data.get().handle.copy() for data in dFin.data )
- Fout_ref = tuple( data.get().handle.copy() for data in dFout.data )
+ fns=analytic_functions['Fout'])
+ Fin_ref = tuple(data.get().handle.copy() for data in dFin.data)
+ Fout_ref = tuple(data.get().handle.copy() for data in dFout.data)
dFout.initialize(self.__random_init, dtype=dtype)
op.apply(simulation=None)
- Wout = tuple( data.get().handle.copy() for data in dFin.data )
- Uout = tuple( data.get().handle.copy() for data in dFout.data )
+ Wout = tuple(data.get().handle.copy() for data in dFin.data)
+ Uout = tuple(data.get().handle.copy() for data in dFout.data)
self._check_output(impl, op, Fin_ref, Fout_ref, Wout, Uout)
print
@@ -235,9 +232,9 @@ class TestSpectralCurl(object):
check_instance(Uout, tuple, values=npw.ndarray, size=len(Fout_ref))
msg0 = 'Reference field {} is not finite.'
- for (fields, name) in zip((Fin_ref, Fout_ref),('Fin_ref', 'Fout_ref')):
- for (i,field) in enumerate(fields):
- iname = '{}{}'.format(name,i)
+ for (fields, name) in zip((Fin_ref, Fout_ref), ('Fin_ref', 'Fout_ref')):
+ for (i, field) in enumerate(fields):
+ iname = '{}{}'.format(name, i)
mask = npw.isfinite(field)
if not mask.all():
print
@@ -249,8 +246,8 @@ class TestSpectralCurl(object):
raise ValueError(msg)
for (out_buffers, ref_buffers, name) in zip((Wout, Uout), (Fin_ref, Fout_ref), ('Fin', 'Fout')):
- for i, (fout,fref) in enumerate(zip(out_buffers, ref_buffers)):
- iname = '{}{}'.format(name,i)
+ for i, (fout, fref) in enumerate(zip(out_buffers, ref_buffers)):
+ iname = '{}{}'.format(name, i)
assert fout.dtype == fref.dtype, iname
assert fout.shape == fref.shape, iname
assert not npw.any(npw.isnan(fref))
@@ -263,14 +260,14 @@ class TestSpectralCurl(object):
elif has_inf:
deps = 'inf'
else:
- eps = npw.finfo(fout.dtype).eps
+ eps = npw.finfo(fout.dtype).eps
dist = npw.abs(fout-fref)
dinf = npw.max(dist)
try:
deps = int(npw.ceil(dinf/eps))
except:
deps = 'inf'
- if (deps < 10000) or True:
+ if (deps < 10000):
print '{}eps, '.format(deps),
continue
@@ -283,26 +280,26 @@ class TestSpectralCurl(object):
print
if cls.enable_debug_mode:
print 'REFERENCE INPUTS:'
- for (i,w) in enumerate(Fin_ref):
+ for (i, w) in enumerate(Fin_ref):
print 'Fin{}'.format(i)
print w
print
if (name == 'Fout'):
print 'REFERENCE OUTPUT:'
- for (i,u) in enumerate(Fout_ref):
+ for (i, u) in enumerate(Fout_ref):
print 'Fout{}'.format(i)
print u
print
print
print 'OPERATOR {} OUTPUT:'.format(op.name.upper())
print
- for (i,u) in enumerate(Uout):
+ for (i, u) in enumerate(Uout):
print 'Fout{}'.format(i)
print u
print
else:
print 'MODIFIED INPUTS:'
- for (i,w) in enumerate(Wout):
+ for (i, w) in enumerate(Wout):
print 'Fin{}'.format(i)
print w
print
@@ -312,34 +309,44 @@ class TestSpectralCurl(object):
msg = msg.format(name, i, impl)
raise RuntimeError(msg)
-
def test_2d_float32__1(self, **kwds):
- self._test(dim=2, dtype=npw.float32, nb_components=1, **kwds)
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=2, dtype=npw.float32, nb_components=1, **kwds)
+
def test_2d_float32__2(self, **kwds):
- self._test(dim=2, dtype=npw.float32, nb_components=2, **kwds)
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=2, dtype=npw.float32, nb_components=2, **kwds)
+
def test_3d_float32(self, **kwds):
- self._test(dim=3, dtype=npw.float32, nb_components=3, **kwds)
-
+ if HYSOP_REAL == npw.float32:
+ self._test(dim=3, dtype=npw.float32, nb_components=3, **kwds)
+
def test_2d_float64__1(self, **kwds):
- self._test(dim=2, dtype=npw.float64, nb_components=1, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=2, dtype=npw.float64, nb_components=1, **kwds)
+
def test_2d_float64__2(self, **kwds):
- self._test(dim=2, dtype=npw.float64, nb_components=2, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=2, dtype=npw.float64, nb_components=2, **kwds)
+
def test_3d_float64(self, **kwds):
- self._test(dim=3, dtype=npw.float64, nb_components=3, **kwds)
+ if HYSOP_REAL == npw.float64:
+ self._test(dim=3, dtype=npw.float64, nb_components=3, **kwds)
def perform_tests(self):
max_2d_runs = None if __ENABLE_LONG_TESTS__ else 2
max_3d_runs = None if __ENABLE_LONG_TESTS__ else 2
- if __ENABLE_LONG_TESTS__ or (HYSOP_REAL==npw.float32):
+ if __ENABLE_LONG_TESTS__ or (HYSOP_REAL == npw.float32):
self.test_2d_float32__1(max_runs=max_2d_runs)
self.test_2d_float32__2(max_runs=max_2d_runs)
self.test_3d_float32(max_runs=max_3d_runs)
- if __ENABLE_LONG_TESTS__ or (HYSOP_REAL==npw.float64):
+ if __ENABLE_LONG_TESTS__ or (HYSOP_REAL == npw.float64):
self.test_2d_float64__1(max_runs=max_2d_runs)
self.test_2d_float64__2(max_runs=max_2d_runs)
self.test_3d_float64(max_runs=max_3d_runs)
+
if __name__ == '__main__':
TestSpectralCurl.setup_class(enable_extra_tests=False,
enable_debug_mode=False)
diff --git a/hysop/operator/tests/test_spectral_derivative.py b/hysop/operator/tests/test_spectral_derivative.py
index 6a5b2b96e2c788e6704f4310a9c1dbee8127811b..c4b5ff01531db8199579f685634d7b140cf4652b 100644
--- a/hysop/operator/tests/test_spectral_derivative.py
+++ b/hysop/operator/tests/test_spectral_derivative.py
@@ -13,7 +13,7 @@ from hysop.tools.io_utils import IO
from hysop.tools.numpywrappers import npw
from hysop.tools.sympy_utils import truncate_expr, round_expr
from hysop.tools.spectral_utils import make_multivariate_trigonometric_polynomial, \
- make_multivariate_polynomial
+ make_multivariate_polynomial
from hysop.parameters.scalar_parameter import ScalarParameter
from hysop.operator.derivative import Implementation, SpectralSpaceDerivative
from hysop.operator.gradient import Gradient
@@ -21,12 +21,13 @@ from hysop.operator.misc import ForceTopologyState
from hysop import Field, Box
+
class TestSpectralDerivative(object):
@classmethod
def setup_class(cls,
- enable_extra_tests=__ENABLE_LONG_TESTS__,
- enable_debug_mode=False):
+ enable_extra_tests=__ENABLE_LONG_TESTS__,
+ enable_debug_mode=False):
IO.set_default_path('/tmp/hysop_tests/test_spectral_derivative')
@@ -34,13 +35,13 @@ class TestSpectralDerivative(object):
cls.size_max = 16
cls.enable_extra_tests = enable_extra_tests
- cls.enable_debug_mode = enable_debug_mode
+ cls.enable_debug_mode = enable_debug_mode
cls.t = ScalarParameter(name='t', dtype=HYSOP_REAL)
@classmethod
def build_analytic_expressions(cls, polynomial, dim, max_derivative,
- lboundaries, rboundaries, origin, end):
+ lboundaries, rboundaries, origin, end):
from hysop.tools.sympy_utils import enable_pretty_printing
from hysop.symbolic.base import TensorBase
from hysop.symbolic.frame import SymbolicFrame
@@ -58,57 +59,54 @@ class TestSpectralDerivative(object):
10, 4)
else:
f, y = make_multivariate_trigonometric_polynomial(origin, end,
- lboundaries, rboundaries, 2)
- f = f.xreplace({yi: xi for (yi,xi) in zip(y, frame.coords)})
- f *= sm.Integer(1) / (sm.Integer(1) + npw.random.randint(1,5)*cls.t.s)
+ lboundaries, rboundaries, 2)
+ f = f.xreplace({yi: xi for (yi, xi) in zip(y, frame.coords)})
+ f *= sm.Integer(1) / (sm.Integer(1) + npw.random.randint(1, 5)*cls.t.s)
return f
- F = gen_F()
+ F = gen_F()
fF = sm.lambdify(params, F)
- dFs = {}
+ dFs = {}
fdFs = {}
symbolic_dvars = {}
for idx in it.product(range(max_derivative+1), repeat=dim):
- if sum(idx)> max_derivative:
+ if sum(idx) > max_derivative:
continue
- xvars = tuple((ci,i) for (i,ci) in zip(idx, coords))
+ xvars = tuple((ci, i) for (i, ci) in zip(idx, coords))
symbolic_dvars[idx] = xvars
dF = F
- for (ci,i) in xvars:
- if (i==0):
+ for (ci, i) in xvars:
+ if (i == 0):
continue
- dF = dF.diff(ci,i)
- dFs[idx] = dF
+ dF = dF.diff(ci, i)
+ dFs[idx] = dF
fdFs[idx] = sm.lambdify(params, dF)
- analytic_expressions = {'F':F, 'dF':dFs}
- analytic_functions = {'F':fF, 'dF':fdFs}
+ analytic_expressions = {'F': F, 'dF': dFs}
+ analytic_functions = {'F': fF, 'dF': fdFs}
return (symbolic_dvars, analytic_expressions, analytic_functions)
-
@classmethod
def teardown_class(cls):
pass
@staticmethod
- def __random_init(data, coords):
- for d in data:
- if is_fp(d.dtype):
- d[...] = npw.random.random(size=d.shape).astype(dtype=d.dtype)
- else:
- msg = 'Unknown dtype {}.'.format(d.dtype)
- raise NotImplementedError(msg)
+ def __random_init(data, coords, component):
+ dtype = data.dtype
+ if is_fp(dtype):
+ data[...] = npw.random.random(size=data.shape).astype(dtype=dtype)
+ else:
+ msg = 'Unknown dtype {}.'.format(dtype)
+ raise NotImplementedError(msg)
@staticmethod
- def __analytic_init(data, coords, fns, t):
- assert len(fns) == len(data)
- for (d,fn,coord) in zip(data,fns,coords):
- coord = tuple(c.astype(d.dtype) for c in coord)
- d[...] = fn(*(coord+(t(),))).astype(d.dtype)
+ def __analytic_init(data, coords, fns, t, component):
+ fn = fns[component]
+ data[...] = npw.asarray(fn(*(coords+(t(),)))).astype(data.dtype)
def _test(self, dim, dtype, polynomial, max_derivative=2,
- size_min=None, size_max=None, max_runs=None):
+ size_min=None, size_max=None, max_runs=None):
enable_extra_tests = self.enable_extra_tests
size_min = first_not_None(size_min, self.size_min)
@@ -119,7 +117,8 @@ class TestSpectralDerivative(object):
domain_boundaries = list(domain_boundary_iterator(dim=dim))
periodic = domain_boundaries[0]
domain_boundaries = domain_boundaries[1:]
- random.shuffle(domain_boundaries)
+ if (max_runs is not None):
+ random.shuffle(domain_boundaries)
domain_boundaries.insert(0, periodic)
for i, (lboundaries, rboundaries) in enumerate(domain_boundaries, 1):
@@ -131,27 +130,27 @@ class TestSpectralDerivative(object):
F = Field(domain=domain, name='F', dtype=dtype)
self._test_one(shape=shape, dim=dim, dtype=dtype,
- domain=domain, F=F,
- polynomial=polynomial,
- max_derivative=max_derivative)
+ domain=domain, F=F,
+ polynomial=polynomial,
+ max_derivative=max_derivative)
- if (max_runs is not None) and (i==max_runs):
+ if (max_runs is not None) and (i == max_runs):
missing = ((4**(dim+1) - 1) / 3) - i
print
- print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(dim, missing)
+ print '>> MAX RUNS ACHIEVED FOR {}D DOMAINS -- SKIPING {} OTHER BOUNDARY CONDITIONS <<'.format(
+ dim, missing)
print
print
break
else:
- assert (i==(4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
+ assert (i == (4**(dim+1)-1)/3), (i+1, (4**(dim+1)-1)/3)
print
print '>> TESTED ALL {}D BOUNDARY CONDITIONS <<'.format(dim)
print
print
-
def _test_one(self, shape, dim, dtype,
- domain, F, polynomial, max_derivative):
+ domain, F, polynomial, max_derivative):
implementations = SpectralSpaceDerivative.implementations()
@@ -159,39 +158,39 @@ class TestSpectralDerivative(object):
self.build_analytic_expressions(
dim=dim, polynomial=polynomial,
max_derivative=max_derivative,
- lboundaries=F.lboundaries[::-1], # => boundaries in variable order x0,...,xn
+ lboundaries=F.lboundaries[::-1], # => boundaries in variable order x0,...,xn
rboundaries=F.rboundaries[::-1],
origin=domain.origin[::-1],
end=domain.end[::-1])
- Fs = analytic_expressions['F']
+ Fs = analytic_expressions['F']
fFs = analytic_functions['F']
def format_expr(e):
return truncate_expr(round_expr(e, 3), 80)
- msg='\nTesting {}D SpectralDerivative: dtype={} shape={}, polynomial={}, bc=[{}]'
- msg=msg.format(dim, dtype.__name__, shape, polynomial, F.domain.format_boundaries())
- msg+='\n >Corresponding field boundary conditions are [{}].'.format(F.format_boundaries())
- msg+='\n >Input analytic functions (truncated):'
- msg+='\n *{}(x,t) = {}'.format(F.pretty_name, format_expr(Fs))
- msg+='\n >Testing derivatives:'
+ msg = '\nTesting {}D SpectralDerivative: dtype={} shape={}, polynomial={}, bc=[{}]'
+ msg = msg.format(dim, dtype.__name__, shape, polynomial, F.domain.format_boundaries())
+ msg += '\n >Corresponding field boundary conditions are [{}].'.format(F.format_boundaries())
+ msg += '\n >Input analytic functions (truncated):'
+ msg += '\n *{}(x,t) = {}'.format(F.pretty_name, format_expr(Fs))
+ msg += '\n >Testing derivatives:'
print msg
for idx in sorted(symbolic_dvars.keys(), key=lambda x: sum(x)):
xvars = symbolic_dvars[idx]
dFe = F.s()
- for (ci,i) in xvars:
- if (i==0):
+ for (ci, i) in xvars:
+ if (i == 0):
continue
- dFe = dFe.diff(ci,i)
+ dFe = dFe.diff(ci, i)
dF = F.from_sympy_expression(expr=dFe,
- space_symbols=domain.frame.coords)
- dFs = analytic_expressions['dF'][idx]
- fdFs = analytic_functions['dF'][idx]
+ space_symbols=domain.frame.coords)
+ dFs = analytic_expressions['dF'][idx]
+ fdFs = analytic_functions['dF'][idx]
print ' *{}'.format(dF.pretty_name)
- variables = { F:shape, dF: shape }
+ variables = {F: shape, dF: shape}
def iter_impl(impl):
base_kwds = dict(F=F, dF=dF, derivative=idx,
@@ -199,25 +198,24 @@ class TestSpectralDerivative(object):
implementation=impl,
testing=True)
if impl is Implementation.PYTHON:
- msg=' |Python: '
+ msg = ' |Python: '
print msg,
op = SpectralSpaceDerivative(**base_kwds)
yield op.to_graph()
print
elif impl is Implementation.OPENCL:
- msg=' |Opencl: '
+ msg = ' |Opencl: '
print msg
for cl_env in iter_clenv():
- msg=' >platform {}, device {}:'.format(
- cl_env.platform.name.strip(),
- cl_env.device.name.strip())
+ msg = ' >platform {}, device {}:'.format(
+ cl_env.platform.name.strip(),
+ cl_env.device.name.strip())
print msg,
op = SpectralSpaceDerivative(cl_env=cl_env, **base_kwds)
yield op.to_graph()
print
- print
else:
- msg='Unknown implementation to test {}.'.format(impl)
+ msg = 'Unknown implementation to test {}.'.format(impl)
raise NotImplementedError(msg)
# Compare to analytic solution
@@ -225,23 +223,22 @@ class TestSpectralDerivative(object):
for impl in implementations:
for op in iter_impl(impl):
op.build(outputs_are_inputs=False)
- #op.display()
- Fd = op.get_input_discrete_field(F)
+ Fd = op.get_input_discrete_field(F)
dFd = op.get_output_discrete_field(dF)
if (Fref is None):
dFd.initialize(self.__analytic_init, fns=(fdFs,), t=self.t)
- dFref = tuple( data.get().handle.copy() for data in dFd.data )
+ dFref = tuple(data.get().handle.copy() for data in dFd.data)
Fd.initialize(self.__analytic_init, fns=(fFs,), t=self.t)
- Fref = tuple( data.get().handle.copy() for data in Fd.data )
+ Fref = tuple(data.get().handle.copy() for data in Fd.data)
dFd.initialize(self.__random_init)
op.apply()
- Fout = tuple( data.get().handle.copy() for data in Fd.data )
- dFout = tuple( data.get().handle.copy() for data in dFd.data )
+ Fout = tuple(data.get().handle.copy() for data in Fd.data)
+ dFout = tuple(data.get().handle.copy() for data in dFd.data)
self._check_output(impl, op, Fref, dFref, Fout, dFout, idx)
@@ -253,11 +250,11 @@ class TestSpectralDerivative(object):
check_instance(Fout, tuple, values=npw.ndarray, size=len(Fref))
check_instance(dFout, tuple, values=npw.ndarray, size=len(dFref))
- for j,(out_buffers, ref_buffers, name) in enumerate(zip((Fout, dFout),
- (Fref, dFref),
- ('F', 'dF'))):
- for i, (fout,fref) in enumerate(zip(out_buffers, ref_buffers)):
- iname = '{}{}'.format(name,i)
+ for j, (out_buffers, ref_buffers, name) in enumerate(zip((Fout, dFout),
+ (Fref, dFref),
+ ('F', 'dF'))):
+ for i, (fout, fref) in enumerate(zip(out_buffers, ref_buffers)):
+ iname = '{}{}'.format(name, i)
assert fout.dtype == fref.dtype, iname
assert fout.shape == fref.shape, iname
@@ -269,12 +266,16 @@ class TestSpectralDerivative(object):
if (has_nan or has_inf):
pass
else:
- eps = npw.finfo(fout.dtype).eps
+ eps = npw.finfo(fout.dtype).eps
dist = npw.abs(fout-fref)
dinf = npw.max(dist)
- deps = int(dinf/eps)
- if (deps <= 10**(nidx+2)):
- if (j==1):
+ try:
+ deps = int(dinf/eps)
+ except OverflowError:
+ import numpy as np
+ deps = np.inf
+ if (deps <= 5*10**(nidx+2)):
+ if (j == 1):
print '{}eps ({})'.format(deps, dinf),
else:
print '{}eps, '.format(deps),
@@ -290,65 +291,79 @@ class TestSpectralDerivative(object):
print
if cls.enable_debug_mode:
print 'REFERENCE INPUTS:'
- for (i,w) in enumerate(Fref):
+ for (i, w) in enumerate(Fref):
print 'F{}'.format(i)
print w
print
if (name == 'dF'):
print 'REFERENCE OUTPUT:'
- for (i,u) in enumerate(dFref):
+ for (i, u) in enumerate(dFref):
print 'dF{}'.format(i)
print u
print
print
print 'OPERATOR {} OUTPUT:'.format(op.name.upper())
print
- for (i,u) in enumerate(dFout):
+ for (i, u) in enumerate(dFout):
print 'dF{}'.format(i)
print u
print
else:
print 'MODIFIED INPUTS:'
- for (i,w) in enumerate(Fout):
+ for (i, w) in enumerate(Fout):
print 'F{}'.format(i)
print w
print
print
msg = 'Test failed for {} on component {} for implementation {}.'.format(name,
- i, impl)
+ i, impl)
raise RuntimeError(msg)
+ def test_1d_trigonometric_float32(self, **kwds):
+ kwds.update({'max_derivative': 3})
+ self._test(dim=1, dtype=npw.float32, polynomial=False, **kwds)
+ def test_2d_trigonometric_float32(self, **kwds):
+ kwds.update({'max_derivative': 1, 'max_runs': None})
+ self._test(dim=2, dtype=npw.float32, polynomial=False, **kwds)
- # def test_1d_trigonometric_float32(self, **kwds):
- # self._test(dim=1, dtype=npw.float32, polynomial=False, **kwds)
- # def test_2d_trigonometric_float32(self, **kwds):
- # self._test(dim=2, dtype=npw.float32, polynomial=False, **kwds)
def test_3d_trigonometric_float32(self, **kwds):
- self._test(dim=3, dtype=npw.float32, polynomial=False, **kwds)
+ kwds.update({'max_derivative': 1, 'max_runs': 5})
+ if __ENABLE_LONG_TESTS__:
+ self._test(dim=3, dtype=npw.float32, polynomial=False, **kwds)
+
+ def test_1d_trigonometric_float64(self, **kwds):
+ kwds.update({'max_derivative': 3})
+ self._test(dim=1, dtype=npw.float64, polynomial=False, **kwds)
+
+ def test_2d_trigonometric_float64(self, **kwds):
+ kwds.update({'max_derivative': 1, 'max_runs': None})
+ self._test(dim=2, dtype=npw.float64, polynomial=False, **kwds)
- # def test_1d_trigonometric_float64(self, **kwds):
- # self._test(dim=1, dtype=npw.float64, polynomial=False, **kwds)
- # def test_2d_trigonometric_float64(self, **kwds):
- # self._test(dim=2, dtype=npw.float64, polynomial=False, **kwds)
def test_3d_trigonometric_float64(self, **kwds):
- self._test(dim=3, dtype=npw.float64, polynomial=False, **kwds)
+ kwds.update({'max_derivative': 1, 'max_runs': 5})
+ if __ENABLE_LONG_TESTS__:
+ self._test(dim=3, dtype=npw.float64, polynomial=False, **kwds)
+
+ def test_1d_polynomial_float32(self, **kwds):
+ self._test(dim=1, dtype=npw.float32, polynomial=True, **kwds)
+
+ def test_2d_polynomial_float32(self, **kwds):
+ self._test(dim=2, dtype=npw.float32, polynomial=True, **kwds)
- # def test_1d_polynomial_float32(self, **kwds):
- # self._test(dim=1, dtype=npw.float32, polynomial=True, **kwds)
- # def test_2d_polynomial_float32(self, **kwds):
- # self._test(dim=2, dtype=npw.float32, polynomial=True, **kwds)
def test_3d_polynomial_float32(self, **kwds):
- self._test(dim=3, dtype=npw.float32, polynomial=True, **kwds)
+ kwds.update({'max_derivative': 1})
+ if __ENABLE_LONG_TESTS__:
+ self._test(dim=3, dtype=npw.float32, polynomial=True, **kwds)
def perform_tests(self):
- max_2d_runs = None if __ENABLE_LONG_TESTS__ else 2
- max_3d_runs = None if __ENABLE_LONG_TESTS__ else 2
-
- # self.test_1d_trigonometric_float32(max_derivative=3)
- # self.test_2d_trigonometric_float32(max_derivative=2, max_runs=max_2d_runs)
- self.test_3d_trigonometric_float32(max_derivative=1, max_runs=max_3d_runs)
+ self.test_1d_trigonometric_float32(max_derivative=3)
+ self.test_2d_trigonometric_float32(max_derivative=1, max_runs=None)
+ self.test_3d_trigonometric_float32(max_derivative=1, max_runs=5)
+ self.test_1d_trigonometric_float64(max_derivative=3)
+ self.test_2d_trigonometric_float64(max_derivative=1, max_runs=None)
+ self.test_3d_trigonometric_float64(max_derivative=1, max_runs=5)
if __ENABLE_LONG_TESTS__:
# self.test_1d_trigonometric_float64(max_derivative=3)
@@ -359,9 +374,10 @@ class TestSpectralDerivative(object):
# self.test_2d_polynomial_float32(max_derivative=2)
self.test_3d_polynomial_float32(max_derivative=1)
+
if __name__ == '__main__':
TestSpectralDerivative.setup_class(enable_extra_tests=False,
- enable_debug_mode=False)
+ enable_debug_mode=False)
test = TestSpectralDerivative()
diff --git a/hysop/operator/tests/test_transpose.py b/hysop/operator/tests/test_transpose.py
index 6ebe79df3d9fbc2c4bd47535218a6af2ef9473be..1fefbf291e425903263617573fc2922363b97353 100644
--- a/hysop/operator/tests/test_transpose.py
+++ b/hysop/operator/tests/test_transpose.py
@@ -1,4 +1,3 @@
-
import random
from hysop.deps import np, it
from hysop.testsenv import __ENABLE_LONG_TESTS__, __HAS_OPENCL_BACKEND__
@@ -11,32 +10,32 @@ from hysop.operator.transpose import Transpose, Implementation
from hysop import Field, Box
+
class TestTransposeOperator(object):
@classmethod
- def setup_class(cls,
- enable_extra_tests=__ENABLE_LONG_TESTS__,
- enable_debug_mode=False):
+ def setup_class(cls,
+ enable_extra_tests=__ENABLE_LONG_TESTS__,
+ enable_debug_mode=False):
IO.set_default_path('/tmp/hysop_tests/test_transpose')
-
+
if enable_debug_mode:
- cls.size_min = 2
- cls.size_max = 6
+ cls.size_min = 3
+ cls.size_max = 4
else:
- cls.size_min = 2
+ cls.size_min = 4
cls.size_max = 23
-
+
cls.enable_extra_tests = enable_extra_tests
- cls.enable_debug_mode = enable_debug_mode
+ cls.enable_debug_mode = enable_debug_mode
@classmethod
def teardown_class(cls):
pass
-
def _test(self, dim, dtype, is_inplace,
- size_min=None, size_max=None, naxes=None):
+ size_min=None, size_max=None, naxes=None):
enable_extra_tests = self.enable_extra_tests
assert dim > 1
@@ -46,7 +45,7 @@ class TestTransposeOperator(object):
assert (((size_max-size_min+1)**dim) >= nshapes)
shapes = ((size_min,)*dim,)
- while(len(shapes)<nshapes):
+ while(len(shapes) < nshapes):
shape = tuple(np.random.randint(low=size_min, high=size_max+1, size=dim).tolist())
if (shape in shapes) or all((si == shape[0]) for si in shape):
continue
@@ -57,128 +56,129 @@ class TestTransposeOperator(object):
all_axes = list(all_axes)
if (naxes is not None):
random.shuffle(all_axes)
- all_axes = all_axes[:min(naxes,len(all_axes))]
-
- if dtype is None:
- types = [#np.int8, np.int16, np.int32, np.int64,
- #np.uint8, np.uint16, np.uint32, np.uint64,
- #np.float32, np.float64,
+ all_axes = all_axes[:min(naxes, len(all_axes))]
+
+ if (dtype is None):
+ types = [np.float32, np.float64,
np.complex64, np.complex128]
- random.shuffle(types)
dtype = types[0]
-
+
domain = Box(length=(1.0,)*dim)
- for nb_components in (2,):
- Fin = Field(domain=domain, name='Fin', dtype=dtype,
- nb_components=nb_components, register_object=False)
- Fout = Field(domain=domain, name='Fout', dtype=dtype,
- nb_components=nb_components, register_object=False)
+ for nb_components in (2,):
+ Fin = Field(domain=domain, name='Fin', dtype=dtype,
+ nb_components=nb_components, register_object=False)
+ Fout = Field(domain=domain, name='Fout', dtype=dtype,
+ nb_components=nb_components, register_object=False)
for axes in all_axes:
for shape in shapes:
self._test_one(shape=shape, axes=axes,
- dim=dim, dtype=dtype, is_inplace=is_inplace,
- domain=domain, Fin=Fin, Fout=Fout)
+ dim=dim, dtype=dtype, is_inplace=is_inplace,
+ domain=domain, Fin=Fin, Fout=Fout)
@classmethod
- def __field_init(cls, data, coords, dtype):
- shape = data[0].shape
+ def __field_init(cls, data, coords, component, dtype):
+ shape = data.shape
if is_integer(dtype):
- for d in data:
- d[...] = np.random.random_integers(low=0, high=255, size=shape)
+ data[...] = np.random.random_integers(low=0, high=255, size=shape)
elif is_fp(dtype):
- for d in data:
- d[...] = np.random.random(size=shape)
+ data[...] = np.random.random(size=shape)
elif is_complex(dtype):
- for d in data:
- real = np.random.random(size=shape)
- imag = np.random.random(size=shape)
- d[...] = real + 1j*imag
+ real = np.random.random(size=shape)
+ imag = np.random.random(size=shape)
+ data[...] = real + 1j*imag
else:
- msg='Unknown dtype {}.'.format(dtype)
+ msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
def _test_one(self, shape, axes,
- dim, dtype, is_inplace,
- domain, Fin, Fout):
+ dim, dtype, is_inplace,
+ domain, Fin, Fout):
print '\nTesting {}D Transpose: inplace={} dtype={} shape={} axes={}'.format(
- dim, is_inplace, dtype.__name__, shape, axes)
+ dim, is_inplace, dtype.__name__, shape, axes)
if is_inplace:
fin, fout = Fin, Fin
- variables = { fin: shape }
+ variables = {fin: shape}
else:
fin, fout = Fin, Fout
- variables = { fin: shape, fout: shape }
+ variables = {fin: shape, fout: shape}
implementations = Transpose.implementations()
ref_impl = Implementation.PYTHON
assert ref_impl in implementations
-
+
# Compute reference solution
print ' *reference PYTHON implementation.'
transpose = Transpose(fields=fin, output_fields=fout,
variables=variables, axes=axes,
implementation=ref_impl).build()
- dfin = transpose.get_input_discrete_field(fin)
+ dfin = transpose.get_input_discrete_field(fin)
dfout = transpose.get_output_discrete_field(fout)
dfin.initialize(self.__field_init, dtype=dtype)
-
+
if is_inplace:
refin = tuple(df.copy() for df in dfin.buffers)
else:
refin = tuple(df for df in dfin.buffers)
transpose.apply()
-
+
refout = tuple(df.copy() for df in dfout.buffers)
- for in_,out_ in zip(refin, refout):
- assert np.all(out_ == np.transpose(in_, axes=axes))
-
+ for i, (in_, out_) in enumerate(zip(refin, refout)):
+ ref = np.transpose(in_, axes=axes)
+ if (ref != out_).any():
+ print
+ print np.transpose(in_, axes=axes)
+ print
+ print out_
+ msg = 'Reference did not match numpy for component {}.'.format(i)
+ raise RuntimeError(msg)
+
def iter_impl(impl):
base_kwds = dict(fields=fin, output_fields=fout, variables=variables,
- axes=axes, implementation=impl,
+ axes=axes, implementation=impl,
name='test_transpose_{}'.format(str(impl).lower()))
if impl is ref_impl:
- return
+ return
elif impl is Implementation.OPENCL:
for cl_env in iter_clenv():
- msg=' *platform {}, device {}'.format(cl_env.platform.name.strip(),
- cl_env.device.name.strip())
+ msg = ' *platform {}, device {}'.format(cl_env.platform.name.strip(),
+ cl_env.device.name.strip())
print msg
yield Transpose(cl_env=cl_env, **base_kwds)
else:
- msg='Unknown implementation to test {}.'.format(impl)
+ msg = 'Unknown implementation to test {}.'.format(impl)
raise NotImplementedError(msg)
-
+
# Compare to other implementations
for impl in implementations:
for op in iter_impl(impl):
op = op.build()
- dfin = op.get_input_discrete_field(fin)
+ dfin = op.get_input_discrete_field(fin)
dfout = op.get_output_discrete_field(fout)
dfin.copy(refin)
op.apply()
- out = tuple( data.get().handle for data in dfout.data )
+ out = tuple(data.get().handle for data in dfout.data)
self._check_output(impl, op, refin, refout, out)
-
+
@classmethod
def _check_output(cls, impl, op, refin_buffers, refout_buffers, out_buffers):
check_instance(out_buffers, tuple, values=np.ndarray)
check_instance(refout_buffers, tuple, values=np.ndarray)
check_instance(refin_buffers, tuple, values=np.ndarray)
- for i, (out,refin,refout) in enumerate(zip(out_buffers, refin_buffers, refout_buffers)):
+ for i, (out, refin, refout) in enumerate(zip(out_buffers, refin_buffers, refout_buffers)):
assert refout.dtype == out.dtype
assert refout.shape == out.shape
if np.all(out == refout):
continue
-
+
if cls.enable_debug_mode:
has_nan = np.any(np.isnan(out))
has_inf = np.any(np.isinf(out))
-
+
print
print 'Test output comparisson failed for component {}:'.format(i)
print ' *has_nan: {}'.format(has_nan)
@@ -194,50 +194,66 @@ class TestTransposeOperator(object):
print out
print
print
-
- msg = 'Test failed on component {} for implementation {}.'.format(i, impl)
- raise RuntimeError(msg)
+ msg = 'Test failed on component {} for implementation {}.'.format(i, impl)
+ raise RuntimeError(msg)
def test_2d_out_of_place(self):
- self._test(dim=2, dtype=None, is_inplace=False)
+ self._test(dim=2, is_inplace=False, dtype=np.float32)
+
def test_3d_out_of_place(self):
- self._test(dim=3, dtype=None, is_inplace=False)
+ self._test(dim=3, is_inplace=False, dtype=np.complex64)
+
def test_4d_out_of_place(self):
- self._test(dim=4, dtype=None, is_inplace=False)
+ if __ENABLE_LONG_TESTS__:
+ self._test(dim=4, is_inplace=False, dtype=np.float64)
+
def test_upper_dimensions_out_of_place(self):
- for i in xrange(5,9):
- self._test(dim=i, dtype=None, is_inplace=False,
- size_min=3, size_max=4, naxes=1)
-
+ if __ENABLE_LONG_TESTS__:
+ for i in xrange(5, 9):
+ self._test(dim=i, dtype=None, is_inplace=False,
+ size_min=3, size_max=4, naxes=1)
+
def test_2d_inplace(self):
- self._test(dim=2, dtype=None, is_inplace=True)
+ self._test(dim=2, is_inplace=True, dtype=np.float32)
+
def test_3d_inplace(self):
- self._test(dim=3, dtype=None, is_inplace=True)
+ self._test(dim=3, is_inplace=True, dtype=np.float32)
+
def test_4d_inplace(self):
- self._test(dim=4, dtype=None, is_inplace=True)
+ if __ENABLE_LONG_TESTS__:
+ self._test(dim=4, is_inplace=True, dtype=np.float32)
+
def test_upper_dimensions_inplace(self):
- for i in xrange(5,9):
- self._test(dim=i, dtype=None, is_inplace=True,
- size_min=3, size_max=4, naxes=1)
+ if __ENABLE_LONG_TESTS__:
+ for i in xrange(5, 9):
+ self._test(dim=i, dtype=None, is_inplace=True,
+ size_min=3, size_max=4, naxes=1)
def perform_tests(self):
- self.test_2d_out_of_place()
+ self._test(dim=2, is_inplace=False, dtype=np.float32)
+ self._test(dim=3, is_inplace=False, dtype=np.float64)
+ self._test(dim=3, is_inplace=False, dtype=np.complex64)
if __ENABLE_LONG_TESTS__:
- self.test_3d_out_of_place()
- self.test_4d_out_of_place()
- self.test_upper_dimensions_out_of_place()
-
- self.test_2d_inplace()
+ self._test(dim=4, is_inplace=False, dtype=np.float64)
+ for i in xrange(5, 9):
+ self._test(dim=i, dtype=None, is_inplace=False,
+ size_min=3, size_max=4, naxes=1)
+
+ self._test(dim=2, is_inplace=True, dtype=np.float32)
+ self._test(dim=3, is_inplace=True, dtype=np.float64)
+ self._test(dim=3, is_inplace=True, dtype=np.complex128)
if __ENABLE_LONG_TESTS__:
- self.test_3d_inplace()
- self.test_4d_inplace()
- self.test_upper_dimensions_inplace()
-
+ self._test(dim=4, is_inplace=True, dtype=np.float32)
+ for i in xrange(5, 9):
+ self._test(dim=i, dtype=None, is_inplace=True,
+ size_min=3, size_max=4, naxes=1)
+
+
if __name__ == '__main__':
- TestTransposeOperator.setup_class(enable_extra_tests=False,
+ TestTransposeOperator.setup_class(enable_extra_tests=False,
enable_debug_mode=False)
-
+
test = TestTransposeOperator()
test.perform_tests()
diff --git a/hysop/operator/tests/test_velocity_correction.py b/hysop/operator/tests/test_velocity_correction.py
old mode 100755
new mode 100644
index e463f745dd90ff63cba59dcdab95528ae33ce850..b1aec222c2c1d4d349769836a601a35a1c1b21bd
--- a/hysop/operator/tests/test_velocity_correction.py
+++ b/hysop/operator/tests/test_velocity_correction.py
@@ -15,7 +15,6 @@ from hysop.parameters.scalar_parameter import ScalarParameter, TensorParameter
from hysop.operator.flowrate_correction import FlowRateCorrection
from hysop.constants import Implementation
import numpy as np
-pi = np.pi
from hysop import Field, Box
@@ -49,29 +48,34 @@ class TestFlowRateCorrection(object):
pass
@staticmethod
- def __random_init(data, coords):
- dtype = data[0].dtype
+ def __random_init(data, coords, component):
+ dtype = data.dtype
if is_fp(dtype):
- for d in data:
- d[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
+ data[...] = npw.random.random(size=d.shape).astype(dtype=dtype)
else:
msg = 'Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
@staticmethod
- def __velo_init(data, coords):
+ def __velo_init(data, coords, component):
from numpy import sin, cos
- (x, y, z) = coords[0]
- data[0][...] = sin(x) * cos(y) * cos(z)
- data[1][...] = - cos(x) * sin(y) * cos(z)
- data[2][...] = 0.
+ (x, y, z) = coords
+ if component == 0:
+ data[...] = sin(x) * cos(y) * cos(z)
+ if component == 1:
+ data[...] = - cos(x) * sin(y) * cos(z)
+ if component == 2:
+ data[...] = 0.
@staticmethod
- def __vorti_init(data, coords):
+ def __vorti_init(data, coords, component):
from numpy import sin, cos
- (x, y, z) = coords[0]
- data[0][...] = - cos(x) * sin(y) * sin(z)
- data[1][...] = - sin(x) * cos(y) * sin(z)
- data[2][...] = 2. * sin(x) * sin(y) * cos(z)
+ (x, y, z) = coords
+ if component == 0:
+ data[...] = - cos(x) * sin(y) * sin(z)
+ if component == 1:
+ data[...] = - sin(x) * cos(y) * sin(z)
+ if component == 2:
+ data[...] = 2. * sin(x) * sin(y) * cos(z)
def _test(self, dim, dtype,
size_min=None, size_max=None):
@@ -84,7 +88,7 @@ class TestFlowRateCorrection(object):
high=size_max+1,
size=dim).tolist())
- domain = Box(length=(2*pi,)*dim)
+ domain = Box(length=(1,)*dim)
velo = Field(domain=domain, name='velo', dtype=dtype,
nb_components=3, register_object=False)
vorti = Field(domain=domain, name='vorti', dtype=dtype,
@@ -157,7 +161,7 @@ class TestFlowRateCorrection(object):
spaceStep = mesh.space_step
sl = [_ for _ in mesh.local_compute_slices]
sl[-1] = mesh.point_local_indices((0., 0., 0.))[-1]
- flowrate = np.asarray([np.sum(_[tuple(sl)]) for _ in Fout])
+ flowrate = np.asarray([np.sum(_[tuple(sl)]) for _ in Fout[::-1]])
flowrate *= np.prod(spaceStep[0:2])
dist = npw.abs(flowrate-self.flowrate())
dinf = npw.max(dist)
@@ -169,7 +173,7 @@ class TestFlowRateCorrection(object):
print
print 'Test output comparisson failed for flowrate:'
print ' *dinf={} ({} eps)'.format(dinf, deps)
- print ' *flowrate={} ({})'.format(flowrate, self.flowrate())
+ print ' *flowrate={} ({})'.format(flowrate, ref_flowrate)
print
msg = 'Test failed on flowrate for implementation {}.'.format(impl)
raise RuntimeError(msg)
diff --git a/hysop/operator/transpose.py b/hysop/operator/transpose.py
index 2ae2e42b02a65407e03cced31e4b708c000fa6db..48cb847b88ddcd357f95ba29b5faf9002cf83ec6 100644
--- a/hysop/operator/transpose.py
+++ b/hysop/operator/transpose.py
@@ -113,9 +113,6 @@ class Transpose(ComputationalGraphNodeGenerator):
Out of place transpose will always be faster to process.
The only exception to this rule may be 2D square matrices.
- Component-wise transpose is *not* yet supported in Fields and will
- raise directly in frontend.
-
Inplace transposition may request a temporary buffer because not all implementations
may support inplace transposition.
diff --git a/hysop/operator/vorticity_absorption.py b/hysop/operator/vorticity_absorption.py
old mode 100755
new mode 100644
diff --git a/hysop/operators.py b/hysop/operators.py
index ba5e73ac9ec96e027a8b63fc1196ea6226a507d1..4ab660d2dc823676c7b346516617c1dccfe39bae 100644
--- a/hysop/operators.py
+++ b/hysop/operators.py
@@ -5,47 +5,55 @@ Allows things like:
from hysop.operators import DirectionalAdvection
"""
-from hysop.operator.poisson import Poisson
+from hysop.operator.poisson import Poisson
from hysop.operator.poisson_curl import PoissonCurl
-from hysop.operator.diffusion import Diffusion # FFTW diffusion
-from hysop.operator.advection import Advection # Scales fortran advection
+from hysop.operator.diffusion import Diffusion # FFTW diffusion
+from hysop.operator.advection import Advection # Scales fortran advection
+from hysop.operator.penalization import PenalizeVorticity
+from hysop.operator.flowrate_correction import FlowRateCorrection
+from hysop.operator.vorticity_absorption import VorticityAbsorption
+from hysop.operator.transpose import Transpose
+from hysop.operator.misc import Noop, ForceTopologyState
-from hysop.operator.redistribute import Redistribute
-from hysop.operator.analytic import AnalyticField
-from hysop.operator.mean_field import ComputeMeanField
-from hysop.operator.enstrophy import Enstrophy
-from hysop.operator.kinetic_energy import KineticEnergy
-from hysop.operator.adapt_timestep import AdaptiveTimeStep
-from hysop.operator.hdf_io import HDF_Writer, HDF_Reader
-from hysop.operator.custom_symbolic import CustomSymbolicOperator
-from hysop.operator.parameter_plotter import ParameterPlotter
-from hysop.operator.integrate import Integrate
-from hysop.operator.penalization import PenalizeVorticity
-from hysop.operator.flowrate_correction import FlowRateCorrection
-from hysop.operator.vorticity_absorption import VorticityAbsorption
-from hysop.operator.dummy import Dummy
-from hysop.operator.custom import CustomOperator
-from hysop.operator.convergence import Convergence
-from hysop.operator.spatial_filtering import LowpassFilter
+from hysop.operator.redistribute import Redistribute
+from hysop.operator.analytic import AnalyticField
+from hysop.operator.mean_field import ComputeMeanField
+from hysop.operator.enstrophy import Enstrophy
+from hysop.operator.kinetic_energy import KineticEnergy
+from hysop.operator.adapt_timestep import AdaptiveTimeStep
+from hysop.operator.hdf_io import HDF_Writer, HDF_Reader
+from hysop.operator.custom_symbolic import CustomSymbolicOperator
+from hysop.operator.parameter_plotter import ParameterPlotter
+from hysop.operator.integrate import Integrate
+from hysop.operator.penalization import PenalizeVorticity
+from hysop.operator.flowrate_correction import FlowRateCorrection
+from hysop.operator.vorticity_absorption import VorticityAbsorption
+from hysop.operator.dummy import Dummy
+from hysop.operator.custom import CustomOperator
+from hysop.operator.convergence import Convergence
+from hysop.operator.spatial_filtering import SpatialFilter
from hysop.operator.derivative import SpaceDerivative, \
- SpectralSpaceDerivative, \
- FiniteDifferencesSpaceDerivative, \
- MultiSpaceDerivatives
+ SpectralSpaceDerivative, \
+ FiniteDifferencesSpaceDerivative, \
+ MultiSpaceDerivatives
from hysop.operator.min_max import MinMaxFieldStatistics, \
- MinMaxFiniteDifferencesDerivativeStatistics, \
- MinMaxSpectralDerivativeStatistics
+ MinMaxFiniteDifferencesDerivativeStatistics, \
+ MinMaxSpectralDerivativeStatistics
from hysop.operator.gradient import Gradient, MinMaxGradientStatistics
-from hysop.operator.curl import Curl, SpectralCurl
+from hysop.operator.curl import Curl, SpectralCurl
from hysop.operator.external_force import SpectralExternalForce
-from hysop.backend.device.opencl.operator.external_force import SymbolicExternalForce
+try:
+ from hysop.backend.device.opencl.operator.external_force import SymbolicExternalForce
+except ImportError:
+ SymbolicExternalForce = None
from hysop.numerics.splitting.strang import StrangSplitting
-from hysop.operator.directional.symbolic_dir import DirectionalSymbolic
-from hysop.operator.directional.advection_dir import DirectionalAdvection
-from hysop.operator.directional.diffusion_dir import DirectionalDiffusion
+from hysop.operator.directional.symbolic_dir import DirectionalSymbolic
+from hysop.operator.directional.advection_dir import DirectionalAdvection
+from hysop.operator.directional.diffusion_dir import DirectionalDiffusion
from hysop.operator.directional.stretching_dir import DirectionalStretching
-from hysop.operator.directional.stretching_dir import StaticDirectionalStretching # Python streching
+from hysop.operator.directional.stretching_dir import StaticDirectionalStretching
from hysop.operator.directional.stretching_diffusion_dir import DirectionalStretchingDiffusion
diff --git a/hysop/parameters/__init__.py b/hysop/parameters/__init__.py
index a8af4cd1a4042d1bc570fa39e8fe089d3ddc4936..77fa1da49b07ed37ff0fb23844eee9e13f663e0d 100644
--- a/hysop/parameters/__init__.py
+++ b/hysop/parameters/__init__.py
@@ -1,4 +1,5 @@
-from hysop.parameters.tensor_parameter import TensorParameter
+from hysop.parameters.tensor_parameter import TensorParameter
from hysop.parameters.scalar_parameter import ScalarParameter
-__all__ = ( ScalarParameter, TensorParameter )
+from hysop.parameters.buffer_parameter import BufferParameter
+__all__ = ( ScalarParameter, TensorParameter, BufferParameter)
diff --git a/hysop/parameters/buffer_parameter.py b/hysop/parameters/buffer_parameter.py
index 36543d93c5165494bf7b8352bc4e6997660f62a9..0a100f5b82e45af543546cdf66adc8a81113e1fd 100644
--- a/hysop/parameters/buffer_parameter.py
+++ b/hysop/parameters/buffer_parameter.py
@@ -89,6 +89,9 @@ BufferParameter[name={}]
def _get_shape(self):
"""Get parameter shape."""
return self._value.shape if (self._value is not None) else None
+ def _get_ndim(self):
+ """Get parameter ndim."""
+ return self._value.ndim if (self._value is not None) else None
def _get_size(self):
"""Get parameter size."""
return self._value.size if (self._value is not None) else 0
@@ -101,6 +104,7 @@ BufferParameter[name={}]
dtype = self.dtype
return dtype_to_ctype(dtype)
+ ndim = property(_get_ndim)
shape = property(_get_shape)
size = property(_get_size)
dtype = property(_get_dtype)
diff --git a/hysop/parameters/parameter.py b/hysop/parameters/parameter.py
index 8805d755f207deaca4eb6b90158a35a33d304b25..f09da60d8fd6dba4678cd57cf60cee96ed3925b0 100644
--- a/hysop/parameters/parameter.py
+++ b/hysop/parameters/parameter.py
@@ -4,11 +4,12 @@ Parameters description.
"""
from abc import ABCMeta, abstractmethod
-from hysop import dprint, vprint
+from hysop import dprint, vprint, __DEBUG__
from hysop.tools.types import check_instance, to_tuple, first_not_None
from hysop.tools.handle import TaggedObject
from hysop.tools.variable import Variable, VariableTag
+
class Parameter(TaggedObject, VariableTag):
"""
A parameter is a value of a given type that may change value as simulation advances.
@@ -16,11 +17,11 @@ class Parameter(TaggedObject, VariableTag):
"""
__metaclass__ = ABCMeta
- def __new__(cls, name, parameter_types,
- initial_value=None, allow_None=False,
- quiet=False, const=False,
- pretty_name=None, var_name=None,
- is_view=False, **kwds):
+ def __new__(cls, name, parameter_types,
+ initial_value=None, allow_None=False,
+ quiet=False, const=False,
+ pretty_name=None, var_name=None,
+ is_view=False, **kwds):
"""
Create or _get an existing Parameter with a specific name
and type.
@@ -53,9 +54,9 @@ class Parameter(TaggedObject, VariableTag):
Attributes
----------
- value:
- _get or set the current value of this Parameter object.
- Returned value is is a copy or a read-only reference to
+ value:
+ _get or set the current value of this Parameter object.
+ Returned value is is a copy or a read-only reference to
the current parameter value.
parameter_types:
Return allowed parameter types for this parameter.
@@ -71,9 +72,9 @@ class Parameter(TaggedObject, VariableTag):
parameter_types = to_tuple(parameter_types)
if const and (initial_value is None):
- msg='Constant parameter should be initialized.'
+ msg = 'Constant parameter should be initialized.'
raise ValueError(msg)
-
+
# register own class to authorized parameter types
parameter_types += (cls,)
@@ -82,9 +83,9 @@ class Parameter(TaggedObject, VariableTag):
parameter_types = tuple(set(parameter_types))
- obj = super(Parameter, cls).__new__(cls,
- tag_prefix='p', variable_kind=Variable.PARAMETER, **kwds)
-
+ obj = super(Parameter, cls).__new__(cls,
+ tag_prefix='p', variable_kind=Variable.PARAMETER, **kwds)
+
pretty_name = first_not_None(pretty_name, name)
if isinstance(pretty_name, unicode):
pretty_name = pretty_name.encode('utf-8')
@@ -100,53 +101,60 @@ class Parameter(TaggedObject, VariableTag):
obj._const = const
obj._symbol = None
obj._quiet = quiet
- obj._is_view = is_view
+ obj._is_view = is_view
return obj
def __eq__(self, other):
return (self is other)
+
def __ne__(self, other):
return (self is not other)
+
def __hash__(self):
return id(self)
def set_value(self, value):
"""Set the value of this Parameter object."""
if self._const:
- msg='Cannot modify the value of constant parameter {}.'.format(self.pretty_name)
+ msg = 'Cannot modify the value of constant parameter {}.'.format(self.pretty_name)
raise RuntimeError(msg)
if not isinstance(value, self._parameter_types):
- msg ='Parameter.set_value() got a value of type {} but '
- msg+='only the following types are valid for parameter {}:\n {}'
- msg=msg.format(type(value), self.pretty_name, self._parameter_types)
+ msg = 'Parameter.set_value() got a value of type {} but '
+ msg += 'only the following types are valid for parameter {}:\n {}'
+ msg = msg.format(type(value), self.pretty_name, self._parameter_types)
raise ValueError(msg)
if isinstance(value, self.__class__):
value = value._get_value()
self._set_value_impl(value)
- if not self.quiet:
- msg='>Parameter {} set to {}.'.format(self.pretty_name, self._value)
+ if not self.quiet or __DEBUG__:
+ msg = '>Parameter {} set to {}.'.format(
+ self.pretty_name, value)
vprint(msg)
def _get_value(self):
"""
- _get the current value of this Parameter object.
+ _get the current value of this Parameter object.
Returned value is not a reference to current parameter value.
"""
return self._get_value_impl()
-
+
def _get_name(self):
"""Return parameter name."""
return self._name
+
def _get_pretty_name(self):
"""Return parameter pretty name."""
return self._pretty_name
+
def _get_var_name(self):
"""Return parameter variable name."""
return self._pretty_name
+
def _get_const(self):
"""Return True if this parameter was set to be constant."""
return self._const
+
def _get_quiet(self):
"""Return True if this parameter was set to be quiet."""
return self._quiet
@@ -171,6 +179,7 @@ class Parameter(TaggedObject, VariableTag):
@abstractmethod
def _get_value_impl(self):
pass
+
@abstractmethod
def _set_value_impl(self):
pass
@@ -179,6 +188,7 @@ class Parameter(TaggedObject, VariableTag):
def short_description(self):
"""Return a short description of this parameter as a string."""
pass
+
@abstractmethod
def long_description(self):
"""Return a long description of this parameter as a string."""
@@ -201,5 +211,3 @@ class Parameter(TaggedObject, VariableTag):
quiet = property(_get_quiet)
s = property(_get_symbol)
is_view = property(_get_is_view)
-
-
diff --git a/hysop/parameters/tensor_parameter.py b/hysop/parameters/tensor_parameter.py
index 7bc6edfe58c63e5e01b525a373e098e18cb4f60d..9ac2c0767244c69d2368b85dad6b9f8c9c1e7451 100644
--- a/hysop/parameters/tensor_parameter.py
+++ b/hysop/parameters/tensor_parameter.py
@@ -124,8 +124,8 @@ class TensorParameter(Parameter):
if isinstance(initial_value, np.ndarray):
check_instance(initial_value, np.ndarray)
- assert initial_value.dtype == dtype
- assert initial_value.shape == shape
+ assert initial_value.dtype == dtype, (initial_value.dtype, dtype)
+ assert initial_value.shape == shape, (initial_value.shape, shape)
cls.__check_values(a=initial_value, dtype=dtype, min_value=min_value,
max_value=max_value, ignore_nans=ignore_nans)
elif np.isscalar(initial_value):
@@ -160,12 +160,21 @@ class TensorParameter(Parameter):
_pretty_name = self.pretty_name + subscripts(ids=idx, sep='').encode('utf-8')
name = first_not_None(name, _name)
pretty_name = first_not_None(pretty_name, _pretty_name)
- return TensorParameter(name=name, pretty_name=pretty_name,
- initial_value=initial_value, dtype=self.dtype, shape=initial_value.shape,
- min_value=self.min_value, max_value=self.max_value,
- ignore_nans=self.ignore_nans,
- const=self.const, quiet=self.quiet,
- is_view=True, **kwds)
+ if initial_value.size == 1:
+ from scalar_parameter import ScalarParameter
+ return ScalarParameter(name=name, pretty_name=pretty_name,
+ initial_value=initial_value.ravel(), dtype=self.dtype,
+ min_value=self.min_value, max_value=self.max_value,
+ ignore_nans=self.ignore_nans,
+ const=self.const, quiet=self.quiet,
+ is_view=True, **kwds)
+ else:
+ return TensorParameter(name=name, pretty_name=pretty_name,
+ initial_value=initial_value, dtype=self.dtype, shape=initial_value.shape,
+ min_value=self.min_value, max_value=self.max_value,
+ ignore_nans=self.ignore_nans,
+ const=self.const, quiet=self.quiet,
+ is_view=True, **kwds)
def iterviews(self):
"""Iterate over all parameters views to yield scalarparameters."""
@@ -231,6 +240,13 @@ class TensorParameter(Parameter):
view = self._value.view()
view.flags.writeable = False
return view.view()
+
+ def _get_tensor_value(self):
+ """
+ Get a read-only view on this array parameter but always as a numpy array,
+ even for ScalarParameter parameters.
+ """
+ return self._value.copy()
def _set_value_impl(self, value):
"""Given value will be copied into internal buffer."""
@@ -300,4 +316,5 @@ TensorParameter[name={}, pname={}]
min_value = property(_get_min_value)
max_value = property(_get_max_value)
ignore_nans = property(_get_ignore_nans)
+ tensor_value = property(_get_tensor_value)
diff --git a/hysop/problem.py b/hysop/problem.py
index a027ee8774f516132dc0c9c6131503ab6e70ea4f..e7031a3626988605984c3676b7d3bbdfb35263de 100644
--- a/hysop/problem.py
+++ b/hysop/problem.py
@@ -1,41 +1,55 @@
-import datetime, sys
+from __future__ import absolute_import
+import sys, datetime
+
from hysop.constants import Backend, MemoryOrdering
+from hysop.tools.types import check_instance, first_not_None, to_tuple, to_list
from hysop.tools.string_utils import vprint_banner
from hysop.tools.contexts import Timer
from hysop.tools.decorators import debug
+from hysop.tools.parameters import MPIParams
+from hysop.core.checkpoints import CheckpointHandler
from hysop.core.graph.computational_graph import ComputationalGraph
from hysop.tools.string_utils import vprint_banner, vprint
+
class Problem(ComputationalGraph):
- def __init__(self, name=None, method=None,
- check_unique_clenv=True, **kwds):
- super(Problem,self).__init__(name=name, method=method, **kwds)
+ def __init__(self, name=None, method=None, mpi_params=None,
+ check_unique_clenv=True, **kwds):
+ mpi_params = first_not_None(mpi_params, MPIParams()) # enforce mpi params for problems
+ super(Problem, self).__init__(name=name, method=method, mpi_params=mpi_params, **kwds)
self._do_check_unique_clenv = check_unique_clenv
@debug
def insert(self, *ops):
self.push_nodes(*ops)
+ return self
@debug
- def build(self, args=None, allow_subbuffers=False):
+ def build(self, args=None, allow_subbuffers=False, outputs_are_inputs=True):
with Timer() as tm:
- msg = self.build_problem(args=args, allow_subbuffers=allow_subbuffers)
+ msg = self.build_problem(args=args,
+ allow_subbuffers=allow_subbuffers,
+ outputs_are_inputs=outputs_are_inputs)
if msg:
- msg=' Problem {} achieved, exiting ! '.format(msg)
+ msg = ' Problem {} achieved, exiting ! '.format(msg)
vprint_banner(msg, at_border=2)
sys.exit(0)
- msg=' Problem building took {} ({}s) '
- msg=msg.format(datetime.timedelta(seconds=round(tm.interval)),
- tm.interval)
+ size = self.mpi_params.size
+ avg_time = self.mpi_params.comm.allreduce(tm.interval) / size
+ msg = ' Problem building took {} ({}s)'
+ if size > 1:
+ msg += ', averaged over {} ranks. '.format(size)
+ msg = msg.format(datetime.timedelta(seconds=round(avg_time)),
+ avg_time)
vprint_banner(msg, spacing=True, at_border=2)
if (args is not None) and args.stop_at_build:
- msg=' Problem has been built, exiting. '
+ msg = ' Problem has been built, exiting. '
vprint_banner(msg, at_border=2)
sys.exit(0)
- def build_problem(self, args, allow_subbuffers):
+ def build_problem(self, args, allow_subbuffers, outputs_are_inputs=True):
if (args is not None) and args.stop_at_initialization:
return 'initialization'
vprint('\nInitializing problem...')
@@ -43,7 +57,7 @@ class Problem(ComputationalGraph):
for node in [_ for _ in self.nodes if isinstance(_, Problem)]:
node.initialize(outputs_are_inputs=True, topgraph_method=None)
node.discretize()
- self.initialize(outputs_are_inputs=True, topgraph_method=None)
+ self.initialize(outputs_are_inputs=outputs_are_inputs, topgraph_method=None)
if (args is not None) and args.stop_at_discretization:
return 'discretization'
@@ -71,100 +85,89 @@ class Problem(ComputationalGraph):
self.check_unique_clenv()
def check_unique_clenv(self):
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
-
- cl_env, op = None, None
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
+ cl_env, first_op = None, None
+ for op in self.nodes:
for topo in set(op.input_fields.values() + op.output_fields.values()):
if (topo.backend.kind == Backend.OPENCL):
if (cl_env is None):
first_op = op
cl_env = topo.backend.cl_env
elif (topo.backend.cl_env is not cl_env):
- msg=''
- msg+='\nOpenCl environment mismatch between operator {} and operator {}.'
- msg=msg.format(first_op.name, op.name)
- msg+='\n{}'.format(cl_env)
- msg+='\n and'
- msg+='\n{}'.format(topo.backend.cl_env)
- msg+='\n If this is required, override check_unique_clenv().'
+ msg = ''
+ msg += '\nOpenCl environment mismatch between operator {} and operator {}.'
+ msg = msg.format(first_op.name, op.name)
+ msg += '\n{}'.format(cl_env)
+ msg += '\n and'
+ msg += '\n{}'.format(topo.backend.cl_env)
+ msg += '\n If this is required, override check_unique_clenv().'
raise RuntimeError(msg)
def initialize_field(self, field, **kwds):
"""Initialize a field on all its input and output topologies."""
- reduced_graph = self.reduced_graph
- operators = reduced_graph.vertex_properties['operators']
-
initialized = set()
- for vid in self.sorted_nodes:
- vertex = reduced_graph.vertex(vid)
- op = operators[vertex]
+ for op in self.nodes:
+ # give priority to tensor field initialization
for op_fields in (self.input_discrete_tensor_fields, self.output_discrete_tensor_fields,
op.input_discrete_tensor_fields, op.output_discrete_tensor_fields,
op.input_discrete_fields, op.output_discrete_fields):
- # give priority to tensor field initialization
if (field in op_fields):
dfield = op_fields[field]
if all((df in initialized) for df in dfield.discrete_fields()):
# all contained scalar fields were already initialized
continue
- elif dfield.has_unique_topology() and \
- all((df not in initialized) for df in dfield.discrete_fields()):
- # dfield has a unique topology and
- # none of its scalar fields has ever been initialized
- topo_view = dfield.topology
- topo = topo_view.topology
- wstate = topo_view.topology_state.copy(memory_order=MemoryOrdering.C_CONTIGUOUS,
- is_read_only=False) # get a writtable state
- dfield = field.discretize(topo, wstate)
- dfield.initialize(**kwds)
- initialized.update(dfield.discrete_fields())
else:
- # dfield has not unique topology
- # or some of its scalar fields were already initialized
- for (component, dfield_i) in dfield.nd_iter():
- if (dfield_i._dfield in initialized):
- continue
- topo_view = dfield_i.topology
- topo = topo_view.topology
- wstate = topo_view.topology_state.copy(memory_order=MemoryOrdering.C_CONTIGUOUS,
- is_read_only=False) # get a writtable state
- dfield_i = dfield_i.field.discretize(topo, wstate)
- dfield_i.initialize(component=component, **kwds)
- initialized.add(dfield_i._dfield)
+ components = ()
+ for (component, scalar_dfield) in dfield.nd_iter():
+ if (scalar_dfield._dfield not in initialized):
+ components += (component,)
+ dfield.initialize(components=components, **kwds)
+ initialized.update(dfield.discrete_fields())
if not initialized:
- msg='FATAL ERROR: Could not initialize field {}.'.format(field.name)
+ msg = 'FATAL ERROR: Could not initialize field {}.'.format(field.name)
raise RuntimeError(msg)
@debug
def solve(self, simu, dry_run=False, dbg=None,
- report_freq=10, plot_freq=10, **kargs):
+ report_freq=10, plot_freq=10,
+ checkpoint_handler=None, **kwds):
+
if dry_run:
vprint()
vprint_banner('** Dry-run requested, skipping simulation. **')
return
- vprint('\nSolving problem...')
+
simu.initialize()
+
+ check_instance(checkpoint_handler, CheckpointHandler, allow_none=True)
+ checkpoint_handler.create_checkpoint_template(self, simu)
+ checkpoint_handler.load_checkpoint(self, simu)
+
+ vprint('\nSolving problem...')
with Timer() as tm:
while not simu.is_over:
- vprint()
- simu.print_state()
- self.apply(simulation=simu, dbg=dbg, **kargs)
- simu.advance(dbg=dbg, plot_freq=plot_freq)
- if (simu.current_iteration % report_freq) == 0:
- self.profiler_report()
-
- msg=' Simulation took {} ({}s) '
- msg+='\n for {} iterations ({}s per iteration) '
- msg=msg.format(datetime.timedelta(seconds=round(tm.interval)),
- tm.interval, max(simu.current_iteration+1,1),
- tm.interval/max(simu.current_iteration+1,1))
+ vprint()
+ simu.print_state()
+ self.apply(simulation=simu, dbg=dbg, **kwds)
+ should_dump_checkpoint = checkpoint_handler.should_dump(simu) # determined before simu advance
+ simu.advance(dbg=dbg, plot_freq=plot_freq)
+ if should_dump_checkpoint:
+ checkpoint_handler.save_checkpoint(self, simu)
+ if report_freq and (simu.current_iteration % report_freq) == 0:
+ self.profiler_report()
+
+ size = self.mpi_params.size
+ avg_time = self.mpi_params.comm.allreduce(tm.interval) / size
+ msg = ' Simulation took {} ({}s)'
+ if size > 1:
+ msg += ', averaged over {} ranks. '.format(size)
+ msg += '\n for {} iterations ({}s per iteration) '
+ msg = msg.format(datetime.timedelta(seconds=round(avg_time)),
+ avg_time, max(simu.current_iteration+1, 1),
+ avg_time/max(simu.current_iteration+1, 1))
vprint_banner(msg, spacing=True, at_border=2)
simu.finalize()
+ checkpoint_handler.finalize(self.mpi_params)
self.final_report()
if (dbg is not None):
@@ -177,3 +180,4 @@ class Problem(ComputationalGraph):
def finalize(self):
vprint('Finalizing problem...')
super(Problem, self).finalize()
+
diff --git a/hysop/scales_f/scales2py.f90 b/hysop/scales_f/scales2py.f90
index ed419f0acbfd700d04147ea39bbf1b0242d76f9b..a59135b810c135a0d1d20d2276198f26cd6da3fc 100755
--- a/hysop/scales_f/scales2py.f90
+++ b/hysop/scales_f/scales2py.f90
@@ -19,12 +19,13 @@ contains
!! @param[in] mpi communicator from python
!! @param[out] datashape local dimension of the input/output field
!! @param[out] offset absolute index of the first component of the local field
- subroutine init_advection_solver(ncells,lengths,topodims,main_comm,datashape,offset,dim,order,dim_split)
+ subroutine init_advection_solver(ncells,lengths,topodims,main_comm,verbosity,datashape,offset,dim,order,dim_split)
integer, intent(in) :: dim
integer, dimension(dim),intent(in) :: ncells
real(wp),dimension(dim), intent(in) :: lengths
integer, dimension(dim), intent(in) :: topodims
integer, intent(in) :: main_comm
+ logical, intent(in) :: verbosity
integer(ip), dimension(dim), intent(out) :: datashape
integer(ip), dimension(dim), intent(out) :: offset
character(len=*), optional, intent(in) :: order, dim_split
@@ -45,13 +46,13 @@ contains
!call MPI_COMM_SIZE(MPI_COMM_WORLD,nbprocs,error)
!groupsize = 5
- call cart_create(topodims,error, main_comm)
+ call cart_create(topodims, error, main_comm, verbosity)
!call set_group_size(groupSize)
! Create meshes
- call discretisation_create(ncells(1),ncells(2),ncells(3),lengths(1),lengths(2),lengths(3))
+ call discretisation_create(ncells(1),ncells(2),ncells(3),lengths(1),lengths(2),lengths(3), verbosity)
! Init advection solver
- call advec_init(order,stab_coeff,dim_split=dim_split)
+ call advec_init(order,stab_coeff,verbosity,dim_split)
! get the local resolution (saved in scales global variable "N_proc")
datashape = N_proc
diff --git a/hysop/scales_f/scales2py.pyf b/hysop/scales_f/scales2py.pyf
index 60efaab3fd92287c03c1544a232a4cb73338862a..96457c87df075940d99a7ed23aecce05727bdcd7 100644
--- a/hysop/scales_f/scales2py.pyf
+++ b/hysop/scales_f/scales2py.pyf
@@ -8,11 +8,12 @@ module scales2py ! in scales2py.f90
use advec_vect, only: advec_step_vect,advec_step_inter_basic_vect
use mpi
use precision
- subroutine init_advection_solver(ncells,lengths,topodims,main_comm,datashape,offset,dim,order,dim_split) ! in scales2py.f90:scales2py
+ subroutine init_advection_solver(ncells,lengths,topodims,main_comm,verbose,datashape,offset,dim,order,dim_split) ! in scales2py.f90:scales2py
integer dimension(dim),intent(in) :: ncells
real(kind=wp) dimension(dim),intent(in),depend(dim) :: lengths
integer dimension(dim),intent(in),depend(dim) :: topodims
integer intent(in) :: main_comm
+ logical, intent(in) :: verbose
integer(kind=ip) dimension(dim),intent(out),depend(dim) :: datashape
integer(kind=ip) dimension(dim),intent(out),depend(dim) :: offset
integer, optional,intent(hide),depend(ncells) :: dim=len(ncells)
diff --git a/hysop/simulation.py b/hysop/simulation.py
index 629a53904b229d90d315cbb7974ba1f7d00b4ebc..e8a5afd02a215512717d879b6eb3307f44495d55 100644
--- a/hysop/simulation.py
+++ b/hysop/simulation.py
@@ -1,4 +1,5 @@
-"""Description of the simulation parameters (time, iteration ...)
+"""
+Description of the simulation parameters (time, iteration ...)
Usage
-----
@@ -26,20 +27,18 @@ Usage
# end simulation (optional) to prepare io
s.finalize()
io.apply(s)
-
"""
+import numpy as np
from abc import ABCMeta, abstractmethod
from hysop import dprint, vprint
-from hysop.deps import sys, os
from hysop.constants import HYSOP_REAL
+from hysop.deps import sys, os
from hysop.parameters.scalar_parameter import ScalarParameter
-from hysop.tools.types import first_not_None, to_set
+from hysop.tools.types import first_not_None, to_set, check_instance
from hysop.tools.numpywrappers import npw
from hysop.tools.io_utils import IO, IOParams
from hysop.tools.string_utils import vprint_banner
-
-eps = npw.finfo(HYSOP_REAL).eps
-"""Machine epsilon, used to compare times."""
+from hysop.core.mpi import main_rank, main_comm
class Simulation(object):
@@ -47,7 +46,8 @@ class Simulation(object):
"""
def __init__(self, name=None, start=0.0, end=1.0, nb_iter=None, dt0=None,
- max_iter=None, t=None, dt=None, times_of_interest=None, quiet=False,
+ max_iter=None, t=None, dt=None, times_of_interest=None,
+ mpi_params=None, quiet=False, clamp_t_to_end=True, restart=0,
**kwds):
"""
Parameters
@@ -72,10 +72,14 @@ class Simulation(object):
times_of_interest: array-like of float
List of times ti where the simulation may
modify current timestep to get t=ti.
- Mainly used by HDF_Writers for precise
+ Mainly used by HDF_Writers for precise
time dependent dumping.
tstart < ti <= tend
Defaults to empty set.
+ clamp_t_to_end : bool, optional
+ Specify if Simulation adjst dt for last iteration to have t=end
+ restart : int, optional
+ Iteration number to start from.
Attributes
----------
@@ -112,6 +116,10 @@ class Simulation(object):
self.time = start
self.is_over = False
self.current_iteration = -1
+ self._rank = main_rank if (mpi_params is None) else mpi_params.rank
+ self._comm = main_comm if (mpi_params is None) else mpi_params.comm
+ self.clamp_t_to_end = clamp_t_to_end
+ self._restart = restart
if (nb_iter is not None):
self.nb_iter = nb_iter
@@ -127,35 +135,37 @@ class Simulation(object):
elif (dt is not None):
assert isinstance(dt, ScalarParameter), type(dt)
assert not dt.const, 'dt cannot be a constant parameter.'
- dt0 = dt.value
+ assert (dt0 is not None), 'dt parameter given, but dt0 has not been given.'
else:
raise ValueError('You must set nb_iter or dt0 value.')
-
- msg='dt0={}, start={}, end={}'.format(dt0, start, end)
+
+ msg = 'dt0={}, start={}, end={}'.format(dt0, start, end)
assert (dt0 > 0.0) and (dt0 <= (end-start)), msg
self._dt0 = dt0
dt_name = '{}_dt'.format(name) if (name is not None) else 'dt'
if (dt is None):
- self.dt = ScalarParameter(name=dt_name, dtype=HYSOP_REAL, min_value=eps,
- initial_value=dt0, quiet=quiet)
+ dtype = t.dtype if (t is not None) else HYSOP_REAL
+ dt = ScalarParameter(name=dt_name, dtype=dtype,
+ min_value=np.finfo(dtype).eps,
+ initial_value=dt0, quiet=quiet)
else:
dt.value = dt0
- self.dt = dt
+ self.dt = dt
self.name = name
-
+
# backup initial time step, required to reset simulation.
self.max_iter = first_not_None(max_iter, 1e9)
# Starting time for the current iteration
if (t is None):
- self.t = ScalarParameter(name='t', dtype=HYSOP_REAL,
- initial_value=start, quiet=quiet)
+ t = ScalarParameter(name='t', dtype=dt.dtype,
+ initial_value=start, quiet=quiet)
else:
- self.t = t
assert isinstance(t, ScalarParameter), type(t)
assert not t.const, 't cannot be a constant parameter.'
t.value = start
-
+ self.t = t
+
# tk+1 = t + dt
self.tkp1 = start + self.time_step
@@ -172,12 +182,15 @@ class Simulation(object):
self.times_of_interest = times_of_interest
# Internal tolerance for timer
- self.tol = eps
+ assert t.dtype == dt.dtype
+ assert t.dtype in (np.float32, np.float64)
+ self.tol = np.finfo(dt.dtype).eps
+
# True if initialize has been called.
- self._is_ready = False
- self._next_is_last = False
+ self._is_ready = False
+ self._next_is_last = False
self._next_is_time_of_interest = False
- self._parameters_to_write = []
+ self._parameters_to_write = []
def _get_time_step(self):
"""Get current timestep."""
@@ -200,75 +213,91 @@ class Simulation(object):
if (dbg is not None):
if self.is_time_of_interest:
dbg(msg='t={}'.format(self.t()), nostack=True)
- elif (plot_freq>0) and ((self.current_iteration%plot_freq)==0):
+ elif (plot_freq > 0) and ((self.current_iteration % plot_freq) == 0):
dbg.fig.suptitle('it={}, t={}'.format(self.current_iteration+1, self.t()))
dbg.update()
for (io_params, params, kwds) in self._parameters_to_write:
- if (io_params.fileformat is IO.ASCII):
- kwds = kwds.copy()
- f = kwds.pop('file')
- formatter = kwds.pop('formatter')
- values = npw.asarray(tuple(p() for p in params))
- values = npw.array2string(values, max_line_width=npw.inf,
- formatter=formatter, **kwds)
- values = '\n'+values[1:-1]
- f.write(values)
- f.flush()
- else:
- msg='Unknown format {}.'.format(fileformat)
- raise ValueError(msg)
+ if self._rank == io_params.io_leader:
+ if (io_params.fileformat is IO.ASCII):
+ kwds = kwds.copy()
+ f = kwds.pop('file')
+ formatter = kwds.pop('formatter')
+ values = npw.asarray(tuple(map(lambda x: x.item() if x.size == 1 else x,
+ (p() for p in params))))
+ values = npw.array2string(values, max_line_width=npw.inf,
+ formatter=formatter, legacy='1.13', **kwds)
+ values = '\n'+values[1:-1]
+ f.write(values)
+ f.flush()
+ else:
+ msg = 'Unknown format {}.'.format(fileformat)
+ raise ValueError(msg)
if self._next_is_last:
self.is_over = True
return
- self.t.set_value(self.tkp1)
-
+ self._comm.Barrier()
+ self.update_time(self.tkp1)
+
+ all_t = self._comm.gather(self.t(), root=0)
+ if (self._rank == 0):
+ assert np.allclose(all_t, all_t[0])
+
self.is_time_of_interest = False
if (self.target_time_of_interest is not None):
if (abs(self.tkp1 - self.target_time_of_interest) <= self.tol):
self.next_time_of_interest()
self.is_time_of_interest = True
-
+
self.tkp1 = self.t() + self.time_step
if abs(self.tkp1 - self.end) <= self.tol:
self._next_is_last = True
- elif (self.tkp1 > self.end):
- msg='** Next iteration is last iteration, clamping dt to achieve t={}. **'
- msg=msg.format(self.end)
- vprint()
- self._print_banner(msg)
- self._next_is_last = True
- self.tkp1 = self.end
- self.update_time_step(self.end - self.t())
elif (self.target_time_of_interest is not None) and \
- (self.tkp1 > self.target_time_of_interest):
- msg='** Next iteration is a time of interest, clamping dt to achieve t={}. **'
- msg=msg.format(self.target_time_of_interest)
+ (self.tkp1+self.tol >= self.target_time_of_interest):
+ msg = '** Next iteration is a time of interest, clamping dt to achieve t={}. **'
+ msg = msg.format(self.target_time_of_interest)
vprint()
self._print_banner(msg)
self.tkp1 = self.target_time_of_interest
self.update_time_step(self.target_time_of_interest - self.t())
+ self._last_forced_timestep = self.dt()
+ elif (self.tkp1 >= self.end):
+ self._next_is_last = True
+ if self.clamp_t_to_end:
+ msg = '** Next iteration is last iteration, clamping dt to achieve t={}. **'
+ msg = msg.format(self.end)
+ vprint()
+ self._print_banner(msg)
+ self.tkp1 = self.end
+ self.update_time_step(self.end - self.t())
+ elif (self.dt() == self._last_forced_timestep):
+ self.update_time_step(self._dt0)
+ self._last_forced_timestep = None
self.current_iteration += 1
self.time = self.tkp1
if (self.current_iteration + 2 > self.max_iter):
msg = '** Next iteration will be the last because max_iter={} will be achieved. **'
- msg=msg.format(self.max_iter)
+ msg = msg.format(self.max_iter)
vprint()
self._print_banner(msg)
self._next_is_last = True
self.is_time_of_interest = True
+ all_dt = self._comm.gather(self.dt(), root=0)
+ if (self._rank == 0):
+ assert np.allclose(all_dt, all_dt[0])
+
def _print_banner(self, msg):
vprint_banner(msg)
def next_time_of_interest(self):
- toi_counter = self.toi_counter
+ toi_counter = self.toi_counter
times_of_interest = self.times_of_interest
- if (toi_counter<len(times_of_interest)):
+ if (toi_counter < len(times_of_interest)):
self.target_time_of_interest = times_of_interest[toi_counter]
self.toi_counter += 1
else:
@@ -290,6 +319,9 @@ class Simulation(object):
"""
self.dt.set_value(dt)
+
+ def update_time(self, t):
+ self.t.set_value(t)
def initialize(self):
"""(Re)set simulation to initial values
@@ -297,7 +329,7 @@ class Simulation(object):
"""
tstart, tend = self.start, self.end
times_of_interest = self.times_of_interest
-
+
self.toi_counter = 0
self.next_time_of_interest()
self.is_time_of_interest = False
@@ -314,41 +346,43 @@ class Simulation(object):
dt0 = min(self._dt0, self.target_time_of_interest-tstart)
else:
dt0 = self._dt0
-
- self.t.set_value(tstart)
+
+ self.update_time(tstart)
self.update_time_step(dt0)
self.tkp1 = tstart + self.time_step
-
assert self.tkp1 <= tend
if abs(self.tkp1 - self.end) <= self.tol:
self._next_is_last = True
else:
self._next_is_last = False
-
+
self.time = self.tkp1
self.is_over = False
- self.current_iteration = 0
+ self.current_iteration = self._restart
self._is_ready = True
+ self._last_forced_timestep = None
for (io_params, params, kwds) in self._parameters_to_write:
- filename = io_params.filename
+ filename = io_params.filename
fileformat = io_params.fileformat
if ('file' in kwds) and (kwds['file'] is not None):
kwds['file'].close()
- if os.path.isfile(filename):
- os.remove(filename)
- if (fileformat is IO.ASCII):
- f = open(filename, 'a')
- header = '{}\n'.format('\t'.join('{}({})'.format(p.name, p.pretty_name) for p in params))
- f.write(header)
- kwds['file'] = f
-
- formatter={'float_kind': lambda x: '{:8.8f}'.format(x)}
- kwds.setdefault('formatter', formatter)
- else:
- msg='Unknown format {}.'.format(fileformat)
- raise ValueError(msg)
+ if self._rank == io_params.io_leader:
+ if os.path.isfile(filename):
+ os.remove(filename)
+ if (fileformat is IO.ASCII):
+ f = open(filename, 'a')
+ header = '{}\n'.format('\t'.join('{}({})'.format(
+ p.name, p.pretty_name) for p in params))
+ f.write(header)
+ kwds['file'] = f
+
+ formatter = {'float_kind': lambda x: '{:.8g}'.format(x)}
+ kwds.setdefault('formatter', formatter)
+ else:
+ msg = 'Unknown format {}.'.format(fileformat)
+ raise ValueError(msg)
def finalize(self):
"""Use this function when you need to call an hdf i/o operator
@@ -356,15 +390,16 @@ class Simulation(object):
"""
self.is_over = True
self.current_iteration = -1
-
+
for (io_params, params, kwds) in self._parameters_to_write:
- f = kwds.pop('file')
- f.close()
-
+ if self._rank == io_params.io_leader:
+ f = kwds.pop('file')
+ f.close()
+
def print_state(self, verbose=None):
"""Print current simulation parameters
"""
- msg = "== Iteration : {0:3d}, from t = {1:6.5} to t = {2:6.5f} =="
+ msg = "== Iteration : {0:3d}, from t = {1:6.8} to t = {2:6.8f} =="
if verbose:
print msg.format(self.current_iteration, self.t(), self.time)
else:
@@ -373,24 +408,52 @@ class Simulation(object):
def write_parameters(self, *params, **kwds):
if ('io_params' not in kwds):
assert ('filename' in kwds), 'io_params or filename should be specified.'
- filename = kwds.pop('filename')
- filepath = kwds.pop('filepath', None)
- fileformat = kwds.pop('fileformat', IO.ASCII)
- frequency = kwds.pop('frequency', 1)
- io_leader = kwds.pop('io_leader', 0)
+ filename = kwds.pop('filename')
+ filepath = kwds.pop('filepath', None)
+ fileformat = kwds.pop('fileformat', IO.ASCII)
+ frequency = kwds.pop('frequency', 1)
+ io_leader = kwds.pop('io_leader', 0)
visu_leader = kwds.pop('visu_leader', 0)
io_params = IOParams(filename=filename, filepath=filepath,
- frequency=frequency, fileformat=fileformat,
- io_leader=io_leader, visu_leader=visu_leader)
+ frequency=frequency, fileformat=fileformat,
+ io_leader=io_leader, visu_leader=visu_leader)
else:
io_params = kwds.pop('io_params')
_params = ()
for p in params:
- for (_,param) in p.iterviews():
+ for (_, param) in p.iterviews():
_params += (param,)
params = _params
self._parameters_to_write.append((io_params, params, kwds))
+ def save_checkpoint(self, datagroup, mpi_params, io_params, compressor):
+ import zarr
+ check_instance(datagroup, zarr.hierarchy.Group)
+ is_io_leader = (mpi_params.rank == io_params.io_leader)
+ if is_io_leader:
+ # we need to export simulation parameter values because they
+ # may not be part of global problem parameters
+ datagroup.attrs['t'] = float(self.t())
+ datagroup.attrs['dt'] = float(self.dt())
+ for attrname in ('current_iteration', 'tkp1', 'time'):
+ data = getattr(self, attrname)
+ try:
+ data = data.item()
+ except AttributeError:
+ pass
+ datagroup.attrs[attrname] = data
+
+ def load_checkpoint(self, datagroup, mpi_params, io_params, relax_constraints):
+ import zarr
+ check_instance(datagroup, zarr.hierarchy.Group)
+ self.times_of_interest = tuple(sorted(filter(lambda t: t>=datagroup.attrs['time'], self.times_of_interest)))
+ self.toi_counter = 0
+ self.next_time_of_interest()
+ self.t._value[...] = datagroup.attrs['t'] # silent parameter update
+ self.dt._value[...] = datagroup.attrs['dt'] # silent parameter update
+ for attrname in ('current_iteration', 'tkp1', 'time'):
+ setattr(self, attrname, datagroup.attrs[attrname])
+
def __str__(self):
s = "Simulation parameters : "
s += "from " + str(self.start) + ' to ' + str(self.end)
@@ -399,12 +462,16 @@ class Simulation(object):
s += str(self.current_iteration) + ', max number of iterations : '
s += str(self.max_iter)
return s
-
+
def should_dump(self, frequency, with_last=False):
- dump = (frequency>=0) and (with_last and self._next_is_last)
+ import warnings
+ from hysop.tools.warning import HysopDeprecationWarning
+ msg = 'This method will be deprecated soon. Please use io_params.should_dump(simulation, with_last) instead.'
+ warnings.warn(msg, HysopDeprecationWarning)
+
+ dump = (frequency >= 0) and (with_last and self._next_is_last)
if (frequency >= 0):
dump |= self.is_time_of_interest
if (frequency > 0):
dump |= ((self.current_iteration % frequency) == 0)
return dump
-
diff --git a/hysop/symbolic/array.py b/hysop/symbolic/array.py
index 76c3b4da54a546ba765db31b0be7814a09bbdb2b..a1ae050f02ef99e0adb722e30bd6a632b834bbf4 100644
--- a/hysop/symbolic/array.py
+++ b/hysop/symbolic/array.py
@@ -2,8 +2,10 @@
from abc import ABCMeta, abstractmethod
from hysop.constants import Backend
from hysop.symbolic.base import DummySymbolicScalar, sm
+from hysop.symbolic.constant import SymbolicConstant
from hysop.tools.types import check_instance, to_tuple, first_not_None
from hysop.tools.numpywrappers import npw
+from hysop.tools.sympy_utils import subscript
from hysop.backend.device.opencl import clArray
from hysop.backend.device.opencl.opencl_array import OpenClArray
from hysop.backend.host.host_array import HostArray
@@ -188,12 +190,86 @@ class SymbolicBuffer(SymbolicMemoryObject):
return self
+class SymbolicNdBuffer(SymbolicBuffer):
+ """Same as a SymbolicBuffer, but with ndindex access and ghost support."""
+ def __new__(cls, name, memory_object=None, dim=None, strides=None, dtype=None, ghosts=None, **kwds):
+ obj = super(SymbolicNdBuffer, cls).__new__(cls, memory_object=memory_object,
+ name=name, **kwds)
+ msg='Dimension could not be deduced from memory_object, '
+ msg+='please specify a dimension for symbolic array {}.'
+ msg=msg.format(name.encode('utf-8'))
+ if (memory_object is None):
+ if (dim is None):
+ raise RuntimeError(msg)
+ elif hasattr(memory_object, 'ndim'):
+ dim = memory_object.ndim
+ elif hasattr(memory_object, 'dim'):
+ dim = memory_object.dim
+ else:
+ raise RuntimeError(msg)
+ check_instance(dim, int)
+ obj._dim = dim
+ obj._symbolic_strides = tuple(SymbolicConstant(name='s{}'.format(i),
+ pretty_name='s'+subscript(i),
+ dtype=npw.int32) for i in xrange(dim))
+ obj._symbolic_ghosts = tuple(SymbolicConstant(name='g{}'.format(i),
+ pretty_name='g'+subscript(i),
+ dtype=npw.int32) for i in xrange(dim))
+ obj._allow_update_symbolic_constants = True
+ obj.update_symbolic_constants(memory_object=memory_object, strides=strides, dtype=dtype, ghosts=ghosts, force=False)
+ return obj
+
+ def bind_memory_object(self, memory_object, strides=None, dtype=None, ghosts=None, force=False, **kwds):
+ super(SymbolicNdBuffer, self).bind_memory_object(memory_object=memory_object, force=force, **kwds)
+ self.update_symbolic_constants(memory_object=memory_object, strides=strides, dtype=dtype, ghosts=ghosts, force=force)
+
+ def update_symbolic_constants(self, memory_object, strides, dtype, ghosts, force):
+ if hasattr(self, '_allow_update_symbolic_constants') and self._allow_update_symbolic_constants:
+ strides = first_not_None(strides, getattr(memory_object, 'strides', None))
+ dtype = first_not_None(dtype, getattr(memory_object, 'dtype', None))
+ assert (strides is not None), 'Could not determine strides from memory_object.'
+ assert (dtype is not None), 'Could not determine dtype from memory_object.'
+ itemsize = dtype.itemsize
+ strides = to_tuple(strides)
+ check_instance(strides, tuple, values=(int,long), size=self._dim)
+ for ss,si in zip(self._symbolic_strides, strides):
+ assert si%itemsize == 0
+ ss.bind_value(si//itemsize, force=force)
+
+ ghosts = first_not_None(ghosts, getattr(memory_object, 'ghosts', None))
+ assert (ghosts is not None), 'Could not determine ghosts from memory_object.'
+ ghosts = to_tuple(ghosts)
+ check_instance(ghosts, tuple, values=(int,long), size=self._dim)
+ for sg,gi in zip(self._symbolic_ghosts, ghosts):
+ sg.bind_value(gi, force=force)
+
+ @property
+ def dim(self):
+ return self._dim
+
+ @property
+ def symbolic_strides(self):
+ return self._symbolic_strides
+
+ @property
+ def symbolic_ghosts(self):
+ return self._symbolic_ghosts
+
+ def __call__(self, *idx):
+ if len(idx)==1 and isinstance(idx[0], npw.ndarray):
+ assert idx[0].size==self._dim, idx[0].shape
+ idx = tuple(idx[0].ravel().tolist())
+ assert len(idx) == self._dim, idx
+ offset = npw.dot(self._symbolic_strides, npw.add(idx, self._symbolic_ghosts))
+ return self.__getitem__(key=offset)
+
+
+
class SymbolicHostMemoryObject(object):
def bind_memory_object(self, memory_object, **kwds):
check_instance(memory_object, (HostArray, npw.ndarray))
return super(SymbolicHostMemoryObject, self).bind_memory_object(memory_object, **kwds)
-
class SymbolicDeviceMemoryObject(object):
def bind_memory_object(self, memory_object, **kwds):
check_instance(memory_object, (OpenClArray, clArray.Array))
@@ -216,6 +292,10 @@ class HostSymbolicBuffer(SymbolicHostMemoryObject, SymbolicBuffer):
pass
class OpenClSymbolicBuffer(SymbolicDeviceMemoryObject, SymbolicBuffer):
pass
+class HostSymbolicNdBuffer(SymbolicHostMemoryObject, SymbolicNdBuffer):
+ pass
+class OpenClSymbolicNdBuffer(SymbolicDeviceMemoryObject, SymbolicNdBuffer):
+ pass
if __name__ == '__main__':
diff --git a/hysop/symbolic/constant.py b/hysop/symbolic/constant.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ff7c109dc9d22a9929bd75555bbd3c11dffd6d5
--- /dev/null
+++ b/hysop/symbolic/constant.py
@@ -0,0 +1,69 @@
+
+from hysop.tools.numpywrappers import npw
+from hysop.symbolic.base import DummySymbolicScalar, sm
+
+class SymbolicConstant(DummySymbolicScalar):
+ """Temporary constant variables."""
+ def __new__(cls, name, **kwds):
+ if ('dtype' not in kwds):
+ msg='dtype has not been specified for SymbolicConstant {}.'
+ msg=msg.format(name).encode('utf-8')
+ raise RuntimeError(msg)
+ dtype = kwds.pop('dtype')
+ value = kwds.pop('value', None)
+ obj = super(SymbolicConstant, cls).__new__(cls, name=name, **kwds)
+ obj._dtype = dtype
+ obj._value = None
+ if (value is not None):
+ obj.bind_value(value)
+ return obj
+
+ @property
+ def is_bound(self):
+ return (self._value is not None)
+
+ def assert_bound(self):
+ if not self.is_bound:
+ msg='{}::{} value has not been bound yet.'
+ msg=msg.format(self.__class__.__name__, self.name)
+ raise RuntimeError(msg)
+
+ def bind_value(self, value, force=False):
+ if (not force) and (self._value is not None):
+ msg='A value has already been bound to SymbolicConstant {}.'.format(self.name)
+ raise RuntimeError(msg)
+ if isinstance(value, npw.ndarray):
+ assert value.size == 1, value.size
+ value = value.item()
+ value = self._dtype(value)
+ self._value = value
+ return self
+
+ @property
+ def value(self):
+ self.assert_bound()
+ return self._value
+ @property
+ def dtype(self):
+ self.assert_bound()
+ return self._dtype
+ @property
+ def ctype(self):
+ from hysop.backend.device.codegen.base.variables import dtype_to_ctype
+ self.assert_bound()
+ return dtype_to_ctype(self._dtype)
+
+ def short_description(self):
+ self.assert_bound()
+ return '{}[dtype={}, ctype={}]'.format(
+ self.__class__.__name__, self.dtype, self.ctype)
+
+ def __eq__(self, other):
+ return id(self) == id(other)
+ def __hash__(self):
+ return id(self)
+ def _hashable_content(self):
+ """See sympy.core.basic.Basic._hashable_content()"""
+ hc = super(SymbolicConstant, self)._hashable_content()
+ hc += (str(id(self)),)
+ return hc
diff --git a/hysop/symbolic/relational.py b/hysop/symbolic/relational.py
index b63adc4a5f17b0df1b7578c3d129d12984438445..8ed218e3b1afcdf7503fe2823781d962d1a93f12 100644
--- a/hysop/symbolic/relational.py
+++ b/hysop/symbolic/relational.py
@@ -142,16 +142,19 @@ class Assignment(BinaryRelation):
return '='
@classmethod
- def assign(cls, lhs, rhs):
+ def assign(cls, lhs, rhs, skip_zero_rhs=False):
exprs = ()
+ def create_expr(rhs):
+ return (not skip_zero_rhs) or (rhs!=0)
if isinstance(lhs, npw.ndarray) and isinstance(rhs, npw.ndarray):
assert isinstance(lhs, npw.ndarray), type(lhs)
assert isinstance(rhs, npw.ndarray), type(rhs)
assert (rhs.size == lhs.size)
assert (rhs.shape == lhs.shape)
for (l,r) in zip(lhs.ravel().tolist(), rhs.ravel().tolist()):
- e = cls(l, r)
- exprs += (e,)
+ if create_expr(r):
+ e = cls(l, r)
+ exprs += (e,)
elif isinstance(lhs, npw.ndarray) or isinstance(rhs, npw.ndarray):
if isinstance(lhs, npw.ndarray):
lhss = lhs.ravel().tolist()
@@ -160,13 +163,15 @@ class Assignment(BinaryRelation):
rhss = rhs.ravel().tolist()
lhss = (lhs,)*len(rhss)
for (l,r) in zip(lhss, rhss):
- e = cls(l, r)
- exprs += (e,)
+ if create_expr(r):
+ e = cls(l, r)
+ exprs += (e,)
elif isinstance(lhs, sm.Basic) and isinstance(rhs, sm.Basic):
assert isinstance(lhs, sm.Basic), type(lhs)
assert isinstance(rhs, sm.Basic), type(rhs)
e = cls(lhs, rhs)
- exprs += (e,)
+ if create_expr(rhs):
+ exprs += (e,)
else:
msg='Cannot handle operand types:\n *lhs: {}\n *rhs: {}\n'
msg=msg.format(type(lhs), type(rhs))
diff --git a/hysop/testsenv.py b/hysop/testsenv.py
index 8e1b7e1ec3f10ee6b186d3afd284d15d568d1389..046f2b4d3191a5c5c0cc7bbe13597945f0df0a5b 100644
--- a/hysop/testsenv.py
+++ b/hysop/testsenv.py
@@ -93,17 +93,14 @@ if __HAS_OPENCL_BACKEND__:
cl_environments[cl_device_type] = []
if (cl_device_type is None):
mpi_params = default_mpi_params()
- if all_platforms:
- for i,plat in enumerate(cl.get_platforms()):
- for j,dev in enumerate(plat.get_devices()):
- cl_env = get_or_create_opencl_env(platform_id=i, device_id=j,
- mpi_params=mpi_params, **kwds)
+ for i,plat in enumerate(cl.get_platforms()):
+ for j,dev in enumerate(plat.get_devices()):
+ cl_env = get_or_create_opencl_env(platform_id=i, device_id=j,
+ mpi_params=mpi_params, **kwds)
+ if (i==__DEFAULT_PLATFORM_ID__) and (j==__DEFAULT_DEVICE_ID__):
+ cl_environments[None].insert(0, cl_env)
+ else:
cl_environments[None].append(cl_env)
- else:
- cl_env = get_or_create_opencl_env(platform_id=__DEFAULT_PLATFORM_ID__,
- device_id=__DEFAULT_DEVICE_ID__,
- mpi_params=mpi_params, **kwds)
- cl_environments[None].append(cl_env)
else:
for cl_env in iter_clenv(cl_device_type=None, all_platforms=True):
if (cl_env.device.type & cl_device_type):
@@ -120,6 +117,7 @@ if __HAS_OPENCL_BACKEND__:
yield cl_env
if not all_platforms:
return
+
else:
opencl_failed = pytest.mark.xfail
iter_clenv = None
diff --git a/hysop/tools/cache.py b/hysop/tools/cache.py
index 01294f480fdbbc9c7673bef9a4367c6b3bdf5506..44a9984349ee3ffa7f4710032fe95d2a1a1e10c5 100644
--- a/hysop/tools/cache.py
+++ b/hysop/tools/cache.py
@@ -20,18 +20,19 @@ if (machine_id in (None,'')):
@contextlib.contextmanager
def lock_file(filepath, mode, compressed=True,
- timeout=20, check_interval=0.1):
+ timeout=3600, check_interval=1):
"""
Opens a locked file with specified mode, possibly compressed.
"""
_dir = os.path.dirname(filepath)
try:
- try:
- os.makedirs(_dir)
- except OSError as e:
- if (e.errno != errno.EEXIST):
- raise
+ if not os.path.isdir(_dir):
+ try:
+ os.makedirs(_dir)
+ except OSError as e:
+ if (e.errno != errno.EEXIST):
+ raise
if not os.path.exists(filepath):
open(filepath, 'a').close()
with portalocker.Lock(filename=filepath, timeout=timeout, mode=mode,
@@ -49,7 +50,7 @@ def lock_file(filepath, mode, compressed=True,
@contextlib.contextmanager
def read_only_lock(filepath, compressed=True,
- timeout=20, check_interval=0.1):
+ timeout=3600, check_interval=1):
"""Opens a locked read only file, possibly compressed."""
with lock_file(filepath=filepath, mode='r', compressed=compressed,
timeout=timeout, check_interval=check_interval) as f:
@@ -57,7 +58,7 @@ def read_only_lock(filepath, compressed=True,
@contextlib.contextmanager
def write_only_lock(filepath, compressed=True,
- timeout=20, check_interval=0.1):
+ timeout=3600, check_interval=1):
"""Opens a locked write only file, possibly compressed."""
with lock_file(filepath=filepath, mode='w', compressed=compressed,
timeout=timeout, check_interval=check_interval) as f:
@@ -72,7 +73,7 @@ def load_cache(filepath, match_type=dict, on_fail={}, **kwds):
data = pickle.load(f)
if not isinstance(data, match_type):
raise pickle.UnpicklingError
- except (IOError, EOFError, pickle.UnpicklingError, AttributeError):
+ except (IOError, EOFError, pickle.UnpicklingError, AttributeError, TypeError):
data = on_fail
return data
diff --git a/hysop/tools/contexts.py b/hysop/tools/contexts.py
index 6ae0dbe6fc95b11160da54675598ef8ba4a2408f..7703a92adc0f09b6f820debd534de60f1c07c85f 100644
--- a/hysop/tools/contexts.py
+++ b/hysop/tools/contexts.py
@@ -1,7 +1,22 @@
+import os
from hysop.deps import np, time, sys
from contextlib import contextmanager
+class Timer(object):
+ def __enter__(self, factor=1):
+ self.start = time.time()
+ self.factor = factor
+ self.end = None
+ self.interval = None
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.end = time.time()
+ self.interval = (self.end - self.start)*self.factor
+ if exc_type:
+ raise
+
@contextmanager
def printoptions(*args, **kwargs):
original = np.get_printoptions()
@@ -20,16 +35,60 @@ def systrace(fn=None):
yield
sys.settrace(__old_trace)
-class Timer(object):
- def __enter__(self, factor=1):
- self.start = time.time()
- self.factor = factor
- self.end = None
- self.interval = None
- return self
+@contextmanager
+def redirect_stdout(fileobj):
+ old = sys.stdout
+ old.flush()
+ sys.stdout = fileobj
+ try:
+ yield fileobj
+ finally:
+ sys.stdout = old
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.end = time.time()
- self.interval = (self.end - self.start)*self.factor
- if exc_type:
- raise
+@contextmanager
+def redirect_stderr(fileobj):
+ old = sys.stderr
+ old.flush()
+ sys.stderr = fileobj
+ try:
+ yield fileobj
+ finally:
+ sys.stderr = old
+
+
+# See https://stackoverflow.com/questions/4675728/redirect-stdout-to-a-file-in-python/22434262#22434262
+@contextmanager
+def stdout_redirected(to=os.devnull): # C-level redirection (file descriptor level)
+ def fileno(file_or_fd):
+ fd = getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
+ if not isinstance(fd, int):
+ raise ValueError("Expected a file (`.fileno()`) or a file descriptor")
+ return fd
+ stdout = sys.stdout
+ stdout_fd = fileno(stdout)
+ with os.fdopen(os.dup(stdout_fd), 'wb') as copied:
+ stdout.flush()
+ os.dup2(fileno(to), stdout_fd)
+ try:
+ yield
+ finally:
+ stdout.flush()
+ os.dup2(copied.fileno(), stdout_fd)
+
+@contextmanager
+def stderr_redirected(to=os.devnull): # C-level redirection (file descriptor level)
+ def fileno(file_or_fd):
+ fd = getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
+ if not isinstance(fd, int):
+ raise ValueError("Expected a file (`.fileno()`) or a file descriptor")
+ return fd
+ stderr = sys.stderr
+ stderr_fd = fileno(stderr)
+ with os.fdopen(os.dup(stderr_fd), 'wb') as copied:
+ stderr.flush()
+ os.dup2(fileno(to), stderr_fd)
+ try:
+ yield
+ finally:
+ stderr.flush()
+ os.dup2(copied.fileno(), stderr_fd)
diff --git a/hysop/tools/debug_dumper.py b/hysop/tools/debug_dumper.py
index eebcbbefc5cd151391ec601c4cb71bb86a887a35..868179b3f0def67cf98a1d5ba8779f1b69122a10 100644
--- a/hysop/tools/debug_dumper.py
+++ b/hysop/tools/debug_dumper.py
@@ -1,54 +1,77 @@
-
-import os, shutil, datetime, inspect, argparse, sys
+import os
+import shutil
+import datetime
+import inspect
+import argparse
+import sys
import numpy as np
+from hysop import MPI
from hysop.tools.types import check_instance
from hysop.fields.discrete_field import DiscreteScalarFieldView
-class DebugDumper(object):
- def __init__(self, name, path='/tmp/hysop/debug', force_overwrite=False,
- enable_on_op_apply=False):
- directory = path+'/'+name
- blobs_directory = directory + '/data'
-
- if os.path.exists(directory):
- if force_overwrite:
- shutil.rmtree(directory)
- else:
- msg='Directory \'{}\' already exists.'.format(directory)
- raise RuntimeError(msg)
-
- os.makedirs(blobs_directory)
- runfile = '{}/run.txt'.format(directory)
- runfile = open(runfile, 'a')
+class DebugDumper(object):
+ def __init__(self, name, path, force_overwrite=False,
+ enable_on_op_apply=False, dump_precision=10,
+ comm=MPI.COMM_WORLD, io_leader=0):
+ assert isinstance(name, str), name
+ assert isinstance(path, str), path
+ directory = os.path.join(path, name)
+ blobs_directory = os.path.join(directory, 'data')
+ if not os.path.isdir(blobs_directory) and comm.rank==0:
+ os.makedirs(blobs_directory)
self.name = name
self.directory = directory
self.blobs_directory = blobs_directory
- self.runfile = runfile
self.dump_id = 0
self.enable_on_op_apply = enable_on_op_apply
+ self.dump_precision = dump_precision
+
+ self.comm = comm
+ self.io_leader = io_leader
+ self.comm_size = comm.Get_size()
+ self.comm_rank = comm.Get_rank()
+ assert 0 <= self.io_leader < self.comm_size
+ self.is_io_leader = (self.comm_rank == self.io_leader)
- self.print_header()
+ if self.is_io_leader:
+ if os.path.exists(directory):
+ if force_overwrite:
+ shutil.rmtree(directory)
+ else:
+ msg = 'Directory \'{}\' already exists.'.format(directory)
+ raise RuntimeError(msg)
+ os.makedirs(blobs_directory)
+ runfile = '{}/run.txt'.format(directory)
+ runfile = open(runfile, 'a')
+ self.runfile = runfile
+ self.print_header()
+ else:
+ self.runfile = None
def __del__(self):
if hasattr(self, 'runfile') and (self.runfile is not None):
self.runfile.close()
self.runfile = None
-
+
@classmethod
- def lformat(cls, id_, iteration, time, tag, dtype, shape, min_, max_, mean, variance, description=''):
- return '{:<4} {:<10} {:<20} {:<20} {:<20} {:<20} {:<20} {:<20} {:<20} {:<20} {}'.format(
- id_, iteration, time, tag, dtype, shape, min_, max_, mean, variance, description)
-
- def print_header(self):
+ def lformat(cls, id_, iteration, time, tag, min_, max_, mean, variance, dtype, shape, description='', dump_precision=None):
+ try:
+ return '{:<4} {:<10} {:<20.{p}f} {:<40} {:<+20.{p}f} {:<+20.{p}f} {:<+20.{p}f} {:<+20.{p}f} {:<20} {:<20} {}'.format(
+ id_, iteration, time, tag, min_, max_, mean, variance, dtype, shape, description, p=dump_precision)
+ except:
+ return '{:<4} {:<10} {:<20} {:<40} {:<20} {:<20} {:<20} {:<20} {:<20} {:<20} {}'.format(
+ id_, iteration, time, tag, min_, max_, mean, variance, dtype, shape, description)
+
+ def print_header(self, with_datetime=False):
now = datetime.datetime.now()
- self.runfile.write('DEBUG DUMP {} ({})\n'.format(
+ self.runfile.write('DEBUG DUMP {}{}\n'.format(
self.name,
- now.strftime("%Y-%m-%d %H:%M")))
- self.runfile.write(self.lformat('id', 'iteration', 'time', 'tag', 'dtype', 'shape', 'min', 'max', 'mean', 'variance',
- 'description'))
+ ' ({})'.format(now.strftime("%Y-%m-%d %H:%M")) if with_datetime else ''))
+ self.runfile.write(self.lformat('id', 'iteration', 'time', 'tag', 'min', 'max', 'mean', 'variance',
+ 'dtype', 'shape', 'description'))
@classmethod
def get_arrays(self, arrays):
@@ -59,22 +82,26 @@ class DebugDumper(object):
else:
check_instance(arrays, tuple, values=np.ndarray)
return arrays
-
def __call__(self, iteration, time, tag, arrays, description=''):
check_instance(iteration, int)
arrays = self.get_arrays(arrays)
N = len(arrays)
+ comm = self.comm
+ comm_size = self.comm_size
for (i, data) in enumerate(arrays):
- if (N>1):
+ if (N > 1):
tag_ = '{}_{}'.format(tag, i)
else:
tag_ = tag
- if (description != '') and (N>1):
- description_ = '{} (component {})'.format(description, i)
+ if (description != ''):
+ if (N > 1):
+ description_ = '{} (component {})'.format(description, i)
+ else:
+ description_ = description
else:
- _file,_line = inspect.stack()[1][1:3]
- description_='{}:{}'.format(_file, _line)
+ _file, _line = inspect.stack()[1][1:3]
+ description_ = '{}:{}'.format(_file, _line)
dtype = data.dtype
if dtype in (np.complex64, np.complex128):
data = (data.real, data.imag)
@@ -82,18 +109,23 @@ class DebugDumper(object):
else:
data = (data,)
tags = (tag_,)
- for (d,tag_) in zip(data, tags):
+ for (d, tag_) in zip(data, tags):
dtype = d.dtype
- shape = d.shape
+ shape = None
id_ = self.dump_id
- _min, _max = np.nanmin(d), np.nanmax(d)
- mean, variance = np.nanmean(d), np.nanvar(d)
- entry = '\n'+self.lformat(id_, iteration, time, tag_, dtype, shape, _min, _max, mean, variance, description_)
-
- self.runfile.write(entry)
+ _min = comm.allreduce(float(np.nanmin(d)), op=MPI.MIN)
+ _max = comm.allreduce(float(np.nanmax(d)), op=MPI.MAX)
+ mean = comm.allreduce(float(np.nanmean(d))) / comm_size
+ variance = comm.allreduce(float(np.nansum((d-mean)**2))) / \
+ float(comm.allreduce(long(d.size)))
+ entry = '\n'+self.lformat(id_, iteration, time, tag_, _min, _max,
+ mean, variance, dtype, shape, description_, self.dump_precision)
- dst = '{}/{}'.format(self.blobs_directory, self.dump_id)
- np.savez_compressed(dst, data=d)
+ if self.is_io_leader:
+ self.runfile.write(entry)
- self.dump_id += 1
+ if (comm_size == 1):
+ dst = '{}/{}'.format(self.blobs_directory, self.dump_id)
+ np.savez_compressed(dst, data=d)
+ self.dump_id += 1
diff --git a/hysop/tools/enum.py b/hysop/tools/enum.py
index 176ee92b2ae2add2827259fee15ba3f785c93a0d..bf00ef36c0e0d7ce2041ac548ae3673d7d22bf37 100644
--- a/hysop/tools/enum.py
+++ b/hysop/tools/enum.py
@@ -242,7 +242,7 @@ class EnumFactory(object):
def __hash__(self):
return hash(self._field)
- #pickling
+ # pickling
def __reduce__(self):
return (_EnumInstanceGenerator(), (name, self._field))
diff --git a/hysop/tools/hptt_utils.py b/hysop/tools/hptt_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec7af819069ab39deb1e34046ed2ee5ee68e27b1
--- /dev/null
+++ b/hysop/tools/hptt_utils.py
@@ -0,0 +1,38 @@
+import numpy as np
+
+try:
+ import hptt
+ HAS_HPTT=True
+ # required version is: https://gitlab.com/keckj/hptt
+except ImportError:
+ hptt = None
+ HAS_HPTT=False
+ import warnings
+ from hysop.tools.warning import HysopPerformanceWarning
+ msg='Failed to import HPTT module, falling back to slow numpy transpose. Required version is available at https://gitlab.com/keckj/hptt.'
+ warnings.warn(msg, HysopPerformanceWarning)
+
+def array_share_data(a,b):
+ abeg, aend = np.byte_bounds(a)
+ bbeg, bend = np.byte_bounds(b)
+ beg, end = max(abeg, bbeg), min(aend, bend)
+ return (end-beg > 0)
+
+if HAS_HPTT:
+ def can_exec_hptt(src, dst):
+ if (src is dst):
+ return False
+ if (src.dtype != dst.dtype):
+ return False
+ if src.dtype not in (np.float32, np.float64, np.complex64, np.complex128):
+ return False
+ if src.flags['C_CONTIGUOUS'] != dst.flags['C_CONTIGUOUS']:
+ return False
+ if src.flags['F_CONTIGUOUS'] != dst.flags['F_CONTIGUOUS']:
+ return False
+ if not (src.flags['C_CONTIGUOUS'] ^ src.flags['F_CONTIGUOUS']):
+ return False
+ return not array_share_data(src, dst)
+else:
+ def can_exec_hptt(src, dst):
+ return False
diff --git a/hysop/tools/hysop_ls.py b/hysop/tools/hysop_ls.py
index 5d1865c3441c3de7b19f17197b8af4c835b775b9..95a8659304899091fc44728e4ecb660973d56823 100755
--- a/hysop/tools/hysop_ls.py
+++ b/hysop/tools/hysop_ls.py
@@ -340,7 +340,7 @@ def run(arguments=None):
if verbose:
print 'Results have been cached to {}.'.format(cache_file)
- # load backed cached hardware topologies
+ # load back cached hardware topologies
if verbose:
print 'Loading topologies and computing requested statistics...'
topologies = load_cache(cache_file)
diff --git a/hysop/tools/interface.py b/hysop/tools/interface.py
index dcd1334ab0550d5c37fdd01b540812049136b94d..3722820a076d08c4f7c5e21308d84799474fcba5 100644
--- a/hysop/tools/interface.py
+++ b/hysop/tools/interface.py
@@ -112,6 +112,28 @@ class NamedScalarContainerI(NamedObjectI, SymbolContainerI):
raise RuntimeError(msg)
self._var_name = var_name
+ def nd_iter(self):
+ """Return an nd-indexed iterator of contained objects."""
+ yield ((1,), self)
+
+ def __iter__(self):
+ """Return an iterator on unique scalar objects."""
+ return (self,).__iter__()
+
+ def __tuple__(self):
+ """
+ Fix hysop.tools/type.to_tuple for FieldContainers,
+ because __iter__ has been redefined.
+ """
+ return (self,)
+
+ def __contains__(self, obj):
+ """Check if a scalar object is contained in self."""
+ return (obj is self)
+
+ def __getitem__(self, slc):
+ return self
+
var_name = property(_get_var_name)
@@ -166,6 +188,13 @@ class NamedTensorContainerI(NamedObjectI, SymbolContainerI):
def __iter__(self):
"""Return an iterator on unique scalar objects."""
return self._contained_objects.ravel().__iter__()
+
+ def __tuple__(self):
+ """
+ Fix hysop.tools/type.to_tuple for FieldContainers,
+ because __iter__ has been redefined.
+ """
+ return (self,)
def __contains__(self, obj):
"""Check if a scalar object is contained in self."""
diff --git a/hysop/tools/io_utils.py b/hysop/tools/io_utils.py
index 31d1406f29efa686748b214e2fbe15aaa80b7e04..16d197b31c9412e9a6a3a8412e148684cd7b5e77 100755
--- a/hysop/tools/io_utils.py
+++ b/hysop/tools/io_utils.py
@@ -8,17 +8,27 @@
* :class:`~XMF`, tools to prepare/write xmf files.
"""
-import os, h5py, psutil, warnings, tempfile, socket
+import os
+import h5py
+import psutil
+import warnings
+import tempfile
+import socket
+import shutil
+import atexit
+import numpy as np
import subprocess32 as subprocess
from collections import namedtuple
from inspect import getouterframes, currentframe
from re import findall
+from hysop.tools.types import first_not_None, check_instance
from hysop.tools.parameters import MPIParams
from hysop.tools.warning import HysopWarning
from hysop.tools.decorators import requires_cmd
import hysop.core.mpi as mpi
+
class IO(object):
"""
Static class with utilities to set/find the place where i/o files
@@ -27,6 +37,7 @@ class IO(object):
_default_path = None
_cache_path = None
+ _tmp_dirs = {}
HDF5 = 998
"""HDF5 format id"""
@@ -34,13 +45,15 @@ class IO(object):
ASCII = 997
"""ascii format id"""
-
@staticmethod
@requires_cmd('stat')
def get_fs_type(path):
cmd = ['stat', '-f', '-c', '%T', path]
- fs_type = subprocess.check_output(cmd)
- return fs_type.replace('\n','')
+ fs_type = ''
+ if mpi.main_rank == 0:
+ fs_type = subprocess.check_output(cmd)
+ fs_type = mpi.main_comm.bcast(fs_type, root=0)
+ return fs_type.replace('\n', '')
@classmethod
def is_shared_fs(cls, path):
@@ -58,14 +71,38 @@ class IO(object):
assert (cls._default_path is not None), 'default path has not been set.'
return cls._default_path
+ @classmethod
+ def default_ram_path(cls):
+ """Get the current default path used for io in memory.
+
+ Returns
+ -------
+ string
+ the default value of the current RAM i/o path.
+ """
+ try:
+ import memory_tempfile
+ except ImportError as e:
+ print
+ print e
+ print
+ msg = 'You are trying to use a RAM filesystem but the \'mempory_tempfile\' is not present on your system.'
+ msg += 'Get it from https://gitlab.com/keckj/memory-tempfile.'
+ raise RuntimeError(msg)
+ mt = memory_tempfile.MemoryTempfile(fallback=True)
+ if mt.found_mem_tempdir():
+ return mt.gettempdir()
+ else:
+ return None
+
@staticmethod
- def check_dir(filename, io_rank=0, comm=None):
+ def check_dir(filepath, io_rank=0, comm=None):
"""Check if the directory of 'filename' exists and creates it if not.
Parameters
-----------
- filename : string
- file name with full or relative path
+ filepath : string
+ directory path with full or relative path
io_rank : int
processus rank that does the check.
comm : mpi communicator
@@ -75,7 +112,7 @@ class IO(object):
if (comm is None):
comm = mpi.main_comm
if (comm.Get_rank() == io_rank):
- d = os.path.dirname(filename)
+ d = filepath
if not os.path.exists(d):
os.makedirs(d)
@@ -87,40 +124,35 @@ class IO(object):
-----------
pathdir : string
the new path
-
- Notes
- ------
- pN will be add to path name, N being the number of MPI process
- used for the simulation.
-
"""
assert isinstance(pathdir, str)
- IO._default_path = os.path.join(pathdir,
- 'p' + str(mpi.main_size))
+ IO._default_path = pathdir
IO.check_dir(IO._default_path)
@classmethod
def default_cache_path(cls):
from hysop import get_env
home = os.path.expanduser('~')
- tmp = tempfile.gettempdir()
+ tmp = tempfile.gettempdir()
candidates = [get_env('CACHE_DIR', None), '{}/.cache'.format(home), home, '{}'.format(tmp)]
cpath = None
for c in candidates:
- if (c is None) or (not os.path.isdir(c)) or cls.is_shared_fs(c):
+ if (c is None):
continue
- if (c == home):
+ elif (c == home):
cpath = '{}/.hysop'.format(home)
else:
cpath = '{}/hysop'.format(c)
+ cpath += '/{}'.format(socket.gethostname())
break
if (cpath is None):
- msg='No suitable caching directory was found in {}.'
- msg=msg.format(candidates)
+ msg = 'No suitable caching directory was found in {}.'
+ msg = msg.format(candidates)
raise RuntimeError(msg)
if not os.path.exists(cpath):
try:
- os.makedirs(cpath)
+ if mpi.main_rank == 0:
+ os.makedirs(cpath)
except IOError:
pass
return cpath
@@ -130,17 +162,40 @@ class IO(object):
if IO._cache_path is None:
IO.set_cache_path(IO.default_cache_path())
return IO._cache_path
-
+
+ @classmethod
+ def ram_path(cls):
+ return cls.default_ram_path()
+
+ @classmethod
+ def get_tmp_dir(cls, key):
+ """
+ Create or get an existing temporary directory.
+ """
+ if (key in cls._tmp_dirs):
+ tmp_dir = cls._tmp_dirs[key]
+ else:
+ tmp_dir = tempfile.mkdtemp()
+ cls._tmp_dirs[key] = tmp_dir
+ return tmp_dir
+
+ @classmethod
+ def _remove_tmp_dirs(cls):
+ for f in cls._tmp_dirs.values():
+ shutil.rmtree(f, ignore_errors=True, onerror=None)
+
@classmethod
def set_cache_path(cls, path):
if cls.is_shared_fs(path):
- new_path += '/{}'.format(socket.gethostname())
- msg='\nSpecified cache path \'{}\' is stored on a network filesystem '
- msg += 'which does not correctly support file locking.'
- msg += '\nSetting cache_path to \'{}\'.'
- msg=msg.format(path, new_path)
- warnings.warn(msg, HysopWarning)
- path = new_path
+ hostname = socket.gethostname()
+ if (hostname not in path):
+ new_path = '{}/{}'.format(path, hostname)
+ msg = '\nSpecified cache path \'{}\' is stored on a network filesystem '
+ msg += 'which does not correctly support file locking.'
+ msg += '\nSetting cache_path to \'{}\'.'
+ msg = msg.format(path, new_path)
+ warnings.warn(msg, HysopWarning)
+ path = new_path
IO._cache_path = path
IO.check_dir(path)
@@ -176,25 +231,59 @@ class IO(object):
class IOParams(namedtuple("IOParams", ['filename', 'filepath',
'frequency', 'fileformat',
- 'io_leader', 'visu_leader',
- 'kwds'])):
+ 'dump_times_fp32', 'dump_times_fp64',
+ 'dump_tstart', 'dump_tend', 'dump_func',
+ 'io_leader', 'visu_leader', 'with_last',
+ 'enable_ram_fs', 'force_ram_fs',
+ 'dump_is_temporary', 'postprocess_dump', 'append',
+ 'hdf5_disable_compression', 'hdf5_disable_slicing',
+ 'disk_filepath', 'kwds'])):
"""
A struct to handle I/O files parameters
Parameters
-----------
filename : string
- name of the file (absolute or relative path)
+ Name of the file (absolute or relative path)
filepath : string
- location of the file
+ Location of the file
frequency : int
- frequency of output or input (e.g. every N times steps)
+ Frequency of output or input (e.g. every N times steps)
fileformat : int
- format of the file. See notes for available format. Default=HDF5.
+ Format of the file. See notes for available format. Default=HDF5.
+ dump_times: tuple of floats
+ Extra dump times that should be used to dump in addition to frequency (double precision)
+ dump_tstart: float
+ Start to dump at given time. Defaults to -np.inf (no time constraints).
+ dump_tend: float
+ Stop to dump at given time. Defaults to +np.inf (no time constraints).
+ dump_func: function
+ Generic function to compute the should_dump result.
+ with_last: boolean
+ should dump when iteration is last one
io_leader : int
- rank of the mpi process dealing with the io. Default is 0.
+ Rank of the mpi process dealing with the io. Default is 0.
visu_leader : int
- rank of the mpi process dealing with the graphical io. Default is 0.
+ Rank of the mpi process dealing with the graphical io. Default is 0.
+ enable_ram_fs: bool
+ Instruct the dumper to write directly to RAM, fallback to filepath/filename when this is not possible.
+ force_ram_fs: bool
+ Force the dumper to write directly to RAM, and raise an error when this is not possible (filepath/filename are ignored).
+ Implies enable_ram_fs.
+ dump_is_temporary: bool
+ Instruct the dumper to delete dumped data from disk or RAM after postprocessing script has been called.
+ Implies that a postprocessing script is supplied.
+ postprocess_dump: str
+ Path to a postprocessing script that will be called after dump.
+ See hysop/tools/postprocess_dump.sh for an example of post processing script.
+ hdf5_disable_compression: bool
+ Disable compression for HDF5 outputs (when available).
+ Can be used to accelerate in RAM postprocessing.
+ hdf5_disable_slicing: bool
+ Disable slicing for HDF5 outputs (when available).
+ May reduce performance but avoid hdf5 file fragmentation.
+ append : bool, optional
+ Tell if appended (on xmf files, when using hdf format)
kwds: dict
Custom extra keyword arguments to pass to operators
@@ -207,36 +296,190 @@ class IOParams(namedtuple("IOParams", ['filename', 'filepath',
- :class:`~IO.ASCII`
"""
- def __new__(cls, filename, filepath=None, frequency=1,
- fileformat=None, io_leader=0, visu_leader=0,
- **kwds):
+ def __new__(cls, filename, filepath=None,
+ frequency=1, fileformat=None,
+ dump_times=None, dump_tstart=None, dump_tend=None, dump_func=None,
+ io_leader=0, visu_leader=0, with_last=False,
+ enable_ram_fs=False, force_ram_fs=False,
+ dump_is_temporary=False, postprocess_dump=None,
+ hdf5_disable_compression=False, hdf5_disable_slicing=False,
+ append=False, **kwds):
+
+ dump_tstart = first_not_None(dump_tstart, -np.inf)
+ dump_tend = first_not_None(dump_tend, +np.inf)
+ fileformat = first_not_None(fileformat, IO.HDF5)
+ dump_times = first_not_None(dump_times, ())
+
+ check_instance(filename, str, allow_none=True)
+ check_instance(filepath, str, allow_none=True)
+ check_instance(frequency, (int, long))
+ check_instance(dump_times, tuple, values=(float, np.float64))
+ check_instance(dump_tstart, (int, long, float, np.float64))
+ check_instance(dump_tend, (int, long, float, np.float64))
+ check_instance(io_leader, (int, long))
+ check_instance(visu_leader, (int, long))
+ check_instance(with_last, bool)
+ check_instance(enable_ram_fs, bool)
+ check_instance(force_ram_fs, bool)
+ check_instance(dump_is_temporary, bool)
+ check_instance(postprocess_dump, str, allow_none=True)
+ check_instance(hdf5_disable_compression, bool)
+ check_instance(hdf5_disable_slicing, bool)
+ check_instance(append, bool)
+ if dump_func:
+ assert callable(dump_func), "given function must be callable"
+ assert dump_func.func_code.co_argcount, "given function must take one arg (as simulation object)"
+ frequency = int(frequency)
+ dump_tstart = float(dump_tstart)
+ dump_tend = float(dump_tend)
+ io_leader = int(io_leader)
+ visu_leader = int(visu_leader)
+
+ dump_times_fp64 = tuple(map(np.float64, dump_times))
+ dump_times_fp32 = tuple(map(np.float32, dump_times))
+
+ if force_ram_fs:
+ enable_ram_fs = True
+
+ try:
+ ram_path = IO.ram_path()
+ except RuntimeError:
+ if force_ram_fs:
+ raise
+ else:
+ ram_path = None
- # Filename is absolute path, filepath arg is ignored.
- if os.path.isabs(filename):
- filepath = os.path.dirname(filename)
+ disk_filepath = None
+ if enable_ram_fs and (ram_path is not None):
+ if filename:
+ assert not os.path.isabs(filename), filename
+ disk_filepath = filepath
+ filepath = ram_path
- else:
- if (filepath is not None):
- filename = os.path.join(filepath, filename)
- filepath = os.path.abspath(os.path.dirname(filename))
- else:
+ # Filename is absolute path, filepath arg is ignored.
+ if filename:
+ if os.path.isabs(filename):
filepath = os.path.dirname(filename)
- if filepath == '':
- # Get default output path
- filepath = IO.default_path()
+ else:
+ if (filepath is not None):
filename = os.path.join(filepath, filename)
+ filepath = os.path.abspath(os.path.dirname(filename))
else:
- filepath = os.path.abspath(filepath)
- filename = os.path.join(filepath,
- os.path.basename(filename))
- if (fileformat is None):
- fileformat = IO.HDF5
+ filepath = os.path.dirname(filename)
+ if filepath == '':
+ # Get default output path
+ filepath = IO.default_path()
+ filename = os.path.join(filepath, filename)
+ else:
+ filepath = os.path.abspath(filepath)
+ filename = os.path.join(filepath,
+ os.path.basename(filename))
+ elif filepath:
+ filepath = os.path.abspath(filepath)
+ else:
+ filepath = IO.default_path()
+ IO.check_dir(filepath)
+
+ if (disk_filepath is None):
+ disk_filepath = filepath
+
+ if dump_is_temporary:
+ msg = 'Dump is temporary but no postprocessing script has been supplied'
+ assert (postprocess_dump is not None), msg
- IO.check_dir(filename)
return super(IOParams, cls).__new__(cls, filename, filepath,
- frequency, fileformat,
- io_leader, visu_leader,
- kwds)
+ frequency, fileformat,
+ dump_times_fp32, dump_times_fp64,
+ dump_tstart, dump_tend, dump_func,
+ io_leader, visu_leader, with_last,
+ enable_ram_fs, force_ram_fs,
+ dump_is_temporary, postprocess_dump, append,
+ hdf5_disable_compression, hdf5_disable_slicing,
+ disk_filepath, kwds)
+
+ def should_dump(self, simulation):
+ if (self.dump_func is not None):
+ return self.dump_func(simulation)
+ frequency = self.frequency
+ t = simulation.t()
+ dump = (frequency >= 0) and (self.with_last and simulation._next_is_last)
+ if (t < self.dump_tstart - simulation.tol) or (t > self.dump_tend + simulation.tol):
+ return dump
+ if (frequency >= 0) and simulation.is_time_of_interest:
+ if isinstance(t, np.float32):
+ dump |= (t in self.dump_times_fp32)
+ elif isinstance(t, np.float64):
+ dump |= (t in self.dump_times_fp64)
+ else:
+ raise NotImplementedError(type(t))
+ if (frequency > 0):
+ dump |= ((simulation.current_iteration % frequency) == 0)
+ return dump
+
+ def clone(self, **kwds):
+ keys = ('filename',
+ 'frequency', 'fileformat',
+ 'dump_times', 'dump_tstart', 'dump_tend', 'dump_func',
+ 'io_leader', 'visu_leader', 'with_last',
+ 'enable_ram_fs', 'force_ram_fs',
+ 'dump_is_temporary', 'postprocess_dump',
+ 'hdf5_disable_compression', 'hdf5_disable_slicing',
+ 'append', 'kwds')
+
+ diff = set(kwds.keys()).difference(keys)
+ if diff:
+ msg = 'Unknown parameters {} for class {}.'.format(diff, self.__class__.__name__)
+ raise ValueError(msg)
+
+ all_kwds = {}
+ for k in keys:
+ if (k == 'kwds'):
+ for (k, v) in kwds.get(k, getattr(self, k)).iteritems():
+ all_kwds[k] = v
+ else:
+ all_kwds[k] = kwds.get(k, getattr(self, k))
+
+ all_kwds['filepath'] = kwds.get('filepath', getattr(self, 'disk_filepath'))
+ return IOParams(**all_kwds)
+
+ @property
+ def dump_times(self):
+ return self.dump_times_fp64
+
+ def __str__(self):
+ return self.to_string()
+
+ def to_string(self, prefix=''):
+ ss =\
+ '''filename: {}
+filepath: {}
+fileformat: {}
+frequency: {}
+dump_times: {}
+dump_tstart: {}
+dump_func: {}
+dump_tend: {}
+io_leader: {}
+visu_leader: {}
+enable_ram_fs: {}
+force_ram_fs: {}
+dump_is_tmp: {}
+post_process: {}
+hdf5_no_compr: {}
+hdf5_no_slice: {}
+append: {}
+extra_kwds: {}'''.format(
+ self.filename, self.filepath, self.fileformat,
+ self.frequency, self.dump_times, self.dump_tstart, self.dump_tend, self.dump_func,
+ self.io_leader, self.visu_leader,
+ self.enable_ram_fs, self.force_ram_fs,
+ self.dump_is_temporary,
+ self.postprocess_dump,
+ self.hdf5_disable_compression,
+ self.hdf5_disable_slicing,
+ self.append,
+ self.kwds)
+ return prefix+('\n'+prefix).join(ss.split('\n'))
class Writer(object):
@@ -257,6 +500,7 @@ class Writer(object):
result : buffer is written into r.dat
"""
+
def __init__(self, io_params, buffshape=None, mpi_params=None,
safe_io=True):
"""
@@ -264,11 +508,11 @@ class Writer(object):
Parameters
----------
io_params : hysop.tools.io_utils.IOParams
- setup for file ouput (name, location ...)
+ Setup for file ouput (name, location ...)
buffshape : tuple
2D numpy.array.shape like tuple, shape of the output/input buffer.
mpi_params : hysop.tools.parameters.MPIParams
- mpi setup (comm that owns the writer)
+ Mpi setup (comm that owns the writer)
safe_io : boolean
True --> open/close file everytime data are written.
False --> open at init and close during finalize.
@@ -293,7 +537,7 @@ class Writer(object):
self.mpi_params = mpi_params
# check if output dir exists, create it if not.
- IO.check_dir(self.io_params.filename, self.io_params.io_leader,
+ IO.check_dir(self.io_params.filepath, self.io_params.io_leader,
self.mpi_params.comm)
# Shape of the output buffer (must be a 2D numpy array)
@@ -341,17 +585,42 @@ class Writer(object):
return rk == self.io_params.io_leader and \
(num % self.io_params.frequency) == 0
+ def _ft_write(self):
+ """Write a two-dim. NumPy array a in tabular form to fileobj."""
+ # Function taken from scitools
+ # fastest version (of the write family of functions) so far...
+ # written by Mario Pernici <Mario.Pernici@mi.infn.it>
+ fileobj, a = self._file, self.buffer
+ if len(a.shape) != 2:
+ raise TypeError("a 2D array is required, shape now is "+str(a.shape))
+ N = 512
+ shape0 = a.shape[0]
+ shape1 = a.shape[1]
+ str_fmt = '%g\t'*(shape1 - 1) + '%g\n'
+ # use a big format string
+ str_fmt_N = str_fmt * N
+ for i in xrange(shape0/N):
+ a1 = a[i:i+N, :]
+ # put a1 in 1D array form; ravel better than reshape for
+ # non-contiguous arrays.
+ a1 = ravel(a1)
+ fileobj.write(str_fmt_N % tuple(a1))
+ for i in range(shape0 - shape0 % N, shape0):
+ fileobj.write(str_fmt % tuple(a[i]))
+
def _fullwrite(self):
"""open, write and close"""
- import scitools.filetable as ft
+ #import scitools.filetable as ft
self._file = open(self.io_params.filename, 'a')
- ft.write(self._file, self.buffer)
+ #ft.write(self._file, self.buffer)
+ self._ft_write()
self._file.close()
def _partialwrite(self):
"""just write, no open, nor close"""
- import scitools.filetable as ft
- ft.write(self._file, self.buffer)
+ #import scitools.filetable as ft
+ #ft.write(self._file, self.buffer)
+ self._ft_write()
def finalize(self):
"""close, if required"""
@@ -387,7 +656,7 @@ class XMF(object):
@staticmethod
def prepare_grid_attributes(dataset_names,
- resolution, origin, step):
+ resolution, origin, step, joinrkfiles=None):
"""
Prepare XDMF header as a string.
@@ -398,9 +667,7 @@ class XMF(object):
resolution: 3d tuple
origin: 3d tuple
step: 3d tuple
- subset : :class:`hysop.domain.subsets.Subset`, optional
- to define a grid only on this subset.
- If None, grid on the whole domain (from topo)
+ joinrkfiles : (optional)
Returns:
--------
@@ -408,7 +675,9 @@ class XMF(object):
the xml-like header formattable with the following keywords:
niteration : iteration number
time: time in seconds
- filename: target file name
+ filename: target file name, in sequential or with parallel hdf5 support
+ filename0, ... filenameN : target file names for each rank 0 to N, in parallel without HDF5 parallel support
+ resolution0, ... resolutionN : local resolutions for each rank 0 to N, in parallel without HDF5 parallel support
"""
# The header (xml-like), saved in a string.
@@ -416,7 +685,7 @@ class XMF(object):
xml_grid = ""
topo_type = "3DCORECTMesh"
geo_type = "ORIGIN_DXDYDZ"
- xml_grid += " <Grid Name=\"Iteration {}\"".format('{niteration:03d}')
+ xml_grid += " <Grid Name=\"Iteration {}\"".format('{niteration:06d}')
xml_grid += " GridType=\"Uniform\">\n"
xml_grid += " <Time Value=\"{}\" />\n".format('{time}')
xml_grid += " <Topology TopologyType=\"" + str(topo_type) + "\""
@@ -437,13 +706,32 @@ class XMF(object):
xml_grid += " <Attribute Name=\""
xml_grid += name + "\""
xml_grid += " AttributeType=\"Scalar\" Center=\"Node\">\n"
- xml_grid += " <DataItem Dimensions=\""
- xml_grid += XMF._list_format(resolution) + " \""
- xml_grid += " NumberType=\"Float\" Precision=\"8\" Format=\"HDF\""
- xml_grid += " Compression=\"Raw\">\n" #
- xml_grid += " {filename}"
- xml_grid += ":/" + name
- xml_grid += "\n </DataItem>\n"
+ if joinrkfiles is None:
+ xml_grid += " <DataItem Dimensions=\""
+ xml_grid += XMF._list_format(resolution) + " \""
+ xml_grid += " NumberType=\"Float\" Precision=\"8\" Format=\"HDF\""
+ xml_grid += " Compression=\"Raw\">\n" #
+ xml_grid += " {filename}"
+ xml_grid += ":/" + name
+ xml_grid += "\n </DataItem>\n"
+ else:
+ xml_grid += " <DataItem Dimensions=\""
+ xml_grid += XMF._list_format(resolution) + " \""
+ xml_grid += " ItemType=\"Function\" Function=\"JOIN("
+ xml_grid += " ; ".join("$"+str(i) for i in joinrkfiles)
+ xml_grid += ")\">\n"
+ for i in joinrkfiles:
+ xml_grid += " <DataItem Dimensions=\""
+ xml_grid += "{resolution"+str(i)+"}" + " \""
+ xml_grid += " NumberType=\"Float\" Precision=\"8\" Format=\"HDF\""
+ xml_grid += " Compression=\"Raw\">\n" #
+ xml_grid += " {filename"+str(i)+"}"
+ xml_grid += ":/" + name
+ xml_grid += "\n </DataItem>\n"
+ xml_grid += " </DataItem>\n"
xml_grid += " </Attribute>\n"
xml_grid += " </Grid>\n"
return xml_grid
+
+
+atexit.register(IO._remove_tmp_dirs)
diff --git a/hysop/tools/method_utils.py b/hysop/tools/method_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..7aa96662d68147142b70c3d8eec04e64355bcd2d
--- /dev/null
+++ b/hysop/tools/method_utils.py
@@ -0,0 +1,78 @@
+
+from hysop.constants import SpaceDiscretization
+from hysop.tools.types import check_instance, to_list, first_not_None, InstanceOf
+from hysop.tools.decorators import debug
+from hysop.numerics.interpolation.polynomial import PolynomialInterpolator, PolynomialInterpolation
+
+class SpaceDiscretizationMethod(object):
+ """
+ Operator helper to handle space discretization method.
+ """
+ __default_method = {
+ SpaceDiscretization: 2
+ }
+
+ __available_methods = {
+ SpaceDiscretization: (InstanceOf(int), InstanceOf(SpaceDiscretization)),
+ }
+
+ @classmethod
+ def default_method(cls):
+ dm = super(SpaceDiscretizationMethod, cls).default_method()
+ dm.update(cls.__default_method)
+ return dm
+
+ @classmethod
+ def available_methods(cls):
+ am = super(SpaceDiscretizationMethod, cls).available_methods()
+ am.update(cls.__available_methods)
+ return am
+
+ @debug
+ def handle_method(self,method):
+ super(SpaceDiscretizationMethod, self).handle_method(method)
+ sdm = method.pop(SpaceDiscretization)
+ if isinstance(sdm, int):
+ sd = sdm
+ elif isinstance(sdm, SpaceDiscretization):
+ assert str(sdm).startswith('FDC')
+ sd = int(str(sdm)[3:])
+ else:
+ raise NotImplementedError(sdm)
+ self.space_discretization_method = sdm
+ self.space_discretization = sd
+
+
+class PolynomialInterpolationMethod(SpaceDiscretizationMethod):
+ """
+ Operator helper to handle polynomial interpolation method.
+ """
+ __default_method = {
+ PolynomialInterpolator: PolynomialInterpolation.LINEAR,
+ }
+
+ __available_methods = {
+ PolynomialInterpolator: InstanceOf(PolynomialInterpolation),
+ }
+
+ @classmethod
+ def default_method(cls):
+ dm = super(PolynomialInterpolationMethod, cls).default_method()
+ dm.update(cls.__default_method)
+ return dm
+
+ @classmethod
+ def available_methods(cls):
+ am = super(PolynomialInterpolationMethod, cls).available_methods()
+ am.update(cls.__available_methods)
+ return am
+
+ @debug
+ def handle_method(self,method):
+ super(PolynomialInterpolationMethod, self).handle_method(method)
+ fd = self.space_discretization
+ pi = method.pop(PolynomialInterpolator)
+ self.polynomial_interpolation_method = pi
+ self.polynomial_interpolator = PolynomialInterpolator.build_interpolator(pi=pi, fd=fd, dim=self.dim)
+
+
diff --git a/hysop/tools/misc.py b/hysop/tools/misc.py
index ba6ee344e8fa579e7642c2c642c87af2a74196b4..562f4b9f4df2c09c39f5b2aa1a3aa3155ab218d9 100644
--- a/hysop/tools/misc.py
+++ b/hysop/tools/misc.py
@@ -265,11 +265,11 @@ class WorkSpaceTools(object):
"""
if dtype is HYSOP_REAL:
assert (HYSOP_REAL is np.float32 and s == 4) or \
- (HYSOP_REAL is np.float64 and s == 8)
+ (HYSOP_REAL is np.float64 and s == 8)
elif dtype is HYSOP_INTEGER:
assert (HYSOP_INTEGER is np.int16 and s == 2) or \
- (HYSOP_INTEGER is np.int32 and s == 4) or \
- (HYSOP_INTEGER is np.int64 and s == 8)
+ (HYSOP_INTEGER is np.int32 and s == 4) or \
+ (HYSOP_INTEGER is np.int64 and s == 8)
@staticmethod
def find_common_workspace(operators, array_type='rwork'):
diff --git a/hysop/tools/mpi_utils.py b/hysop/tools/mpi_utils.py
index ac8528b8422bd1d0f96c7f6b621a4cf8f60f7f18..0fab45c3d07df2dca141b0d1021a02e6cb2d5302 100644
--- a/hysop/tools/mpi_utils.py
+++ b/hysop/tools/mpi_utils.py
@@ -47,3 +47,33 @@ def dtype_to_mpi_type(dtype):
msg='Unknown dtype {}.'.format(dtype)
raise NotImplementedError(msg)
return mpi_types[dtype]
+
+def order_to_mpi_order(order):
+ from hysop.constants import MemoryOrdering
+ if (order in 'cC') or (order==MemoryOrdering.C_CONTIGUOUS) or (order==MPI.ORDER_C):
+ return MPI.ORDER_C
+ elif (order in 'fF') or (order==MemoryOrdering.F_CONTIGUOUS) or (order==MPI.ORDER_F):
+ return MPI.ORDER_F
+ else:
+ msg='Unknown value of type {}.'.format(type(order))
+ raise ValueError(msg)
+
+def get_mpi_order(data):
+ from hysop.core.arrays.array import Array
+ if isinstance(data, Array):
+ is_c_contiguous = data.is_c_contiguous
+ is_f_contiguous = data.is_fortran_contiguous
+ else:
+ # assume numpy like interface
+ is_c_contiguous = data.flags['C_CONTIGUOUS']
+ is_f_contiguous = data.flags['F_CONTIGUOUS']
+ if is_c_contiguous:
+ return MPI.ORDER_C
+ elif is_f_contiguous:
+ return MPI.ORDER_F
+ else:
+ msg='Data is neither C, nor Fortran contiguous.'
+ raise ValueError(msg)
+
+
+
diff --git a/hysop/tools/numba_utils.py b/hysop/tools/numba_utils.py
index 069ed7caa760adbb7136ed538f92a97cf47baf23..58a73f603acb00a0e61227e4781e82a6fdbbdae2 100644
--- a/hysop/tools/numba_utils.py
+++ b/hysop/tools/numba_utils.py
@@ -1,8 +1,15 @@
-import numba as nb
import numpy as np
+from hysop import __DEFAULT_NUMBA_TARGET__
from hysop.core.arrays.array import Array
+try:
+ import numba as nb
+ from numba import prange
+ HAS_NUMBA=True
+except ImportError:
+ HAS_NUMBA=False
+
def make_numba_signature(*args, **kwds):
raise_on_cl_array = kwds.pop('raise_on_cl_array', True)
if kwds:
@@ -93,3 +100,169 @@ def make_numba_signature(*args, **kwds):
numba_args += (na,)
return nb.void(*numba_args), ','.join(numba_layout)
+
+
+def bake_numba_copy(dst, src, target=None):
+ if (target is None):
+ target = __DEFAULT_NUMBA_TARGET__
+ signature, layout = make_numba_signature(dst, src)
+ if (dst.ndim == 1):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def copy(dst, src):
+ for i in xrange(0, dst.shape[0]):
+ dst[i] = src[i]
+ elif (dst.ndim == 2):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def copy(dst, src):
+ for i in prange(0, dst.shape[0]):
+ for j in xrange(0, dst.shape[1]):
+ dst[i,j] = src[i,j]
+ elif (dst.ndim == 3):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def copy(dst, src):
+ for i in prange(0, dst.shape[0]):
+ for j in prange(0, dst.shape[1]):
+ for k in xrange(0, dst.shape[2]):
+ dst[i,j,k] = src[i,j,k]
+ elif (dst.ndim == 4):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def copy(dst, src):
+ for i in prange(0, dst.shape[0]):
+ for j in prange(0, dst.shape[1]):
+ for k in prange(0, dst.shape[2]):
+ for l in xrange(0, dst.shape[3]):
+ dst[i,j,k,l] = src[i,j,k,l]
+ else:
+ raise NotImplementedError(dst.ndim)
+ def _exec_copy(copy=copy, dst=dst, src=src):
+ copy(dst,src)
+ return _exec_copy
+
+
+def bake_numba_accumulate(dst, src, target=None):
+ if (target is None):
+ target = __DEFAULT_NUMBA_TARGET__
+ signature, layout = make_numba_signature(dst, src)
+ if (dst.ndim == 1):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def accumulate(dst, src):
+ for i in xrange(0, dst.shape[0]):
+ dst[i] += src[i]
+ elif (dst.ndim == 2):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def accumulate(dst, src):
+ for i in prange(0, dst.shape[0]):
+ for j in xrange(0, dst.shape[1]):
+ dst[i,j] += src[i,j]
+ elif (dst.ndim == 3):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def accumulate(dst, src):
+ for i in prange(0, dst.shape[0]):
+ for j in prange(0, dst.shape[1]):
+ for k in xrange(0, dst.shape[2]):
+ dst[i,j,k] += src[i,j,k]
+ elif (dst.ndim == 4):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def accumulate(dst, src):
+ for i in prange(0, dst.shape[0]):
+ for j in prange(0, dst.shape[1]):
+ for k in prange(0, dst.shape[2]):
+ for l in xrange(0, dst.shape[3]):
+ dst[i,j,k,l] += src[i,j,k,l]
+ else:
+ raise NotImplementedError(dst.ndim)
+ def _exec_accumulate(accumulate=accumulate, dst=dst, src=src):
+ accumulate(dst,src)
+ return _exec_accumulate
+
+
+def bake_numba_transpose(src, dst, axes, target=None):
+ # inefficient permutations
+
+ if (target is None):
+ target = __DEFAULT_NUMBA_TARGET__
+ signature, layout = make_numba_signature(dst, src)
+
+ assert src.ndim == dst.ndim
+ assert dst.shape == tuple(src.shape[i] for i in axes)
+ assert dst.dtype == src.dtype
+ ndim = src.ndim
+
+ def noop(dst, src):
+ pass
+
+ if (ndim == 1):
+ transpose = noop
+ elif (ndim == 2):
+ if axes == (0,1):
+ transpose == noop
+ elif axes == (1,0):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def transpose(dst, src):
+ for i in prange(0, src.shape[0]):
+ for j in xrange(0, src.shape[1]):
+ dst[j,i] = src[i,j]
+ else:
+ raise NotImplementedError
+ elif (ndim == 3):
+ if axes == (0,1,2):
+ transpose == noop
+ elif axes == (0,2,1):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def transpose(dst, src):
+ for i in prange(0, src.shape[0]):
+ for j in prange(0, src.shape[1]):
+ for k in xrange(0, src.shape[2]):
+ dst[i,k,j] = src[i,j,k]
+ elif axes == (1,0,2):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def transpose(dst, src):
+ for i in prange(0, src.shape[0]):
+ for j in prange(0, src.shape[1]):
+ for k in xrange(0, src.shape[2]):
+ dst[j,i,k] = src[i,j,k]
+ elif axes == (1,2,0):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def transpose(dst, src):
+ for i in prange(0, src.shape[0]):
+ for j in prange(0, src.shape[1]):
+ for k in xrange(0, src.shape[2]):
+ dst[j,k,i] = src[i,j,k]
+ elif axes == (2,1,0):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def transpose(dst, src):
+ for i in prange(0, src.shape[0]):
+ for j in prange(0, src.shape[1]):
+ for k in xrange(0, src.shape[2]):
+ dst[k,j,i] = src[i,j,k]
+ elif axes == (2,0,1):
+ @nb.guvectorize([signature], layout,
+ target=target, nopython=True, cache=True)
+ def transpose(dst, src):
+ for i in prange(0, src.shape[0]):
+ for j in prange(0, src.shape[1]):
+ for k in xrange(0, src.shape[2]):
+ dst[k,i,j] = src[i,j,k]
+ else:
+ raise NotImplementedError(axes)
+ else:
+ raise NotImplementedError(ndim)
+
+ def _exec_transpose(transpose=transpose, dst=dst, src=src):
+ transpose(dst,src)
+ return _exec_transpose
+
+
diff --git a/hysop/tools/parameters.py b/hysop/tools/parameters.py
index c00400c3bd3e30fd44423a7d204a75d97a2684c6..b59b80b8993904e0e7e0158e3b1c60275fc303a5 100755
--- a/hysop/tools/parameters.py
+++ b/hysop/tools/parameters.py
@@ -45,11 +45,12 @@ class MPIParams(namedtuple('MPIParams', ['comm', 'size', 'task_id',
task_id=HYSOP_DEFAULT_TASK_ID,
rank=main_rank,
on_task=True):
- if comm != MPI.COMM_NULL:
+ if (comm != MPI.COMM_NULL):
rank = comm.Get_rank()
size = comm.Get_size()
else:
rank = MPI.UNDEFINED
+ size = MPI.UNDEFINED
return super(MPIParams, cls).__new__(cls, comm, size, task_id,
rank, on_task)
@@ -106,7 +107,7 @@ class CartesianDiscretization(namedtuple("CartesianDiscretization",
lboundaries = npw.empty(shape=(resolution.size,), dtype=object)
lboundaries[...] = BoundaryCondition.PERIODIC
rboundaries = lboundaries.copy()
-
+
check_instance(lboundaries, npw.ndarray, dtype=object,
size=resolution.size, values=BoundaryCondition,
allow_none=True)
diff --git a/hysop/tools/plotDrag.py b/hysop/tools/plotDrag.py
index 58a49e065c6f2b7ac1a825db0800d29d12d6eabf..e10269c119b1e08c0de01b489351b4be49697f3e 100644
--- a/hysop/tools/plotDrag.py
+++ b/hysop/tools/plotDrag.py
@@ -1,40 +1,86 @@
-import scitools.easyviz as sea
import numpy as np
-import scitools.filetable as ft
+#import scitools.filetable as ft
import matplotlib.pyplot as plt
+
+def _ft_read(fileobj, commentchar='#'):
+ """
+ Load a table with numbers into a two-dim. NumPy array.
+ @param fileobj: open file object.
+ @param commentchar: lines starting with commentchar are skipped
+ (a blank line is an array data delimiter and stops reading).
+ @return: two-dimensional (row-column) NumPy array.
+ """
+ # Function taken from scitools
+ # based on a version by Mario Pernici <Mario.Pernici@mi.infn.it>
+ location = fileobj.tell()
+ import re
+ commentchar = re.escape(commentchar)
+ while True:
+ line = fileobj.readline()
+ if not line:
+ break # end of file
+ elif line.isspace():
+ break # blank line
+ elif re.match(commentchar, line):
+ continue # treat next line
+ else:
+ break
+
+ shape1 = len(line.split())
+ if shape1 == 0:
+ return None
+ fileobj.seek(location)
+
+ blankline = re.compile('\n\s*\n', re.M)
+ commentline = re.compile('^%s[^\n]*\n' % commentchar, re.M)
+ filestr = fileobj.read()
+ # remove lines after a blank line
+ m = re.search(blankline, filestr)
+ if m:
+ filestr = filestr[:m.start()+1]
+ # skip lines starting with the comment character
+ filestr = re.sub(commentline, '', filestr)
+ a = [float(x) for x in filestr.split()]
+ data = np.array(a)
+ data.shape = (len(a)/shape1, shape1)
+ return data
+
+
# Lambda comparison
# Results in Softs/MethodesParticulaires/Resultats_simu/Comp_lmanda
-fileDt=(('drag129_fixe'),('drag129_var'),('drag65_fixe'),('drag65_var'))
-fileListLayer=(('drag_01'),('drag_02'),('drag_03'))
-fileListLambda=(('drag_05'),('drag_06'),('drag_07'),('drag_09'),('drag_11'))
-fileListLambda2=(('d129_4'),('d129_5'),('drag_06'),('d129_7'),('d129_12'))
-fileListLambda3=(('d129_5'),('d257_5'))#,('d257_7'))
-fileListLambda4=(('drag_06'),('d257_6'))#,('d257_7'))
-
-legendLayer=('layer=0.1', 'layer=0.2','layer=0.3')
-legendLambda=('lambda=1e5','lambda=1e6','lambda=1e7','lambda=1e9','lambda=1e11', 'Ref from Folke : 0.6726')
-legendLambda2=('lambda=1e4','lambda=1e5','lambda=1e6','lambda=1e7','lambda=1e12','Ref from Folke : 0.6726')
-legendLambda3=('lambda=1e5','257 - lambda=1e5','Ref from Folke : 0.6726')
-legendLambda3=('lambda=1e6','257 - lambda=1e6','Ref from Folke : 0.6726')
+fileDt = (('drag129_fixe'), ('drag129_var'), ('drag65_fixe'), ('drag65_var'))
+fileListLayer = (('drag_01'), ('drag_02'), ('drag_03'))
+fileListLambda = (('drag_05'), ('drag_06'), ('drag_07'), ('drag_09'), ('drag_11'))
+fileListLambda2 = (('d129_4'), ('d129_5'), ('drag_06'), ('d129_7'), ('d129_12'))
+fileListLambda3 = (('d129_5'), ('d257_5')) # ,('d257_7'))
+fileListLambda4 = (('drag_06'), ('d257_6')) # ,('d257_7'))
+
+legendLayer = ('layer=0.1', 'layer=0.2', 'layer=0.3')
+legendLambda = ('lambda=1e5', 'lambda=1e6', 'lambda=1e7',
+ 'lambda=1e9', 'lambda=1e11', 'Ref from Folke : 0.6726')
+legendLambda2 = ('lambda=1e4', 'lambda=1e5', 'lambda=1e6',
+ 'lambda=1e7', 'lambda=1e12', 'Ref from Folke : 0.6726')
+legendLambda3 = ('lambda=1e5', '257 - lambda=1e5', 'Ref from Folke : 0.6726')
+legendLambda3 = ('lambda=1e6', '257 - lambda=1e6', 'Ref from Folke : 0.6726')
plt.hold('off')
plt.xlabel('time')
plt.hold('on')
plt.ylabel('drag')
-plt.axis([0,70,0.3,1])
+plt.axis([0, 70, 0.3, 1])
plt.grid('on')
for filename in fileListLambda3:
- print ("my file is ", filename)
- file=open(filename)
- table=ft.read(file)
- time=table[:,0]
- drag=table[:,1]
- file.close()
- plt.plot(time,drag,'--')
-plt.axhline(y=0.6726,xmin=0,xmax=22,color='r')
+ print ("my file is ", filename)
+ file = open(filename)
+ table = _ft_read(file)
+ time = table[:, 0]
+ drag = table[:, 1]
+ file.close()
+ plt.plot(time, drag, '--')
+plt.axhline(y=0.6726, xmin=0, xmax=22, color='r')
plt.legend(legendLambda3)
-#plt.hold('on')
+# plt.hold('on')
plt.savefig('DragRe133_CompLambda3.pdf')
plt.show()
diff --git a/hysop/tools/postprocess_dump.sh b/hysop/tools/postprocess_dump.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b55479ad73b446f56ba6af9fdca890acb438b87e
--- /dev/null
+++ b/hysop/tools/postprocess_dump.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# Example of I/O post processing script.
+# Input arguments are:
+# OP_NAME
+# ACTUAL_FILEPATH DISK_FILEPATH
+# XMF_FILE HDF5_FILE
+# IS_TMP ITERATION TIME
+# See example hysop/examples/example_utils.py interface and '--dump-postprocess' argument.
+
+set -e
+if [ "$#" -ne 8 ]; then
+ echo "Script expected 8 parameters."
+ exit 1
+fi
+
+OP_NAME=${1}
+ACTUAL_FILEPATH=${2}
+DISK_FILEPATH=${3}
+XMF_FILE=${4}
+HDF5_FILE=${5}
+IS_TMP=${6}
+ITERATION=${7}
+TIME=${8}
+
+echo ">Successfully postprocessed dump '$OP_NAME', iteration ${ITERATION} at t=${TIME}."
+exit 0
diff --git a/hysop/tools/postprocess_kernel.sh b/hysop/tools/postprocess_kernel.sh
new file mode 100755
index 0000000000000000000000000000000000000000..61ed13cc18646b199802a3cf7c6aaf9fd46cd835
--- /dev/null
+++ b/hysop/tools/postprocess_kernel.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+# Example of autotuner post processing script.
+# Input arguments are:
+# FILE_BASENAME FROM_CACHE
+# AUTOTUNER_DUMP_DIR AUTOTUNER_NAME KERNEL_NAME
+# MEAN_EXECUTION_TIME_NS MIN_EXECUTION_TIME_NS MAX_EXECUTION_TIME_NS
+# KERNEL_SOURCE_FILE KERNEL_ISOLATION_FILE KERNEL_HASH_LOGS
+# VENDOR_NAME DEVICE_NAME
+# WORK_SIZE WORK_LOAD
+# GLOBAL_WORK_SIZE LOCAL_WORK_SIZE
+# EXTRA_PARAMETERS EXTRA_KWDS_HASH SRC_HASH
+# See example hysop/examples/example_utils.py interface and '--autotuner-postprocess-kernels' argument.
+
+set -e
+if [ "$#" -ne 20 ]; then
+ echo "Script expected 20 parameters."
+ exit 1
+fi
+
+FILE_BASENAME=${1}
+FROM_CACHE=${2}
+AUTOTUNER_DUMP_DIR=${3}
+AUTOTUNER_NAME=${4}
+KERNEL_NAME=${5}
+MEAN_EXECUTION_TIME_NS=${6}
+MIN_EXECUTION_TIME_NS=${7}
+MAX_EXECUTION_TIME_NS=${8}
+KERNEL_SOURCE_FILE=${9}
+KERNEL_ISOLATION_FILE=${10}
+KERNEL_HASH_LOGS_FILE=${11}
+VENDOR_NAME=${12}
+DEVICE_NAME=${13}
+WORK_SIZE=${14}
+WORK_LOAD=${15}
+GLOBAL_WORK_SIZE=${16}
+LOCAL_WORK_SIZE=${17}
+EXTRA_PARAMETERS=${18}
+EXTRA_KWDS_HASH=${19}
+SRC_HASH=${20}
+
+echo "Successfully postprocessed kernel '$AUTOTUNER_NAME'."
+exit 0
diff --git a/hysop/tools/problem2dot.py b/hysop/tools/problem2dot.py
deleted file mode 100644
index fb5f112c6d702fe7f980a16e3f1259f5809a65bc..0000000000000000000000000000000000000000
--- a/hysop/tools/problem2dot.py
+++ /dev/null
@@ -1,134 +0,0 @@
-"""Converts a problem instance into a 'dot' graph.
-
-"""
-from hysop.operator.advection import Advection
-from hysop.operator.redistribute import Redistribute, RedistributeInter
-from hysop.core.mpi import main_rank
-import pydot
-colors = [
- "#dc322f",
- "#859900",
- "#268bd2",
- "#b58900",
- "#d33682",
- "#2aa198",
- "#cb4b16",
- "#6c71c4",
- "#ffffff"]
-
-
-def get_shape(op):
- """Return graph shape depending on the type of mpi communicator"""
- if isinstance(op, Redistribute) or isinstance(op, RedistributeInter):
- return 'octagon'
- else:
- return 'box'
-
-
-def to_dot(pb, filename='graph.pdf'):
- """Convert problem into graph using dot and
- save result into a pdf
-
- Parameters
- ----------
- pb : :class:`~hysop.problem.problem.Problem`
- filename : string, optional
- output file, default = graph.pdf
- """
- if main_rank == 0:
- all_ops = []
- all_vars = []
- tasks = []
- for op in pb.operators:
- if isinstance(op, Advection) and op.advecDir is not None:
- for ad_op in op.advecDir:
- all_ops.append(ad_op)
- tasks.append(ad_op.task_id)
- else:
- all_ops.append(op)
- tasks.append(op.task_id)
- for v in op.variables:
- all_vars.append(v)
- all_vars = list(set(all_vars))
- tasks = list(set(tasks))
-
- all_edges = {}
- for op_id, op in enumerate(all_ops):
- for v in op.input:
- out = None
- for req in op.wait_list():
- if v in req.output:
- out = req
- i = op_id - 1
- while out is None:
- if v in all_ops[i].output:
- if isinstance(all_ops[i], RedistributeInter):
- if op == all_ops[i].opTo:
- out = all_ops[i]
- else:
- if not isinstance(all_ops[i], Redistribute):
- out = all_ops[i]
- i = i - 1
- if (out, op) in all_edges.keys():
- all_edges[(out, op)].append(v.name)
- else:
- all_edges[(out, op)] = [v.name]
-
- graph = pydot.Dot(pb.__class__.__name__, graph_type='digraph')
- sub_graphs = {}
- nodes = {}
- edges = {}
- from_start = {}
- to_end = {}
- # Start iteration node
- G_start = pydot.Node(-1, label="START", shape='none')
- graph.add_node(G_start)
- # End iteration node
- G_end = pydot.Node(-2, label="END", shape='none')
- graph.add_node(G_end)
- if len(tasks) > 1:
- for t in tasks:
- if t is None:
- c = 'white'
- else:
- c = colors[tasks.index(t)]
- sub_graphs[t] = pydot.Subgraph('cluster_' + str(t),
- label='',
- color=c)
- else:
- sub_graphs[tasks[0]] = graph
- for op_id, op in enumerate(all_ops):
- label = 'Op' + str(op_id) + '_' + op.name
- nodes[op] = pydot.Node(op_id, label=label,
- shape=get_shape(op))
- sub_graphs[op.task_id].add_node(nodes[op])
- for e in all_edges.keys():
- if all_ops.index(e[0]) < all_ops.index(e[1]):
- edges[e] = pydot.Edge(nodes[e[0]], nodes[e[1]],
- label='_'.join(list(set(all_edges[e]))),
- color='black')
- graph.add_edge(edges[e])
- else:
- if (e[0], G_end) in to_end.keys():
- to_end[(e[0], G_end)] += all_edges[e]
- else:
- to_end[(e[0], G_end)] = all_edges[e]
- if (G_start, e[1]) in from_start.keys():
- from_start[(G_start, e[1])] += all_edges[e]
- else:
- from_start[(G_start, e[1])] = all_edges[e]
- for e in to_end.keys():
- edges[e] = pydot.Edge(nodes[e[0]], e[1],
- label='_'.join(list(set(to_end[e]))),
- color='black')
- graph.add_edge(edges[e])
- for e in from_start.keys():
- edges[e] = pydot.Edge(e[0], nodes[e[1]],
- label='_'.join(list(set(from_start[e]))),
- color='black')
- graph.add_edge(edges[e])
- if len(tasks) > 1:
- for t in tasks:
- graph.add_subgraph(sub_graphs[t])
- graph.write(filename + '.dot', format='dot')
- graph.write(filename, format=filename.split('.')[-1])
diff --git a/hysop/tools/profiler.py b/hysop/tools/profiler.py
index f67258199918f7a883c823485cf0bdc437859fdf..9a47b1d59b9f682a848b50436fabf1034fa8d42a 100644
--- a/hysop/tools/profiler.py
+++ b/hysop/tools/profiler.py
@@ -50,9 +50,9 @@ class FProfiler(object):
def __str__(self):
if self.nb_calls > 0:
- s = '{} ncalls={}, total={}, mean={}'.format(self.fname,
+ s = '{} ncalls={}, total={}, mean={}'.format(self.fname,
self.nb_calls,
- time2str(self.total_time),
+ time2str(self.total_time),
time2str(self.total_time/self.nb_calls))
else:
s = ''
@@ -89,12 +89,12 @@ class Profiler(object):
self._elems = {}
# profiled object
self._obj = obj
-
+
self._l = 1
self.all_times = None
self.all_call_nb = None
self.all_names = [None]
-
+
def down(self, l):
self._l = l + 1
@@ -126,10 +126,11 @@ class Profiler(object):
isinstance(summary.values()[0], FProfiler):
s = '>{}::{}'.format(self.get_name(), summary.values()[0])
else:
- s = '{}>{}{}'.format(
- '\n' if (self._l==1) else '',
- self.get_name(),
- ' profiler report' if (self._l==1) else '')
+ s = '{}[{}]>{}{}'.format(
+ '\n' if (self._l==1) else '',
+ main_rank,
+ self.get_name(),
+ ' profiler report' if (self._l==1) else '')
for v in summary.values():#sorted(summary.values(), key=lambda x: x.total_time):
if len(str(v)) > 0:
s += '\n{}'.format(' '*self._l + str(v))
diff --git a/hysop/tools/spectral_utils.py b/hysop/tools/spectral_utils.py
index 46bfb0e3a5baaadc5f222394a8e4891b214f379e..f1d792a15c16d9398764fa0aec5518350d783c92 100644
--- a/hysop/tools/spectral_utils.py
+++ b/hysop/tools/spectral_utils.py
@@ -1,8 +1,6 @@
import math, os
import numpy as np
import sympy as sm
-import matplotlib
-import matplotlib.pyplot as plt
from hysop import main_rank
from hysop.tools.io_utils import IOParams
@@ -251,7 +249,7 @@ class SpectralTransformUtils(object):
"""
check_instance(field, ScalarField)
boundaries = tuple((lbd, rbd) for (lbd, rbd)
- in zip(field.lboundaries, field.rboundaries))
+ in zip(field.lboundaries_kind, field.rboundaries_kind))
transforms = cls.boundaries_to_transforms(boundaries[::-1], transformed_axes)[::-1]
return transforms
@@ -757,7 +755,7 @@ class EnergyDumper(object):
def update(self, simulation, wait_for):
if not self.should_write:
return
- if not simulation.should_dump(frequency=self.io_params.frequency, with_last=True):
+ if not self.io_params.should_dump(simulation=simulation, with_last=True):
return
if (wait_for is not None):
wait_for.wait()
@@ -801,6 +799,8 @@ class EnergyPlotter(object):
def __init__(self, energy_parameters, io_params, fname,
fig_title=None, axes_shape=(1,), figsize=(15,9),
basex=10, basey=10, **kwds):
+ import matplotlib
+ import matplotlib.pyplot as plt
from hysop.parameters.buffer_parameter import BufferParameter
super(EnergyPlotter, self).__init__(**kwds)
check_instance(io_params, IOParams)
@@ -886,6 +886,7 @@ class EnergyPlotter(object):
self.energy_parameters = energy_parameters
self.ulp = ulp
+ self.plt = plt
def update(self, simulation, wait_for):
if not self.should_draw:
@@ -940,7 +941,7 @@ class EnergyPlotter(object):
return
self.fig.canvas.draw()
self.fig.show()
- plt.pause(0.001)
+ self.plt.pause(0.001)
def _savefig(self, iteration):
filename = self.filename.format(ite='{:05}'.format(iteration))
@@ -952,7 +953,7 @@ class EnergyPlotter(object):
def _on_key_press(self, event):
key = event.key
if key == 'q':
- plt.close(self.fig)
+ self.plt.close(self.fig)
self.has_gui_running = False
diff --git a/hysop/tools/sympy_utils.py b/hysop/tools/sympy_utils.py
index 0a0b0e9232e47208bebd756d245ea0b4d38134b1..0b7d861fd9110af6787be6d256215a4a250369ec 100644
--- a/hysop/tools/sympy_utils.py
+++ b/hysop/tools/sympy_utils.py
@@ -154,7 +154,7 @@ class AppliedUndef(sm.function.AppliedUndef):
#return '{}({})'.format(self._pretty_name,
#','.join(printer._print(a) for a in self.args))
-def subscript(i, with_sign=False):
+def subscript(i, with_sign=False, disable_unicode=False):
"""
Generate an unicode subscript of value i, signs can be enforced.
"""
@@ -164,16 +164,19 @@ def subscript(i, with_sign=False):
s0 = snumber[0]
if s0 in decimals:
snumber = '+'+snumber
- out = u''
- for s in snumber:
- if s in decimals:
- out += decimal_subscripts[int(s)]
- elif s=='+':
- out += signs[0]
- elif s=='-':
- out += signs[1]
- else:
- out += s
+ if disable_unicode:
+ out = snumber
+ else:
+ out =u''
+ for s in snumber:
+ if s in decimals:
+ out += decimal_subscripts[int(s)]
+ elif s=='+':
+ out += signs[0]
+ elif s=='-':
+ out += signs[1]
+ else:
+ out += s
return out
def exponent(i, with_sign=False):
@@ -198,16 +201,21 @@ def exponent(i, with_sign=False):
out += s
return out
-def subscripts(ids,sep,with_sign=False,with_parenthesis=False,prefix=''):
+def subscripts(ids,sep,with_sign=False,with_parenthesis=False,prefix='',disable_unicode=False):
"""
Generate a unicode tuple subscript separated by sep,
with or without parenthesis, prefix, and signs.
"""
ids = to_tuple(ids)
if with_parenthesis:
- return u'{}{}{}{}'.format(prefix,parenthesis[0],sep.join([subscript(i,with_sign) for i in ids]),parenthesis[1])
+ lparen = '(' if disable_unicode else parenthesis[0]
+ rparen = ')' if disable_unicode else parenthesis[1]
+ base = '{}{}{}{}' if disable_unicode else u'{}{}{}{}'
+ return base.format(prefix,lparen,sep.join([subscript(i,with_sign,disable_unicode)
+ for i in ids]),rparen)
else:
- return u'{}{}'.format(prefix,sep.join([subscript(i,with_sign) for i in ids]))
+ base = '{}{}' if disable_unicode else u'{}{}'
+ return base.format(prefix,sep.join([subscript(i,with_sign,disable_unicode) for i in ids]))
def exponents(ids,sep,with_sign=False,with_parenthesis=False,prefix=''):
"""
@@ -256,8 +264,10 @@ def tensor_xreplace(tensor,vars):
if isinstance(symbol,sm.Expr):
if (symbol in vars.keys()):
T[idx] = vars[symbol]
- elif (symbol.name in vars.keys()):
+ elif (hasattr(symbol, 'name')) and (symbol.name in vars.keys()):
T[idx] = vars[symbol.name]
+ else:
+ T[idx] = symbol.xreplace(vars)
return T
def non_eval_xreplace(expr, rule):
diff --git a/hysop/tools/types.py b/hysop/tools/types.py
index 3f127f44000393a126e1d5097757d9b05c947d11..0fa5fea24ceaa47b3471e7c3741e980d0a6ee864 100644
--- a/hysop/tools/types.py
+++ b/hysop/tools/types.py
@@ -1,6 +1,5 @@
from hysop.deps import np
from collections import Iterable
-from hysop.tools.misc import prod
class InstanceOf(object):
def __init__(self, cls):
@@ -14,7 +13,7 @@ class InstanceOf(object):
return 'InstanceOf({})'.format(self.cls.__name__)
-def check_instance(val, cls, allow_none=False,
+def check_instance(val, cls, allow_none=False,
check_kwds=True, **kargs):
"""
Raise a TypeError if val is not an instance of cls.
@@ -117,12 +116,12 @@ def check_instance(val, cls, allow_none=False,
msg=msg.format(type(val).__name__, all_val_cls, type(v))
print_offending_value(v, all_val_cls)
raise TypeError(msg)
- if (minval is not None) and (minval and v<minval):
+ if (minval is not None) and (v<minval):
msg='Value contained in given {} has value {} which is less '
msg+='than the specified minimum value {}.'
msg=msg.format(cls.__name__, v, minval)
raise ValueError(msg)
- if (maxval is not None) and (maxval and v>maxval):
+ if (maxval is not None) and (v>maxval):
msg='Value contained in given {} has value {} which is greater '
msg+='than the specified maximum value {}.'
msg=msg.format(cls.__name__, v, maxval)
@@ -171,6 +170,7 @@ def check_instance(val, cls, allow_none=False,
print_offending_value(v, all_val_cls)
raise TypeError(msg)
elif isinstance(val, np.ndarray):
+ from hysop.tools.misc import prod
dtype = kargs.pop('dtype', None)
shape = kargs.pop('shape', None)
size = kargs.pop('size', None)
@@ -240,9 +240,11 @@ def check_instance(val, cls, allow_none=False,
msg='Value {} is greater than the specified maximum value {}.'
msg=msg.format(val, maxval)
raise ValueError(msg)
-
- if check_kwds and kargs:
- raise RuntimeError('Some arguments were not used ({}).'.format(kargs))
+ if kargs:
+ # Ignore unused 'keys' argument if val can be a dict and
+ # is instance of another type
+ if not (dict in allcls and type(val) is not dict):
+ raise RuntimeError('Some arguments were not used ({}).'.format(kargs))
def to_tuple(arg, cast=None):
diff --git a/hysop/tools/warning.py b/hysop/tools/warning.py
index eb408c07c950199ee850de64d872b3de6a46a0e2..ee8bb9246fb993ce85e8d1ee845f8cd7b7d75aa0 100644
--- a/hysop/tools/warning.py
+++ b/hysop/tools/warning.py
@@ -11,6 +11,24 @@ class HysopDeprecationWarning(DeprecationWarning):
"""
pass
+class HysopPerformanceWarning(HysopWarning):
+ """
+ Custom warning class for hysop performance.
+ """
+ pass
+
+class HysopDumpWarning(HysopWarning):
+ """
+ Custom warning class for hysop I/O dumps.
+ """
+ pass
+
+class HysopCacheWarning(HysopWarning):
+ """
+ Custom warning class for hysop caching.
+ """
+ pass
+
def configure_hysop_warnings(action):
"""
Configure hysop warnings.
diff --git a/hysop/topology/cartesian_descriptor.py b/hysop/topology/cartesian_descriptor.py
index 80a3315d35be912652d220b3288b5ed6a98be762..0b8b86a15da94b0d868d1f440909c27dc55bd499 100644
--- a/hysop/topology/cartesian_descriptor.py
+++ b/hysop/topology/cartesian_descriptor.py
@@ -1,5 +1,5 @@
-from hysop.tools.types import check_instance
+from hysop.tools.types import check_instance, to_tuple
from hysop.topology.topology_descriptor import TopologyDescriptor
from hysop.topology.cartesian_topology import CartesianTopology
from hysop.tools.parameters import CartesianDiscretization
@@ -155,13 +155,14 @@ class CartesianTopologyDescriptor(TopologyDescriptor):
else:
global_resolution = handle
+
cartesian_discretization = CartesianDiscretization(resolution=global_resolution,
- lboundaries=field.lboundaries, rboundaries=field.rboundaries,
+ lboundaries=field.lboundaries_kind, rboundaries=field.rboundaries_kind,
ghosts=None)
-
+
+ kwds.setdefault('mpi_params', operator.mpi_params)
+ kwds.setdefault('domain', field.domain)
return CartesianTopologyDescriptor(backend=backend,
- domain=field.domain,
- mpi_params=operator.mpi_params,
cartesian_discretization = cartesian_discretization,
**kwds)
elif isinstance(handle, CartesianTopologyDescriptor):
@@ -209,3 +210,19 @@ Instance of those types can be used to create a CartesianTopologyDescriptor.
Thus they can be passed in the variables of each operator supporting
CartesianTopology topologies.
"""
+
+def get_topo_descriptor_discretization(td):
+ """
+ Get grid resolution from any type of CartesianTopologyDescriptor.
+ """
+ check_instance(td, CartesianTopologyDescriptors, allow_none=True)
+ if (td is None):
+ return None
+ elif isinstance(td, CartesianTopology):
+ td = td.grid_resolution
+ elif isinstance(td, CartesianTopologyDescriptor):
+ td = td.grid_resolution
+ elif isinstance(td, CartesianDiscretization):
+ td = td.grid_resolution
+ return to_tuple(td)
+
diff --git a/hysop/topology/cartesian_topology.py b/hysop/topology/cartesian_topology.py
index 6a64a61bc6551a605b722b7b9945f48e3fd64615..b7443e3f9b482dbdf70c4418477fbd5f634d5efa 100644
--- a/hysop/topology/cartesian_topology.py
+++ b/hysop/topology/cartesian_topology.py
@@ -1,9 +1,8 @@
-
from hysop.deps import warnings
from hysop.topology.topology import Topology, TopologyState, TopologyView, TopologyWarning
from hysop.constants import np, math, Backend, MemoryOrdering
from hysop.constants import HYSOP_ORDER, BoundaryCondition, HYSOP_INTEGER
-from hysop.constants import HYSOP_MPI_REAL, HYSOP_MPI_ORDER, TranspositionState
+from hysop.constants import HYSOP_REAL, HYSOP_MPI_REAL, TranspositionState
from hysop.tools.transposition_states import TranspositionState
from hysop.domain.box import Box, BoxView
from hysop.core.mpi import MPI
@@ -20,15 +19,15 @@ class CartesianTopologyState(TopologyState):
CartesianTopology topology state.
This is a helper class to qualify CartesianDiscreteField states.
- A CartesianTopologyState contains informations about
- the way the application should perceive the contained data
+ A CartesianTopologyState contains informations about
+ the way the application should perceive the contained data
(Arrays) in CartesianDiscreteFields.
Those informations include for the current physical
transposition state of the topology and the local meshes
and the memory_order.
- Currently the state is shared accross all components of the
+ Currently the state is shared accross all components of the
CartesianDiscreteField. This is global state for all processes
contained in the linked Cartesian topology.
"""
@@ -38,12 +37,12 @@ class CartesianTopologyState(TopologyState):
@debug
def __new__(cls, dim, axes=None, memory_order=None, is_read_only=False, **kwds):
return super(CartesianTopologyState, cls).__new__(cls, is_read_only=is_read_only, **kwds)
-
+
@debug
def __init__(self, dim, axes=None, memory_order=None, is_read_only=False, **kwds):
"""
Initialize a CartesianState to given parameters.
-
+
Parameters
----------
dim: int
@@ -62,7 +61,7 @@ class CartesianTopologyState(TopologyState):
self._dim = int(dim)
self._set_axes(axes)
self._set_memory_order(memory_order)
-
+
def _get_axes(self):
"""Return current permutation as a tuple of int."""
return self._axes
@@ -70,7 +69,7 @@ class CartesianTopologyState(TopologyState):
"""Set the current permutation as a tuple of int."""
axes = axes or TranspositionState[self._dim].default_axes()
axes = to_tuple(axes, cast=int)
- check_instance(axes, tuple, values=int)
+ check_instance(axes, tuple, values=int)
assert set(axes)==set(range(self._dim))
self._axes = axes
@@ -84,17 +83,17 @@ class CartesianTopologyState(TopologyState):
memory_order = MemoryOrdering.C_CONTIGUOUS
elif (memory_order is 'f'):
memory_order = MemoryOrdering.F_CONTIGUOUS
- assert memory_order in (MemoryOrdering.C_CONTIGUOUS,
+ assert memory_order in (MemoryOrdering.C_CONTIGUOUS,
MemoryOrdering.F_CONTIGUOUS), memory_order
self._memory_order = memory_order
-
+
def _get_dim(self):
"""Return the dimension of the underlying topology domain."""
return self._dim
def _get_tstate(self):
"""Return the TranspositionState corresponding to current permutation axes."""
return TranspositionState.axes_to_tstate(self._axes)
-
+
def copy(self, axes=None, memory_order=None):
"""Return of copy of this object."""
axes = first_not_None(axes, self._axes)
@@ -102,10 +101,10 @@ class CartesianTopologyState(TopologyState):
memory_order = first_not_None(memory_order, self._memory_order)
return CartesianTopologyState(dim=dim, axes=axes,
memory_order=memory_order)
-
+
def __transposed(self, vec, axes):
- """
- Compute permutation of input vector of size len(axes) according
+ """
+ Compute permutation of input vector of size len(axes) according
to axes permutation.
"""
axes = to_tuple(axes)
@@ -115,18 +114,22 @@ class CartesianTopologyState(TopologyState):
assert set(axes) == set(range(len(axes))), axes
if isinstance(vec, np.ndarray):
- assert vec.size == len(axes), '{} != {}'.format(vec.size, len(axes))
- res = vec.copy()
- res[...] = tuple(vec[i] for i in axes)
- return res
+ if (vec.ndim > 1) and (vec.ndim == len(axes)):
+ assert vec.size != len(axes), 'ambiguous transposition'
+ return npw.transpose(vec, axes=axes)
+ else:
+ assert vec.size == len(axes), '{} != {}'.format(vec.size, len(axes))
+ res = vec.copy()
+ res[...] = tuple(vec[i] for i in axes)
+ return res
else:
assert len(vec) == len(axes)
return type(vec)(vec[i] for i in axes)
-
+
def transposed(self, vec):
"""Compute permutation of input vector according to current transposition state."""
return self.__transposed(vec, self._axes)
-
+
def copy(self, axes=None, memory_order=None, is_read_only=None):
"""Return a copy of self, some properties may be alterted in kwds."""
memory_order = first_not_None(memory_order, self.memory_order)
@@ -134,29 +137,30 @@ class CartesianTopologyState(TopologyState):
axes = first_not_None(axes, self.axes)
return CartesianTopologyState(dim=self.dim,
axes=axes,
- memory_order=memory_order,
+ memory_order=memory_order,
is_read_only=is_read_only)
-
+
def short_description(self):
"""Return a short description of this CartesianTopologyState."""
s='{}[order={}, axes=({}), ro={}]'
return s.format(self.full_tag,
self.memory_order,
- ','.join(str(a) for a in self.axes),
+ ','.join(str(a) for a in self.axes),
'1' if self.is_read_only else '0')
def long_description(self):
"""Return a long description of this CartesianTopologyState."""
s='''{}
- *dim: {}
- *order: {}
- *axes: ({})
- *tstate: {}
+ *dim: {}
+ *order: {}
+ *axes: ({})
+ *tstate: {}
+ *read only: {}
'''
- return s.format(self.full_tag, self.dim,
+ return s.format(self.full_tag, self.dim,
self.memory_order,
- ','.join([str(a) for a in self.axes]),
- self.tstate)
+ ','.join([str(a) for a in self.axes]),
+ self.tstate, self.is_read_only)
def match(self, other, invert=False):
"""Check if this topology state does match the other one."""
@@ -166,11 +170,8 @@ class CartesianTopologyState(TopologyState):
match &= (self._dim == other._dim)
match &= (self._axes == other._axes)
match &= (self._memory_order == other._memory_order)
- if invert:
- match = not match
- else:
- return match
-
+ return not match if invert else match
+
def __hash__(self):
h = super(CartesianTopologyState, self).__hash__()
return h ^ hash(self._dim) ^ hash(self._axes) ^ hash(self._memory_order)
@@ -178,7 +179,7 @@ class CartesianTopologyState(TopologyState):
dim = property(_get_dim)
tstate = property(_get_tstate)
axes = property(_get_axes, _set_axes)
- memory_order = property(_get_memory_order, _set_memory_order)
+ memory_order = property(_get_memory_order, _set_memory_order)
class CartesianTopologyView(TopologyView):
@@ -188,16 +189,16 @@ class CartesianTopologyView(TopologyView):
"""
__slots__ = ('_mesh_view', '_domain_view', '_topology', '_topology_state')
-
+
@debug
def __new__(cls, topology_state, topology=None, **kwds):
"""
Create and initialize a cartesian topology view.
-
+
Parameters
----------
topology_state: :class:`~hysop.topology.cartesian_topology.CartesianTopologyState`
- State that charaterizes the given view.
+ State that charaterizes the given view.
topology: :class:`~hysop.topology.topology.CartesianTopology`
Original cartesian topology on which the view is.
kwds: dict
@@ -206,12 +207,12 @@ class CartesianTopologyView(TopologyView):
check_instance(topology_state, CartesianTopologyState)
check_instance(topology, CartesianTopology, allow_none=True)
- obj = super(CartesianTopologyView, cls).__new__(cls,
+ obj = super(CartesianTopologyView, cls).__new__(cls,
topology_state=topology_state, topology=topology, **kwds)
check_instance(obj._topology, CartesianTopology)
return obj
-
+
def _get_proc_axes(self):
""" Returns state transposition axes."""
return self._topology_state.axes
@@ -222,10 +223,10 @@ class CartesianTopologyView(TopologyView):
def _proc_transposed(self, vec):
"""Returns transposed vec according to current transposition state."""
return self._topology_state.transposed(vec)
-
+
def _distributed_components(self, vec):
"""
- Extract distributed components of vector and returns
+ Extract distributed components of vector and returns
reduced vector of same type.
"""
rvec = np.asarray(vec)[self._get_is_distributed()]
@@ -234,7 +235,7 @@ class CartesianTopologyView(TopologyView):
else:
return type(vec)(rvec.tolist())
-
+
# ATTRIBUTE GETTERS
def _get_global_resolution(self):
"""Returns global resolution of the discretization (logical grid size)."""
@@ -263,14 +264,14 @@ class CartesianTopologyView(TopologyView):
def _get_cart_periods(self):
"""MPI cartesian topology shape."""
return self._distributed_components(self._get_is_periodic())
-
+
def _get_cart_coords(self):
"""Current process MPI cartesian topology coordinates."""
return self._distributed_components(self._get_proc_coords())
def _get_cart_rank(self):
"""Current process MPI cartesian topology rank."""
return self._topology._cart_rank
-
+
def _get_cart_ranks(self):
"""Return all MPI cartesian topology ranks as np.ndarray."""
return self._get_proc_ranks().reshape(self._get_cart_shape())
@@ -279,17 +280,17 @@ class CartesianTopologyView(TopologyView):
return self._get_proc_ranks_mapping().reshape(self._get_cart_shape())
def _get_cart_neighbour_ranks(self):
"""Return the ranks of the neighbours nodes as obtained by MPI_Cart_shift.
- self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next)
+ self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next)
neighbour in axe i."""
return self._get_proc_neighbour_ranks()[:, self._get_is_distributed()]
-
+
def _get_proc_shape(self):
"""MPI cartesian topology extended shape (ie. undistributed axes included)."""
return self._proc_transposed(self._topology._proc_shape)
def _get_proc_coords(self):
"""
- Current process cartesian topology extended coordinates (ie. undistributed
+ Current process cartesian topology extended coordinates (ie. undistributed
axes included).
"""
return self._proc_transposed(self._topology._proc_coords)
@@ -301,17 +302,21 @@ class CartesianTopologyView(TopologyView):
return np.transpose(self._topology._proc_ranks, axes=self._get_proc_axes())
def _get_proc_ranks_mapping(self):
"""
- Return all parent communicator topology ranks as np.ndarray,
+ Return all parent communicator topology ranks as np.ndarray,
undistributed axes included.
"""
return np.transpose(self._topology._proc_ranks_mapping, axes=self._get_proc_axes())
def _get_proc_neighbour_ranks(self):
"""
Return the ranks of the neighbours nodes as obtained by MPI_Cart_shift.
- self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next) neighbour in axe i.
+ self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next) neighbour in axe i.
If axe is not distributed, self.neighbours[:,i] returns [-1,-1].
"""
- return self._topology._proc_neighbour_ranks[:, tuple(self._get_proc_axes())]
+ if (self._topology_state.memory_order is MemoryOrdering.F_CONTIGUOUS):
+ prev, next = self._topology._proc_neighbour_ranks[:, tuple(self._get_proc_axes())]
+ return npw.asintegerarray((prev[::-1], next[::-1]))
+ else:
+ return self._topology._proc_neighbour_ranks[:, tuple(self._get_proc_axes())]
def _get_is_distributed(self):
"""
@@ -325,18 +330,18 @@ class CartesianTopologyView(TopologyView):
is_periodic[dir] = True means that the MPI grid is periodic along dir.
/!\ This is not equivalent to domain periodicity, as a periodic
direction might not be distributed in the MPI cartesian grid
- or might be forced to be periodic for other reasons through
+ or might be forced to be periodic for other reasons through
the is_periodic parameter override.
"""
return self._proc_transposed(self._topology._is_periodic)
-
+
def _get_distributed_axes(self):
"""Return distributed axes ids as a np.ndarray of integers."""
return np.where(self._get_is_distributed() == True)[0].astype(np.int32)
def _get_periodic_axes(self):
"""Return cartesian communicator periodic axes ids as a np.ndarray of integers."""
return np.where(self._get_is_periodic() == True)[0].astype(np.int32)
-
+
global_resolution = property(_get_global_resolution)
grid_resolution = property(_get_grid_resolution)
ghosts = property(_get_ghosts)
@@ -353,7 +358,7 @@ class CartesianTopologyView(TopologyView):
cart_ranks = property(_get_cart_ranks)
cart_ranks_mapping = property(_get_cart_ranks_mapping)
cart_neighbour_ranks = property(_get_cart_neighbour_ranks)
-
+
proc_coords = property(_get_proc_coords)
proc_shape = property(_get_proc_shape)
proc_ranks = property(_get_proc_ranks)
@@ -365,7 +370,7 @@ class CartesianTopologyView(TopologyView):
distributed_axes = property(_get_distributed_axes)
periodic_axes = property(_get_periodic_axes)
-
+
def default_state(self):
"""Return the default topology state of this topology."""
return CartesianTopologyState(dim=self.domain.dim)
@@ -375,18 +380,18 @@ class CartesianTopologyView(TopologyView):
Returns a short description of the current TopologyView.
Short version of long_description().
"""
- s='{}[domain={}, backend={}, pcoords={}, pshape={}, '
+ s='{}[domain={}, backend={}, pshape={}, '
s+='grid_resolution={}, ghosts={}, bc=({})]'
s = s.format(
- self.full_tag,
- self.domain.domain.full_tag,
+ self.full_tag,
+ self.domain.domain.full_tag,
self.backend.kind,
- self.proc_coords, self.proc_shape,
+ self.proc_shape,
'[{}]'.format(','.join(str(s) for s in self.grid_resolution)),
'[{}]'.format(','.join(str(g) for g in self.ghosts)),
','.join(('{}/{}'.format(
str(lb).replace('HOMOGENEOUS_','')[:3],
- str(rb).replace('HOMOGENEOUS_','')[:3])
+ str(rb).replace('HOMOGENEOUS_','')[:3])
for (lb,rb) in zip(*self.mesh.global_boundaries))))
return s
@@ -400,7 +405,7 @@ class CartesianTopologyView(TopologyView):
s += ' *backend: ' + str(self.backend.full_tag) + '\n'
s += ' *shape: ' + str(self.proc_shape) + '\n'
s += ' *process of coords ' + str(self.proc_coords[:])
- s += ' and of ranks cart_rank={}, parent_rank={}\n'.format(self.cart_rank,
+ s += ' and of ranks cart_rank={}, parent_rank={}\n'.format(self.cart_rank,
self.mpi_params.rank)
s += ' *cartesian ranks map:\n'
s += prepend(str(self.cart_ranks), ' '*4) + '\n'
@@ -427,9 +432,9 @@ class CartesianTopologyView(TopologyView):
msg += ' two different mpi tasks. Set taskids properly or use'
msg += ' InterBridge.'
assert self.task_id == target.task_id, msg
-
+
return self.is_consistent_with(target)
-
+
def is_consistent_with(self, target):
"""
True if target and current object are equal and
@@ -447,15 +452,15 @@ class CartesianTopologyView(TopologyView):
class CartesianTopology(CartesianTopologyView, Topology):
"""
- CartesianTopology topologies defined on cartesian meshes which communicates
+ CartesianTopology topologies defined on cartesian meshes which communicates
accross processes through a MPI CartesianTopology communicator.
"""
@debug
- def __new__(cls, domain, discretization, mpi_params=None,
+ def __new__(cls, domain, discretization, mpi_params=None,
cart_dim=None, cart_shape=None,
- is_periodic=None, cutdirs=None,
- mesh=None, cartesian_topology=None,
+ is_periodic=None, cutdirs=None,
+ mesh=None, cartesian_topology=None,
cl_env=None, **kwds):
"""
Initializes or get an existing CartesianTopology topology.
@@ -471,7 +476,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
MPI parameters (comm, task ...).
If not specified, comm = domain.task_comm, task = domain.curent_task()
backend: :class:`~hysop.constants.Backend` or `~hysop.core.arrays.ArrayBackend`, optional
- Backend or backend kind for this topology.
+ Backend or backend kind for this topology.
By default a topology will use Backend.HOST.
cart_dim: int, optional
MPI topology dimension.
@@ -497,7 +502,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
global_resolution: np.ndarray of HYSOP_INTEGER
Resolution of the global mesh (as given in the discretization parameter).
ghosts: np.ndarray of HYSOP_INTEGER
- CartesianDiscretization ghosts of local-to-process mesh (as given in
+ CartesianDiscretization ghosts of local-to-process mesh (as given in
the discretization parameter).
mesh: :class:`~hysop.domain.mesh.CartesianMeshView`:
Local mesh on the current mpi process.
@@ -525,35 +530,35 @@ class CartesianTopology(CartesianTopologyView, Topology):
cart_periods: np.ndarray of bool
MPI_Cart grid periodicity
cart_ranks: np.ndarray of np.int32
- Return all ranks of this cartesian topology as a np.ndarray such
+ Return all ranks of this cartesian topology as a np.ndarray such
that array[cart_coords] = rank.
cart_ranks_mapping: np.ndarray of np.int32
- Return all ranks of the parent MPI communicator as a np.ndarray such
+ Return all ranks of the parent MPI communicator as a np.ndarray such
that array[cart_coords] = parent rank.
cart_neighbour_ranks: np.ndarray
Return the ranks of the neighbours nodes as obtained by MPI_Cart_shift.
- self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next)
+ self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next)
neighbour in direction i.
proc_coords: tuple of int
- Coordinates of this process in the extended cartesian grid
+ Coordinates of this process in the extended cartesian grid
(ie. with non distributed directions included).
The returned tuple is of dimension self.domain_dim.
proc_shape: tuple of int
- Processus grid shape, same as cart_shape but extended with non distributed
+ Processus grid shape, same as cart_shape but extended with non distributed
directions.
proc_ranks: np.ndarray of np.int32
- Return all ranks of this cartesian topology as a np.ndarray such
+ Return all ranks of this cartesian topology as a np.ndarray such
that array[proc_coords] = rank.
proc_ranks_mapping: np.ndarray of np.int32
- Return all ranks of the parent MPI communicator as a np.ndarray such
+ Return all ranks of the parent MPI communicator as a np.ndarray such
that array[proc_coords] = parent rank.
proc_neighbour_ranks: np.ndarray
Return the ranks of the neighbours nodes as obtained by MPI_Cart_shift.
- self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next)
- neighbour in axe i.
+ self.neighbours[0,i] (resp. [1,i]) is the previous (resp. next)
+ neighbour in axe i.
If axe is not distributed, self.neighbours[:,i] returns [-1,-1].
-
+
is_distributed : tuple of bool
Directions which have been distributed,
is_distributed[dir] = True means that data has been distributed along dir.
@@ -562,10 +567,10 @@ class CartesianTopology(CartesianTopologyView, Topology):
is_periodic[dir] = True means that the MPI grid is periodic along dir.
/!\ This is not equivalent to domain periodicity, as a periodic
direction might not be distributed in the MPI cartesian grid
- or might be forced to be periodic for other reasons through
+ or might be forced to be periodic for other reasons through
the is_periodic parameter override.
Domain periodicity is self.domain.periodicity
-
+
Notes:
------
* Almost all parameters above are optional.
@@ -574,12 +579,11 @@ class CartesianTopology(CartesianTopologyView, Topology):
* When cartesian_topology is given, dim, shape and cutdirs parameters,
if set, are not used to build the mpi topology, but compared with
cartesian_topology parameters. If they do not fit, error is raised.
- * Unless is_periodic is specified periodicity is extracted
+ * Unless is_periodic is specified periodicity is extracted
from domain boundary conditions.
* All attributes are read-only properties.
"""
-
# Get or create mpi parameters
mpi_params = cls._create_mpi_params(mpi_params, domain, cl_env)
@@ -599,41 +603,41 @@ class CartesianTopology(CartesianTopologyView, Topology):
check_instance(is_distributed, np.ndarray, dtype=bool)
check_instance(cartesian_topology, MPI.Cartcomm, allow_none=True)
check_instance(mesh, CartesianMesh, allow_none=True)
-
- npw.set_readonly(proc_shape, is_periodic, is_distributed)
-
+
+ npw.set_readonly(proc_shape, is_periodic, is_distributed)
+
topology_state = CartesianTopologyState(dim=domain.dim)
obj = super(CartesianTopology,cls).__new__(cls,
mpi_params = mpi_params,
domain=domain,
discretization=discretization,
- cart_dim=cart_dim, cart_size=cart_size, proc_shape=proc_shape,
+ cart_dim=cart_dim, cart_size=cart_size, proc_shape=proc_shape,
is_periodic=is_periodic, is_distributed=is_distributed,
cartesian_topology=id(cartesian_topology), mesh=hash(mesh),
topology_state = topology_state, cl_env=cl_env,
**kwds)
-
+
if not obj.obj_initialized:
- obj.__initialize(domain, discretization,
- cart_dim, cart_size, proc_shape,
- is_periodic, is_distributed,
- cartesian_topology, mesh)
+ obj.__initialize(domain, discretization,
+ cart_dim, cart_size, proc_shape,
+ is_periodic, is_distributed,
+ cartesian_topology, mesh)
return obj
- def __initialize(self, domain, discretization,
- cart_dim, cart_size, proc_shape,
- is_periodic, is_distributed,
+ def __initialize(self, domain, discretization,
+ cart_dim, cart_size, proc_shape,
+ is_periodic, is_distributed,
cartesian_topology, mesh):
-
+
self._discretization = discretization
self._cart_dim = cart_dim
self._cart_size = cart_size
self._proc_shape = proc_shape
self._is_periodic = is_periodic
self._is_distributed = is_distributed
-
+
if (cartesian_topology is None):
cartesian_topology = self._build_mpi_topo()
@@ -647,7 +651,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
mesh = self._compute_mesh(domain, discretization)
self._mesh = mesh
self._TopologyView__set_mesh(mesh)
-
+
npw.set_readonly(self._proc_coords,
self._proc_shape,
self._proc_ranks,
@@ -667,7 +671,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
check_instance(self.cart_dim, int, minval=1)
check_instance(self.cart_size, int, minval=1, maxval=self.mpi_params.size)
check_instance(self.cart_rank, int, minval=0, maxval=self._cart_size)
-
+
check_instance(self.cart_coords, np.ndarray, dtype=HYSOP_INTEGER)
check_instance(self.cart_shape, np.ndarray, dtype=HYSOP_INTEGER)
check_instance(self.cart_ranks, np.ndarray, dtype=HYSOP_INTEGER)
@@ -689,8 +693,8 @@ class CartesianTopology(CartesianTopologyView, Topology):
check_instance(self.domain, BoxView)
check_instance(self.mesh, CartesianMeshView)
- def topology_like(self, backend=None, grid_resolution=None, ghosts=None,
- lboundaries=None, rboundaries=None, mpi_params=None,
+ def topology_like(self, backend=None, grid_resolution=None, ghosts=None,
+ lboundaries=None, rboundaries=None, mpi_params=None,
cart_shape=None, **kwds):
"""Return a topology like this object, possibly altered."""
assert ('global_resolution' not in kwds), 'Specify grid_resolution instead.'
@@ -704,7 +708,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
# find out the target mpi_params
from hysop.core.arrays.all import OpenClArrayBackend
- if isinstance(backend, OpenClArrayBackend):
+ if isinstance(backend, OpenClArrayBackend):
if (mpi_params is not None) and (mpi_params != backend.cl_env.mpi_params):
msg='Backend mpi params mismatch.'
raise RuntimeError(msg)
@@ -715,11 +719,11 @@ class CartesianTopology(CartesianTopologyView, Topology):
cart_shape = first_not_None(cart_shape, self.proc_shape)
return CartesianTopology(domain=self._domain, mpi_params=mpi_params,
- discretization=discretization, backend=backend,
- cart_shape=self.proc_shape,
+ discretization=discretization, backend=backend,
+ cart_shape=self.proc_shape,
cartesian_topology=None, **kwds)
-
-
+
+
@classmethod
def _check_topo_parameters(cls, mpi_params, domain, discretization,
shape, cutdirs,
@@ -738,10 +742,10 @@ class CartesianTopology(CartesianTopologyView, Topology):
choose the 'best' layout.
(e) - in last resort the dimension will be the dimension of the domain.
"""
-
+
domain_dim = domain.dim
parent_size = mpi_params.comm.Get_size()
-
+
if cartesian_topology:
msg = 'Wrong type for input communicator.'
assert isinstance(cartesian_topology, MPI.Cartcomm), msg
@@ -771,19 +775,20 @@ class CartesianTopology(CartesianTopologyView, Topology):
msg = ' parameter is useless when cutdirs is provided.'
assert shape is None, 'shape ' + msg
assert dim is None, 'dim ' + msg
- is_distributed = npw.asboolarray(cutdirs).copy()
- dim = is_distributed.size
- assert dim == domain_dim, 'cutdirs is not of size domain_dim'
-
- cart_shape = npw.asintegerarray(MPI.Compute_dims(parent_size,dim))
- cls._optimize_shape(cart_shape)
-
- is_distributed = (cart_shape > 1)
- cart_shape = cart_shape[is_distributed]
-
shape = npw.dim_ones(domain_dim)
- shape[is_distributed] = cart_shape
- else:
+ is_distributed = npw.asboolarray(cutdirs).copy()
+ if is_distributed.any():
+ dim = np.sum(is_distributed>0)
+ assert dim <= domain_dim, 'cutdirs is not of size domain_dim'
+ cart_shape = npw.asintegerarray(MPI.Compute_dims(parent_size,dim))
+ cls._optimize_shape(cart_shape)
+ assert np.sum(cutdirs > 0) == cart_shape.size,\
+ "Created shape {} doesnt respect specified cutdirs {}".format(
+ np.sum(cutdirs > 0), cart_shape.size)
+ shape[is_distributed>0] = cart_shape
+ else:
+ assert parent_size==1
+ else:
if (dim is not None):
# method (d)
msg = ' parameter is useless when dim is provided.'
@@ -796,9 +801,9 @@ class CartesianTopology(CartesianTopologyView, Topology):
cart_shape = npw.asintegerarray(MPI.Compute_dims(parent_size,dim))
shape = npw.dim_ones(domain_dim)
shape[:dim] = cart_shape
-
+
cls._optimize_shape(shape)
-
+
if (is_periodic is None):
try:
is_periodic = discretization.periodicity
@@ -808,7 +813,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
msg+='\n{}'
msg=msg.format(discretization)
raise ValueError(msg)
-
+
shape = npw.asintegerarray(shape)
is_periodic = (np.asarray(is_periodic) != 0)
assert shape.size == domain_dim
@@ -820,7 +825,6 @@ class CartesianTopology(CartesianTopologyView, Topology):
cart_shape = shape[is_distributed]
cart_dim = cart_shape.size
cart_size = prod(cart_shape)
-
is_periodic = is_periodic * is_distributed
assert (cart_dim>0) and (cart_dim <= domain_dim)
@@ -839,7 +843,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
proc_shape = shape
return (cart_dim, cart_size, proc_shape, is_periodic, is_distributed)
-
+
def _build_mpi_topo(self):
cart_shape = self._proc_shape[self._is_distributed]
periods = self._is_periodic[self._is_distributed]
@@ -852,7 +856,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
"""
msg = 'Wrong type for input communicator.'
assert isinstance(cartesian_topology, MPI.Cartcomm), msg
-
+
comm = cartesian_topology
assert self.cart_dim == comm.ndim
@@ -862,7 +866,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
self._cart_comm = comm
self._cart_rank = comm.Get_rank()
-
+
def _extract_topo_features(self, domain):
""" Set self._proc_coords, self._proc_ranks, self._proc_ranks_mapping.
"""
@@ -880,7 +884,7 @@ class CartesianTopology(CartesianTopologyView, Topology):
proc_ranks = npw.dim_zeros(proc_shape)
cart_ranks = proc_ranks.reshape(cart_shape)
-
+
proc_ranks_mapping = npw.dim_zeros(proc_shape)
cart_ranks_mapping = proc_ranks_mapping.reshape(proc_ranks_mapping.size)
@@ -889,10 +893,10 @@ class CartesianTopology(CartesianTopologyView, Topology):
for coords in np.ndindex(*cart_shape):
rank = cart_comm.Get_cart_rank(coords)
cart_ranks[coords] = rank
-
- cart_ranks_mapping[...] = MPI.Group.Translate_ranks(cart_comm.group,
+
+ cart_ranks_mapping[...] = MPI.Group.Translate_ranks(cart_comm.group,
cart_ranks.flatten(), mpi_params.comm.group)
-
+
direction = 0
for i in range(self.domain_dim):
if is_distributed[i]:
@@ -929,35 +933,37 @@ class CartesianTopology(CartesianTopologyView, Topology):
proc_coords = self._proc_coords
proc_shape = self._proc_shape
-
- # Find out dimension and periodic axes of the domain
+
+ # Find out dimension and periodic axes of the domain
domain_dim = domain.dim
periodicity = discretization.periodicity
-
+
# /!\ Now we assume that the user gives us the grid resolutionn
# and not the global_resolution as it used to be.
# We do not remove 1 point on each periodic axe because of periodicity
computational_grid_resolution = discretization.grid_resolution
# Number of "computed" points (i.e. excluding ghosts).
- pts_noghost = npw.dim_zeros((domain_dim))
- pts_noghost[:] = computational_grid_resolution // proc_shape
+ # /!\ we try to match fftw_mpi_local_size_* functions for the Fortran spectral backend
assert all(computational_grid_resolution >= proc_shape)
+ pts_noghost = npw.dim_zeros((domain_dim))
+ pts_noghost[:] = npw.ceil(npw.divide(computational_grid_resolution.astype(HYSOP_REAL), proc_shape))
# If any, remaining points are added on the mesh of the last process.
remaining_points = npw.dim_zeros(domain_dim)
- remaining_points[:] += computational_grid_resolution % proc_shape
+ remaining_points[:] = computational_grid_resolution - (proc_shape-1)*pts_noghost
+ assert (remaining_points >= 1).all(), remaining_points
# Total number of points (size of arrays to be allocated)
nbpoints = pts_noghost.copy()
for i in range(domain_dim):
- if proc_coords[i] == proc_shape[i] - 1:
- nbpoints[i] += remaining_points[i]
+ if (proc_coords[i] == proc_shape[i] - 1):
+ nbpoints[i] = remaining_points[i]
local_resolution = nbpoints.copy()
local_resolution += 2 * discretization.ghosts
-
- msg='\nLocal compute shape is smaller than the total number of ghosts, '
+
+ msg='\nLocal compute shape is smaller than the total number of ghosts, '
msg+='on at least one axis:'
msg+='\n *compute shape: {}'.format(nbpoints)
msg+='\n *ghosts: 2*{}'.format(discretization.ghosts)
@@ -966,18 +972,18 @@ class CartesianTopology(CartesianTopologyView, Topology):
# Global indices for the local mesh points
global_start = proc_coords * pts_noghost
-
- return CartesianMesh(topology=self,
- local_resolution=local_resolution,
+
+ return CartesianMesh(topology=self,
+ local_resolution=local_resolution,
global_start=global_start)
-
+
def view(self, topology_state):
"""
Returns a view of this topology with the given state.
"""
check_instance(topology_state, CartesianTopologyState)
return CartesianTopologyView(topology=self, topology_state=topology_state)
-
+
def discretize(self, field):
"""Discretize a continous field on this topology and return a DiscreteField."""
from hysop.fields.continuous_field import ScalarField
@@ -985,8 +991,8 @@ class CartesianTopology(CartesianTopologyView, Topology):
TmpCartesianDiscreteScalarField
check_instance(field, ScalarField)
- if (field.lboundaries != self._discretization.lboundaries).any() or \
- (field.rboundaries != self._discretization.rboundaries).any():
+ if (field.lboundaries_kind != self._discretization.lboundaries).any() or \
+ (field.rboundaries_kind != self._discretization.rboundaries).any():
msg=\
'''
Cannot discretize a field with cartesian boundary conditions:'
@@ -995,7 +1001,7 @@ Cannot discretize a field with cartesian boundary conditions:'
On a cartesian topology with different boundary conditions:
lboundaries: {}
rboundaries: {}
-'''.format(field.lboundaries, field.rboundaries,
+'''.format(field.lboundaries_kind, field.rboundaries_kind,
self._discretization.lboundaries,
self._discretization.rboundaries)
raise RuntimeError(msg)
@@ -1004,4 +1010,3 @@ On a cartesian topology with different boundary conditions:
return TmpCartesianDiscreteScalarField(field=field, topology=self)
else:
return CartesianDiscreteScalarField(field=field, topology=self)
-
diff --git a/hysop/topology/topology.py b/hysop/topology/topology.py
index 77300f5eec1321f0b0173d7e0397340f8b3ad44a..398ad19a199203e526b60b8b2e6013efb7785217 100644
--- a/hysop/topology/topology.py
+++ b/hysop/topology/topology.py
@@ -9,7 +9,7 @@ from itertools import count
from abc import ABCMeta, abstractmethod
from hysop.constants import np, math, Backend
from hysop.constants import HYSOP_ORDER, BoundaryCondition
-from hysop.constants import HYSOP_MPI_REAL, HYSOP_MPI_ORDER
+from hysop.constants import HYSOP_MPI_REAL
from hysop.domain.domain import Domain
from hysop.core.mpi import MPI
from hysop.core.arrays.array_backend import ArrayBackend
@@ -58,7 +58,8 @@ class TopologyState(TaggedObject):
@abstractmethod
def match(self, other, invert=False):
"""Check if this topology state does match the other one."""
- return (self._is_read_only == other._is_read_only)
+ res = (self._is_read_only == other._is_read_only)
+ return (not res) if invert else res
@abstractmethod
def __hash__(self):
@@ -124,8 +125,6 @@ class TopologyView(TaggedObjectView):
topology_state: :class:`~hysop.topology.topology.TopologyState`
State that charaterizes the given view.
- topo_id: int
- The topology unique id.
domain : :class:`~hysop.domain.domain.Domain`
The geometry on which the topology is defined.
backend: :class:`~hysop.core.arrays.array_backend.ArrayBackend`
diff --git a/hysop/topology/topology_descriptor.py b/hysop/topology/topology_descriptor.py
index 7aa11479a973ea0d75244c983649bcafd133b72c..81ac7454fd27d6deb451e0e1ee69f0ecbcacc677 100644
--- a/hysop/topology/topology_descriptor.py
+++ b/hysop/topology/topology_descriptor.py
@@ -31,7 +31,7 @@ class TopologyDescriptor(object):
self._backend=backend
self._extra_kwds = frozenset(kwds.items())
- if ('cl_env' in kwds):
+ if ('cl_env' in kwds) and (kwds['cl_env'] is not None):
assert kwds['cl_env'].mpi_params is mpi_params
def _get_mpi_params(self):
diff --git a/examples/__init__.py b/hysop_examples/__init__.py
similarity index 100%
rename from examples/__init__.py
rename to hysop_examples/__init__.py
diff --git a/examples/example_utils.py b/hysop_examples/example_utils.py
similarity index 50%
rename from examples/example_utils.py
rename to hysop_examples/example_utils.py
index 6c5211d51db312447a0c3829e4459b0de3b40043..9f63f320d04c4654142bdf4bef4281ca055c1319 100644
--- a/examples/example_utils.py
+++ b/hysop_examples/example_utils.py
@@ -1,5 +1,6 @@
-import os, argparse, tempfile, colors, textwrap, warnings, contextlib, tee, re, errno, shutil, psutil
+import os, argparse, tempfile, colors, textwrap, warnings, contextlib, tee, re, errno, shutil, psutil, sys, functools, atexit
from argparse_color_formatter import ColorHelpFormatter
+import numpy as np
# Fix a bug in the tee module #########
class FixTee(object):
@@ -32,17 +33,22 @@ class SplitAppendAction(argparse._AppendAction):
self._append = append
def __call__(self, parser, namespace, values, option_string=None):
- assert isinstance(values, str), type(values)
- for c in ('(','{','[',']','}',')'):
- values = values.replace(c, '')
- try:
- values = tuple(self._convert(v) for v in values.split(self._separator))
- except:
- msg='Failed to convert \'{}\' to {} of {}s for parameter {}.'
- msg=msg.format(values, self._container.__name__, self._convert.__name__,
- self.dest)
- parser.error(msg)
- assert len(values)>0
+ if isinstance(values, str):
+ for c in ('(','{','[',']','}',')'):
+ values = values.replace(c, '')
+ try:
+ values = tuple(self._convert(v) for v in values.split(self._separator))
+ except:
+ msg='Failed to convert \'{}\' to {} of {}s for parameter {}.'
+ msg=msg.format(values, self._container.__name__, self._convert.__name__,
+ self.dest)
+ parser.error(msg)
+ else:
+ try:
+ values = tuple(values)
+ except:
+ msg='Could not convert values \'{}\' to tuple for parameter {}.'.format(values, self.dest)
+ parser.error(msg)
if self._append:
items = argparse._ensure_value(namespace, self.dest, self._container())
else:
@@ -114,8 +120,9 @@ class HysopArgParser(argparse.ArgumentParser):
def __init__(self, prog_name, description,
domain=None, default_dump_dir=None,
+ generate_io_params=None,
**kwds):
-
+
prog = prog_name
epilog = colors.color('[ADDITIONAL NOTES]', fg='yellow', style='bold')
epilog += '\nOpenCL and Autotuner parameters only have an effect on the OpenCL backend.'
@@ -130,6 +137,11 @@ class HysopArgParser(argparse.ArgumentParser):
domain = 'box'
if (default_dump_dir is None):
default_dump_dir = '{}/hysop/{}'.format(self.tmp_dir(), prog_name)
+ if (generate_io_params is None):
+ generate_io_params = ()
+ generate_io_params += ('checkpoint',)
+
+ self.default_dump_dir = default_dump_dir
self._domain = domain
@@ -143,71 +155,139 @@ class HysopArgParser(argparse.ArgumentParser):
self._add_opencl_args()
self._add_autotuner_args()
self._add_graphical_io_args()
- self._add_file_io_args(default_dump_dir)
+ self._add_file_io_args(default_dump_dir, generate_io_params)
self._add_term_io_args()
self._add_misc_args()
-
- def parse(self):
+
+ def pre_process_args(self, args):
+ pass
+
+ def run(self, program, **kwds):
args = self.parse_args()
args.__class__ = HysopNamespace
- self._check_threading_args(args)
-
- self._setup_hysop_env(args)
-
- # /!\ only import hysop from there on /!\
- # (env. variables have been correctly set)
- import hysop
-
- self._check_positional_args(args)
- self._check_main_args(args)
- self._check_domain_args(args)
- self._check_problem_args(args)
- self._check_simu_args(args)
- self._check_method_args(args)
- self._check_opencl_args(args)
- self._check_autotuner_args(args)
- self._check_graphical_io_args(args)
- self._check_file_io_args(args)
- self._check_term_io_args(args)
- self._check_misc_args(args)
-
- self._setup_parameters(args)
- self._setup_implementation(args)
-
- return args
-
- def run(self, program, **kwds):
+ # SETUP I/O
from mpi4py import MPI
size = MPI.COMM_WORLD.Get_size()
rank = MPI.COMM_WORLD.Get_rank()
-
- args = self.parse()
- args.stdout = self._fmt_filename(args.stdout, rank, size, args)
- args.stderr = self._fmt_filename(args.stderr, rank, size, args)
+ self.size = size
+ self.rank = rank
+
+ self.default_dump_dir = self._fmt_filename(self.default_dump_dir, rank, size,
+ args.dump_dir, self.default_dump_dir)
+
+ self.pre_process_args(args)
+ self._check_term_io_args(args)
+ self._check_file_io_args(args)
+
+ args.stdout = self._fmt_filename(args.stdout, rank, size, args.dump_dir, self.default_dump_dir)
+ args.stderr = self._fmt_filename(args.stderr, rank, size, args.dump_dir, self.default_dump_dir)
self._rmfile(args.stdout)
self._rmfile(args.stderr)
+
if args.clean:
- dump_dir = '{}/p{}'.format(args.dump_dir, size)
- self._rmfiles(dump_dir, 'h5')
- self._rmfiles(dump_dir, 'xmf')
- self._rmfiles(dump_dir, 'out')
- self._rmfiles(dump_dir, 'txt')
- self._rmfiles(dump_dir, 'png')
- self._rmdir(dump_dir, 'generated_kernels', force=True)
- self._rmdir(dump_dir, 'spectral', force=True)
-
- with self.redirect_stdout(rank, args), self.redirect_stderr(rank, args):
- from hysop.tools.contexts import printoptions
- with printoptions(threshold=10000, linewidth=240,
- nanstr='nan', infstr='inf',
- formatter={'float': lambda x: '{:>6.2f}'.format(x)}):
- program(args, **kwds)
+ dump_dirs = set([args.dump_dir, args.autotuner_dump_dir])
+ dump_dirs.update(getattr(args, '{}_dump_dir'.format(pname))
+ for pname in self.generate_io_params)
+ dump_dirs = filter(lambda ddir: isinstance(ddir, str), dump_dirs)
+ dump_dirs = map(lambda ddir: os.path.abspath(ddir), dump_dirs)
+ dump_dirs = filter(lambda ddir: os.path.isdir(ddir) and \
+ (ddir not in ('/','/home','~',os.path.expanduser('~'))), dump_dirs)
+ if args.no_interactive:
+ confirm_deletion = True
+ else:
+ msg='HySoP will clean the following directories prior to launch:'
+ for ddir in dump_dirs:
+ msg+='\n {}'.format(ddir)
+ print msg
+ valid = {"yes": True, "y": True,
+ "no": False, "n": False,
+ '': True}
+ confirm_deletion = None
+ while (confirm_deletion is None):
+ prompt='Please confirm this action [Y/n]: '
+ sys.stdout.write(prompt)
+ choice = raw_input().lower().strip()
+ if (choice in valid):
+ confirm_deletion = valid[choice]
+
+ assert isinstance(confirm_deletion, bool)
+ if confirm_deletion:
+ for ddir in dump_dirs:
+ # tar should be kept for checkpoint dumps
+ self._rmfiles(ddir, 'txt')
+ self._rmfiles(ddir, 'out')
+ self._rmfiles(ddir, 'log')
+ self._rmfiles(ddir, 'png')
+ self._rmfiles(ddir, 'jpg')
+ self._rmfiles(ddir, 'eps')
+ self._rmfiles(ddir, 'pdf')
+ self._rmfiles(ddir, 'xml')
+ self._rmfiles(ddir, 'json')
+ self._rmfiles(ddir, 'h5')
+ self._rmfiles(ddir, 'xmf')
+ self._rmfiles(ddir, 'cl')
+ self._rmfiles(ddir, 'sim')
+ self._rmfiles(ddir, 'npz')
+ self._rmfiles(ddir, 'pklz')
+ self._rmdir(ddir, 'generated_kernels', force=True)
+ self._rmdir(ddir, 'spectral', force=True)
+ else:
+ print 'Deletion skipped by user.'
+
+ MPI.COMM_WORLD.Barrier()
+
+ with self.redirect_stdout(rank, size, args), self.redirect_stderr(rank, size, args):
+ # Build hysop environment (without importing hysop)
+ self._check_threading_args(args)
+ self._setup_hysop_env(args)
+
+ # /!\ only import hysop from there on /!\
+ # (env. variables have been correctly set)
+ import hysop
+ from hysop import vprint
+
+ # register exit handler
+ def at_exit(rank, size, args):
+ if (rank in args.tee_ranks):
+ vprint(self._rank_filter('Logs have been dumped to \'{}\'.'.format(args.stdout),
+ rank=rank, size=size))
+ MPI.COMM_WORLD.Barrier()
+ if (size>1) and (rank == args.tee_ranks[0]):
+ vprint()
+ atexit.register(at_exit, rank=rank, size=size, args=args)
+
+ # check remaining arguments
+ self._check_positional_args(args)
+ self._check_main_args(args)
+ self._check_domain_args(args)
+ self._check_problem_args(args)
+ self._check_simu_args(args)
+ self._check_method_args(args)
+ self._check_opencl_args(args)
+ self._check_autotuner_args(args)
+ self._check_graphical_io_args(args)
+ self._check_misc_args(args)
+
+ # setup arguments
+ self._setup_parameters(args)
+ self._setup_implementation(args)
+
+ MPI.COMM_WORLD.Barrier()
+
+ # filter numpy arrays and run program
+ from hysop.tools.contexts import printoptions
+ with printoptions(threshold=10000, linewidth=240,
+ nanstr='nan', infstr='inf',
+ formatter={'float': lambda x: '{:>6.2f}'.format(x)}):
+ program(args, **kwds)
@staticmethod
- def _fmt_filename(filename, rank, size, args):
- return filename.format(rank=rank, size=size, dpath=args.dump_dir)
+ def _fmt_filename(filename, rank, size, dump_dir, default_dump_dir):
+ return filename.format(rank=rank, size=size,
+ dump_dir=dump_dir,
+ default_dump_dir=default_dump_dir)
@staticmethod
def _color_filter(msg):
@@ -216,10 +296,20 @@ class HysopArgParser(argparse.ArgumentParser):
@staticmethod
def _null_filter(msg):
return None
-
+
@staticmethod
- def _mkdir(path):
- path = os.path.dirname(os.path.realpath(path))
+ def _rank_filter(msg, rank, size):
+ if (size>1):
+ prefix='\n[P{}] '.format(rank)
+ return msg.replace('\n', prefix)
+ else:
+ return msg
+
+ @staticmethod
+ def _mkdir(path, dirname=True):
+ path = os.path.realpath(path)
+ if dirname:
+ path = os.path.dirname(path)
try:
os.makedirs(path)
except OSError as e:
@@ -251,24 +341,28 @@ class HysopArgParser(argparse.ArgumentParser):
msg='Are you sure you want to delete {} y/n ?'
msg=msg.format(path)
remove='u'
- if force:
- shutil.rmtree(path)
- else:
- while(remove not in ('y','n')):
- remove = raw_input(msg)
- if (remove=='y'):
+ try:
+ if force:
shutil.rmtree(path)
+ else:
+ while(remove not in ('y','n')):
+ remove = raw_input(msg)
+ if (remove=='y'):
+ shutil.rmtree(path)
+ except OSError as e:
+ if (e.errno != errno.ENOENT):
+ raise
@contextlib.contextmanager
- def redirect_stdout(self, rank, args):
+ def redirect_stdout(self, rank, size, args):
redirect_to_terminal = (rank in args.tee_ranks)
file_filters = [self._color_filter]
if redirect_to_terminal:
- stream_filters = []
+ stream_filters = [functools.partial(self._rank_filter, rank=rank, size=size)]
else:
stream_filters = [self._null_filter]
-
+
self._mkdir(args.stdout)
with StdoutTee(args.stdout, mode='a',
file_filters=file_filters,
@@ -276,12 +370,12 @@ class HysopArgParser(argparse.ArgumentParser):
yield
@contextlib.contextmanager
- def redirect_stderr(self, rank, args):
+ def redirect_stderr(self, rank, size, args):
redirect_to_terminal = (rank in args.tee_ranks)
-
+
file_filters = [self._color_filter]
if redirect_to_terminal:
- stream_filters = []
+ stream_filters = [functools.partial(self._rank_filter, rank=rank, size=size)]
else:
stream_filters = [self._null_filter]
@@ -328,6 +422,13 @@ class HysopArgParser(argparse.ArgumentParser):
action=self.split, container=tuple, convert=int, append=False,
dest='npts',
help='Cartesian discretization, number of points in each direction.')
+ discretization.add_argument('-sd', '--scalar-discretization', type=str, default=None,
+ action=self.split, container=tuple, convert=int, append=False,
+ dest='snpts',
+ help='Cartesian discretization, number of points in each direction for scalars.')
+ discretization.add_argument('-gr', '--grid-ratio', type=int, default=1,
+ dest='grid_ratio',
+ help='Cartesian discretization, number of points in each direction for scalars compared to base velocity and vorticity grid.')
discretization.add_argument('-bo', '--box-origin', type=str, default=(0.0,),
action=self.split, container=tuple, convert=float, append=False,
dest='box_origin',
@@ -348,7 +449,8 @@ class HysopArgParser(argparse.ArgumentParser):
self.error(msg)
if (self._domain == 'box'):
npts = args.npts
- box_origin = args.box_origin
+ snpts = args.snpts
+ box_origin = args.box_origin
box_length = args.box_length
self._check_default(args, ('npts', 'box_origin', 'box_length'), tuple)
if len(npts)==1:
@@ -377,7 +479,25 @@ class HysopArgParser(argparse.ArgumentParser):
msg='Negative box length encountered.'
msg+='\nGot {}.'.format(box_length)
self.error(msg)
+ if snpts:
+ if len(snpts)==1:
+ snpts *= dim
+ if len(snpts)!=dim:
+ msg='Discretization should be of the same size as the dimension.'
+ msg+='\nGot {} but ndim={}.'.format(snpts, dim)
+ self.error(msg)
+ if any(x<=0 for x in snpts):
+ msg='Negative discretization encountered.'
+ msg+='\nGot {}.'.format(snpts)
+ self.error(msg)
+ elif args.grid_ratio:
+ assert args.grid_ratio>=1
+ gr = args.grid_ratio
+ snpts = tuple(di*gr for di in npts)
+ else:
+ snpts = npts[:]
args.npts = npts
+ args.snpts = snpts
args.box_origin = box_origin
args.box_length = box_length
else:
@@ -405,15 +525,21 @@ class HysopArgParser(argparse.ArgumentParser):
help=('Specify timestep instead of a number of iterations '+
'(has priority over number of iterations).'+
' This will be the initial timestep when using adaptive timestep.'))
+ simu.add_argument('-fts', '--fixed-timestep', default=False, action='store_true',
+ dest='fixed_timestep',
+ help='Disable variable timestepping. In this case, timestep has to be specified with -dt or -nb_iter.')
+ simu.add_argument('-mindt', '--min-timestep', type=float,
+ default=np.finfo(np.float64).eps, dest='min_dt',
+ help='Enforce a minimal timestep.')
+ simu.add_argument('-maxdt', '--max-timestep', type=float, default=np.inf,
+ dest='max_dt',
+ help='Enforce a maximal timestep.')
simu.add_argument('-cfl', '--cfl', type=float, default=None,
dest='cfl',
help='Specify CFL for adaptive time stepping.')
simu.add_argument('-lcfl', '--lagrangian-cfl', type=float, default=None,
dest='lcfl',
help='Specify LCFL for adaptive time stepping.')
- simu.add_argument('-dr', '--dry-run', default=False, action='store_true',
- dest='dry_run',
- help='Stop execution before the first simulation iteration.')
def _add_problem_args(self):
problem = self.add_argument_group('Problem parameters')
@@ -435,6 +561,9 @@ class HysopArgParser(argparse.ArgumentParser):
problem.add_argument('-stopb', '--stop-at-build', default=False, action='store_true',
dest='stop_at_build',
help='Stop execution once the problem has been built.')
+ problem.add_argument('-dr', '--dry-run', default=False, action='store_true',
+ dest='dry_run',
+ help='Stop execution before the first simulation iteration.')
return problem
def _check_problem_args(self, args):
@@ -445,8 +574,8 @@ class HysopArgParser(argparse.ArgumentParser):
self._check_default(args, ('tstart', 'tend'), float)
self._check_default(args, 'dt', float, allow_none=True)
self._check_default(args, 'nb_iter', int, allow_none=True)
- self._check_default(args, 'dry_run', bool, allow_none=False)
- self._check_positive(args, 'dt', strict=True, allow_none=True)
+ self._check_default(args, ('dry_run', 'fixed_timestep'), bool, allow_none=False)
+ self._check_positive(args, ('dt', 'min_dt', 'max_dt'), strict=True, allow_none=True)
self._check_positive(args, 'nb_iter', strict=True, allow_none=True)
self._check_positive(args, 'max_iter', strict=True, allow_none=True)
self._check_positive(args, 'cfl', strict=True, allow_none=True)
@@ -455,6 +584,15 @@ class HysopArgParser(argparse.ArgumentParser):
msg=('\nTimestep and number of iterations specified in the same time, '
+ 'using timestep.')
warnings.warn(msg, HysopArgumentWarning)
+ if ((args.min_dt is not None) and (args.max_dt is not None)
+ and (args.min_dt > args.max_dt)):
+ msg='\nmin_dt > max_dt'
+ self.error(msg)
+ if args.fixed_timestep and (args.dt is None) and (args.nb_iter is None):
+ msg='Fixed timestep requires a timestep or a number of iterations to be specified.'
+ self.error(msg)
+ args.variable_timestep = not args.fixed_timestep
+
def _add_method_args(self):
method = self.add_argument_group('Method parameters')
@@ -474,10 +612,22 @@ class HysopArgParser(argparse.ArgumentParser):
default='L4_2',
dest='remesh_kernel',
help='Set the default remeshing formula for advection-remeshing.')
- method.add_argument('-interp', '--interpolation', type=str,
- default='linear',
- dest='interpolation',
+ method.add_argument('-interp', '--interpolation-filter', type=str,
+ default='polynomial',
+ dest='interpolation_filter',
help='Set the default interpolation formula to compute subgrid field values.')
+ method.add_argument('-restrict', '--restriction-filter', type=str,
+ default='polynomial',
+ dest='restriction_filter',
+ help='Set the default restriction formula to pass from fine grids to coarse ones.')
+ method.add_argument('-pi', '--polynomial-interpolator', type=str,
+ default='LINEAR',
+ dest='polynomial_interpolator',
+ help='Set the default polynomial interpolator for polynomial interpolation or restriction methods.')
+ method.add_argument('-ai', '--advection-interpolator', type=str,
+ default='LEGACY',
+ dest='advection_interpolator',
+ help='Set the default polynomial interpolator for bilevel advection. Legacy interpolator uses linear interpolation, else specify a custom polynomial interpolator.')
method.add_argument('-sf', '--stretching-formulation', type=str,
default='conservative',
dest='stretching_formulation',
@@ -490,13 +640,26 @@ class HysopArgParser(argparse.ArgumentParser):
default=2,
dest='strang_order',
help='Set the default directional splitting order.')
+ method.add_argument('-sdm', '--scalars-diffusion-mode', type=str,
+ default='spectral', dest='scalars_diffusion_mode',
+ help='Enforce either spectral or directional diffusion with finite differences for scalars. Vorticity diffusion mode may not be enforced by this parameter, see --vorticity-diffusion-mode. The default value is spectral diffusion mode.')
+ method.add_argument('-vdm', '--vorticity-diffusion-mode', type=str,
+ default='spectral', dest='vorticity_diffusion_mode',
+ help='Enforce either spectral or directional diffusion with finite differences for vorticity. Vorticity is a special case for diffusion because vorticity diffusion can be computed at the same time as the Poisson operator which recovers the velocity. Spectral diffusion of vorticity when divergence-free field projection is enabled is virtually free. The default value is spectral diffusion mode.')
+ method.add_argument('--enable-diffusion-substepping',
+ dest='enable_diffusion_substepping', default=False, action='store_true',
+ help='Do not restrict timestep because of finite difference directional diffusion CFL but enforce substepping inside the operator depending on current timestep.')
+
return method
def _check_method_args(self, args):
+ self._check_default(args, 'enable_diffusion_substepping', bool, allow_none=False)
self._check_default(args, ('compute_granularity', 'fd_order', 'strang_order',
'reprojection_frequency'), int, allow_none=False)
- self._check_default(args, ('time_integrator', 'remesh_kernel', 'interpolation',
- 'stretching_formulation'), str, allow_none=False)
+ self._check_default(args, ('time_integrator', 'remesh_kernel', 'interpolation_filter',
+ 'restriction_filter', 'stretching_formulation', 'polynomial_interpolator',
+ 'vorticity_diffusion_mode', 'scalars_diffusion_mode'),
+ str, allow_none=False)
self._check_positive(args, 'compute_granularity', strict=False, allow_none=False)
self._check_positive(args, 'fd_order', strict=True, allow_none=False)
self._check_positive(args, 'strang_order', strict=True, allow_none=False)
@@ -510,8 +673,18 @@ class HysopArgParser(argparse.ArgumentParser):
args.remesh_kernel)
args.stretching_formulation = self._convert_stretching_formulation(
'stretching_formulation', args.stretching_formulation)
- args.interpolation = self._convert_interpolation('interpolation',
- args.interpolation)
+ args.interpolation_filter = \
+ self._convert_filtering_method('interpolation_filter', args.interpolation_filter,
+ allow_subgrid=True)
+ args.restriction_filter = \
+ self._convert_filtering_method('restriction_filter', args.restriction_filter,
+ allow_subgrid=False)
+ args.polynomial_interpolator = \
+ self._convert_polynomial_interpolation('polynomial_interpolator', args.polynomial_interpolator)
+ args.advection_interpolator = \
+ self._convert_advection_interpolation('advection_interpolator', args.advection_interpolator)
+ self._check_and_set_diffusion_mode('vorticity_diffusion_mode', args)
+ self._check_and_set_diffusion_mode('scalars_diffusion_mode', args)
def _add_threading_args(self):
threading = self.add_argument_group('threading parameters')
@@ -521,9 +694,9 @@ class HysopArgParser(argparse.ArgumentParser):
dest='enable_threading',
help=msg)
msg='Set the default maximum usable threads for threading backends (OpenMP, MKL) and operator backends using threads (Numba, FFTW). '
- msg+='This parameter will set HYSOP_MAX_THREADS and does not affect the OpenCL backend.'
+ msg+='This parameter will set HYSOP_MAX_THREADS and does not affect the OpenCL backend. '
msg+="If this parameter is set to 'physical', the maximum number of threads will be set to the number of physical cores available to the process (taking into account the cpuset). "
- msg+="If set to 'logical', logical cores will be chosen instead. Else this parameter expects a positive integer."
+ msg+="If set to 'logical', logical cores will be chosen instead. Else this parameter expects a positive integer. "
msg+='If --enable-threads is set to False, this parameter is ignored and HYSOP_MAX_THREADS will be set to 1.'
threading.add_argument('--max-threads', type=str, default='physical',
dest='max_threads',
@@ -534,6 +707,12 @@ class HysopArgParser(argparse.ArgumentParser):
threading.add_argument('--mkl-threads', type=str, default=None,
dest='mkl_threads',
help='This parameter will set MKL_NUM_THREADS to a custom value (overrides --max-threads).')
+ threading.add_argument('--mkl-domain-threads', type=str, default=None,
+ dest='mkl_domain_threads',
+ help='This parameter will set MKL_DOMAIN_NUM_THREADS to a custom value (overrides --max-threads).')
+ threading.add_argument('--mkl-threading-layer', type=str, default='TBB',
+ dest='mkl_threading_layer',
+ help="This parameter will set MKL_THREADING_LAYER to a custom value ('TBB', 'GNU', 'INTEL', 'SEQUENTIAL').")
threading.add_argument('--numba-threads', type=str, default=None,
dest='numba_threads',
help='This parameter will set NUMBA_NUM_THREADS to a custom value (overrides --max-threads).')
@@ -590,9 +769,9 @@ class HysopArgParser(argparse.ArgumentParser):
return opencl
def _check_threading_args(self, args):
- self._check_default(args, ('enable_threading', 'max_threads', 'numba_threading_layer',
+ self._check_default(args, ('enable_threading', 'max_threads', 'mkl_threading_layer', 'numba_threading_layer',
'fftw_planner_effort', 'fftw_planner_timelimit'), str, allow_none=False)
- self._check_default(args, ('openmp_threads', 'mkl_threads', 'numba_threads', 'fftw_threads'),
+ self._check_default(args, ('openmp_threads', 'mkl_threads', 'mkl_domain_threads', 'numba_threads', 'fftw_threads'),
str, allow_none=True)
args.enable_threading = self._convert_bool('enable_threading', args.enable_threading)
@@ -603,6 +782,8 @@ class HysopArgParser(argparse.ArgumentParser):
for argname in ('openmp_threads', 'mkl_threads', 'numba_threads', 'fftw_threads'):
setattr(args, argname, self._convert_threads(argname, getattr(args, argname),
default=args.max_threads))
+ args.mkl_threading_layer = self._convert_mkl_threading_layer('mkl_threading_layer',
+ args.mkl_threading_layer)
args.numba_threading_layer = self._convert_numba_threading_layer('numba_threading_layer',
args.numba_threading_layer)
args.fftw_planner_effort = self._convert_fftw_planner_effort('fftw_planner_effort',
@@ -640,6 +821,14 @@ class HysopArgParser(argparse.ArgumentParser):
def _add_autotuner_args(self):
autotuner = self.add_argument_group('Kernel autotuner parameters')
+ autotuner.add_argument('--autotuner-dump-dir', type=str, default=None,
+ dest='autotuner_dump_dir',
+ help='Configure kernel autotuner dump directory.')
+ autotuner.add_argument('--autotuner-cache-override',
+ default=False, action='store_true',
+ dest='autotuner_cache_override',
+ help=('Override kernel autotuner cached data. Best kernels candidates will be stored in '
+ + 'a temporary directory instead of persistant system-wide cache directory.'))
autotuner.add_argument('--autotuner-flag', type=str, default=None,
dest='autotuner_flag',
help=('Configure kernel autotuner rigor flag'
@@ -656,40 +845,89 @@ class HysopArgParser(argparse.ArgumentParser):
autotuner.add_argument('--autotuner-verbose', type=int, default=None,
dest='autotuner_verbose',
help='Configure kernel autotuner kernel verbosity (0 to 5).')
- autotuner.add_argument('--autotuner-debug', type=bool, default=None,
+ autotuner.add_argument('--autotuner-debug',
+ default=False, action='store_true',
dest='autotuner_debug',
help='Configure kernel autotuner kernel debug flag.')
- autotuner.add_argument('--autotuner-dump-kernels', type=bool, default=None,
+ autotuner.add_argument('--autotuner-dump-kernels',
+ default=False, action='store_true',
dest='autotuner_dump_kernels',
help='Configure kernel autotuner kernel source dumping.')
- autotuner.add_argument('--autotuner-dump-isolation', type=bool, default=None,
+ autotuner.add_argument('--autotuner-dump-isolation',
+ default=False, action='store_true',
dest='autotuner_dump_isolation',
- help='Configure kernel autotuner kernel isolation file generation.')
- autotuner.add_argument('--autotuner-cache-override', type=bool, default=None,
- dest='autotuner_cache_override',
- help='Override kernel autotuner cached data.')
- autotuner.add_argument('--autotuner-dump-dir', type=str, default=None,
- dest='autotuner_dump_dir',
- help='Configure kernel autotuner dump directory.')
+ help='Configure kernel autotuner to generate oclgrind kernel isolation files for each optimal kernel.')
+ autotuner.add_argument('--autotuner-dump-hash-logs',
+ default=False, action='store_true',
+ dest='autotuner_dump_hash_logs',
+ help=('Configure kernel autotuner to generate kernel extra keywords hash logs '
+ +'for kernel caching debugging purposes.'))
+ autotuner.add_argument('--autotuner-filter-statistics',
+ type=str, default='.*',
+ dest='autotuner_filter_statistics',
+ help=('Space separated list of regular expressions to match against kernel names. '
+ +'A kernel that matches becomes candidate for statistics, postprocessing, source and isolation dump, if enabled. '
+ +'If not specified, all kernels are considered by default by using the generic \'.*\' pattern.'))
+ autotuner.add_argument('--autotuner-plot-statistics',
+ default=False, action='store_true',
+ dest='autotuner_plot_statistics',
+ help='Compute and plot tuning statistics for all tuned kernels.')
+ autotuner.add_argument('--autotuner-bench-kernels',
+ default=False, action='store_true',
+ dest='autotuner_bench_kernels',
+ help=('Enable standard bench mode for kernels: search without max candidates '
+ +'at maximum verbosity with cache override and nruns=8. '
+ +'Prune threshold and autotuner flag are however not modified.'))
+ autotuner.add_argument('--autotuner-postprocess-kernels', type=str, default=None,
+ dest='autotuner_postprocess_kernels',
+ help=('Run a custom command after each final generated kernel: '
+ +'command FILE_BASENAME FROM_CACHE AUTOTUNER_DUMP_DIR AUTOTUNER_NAME KERNEL_NAME '
+ +'MEAN_EXECUTION_TIME_NS MIN_EXECUTION_TIME_NS MAX_EXECUTION_TIME_NS '
+ +'KERNEL_SOURCE_FILE KERNEL_ISOLATION_FILE KERNEL_HASH_LOGS_FILE '
+ +'VENDOR_NAME DEVICE_NAME WORK_SIZE WORK_LOAD GLOBAL_WORK_SIZE '
+ +'LOCAL_WORK_SIZE EXTRA_PARAMETERS EXTRA_KWDS_HASH SRC_HASH. '
+ +'See hysop/tools/postprocess_kernel.sh for an example of post processing script.'))
+ autotuner.add_argument('--autotuner-postprocess-nruns', type=int, default=16,
+ dest='autotuner_postprocess_nruns',
+ help='Number of time to run the best obtained kernel with autotuning_mode set to False.')
+
return autotuner
def _check_autotuner_args(self, args):
- self._check_default(args, ('autotuner_flag', 'autotuner_dump_dir'),
- str, allow_none=True)
+ self._check_default(args, ('autotuner_flag', 'autotuner_dump_dir',
+ 'autotuner_postprocess_kernels', 'autotuner_filter_statistics'),
+ str, allow_none=True)
self._check_default(args, ('autotuner_nruns', 'autotuner_max_candidates',
- 'autotuner_verbose'), int, allow_none=True)
- self._check_default(args, ('autotuner_dump_kernels', 'autotuner_dump_isolation'),
- bool, allow_none=True)
+ 'autotuner_verbose', 'autotuner_postprocess_nruns'), int, allow_none=True)
+ self._check_default(args, ('autotuner_dump_kernels',
+ 'autotuner_dump_isolation',
+ 'autotuner_dump_hash_logs',
+ 'autotuner_bench_kernels',
+ 'autotuner_plot_statistics'),
+ bool, allow_none=True)
self._check_default(args, 'autotuner_prune_threshold', float, allow_none=True)
- self._check_positive(args, ('autotuner_nruns', 'autotuner_max_candidates'),
+ self._check_positive(args, ('autotuner_nruns', 'autotuner_max_candidates',
+ 'autotuner_postprocess_nruns'),
strict=True, allow_none=True)
self._check_positive(args, 'autotuner_verbose', strict=False, allow_none=True)
self._check_range(args, 'autotuner_prune_threshold', 1.0, 5.0, allow_none=True)
self._check_dir(args, 'autotuner_dump_dir', allow_shared=True, allow_none=True)
-
+
args.autotuner_flag = self._convert_autotuner_flag('autotuner_flag',
args.autotuner_flag)
+
+ patterns = filter(lambda x: len(x), args.autotuner_filter_statistics.split(' '))
+ patterns = tuple(re.compile(e) for e in patterns)
+ def filter_statistics(kernel_name, patterns=patterns):
+ return any(pat.match(kernel_name) for pat in patterns)
+ args.autotuner_filter_statistics = filter_statistics
+
+ if args.autotuner_bench_kernels:
+ args.autotuner_nruns = 8
+ args.autotuner_max_candidates = np.iinfo(np.int64).max
+ args.autotuner_verbose = np.iinfo(np.int64).max
+ args.autotuner_cache_override = True
def _build_autotuner_config(self, args):
from hysop.methods import OpenClKernelAutotunerConfig
@@ -705,25 +943,157 @@ class HysopArgParser(argparse.ArgumentParser):
verbose=args.autotuner_verbose,
debug=args.autotuner_debug,
dump_kernels=args.autotuner_dump_kernels,
+ dump_hash_logs=args.autotuner_dump_hash_logs,
generate_isolation_file=args.autotuner_dump_isolation,
+ plot_statistics=args.autotuner_plot_statistics,
override_cache=override_cache,
- dump_folder=args.autotuner_dump_dir)
+ dump_folder=args.autotuner_dump_dir,
+ postprocess_kernels=args.autotuner_postprocess_kernels,
+ postprocess_nruns=args.autotuner_postprocess_nruns,
+ filter_statistics=args.autotuner_filter_statistics)
return autotuner_config
- def _add_file_io_args(self, default_dump_dir):
+ def _add_file_io_args(self, default_dump_dir, generate_io_params):
+
file_io = self.add_argument_group('File I/O')
+
file_io.add_argument('--dump-dir', type=str, default=default_dump_dir,
dest='dump_dir',
- help=('HySoP output directory.'
+ help=('Global output directory for all IO params.'
+' Overrides HYSOP_DUMP_DIR.'.format(default_dump_dir)))
- file_io.add_argument('--dump-freq', type=int, default=10,
+ file_io.add_argument('--dump-freq', type=int, default=0,
dest='dump_freq',
- help=('HDF5 output frequency in terms of iterations.'
+ help=('Global output frequency in terms of number of iterations for all IO params.'
+' Use 0 to disable frequency based dumping.'))
- file_io.add_argument('--dump-times', type=str, default=None, convert=float,
+ file_io.add_argument('--dump-period', type=float, default=0.0,
+ dest='dump_period',
+ help=('Global output period for all IO params.'
+ +' This will append linspace(tstart, tend, int((tend-tstart)/dump_period)) to times of interest.'
+ +' Use 0.0 to disable period based dumping.'))
+ file_io.add_argument('--dump-times', type=str, default=None, convert=float, nargs='?', const=tuple(),
action=self.split, container=tuple, append=False,
dest='dump_times',
- help='Comma delimited list of additional HDF5 output times of interest.')
+ help='Global comma delimited list of additional output times of interest for all io_params.')
+ file_io.add_argument('--dump-tstart', type=float, default=None,
+ dest='dump_tstart',
+ help='Set global starting time at which output are dumped for all IO params. Defaults to simulation start.')
+ file_io.add_argument('--dump-tend', type=float, default=None,
+ dest='dump_tend',
+ help='Set global end time at which output are dumped for all IO params. Defaults to simulation end.')
+ file_io.add_argument('--dump-last', action='store_true', dest='dump_last',
+ help='If set, always dump on last simulation iteration.')
+ file_io.add_argument('--dump-postprocess', type=str, default=None,
+ dest='postprocess_dump',
+ help=('Run a custom command after I/O dump: '
+ +'command FILENAME\n'
+ +'See hysop/tools/postprocess_dump.sh for an example of post processing script.\n'
+ +'I/O can be postprocessed directly from RAM by setting --enable-ram-fs.'))
+ file_io.add_argument('--dump-is-temporary', default=False, action='store_true',
+ dest='dump_is_temporary',
+ help='Delete dumped data files after callback has been executed. Best used with --enable-ram-fs and --dump-post-process.')
+ file_io.add_argument('--enable-ram-fs', default=False, action='store_true',
+ dest='enable_ram_fs',
+ help='Dump I/O directly into RAM (if possible), else fallback to --dump-dir unless --force-ram-fs has been set.')
+ file_io.add_argument('--force-ram-fs', default=False, action='store_true',
+ dest='force_ram_fs',
+ help='Dump I/O directly into RAM. Raises an EnvironmentError when no ramfs is available. Implies --enable-ram-fs. When enabled --dump-dir is ignored.')
+ file_io.add_argument('--hdf5-disable-compression', default=False, action='store_true',
+ dest='hdf5_disable_compression',
+ help='Disable compression for HDF5 outputs (when available).')
+ file_io.add_argument('--hdf5-disable-slicing', default=False, action='store_true',
+ dest='hdf5_disable_slicing',
+ help=('Disable HDF5 slicing that is obtained with XDMF JOIN. '
+ 'May reduce performances when HDF5 slicing applies (<= 16 processes slab topologies).'
+ 'Enabling this option guarantees a single HDF5 file for all processes per dump.'))
+
+ # list of additional named io_params to be generated
+ assert (generate_io_params is not None), generate_io_params
+ assert 'checkpoint' in generate_io_params, generate_io_params
+
+ self.generate_io_params = generate_io_params
+ for pname in generate_io_params:
+ if (pname == 'checkpoint'):
+ description = ('Configure problem checkpoints I/O parameters, dumped checkpoints represent simulation states '
+ 'that can be loaded back to continue the simulation later on.')
+ pargs = self.add_argument_group('{} I/O'.format(pname.upper()), description=description)
+ pargs.add_argument('-L', '--load-checkpoint', default=None, const='checkpoint.tar', nargs='?', type=str, dest='load_checkpoint_path',
+ help=('Begin simulation from this checkpoint. Can be given as fullpath or as a filename relative to --checkpoint-dump-dir. '
+ 'The given checkpoint has to be compatible with the problem it will be loaded to. '
+ 'This will only work if parameter names, variable names, operator names, discretization and global topology information remain unchanged. '
+ 'Operator ordering, boundary conditions, data ordering, data permutation and MPI layouts may be however be changed. '
+ 'Defaults to {checkpoint_output_dir}/checkpoint.tar if no filename is specified.'))
+ pargs.add_argument('-S', '--save-checkpoint', default=None, const='checkpoint.tar', nargs='?', type=str, dest='save_checkpoint_path',
+ help=('Enable simulation checkpoints to be able to restart simulations from a specific point later on. '
+ 'Can be given as fullpath or as a filename relative to --checkpoint-dump-dir. '
+ 'Frequency or time of interests for checkpoints can be configured by using global FILE I/O parameters or '
+ 'specific --checkpoint-dump-* arguments which takes priority over global ones. '
+ 'Should not be to frequent for efficiency reasons. May be used in conjunction with --load-checkpoint, '
+ 'in which case the starting checkpoint may be overwritten in the case the same path are given. '
+ 'Defaults to {checkpoint_output_dir}/checkpoint.tar if no filename is specified.'))
+ pargs.add_argument('--checkpoint-compression-method', type=str, default=None, dest='checkpoint_compression_method',
+ help='Set the compression method used by the Blosc meta-compressor for checkpoint array data. Defaults to zstd.')
+ pargs.add_argument('--checkpoint-compression-level', type=int, default=None, dest='checkpoint_compression_level',
+ help='Set the compression level used by the Blosc meta-compressor for checkpoint array data, from 0 (no compression) to 9 (maximum compression). Defaults to 6.')
+ pargs.add_argument('--checkpoint-relax-constraints', action='store_true', dest='checkpoint_relax_constraints',
+ help=('Relax field/parameter checks when loading a checkpoint. This allows for a change in datatype, '
+ 'boundary conditions, ghost count and topology shape when reloading a checkpoint. '
+ 'Useful to continue a simulation with a different precision, different compute backend, '
+ 'different boundary conditions or with a different number of processes.'))
+ else:
+ pargs = self.add_argument_group('{} I/O'.format(pname.upper()))
+
+ assert isinstance(pname, str), pname
+ pargs.add_argument('--{}-dump-dir'.format(pname),
+ type=str, default=None,
+ dest='{}_dump_dir'.format(pname),
+ help='Custom output directory for custom IO parameter \'{}.\''.format(pname))
+ pargs.add_argument('--{}-dump-freq'.format(pname),
+ type=int, default=None,
+ dest='{}_dump_freq'.format(pname),
+ help='Custom output frequency in terms of number of iterations for IO parameter \'{}.\''.format(pname))
+ pargs.add_argument('--{}-dump-period'.format(pname),
+ type=float, default=None,
+ dest='{}_dump_period'.format(pname),
+ help='Custom output period for IO parameter \'{}.\''.format(pname))
+ pargs.add_argument('--{}-dump-times'.format(pname), nargs='?', const=tuple(),
+ action=self.split, container=tuple, append=False,
+ type=str, default=None, convert=float,
+ dest='{}_dump_times'.format(pname),
+ help='Comma delimited list of additional output times of interest for IO parameter \'{}.\''.format(pname))
+ pargs.add_argument('--{}-dump-tstart'.format(pname),
+ type=float, default=None,
+ dest='{}_dump_tstart'.format(pname),
+ help='Set starting time at which output are dumped for IO parameter \'{}\'.'.format(pname))
+ pargs.add_argument('--{}-dump-tend'.format(pname),
+ type=float, default=None,
+ dest='{}_dump_tend'.format(pname),
+ help='Set end time at which output are dumped for IO parameter \'{}\'.'.format(pname))
+ pargs.add_argument('--{}-dump-last'.format(pname), action='store_true',
+ dest='{}_dump_last'.format(pname),
+ help='If set, always dump on last simulation iteration for IO parameter \'{}\''.format(pname))
+ pargs.add_argument('--{}-dump-postprocess'.format(pname), type=str, default=None,
+ dest='{}_postprocess_dump'.format(pname),
+ help=('Run a custom command after {} I/O dump: '.format(pname)
+ +'command FILENAME\n'
+ +'See hysop/tools/postprocess_dump.sh for an example of post processing script.\n'
+ +'{} I/O can be postprocessed directly from RAM by setting --enable-ram-fs.'.format(pname)))
+ pargs.add_argument('--{}-dump-is-temporary'.format(pname), default=None, action='store_true',
+ dest='{}_dump_is_temporary'.format(pname),
+ help='Delete {} data files after callback has been executed. Best used with --enable-ram-fs and --dump-post-process.'.format(pname))
+ pargs.add_argument('--{}-enable-ram-fs'.format(pname), default=None, action='store_true',
+ dest='{}_enable_ram_fs'.format(pname),
+ help='Dump I/O directly into RAM (if possible), else fallback to --dump-dir unless --force-ram-fs has been set.')
+ pargs.add_argument('--{}-force-ram-fs'.format(pname), default=None, action='store_true',
+ dest='{}_force_ram_fs'.format(pname),
+ help='Dump {} I/O directly into RAM (if possible), else raise an EnvironmentError. Implies --enable-ram-fs. When enabled --dump-dir is ignored.'.format(pname))
+ pargs.add_argument('--{}-hdf5-disable-compression'.format(pname), default=None, action='store_true',
+ dest='{}_hdf5_disable_compression'.format(pname),
+ help='Disable compression for {} HDF5 outputs (when available).'.format(pname))
+ pargs.add_argument('--{}-hdf5-disable-slicing'.format(pname), default=False, action='store_true',
+ dest='{}_hdf5_disable_slicing'.format(pname),
+ help='Disable HDF5 slicing that is obtained with XDMF JOIN for {}.'.format(pname))
+ setattr(file_io, '{}_io'.format(pname), pargs)
+
file_io.add_argument('--cache-dir', type=str, default=None,
dest='cache_dir',
help=('Specify an alternative HySoP caching directory.'
@@ -731,54 +1101,186 @@ class HysopArgParser(argparse.ArgumentParser):
file_io.add_argument('--override-cache', default=None, action='store_true',
dest='override_cache',
help='Ignore cached data.')
- file_io.add_argument('-C', '--clean', action='store_true', default=False,
- dest='clean',
- help=('Clean the dump_folder prior to launch '+
- '(remove all *.txt, *.png, *.xmf and *.h5 files)'))
file_io.add_argument('--debug-dump-dir', type=str,
- default='{}/hysop/debug'.format(self.tmp_dir()),
+ default=None,
dest='debug_dump_dir',
- help=('Target root directory for debug dumps. Debug dumps will appear into <dump dir>/<target>.'))
+ help=('Target root directory for debug dumps. Debug dumps will appear into <dump dir>/<target>. Defaults to global hysop dump_dir.'))
file_io.add_argument('--debug-dump-target', type=str, default=None,
dest='debug_dump_target',
help=('Tag for field debug dumps. Debug dumps will appear into <dump dir>/<target>.'))
+ file_io.add_argument('-C', '--clean', action='store_true', default=False,
+ dest='clean',
+ help=('Clean the dump_folders (default dump, autotuner dump and extra_io_params directories) prior to launch. '
+ + 'Remove all files matching the following extensions: '
+ + 'txt, out, log, png, jpg, eps, pdf, xml, json, h5, xmf, cl, sim, npz, pklz. '
+ + 'The user will be prompted to confirm action prior to cleaning unless --no-interactive or -N is passed.'))
+
return file_io
def _check_file_io_args(self, args):
- self._check_default(args, ('dump_dir', 'cache_dir',
- 'debug_dump_dir', 'debug_dump_target'), str, allow_none=True)
- self._check_default(args, ('dump_freq'), int, allow_none=True)
- self._check_default(args, ('dump_times'), tuple, allow_none=True)
- self._check_default(args, ('override_cache'), bool, allow_none=True)
- self._check_positive(args, 'dump_freq', strict=False, allow_none=False)
+ pnames = self.generate_io_params
+
+ self._check_default(args, ('debug_dump_dir', 'debug_dump_target'), str, allow_none=True)
+ self._check_default(args, 'override_cache', bool, allow_none=True)
self._check_default(args, 'clean', bool, allow_none=True)
- self._check_dir(args, 'dump_dir', allow_shared=True, allow_none=True)
+ self._check_default(args, ('cache_dir', 'postprocess_dump'), str, allow_none=True)
self._check_dir(args, 'cache_dir', allow_shared=False, allow_none=True)
-
+ self._check_default(args, ('no_interactive', 'dump_is_temporary',
+ 'enable_ram_fs', 'force_ram_fs', 'hdf5_disable_compression', 'hdf5_disable_slicing'),
+ bool, allow_none=False)
+
+ self._check_default(args, 'dump_dir', str, allow_none=False)
+ self._check_default(args, 'dump_freq', int, allow_none=True)
+ self._check_default(args, 'dump_period', float, allow_none=True)
+ self._check_default(args, 'dump_times', tuple, allow_none=True)
+ self._check_default(args, 'dump_last', bool, allow_none=False)
+ self._check_positive(args, 'dump_freq', strict=False, allow_none=False)
+ self._check_dir(args, 'dump_dir', allow_shared=True, allow_none=True)
+
+ self._check_default(args, ('tstart', 'tend'), float, allow_none=False)
+ self._check_default(args, ('dump_tstart', 'dump_tend'), float, allow_none=True)
+ args.dump_tstart = args.dump_tstart if (args.dump_tstart is not None) else args.tstart
+ args.dump_tend = args.dump_tend if (args.dump_tend is not None) else args.tend
if (args.tstart >= args.tend):
msg='Invalid time range for the simulation: tstart={}, tend={}.'
msg=msg.format(args.tstart, args.tend)
self.error(msg)
-
- if (args.dump_times is not None):
- args.dump_times = set(args.dump_times)
- msg='args.dump_times = {}\n'.format(args.dump_times)
- for dp in args.dump_times:
- if not isinstance(dp, float):
- msg='Dump time {} is not a float but a {}.'.format(dp, type(dp))
- self.error(msg)
- elif (dp<args.tstart):
- msg+='Dump time of interest t={} happens before tstart={}.'
- msg=msg.format(dp, args.tstart)
- self.error(msg)
- elif (dp==args.tend):
- msg+='Dump time of interest t={} happens exactly at tend={}.'
- msg=msg.format(dp, args.tend)
- self.error(msg)
- elif (dp>=args.tend):
- msg+='Dump time of interest t={} happens after tend={}.'
- msg=msg.format(dp, args.tend)
+ if (args.dump_tstart >= args.dump_tend):
+ msg='Invalid time range for the dumping: tstart={}, tend={}.'
+ msg=msg.format(args.dump_tstart, args.dump_tend)
+ self.error(msg)
+ if (args.dump_tstart < args.tstart):
+ msg='Cannot dump before the simulation starts: simulation.tstart={}, dump.tstart={}.'
+ msg=msg.format(args.tstart, args.dump_tstart)
+ self.error(msg)
+ if (args.dump_tend > args.tend):
+ msg='Cannot dump after the simulation ends: simulation.tend={}, dump.tend={}.'
+ msg=msg.format(args.tend, args.dump_tend)
+ self.error(msg)
+
+ times_of_interest = set()
+ tstart = args.dump_tstart
+ tend = args.dump_tend
+ T = tend-tstart
+ dt = args.dump_period
+
+ if (args.dump_times is not None) or ((args.dump_period is not None) and (args.dump_period > 0.0)):
+ args.dump_times = set() if (args.dump_times is None) else set(args.dump_times)
+ if (args.dump_period is not None) and (args.dump_period > 0.0):
+ ndumps = int(np.floor(T/dt)) + 1
+ toi = tstart + np.arange(ndumps)*dt
+ args.dump_times.update(toi)
+ args.dump_times = filter(lambda t: (t>=tstart) & (t<=tend), args.dump_times)
+ args.dump_times = tuple(sorted(args.dump_times))
+ times_of_interest.update(args.dump_times)
+
+ if args.force_ram_fs:
+ args.enable_ram_fs = True
+
+ if args.dump_is_temporary and (args.postprocess_dump is None):
+ msg='Dump is temporary but no postprocessing script has been supplied.'
+ self.error(msg)
+
+ for pname in pnames:
+ def _set_arg(args, argname, pname, prefix=''):
+ bname = '{}{}'.format(prefix, argname)
+ vname = '{}_{}'.format(pname, bname)
+ default_value = getattr(args, bname)
+ actual_value = getattr(args, vname)
+ if (actual_value is None):
+ setattr(args, vname, default_value)
+ value = getattr(args, vname)
+ return value
+ for argname in ('dir','freq','period','last', 'times','tstart','tend','is_temporary'):
+ _set_arg(args, argname, pname, prefix='dump_')
+ for argname in ('enable_ram_fs', 'force_ram_fs', 'hdf5_disable_compression', 'hdf5_disable_slicing', 'postprocess_dump'):
+ _set_arg(args, argname, pname)
+ if getattr(args, '{}_force_ram_fs'.format(pname)):
+ setattr(args, '{}_enable_ram_fs'.format(pname), True)
+ if getattr(args, '{}_dump_is_temporary'.format(pname)):
+ pd = getattr(args, '{}_postprocess_dump'.format(pname))
+ if (pd is None):
+ msg='{} dump is temporary but no postprocessing script has been supplied'.format(pname)
self.error(msg)
+
+ bname = '{}_dump'.format(pname)
+ self._check_default(args, '{}_dir'.format(bname), str, allow_none=False)
+ self._check_default(args, '{}_freq'.format(bname), int, allow_none=False)
+ self._check_default(args, '{}_period'.format(bname), float, allow_none=True)
+ self._check_default(args, '{}_times'.format(bname), tuple, allow_none=True)
+ self._check_default(args, '{}_last'.format(bname), bool, allow_none=True)
+ self._check_default(args, '{}_tstart'.format(bname), float, allow_none=False)
+ self._check_default(args, '{}_tend'.format(bname), float, allow_none=False)
+ self._check_positive(args, '{}_freq'.format(bname), strict=False, allow_none=False)
+ self._check_default(args,
+ tuple(map(lambda k: '{}_{}'.format('{}'.format(pname), k), ('dump_is_temporary',
+ 'enable_ram_fs', 'force_ram_fs', 'hdf5_disable_compression', 'hdf5_disable_slicing'))),
+ bool, allow_none=False)
+ self._check_dir(args, '{}_dir'.format(bname), allow_shared=True, allow_none=False)
+
+ ststart = '{}_tstart'.format(bname)
+ stend = '{}_tend'.format(bname)
+ tstart = getattr(args, ststart)
+ tend = getattr(args, stend)
+ T = tend-tstart
+ if (tstart >= tend):
+ msg='Invalid time range for the dumping of IO parameter {}: {}={}, {}={}.'
+ msg=msg.format(pname, ststart, tstart, stend, tend)
+ self.error(msg)
+ if (tstart < args.tstart):
+ msg='Cannot dump before the simulation starts for IO parameter {}: simulation.tstart={}, {}={}.'
+ msg=msg.format(pname, args.tstart, ststart, tstart)
+ self.error(msg)
+ if (tend > args.tend):
+ msg='Cannot dump after the simulation ends for IO parameter {}: simulation.tend={}, {}={}.'
+ msg=msg.format(pname, args.tend, stend, tend)
+ self.error(msg)
+
+ dump_times = getattr(args, '{}_times'.format(bname))
+ dump_period = getattr(args, '{}_period'.format(bname))
+
+ dump_times = set() if (dump_times is None) else set(dump_times)
+ if (dump_period is not None) and (dump_period > 0.0):
+ dt = dump_period
+ ndumps = int(np.floor(T/dt)) + 1
+ toi = tstart + np.arange(ndumps)*dt
+ dump_times.update(toi)
+ dump_times = filter(lambda t: (t>=tstart) & (t<=tend), dump_times)
+
+ setattr(args, '{}_times'.format(bname), tuple(sorted(dump_times)))
+ times_of_interest.update(dump_times)
+
+ msg='args.times_of_interest = {}\n'.format(times_of_interest)
+
+ times_of_interest = tuple(sorted(times_of_interest))
+ if (len(times_of_interest)>0) and (times_of_interest[-1] == args.tend):
+ args.tend += np.finfo(np.float32).eps
+
+ for dp in times_of_interest[::-1]:
+ if not isinstance(dp, float):
+ msg='Dump time {} is not a float but a {}.'.format(dp, type(dp))
+ self.error(msg)
+ elif (dp<args.tstart):
+ msg+='Dump times of interest t={} happens before tstart={}.'
+ msg=msg.format(dp, args.tstart)
+ self.error(msg)
+ elif (dp==args.tend):
+ msg+='Dump times of interest t={} happens exactly at tend={}.'
+ msg=msg.format(dp, args.tend)
+ self.error(msg)
+ elif (dp>=args.tend):
+ msg+='Dump times of interest t={} happens after tend={}.'
+ msg=msg.format(dp, args.tend)
+ self.error(msg)
+
+ args.times_of_interest = times_of_interest
+
+ # extra checkpoints arguments
+ self._check_default(args, 'load_checkpoint_path', str, allow_none=True)
+ self._check_default(args, 'save_checkpoint_path', str, allow_none=True)
+ self._check_default(args, 'checkpoint_relax_constraints', bool, allow_none=False)
+ self._check_default(args, 'checkpoint_compression_method', str, allow_none=True)
+ self._check_default(args, 'checkpoint_compression_level', int, allow_none=True)
def _add_graphical_io_args(self):
graphical_io = self.add_argument_group('Graphical I/O')
@@ -804,20 +1306,24 @@ class HysopArgParser(argparse.ArgumentParser):
def _add_term_io_args(self):
term_io = self.add_argument_group('Terminal I/O')
msg0=('All {rank} and {size} occurences are replaced by the MPI rank and '
- +'MPI communicator size. {dpath} is replaced by default output path.')
+ +'MPI communicator size. {default_dump_dir} is replaced by default output path.'
+ +'{dump_dir} is replaced by user defined dump_dir.')
#+'{program} and {hostname} are replaced by actual program and host name.')
term_io.add_argument('-stdout', '--std-out',
- type=str, default='{dpath}/p{size}/{rank}.out',
+ type=str, default='{dump_dir}/{rank}.out',
dest='stdout',
help='Redirect stdout to this file. ' + msg0)
term_io.add_argument('-stderr', '--std-err',
- type=str, default='{dpath}/p{size}/{rank}.out',
+ type=str, default='{dump_dir}/{rank}.out',
dest='stderr',
help='Redirect stderr to this file. '+msg0)
term_io.add_argument('-tee', '--tee-ranks', type=str, default=(0,),
action=self.split, container=tuple, append=False, convert=int,
dest='tee_ranks',
help='Tee stdout and stderr of specified MPI ranks to terminal.')
+ term_io.add_argument('-N', '--no-interactive', action='store_true',
+ dest='no_interactive',
+ help=('Disable user interactivity.'))
term_io.add_argument('-V', '--verbose', action='store_true', default=None,
dest='verbose',
help='Enable verbosity. Overrides HYSOP_VERBOSE.')
@@ -841,8 +1347,10 @@ class HysopArgParser(argparse.ArgumentParser):
+ '\n [memallocs] memory allocations'
+ '\n [bigallocs] fat memory allocations'
+ '\n [kernels] opencl and cuda kernel calls'
+ + '\n [nocopy] disable trace of opencl and cuda copy kernel calls'
+ + '\n [noacc] disable trace of opencl and cuda accumulate kernel calls'
+ '\n [all] enable [warnings,memallocs,kernels]'
- + '\nOverrides HYSOP_TRACE_{CALLS,WARNINGS,MEMALLOCS,KERNELS}.'))
+ + '\nOverrides HYSOP_TRACE_{CALLS,WARNINGS,MEMALLOCS,KERNELS,NOCOPY,NOACCUMULATE}.'))
return term_io
def _check_term_io_args(self, args):
@@ -899,7 +1407,7 @@ class HysopArgParser(argparse.ArgumentParser):
def _check_default(self, args, argnames, types, allow_none=False):
if not isinstance(argnames, tuple):
argnames = (argnames,)
- assert all(isinstance(a, str) for a in argnames)
+ assert all(isinstance(a, str) for a in argnames), argnames
if not isinstance(types, tuple):
types = (types,)
assert all(isinstance(a, type) for a in types)
@@ -969,7 +1477,7 @@ class HysopArgParser(argparse.ArgumentParser):
self.error(msg)
def _check_dir(self, args, argnames, allow_shared=False, allow_none=False,
- assert_root_folder_exists=True):
+ enforce_shared=False, assert_root_folder_exists=True):
if not isinstance(argnames, tuple):
argnames = (argnames,)
for argname in argnames:
@@ -983,17 +1491,35 @@ class HysopArgParser(argparse.ArgumentParser):
msg='Got invalid None value for parameter \'{}\'.'
msg=msg.format(argname)
self.error(msg)
+
+ argvalue = self._fmt_filename(argvalue,
+ self.rank, self.size,
+ args.dump_dir,
+ self.default_dump_dir)
path = argvalue
+ i=0
while not os.path.isdir(path):
- path = os.path.realpath(argvalue+'/..')
+ path = os.path.realpath(path+'/..')
if path == '/':
break
+ i+=1
+ if (i==256):
+ msg='Achieved more than 256 subfolders, {} is not a valid path !'
+ msg=msg.format(path)
+ self.error(msg)
if (not allow_shared) and self.is_shared_fs(path):
- msg='{} directory \'{}\' cannot be stored on a network file system.'
+ msg='{} directory \'{}\' cannot be stored on a shared network file system.'
+ msg=msg.format(argname, argvalue)
+ self.error(msg)
+
+ if enforce_shared and not self.is_shared_fs(path):
+ msg='{} directory \'{}\' has to be stored on a shared network file system.'
msg=msg.format(argname, argvalue)
self.error(msg)
+
+ self._mkdir(argvalue, dirname=False)
setattr(args, argname, os.path.realpath(argvalue))
def _setup_hysop_env(self, args):
@@ -1009,6 +1535,10 @@ class HysopArgParser(argparse.ArgumentParser):
module = module.lower()
if module == 'calls':
self.set_env('TRACE_CALLS', '1')
+ elif module == 'nocopy':
+ self.set_env('TRACE_NOCOPY', '1')
+ elif module == 'noacc':
+ self.set_env('TRACE_NOACCUMULATE', '1')
elif module == 'bigallocs':
self.set_env('BACKTRACE_BIG_MEMALLOCS', '1')
elif module in ('all', 'warnings'):
@@ -1018,7 +1548,7 @@ class HysopArgParser(argparse.ArgumentParser):
elif module in ('all', 'kernels'):
self.set_env('TRACE_KERNELS', '1')
else:
- msg='Uknown tracing module \'{}\'.'.format(module)
+ msg='Unknown tracing module \'{}\'.'.format(module)
self.error(msg)
self.set_env('ENABLE_THREADING', args.enable_threading, True)
@@ -1030,11 +1560,80 @@ class HysopArgParser(argparse.ArgumentParser):
# those environment variables are not part of HySoP
self.set_env('OMP_NUM_THREADS', args.openmp_threads, False)
self.set_env('MKL_NUM_THREADS', args.mkl_threads, False)
+ self.set_env('MKL_DOMAIN_NUM_THREADS', args.mkl_domain_threads, False)
+ self.set_env('MKL_THREADING_LAYER', args.mkl_threading_layer, False)
self.set_env('NUMBA_NUM_THREADS', args.numba_threads, False)
self.set_env('NUMBA_THREADING_LAYER', args.numba_threading_layer, False)
def _setup_parameters(self, args):
- pass
+ from hysop import IO, IOParams
+ from hysop.core.checkpoints import CheckpointHandler
+ from hysop.tools.debug_dumper import DebugDumper
+
+ args.io_params = IOParams(filename=None, filepath=args.dump_dir,
+ frequency=args.dump_freq, dump_times=args.dump_times,
+ dump_tstart=args.dump_tstart, dump_tend=args.dump_tend, dump_last=args.dump_last,
+ enable_ram_fs=args.enable_ram_fs, force_ram_fs=args.force_ram_fs,
+ dump_is_temporary=args.dump_is_temporary,
+ postprocess_dump=args.postprocess_dump,
+ hdf5_disable_compression=args.hdf5_disable_compression,
+ hdf5_disable_slicing=args.hdf5_disable_slicing)
+
+ for pname in self.generate_io_params:
+ iop = IOParams(filename=None,
+ filepath = getattr(args, '{}_dump_dir'.format(pname)),
+ frequency = getattr(args, '{}_dump_freq'.format(pname)),
+ dump_times = getattr(args, '{}_dump_times'.format(pname)),
+ with_last = getattr(args, '{}_dump_last'.format(pname)) or args.dump_last,
+ dump_tstart = getattr(args, '{}_dump_tstart'.format(pname)),
+ dump_tend = getattr(args, '{}_dump_tend'.format(pname)),
+ enable_ram_fs = getattr(args, '{}_enable_ram_fs'.format(pname)),
+ force_ram_fs = getattr(args, '{}_force_ram_fs'.format(pname)),
+ dump_is_temporary = getattr(args, '{}_dump_is_temporary'.format(pname)),
+ postprocess_dump = getattr(args, '{}_postprocess_dump'.format(pname)),
+ hdf5_disable_compression = getattr(args, '{}_hdf5_disable_compression'.format(pname)),
+ hdf5_disable_slicing = getattr(args, '{}_hdf5_disable_slicing'.format(pname)))
+ setattr(args, '{}_io_params'.format(pname), iop)
+
+ load_checkpoint_path = args.load_checkpoint_path
+ if (load_checkpoint_path is not None):
+ if not load_checkpoint_path.endswith('.tar'):
+ msg='Load checkpoint filename has to end with .tar, got \'{}\'.'
+ self.error(msg.format(load_checkpoint_path))
+ if (os.path.sep not in load_checkpoint_path):
+ load_checkpoint_path = os.path.join(args.checkpoint_dump_dir, load_checkpoint_path)
+ if not os.path.isfile(load_checkpoint_path):
+ msg = 'Cannot load checkpoint \'{}\' because the file does not exist.'
+ self.error(msg.format(load_checkpoint_path))
+ load_checkpoint_path = os.path.abspath(load_checkpoint_path)
+ args.load_checkpoint_path = load_checkpoint_path
+
+ save_checkpoint_path = args.save_checkpoint_path
+ if (save_checkpoint_path is not None):
+ if not save_checkpoint_path.endswith('.tar'):
+ msg='Save checkpoint filename has to end with .tar, got \'{}\'.'
+ self.error(msg.format(save_checkpoint_path))
+ if (os.path.sep not in save_checkpoint_path):
+ save_checkpoint_path = os.path.join(args.checkpoint_dump_dir, save_checkpoint_path)
+ save_checkpoint_path = os.path.abspath(save_checkpoint_path)
+ args.checkpoint_dump_dir = os.path.dirname(save_checkpoint_path)
+ args.save_checkpoint_path = save_checkpoint_path
+
+ args.checkpoint_handler = CheckpointHandler(args.load_checkpoint_path, args.save_checkpoint_path,
+ args.checkpoint_compression_method, args.checkpoint_compression_level,
+ args.checkpoint_io_params, args.checkpoint_relax_constraints)
+
+ # debug dumps
+ if (args.debug_dump_dir is None):
+ args.debug_dump_dir = args.dump_dir
+ if args.debug_dump_target:
+ debug_dumper = DebugDumper(
+ path=args.debug_dump_dir,
+ name=args.debug_dump_target,
+ force_overwrite=True, enable_on_op_apply=True)
+ else:
+ debug_dumper = None
+ args.debug_dumper = debug_dumper
def _setup_implementation(self, args):
from hysop.constants import Implementation
@@ -1072,6 +1671,22 @@ class HysopArgParser(argparse.ArgumentParser):
msg+='\n *'.join('{}: {}'.format(k, v) for (k,v) in values.iteritems())
self.error(msg)
+ def _check_and_set_diffusion_mode(self, argname, args):
+ dm = getattr(args, argname, None)
+ modes=('spectral', 'directional')
+ if (dm is None):
+ msg='Diffusion mode for parameter \'{}\' has not been set.'
+ msg=msg.format(dm, argname)
+ self.error(msg)
+ if (dm not in modes):
+ msg='Unknown diffusion mode \'{}\' for parameter \'{}\'. Available modes are {}.'
+ msg=msg.format(dm, argname, modes)
+ self.error(msg)
+ target=argname.split('_')[0]
+ for mode in modes:
+ varname='use_{}_{}_diffusion'.format(target, mode)
+ setattr(args, varname, dm==mode)
+
def _convert_bool(self, argname, val):
values = {
None: None,
@@ -1111,6 +1726,15 @@ class HysopArgParser(argparse.ArgumentParser):
}
return self._check_convert(argname, val, values)
+ def _convert_mkl_threading_layer(self, argname, val):
+ values = {
+ 'seq': 'SEQUENTIAL',
+ 'omp': 'OMP',
+ 'tbb': 'TBB',
+ 'intel': 'INTEL'
+ }
+ return self._check_convert(argname, val, values)
+
def _convert_numba_threading_layer(self, argname, val):
values = {
'workqueue': 'workqueue',
@@ -1204,13 +1828,14 @@ class HysopArgParser(argparse.ArgumentParser):
return self._check_convert(argname, strang_order, strang_orders)
def _convert_time_integrator(self, argname, time_integrator):
- from hysop.numerics.odesolvers.runge_kutta import Euler, RK2, RK3, RK4
+ from hysop.numerics.odesolvers.runge_kutta import Euler, RK2, RK3, RK4, RK4_38
time_integrators = {
'euler': Euler,
'rk1': Euler,
'rk2': RK2,
'rk3': RK3,
- 'rk4': RK4
+ 'rk4': RK4,
+ 'rk4_38': RK4_38
}
return self._check_convert(argname, time_integrator, time_integrators)
@@ -1234,6 +1859,50 @@ class HysopArgParser(argparse.ArgumentParser):
}
return self._check_convert(argname, remesh_kernel, remesh_kernels)
+ def _convert_polynomial_interpolation(self, argname, pi):
+ from hysop.numerics.interpolation.polynomial import PolynomialInterpolation
+ polynomial_interpolations = {
+ 'linear': PolynomialInterpolation.LINEAR,
+ 'cubic': PolynomialInterpolation.CUBIC,
+ 'quintic': PolynomialInterpolation.QUINTIC,
+ 'septic': PolynomialInterpolation.SEPTIC,
+ 'nonic': PolynomialInterpolation.NONIC,
+ 'cubic_fdc2': PolynomialInterpolation.CUBIC_FDC2,
+ 'cubic_fdc4': PolynomialInterpolation.CUBIC_FDC4,
+ 'cubic_fdc6': PolynomialInterpolation.CUBIC_FDC6,
+ 'quintic_fdc2': PolynomialInterpolation.QUINTIC_FDC2,
+ 'quintic_fdc4': PolynomialInterpolation.QUINTIC_FDC4,
+ 'quintic_fdc6': PolynomialInterpolation.QUINTIC_FDC6,
+ 'septic_fdc2': PolynomialInterpolation.SEPTIC_FDC2,
+ 'septic_fdc4': PolynomialInterpolation.SEPTIC_FDC4,
+ 'septic_fdc6': PolynomialInterpolation.SEPTIC_FDC6,
+ 'nonic_fdc2': PolynomialInterpolation.NONIC_FDC2,
+ 'nonic_fdc4': PolynomialInterpolation.NONIC_FDC4,
+ 'nonic_fdc6': PolynomialInterpolation.NONIC_FDC6,
+ }
+ return self._check_convert(argname, pi, polynomial_interpolations)
+
+ def _convert_advection_interpolation(self, argname, ai):
+ from hysop.numerics.interpolation.interpolation import Interpolation
+ from hysop.numerics.interpolation.polynomial import PolynomialInterpolation
+ advection_interpolations = {
+ 'legacy': Interpolation.LINEAR,
+ 'linear': PolynomialInterpolation.LINEAR,
+ 'cubic_fdc2': PolynomialInterpolation.CUBIC_FDC2,
+ 'cubic_fdc4': PolynomialInterpolation.CUBIC_FDC4,
+ 'cubic_fdc6': PolynomialInterpolation.CUBIC_FDC6,
+ 'quintic_fdc2': PolynomialInterpolation.QUINTIC_FDC2,
+ 'quintic_fdc4': PolynomialInterpolation.QUINTIC_FDC4,
+ 'quintic_fdc6': PolynomialInterpolation.QUINTIC_FDC6,
+ 'septic_fdc2': PolynomialInterpolation.SEPTIC_FDC2,
+ 'septic_fdc4': PolynomialInterpolation.SEPTIC_FDC4,
+ 'septic_fdc6': PolynomialInterpolation.SEPTIC_FDC6,
+ 'nonic_fdc2': PolynomialInterpolation.NONIC_FDC2,
+ 'nonic_fdc4': PolynomialInterpolation.NONIC_FDC4,
+ 'nonic_fdc6': PolynomialInterpolation.NONIC_FDC6,
+ }
+ return self._check_convert(argname, ai, advection_interpolations)
+
def _convert_stretching_formulation(self, argname, stretching_formulation):
from hysop.constants import StretchingFormulation
stretching_formulations = {
@@ -1244,12 +1913,17 @@ class HysopArgParser(argparse.ArgumentParser):
}
return self._check_convert(argname, stretching_formulation, stretching_formulations)
- def _convert_interpolation(self, argname, interpolation):
- from hysop.methods import Interpolation
- interpolations = {
- 'linear': Interpolation.LINEAR
+ def _convert_filtering_method(self, argname, fm, allow_subgrid=True):
+ from hysop.methods import FilteringMethod
+ filtering_methods = {
+ 'spectral': FilteringMethod.SPECTRAL,
+ 'remesh': FilteringMethod.REMESH,
+ 'polynomial': FilteringMethod.POLYNOMIAL,
+ 'subgrid': FilteringMethod.SUBGRID,
}
- return self._check_convert(argname, interpolation, interpolations)
+ if allow_subgrid:
+ filtering_methods['subgrid'] = FilteringMethod.SUBGRID
+ return self._check_convert(argname, fm, filtering_methods)
class HysopHelpFormatter(ColorHelpFormatter):
def _format_args(self, *args, **kwds):
@@ -1279,10 +1953,8 @@ class HysopHelpFormatter(ColorHelpFormatter):
p &= (len(action.option_strings)<2) or (action.option_strings[1] not in blacklist)
return p
actions = filter(predicate, actions)
- usage = super(HysopHelpFormatter, self)._format_usage(usage=usage, actions=actions,
- groups=groups, prefix=prefix)
+ usage = self._format_usage_color_help_formatter(usage=usage, actions=actions, groups=groups, prefix=prefix)
usage = usage.rstrip()
- s=' '*(8+len(self._prog))
opencl_parameters = colors.color('OPENCL_PARAMETERS', fg='green', style='bold')
autotuner_parameters = colors.color('AUTOTUNER_PARAMETERS', fg='green', style='bold')
trace = colors.color('TRACE', fg='green', style='bold')
@@ -1290,6 +1962,8 @@ class HysopHelpFormatter(ColorHelpFormatter):
stdout = colors.color('STDOUT', fg='green', style='bold')
stderr = colors.color('STDERR', fg='green', style='bold')
+ s=' '*(8+len(self._prog))
+
usage +='\n{s}[--opencl-{{...}} {}]\n{s}[--autotuner-{{...}} {}]'.format(
opencl_parameters, autotuner_parameters, s=s)
usage +='\n{s}[-tee {}] [-stdout {}] [-stderr {}]'.format(tee, stdout, stderr, s=s)
@@ -1297,6 +1971,100 @@ class HysopHelpFormatter(ColorHelpFormatter):
usage +='\n{s}[--help] [--version] [--hardware-info] [--hardware-summary]'.format(s=s)
usage +='\n\n'
return usage
+
+ def _format_usage_color_help_formatter(self, usage, actions, groups, prefix):
+ from gettext import gettext as _
+ from colors import strip_color
+ import re as _re
+ if prefix is None:
+ prefix = _('usage: ')
+
+ # if usage is specified, use that
+ if usage is not None:
+ usage = usage % dict(prog=self._prog)
+
+ # if no optionals or positionals are available, usage is just prog
+ elif usage is None and not actions:
+ usage = '%(prog)s' % dict(prog=self._prog)
+
+ # if optionals and positionals are available, calculate usage
+ elif usage is None:
+ prog = '%(prog)s' % dict(prog=self._prog)
+
+ # split optionals from positionals
+ optionals = []
+ positionals = []
+ for action in actions:
+ if action.option_strings:
+ optionals.append(action)
+ else:
+ positionals.append(action)
+
+ # build full usage string
+ format = self._format_actions_usage
+ action_usage = format(optionals + positionals, groups)
+ usage = ' '.join([s for s in [prog, action_usage] if s])
+
+ # wrap the usage parts if it's too long
+ text_width = self._width - self._current_indent
+ if len(prefix) + len(strip_color(usage)) > text_width:
+
+ # break usage into wrappable parts
+ part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
+ opt_usage = format(optionals, groups)
+ pos_usage = format(positionals, groups)
+ opt_parts = _re.findall(part_regexp, opt_usage)
+ pos_parts = _re.findall(part_regexp, pos_usage)
+
+ # helper for wrapping lines
+ def get_lines(parts, indent, prefix=None):
+ lines = []
+ line = []
+ if prefix is not None:
+ line_len = len(prefix) - 1
+ else:
+ line_len = len(indent) - 1
+ for part in parts:
+ if line_len + 1 + len(strip_color(part)) > text_width and line:
+ lines.append(indent + ' '.join(line))
+ line = []
+ line_len = len(indent) - 1
+ line.append(part)
+ line_len += len(strip_color(part)) + 1
+ if line:
+ lines.append(indent + ' '.join(line))
+ if prefix is not None:
+ lines[0] = lines[0][len(indent):]
+ return lines
+
+ # if prog is short, follow it with optionals or positionals
+ len_prog = len(strip_color(prog))
+ if len(prefix) + len_prog <= 0.75 * text_width:
+ indent = ' ' * (len(prefix) + len_prog + 1)
+ if opt_parts:
+ lines = get_lines([prog] + opt_parts, indent, prefix)
+ lines.extend(get_lines(pos_parts, indent))
+ elif pos_parts:
+ lines = get_lines([prog] + pos_parts, indent, prefix)
+ else:
+ lines = [prog]
+
+ # if prog is long, put it on its own line
+ else:
+ indent = ' ' * len(prefix)
+ parts = opt_parts + pos_parts
+ lines = get_lines(parts, indent)
+ if len(lines) > 1:
+ lines = []
+ lines.extend(get_lines(opt_parts, indent))
+ lines.extend(get_lines(pos_parts, indent))
+ lines = [prog] + lines
+
+ # join lines into usage
+ usage = '\n'.join(lines)
+
+ # prefix with 'usage:'
+ return '%s%s\n\n' % (prefix, usage)
def start_section(self, heading):
heading = colors.color('[{}]'.format(heading.upper()), fg='yellow', style='bold')
@@ -1320,3 +2088,6 @@ class HysopHelpFormatter(ColorHelpFormatter):
class HysopNamespace(argparse.Namespace):
pass
+if __name__=='__main__':
+ parser = HysopArgParser(prog_name='example_demo', description='This is an HySoP example demo.')
+ parser.print_help()
diff --git a/examples/.gitignore b/hysop_examples/examples/.gitignore
similarity index 100%
rename from examples/.gitignore
rename to hysop_examples/examples/.gitignore
diff --git a/examples/analytic/analytic.py b/hysop_examples/examples/analytic/analytic.py
similarity index 59%
rename from examples/analytic/analytic.py
rename to hysop_examples/examples/analytic/analytic.py
index 09f01a5cdfcf06c9932af7505a1d80ae1835082c..be9bddad40836793a8e8c3f04f04c6443ede93c1 100755
--- a/examples/analytic/analytic.py
+++ b/hysop_examples/examples/analytic/analytic.py
@@ -1,66 +1,70 @@
#!/usr/bin/env python2
import numpy as np
import sympy as sm
-
+
+
def compute(args):
'''
HySoP Analytic Example: Initialize a field with a space and time dependent analytic formula.
'''
- from hysop import Field, Box, MPIParams, \
- Simulation, Problem, ScalarParameter
+ from hysop import Field, Box, IOParams, MPIParams, \
+ Simulation, Problem, ScalarParameter
from hysop.constants import Implementation
- from hysop.operators import AnalyticField
-
+ from hysop.operators import AnalyticField, HDF_Writer
+
# Define domain
npts = args.npts
- box = Box(origin=args.box_origin, length=args.box_length, dim=args.ndim)
-
+ box = Box(origin=args.box_origin, length=args.box_length, dim=args.ndim)
+
# Define parameters and field (time and analytic field)
- t = ScalarParameter('t', dtype=args.dtype)
+ t = ScalarParameter('t', dtype=args.dtype)
scalar = Field(domain=box, name='S0', dtype=args.dtype)
-
+
# We need to first get default MPI parameters (even for non MPI jobs)
# so we use default domain communicator and task.
mpi_params = MPIParams(comm=box.task_comm,
task_id=box.current_task())
-
+
# Setup implementation specific variables
impl = args.impl
op_kwds = {'mpi_params': mpi_params}
if (impl is Implementation.PYTHON):
# Setup python specific extra operator keyword arguments
# (mapping: variable name => variable value)
- op_kwds['extra_input_kwds'] = {'t': t}
+ op_kwds['extra_input_kwds'] = {'t': t}
elif (impl is Implementation.OPENCL):
# For the OpenCL implementation we need to setup the compute device
# and configure how the code is generated and compiled at runtime.
-
+
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params, platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank % get_device_number() if args.cl_device_id is None else None)
+
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
method = {OpenClKernelConfig: args.opencl_kernel_config}
-
+
# Setup opencl specific extra operator keyword arguments
- op_kwds['cl_env'] = cl_env
- op_kwds['method'] = method
+ op_kwds['cl_env'] = cl_env
+ op_kwds['method'] = method
else:
- msg='Unknown implementation \'{}\'.'.format(impl)
+ msg = 'Unknown implementation \'{}\'.'.format(impl)
raise ValueError(msg)
-
+
# Analytic initialization method depends on chosen implementation
if (impl is Implementation.PYTHON):
# With the python implementation we can directly use a python method
# (using numpy arrays). Here each field component is stored in the
- # tuple 'data'. Coordinates will be passed as a tuple as a second
+ # tuple 'data'. Coordinates will be passed as a tuple as a second
# argument. Finally extra arguments (here t) are passed last.
# Note that t is a ScalarParameter, so we evaluate it to get its value.
- def compute_scalar(data, coords, t):
- data[0][...] = (1.0/(1.0+0.1*t()))
- for x in coords[0]:
- data[0][...] *= np.cos(x-t())
+ def compute_scalar(data, coords, component, t):
+ data[...] = (1.0/(1.0+0.1*t()))
+ for x in coords:
+ data[...] *= np.cos(x-t())
elif (impl is Implementation.OPENCL):
# With the opencl codegen implementation we use a symbolic expression
# generated using sympy. OpenCL code will be automatically generated,
@@ -74,20 +78,24 @@ def compute(args):
for xi in xs:
compute_scalar *= sm.cos(xi-ts)
else:
- msg='Unknown implementation {}.'.format(impl)
-
+ msg = 'Unknown implementation {}.'.format(impl)
+
# Finally build the operator
- analytic = AnalyticField(name='analytic',
- field=scalar, formula=compute_scalar,
- variables = {scalar: npts}, implementation=impl,
- **op_kwds)
+ analytic = AnalyticField(name='analytic',
+ field=scalar, formula=compute_scalar,
+ variables={scalar: npts}, implementation=impl,
+ **op_kwds)
# Write output field at given frequency
- analytic.dump_outputs(fields=scalar, frequency=args.dump_freq, filename='F', **op_kwds)
-
+ io_params = IOParams(filename='analytic', frequency=args.dump_freq)
+ df = HDF_Writer(name='S',
+ io_params=io_params,
+ variables={scalar: npts},
+ **op_kwds)
+
# Create the problem we want to solve and insert our operator
problem = Problem()
- problem.insert(analytic)
+ problem.insert(analytic, df)
problem.build(args)
# If a visu_rank was provided, and show_graph was set,
@@ -95,36 +103,38 @@ def compute(args):
if args.display_graph:
problem.display(args.visu_rank)
- # Create a simulation and solve the problem
+ # Create a simulation and solve the problem
# (do not forget to specify the time parameter here)
- simu = Simulation(start=args.tstart, end=args.tend,
- nb_iter=args.nb_iter, dt0=args.dt,
- max_iter=args.max_iter,
- times_of_interest=args.dump_times,
+ simu = Simulation(start=args.tstart, end=args.tend,
+ nb_iter=args.nb_iter, dt0=args.dt,
+ max_iter=args.max_iter,
+ times_of_interest=args.times_of_interest,
t=t)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
-
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
-if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
-
+if __name__ == '__main__':
+ from hysop_examples.example_utils import HysopArgParser, colors
+
prog_name = 'analytic'
default_dump_dir = '{}/hysop_examples/{}'.format(HysopArgParser.tmp_dir(), prog_name)
- description=colors.color('HySoP Analytic Example: ', fg='blue', style='bold')
- description+='Initialize a field with a space and time dependent analytic formula.'
+ description = colors.color('HySoP Analytic Example: ', fg='blue', style='bold')
+ description += 'Initialize a field with a space and time dependent analytic formula.'
parser = HysopArgParser(prog_name=prog_name,
- description=description,
- default_dump_dir=default_dump_dir)
+ description=description,
+ default_dump_dir=default_dump_dir)
- parser.set_defaults(box_start=(0.0,), box_length=(2*np.pi,),
- tstart=0.0, tend=10.0, nb_iter=100,
- dump_freq=5)
+ parser.set_defaults(box_start=(0.0,), box_length=(2*np.pi,),
+ tstart=0.0, tend=10.0, nb_iter=100,
+ dump_freq=5)
parser.run(compute)
diff --git a/examples/bubble/periodic_bubble.py b/hysop_examples/examples/bubble/periodic_bubble.py
similarity index 92%
rename from examples/bubble/periodic_bubble.py
rename to hysop_examples/examples/bubble/periodic_bubble.py
index 8029f494f7fde2818c9860565e02ca6970e38285..1b25b879d72ddc0c6a48f2c964ff16c025edef0c 100644
--- a/examples/bubble/periodic_bubble.py
+++ b/hysop_examples/examples/bubble/periodic_bubble.py
@@ -9,32 +9,33 @@
import os
import numpy as np
-def init_vorticity(data, coords):
- for d in data:
- d[...] = 0.0
+def init_vorticity(data, **kwds):
+ data[...] = 0.0
-def init_velocity(data, coords, **kwds):
- for d in data:
- d[...] = 0.0
+def init_velocity(data, **kwds):
+ data[...] = 0.0
-def init_rho(data, coords, Br, Bc, rho1, rho2, eps):
+def init_rho(data, coords, Br, Bc, rho1, rho2, eps, component):
+ assert (component==0)
# initialize density with the levelset
- init_phi(data, coords, Br, Bc)
- data[0][...] = regularize(data[0], rho1, rho2, eps)
+ init_phi(data=data, coords=coords, component=component, Br=Br, Bc=Bc)
+ data[...] = regularize(data, rho1, rho2, eps)
-def init_mu(data, coords, Br, Bc, mu1, mu2, eps):
+def init_mu(data, coords, Br, Bc, mu1, mu2, eps, component):
+ assert (component==0)
# initialize viscosity with the levelset
- init_phi(data, coords, Br, Bc)
- data[0][...] = regularize(data[0], mu1, mu2, eps)
+ init_phi(data=data, coords=coords, component=component, Br=Br, Bc=Bc)
+ data[...] = regularize(data, mu1, mu2, eps)
-def init_phi(data, coords, Br, Bc):
+def init_phi(data, coords, Br, Bc, component):
+ assert (component==0)
assert len(Bc)==len(Br)>=1
- phi = data[0]
+ phi = data
phi[...] = np.inf
Di = np.empty_like(phi)
for (C, R) in zip(Bc, Br):
Di[...] = 0
- for (Xi,Ci) in zip(coords[0], C):
+ for (Xi,Ci) in zip(coords, C):
Li = 1.0
Di += np.minimum((Xi-Ci-Li)**2, (Xi-Ci)**2, (Xi-Ci+Li)**2)
Di -= R**2
@@ -93,10 +94,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -252,7 +254,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
@@ -274,7 +275,7 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
enstrophy, rhov, muv,
@@ -293,15 +294,17 @@ def compute(args):
problem.initialize_field(field=rho, formula=init_rho, rho1=args.rho1, rho2=args.rho2, Bc=Bc, Br=Br, reorder='Bc', eps=eps)
problem.initialize_field(field=mu, formula=init_mu, mu1=args.mu1, mu2=args.mu2, Bc=Bc, Br=Br, reorder='Bc', eps=eps)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class PeriodicBubbleArgParser(HysopArgParser):
def __init__(self):
@@ -384,6 +387,7 @@ if __name__=='__main__':
self._check_positive(args, 'plot_freq', strict=True, allow_none=False)
def _setup_parameters(self, args):
+ super(PeriodicBubbleArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/bubble/periodic_bubble_levelset.py b/hysop_examples/examples/bubble/periodic_bubble_levelset.py
similarity index 94%
rename from examples/bubble/periodic_bubble_levelset.py
rename to hysop_examples/examples/bubble/periodic_bubble_levelset.py
index 6fcaf328e800ef37e734ecca042fe803b1e18e45..d3ba8e80fda7fec5edd53930232ca6a90f20f174 100644
--- a/examples/bubble/periodic_bubble_levelset.py
+++ b/hysop_examples/examples/bubble/periodic_bubble_levelset.py
@@ -7,28 +7,27 @@
import os
import numpy as np
-def init_vorticity(data, coords):
- for d in data:
- d[...] = 0.0
+def init_vorticity(data, **kwds):
+ data[...] = 0.0
-def init_velocity(data, coords, **kwds):
- for d in data:
- d[...] = 0.0
+def init_velocity(data, **kwds):
+ data[...] = 0.0
-def init_rho(data, coords):
- data[0][...] = 0.0
+def init_rho(data, **kwds):
+ data[...] = 0.0
-def init_mu(data, coords):
- data[0][...] = 0.0
+def init_mu(data, **kwds):
+ data[...] = 0.0
-def init_phi(data, coords, Br, Bc):
+def init_phi(data, coords, Br, Bc, component):
+ assert (component==0)
assert len(Bc)==len(Br)>=1
- phi = data[0]
+ phi = data
phi[...] = np.inf
Di = np.empty_like(phi)
for (C, R) in zip(Bc, Br):
Di[...] = 0
- for (Xi,Ci) in zip(coords[0], C):
+ for (Xi,Ci) in zip(coords, C):
Li = 1.0
Di += np.minimum((Xi-Ci-Li)**2, (Xi-Ci)**2, (Xi-Ci+Li)**2)
Di -= R**2
@@ -81,10 +80,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -255,7 +255,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
@@ -277,7 +276,7 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
enstrophy, rhov, muv,
@@ -293,15 +292,17 @@ def compute(args):
problem.initialize_field(field=mu, formula=init_mu)
problem.initialize_field(field=phi, formula=init_phi, Bc=Bc, Br=Br, reorder='Bc')
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class PeriodicBubbleArgParser(HysopArgParser):
def __init__(self):
@@ -384,6 +385,7 @@ if __name__=='__main__':
self._check_positive(args, 'plot_freq', strict=True, allow_none=False)
def _setup_parameters(self, args):
+ super(PeriodicBubbleArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/bubble/periodic_bubble_levelset_penalization.py b/hysop_examples/examples/bubble/periodic_bubble_levelset_penalization.py
similarity index 94%
rename from examples/bubble/periodic_bubble_levelset_penalization.py
rename to hysop_examples/examples/bubble/periodic_bubble_levelset_penalization.py
index 5732752c4647012cd81bd9454c2400e17223aa22..126bf71ca0da7114e8b3827d085f5a581767a62a 100644
--- a/examples/bubble/periodic_bubble_levelset_penalization.py
+++ b/hysop_examples/examples/bubble/periodic_bubble_levelset_penalization.py
@@ -7,28 +7,27 @@
import os
import numpy as np
-def init_vorticity(data, coords):
- for d in data:
- d[...] = 0.0
+def init_vorticity(data, **kwds):
+ data[...] = 0.0
-def init_velocity(data, coords, **kwds):
- for d in data:
- d[...] = 0.0
+def init_velocity(data, **kwds):
+ data[...] = 0.0
-def init_rho(data, coords):
- data[0][...] = 0.0
+def init_rho(data, **kwds):
+ data[...] = 0.0
-def init_mu(data, coords):
- data[0][...] = 0.0
+def init_mu(data, **kwds):
+ data[...] = 0.0
-def init_phi(data, coords, Br, Bc):
+def init_phi(data, coords, Br, Bc, component):
+ assert (component==0)
assert len(Bc)==len(Br)>=1
- phi = data[0]
+ phi = data
phi[...] = np.inf
Di = np.empty_like(phi)
for (C, R) in zip(Bc, Br):
Di[...] = 0
- for (Xi,Ci) in zip(coords[0], C):
+ for (Xi,Ci) in zip(coords, C):
Li = 1.0
Di += np.minimum((Xi-Ci-Li)**2, (Xi-Ci)**2, (Xi-Ci+Li)**2)
Di -= R**2
@@ -36,11 +35,12 @@ def init_phi(data, coords, Br, Bc):
phi[mask] = Di[mask]
assert np.isfinite(phi).all()
-def init_lambda(data, coords):
- X,Y = coords[0][:2]
- data[0][...] = abs(X-0.5)<0.1
- data[0][...] *= abs(Y-0.7)<0.2
- data[0][...] *= 1.0e8
+def init_lambda(data, coords, component):
+ assert (component==0)
+ X,Y = coords[:2]
+ data[...] = abs(X-0.5)<0.1
+ data[...] *= abs(Y-0.7)<0.2
+ data[...] *= 1.0e8
def compute(args):
from hysop import Box, Simulation, Problem, MPIParams, IOParams, vprint
@@ -89,10 +89,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -295,7 +296,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
@@ -317,7 +317,7 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
enstrophy, rhov, muv,
@@ -334,15 +334,17 @@ def compute(args):
problem.initialize_field(field=phi, formula=init_phi, Bc=Bc, Br=Br, reorder='Bc')
problem.initialize_field(field=_lambda, formula=init_lambda)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class PeriodicBubbleArgParser(HysopArgParser):
def __init__(self):
@@ -425,6 +427,7 @@ if __name__=='__main__':
self._check_positive(args, 'plot_freq', strict=True, allow_none=False)
def _setup_parameters(self, args):
+ super(PeriodicBubbleArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/bubble/periodic_jet_levelset.py b/hysop_examples/examples/bubble/periodic_jet_levelset.py
similarity index 94%
rename from examples/bubble/periodic_jet_levelset.py
rename to hysop_examples/examples/bubble/periodic_jet_levelset.py
index 9f4ba310f2348a1844db8c205dfa883c3dcce464..3bc7b83db0d2920f27c66d8ee74d7b775a2e2ff9 100644
--- a/examples/bubble/periodic_jet_levelset.py
+++ b/hysop_examples/examples/bubble/periodic_jet_levelset.py
@@ -7,22 +7,20 @@
import os
import numpy as np
-def init_vorticity(data, coords):
- for d in data:
- d[...] = 0.0
+def init_vorticity(data, **kwds):
+ data[...] = 0.0
-def init_velocity(data, coords, **kwds):
- for d in data:
- d[...] = 0.0
+def init_velocity(data, **kwds):
+ data[...] = 0.0
-def init_rho(data, coords):
- data[0][...] = 0.0
+def init_rho(data, **kwds):
+ data[...] = 0.0
-def init_phi(data, coords, L):
- phi = data[0]
+def init_phi(data, coords, component, L):
+ phi = data
phi[...] = np.inf
Di = np.ones_like(phi)
- X,Y = coords[0][:2]
+ X,Y = coords[:2]
Ly, Lx = L[:2]
R = Lx*(0.15 - 0.05*np.sin(2*np.pi*Y/Ly) + 0.001*np.cos(2*np.pi*10*Y/Ly))
Di[...] *= (X-0.5*Lx)**2 - R**2
@@ -75,10 +73,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -245,7 +244,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
@@ -267,7 +265,7 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
enstrophy, rhov,
@@ -281,15 +279,17 @@ def compute(args):
problem.initialize_field(field=rho, formula=init_rho)
problem.initialize_field(field=phi, formula=init_phi, L=box.length)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class PeriodicJetArgParser(HysopArgParser):
def __init__(self):
@@ -331,6 +331,7 @@ if __name__=='__main__':
self._check_positive(args, vars_, strict=False, allow_none=False)
def _setup_parameters(self, args):
+ super(PeriodicJetArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/cylinder/oscillating_cylinder.py b/hysop_examples/examples/cylinder/oscillating_cylinder.py
similarity index 93%
rename from examples/cylinder/oscillating_cylinder.py
rename to hysop_examples/examples/cylinder/oscillating_cylinder.py
index e4a34206cf2e6c9f8b295433f1d1b534d499d01e..de8a2f97ac095e79991e24163c96abdd80620448 100644
--- a/examples/cylinder/oscillating_cylinder.py
+++ b/hysop_examples/examples/cylinder/oscillating_cylinder.py
@@ -7,17 +7,14 @@
import os
import numpy as np
-def init_vorticity(data, coords):
- for d in data:
- d[...] = 0.0
+def init_vorticity(data, **kwds):
+ data[...] = 0.0
-def init_velocity(data, coords, **kwds):
- for d in data:
- d[...] = 0.0
+def init_velocity(data, **kwds):
+ data[...] = 0.0
-def init_lambda(data, coords):
- for d in data:
- d[...] = 0.0
+def init_lambda(data, **kwds):
+ data[...] = 0.0
def compute(args):
from hysop import Box, Simulation, Problem, MPIParams, IOParams, vprint, \
@@ -82,10 +79,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -221,7 +219,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
@@ -243,7 +240,7 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf,
@@ -255,15 +252,17 @@ def compute(args):
problem.initialize_field(field=vorti, formula=init_vorticity)
problem.initialize_field(field=_lambda, formula=init_lambda)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class OscillatingCylinderArgParser(HysopArgParser):
def __init__(self):
@@ -282,6 +281,7 @@ if __name__=='__main__':
default_dump_dir=default_dump_dir)
def _setup_parameters(self, args):
+ super(OscillatingCylinderArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/hysop_examples/examples/fixed_point/heat_equation.py b/hysop_examples/examples/fixed_point/heat_equation.py
new file mode 100644
index 0000000000000000000000000000000000000000..452b69d26e7d887f78391de2cd7bf747ddf9e6b9
--- /dev/null
+++ b/hysop_examples/examples/fixed_point/heat_equation.py
@@ -0,0 +1,222 @@
+"""
+Example for fixed point iteration inside Simulation.
+
+We consider steady state of heat equation with a varying source term.
+Each time step, the source terms are computed analytically and then an
+iterative method is used to compute steady state solution.
+"""
+import numpy as np
+import sympy as sp
+
+pos = [0.5, 0.5, 0.5]
+RADIUS = 0.2
+chi = lambda x,y,z: np.sqrt((x-pos[0])*(x-pos[0])+(y-pos[1])*(y-pos[1])+0.*z)<=RADIUS
+schi = lambda x,y,z: sp.sqrt((x-pos[0])*(x-pos[0])+(y-pos[1])*(y-pos[1])+0.*z)<=RADIUS
+
+# Analytic operator for computing source term
+def CS( data, coords, t, component):
+ (x, y, z) = coords
+ data[...] = 0.
+ data[chi(x,y,z)] = np.cos(t())
+def init_u(data, coords, component):
+ (x,y,z) = coords
+ data[...] = 0.
+
+def compute(args):
+ from hysop import Box, Simulation, Problem, Field, MPIParams, IO, IOParams, main_rank
+ from hysop.constants import Implementation, Backend, ResidualError
+ from hysop.defaults import TimeParameters
+ from hysop.parameters.scalar_parameter import ScalarParameter
+ from hysop.topology.cartesian_topology import CartesianTopology
+ from hysop.tools.parameters import CartesianDiscretization
+ from hysop.symbolic.tmp import TmpScalar
+ from hysop.operators import StrangSplitting, DirectionalDiffusion, Diffusion, \
+ Convergence, AnalyticField, Dummy, CustomSymbolicOperator, HDF_Writer, CustomOperator
+ from hysop.symbolic.relational import Assignment
+ from hysop.symbolic.misc import Select
+ from hysop.iterative_method import PseudoSimulation, IterativeMethod
+ from hysop.simulation import eps
+
+ # Define the domain
+ dim = args.ndim
+ npts = args.npts
+ box = Box(origin=args.box_origin, length=args.box_length, dim=dim)
+
+ # Get default MPI Parameters from domain (even for serial jobs)
+ mpi_params = MPIParams(comm=box.task_comm,
+ task_id=box.current_task())
+
+ # Setup usual implementation specific variables
+ impl = args.impl
+ extra_op_kwds = {'mpi_params': mpi_params}
+ if (impl in (Implementation.PYTHON, Implementation.FORTRAN)):
+ backend = Backend.HOST
+ method = {}
+ elif (impl is Implementation.OPENCL):
+ # For the OpenCL implementation we need to setup the compute device
+ # and configure how the code is generated and compiled at runtime.
+
+ # Create an explicit OpenCL context from user parameters
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
+
+ # Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
+ from hysop.methods import OpenClKernelConfig
+ method = { OpenClKernelConfig: args.opencl_kernel_config }
+
+ # Setup opencl specific extra operator keyword arguments
+ extra_op_kwds['cl_env'] = cl_env
+ backend = Backend.OPENCL
+ else:
+ msg='Unknown implementation \'{}\'.'.format(impl)
+ raise ValueError(msg)
+
+ # Fields
+ uSources = Field(domain=box, dtype=args.dtype, is_vector=False, name="uSources")
+ u = Field(domain=box, dtype=args.dtype, is_vector=False, name="u")
+ convergence = ScalarParameter(name="conv", dtype=args.dtype, quiet=True,
+ initial_value=1e10)
+ t, dt = TimeParameters(dtype=args.dtype)
+ pseudo_dt = ScalarParameter(name='pseudo_dt', dtype=args.dtype, min_value=eps,
+ initial_value=eps, quiet=True)
+
+ # Operator for setting iterative method
+ if impl is Implementation.OPENCL:
+ (x0, x1, x2) = box.frame.coords
+ utemp = TmpScalar(name='utemp', value=0., dtype=args.dtype)
+ source = CustomSymbolicOperator(
+ implementation=impl,
+ name="BCAndSourceTerm",
+ exprs=(
+ # Source term
+ Assignment(utemp, Select(u.s(), uSources.s(), schi(x0, x1, x2))),
+ # BC enforcement
+ Assignment(utemp, Select(utemp, 0., x0<0.1)),
+ Assignment(utemp, Select(utemp, 0., x0>0.9)),
+ Assignment(utemp, Select(utemp, 0., x1<0.1)),
+ Assignment(utemp, Select(utemp, 0., x1>0.9)),
+ Assignment(u.s(), utemp)),
+ variables={uSources: npts, u: npts},
+ **extra_op_kwds)
+ else:
+ def computeSRC(src_in, u_in, u_out):
+ (x, y, z) = src_in.mesh_coords
+ # Source term
+ u_out.data[0][chi(x,y,z)] = src_in.data[0][chi(x,y,z)]
+ # BC enforcment
+ u_out.data[0][:,:,x[0,0,:]<0.1] = 0.
+ u_out.data[0][:,:,x[0,0,:]>0.9] = 0.
+ u_out.data[0][:,y[0,:,0]<0.1,:] = 0.
+ u_out.data[0][:,y[0,:,0]>0.9,:] = 0.
+ source = CustomOperator(
+ implementation=Implementation.PYTHON,
+ func=computeSRC,
+ variables={uSources: npts, u: npts},
+ invars=(uSources, u), outvars=(u,),
+ **extra_op_kwds)
+ # Diffusion operator
+ if impl is Implementation.FORTRAN or impl is Implementation.PYTHON:
+ diffuse = Diffusion(
+ implementation=impl,
+ name='diffuse',
+ Fin=u, Fout=u,
+ nu=.1,
+ variables={u: npts},
+ dt=pseudo_dt,
+ **extra_op_kwds)
+ else:
+ diffuse_op = DirectionalDiffusion(
+ implementation=impl,
+ name='diffuse',
+ fields=(u),
+ coeffs=(.1,),
+ variables={u: npts},
+ dt=pseudo_dt,
+ **extra_op_kwds)
+ diffuse = StrangSplitting(splitting_dim=dim, order=args.strang_order)
+ diffuse.push_operators(diffuse_op)
+ # Convergence operator with absolute error
+ conv = Convergence(convergence=convergence,
+ method={ResidualError: ResidualError.ABSOLUTE},
+ variables={u: npts},
+ name='convergence',
+ implementation=Implementation.PYTHON,
+ **extra_op_kwds)
+ # Dummy operators to fix in/out topologies
+ fp_in = Dummy(implementation=Implementation.PYTHON,
+ name="dummy_fixedpoint_input",
+ variables={uSources: npts, u: npts},
+ **extra_op_kwds)
+ fp_out = Dummy(implementation=Implementation.PYTHON,
+ name="dummy_fixedpoint_output",
+ variables={u: npts},
+ **extra_op_kwds)
+ # Iterative method problem with convergence
+ fixedPoint = IterativeMethod(stop_criteria=convergence, tolerance=1e-6,
+ dt0=1e-3, dt=pseudo_dt,
+ name="FixedPointIterations")
+ fixedPoint.insert(fp_in, diffuse,
+ source, conv, fp_out)
+ heat_sources = AnalyticField(name='heat_sources',
+ field=uSources, formula=CS,
+ variables = {uSources: npts},
+ implementation=Implementation.PYTHON,
+ extra_input_kwds={'t': t},
+ **extra_op_kwds)
+ # Dummy operators to fix in/out topologies
+ fp_enter = Dummy(implementation=Implementation.PYTHON,
+ name="dummy_fixedpoint_enter",
+ variables={uSources: npts, u: npts},
+ **extra_op_kwds)
+ fp_after = Dummy(implementation=Implementation.PYTHON,
+ name="dummy_fixedpoint_after",
+ variables={u: npts},
+ **extra_op_kwds)
+ #> We ask to dump the outputs of this operator
+ io_params = IOParams(filename='fields', frequency=args.dump_freq)
+ dump_fields = HDF_Writer(name='fields', io_params=io_params,
+ variables={u: npts}, **extra_op_kwds)
+
+ # Main problem (time iterations)
+ problem = Problem(name="MainProblem")
+ problem.insert(heat_sources, fp_enter, fixedPoint, fp_after, dump_fields)
+ problem.build()
+ simu = Simulation(start=args.tstart, end=args.tend,
+ nb_iter=args.nb_iter,
+ max_iter=args.max_iter,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
+ t=t, dt=dt)
+ simu.write_parameters(t, fixedPoint.it_num,
+ filename='parameters.txt', precision=8)
+ problem.initialize_field(u, formula=init_u)
+ problem.solve(simu, dry_run=args.dry_run,
+ checkpoint_handler=args.checkpoint_handler)
+ problem.finalize()
+
+
+if __name__=='__main__':
+ from hysop_examples.example_utils import HysopArgParser, colors
+
+ class IMArgParser(HysopArgParser):
+ def __init__(self):
+ prog_name = 'iterative_method'
+ default_dump_dir = '{}/hysop_examples/{}'.format(HysopArgParser.tmp_dir(),
+ prog_name)
+ description=colors.color('HySoP iterative method for heat equation Example.\n',
+ fg='blue', style='bold')
+ super(IMArgParser, self).__init__(
+ prog_name=prog_name,
+ description=description,
+ default_dump_dir=default_dump_dir)
+
+ parser = IMArgParser()
+
+ parser.set_defaults(impl='cl', ndim=3, npts=(32,),
+ box_origin=(0.0,), box_length=(1.,),
+ tstart=0.0, tend=np.pi*2,
+ dt=1e-1, dump_freq=10)
+
+ parser.run(compute)
diff --git a/hysop_examples/examples/flow_around_sphere/flow_around_sphere.py b/hysop_examples/examples/flow_around_sphere/flow_around_sphere.py
new file mode 100644
index 0000000000000000000000000000000000000000..858e4bbf71e186cd381554276b68ccc966240156
--- /dev/null
+++ b/hysop_examples/examples/flow_around_sphere/flow_around_sphere.py
@@ -0,0 +1,345 @@
+import os
+import numpy as np
+
+
+
+pi = np.pi
+cos = np.cos
+sin = np.sin
+
+
+def compute(args):
+ from hysop import Box, Simulation, Problem, MPIParams, Field, IOParams
+ from hysop.defaults import VelocityField, VorticityField, \
+ EnstrophyParameter, TimeParameters
+ from hysop.parameters.tensor_parameter import TensorParameter
+ from hysop.constants import Implementation, AdvectionCriteria, HYSOP_REAL, \
+ StretchingFormulation, StretchingCriteria, Backend
+ from hysop.operators import Advection, StaticDirectionalStretching, Diffusion, \
+ PoissonCurl, AdaptiveTimeStep, HDF_Writer, \
+ Enstrophy, MinMaxFieldStatistics, StrangSplitting, \
+ ParameterPlotter, PenalizeVorticity, FlowRateCorrection, \
+ VorticityAbsorption, CustomOperator, DirectionalAdvection, \
+ DirectionalStretching
+ from hysop.numerics.odesolvers.runge_kutta import RK2
+ from hysop.methods import SpaceDiscretization, Remesh, TimeIntegrator, \
+ ComputeGranularity, Interpolation, StrangOrder
+ from hysop.topology.cartesian_topology import CartesianTopology
+ from hysop.tools.parameters import CartesianDiscretization
+ # Define the domain
+ dim = args.ndim
+ assert dim == 3
+ npts = args.npts
+ box = Box(dim=dim,origin=args.box_origin, length=args.box_length)
+ cfl = args.cfl
+ lcfl = args.lcfl
+ uinf = 1.0
+ viscosity = 1. / 250.
+ outfreq = args.dump_freq
+ dt0 = args.dt
+
+ # Get default MPI Parameters from domain (even for serial jobs)
+ mpi_params = MPIParams(comm=box.task_comm,
+ task_id=box.current_task())
+
+ # Setup usual implementation specific variables
+ impl = args.impl
+ extra_op_kwds = {'mpi_params': mpi_params}
+ implIsFortran = impl is Implementation.FORTRAN
+ backend = Backend.HOST
+ if (impl is Implementation.PYTHON or implIsFortran):
+ method = {}
+ elif (impl is Implementation.OPENCL):
+ # For the OpenCL implementation we need to setup the compute device
+ # and configure how the code is generated and compiled at runtime.
+
+ # Create an explicit OpenCL context from user parameters
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
+
+ # Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
+ from hysop.methods import OpenClKernelConfig
+ method = { OpenClKernelConfig: args.opencl_kernel_config }
+
+ # Setup opencl specific extra operator keyword arguments
+ extra_op_kwds['cl_env'] = cl_env
+ else:
+ msg='Unknown implementation \'{}\'.'.format(impl)
+ raise ValueError(msg)
+
+
+ # ====== Sphere inside the domain ======
+ RADIUS = 0.5
+ pos = [0., 0., 0.]
+ def computeSphere(data, coords, component):
+ assert (component==0)
+ (x, y, z) = coords
+ dx = x[0,0,1] - x[0,0,0]
+ dy = y[0,1,0] - y[0,0,0]
+ dz = z[1,0,0] - z[0,0,0]
+ data[...] = 0.
+ chi = lambda x,y,z: np.sqrt((x-pos[0])*(x-pos[0])+(y-pos[1])*(y-pos[1])+(z-pos[2])*(z-pos[2]))<=RADIUS
+ data[chi(x,y,z)] = 1.
+
+ # Smooth the sphere surface with a Volume-of-fluid fraction
+ vof = 5 # number of points in the subgrid
+ front_z = np.where(np.abs(data[0:-1,:,:]-data[1:,:,:])>0.1)
+ front_z = (np.concatenate((front_z[0],front_z[0]+1)),
+ np.concatenate((front_z[1],front_z[1])),
+ np.concatenate((front_z[2],front_z[2])))
+ front_y = np.where(np.abs(data[:,0:-1,:]-data[:,1:,:])>0.1)
+ front_y = (np.concatenate((front_y[0],front_y[0])),
+ np.concatenate((front_y[1],front_y[1]+1)),
+ np.concatenate((front_y[2],front_y[2])))
+ front = (np.concatenate((front_z[0],front_y[0])),
+ np.concatenate((front_z[1],front_y[1])),
+ np.concatenate((front_z[2],front_y[2])))
+ front_x = np.where(np.abs(data[:,:,0:-1]-data[:,:,1:])>0.1)
+ front_x = (np.concatenate((front_x[0],front_x[0])),
+ np.concatenate((front_x[1],front_x[1])),
+ np.concatenate((front_x[2],front_x[2]+1)))
+ front = (np.concatenate((front[0],front_x[0])),
+ np.concatenate((front[1],front_x[1])),
+ np.concatenate((front[2],front_x[2])))
+
+ for k,j,i in zip(*front):
+ sx = np.linspace(x[0,0,i]-dx/2,x[0,0,i]+dx/2,vof)[np.newaxis,np.newaxis,:]
+ sy = np.linspace(y[0,j,0]-dy/2,y[0,j,0]+dy/2,vof)[np.newaxis,:,np.newaxis]
+ sz = np.linspace(z[k,0,0]-dz/2,z[k,0,0]+dz/2,vof)[:,np.newaxis,np.newaxis]
+ data[k,j,i] = 1.*(np.sum(chi(sx, sy, sz))/(1.0*vof**3))
+
+
+ # ======= Function to compute initial velocity =======
+ def computeVel(data, coords, component):
+ data[...] = uinf if (component==0) else 0.0
+
+ # ======= Function to compute initial vorticity =======
+ def computeVort(data, coords, component):
+ data[...] = 0.0
+
+
+ def computeFlowrate(t, flowrate):
+ fr = np.zeros(3)
+ fr[-1] = uinf * box.length[1] * box.length[0]
+ Tstart=3.0
+ if t() >= Tstart and t() <= Tstart + 1.0:
+ fr[1] = sin(pi * (t() - Tstart)) * \
+ box.length[1] * box.length[0]
+ flowrate.value = fr
+
+
+ method = {}
+
+ # Define parameters and field (time, timestep, velocity, vorticity, enstrophy)
+ t, dt = TimeParameters(dtype=args.dtype)
+ velo = VelocityField(domain=box, dtype=args.dtype)
+ vorti = VorticityField(velocity=velo, dtype=args.dtype)
+ sphere = Field(domain=box, name="Sphere", is_vector=False, dtype=args.dtype)
+ wdotw = Field(domain=box, dtype=args.dtype, is_vector=False, name="WdotW")
+ enstrophy = EnstrophyParameter(dtype=args.dtype)
+ flowrate = TensorParameter(name="flowrate", dtype=args.dtype, shape=(3, ),
+ initial_value=[0., 0., uinf * box.length[1] * box.length[0]])
+
+
+ # # Topologies
+ # topo_nogh = CartesianTopology(domain=box,
+ # discretization=CartesianDiscretization(npts,
+ # default_boundaries=True),
+ # mpi_params=mpi_params,
+ # cutdirs=[True, False, False])
+ # topo_gh = CartesianTopology(domain=box,
+ # discretization=CartesianDiscretization(npts,
+ # ghosts=(4, 4, 4), default_boundaries=True),
+ # mpi_params=mpi_params,
+ # cutdirs=[True, False, False])
+
+
+ ### Build the directional operators
+ #> Directional advection
+ if implIsFortran:
+ advec = Advection(
+ implementation=impl,
+ name='advec',
+ velocity=velo,
+ advected_fields=(vorti,),
+ variables={velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ else:
+ advec_dir = DirectionalAdvection(
+ implementation=impl,
+ name='advec',
+ velocity = velo,
+ advected_fields = (vorti, ),
+ velocity_cfl = args.cfl,
+ variables = {velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Directional stretching + diffusion
+ if impl is Implementation.OPENCL:
+ StretchOp = DirectionalStretching
+ else:
+ StretchOp = StaticDirectionalStretching
+ stretch = StretchOp(
+ implementation=Implementation.PYTHON if implIsFortran else impl,
+ name='stretch',
+ formulation=StretchingFormulation.CONSERVATIVE,
+ velocity=velo,
+ vorticity=vorti,
+ variables={velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Directional splitting operator subgraph
+ splitting = StrangSplitting(splitting_dim=dim,
+ order=StrangOrder.STRANG_FIRST_ORDER)
+ if not implIsFortran:
+ splitting.push_operators(advec_dir)
+ splitting.push_operators(stretch)
+ #> Penalization
+ penal = PenalizeVorticity(
+ implementation=Implementation.PYTHON,
+ name='penalization',
+ velocity=velo, vorticity=vorti,
+ variables={velo: npts, vorti: npts, sphere: npts},
+ obstacles=[sphere, ], coeff=1e8,
+ dt=dt, **extra_op_kwds)
+ #> Diffusion operator
+ diffuse = Diffusion(
+ implementation=impl,
+ name='diffuse',
+ nu=viscosity,
+ Fin=vorti,
+ variables={vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Vorticity absorption
+ absorption = VorticityAbsorption(
+ implementation=Implementation.PYTHON,
+ velocity=velo, vorticity=vorti,
+ start_coord=6.68,
+ flowrate=flowrate,
+ name="absorption",
+ variables={velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Poisson operator to recover the velocity from the vorticity
+ poisson = PoissonCurl(
+ implementation=impl,
+ name='poisson',
+ velocity=velo,
+ vorticity=vorti,
+ variables={velo: npts, vorti: npts},
+ projection=None,
+ **extra_op_kwds)
+ #> Flowrate correction operator to adjust velocity with prescribed flowrate
+ computeFlowrate = CustomOperator(func=computeFlowrate,
+ invars=(t, ),
+ outvars=(flowrate, ))
+ correctFlowrate = FlowRateCorrection(
+ implementation=Implementation.PYTHON,
+ name="flowrate_correction",
+ velocity=velo, vorticity=vorti,
+ flowrate=flowrate,
+ dt=dt,
+ variables={velo: npts, vorti: npts},
+ **extra_op_kwds)
+
+ #> outputs
+ io_params = IOParams(filename='fields', frequency=args.dump_freq)
+ dump_fields = HDF_Writer(name='fields', io_params=io_params,
+ force_backend=backend,
+ variables={velo: npts, vorti: npts}, **extra_op_kwds)
+
+ #> Operator to compute the infinite norm of the velocity
+ min_max_U = MinMaxFieldStatistics(name='min_max_U', field=velo,
+ Finf=True, implementation=Implementation.PYTHON if implIsFortran else impl, variables={velo:npts},
+ **extra_op_kwds)
+ #> Operator to compute the infinite norm of the vorticity
+ min_max_W = MinMaxFieldStatistics(name='min_max_W', field=vorti,
+ Finf=True, implementation=Implementation.PYTHON if implIsFortran else impl, variables={vorti:npts},
+ **extra_op_kwds)
+ #> Operator to compute the enstrophy
+ enstrophy_op = Enstrophy(
+ name='enstrophy',
+ vorticity=vorti, enstrophy=enstrophy, WdotW=wdotw,
+ variables={vorti:npts, wdotw: npts},
+ implementation=Implementation.PYTHON if implIsFortran else impl, **extra_op_kwds)
+
+ ### Adaptive timestep operator
+ #TODO: move advection to GRAD_U
+ #TODO: add stretching criteria, based on a gradient
+ adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True,
+ start_time=10*dt0) # start adapting timestep at t=10*dt0
+ dt_cfl = adapt_dt.push_cfl_criteria(cfl=cfl,
+ Finf=min_max_U.Finf,
+ equivalent_CFL=True)
+ dt_advec = adapt_dt.push_advection_criteria(lcfl=lcfl,
+ Finf=min_max_W.Finf,
+ criteria=AdvectionCriteria.W_INF)
+ #criteria=AdvectionCriteria.GRAD_U)
+ # dt_advec = adapt_dt.push_stretching_criteria(lcfl=lcfl,
+ # gradFinf=grad_W.Finf,
+ # criteria=StretchingCriteria.GRAD_U)
+
+ ## Create the problem we want to solve and insert our
+ # directional splitting subgraph and the standard operators.
+ # The method dictionnary passed to this graph will be dispatched
+ # accross all operators contained in the graph.
+ method.update({SpaceDiscretization: args.fd_order,
+ TimeIntegrator: args.time_integrator,
+ Remesh: args.remesh_kernel,
+ Interpolation: Interpolation.LINEAR})
+ problem = Problem(method=method)
+ problem.insert(
+ computeFlowrate,
+ penal,
+ splitting,
+ diffuse)
+ if implIsFortran:
+ problem.insert(advec)
+ problem.insert(
+ absorption,
+ poisson,
+ correctFlowrate,
+ enstrophy_op, min_max_U, min_max_W, dump_fields,
+ adapt_dt
+ )
+ problem.build()
+
+ ## Create a simulation
+ ## (do not forget to specify the t and dt parameters here)
+ simu = Simulation(start=args.tstart, end=args.tend,
+ nb_iter=args.nb_iter,
+ max_iter=args.max_iter,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
+ t=t, dt=dt)
+ simu.write_parameters(t, dt_cfl, dt_advec, dt, enstrophy, flowrate,
+ min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
+ filename='parameters.txt', precision=8)
+
+ problem.initialize_field(vorti, formula=computeVort)
+ problem.initialize_field(velo, formula=computeVel)
+ problem.initialize_field(sphere, formula=computeSphere)
+
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
+
+ # Finalize
+ problem.finalize()
+
+
+if __name__=='__main__':
+ from hysop_examples.example_utils import HysopArgParser, colors
+ parser = HysopArgParser(prog_name="FlowAroundSphere",
+ description="""HySoP flow around a sphere.\n""",
+ default_dump_dir='{}/hysop_examples/FlowAroundSphere'.format(
+ HysopArgParser.tmp_dir()))
+ parser.set_defaults(impl='cl', ndim=3, npts=(32,32,64),
+ box_origin=(-2.56, -2.56, -2.56),
+ box_length=(5.12, 5.12, 10.24),
+ tstart=0.0, tend=10.0,
+ dt=0.0125,
+ cfl=0.5, lcfl=0.125,
+ dump_freq=100, dump_times=(10.0, ))
+ parser.run(compute)
diff --git a/examples/multiresolution/scalar_advection.py b/hysop_examples/examples/multiresolution/scalar_advection.py
similarity index 72%
rename from examples/multiresolution/scalar_advection.py
rename to hysop_examples/examples/multiresolution/scalar_advection.py
index a55ad78194c9b704241787f99f4b9da180cff124..71ed3d9471b23edf9f44adb69b5cde4decd83165 100644
--- a/examples/multiresolution/scalar_advection.py
+++ b/hysop_examples/examples/multiresolution/scalar_advection.py
@@ -7,39 +7,30 @@ def compute(args):
ScalarParameter, MPIParams, IOParams, IO
from hysop.constants import Implementation, BoxBoundaryCondition
from hysop.operators import Advection, DirectionalAdvection, StrangSplitting, \
- LowpassFilter, HDF_Writer
+ SpatialFilter, HDF_Writer
from hysop.methods import Remesh, TimeIntegrator, \
- Interpolation, FilteringMethod
+ Interpolation, FilteringMethod, \
+ PolynomialInterpolator
## IO paths
spectral_path = IO.default_path() + '/spectral'
## Function to compute initial velocity values
- def init_velocity(data, coords, component=None):
- if (component is None):
- for i in xrange(len(data)):
- data[i][...] = args.velocity[::-1][i]
- else:
- assert len(data)==1
- i, = component
- data[0][...] = args.velocity[::-1][i]
+ def init_velocity(data, coords, component):
+ data[...] = args.velocity[::-1][component]
## Function to compute initial scalar values
- def init_scalar(data, coords, component=None):
- if (component in (None,0)):
- data[0][...] = 1.0
- for x in coords[0]:
- data[0][...] *= np.cos(x)
-
- if (component in (None,1)):
- data[1][...] = 1.0
- for x in coords[0]:
- data[1][...] *= np.sin(x)
+ def init_scalar(data, coords, component):
+ data[...] = 1.0
+ for x in coords:
+ data[...] *= np.cos(x + component*(np.pi/2))
# Define domain
- dim = args.ndim
- npts = args.npts
- snpts = tuple(3*x for x in args.npts)
+ dim = args.ndim
+ npts = args.npts # coarse resolution
+ snpts = args.snpts # fine resolution
+ fnpts = tuple(3*_ for _ in snpts) # finest resolution
+ cnpts = tuple(_//2 for _ in npts) # coarsest resolution
lboundaries = (BoxBoundaryCondition.PERIODIC,)*dim
rboundaries = (BoxBoundaryCondition.PERIODIC,)*dim
box = Box(origin=args.box_origin, length=args.box_length, dim=dim,
@@ -57,9 +48,9 @@ def compute(args):
# Setup operator method dictionnary
# Advection-Remesh operator discretization parameters
method = {
- TimeIntegrator: args.time_integrator,
- Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
+ TimeIntegrator: args.time_integrator,
+ Remesh: args.remesh_kernel,
+ PolynomialInterpolator: args.polynomial_interpolator,
}
# Setup implementation specific variables
@@ -70,9 +61,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params, platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning method
# (already done by HysopArgParser for simplicity)
@@ -121,31 +114,45 @@ def compute(args):
# Finally insert our splitted advection into the problem
problem.insert(splitting)
- #> Lowpass filters
- lpfilter = LowpassFilter(input_variables={scalar: snpts},
- output_variables={scalar: npts},
- filtering_method=FilteringMethod.SPECTRAL,
- dump_input_energy=IOParams(filepath=spectral_path,
- filename='E_fine_{fname}', frequency=args.dump_freq),
- dump_output_energy=IOParams(filepath=spectral_path,
- filename='E_coarse_{fname}', frequency=args.dump_freq),
+
+ #> Interpolation filter
+ interpolation_filter = SpatialFilter(input_variables={scalar: snpts},
+ output_variables={scalar: fnpts},
+ filtering_method=args.interpolation_filter,
implementation=impl,
**extra_op_kwds)
-
+ #> Restriction filter
+ restriction_filter = SpatialFilter(input_variables={scalar: npts},
+ output_variables={scalar: cnpts},
+ filtering_method=args.restriction_filter,
+ implementation=impl,
+ **extra_op_kwds)
+
#> Operators to dump all fields
+ io_params = IOParams(filename='finest', frequency=args.dump_freq)
+ df0 = HDF_Writer(name='S_finest',
+ io_params=io_params,
+ variables={scalar: fnpts},
+ **extra_op_kwds)
io_params = IOParams(filename='fine', frequency=args.dump_freq)
- df0 = HDF_Writer(name='S_fin',
+ df1 = HDF_Writer(name='S_fine',
io_params=io_params,
variables={scalar: snpts},
**extra_op_kwds)
io_params = IOParams(filename='coarse', frequency=args.dump_freq)
- df1 = HDF_Writer(name='S_coarse',
+ df2 = HDF_Writer(name='S_coarse',
io_params=io_params,
variables={scalar: npts},
**extra_op_kwds)
+ io_params = IOParams(filename='coarsest', frequency=args.dump_freq)
+ df3 = HDF_Writer(name='S_coarsest',
+ io_params=io_params,
+ variables={scalar: cnpts},
+ **extra_op_kwds)
# Add a writer of input field at given frequency.
- problem.insert(lpfilter, df0, df1)
+ problem.insert(interpolation_filter, restriction_filter,
+ df0, df1, df2, df3)
problem.build(args)
# If a visu_rank was provided, and show_graph was set,
@@ -171,18 +178,20 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- times_of_interest=args.dump_times,
+ times_of_interest=args.times_of_interest,
dt=dt, dt0=dt0)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
-
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class MultiResolutionScalarAdvectionArgParser(HysopArgParser):
def __init__(self):
@@ -212,13 +221,14 @@ if __name__=='__main__':
self._check_default(args, 'velocity', tuple, allow_none=False)
def _setup_parameters(self, args):
+ super(MultiResolutionScalarAdvectionArgParser, self)._setup_parameters(args)
if len(args.velocity) == 1:
args.velocity *= args.ndim
parser = MultiResolutionScalarAdvectionArgParser()
parser.set_defaults(box_origin=(0.0,), box_length=(2*np.pi,),
- tstart=0.0, tend=2*np.pi, npts=(16,16,16,),
+ tstart=0.0, tend=2*np.pi, npts=(16,),
dump_freq=10, cfl=0.5, velocity=(1.0,),
ndim=3, compute_precision='fp64')
diff --git a/examples/particles_above_salt/particles_above_salt_bc.py b/hysop_examples/examples/particles_above_salt/particles_above_salt_bc.py
similarity index 91%
rename from examples/particles_above_salt/particles_above_salt_bc.py
rename to hysop_examples/examples/particles_above_salt/particles_above_salt_bc.py
index 73a0491c389c9a52da0c080acb1c41830a486caa..1054d6ace33451d7c77daa327a117142fe5ff0f8 100644
--- a/examples/particles_above_salt/particles_above_salt_bc.py
+++ b/hysop_examples/examples/particles_above_salt/particles_above_salt_bc.py
@@ -6,38 +6,33 @@ import scipy as sp
import sympy as sm
# initialize vorticity
-def init_vorticity(data, coords, component=None):
+def init_vorticity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize velocity
-def init_velocity(data, coords, component=None):
+def init_velocity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize sediment concentration and salinity
-def delta(*coords):
- d = np.prod(*coords)
- return np.zeros_like(d)
-
def delta(Ys, l0):
Y0 = 1
for Yi in Ys:
Y0 = Y0*Yi
return 0.1*l0*(np.random.rand(*Y0.shape)-0.5)
-def init_concentration(data, coords, l0):
- coords, = coords
+def init_concentration(data, coords, l0, component):
+ assert (component==0)
X = coords[0]
Ys = coords[0:]
- data[0][...] = 0.5*(1.0 +
+ data[...] = 0.5*(1.0 +
sp.special.erf((X-delta(Ys,l0))/l0))
-def init_salinity(data, coords, l0):
- init_concentration(data, coords, l0)
- data[0][...] = 1.0 - data[0][...]
+def init_salinity(data, coords, l0, component):
+ assert (component==0)
+ init_concentration(data=data, coords=coords, l0=l0, component=component)
+ data[...] = 1.0 - data[...]
def compute(args):
from hysop import Field, Box, Simulation, Problem, MPIParams, IOParams, vprint, \
@@ -94,7 +89,7 @@ def compute(args):
S_lboundaries = (BoundaryCondition.PERIODIC,)*(dim-1)+(BoundaryCondition.HOMOGENEOUS_NEUMANN,)
S_rboundaries = (BoundaryCondition.PERIODIC,)*(dim-1)+(BoundaryCondition.HOMOGENEOUS_DIRICHLET,)
C_lboundaries = (BoundaryCondition.PERIODIC,)*(dim-1)+(BoundaryCondition.HOMOGENEOUS_DIRICHLET,)
- C_rboundaries = (BoundaryCondition.PERIODIC,)*(dim-1)+(BoundaryCondition.HOMOGENEOUS_NEUMANN,)
+ C_rboundaries = (BoundaryCondition.PERIODIC,)*(dim-1)+(BoundaryCondition.HOMOGENEOUS_NEUMANN.bind_data(1.0),)
box = Box(origin=Xo, length=np.subtract(Xn,Xo),
lboundaries=lboundaries, rboundaries=rboundaries)
@@ -114,10 +109,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -239,9 +235,8 @@ def compute(args):
**extra_op_kwds)
#> Operators to dump all fields
- io_params = IOParams(filename='fields', frequency=args.dump_freq)
dump_fields = HDF_Writer(name='dump',
- io_params=io_params,
+ io_params=args.io_params.clone(filename='fields'),
force_backend=Backend.OPENCL,
variables={velo: npts,
vorti: npts,
@@ -284,7 +279,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
@@ -301,14 +295,14 @@ def compute(args):
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
- problem.display()
+ problem.display(args.visu_rank)
# Create a simulation
# (do not forget to specify the t and dt parameters here)
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
@@ -320,15 +314,17 @@ def compute(args):
problem.initialize_field(field=C, formula=init_concentration, l0=l0)
problem.initialize_field(field=S, formula=init_salinity, l0=l0)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ParticleAboveSaltArgParser(HysopArgParser):
def __init__(self):
@@ -351,6 +347,7 @@ if __name__=='__main__':
default_dump_dir=default_dump_dir)
def _setup_parameters(self, args):
+ super(ParticleAboveSaltArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/particles_above_salt/particles_above_salt_bc_3d.py b/hysop_examples/examples/particles_above_salt/particles_above_salt_bc_3d.py
similarity index 85%
rename from examples/particles_above_salt/particles_above_salt_bc_3d.py
rename to hysop_examples/examples/particles_above_salt/particles_above_salt_bc_3d.py
index 09383880d777e6361a45d5c75d50b568cfcae588..f7c1b6c54328948bc6b02751f7daf75df3a88c84 100644
--- a/examples/particles_above_salt/particles_above_salt_bc_3d.py
+++ b/hysop_examples/examples/particles_above_salt/particles_above_salt_bc_3d.py
@@ -6,16 +6,14 @@ import scipy as sp
import sympy as sm
# initialize vorticity
-def init_vorticity(data, coords, component=None):
+def init_vorticity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize velocity
-def init_velocity(data, coords, component=None):
+def init_velocity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize sediment concentration and salinity
def delta(*coords):
@@ -28,16 +26,17 @@ def delta(Ys, l0):
Y0 = Y0*Yi
return 0.1*l0*(np.random.rand(*Y0.shape)-0.5)
-def init_concentration(data, coords, l0):
- coords, = coords
+def init_concentration(data, coords, l0, component):
+ assert (component==0)
X = coords[0]
Ys = coords[0:]
- data[0][...] = 0.5*(1.0 +
+ data[...] = 0.5*(1.0 +
sp.special.erf((X-delta(Ys,l0))/l0))
-def init_salinity(data, coords, l0):
- init_concentration(data, coords, l0)
- data[0][...] = 1.0 - data[0][...]
+def init_salinity(data, coords, l0, component):
+ assert (component==0)
+ init_concentration(data=data, coords=coords, l0=l0, component=component)
+ data[...] = 1.0 - data[...]
def compute(args):
from hysop import Field, Box, Simulation, Problem, MPIParams, IOParams, vprint, \
@@ -76,12 +75,16 @@ def compute(args):
# Constants
l0 = 1.5 #initial thickness of the profile
dim = args.ndim
- if (dim==2):
- (Sc, tau, Vp, Rs, Xo, Xn, N) = (0.70, 25, 0.04, 2.0, (-600,0), (600,750), (1537, 512))
- elif (dim==3):
+ if (dim==3):
(Sc, tau, Vp, Rs, Xo, Xn, N) = (7.00, 25, 0.04, 2.0, (-110,0,0), (65,100,100), (3073, 1024, 1024))
- n = 128
+ Sc = args.schmidt
+ tau = args.tau
+ Vp = args.Vp
+ Rs = args.Rs
+ n = args.npts[0]
N = (3*n+1, n, n)
+ print 'Example configuration is Sc={}, Tau={}, Vp={}, Rs={}, n={}, N={}'.format(Sc, tau, Vp, Rs, n, N)
+ print
else:
raise NotImplementedError
@@ -294,14 +297,13 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
problem.insert(poisson,
diffuse_S, diffuse_C,
- dump_fields,
+ # dump_fields,
splitting,
min_max_U, min_max_W, adapt_dt)
problem.build(args)
@@ -309,14 +311,14 @@ def compute(args):
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
- problem.display()
+ problem.display(args.visu_rank)
# Create a simulation
# (do not forget to specify the t and dt parameters here)
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
@@ -328,15 +330,18 @@ def compute(args):
problem.initialize_field(field=C, formula=init_concentration, l0=l0)
problem.initialize_field(field=S, formula=init_salinity, l0=l0)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ParticleAboveSaltArgParser(HysopArgParser):
def __init__(self):
@@ -357,8 +362,30 @@ if __name__=='__main__':
prog_name=prog_name,
description=description,
default_dump_dir=default_dump_dir)
+
+ def _add_main_args(self):
+ args = super(ParticleAboveSaltArgParser, self)._add_main_args()
+ args.add_argument('-Sc', '--schmidt', type=float,
+ dest='schmidt',
+ help='Schmidt number of salt.')
+ args.add_argument('-tau', '--schmidt-ratio', type=float,
+ dest='tau',
+ help='Ratio between salt and sediment schmidt number')
+ args.add_argument('-Vp', '--stokes-velocity', type=float,
+ dest='Vp',
+ help='Falling sediment imposed velocity.')
+ args.add_argument('-Rs', '--density-expension-factor', type=float,
+ dest='Rs',
+ help='Density expension factor.')
+ return args
+
+ def _check_main_args(self, args):
+ super(ParticleAboveSaltArgParser, self)._check_main_args(args)
+ self._check_default(args, ('schmidt', 'tau', 'Vp', 'Rs'), float, allow_none=False)
+ self._check_positive(args, ('schmidt', 'tau', 'Vp', 'Rs'))
def _setup_parameters(self, args):
+ super(ParticleAboveSaltArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
@@ -372,7 +399,8 @@ if __name__=='__main__':
tstart=0.0, tend=201.0,
dt=1e-6, cfl=12.00, lcfl=0.95,
dump_times=(25.0, 50.0, 75.0, 100.0, 125.0, 150.0, 175.0, 200.0),
- dump_freq=0)
+ dump_freq=0,
+ schmidt=7.0, tau=25.0, Vp=0.04, Rs=2.0)
parser.run(compute)
diff --git a/examples/particles_above_salt/particles_above_salt_periodic.py b/hysop_examples/examples/particles_above_salt/particles_above_salt_periodic.py
similarity index 93%
rename from examples/particles_above_salt/particles_above_salt_periodic.py
rename to hysop_examples/examples/particles_above_salt/particles_above_salt_periodic.py
index e90f8a67b039e192943202132f973d5e315f5382..e4cc7645791a927b0e2b9ed7fe960b943513e8b4 100644
--- a/examples/particles_above_salt/particles_above_salt_periodic.py
+++ b/hysop_examples/examples/particles_above_salt/particles_above_salt_periodic.py
@@ -6,45 +6,40 @@ import scipy as sp
import sympy as sm
# initialize vorticity
-def init_vorticity(data, coords, component=None):
+def init_vorticity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize velocity
-def init_velocity(data, coords, component=None):
+def init_velocity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize sediment concentration and salinity
-def delta(*coords):
- d = np.prod(*coords)
- return np.zeros_like(d)
-
def delta(Ys, l0):
Y0 = 1
for Yi in Ys:
Y0 = Y0*Yi
return 0.1*l0*(np.random.rand(*Y0.shape)-0.5)
-def init_concentration(data, coords, l0):
- coords, = coords
+def init_concentration(data, coords, l0, component):
+ assert (component==0)
X = coords[-1]
Ys = coords[:-1]
- data[0][...] = 0.5*(1.0 +
+ data[...] = 0.5*(1.0 +
sp.special.erf((X-delta(Ys,l0))/l0))
-def init_salinity(data, coords, l0):
- init_concentration(data, coords, l0)
- data[0][...] = 1.0 - data[0][...]
+def init_salinity(data, coords, l0, component):
+ assert (component==0)
+ init_concentration(data=data, coords=coords, l0=l0, component=component)
+ data[...] = 1.0 - data[...]
-def init_lambda(data, coords):
- coords, = coords
+def init_lambda(data, coords, component):
+ assert (component==0)
Z = coords[-1]
- data[0][...] = (Z>+575)
- data[0][...] += (Z<-575)
- data[0][...] *= 1.0e8
+ data[...] = (Z>+575)
+ data[...] += (Z<-575)
+ data[...] *= 1.0e8
def compute(args):
from hysop import Field, Box, Simulation, Problem, MPIParams, IOParams, vprint, \
@@ -83,7 +78,7 @@ def compute(args):
# Define the domain
dim = args.ndim
- npts=N
+ npts = args.npts
box = Box(origin=Xo, length=np.subtract(Xn,Xo))
# Get default MPI Parameters from domain (even for serial jobs)
@@ -270,7 +265,7 @@ def compute(args):
msg = msg.format(S_dt, C_dt, W_dt)
msg = '\n'+framed_str(' DIFFUSION STABILITY CRITERIA ', msg)
vprint(msg)
- max_dt = min(S_dt, C_dt, W_dt)
+ max_dt = min(S_dt, C_dt, W_dt, 1.0)
adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True, max_dt=max_dt,
name='merge_dt', pretty_name='dt', )
@@ -295,7 +290,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
@@ -311,14 +305,14 @@ def compute(args):
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
- problem.display()
+ problem.display(args.visu_rank)
# Create a simulation
# (do not forget to specify the t and dt parameters here)
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
@@ -331,15 +325,18 @@ def compute(args):
problem.initialize_field(field=S, formula=init_salinity, l0=l0)
problem.initialize_field(field=_lambda, formula=init_lambda)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ParticleAboveSaltArgParser(HysopArgParser):
def __init__(self):
@@ -362,6 +359,7 @@ if __name__=='__main__':
default_dump_dir=default_dump_dir)
def _setup_parameters(self, args):
+ super(ParticleAboveSaltArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/particles_above_salt/particles_above_salt_symmetrized.py b/hysop_examples/examples/particles_above_salt/particles_above_salt_symmetrized.py
similarity index 93%
rename from examples/particles_above_salt/particles_above_salt_symmetrized.py
rename to hysop_examples/examples/particles_above_salt/particles_above_salt_symmetrized.py
index d48a421ee7e3855c070043dc882a05c394b890c8..9f9f71677e11fa636e23d83a673badec93dd7e6b 100644
--- a/examples/particles_above_salt/particles_above_salt_symmetrized.py
+++ b/hysop_examples/examples/particles_above_salt/particles_above_salt_symmetrized.py
@@ -6,40 +6,35 @@ import scipy as sp
import sympy as sm
# initialize vorticity
-def init_vorticity(data, coords, component=None):
+def init_vorticity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize velocity
-def init_velocity(data, coords, component=None):
+def init_velocity(data, coords, component):
# the flow is initially quiescent
- for d in data:
- d[...] = 0.0
+ data[...] = 0.0
# initialize sediment concentration and salinity
-def delta(*coords):
- d = np.prod(*coords)
- return np.zeros_like(d)
-
def delta(Ys, l0):
Y0 = 1
for Yi in Ys:
Y0 = Y0*Yi
- return 0.04*l0*(np.random.rand(*Y0.shape)-0.5)
+ return 0.1*l0*(np.random.rand(*Y0.shape)-0.5)
-def init_concentration(data, coords, l0):
- coords, = coords
+def init_concentration(data, coords, component, l0):
+ assert (component==0)
X = coords[-1].copy()
Xs = np.sign(X-1200.0)
Xa = np.abs(X-1200.0) - 600.0
Ys = coords[:-1]
- data[0][...] = 0.5*(1.0 +
+ data[...] = 0.5*(1.0 +
sp.special.erf((Xa-delta(Ys,l0))/l0))
-def init_salinity(data, coords, l0):
- init_concentration(data, coords, l0)
- data[0][...] = 1.0 - data[0][...]
+def init_salinity(data, coords, component, l0):
+ assert (component==0)
+ init_concentration(data=data, coords=coords, component=component, l0=l0)
+ data[...] = 1.0 - data[...]
def compute(args):
from hysop import Field, Box, Simulation, Problem, MPIParams, IOParams, vprint, \
@@ -80,7 +75,7 @@ def compute(args):
# Define the domain
dim = args.ndim
- npts = (2048,8192)
+ npts = args.npts
Xo = (0,0)
Xn = (2400,750)
box = Box(origin=Xo, length=np.subtract(Xn,Xo))
@@ -259,7 +254,7 @@ def compute(args):
io_params=io_params)
### Adaptive timestep operator
- adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True,
+ adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True, max_dt=1.0,
name='merge_dt', pretty_name='dt', )
dt_cfl = adapt_dt.push_cfl_criteria(cfl=args.cfl,
Fmin=min_max_U.Fmin,
@@ -282,7 +277,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
@@ -299,14 +293,14 @@ def compute(args):
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
- problem.display()
+ problem.display(args.visu_rank)
# Create a simulation
# (do not forget to specify the t and dt parameters here)
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
@@ -318,15 +312,18 @@ def compute(args):
problem.initialize_field(field=C, formula=init_concentration, l0=l0)
problem.initialize_field(field=S, formula=init_salinity, l0=l0)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ParticleAboveSaltArgParser(HysopArgParser):
def __init__(self):
@@ -349,6 +346,7 @@ if __name__=='__main__':
default_dump_dir=default_dump_dir)
def _setup_parameters(self, args):
+ super(ParticleAboveSaltArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/hysop_examples/examples/scalar_advection/levelset.py b/hysop_examples/examples/scalar_advection/levelset.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bf74e4698ff4a0e8ebde821da6894657ad38242
--- /dev/null
+++ b/hysop_examples/examples/scalar_advection/levelset.py
@@ -0,0 +1,250 @@
+import numpy as np
+import sympy as sm
+pi = np.pi
+
+def compute(args):
+ from hysop import Field, Box, Simulation, Problem, IOParams, vprint, \
+ ScalarParameter, MPIParams, CartesianDiscretization, CartesianTopology
+ from hysop.constants import Implementation, Backend
+ from hysop.operators import DirectionalAdvection, StrangSplitting, Integrate, \
+ AnalyticField, Advection, HDF_Writer
+ from hysop.methods import Remesh, TimeIntegrator, ComputeGranularity, \
+ Interpolation, StrangOrder
+ import hysop.numerics.odesolvers.runge_kutta as rk
+ from hysop.defaults import TimeParameters
+
+ ## Function to compute initial scalar values
+ def init_scalar(data, coords, component):
+ assert (component==0)
+ dim = len(coords)
+ if (dim == 3):
+ (x,y,z) = coords
+ rr = np.sqrt((x - 0.35) ** 2 + (y - 0.35) ** 2 + (z - 0.35) ** 2)
+ else:
+ (x,y) = coords
+ rr = np.sqrt((x - 0.5) ** 2 + (y - 0.75) ** 2)
+ data[...] = 0.
+ data[rr < 0.15] = 1.
+ rr = np.sqrt((x - 0.75) ** 2 + (y - 0.75) ** 2 + (z - 0.75) ** 2)
+ data[rr < 0.1] += 1.
+
+ # Define domain
+ impl = args.impl
+ dim = args.ndim
+ npts = args.npts
+ snpts = args.snpts
+ box = Box(origin=args.box_origin, length=args.box_length, dim=dim)
+ if dim == 3:
+ dt0 = 0.35 / (4. * pi)
+ else:
+ dt0 = 0.35 / (2. * pi)
+ cfl = 1.0 * dt0 * max(npts)
+ vprint('\nCFL is {}'.format(cfl))
+
+ # Get default MPI Parameters from domain (even for serial jobs)
+ mpi_params = MPIParams(comm=box.task_comm,
+ task_id=box.current_task())
+
+ vprint('Default I/O configuration:')
+ vprint(args.io_params.to_string(' '))
+ vprint()
+
+ method = {}
+ extra_op_kwds = { 'mpi_params': mpi_params }
+ if (impl is Implementation.OPENCL):
+ from hysop.methods import OpenClKernelConfig
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
+ extra_op_kwds['cl_env'] = cl_env
+ method[OpenClKernelConfig] = args.opencl_kernel_config
+ backend = Backend.OPENCL
+ elif (impl in (Implementation.PYTHON, Implementation.FORTRAN)):
+ backend = Backend.HOST
+ else:
+ msg='Unknown implementation \'{}\'.'.format(impl)
+ raise ValueError(msg)
+
+ # Define parameters and field (time and analytic field)
+ t, dt = TimeParameters(dtype=args.dtype)
+ velo = Field(domain=box, name='V', nb_components=dim, dtype=args.dtype)
+ scalar = Field(domain=box, name='S', nb_components=1, dtype=args.dtype)
+ vol = ScalarParameter('volume', dtype=args.dtype)
+
+ if (snpts == npts):
+ mask = velo[1]
+ else:
+ mask = scalar.field_like('mask')
+
+ # Setup operator method dictionnary
+ method.update({
+ TimeIntegrator: args.time_integrator,
+ Remesh: args.remesh_kernel,
+ Interpolation: args.advection_interpolator
+ })
+
+ # Create a simulation and solve the problem
+ # (do not forget to specify the dt parameter here)
+ simu = Simulation(start=args.tstart, end=args.tend,
+ nb_iter=args.nb_iter,
+ max_iter=args.max_iter,
+ times_of_interest=args.times_of_interest,
+ t=t, dt=dt, dt0=dt0)
+ simu.write_parameters(simu.t, vol, filename='volume.txt', precision=12)
+
+
+ # Setup implementation specific variables
+ if (impl is Implementation.PYTHON) or (impl is Implementation.FORTRAN):
+ sin, cos = np.sin, np.cos
+ def fcompute_velocity(data, coords, component, t):
+ (x,y,z) = coords
+ fn = [ +2.*sin(pi*x)**2*sin(2*pi*y)*sin(2.*pi*z)*cos(t()*pi/3.),
+ -sin(2.*pi*x)*sin(pi*y)**2*sin(2.*pi*z)*cos(t()*pi/3.),
+ -sin(2.*pi*x)*sin(2.*pi*y)*sin(pi*z)**2*cos(t()*pi/3.)]
+ data[...] = fn[component]
+ def fcompute_norm(data, coords, component):
+ data[...] = np.sqrt(data[0]**2 + data[1]**2 + data[2]**2)
+ def fcompute_volume(data, coords, component, S):
+ data[...] = (S[0] <= 0.5)
+ elif (impl is Implementation.OPENCL):
+ from hysop.symbolic.relational import LogicalLE
+ sin, cos = sm.sin, sm.cos
+ Vs = velo.s()
+ Ss = scalar.s()
+ if dim == 3:
+ x, y, z = box.frame.coords
+ formula = (2.*sin(pi*x)**2*sin(2.*pi*y)*sin(2.*pi*z)*cos(t.s*pi/3.),
+ -sin(2.*pi*x)*sin(pi*y)**2*sin(2.*pi*z)*cos(t.s*pi/3.),
+ -sin(2.*pi*x)*sin(2.*pi*y)*sin(pi*z)**2*cos(t.s*pi/3.))
+ else:
+ x, y = box.frame.coords
+ formula = (-sin(x*pi)**2*sin(y*pi*2)*cos(t.s*pi/3.),
+ sin(y*pi)**2*sin(x*pi*2)*cos(t.s*pi/3.))
+ fcompute_velocity = formula
+ fcompute_norm = (sm.sqrt(np.dot(Vs, Vs)), None, None)
+ fcompute_volume = LogicalLE(Ss, 0.5)
+ else:
+ msg='Unknown implementation \'{}\'.'.format(impl)
+ raise ValueError(msg)
+
+ if (impl is Implementation.FORTRAN):
+ advec = Advection(name='advec',
+ velocity = velo,
+ advected_fields = (scalar,),
+ dt=dt,
+ variables = {velo: npts, scalar: snpts},
+ implementation=impl,
+ **extra_op_kwds)
+ else:
+ advec_dir = DirectionalAdvection(name='advec',
+ velocity = velo,
+ velocity_cfl = cfl,
+ advected_fields = (scalar,),
+ dt=dt,
+ variables = {velo: npts, scalar: snpts},
+ implementation=impl,
+ **extra_op_kwds)
+ advec = StrangSplitting(splitting_dim=dim,
+ order=args.strang_order)
+ advec.push_operators(advec_dir)
+
+
+ compute_velocity = AnalyticField(name='compute_velocity', pretty_name='V(t)',
+ field=velo, formula=fcompute_velocity,
+ variables={velo: npts},
+ extra_input_kwds={'t': simu.t},
+ implementation=Implementation.PYTHON if (impl is Implementation.FORTRAN) else impl,
+ **extra_op_kwds)
+
+ compute_norm = AnalyticField(name='compute_norm', pretty_name='||V||',
+ field=velo, formula=fcompute_norm,
+ variables={velo: npts},
+ implementation=Implementation.PYTHON if (impl is Implementation.FORTRAN) else impl,
+ **extra_op_kwds)
+
+ compute_volume = AnalyticField(name='compute_volume', pretty_name='S<0.5',
+ field=mask, formula=fcompute_volume,
+ variables={mask: snpts, scalar: snpts},
+ extra_input_kwds={'S': scalar},
+ implementation=Implementation.PYTHON if (impl is Implementation.FORTRAN) else impl,
+ **extra_op_kwds)
+
+ # compute the volume (where S<=0.5), use Vy as tmp buffer when possible (ie. npts == snpts)
+ volume = Integrate(name='volume',
+ field=mask,
+ variables={mask: snpts},
+ parameter=vol,
+ implementation=impl,
+ **extra_op_kwds)
+
+ # dump scalar and velocity norm
+ if (npts==snpts):
+ io_params = args.io_params.clone(filename='fields')
+ dump_fields = HDF_Writer(name='fields', io_params=io_params,
+ force_backend=backend, variables={velo[0]: snpts, scalar: snpts}, **extra_op_kwds)
+ dumpers = (dump_fields,)
+ else:
+ io_params = args.io_params.clone(filename='scalar')
+ dump_scalar = HDF_Writer(name='scalar', io_params=io_params,
+ force_backend=backend, variables={scalar: snpts}, **extra_op_kwds)
+
+ io_params = args.io_params.clone(filename='vnorm')
+ dump_velocity_norm = HDF_Writer(name='Vnorm', io_params=io_params,
+ force_backend=backend, variables={velo[0]: npts}, **extra_op_kwds)
+ dumpers = (dump_scalar, dump_velocity_norm)
+
+ problem = Problem(method=method)
+ problem.insert(compute_velocity, advec)
+ if not args.bench_mode:
+ problem.insert(compute_norm, *dumpers)
+ problem.insert(compute_volume, volume)
+ problem.build(args=args)
+
+ # If a visu_rank was provided, and show_graph was set,
+ # display the graph on the given process rank.
+ if args.display_graph:
+ problem.display(args.visu_rank)
+
+ # Initialize scalar
+ problem.initialize_field(scalar, formula=init_scalar)
+
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
+ problem.finalize()
+
+
+if __name__=='__main__':
+ from hysop_examples.example_utils import HysopArgParser, colors
+
+ class LevelsetArgParser(HysopArgParser):
+ def __init__(self):
+ prog_name = 'levelset'
+ default_dump_dir = '{}/hysop_examples/{}'.format(HysopArgParser.tmp_dir(), prog_name)
+
+ description=colors.color('HySoP Levelset Example: ', fg='blue', style='bold')
+ description+='Advect a scalar by a time dependent analytic velocity. '
+
+ super(LevelsetArgParser, self).__init__(
+ prog_name=prog_name,
+ description=description,
+ default_dump_dir=default_dump_dir)
+
+ def _add_main_args(self):
+ args = super(LevelsetArgParser, self)._add_main_args()
+ args.add_argument('-b', '--bench', action='store_true',
+ dest='bench_mode',
+ help='Disable volume computation, bench only advection.')
+ return args
+
+ parser = LevelsetArgParser()
+
+ parser.set_defaults(box_origin=(0.0,), box_length=(1.0,),
+ ndim=3, tstart=0.0, tend=12.0,
+ npts=(128,), snpts=None, grid_ratio=1,
+ dump_period=0.1, dump_freq=0)
+ parser.run(compute)
diff --git a/examples/scalar_advection/scalar_advection.py b/hysop_examples/examples/scalar_advection/scalar_advection.py
similarity index 86%
rename from examples/scalar_advection/scalar_advection.py
rename to hysop_examples/examples/scalar_advection/scalar_advection.py
index 11d007844752144bca59f586e06e0f98d85749af..a75992ab2941e9ea67f3c0e89bd71954a1afd544 100644
--- a/examples/scalar_advection/scalar_advection.py
+++ b/hysop_examples/examples/scalar_advection/scalar_advection.py
@@ -11,20 +11,15 @@ def compute(args):
Interpolation
## Function to compute initial velocity values
- def init_velocity(data, coords, component=None):
- if (component is None):
- for i in xrange(len(data)):
- data[i][...] = args.velocity[::-1][i]
- else:
- assert len(data)==1
- i, = component
- data[0][...] = args.velocity[::-1][i]
+ def init_velocity(data, coords, component):
+ data[...] = args.velocity[::-1][component]
## Function to compute initial scalar values
- def init_scalar(data, coords):
- data[0][...] = 1.0
- for x in coords[0]:
- data[0][...] *= np.cos(x)
+ def init_scalar(data, coords, component):
+ assert (component==0)
+ data[...] = 1.0
+ for x in coords:
+ data[...] *= np.cos(x)
# Define domain
dim = args.ndim
@@ -46,7 +41,6 @@ def compute(args):
ComputeGranularity: args.compute_granularity,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
# Setup implementation specific variables
@@ -57,9 +51,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params, platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning method
# (already done by HysopArgParser for simplicity)
@@ -109,7 +105,8 @@ def compute(args):
problem.insert(splitting)
# Add a writer of input field at given frequency.
- problem.dump_inputs(fields=scalar, filename='S0', frequency=args.dump_freq, **extra_op_kwds)
+ problem.dump_inputs(fields=scalar,
+ io_params=args.io_params.clone(filename='S0'), **extra_op_kwds)
problem.build(args)
# If a visu_rank was provided, and show_graph was set,
@@ -135,18 +132,21 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- times_of_interest=args.dump_times,
+ times_of_interest=args.times_of_interest,
dt=dt, dt0=dt0)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ScalarAdvectionArgParser(HysopArgParser):
def __init__(self):
@@ -176,6 +176,7 @@ if __name__=='__main__':
self._check_default(args, 'velocity', tuple, allow_none=False)
def _setup_parameters(self, args):
+ super(ScalarAdvectionArgParser, self)._setup_parameters(args)
if len(args.velocity) == 1:
args.velocity *= args.ndim
diff --git a/examples/scalar_advection/turbulent_scalar_advection.py b/hysop_examples/examples/scalar_advection/turbulent_scalar_advection.py
similarity index 82%
rename from examples/scalar_advection/turbulent_scalar_advection.py
rename to hysop_examples/examples/scalar_advection/turbulent_scalar_advection.py
index 1c8664a819b0ccd2b8924786a2fc196f9d0db426..22f4ffb7c5640d71a358f8c5b53a302908a65a5c 100644
--- a/examples/scalar_advection/turbulent_scalar_advection.py
+++ b/hysop_examples/examples/scalar_advection/turbulent_scalar_advection.py
@@ -13,44 +13,39 @@ ampl = 0.05
## Function to compute initial vorticity
-def init_velocity(data, coords):
- (x, y, z) = coords[0]
+def init_velocity(data, coords, component):
+ (x, y, z) = coords
yy = (0.1 - 2. * np.abs(y - 0.5)) / (4. * width)
- data[0][...] = 0.5 * (1. + np.tanh(yy))
- data[0][...] *= (1. + ampl3 * np.sin(8. * np.pi * x))
- data[1][...] = 0.
- data[2][...] = 0.
- ## Random perturbation:
- strg1 = np.exp(-np.abs(yy ** 2)) * np.random.random(size=data[0].shape)
- strg2 = np.exp(-np.abs(yy ** 2)) * np.random.random(size=data[1].shape)
- strg3 = np.exp(-np.abs(yy ** 2)) * np.random.random(size=data[2].shape)
- data[0][...] *= (1. + ampl * strg1)
- data[1][...] = ampl * strg2
- data[2][...] = ampl * strg3
+ strg = np.exp(-np.abs(yy ** 2)) * np.random.random(size=data.shape)
+ if (component == 0):
+ data[...] = 0.5 * (1. + np.tanh(yy))
+ data[...] *= (1. + ampl3 * np.sin(8. * np.pi * x))
+ data[...] *= (1. + ampl * strg)
+ else:
+ data[...] = ampl * strg
return data
## Function to compute initial vorticity
-def init_vorticity(data, coords):
- (x, y, z) = coords[0]
- data[0][...] = 0.
- data[1][...] = 0.
- xx = -(0.3*np.sin(8.0*np.pi*x) + 1.0)
- yp=25.0*np.tanh(-50.0*y[y>0.5] + 27.5)**2 - 25.0
- ym=-25.0*np.tanh(50.0*y[y<0.5] - 22.5)**2 + 25.0
- data[2][:,y[0,:,0]>0.5,:] = yp[np.newaxis,:,np.newaxis]
- data[2][:,y[0,:,0]==0.5,:] = 0.
- data[2][:,y[0,:,0]<0.5,:] = ym[np.newaxis,:,np.newaxis]
- data[2][...] *= xx
- return data
-
-
-def init_scal(data, coords):
- (x, y, z) = coords[0]
+def init_vorticity(data, coords, component):
+ (x, y, z) = coords
+ if (component==2):
+ xx = -(0.3*np.sin(8.0*np.pi*x) + 1.0)
+ yp=25.0*np.tanh(-50.0*y[y>0.5] + 27.5)**2 - 25.0
+ ym=-25.0*np.tanh(50.0*y[y<0.5] - 22.5)**2 + 25.0
+ data[:,y[0,:,0]>0.5,:] = yp[np.newaxis,:,np.newaxis]
+ data[:,y[0,:,0]==0.5,:] = 0.
+ data[:,y[0,:,0]<0.5,:] = ym[np.newaxis,:,np.newaxis]
+ data[...] *= xx
+ else:
+ data[...] = 0.
+
+def init_scal(data, coords, component):
+ assert (component == 0)
+ (x, y, z) = coords
yy = abs(y - 0.5)
aux = (0.1 - 2. * yy) / (4. * width)
- data[0][...] = 0.5 * (1. + np.tanh(aux))
- data[0][...] *= (1. + ampl3 * np.sin(8. * pi * x))
- return data
+ data[...] = 0.5 * (1. + np.tanh(aux))
+ data[...] *= (1. + ampl3 * np.sin(8. * pi * x))
from hysop import Box, Simulation, Problem, MPIParams, Field
@@ -70,9 +65,9 @@ from hysop.tools.parameters import CartesianDiscretization
# Define the domain
dim = 3
-npts_uw = (65, )*dim
-npts_s = (129, )*dim
-box = Box(origin=(0., )*dim, length=(1.,)*dim, dim=dim)
+npts_uw = (64, 64, 128)
+npts_s = (128, 128, 256)
+box = Box(origin=(0., )*dim, length=(1.,1., 2.), dim=dim)
# Physical parameters:
# Flow viscosity
VISCOSITY = 1e-4
@@ -89,10 +84,16 @@ dump_freq = 100
mpi_params = MPIParams(comm=box.task_comm,
task_id=box.current_task())
+# Create an explicit OpenCL context from user parameters
+from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=0,
+ device_id=box.machine_rank%get_device_number())
# Setup usual implementation specific variables
impl = None
-extra_op_kwds = {'mpi_params': mpi_params}
-
+extra_op_kwds = {'mpi_params': mpi_params,
+ 'cl_env': cl_env}
method = {}
# Define parameters and field (time, timestep, velocity, vorticity, enstrophy)
@@ -108,7 +109,7 @@ topo_nogh = CartesianTopology(domain=box,
discretization=CartesianDiscretization(npts_uw,
default_boundaries=True),
mpi_params=mpi_params,
- cutdirs=[False, False, True])
+ cutdirs=[True, False, False])
### Build the directional operators
#> Directional advection
diff --git a/examples/scalar_diffusion/scalar_diffusion.py b/hysop_examples/examples/scalar_diffusion/scalar_diffusion.py
similarity index 64%
rename from examples/scalar_diffusion/scalar_diffusion.py
rename to hysop_examples/examples/scalar_diffusion/scalar_diffusion.py
index 4ee0f75ce85c69e4d1907eb8e9f6d87386209400..1abf3be08d7aa62b381b50a8ba66004c58385c97 100755
--- a/examples/scalar_diffusion/scalar_diffusion.py
+++ b/hysop_examples/examples/scalar_diffusion/scalar_diffusion.py
@@ -1,12 +1,12 @@
-#!/usr/bin/env python2
+import numpy as np
## Function to compute initial scalar values
-def init_scalar(data, coords):
- import numpy as np
- data[0][...] = 0.0
- for x in coords[0]:
- data[0][...] += (x - 0.5)*(x - 0.5)
- data[0][...] = np.exp(-np.sqrt(data[0]))
+def init_scalar(data, coords, component):
+ assert (component==0), component
+ data[...] = 0.0
+ for x in coords:
+ data[...] += (x - 0.5)*(x - 0.5)
+ data[...] = np.exp(-np.sqrt(data))
def compute(args):
from hysop import Field, Box, \
@@ -15,15 +15,16 @@ def compute(args):
from hysop.constants import Implementation, ComputeGranularity
from hysop.operator.directional.diffusion_dir import DirectionalDiffusion
+ from hysop.operator.diffusion import Diffusion
from hysop.methods import StrangOrder, TimeIntegrator, SpaceDiscretization
from hysop.numerics.splitting.strang import StrangSplitting
-
+
# Define domain
dim = args.ndim
npts = args.npts
box = Box(origin=args.box_origin, length=args.box_length, dim=dim)
-
+
# Get default MPI Parameters from domain (even for serial jobs)
mpi_params = MPIParams(comm=box.task_comm,
task_id=box.current_task())
@@ -32,57 +33,69 @@ def compute(args):
dt = ScalarParameter('dt', dtype=args.dtype)
nu = ScalarParameter('nu', initial_value=args.nu, const=True, dtype=args.dtype)
scalar = Field(domain=box, name='S0', nb_components=1, dtype=args.dtype)
-
+
# Diffusion operator discretization parameters
- method = {
+ method = {
ComputeGranularity: args.compute_granularity,
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
}
-
+
# Setup implementation specific variables
impl = args.impl
extra_op_kwds = { 'mpi_params': mpi_params }
- if (impl is Implementation.PYTHON):
- pass
+
+ # Create the problem we want to solve and insert our
+ # directional splitting subgraph.
+ # Add a writer of input field at given frequency.
+ problem = Problem(method=method, mpi_params=mpi_params)
+
+ if (impl is Implementation.FORTRAN):
+ # Build the directional diffusion operator
+ diffusion = Diffusion(implementation=impl,
+ name='diffusion', dt=dt,
+ Fin=scalar, nu=nu,
+ variables = {scalar: npts},
+ **extra_op_kwds)
+ problem.insert(diffusion)
elif (impl is Implementation.OPENCL):
# For the OpenCL implementation we need to setup the compute device
# and configure how the code is generated and compiled at runtime.
-
+
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params, platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
-
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
+
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
method[OpenClKernelConfig] = args.opencl_kernel_config
-
+
# Setup opencl specific extra operator keyword arguments
extra_op_kwds['cl_env'] = cl_env
+
+ # Build the directional diffusion operator
+ diffusion = DirectionalDiffusion(implementation=impl,
+ name='diffusion', dt=dt,
+ fields=scalar, coeffs=nu,
+ variables = {scalar: npts},
+ **extra_op_kwds)
+
+ # Build the directional splitting operator graph
+ splitting = StrangSplitting(splitting_dim=dim, order=args.strang_order)
+ splitting.push_operators(diffusion)
+
+ problem.insert(splitting)
else:
msg='Unknown implementation \'{}\'.'.format(impl)
raise ValueError(msg)
- # Build the directional diffusion operator
- diffusion = DirectionalDiffusion(implementation=impl,
- name='diffusion', dt=dt,
- fields=scalar, coeffs=nu,
- variables = {scalar: npts},
- **extra_op_kwds)
-
- # Build the directional splitting operator graph
- splitting = StrangSplitting(splitting_dim=dim, order=args.strang_order)
- splitting.push_operators(diffusion)
-
- # Create the problem we want to solve and insert our
- # directional splitting subgraph.
- # Add a writer of input field at given frequency.
- problem = Problem(method=method)
- problem.insert(splitting)
- problem.dump_inputs(fields=scalar, filename='S0', frequency=args.dump_freq, **extra_op_kwds)
+ io_params = args.io_params.clone(filename='field')
+ problem.dump_inputs(fields=scalar, io_params=io_params, **extra_op_kwds)
problem.build(args)
-
+
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
@@ -90,23 +103,25 @@ def compute(args):
# Initialize discrete scalar field
problem.initialize_field(scalar, formula=init_scalar)
-
- # Create a simulation and solve the problem
+
+ # Create a simulation and solve the problem
# (do not forget to specify the dt parameter here)
- simu = Simulation(start=args.tstart, end=args.tend,
+ simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter, max_iter=args.max_iter,
- times_of_interest=args.dump_times,
+ times_of_interest=args.times_of_interest,
dt=dt, dt0=args.dt)
-
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
-
+
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ScalarDiffusionArgParser(HysopArgParser):
def __init__(self):
@@ -117,7 +132,7 @@ if __name__=='__main__':
description+='Diffuse a scalar with a given diffusion coefficient. '
description+='\n\nThe diffusion operator is directionally splitted resulting '
description+='in the use of one or more diffusion operators per direction.'
-
+
super(ScalarDiffusionArgParser, self).__init__(
prog_name=prog_name,
description=description,
@@ -136,8 +151,8 @@ if __name__=='__main__':
parser = ScalarDiffusionArgParser()
- parser.set_defaults(box_origin=(0.0,), box_length=(1.0,),
- tstart=0.0, tend=1.0, nb_iter=500,
+ parser.set_defaults(box_origin=(0.0,), box_length=(1.0,),
+ tstart=0.0, tend=1.0, nb_iter=500,
dump_freq=5, nu=0.01, impl='cl')
parser.run(compute)
diff --git a/examples/sediment_deposit/C_IN.DAT b/hysop_examples/examples/sediment_deposit/C_IN.DAT
similarity index 100%
rename from examples/sediment_deposit/C_IN.DAT
rename to hysop_examples/examples/sediment_deposit/C_IN.DAT
diff --git a/examples/sediment_deposit/init.f90 b/hysop_examples/examples/sediment_deposit/init.f90
similarity index 100%
rename from examples/sediment_deposit/init.f90
rename to hysop_examples/examples/sediment_deposit/init.f90
diff --git a/examples/sediment_deposit/sediment_deposit.py b/hysop_examples/examples/sediment_deposit/sediment_deposit.py
similarity index 95%
rename from examples/sediment_deposit/sediment_deposit.py
rename to hysop_examples/examples/sediment_deposit/sediment_deposit.py
index c8a3c880d15cdbeb666405c54d00281389b7199b..84c05dbbbfca0d1f715e54cd6494e3088733b17d 100644
--- a/examples/sediment_deposit/sediment_deposit.py
+++ b/hysop_examples/examples/sediment_deposit/sediment_deposit.py
@@ -156,10 +156,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -291,7 +292,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
@@ -307,14 +307,14 @@ def compute(args):
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
- problem.display()
+ problem.display(args.visu_rank)
# Create a simulation
# (do not forget to specify the t and dt parameters here)
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
@@ -326,15 +326,18 @@ def compute(args):
problem.initialize_field(field=S, formula=init_sediment,
nblobs=nblobs, rblob=rblob, without_ghosts=True)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ParticleAboveSaltArgParser(HysopArgParser):
def __init__(self):
@@ -354,6 +357,7 @@ if __name__=='__main__':
default_dump_dir=default_dump_dir)
def _setup_parameters(self, args):
+ super(ParticleAboveSaltArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/sediment_deposit/sediment_deposit_levelset.py b/hysop_examples/examples/sediment_deposit/sediment_deposit_levelset.py
similarity index 95%
rename from examples/sediment_deposit/sediment_deposit_levelset.py
rename to hysop_examples/examples/sediment_deposit/sediment_deposit_levelset.py
index 2aadf45faf24f4848145d101d9acd78aba28e65e..4d2f5bf568c1700efb0c9b32732b767d21c4bdca 100644
--- a/examples/sediment_deposit/sediment_deposit_levelset.py
+++ b/hysop_examples/examples/sediment_deposit/sediment_deposit_levelset.py
@@ -25,11 +25,9 @@ def init_velocity(data, coords, component=None):
for d in data:
d[...] = 0.0
-def init_phi(data, coords, nblobs, rblob):
+def init_phi(data, coords, nblobs, rblob, component):
from hysop import vprint
- data = data[0]
- coords = coords[0]
- X, Y = coords
+ X, Y = coords[0], coords[1]
Bx = np.random.rand(nblobs)
By = TANK_RATIO*np.random.rand(nblobs)
R2 = rblob * rblob
@@ -175,10 +173,11 @@ def compute(args):
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -354,7 +353,6 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
@@ -370,14 +368,14 @@ def compute(args):
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
- problem.display()
+ problem.display(args.visu_rank)
# Create a simulation
# (do not forget to specify the t and dt parameters here)
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt_cfl, dt_advec, dt,
min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
@@ -389,15 +387,18 @@ def compute(args):
problem.initialize_field(field=phi, formula=init_phi, nblobs=nblobs, rblob=rblob,
without_ghosts=BLOB_INIT)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run)
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ParticleAboveSaltArgParser(HysopArgParser):
def __init__(self):
@@ -418,6 +419,7 @@ if __name__=='__main__':
default_dump_dir=default_dump_dir)
def _setup_parameters(self, args):
+ super(ParticleAboveSaltArgParser, self)._setup_parameters(args)
dim = args.ndim
if (dim not in (2,3)):
msg='Domain should be 2D or 3D.'
diff --git a/examples/shear_layer/shear_layer.py b/hysop_examples/examples/shear_layer/shear_layer.py
similarity index 78%
rename from examples/shear_layer/shear_layer.py
rename to hysop_examples/examples/shear_layer/shear_layer.py
index 210494ba3d9296911d325324eebc629cc78d7c13..05bbe3f7c68bce6009cd3fa69975618107e557cf 100644
--- a/examples/shear_layer/shear_layer.py
+++ b/hysop_examples/examples/shear_layer/shear_layer.py
@@ -13,7 +13,7 @@ def compute(args):
TimeParameters, ViscosityParameter
from hysop.constants import Implementation, AdvectionCriteria
- from hysop.operators import DirectionalAdvection, DirectionalDiffusion, \
+ from hysop.operators import DirectionalAdvection, Advection, \
PoissonCurl, AdaptiveTimeStep, \
MinMaxFieldStatistics, StrangSplitting
@@ -34,17 +34,18 @@ def compute(args):
# Setup usual implementation specific variables
impl = args.impl
extra_op_kwds = { 'mpi_params': mpi_params }
- if (impl is Implementation.PYTHON):
+ if (impl is Implementation.PYTHON) or (impl is Implementation.FORTRAN):
method = {}
elif (impl is Implementation.OPENCL):
# For the OpenCL implementation we need to setup the compute device
# and configure how the code is generated and compiled at runtime.
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
@@ -68,11 +69,22 @@ def compute(args):
u = sm.tanh(rho*(0.25-sm.sqrt((y-0.5)*(y-0.5))))
v = delta*sm.sin(2*sm.pi*x)
w = v.diff(x) - u.diff(y)
+ U0 = sm.utilities.lambdify((x,y), u)
+ U1 = sm.utilities.lambdify((x,y), v)
W0 = sm.utilities.lambdify((x,y), w)
- def init_vorticity(data, coords):
- data[0][...] = W0(*coords[0])
- data[0][np.isnan(data[0])] = 0.0
+ def init_velocity(data, coords, component):
+ if (component == 0):
+ data[...] = U0(*coords)
+ elif (component == 1):
+ data[...] = U1(*coords)
+ else:
+ raise NotImplementedError(component)
+
+ def init_vorticity(data, coords, component):
+ assert (component==0)
+ data[...] = W0(*coords)
+ data[np.isnan(data)] = 0.0
# Define parameters and field (time, timestep, viscosity, velocity, vorticity)
t, dt = TimeParameters(dtype=args.dtype)
@@ -81,17 +93,28 @@ def compute(args):
nu = ViscosityParameter(initial_value=args.nu, const=True, dtype=args.dtype)
### Build the directional operators
- #> Directional advection
- advec = DirectionalAdvection(implementation=impl,
- name='advection_remesh',
- velocity = velo,
- advected_fields = (vorti,),
- velocity_cfl = args.cfl,
- variables = {velo: npts, vorti: npts},
- dt=dt, **extra_op_kwds)
- #> Directional splitting operator subgraph
- splitting = StrangSplitting(splitting_dim=dim, order=args.strang_order)
- splitting.push_operators(advec)
+ if (impl is Implementation.FORTRAN) and (dim==3):
+ #> Nd advection
+ advec = Advection(implementation=impl,
+ name='advec',
+ velocity = velo,
+ advected_fields = (vorti,),
+ velocity_cfl = args.cfl,
+ variables = {velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ else:
+ #> Directional advection
+ impl_advec = Implementation.PYTHON if (impl is Implementation.FORTRAN) else impl
+ advec_dir = DirectionalAdvection(implementation=impl_advec,
+ name='advection_remesh',
+ velocity = velo,
+ advected_fields = (vorti,),
+ velocity_cfl = args.cfl,
+ variables = {velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Directional splitting operator subgraph
+ advec = StrangSplitting(splitting_dim=dim, order=args.strang_order)
+ advec.push_operators(advec_dir)
### Build standard operators
@@ -101,11 +124,20 @@ def compute(args):
variables={velo:npts, vorti: npts},
projection=args.reprojection_frequency,
diffusion=nu, dt=dt,
- implementation=impl, **extra_op_kwds)
+ implementation=impl,
+ enforce_implementation=args.enforce_implementation,
+ **extra_op_kwds)
#> We ask to dump the inputs and the outputs of this operator
- poisson.dump_outputs(fields=(vorti,), frequency=args.dump_freq, **extra_op_kwds)
- poisson.dump_outputs(fields=(velo,), frequency=args.dump_freq, **extra_op_kwds)
+ poisson.dump_outputs(fields=(vorti,),
+ io_params=args.io_params.clone(filename='vorti'),
+ **extra_op_kwds)
+ poisson.dump_outputs(fields=(velo,),
+ io_params=args.io_params.clone(filename='velo'),
+ **extra_op_kwds)
+
#> Operator to compute the infinite norm of the velocity
+ if (impl is Implementation.FORTRAN):
+ impl = Implementation.PYTHON
min_max_U = MinMaxFieldStatistics(name='min_max_U', field=velo,
Finf=True, implementation=impl, variables={velo:npts},
**extra_op_kwds)
@@ -130,11 +162,10 @@ def compute(args):
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
- problem.insert(poisson, splitting, min_max_U, min_max_W, adapt_dt)
+ problem.insert(poisson, advec, min_max_U, min_max_W, adapt_dt)
problem.build(args)
# If a visu_rank was provided, and show_graph was set,
@@ -147,30 +178,26 @@ def compute(args):
simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
simu.write_parameters(t, dt, filename='parameters.txt', precision=4)
# Initialize only the vorticity
+ problem.initialize_field(velo, formula=init_velocity)
problem.initialize_field(vorti, formula=init_vorticity)
- # Setup vorticity plotter if required
- if args.plot_vorticity:
- dbg = ImshowDebugger(data={'W':(dfields[vorti],0)})
- dbg.synchronize_queue(cl_env.default_queue)
- dbg.update()
- else:
- dbg=None
-
# Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run, dbg=dbg, plot_freq=args.plot_freq)
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler,
+ plot_freq=args.plot_freq)
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class ShearLayerArgParser(HysopArgParser):
def __init__(self):
@@ -188,7 +215,7 @@ if __name__=='__main__':
description+='orientation of the shear layers is made.'
description+='\n'
description+='\nEach of the shear layers rolls up in a single vortex '
- description+='as the flow evolves.'
+ description+='as the flow eolves.'
description+='\n'
description+='\nDefault example parameters depends on the chosen case:'
description+='\n CASE 0 1 2'
@@ -253,6 +280,7 @@ if __name__=='__main__':
self._check_positive(args, 'plot_freq', strict=False, allow_none=False)
def _setup_parameters(self, args):
+ super(ShearLayerArgParser, self)._setup_parameters(args)
from hysop.tools.types import first_not_None
case = args.case
diff --git a/examples/taylor_green/bench.sh b/hysop_examples/examples/taylor_green/bench.sh
similarity index 100%
rename from examples/taylor_green/bench.sh
rename to hysop_examples/examples/taylor_green/bench.sh
diff --git a/examples/taylor_green/data/reference_512_512_512.txt b/hysop_examples/examples/taylor_green/data/reference_512_512_512.txt
similarity index 100%
rename from examples/taylor_green/data/reference_512_512_512.txt
rename to hysop_examples/examples/taylor_green/data/reference_512_512_512.txt
diff --git a/examples/taylor_green/taylor_green.py b/hysop_examples/examples/taylor_green/taylor_green.py
similarity index 67%
rename from examples/taylor_green/taylor_green.py
rename to hysop_examples/examples/taylor_green/taylor_green.py
index 725e57758bb588639988581115bea7bfe9f3736c..cc51ec1ec95e91866d8803c22fa1900b32344d7b 100644
--- a/examples/taylor_green/taylor_green.py
+++ b/hysop_examples/examples/taylor_green/taylor_green.py
@@ -1,7 +1,6 @@
-
## HySoP Example: Taylor-Green 3D
-## See Van Rees 2011 (first part):
-## A comparison of vortex and pseudo-spectral methods for the simulation of
+## See Van Rees 2011 (first part):
+## A comparison of vortex and pseudo-spectral methods for the simulation of
## periodic vortical flows at high Reynolds numbers
import os
@@ -11,43 +10,38 @@ cos = np.cos
sin = np.sin
## Function to compute initial vorticity
-def init_vorticity(data, coords, component=None):
+def init_vorticity(data, coords, component):
# Ux = sin(x) * cos(y) * cos(z)
# Uy = - cos(x) * sin(y) * cos(z)
# Uz = 0
# W = rot(U)
- (x,y,z) = coords[0]
- if (component is None):
- data[0][...] = - cos(x) * sin(y) * sin(z)
- data[1][...] = - sin(x) * cos(y) * sin(z)
- data[2][...] = 2. * sin(x) * sin(y) * cos(z)
- elif (component[0] is 0):
- data[0][...] = - cos(x) * sin(y) * sin(z)
- elif (component[0] is 1):
- data[0][...] = - sin(x) * cos(y) * sin(z)
- elif (component[0] is 2):
- data[0][...] = 2. * sin(x) * sin(y) * cos(z)
+ (x,y,z) = coords
+ if (component == 0):
+ data[...] = - cos(x) * sin(y) * sin(z)
+ elif (component == 1):
+ data[...] = - sin(x) * cos(y) * sin(z)
+ elif (component == 2):
+ data[...] = 2. * sin(x) * sin(y) * cos(z)
else:
raise NotImplementedError(component)
# initial enstrophy is 6*pi^3
# initial volume averaged enstrophy: 6*pi^3 / (2*pi)^3 = 0.75
def compute(args):
- from hysop import Box, Simulation, Problem, MPIParams, IO, IOParams
+ from hysop import Box, Simulation, Problem, MPIParams, IO, IOParams, main_rank
from hysop.defaults import VelocityField, VorticityField, \
EnstrophyParameter, TimeParameters, \
ViscosityParameter
- from hysop.constants import Implementation, AdvectionCriteria, StretchingCriteria
+ from hysop.constants import Implementation, AdvectionCriteria, StretchingCriteria, Backend
- from hysop.operators import DirectionalAdvection, DirectionalStretchingDiffusion, \
- DirectionalDiffusion, DirectionalStretching, \
+ from hysop.operators import DirectionalAdvection, DirectionalStretching, \
StaticDirectionalStretching, Diffusion, \
- PoissonCurl, AdaptiveTimeStep, \
+ PoissonCurl, AdaptiveTimeStep, HDF_Writer, \
Enstrophy, MinMaxFieldStatistics, StrangSplitting, \
ParameterPlotter, Advection, MinMaxGradientStatistics
- from hysop.methods import SpaceDiscretization, Remesh, TimeIntegrator, \
- ComputeGranularity, Interpolation
+ from hysop.methods import SpaceDiscretization, Remesh, TimeIntegrator, Interpolation
+
## IO paths
spectral_path = IO.default_path() + '/spectral'
@@ -55,59 +49,62 @@ def compute(args):
dim = args.ndim
npts = args.npts
box = Box(origin=args.box_origin, length=args.box_length, dim=dim)
-
+
# Get default MPI Parameters from domain (even for serial jobs)
mpi_params = MPIParams(comm=box.task_comm,
task_id=box.current_task())
-
+
# Setup usual implementation specific variables
impl = args.impl
extra_op_kwds = {'mpi_params': mpi_params}
if (impl in (Implementation.PYTHON, Implementation.FORTRAN)):
+ backend = Backend.HOST
method = {}
elif (impl is Implementation.OPENCL):
# For the OpenCL implementation we need to setup the compute device
# and configure how the code is generated and compiled at runtime.
-
+
# Create an explicit OpenCL context from user parameters
- from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env
- cl_env = get_or_create_opencl_env(mpi_params=mpi_params,
- platform_id=args.cl_platform_id,
- device_id=args.cl_device_id)
-
+ from hysop.backend.device.opencl.opencl_tools import get_or_create_opencl_env, get_device_number
+ cl_env = get_or_create_opencl_env(
+ mpi_params=mpi_params,
+ platform_id=args.cl_platform_id,
+ device_id=box.machine_rank%get_device_number() if args.cl_device_id is None else None)
+
# Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
from hysop.methods import OpenClKernelConfig
method = { OpenClKernelConfig: args.opencl_kernel_config }
-
+
# Setup opencl specific extra operator keyword arguments
extra_op_kwds['cl_env'] = cl_env
+ backend = Backend.OPENCL
else:
msg='Unknown implementation \'{}\'.'.format(impl)
raise ValueError(msg)
-
+
# Define parameters and field (time, timestep, velocity, vorticity, enstrophy)
t, dt = TimeParameters(dtype=args.dtype)
velo = VelocityField(domain=box, dtype=args.dtype)
vorti = VorticityField(velocity=velo)
enstrophy = EnstrophyParameter(dtype=args.dtype)
viscosity = ViscosityParameter(dtype=args.dtype, initial_value=(1.0/args.Re), const=True)
-
+
### Build the directional operators
if (impl is Implementation.FORTRAN):
advec = Advection(implementation=impl,
name='advec',
- velocity = velo,
+ velocity = velo,
advected_fields = (vorti,),
velocity_cfl = args.cfl,
variables = {velo: npts, vorti: npts},
dt=dt, **extra_op_kwds)
advec_dir = None
else:
- #> Directional advection
+ #> Directional advection
advec=None
advec_dir = DirectionalAdvection(implementation=impl,
name='advec',
- velocity = velo,
+ velocity = velo,
advected_fields = (vorti,),
velocity_cfl = args.cfl,
variables = {velo: npts, vorti: npts},
@@ -117,7 +114,7 @@ def compute(args):
stretch_dir = StaticDirectionalStretching(implementation=Implementation.PYTHON,
name='stretch',
formulation = args.stretching_formulation,
- velocity = velo,
+ velocity = velo,
vorticity = vorti,
variables = {velo: npts, vorti: npts},
dt=dt, **extra_op_kwds)
@@ -125,64 +122,73 @@ def compute(args):
stretch_dir = DirectionalStretching(implementation=impl,
name='stretch',
formulation = args.stretching_formulation,
- velocity = velo,
+ velocity = velo,
vorticity = vorti,
variables = {velo: npts, vorti: npts},
dt=dt, **extra_op_kwds)
-
+
### Build standard operators
#> Poisson operator to recover the velocity from the vorticity
- poisson = PoissonCurl(name='poisson', velocity=velo, vorticity=vorti,
- variables={velo:npts, vorti: npts},
+ poisson = PoissonCurl(name='poisson', velocity=velo, vorticity=vorti,
+ variables={velo:npts, vorti: npts},
projection=args.reprojection_frequency,
diffusion=viscosity, dt=dt,
- dump_energy=IOParams(filepath=spectral_path, filename='E_{fname}.txt', frequency=args.dump_freq),
- plot_energy=IOParams(filepath=spectral_path, filename='E_{fname}_{ite}', frequency=args.dump_freq),
- plot_input_vorticity_energy=-1, # <= disable a specific plot
- plot_output_vorticity_energy=-1, # <= disable a specific plot
+ # dump_energy=IOParams(filepath=spectral_path, filename='E_{fname}.txt', frequency=args.dump_freq),
+ # plot_energy=IOParams(filepath=spectral_path, filename='E_{fname}_{ite}', frequency=args.dump_freq),
+ # plot_input_vorticity_energy=-1, # <= disable a specific plot
+ # plot_output_vorticity_energy=-1, # <= disable a specific plot
+ enforce_implementation=args.enforce_implementation,
implementation=impl, **extra_op_kwds)
#> We ask to dump the outputs of this operator
- poisson.dump_outputs(fields=(vorti,), frequency=args.dump_freq, **extra_op_kwds)
- poisson.dump_outputs(fields=(velo,), frequency=args.dump_freq, **extra_op_kwds)
-
+ dump_fields = HDF_Writer(name='fields',
+ io_params=args.io_params.clone(filename='fields'),
+ force_backend=backend,
+ variables={velo: npts, vorti: npts}, **extra_op_kwds)
+
#> Operator to compute the infinite norm of the velocity
if (impl is Implementation.FORTRAN):
impl = Implementation.PYTHON
- min_max_U = MinMaxFieldStatistics(name='min_max_U', field=velo,
- Finf=True, implementation=impl, variables={velo:npts},
- **extra_op_kwds)
- min_max_gradU = MinMaxGradientStatistics(F=velo,
- Finf=True, implementation=impl, variables={velo:npts},
- **extra_op_kwds)
- #> Operator to compute the infinite norm of the vorticity
- min_max_W = MinMaxFieldStatistics(name='min_max_W', field=vorti,
- Finf=True, implementation=impl, variables={vorti:npts},
- **extra_op_kwds)
+ if args.variable_timestep:
+ min_max_U = MinMaxFieldStatistics(name='min_max_U', field=velo,
+ Finf=True, implementation=impl, variables={velo:npts},
+ **extra_op_kwds)
+ min_max_gradU = MinMaxGradientStatistics(F=velo,
+ Finf=True, implementation=impl, variables={velo:npts},
+ **extra_op_kwds)
+ #> Operator to compute the infinite norm of the vorticity
+ min_max_W = MinMaxFieldStatistics(name='min_max_W', field=vorti,
+ Finf=True, implementation=impl, variables={vorti:npts},
+ **extra_op_kwds)
+ else:
+ min_max_U = min_max_gradU = min_max_W = None
#> Operator to compute the enstrophy
enstrophy_op = Enstrophy(name='enstrophy', vorticity=vorti, enstrophy=enstrophy,
variables={vorti:npts}, implementation=impl, **extra_op_kwds)
-
+
#> Directional splitting operator subgraph
splitting = StrangSplitting(splitting_dim=dim, order=args.strang_order)
splitting.push_operators(advec_dir, stretch_dir, min_max_gradU)
### Adaptive timestep operator
- adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True)
- dt_cfl = adapt_dt.push_cfl_criteria(cfl=args.cfl,
- Fmin=min_max_U.Fmin,
- Fmax=min_max_U.Fmax,
- equivalent_CFL=True)
- dt_stretch = adapt_dt.push_stretching_criteria(gradFinf=min_max_gradU.Finf,
- criteria=StretchingCriteria.GRAD_U)
- dt_lcfl0 = adapt_dt.push_advection_criteria(lcfl=args.lcfl, Finf=min_max_W.Finf,
- criteria=AdvectionCriteria.W_INF, name='LCFL0')
- dt_lcfl1 = adapt_dt.push_advection_criteria(lcfl=args.lcfl, gradFinf=min_max_gradU.Finf,
- criteria=AdvectionCriteria.GRAD_U, name='LCFL1')
- dt_lcfl2 = adapt_dt.push_advection_criteria(lcfl=args.lcfl, gradFinf=min_max_gradU.Finf,
- criteria=AdvectionCriteria.DEFORMATION, name='LCFL2')
-
- #> Custom operator to plot enstrophy
- if args.plot_enstrophy:
+ if args.variable_timestep:
+ adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True)
+ dt_cfl = adapt_dt.push_cfl_criteria(cfl=args.cfl, dtype=dt.dtype,
+ Fmin=min_max_U.Fmin,
+ Fmax=min_max_U.Fmax,
+ equivalent_CFL=True)
+ dt_stretch = adapt_dt.push_stretching_criteria(gradFinf=min_max_gradU.Finf,
+ criteria=StretchingCriteria.GRAD_U, dtype=dt.dtype)
+ dt_lcfl0 = adapt_dt.push_advection_criteria(lcfl=args.lcfl, Finf=min_max_W.Finf,
+ criteria=AdvectionCriteria.W_INF, name='LCFL0', dtype=dt.dtype)
+ dt_lcfl1 = adapt_dt.push_advection_criteria(lcfl=args.lcfl, gradFinf=min_max_gradU.Finf,
+ criteria=AdvectionCriteria.GRAD_U, name='LCFL1', dtype=dt.dtype)
+ dt_lcfl2 = adapt_dt.push_advection_criteria(lcfl=args.lcfl, gradFinf=min_max_gradU.Finf,
+ criteria=AdvectionCriteria.DEFORMATION, name='LCFL2', dtype=dt.dtype)
+ else:
+ adapt_dt = None
+
+ #> Custom operator to plot enstrophy
+ if args.plot_enstrophy and (main_rank == args.visu_rank):
class EnstrophyPlotter(ParameterPlotter):
"""Custom plotting operator for enstrophy."""
def __init__(self, **kwds):
@@ -194,17 +200,20 @@ def compute(args):
tag='hysop-{}'.format(snpts)
fig = plt.figure(figsize=(30,18))
axe0 = plt.subplot2grid((3,2), (0,0), rowspan=3, colspan=1)
- axe1 = plt.subplot2grid((3,2), (0,1), rowspan=2, colspan=1)
- axe2 = plt.subplot2grid((3,2), (2,1), rowspan=1, colspan=1)
+ axe1 = plt.subplot2grid((3,2), (0,1), rowspan=2+args.fixed_timestep, colspan=1)
+ axe2 = plt.subplot2grid((3,2), (2,1), rowspan=1, colspan=1) if args.variable_timestep else None
axes = (axe0, axe1, axe2)
- parameters={axe0:{tag:enstrophy},
- axe1:{dt_lcfl0.name: dt_lcfl0,
- dt_lcfl1.name: dt_lcfl1,
- dt_lcfl2.name: dt_lcfl2,
- dt_cfl.name: dt_cfl,
- dt_stretch.name: dt_stretch},
- #dt.name: dt},
- axe2:{'CFL*': adapt_dt.equivalent_CFL }}
+ parameters={axe0:{tag:enstrophy}}
+ if args.variable_timestep:
+ parameters[axe1] = {dt_lcfl0.name: dt_lcfl0,
+ dt_lcfl1.name: dt_lcfl1,
+ dt_lcfl2.name: dt_lcfl2,
+ dt_cfl.name: dt_cfl,
+ dt_stretch.name: dt_stretch}
+ parameters[axe2] = {'CFL*': adapt_dt.equivalent_CFL }
+ else:
+ parameters[axe1] = {dt.name: dt}
+
super(EnstrophyPlotter, self).__init__(name='enstrophy_dt',
parameters=parameters, fig=fig, axes=axes, **kwds)
config='{} {} FD{} PROJECTION_{} {}'.format(
@@ -225,7 +234,7 @@ def compute(args):
for d in (512,):
reference=os.path.join(datadir, 'reference_{d}_{d}_{d}.txt'.format(d=d))
data = np.loadtxt(reference, usecols=(0,2), dtype=np.float32)
- axe0.plot(data[:,0], data[:,1]*2, '--',
+ axe0.plot(data[:,0], data[:,1]*2, '--',
linewidth=1.0,
label='J.DeBonis-$512^3$')
axe0.legend()
@@ -236,80 +245,73 @@ def compute(args):
axe1.set_ylim(1e-4, 1e0)
axe1.set_yscale('log')
axe1.legend()
- axe2.set_title('Equivalent CFL')
- axe2.set_xlabel('Non-dimensional time', fontweight='bold')
- axe2.set_ylabel('CFL*', fontweight='bold')
- axe2.set_xlim(args.tstart, args.tend)
- axe2.axhline(y=args.cfl, color='r', linestyle='--')
- axe2.set_ylim(0., 1.1*args.cfl)
+ if axe2:
+ axe2.set_title('Equivalent CFL')
+ axe2.set_xlabel('Non-dimensional time', fontweight='bold')
+ axe2.set_ylabel('CFL*', fontweight='bold')
+ axe2.set_xlim(args.tstart, args.tend)
+ axe2.axhline(y=args.cfl, color='r', linestyle='--')
+ axe2.set_ylim(0., 1.1*args.cfl)
plot = EnstrophyPlotter(update_frequency=args.plot_freq,
visu_rank=args.visu_rank)
else:
plot = None
-
-
- ## Create the problem we want to solve and insert our
+
+
+ ## Create the problem we want to solve and insert our
# directional splitting subgraph and the standard operators.
# The method dictionnary passed to this graph will be dispatched
# accross all operators contained in the graph.
method.update(
- {
- ComputeGranularity: args.compute_granularity,
+ {
SpaceDiscretization: args.fd_order,
TimeIntegrator: args.time_integrator,
Remesh: args.remesh_kernel,
- Interpolation: args.interpolation
}
)
problem = Problem(method=method)
problem.insert(poisson, advec, splitting,
- min_max_U, min_max_W, enstrophy_op,
- adapt_dt, plot)
+ min_max_U, min_max_W, enstrophy_op,
+ adapt_dt, dump_fields, plot)
problem.build(args)
# If a visu_rank was provided, and show_graph was set,
# display the graph on the given process rank.
if args.display_graph:
problem.display(args.visu_rank)
-
+
# Create a simulation
# (do not forget to specify the t and dt parameters here)
- simu = Simulation(start=args.tstart, end=args.tend,
+ simu = Simulation(start=args.tstart, end=args.tend,
nb_iter=args.nb_iter,
max_iter=args.max_iter,
- dt0=args.dt, times_of_interest=args.dump_times,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
t=t, dt=dt)
- simu.write_parameters(t, dt_cfl, dt_stretch, dt_lcfl0, dt_lcfl1, dt_lcfl2, dt, enstrophy,
- min_max_U.Finf, min_max_W.Finf, min_max_gradU.Finf, adapt_dt.equivalent_CFL,
- filename='parameters.txt', precision=8)
-
- # Attach a field debug dumper if requested
- from hysop.tools.debug_dumper import DebugDumper
- if args.debug_dump_target:
- debug_dumper = DebugDumper(
- path=args.debug_dump_dir,
- name=args.debug_dump_target,
- force_overwrite=True, enable_on_op_apply=True)
- else:
- debug_dumper = None
-
+ params = (t, dt, enstrophy,)
+ if args.variable_timestep:
+ params += (dt_cfl, dt_stretch, dt_lcfl0, dt_lcfl1, dt_lcfl2,
+ min_max_U.Finf, min_max_W.Finf, min_max_gradU.Finf, adapt_dt.equivalent_CFL)
+ simu.write_parameters(*params, filename='parameters.txt', precision=8)
+
# Initialize only the vorticity
problem.initialize_field(vorti, formula=init_vorticity)
- # Finally solve the problem
- problem.solve(simu, dry_run=args.dry_run, debug_dumper=debug_dumper)
-
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
# Finalize
problem.finalize()
if __name__=='__main__':
- from examples.example_utils import HysopArgParser, colors
+ from hysop_examples.example_utils import HysopArgParser, colors
class TaylorGreenArgParser(HysopArgParser):
def __init__(self):
prog_name = 'taylor_green'
- default_dump_dir = '{}/hysop_examples/{}'.format(HysopArgParser.tmp_dir(),
+ default_dump_dir = '{}/hysop_examples/{}'.format(HysopArgParser.tmp_dir(),
prog_name)
description=colors.color('HySoP Taylor-Green Example: ', fg='blue', style='bold')
@@ -324,7 +326,7 @@ if __name__=='__main__':
description+='\n'
description+='\nSee the original paper at '
description+='http://vanreeslab.com/wp-content/papercite-data/pdf/rees-2011.pdf.'
-
+
super(TaylorGreenArgParser, self).__init__(
prog_name=prog_name,
description=description,
@@ -341,7 +343,7 @@ if __name__=='__main__':
super(TaylorGreenArgParser, self)._check_main_args(args)
self._check_default(args, 'Re', float, allow_none=False)
self._check_positive(args, 'Re', strict=True, allow_none=False)
-
+
def _add_graphical_io_args(self):
graphical_io = super(TaylorGreenArgParser, self)._add_graphical_io_args()
graphical_io.add_argument('-pe', '--plot-enstrophy', action='store_true',
@@ -349,17 +351,18 @@ if __name__=='__main__':
help=('Plot the enstrophy component during simulation. '+
'Simulation will stop at each time of interest and '+
'the plot will be updated every specified freq iterations.'))
- graphical_io.add_argument('-pf', '--plot-freq', type=int, default=10,
+ graphical_io.add_argument('-pf', '--plot-freq', type=int, default=10,
dest='plot_freq',
help='Plotting update frequency in terms of iterations.')
-
+
def _check_file_io_args(self, args):
super(TaylorGreenArgParser, self)._check_file_io_args(args)
self._check_default(args, 'plot_enstrophy', bool, allow_none=False)
self._check_default(args, 'plot_freq', int, allow_none=False)
self._check_positive(args, 'plot_freq', strict=True, allow_none=False)
-
+
def _setup_parameters(self, args):
+ super(TaylorGreenArgParser, self)._setup_parameters(args)
if (args.ndim != 3):
msg='This example only works for 3D domains.'
self.error(msg)
@@ -367,9 +370,9 @@ if __name__=='__main__':
parser = TaylorGreenArgParser()
parser.set_defaults(impl='cl', ndim=3, npts=(64,),
- box_origin=(0.0,), box_length=(2*pi,),
- tstart=0.0, tend=20.01,
- dt=1e-5,
+ box_origin=(0.0,), box_length=(2*pi,),
+ tstart=0.0, tend=20.01,
+ dt=1e-5,
cfl=0.5, lcfl=0.125,
dump_freq=100, dump_times=(),
Re=1600.0)
diff --git a/hysop_examples/examples/taylor_green/taylor_green_cpuFortran.py b/hysop_examples/examples/taylor_green/taylor_green_cpuFortran.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fe7bb438c235b45244d9d3d05e0f676c4a70e19
--- /dev/null
+++ b/hysop_examples/examples/taylor_green/taylor_green_cpuFortran.py
@@ -0,0 +1,298 @@
+## HySoP Example: Taylor-Green 3D
+## See Van Rees 2011 (first part):
+## A comparison of vortex and pseudo-spectral methods for the simulation of
+## periodic vortical flows at high Reynolds numbers
+
+import os
+import numpy as np
+pi = np.pi
+cos = np.cos
+sin = np.sin
+
+## Function to compute initial vorticity
+def init_vorticity(data, coords):
+ # Ux = sin(x) * cos(y) * cos(z)
+ # Uy = - cos(x) * sin(y) * cos(z)
+ # Uz = 0
+ # W = rot(U)
+ (x,y,z) = coords
+ data[0][...] = - cos(x) * sin(y) * sin(z)
+ data[1][...] = - sin(x) * cos(y) * sin(z)
+ data[2][...] = 2. * sin(x) * sin(y) * cos(z)
+ # initial enstrophy is 6*pi^3
+ # initial volume averaged enstrophy: 6*pi^3 / (2*pi)^3 = 0.75
+
+
+def compute(args):
+ from hysop import Box, Simulation, Problem, MPIParams, Field
+ from hysop.defaults import VelocityField, VorticityField, \
+ EnstrophyParameter, TimeParameters
+ from hysop.constants import Implementation, AdvectionCriteria, HYSOP_REAL, \
+ StretchingFormulation
+ from hysop.operators import Advection, StaticDirectionalStretching, Diffusion, \
+ PoissonRotational, AdaptiveTimeStep, \
+ Enstrophy, MinMaxFieldStatistics, StrangSplitting, \
+ ParameterPlotter
+ from hysop.numerics.odesolvers.runge_kutta import RK2
+ from hysop.topology.cartesian_topology import CartesianTopology
+ from hysop.tools.parameters import Discretization
+ from hysop.methods import SpaceDiscretization, Remesh, TimeIntegrator, \
+ ComputeGranularity, Interpolation, StrangOrder
+ # Define the domain
+ dim = args.ndim
+ npts = args.npts
+ box = Box(origin=args.box_origin, length=args.box_length, dim=dim)
+
+ # Get default MPI Parameters from domain (even for serial jobs)
+ mpi_params = MPIParams(comm=box.task_comm,
+ task_id=box.current_task())
+
+ # Setup usual implementation specific variables
+ impl = args.impl
+ extra_op_kwds = {'mpi_params': mpi_params}
+ method = {}
+
+ # Define parameters and field (time, timestep, velocity, vorticity, enstrophy)
+ t, dt = TimeParameters(dtype=HYSOP_REAL)
+ velo = VelocityField(domain=box, dtype=HYSOP_REAL)
+ vorti = VorticityField(domain=box, dtype=HYSOP_REAL)
+ enstrophy = EnstrophyParameter(dtype=HYSOP_REAL)
+ wdotw = Field(domain=box, dtype=HYSOP_REAL, is_vector=False, name="WdotW")
+
+ # Topologies
+ topo_nogh = CartesianTopology(domain=box,
+ discretization=Discretization(npts),
+ mpi_params=mpi_params,
+ cutdirs=[False, False, True])
+
+
+ ### Build the directional operators
+ #> Directional advection
+ advec = Advection(implementation=Implementation.FORTRAN,
+ name='advec',
+ velocity = velo,
+ advected_fields = (vorti,),
+ variables = {velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Directional stretching
+ stretch = StaticDirectionalStretching(implementation=impl,
+ name='stretch',
+ formulation = args.stretching_formulation,
+ velocity = velo,
+ vorticity = vorti,
+ variables = {velo: npts, vorti: npts},
+ dt=dt, **extra_op_kwds)
+ #> Directional splitting operator subgraph
+ splitting = StrangSplitting(splitting_dim=dim, order=args.strang_order)
+ splitting.push_operators(stretch)
+ #> Diffusion
+ diffuse = Diffusion(implementation=Implementation.FORTRAN,
+ name='diffuse',
+ viscosity = (1.0/args.Re),
+ input_field = vorti,
+ variables = {vorti: topo_nogh},
+ dt=dt, **extra_op_kwds)
+ ### Build standard operators
+ #> Poisson operator to recover the velocity from the vorticity
+ poisson = PoissonRotational(name='poisson', velocity=velo, vorticity=vorti,
+ variables={velo:topo_nogh, vorti: topo_nogh},
+ projection=args.reprojection_frequency,
+ implementation=Implementation.FORTRAN, **extra_op_kwds)
+ #> We ask to dump the outputs of this operator
+ poisson.dump_outputs(fields=(vorti,), frequency=args.dump_freq)
+ poisson.dump_outputs(fields=(velo,), frequency=args.dump_freq)
+
+ #> Operator to compute the infinite norm of the velocity
+ min_max_U = MinMaxFieldStatistics(name='min_max_U', field=velo,
+ Finf=True, implementation=impl, variables={velo:npts},
+ **extra_op_kwds)
+ #> Operator to compute the infinite norm of the vorticity
+ min_max_W = MinMaxFieldStatistics(name='min_max_W', field=vorti,
+ Finf=True, implementation=impl, variables={vorti:npts},
+ **extra_op_kwds)
+ #> Operator to compute the enstrophy
+ enstrophy_op = Enstrophy(name='enstrophy', vorticity=vorti, enstrophy=enstrophy,
+ variables={vorti:topo_nogh,wdotw:topo_nogh}, implementation=impl, **extra_op_kwds)
+
+ ### Adaptive timestep operator
+ adapt_dt = AdaptiveTimeStep(dt, equivalent_CFL=True)
+ dt_cfl = adapt_dt.push_cfl_criteria(cfl=args.cfl, Finf=min_max_U.Finf,
+ equivalent_CFL=True)
+ dt_advec = adapt_dt.push_advection_criteria(lcfl=args.lcfl, Finf=min_max_W.Finf,
+ criteria=AdvectionCriteria.W_INF)
+
+ #> Custom operator to plot enstrophy
+ if args.plot_enstrophy:
+ class EnstrophyPlotter(ParameterPlotter):
+ """Custom plotting operator for enstrophy."""
+ def __init__(self, **kwds):
+ import matplotlib.pyplot as plt
+ if all(n==npts[0] for n in npts):
+ snpts='${}^3$'.format(npts[0]-1)
+ else:
+ snpts='x'.join(str(n-1) for n in npts)
+ tag='hysop-{}'.format(snpts)
+ fig = plt.figure(figsize=(30,18))
+ axe0 = plt.subplot2grid((3,2), (0,0), rowspan=3, colspan=1)
+ axe1 = plt.subplot2grid((3,2), (0,1), rowspan=2, colspan=1)
+ axe2 = plt.subplot2grid((3,2), (2,1), rowspan=1, colspan=1)
+ axes = (axe0, axe1, axe2)
+ parameters={axe0:{tag:enstrophy},
+ axe1:{dt_advec.name: dt_advec,
+ dt_cfl.name: dt_cfl,
+ dt.name: dt},
+ axe2:{'CFL*': adapt_dt.equivalent_CFL }}
+ super(EnstrophyPlotter, self).__init__(name='enstrophy_dt',
+ parameters=parameters, fig=fig, axes=axes, **kwds)
+ config='{} {} FD{} PROJECTION_{} {}'.format(args.time_integrator, args.remesh_kernel,
+ args.fd_order, args.reprojection_frequency, args.strang_order)
+ fig = fig.suptitle('HySoP Taylor-Green Example {}\n{}'.format(
+ snpts, config), fontweight='bold')
+ axe0.set_title('Integrated Enstrophy')
+ axe0.set_xlabel('Non-dimensional time', fontweight='bold')
+ axe0.set_ylabel('$\zeta$',
+ rotation=0, fontweight='bold')
+ axe0.set_xlim(args.tstart, args.tend)
+ axe0.set_ylim(0, 26)
+ datadir = os.path.realpath(
+ os.path.join(os.getcwd(), os.path.dirname(__file__)))
+ datadir+='/data'
+ for d in (64,128,256,512):
+ reference=os.path.join(datadir, 'reference_{d}_{d}_{d}.txt'.format(d=d))
+ data = np.loadtxt(reference, usecols=(0,2), dtype=np.float32)
+ axe0.plot(data[:,0], data[:,1]*(1+(d==512)), '--',
+ linewidth=1.0,
+ label='hysop-origin ${}^3$'.format(d) if (d<512) else 'reference-$512^3$')
+ axe0.legend()
+ axe1.set_title('Timesteps (CFL={}, LCFL={})'.format(args.cfl, args.lcfl))
+ axe1.set_xlabel('Non-dimensional time', fontweight='bold')
+ axe1.set_ylabel('Non-dimensional time steps', fontweight='bold')
+ axe1.set_xlim(args.tstart, args.tend)
+ axe1.set_ylim(1e-5, 1e0)
+ axe1.set_yscale('log')
+ axe1.legend()
+ axe2.set_title('Equivalent CFL')
+ axe2.set_xlabel('Non-dimensional time', fontweight='bold')
+ axe2.set_ylabel('CFL*', fontweight='bold')
+ axe2.set_xlim(args.tstart, args.tend)
+ axe2.axhline(y=args.cfl, color='r', linestyle='--')
+ axe2.set_ylim(0., 1.1*args.cfl)
+ plot = EnstrophyPlotter(update_frequency=args.plot_freq,
+ visu_rank=args.visu_rank)
+ else:
+ plot = None
+
+ ## Create the problem we want to solve and insert our
+ # directional splitting subgraph and the standard operators.
+ # The method dictionnary passed to this graph will be dispatched
+ # accross all operators contained in the graph.
+ method.update({ComputeGranularity: args.compute_granularity,
+ SpaceDiscretization: args.fd_order,
+ TimeIntegrator: args.time_integrator,
+ Remesh: args.remesh_kernel})
+ problem = Problem(method=method)
+ problem.insert(poisson, advec, splitting, diffuse, enstrophy_op,
+ min_max_U, min_max_W, adapt_dt, plot)
+ problem.build()
+
+ # If a visu_rank was provided, and show_graph was set,
+ # display the graph on the given process rank.
+ if args.display_graph:
+ problem.display(args.visu_rank)
+
+ # Create a simulation
+ # (do not forget to specify the t and dt parameters here)
+ simu = Simulation(start=args.tstart, end=args.tend,
+ nb_iter=args.nb_iter,
+ max_iter=args.max_iter,
+ dt0=args.dt, times_of_interest=args.times_of_interest,
+ t=t, dt=dt)
+ simu.write_parameters(t, dt_cfl, dt_advec, dt, enstrophy,
+ min_max_U.Finf, min_max_W.Finf, adapt_dt.equivalent_CFL,
+ filename='parameters.txt', precision=8)
+
+ # Initialize only the vorticity
+ problem.initialize_field(vorti, formula=init_vorticity)
+
+ # Finally solve the problem
+ problem.solve(simu, dry_run=args.dry_run,
+ debug_dumper=args.debug_dumper,
+ checkpoint_handler=args.checkpoint_handler)
+
+ # Finalize
+ problem.finalize()
+
+
+if __name__=='__main__':
+ from hysop_examples.example_utils import HysopArgParser, colors
+
+ class TaylorGreenArgParser(HysopArgParser):
+ def __init__(self):
+ prog_name = 'taylor_green'
+ default_dump_dir = '{}/hysop_examples/{}'.format(HysopArgParser.tmp_dir(),
+ prog_name)
+
+ description=colors.color('HySoP Taylor-Green Example: ', fg='blue', style='bold')
+ description+=colors.color('[Van Rees 2011] (first part)', fg='yellow', style='bold')
+ description+=colors.color('\nA comparison of vortex and pseudo-spectral methods '
+ +'for the simulation of periodic vortical flows at high Reynolds numbers.',
+ fg='yellow')
+ description+='\n'
+ description+='\nThis example focuses on a validation study for the '
+ description+='hybrid particle-mesh vortex method at Reynolds 1600 for '
+ description+='the 3D Taylor-Green vortex.'
+ description+='\n'
+ description+='\nSee the original paper at '
+ description+='http://vanreeslab.com/wp-content/papercite-data/pdf/rees-2011.pdf.'
+
+ super(TaylorGreenArgParser, self).__init__(
+ prog_name=prog_name,
+ description=description,
+ default_dump_dir=default_dump_dir)
+
+ def _add_main_args(self):
+ args = super(TaylorGreenArgParser, self)._add_main_args()
+ args.add_argument('-Re', '--reynolds-number', type=float,
+ dest='Re',
+ help='Set the simulation Reynolds number.')
+ return args
+
+ def _check_main_args(self, args):
+ super(TaylorGreenArgParser, self)._check_main_args(args)
+ self._check_default(args, 'Re', float, allow_none=False)
+ self._check_positive(args, 'Re', strict=True, allow_none=False)
+
+ def _add_graphical_io_args(self):
+ graphical_io = super(TaylorGreenArgParser, self)._add_graphical_io_args()
+ graphical_io.add_argument('-pe', '--plot-enstrophy', action='store_true',
+ dest='plot_enstrophy',
+ help=('Plot the enstrophy component during simulation. '+
+ 'Simulation will stop at each time of interest and '+
+ 'the plot will be updated every specified freq iterations.'))
+ graphical_io.add_argument('-pf', '--plot-freq', type=int, default=10,
+ dest='plot_freq',
+ help='Plotting update frequency in terms of iterations.')
+
+ def _check_file_io_args(self, args):
+ super(TaylorGreenArgParser, self)._check_file_io_args(args)
+ self._check_default(args, 'plot_enstrophy', bool, allow_none=False)
+ self._check_default(args, 'plot_freq', int, allow_none=False)
+ self._check_positive(args, 'plot_freq', strict=True, allow_none=False)
+
+ def _setup_parameters(self, args):
+ super(TaylorGreenArgParser, self)._setup_parameters(args)
+ if (args.ndim != 3):
+ msg='This example only works for 3D domains.'
+ self.error(msg)
+
+ parser = TaylorGreenArgParser()
+
+ parser.set_defaults(impl='PYTHON', ndim=3, npts=(65,),
+ box_origin=(0.0,), box_length=(2*pi,),
+ tstart=0.0, tend=10.01,
+ dt=1e-5,
+ cfl=0.5, lcfl=0.125,
+ dump_freq=100, dump_times=(),
+ Re=1600.0)
+
+ parser.run(compute)
diff --git a/notebooks/00_introduction.ipynb b/notebooks/00_introduction.ipynb
index 3e81705218fcc9e6f2cd73ce25c003711ec8267c..4e7db4008ff4603d1c36c4e1343ade0dd4ef71b3 100644
--- a/notebooks/00_introduction.ipynb
+++ b/notebooks/00_introduction.ipynb
@@ -1373,7 +1373,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
- "version": "2.7.15rc1"
+ "version": "2.7.15+"
}
},
"nbformat": 4,
diff --git a/opencl_explore.py b/opencl_explore.py
index 6c3dc0547d90da58bfa9151cfa929a34b43d16ee..57618f37c96ab0143473ded0208e5e4143e22784 100644
--- a/opencl_explore.py
+++ b/opencl_explore.py
@@ -89,7 +89,7 @@ def explore(device_type=cl.device_type.GPU):
default_platform, default_device = \
get_defaults(device_type=device_type)
- out += "Platforms informations:\n Id |"
+ out += "\nPlatforms informations:\n Id |"
for i, plt in enumerate(platforms):
out += str(i) + ' ' * (p_str_max[i] - len(str(i))) + ' |'
for i, plt_info in enumerate(platforms_info):
@@ -97,7 +97,7 @@ def explore(device_type=cl.device_type.GPU):
for i_p, plt in enumerate(platforms):
out += p_data[plt][i]
out += ' ' * (p_str_max[i_p] - len(p_data[plt][i])) + ' |'
- out += "\nDevices informations: \n Default device |"
+ out += "\n\nDevices informations: \n Default device |"
for i, dev in enumerate(all_devices):
if i == default_device and d_data[dev][-1] == default_platform:
out += "DEFAULT" + ' ' * (d_str_max[dev] - 7) + ' |'
diff --git a/requirements.txt b/requirements.txt
index b44b42fb480f3c6487bcd7bc3fb1cfc964d87a31..163c660c86bd6f1c282d9f75075352fec69dec0b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -11,7 +11,6 @@ editdistance
portalocker
tee
ansicolors
-backports.weakref
argparse_color_formatter
primefac
pybind11
@@ -20,3 +19,11 @@ pyfftw
mpi4py
matplotlib
numba
+configparser
+backports.tempfile
+backports.weakref
+networkx
+pyvis
+zarr
+numcodecs
+jsonpickle
diff --git a/setup.py.in b/setup.py.in
index 9b1630a437e2fae13c66843582c1fba1c122926c..0c61ea8347546f7c1e8e65ff5c3cf2e43354aa3b 100644
--- a/setup.py.in
+++ b/setup.py.in
@@ -24,22 +24,18 @@ if enable_cpp:
swig_executable = find_executable("@SWIG_EXECUTABLE@")
-def parseCMakeVar(var):
+def parseCMakeVar(var, sep=';'):
"""
Post-process cmake list-like variables.
Example::
-
- a = parseCMakeVar("var1;var2;var3;")
+ a = parseCMakeVar("var1;var2 ; var3;")
# --> a = ['var', 'var2', 'var3']
"""
if var != "":
- res = list(set(var.split(';')))
- # list/set stuff to avoid duplicates
- # remove empty strings to avoid '-I -I' things leading to bugs
- if res.count(''):
- res.remove('')
- return res
+ # split and remove empty strings
+ res = list(var.split(sep))
+ return list(filter(len, map(str.strip, res)))
else:
return []
@@ -136,9 +132,10 @@ def create_fortran_extension(name, pyf_file=None, src_dirs=None, sources=None,
# --- set f2py options ---
f2py_options = ['--no-lower', '--no-wrap-functions']
options = []
- options.append(('F2PY_REPORT_ON_ARRAY_COPY', '1'))
- if debug_mode and (os.uname()[0] == 'Linux'):
- options.append(('F2PY_REPORT_ATEXIT', '1'))
+ if debug_mode == 1:
+ options.append(('F2PY_REPORT_ON_ARRAY_COPY', '1'))
+ if os.uname()[0] == 'Linux':
+ options.append(('F2PY_REPORT_ATEXIT', '1'))
# --- set include dir ---
inc_dir = parseCMakeVar("@FORTRAN_INCLUDE_DIRS@")
@@ -146,12 +143,12 @@ def create_fortran_extension(name, pyf_file=None, src_dirs=None, sources=None,
inc_dir += parseCMakeVar('@CMAKE_Fortran_MODULE_DIRECTORY@')
# --- set compilation flags ---
- fortran_flags = ['@Fortran_FLAGS@']
+ fortran_flags = parseCMakeVar('@Fortran_FLAGS@', sep=' ')
# we trust cmake for external libraries and
# add them to linker, without using libraries option
extra_link_args = hysop_link_libraries
-
+
ext_fort = Extension(name=name,
sources=sources,
f2py_options=f2py_options,
@@ -222,8 +219,8 @@ def create_swig_extension(name, inc_dirs, src_dirs=None, sources=None):
libraries = parseCMakeVar("@CXX_EXT_LIBS@")
library_dirs = parseCMakeVar("@CXX_EXT_LIB_DIRS@")
- extra_compile_args = parseCMakeVar("@CXX_FLAGS@")
- extra_link_args = parseCMakeVar("@CXX_LINKER_FLAGS@")
+ extra_compile_args = parseCMakeVar("@CXX_FLAGS@", sep=' ')
+ extra_link_args = parseCMakeVar("@CXX_LINKER_FLAGS@", sep=' ')
define_macros = parseCMakeDefines("@CXX_EXTRA_DEFINES@")
swig_ext = Extension(name, sources=sources, language='c++',
swig_opts=swig_opts,
@@ -241,11 +238,11 @@ def create_swig_extension(name, inc_dirs, src_dirs=None, sources=None):
# ------------ Set list of packages required to build the module -------------
# List of modules (directories) to be included
with_test = "@WITH_TESTS@" is "ON"
-with_gpu = "@WITH_GPU@" is "ON"
+with_opencl = "@WITH_OPENCL@" is "ON"
exclude=[]
if not with_test:
exclude.append('*tests*')
-if not with_gpu:
+if not with_opencl:
exclude.append('*opencl*')
packages = find_packages(exclude=exclude, where="@CMAKE_SOURCE_DIR@")
@@ -345,17 +342,6 @@ if enable_cpp is "ON":
ext_modules.append(ext[ex])
data_files = []
-# if "@WITH_GPU@" is "ON":
- # cl_src_dirs = ["cl_src", "cl_src/kernels",
- # "cl_src/advection", "cl_src/remeshing"]
- # for cl_dir in cl_src_dirs:
- # data_files.append(
- # ('./hysop/gpu/' + cl_dir,
- # ['@CMAKE_SOURCE_DIR@/hysop/gpu/' + cl_dir + '/'
- # + cl_file
- # for cl_file in os.listdir(
- # '@CMAKE_SOURCE_DIR@/hysop/gpu/' + cl_dir + '/')
- # if cl_file[0] != '.' and cl_file[0] != '#' and cl_file[-3:] == '.cl']))
descr = 'Hybrid Computation with Particles.'
authors = 'G.H Cottet, J.M Etancelin, J.B Keck, C.Mimeau, F.Pérignon, C. Picard'
diff --git a/src/scalesInterface/layout/cart_topology.f90 b/src/scalesInterface/layout/cart_topology.f90
index c499641ef60cc55232150d84f2d9e3bea4478e52..41ff78e8ab9da9f2258552c78c616cfeb2a1ceeb 100644
--- a/src/scalesInterface/layout/cart_topology.f90
+++ b/src/scalesInterface/layout/cart_topology.f90
@@ -171,12 +171,13 @@ contains
!! that will be used for all the spectral part of the code (ie everything except
!! the particles part). If needed, it also initialzed all the mpi context
!! used by the particles solver.
-subroutine cart_create(dims, ierr, parent_comm, spec_comm, topology)
+subroutine cart_create(dims, ierr, parent_comm, verbosity, spec_comm, topology)
! Input/Output
integer, dimension(:), intent(in) :: dims
integer, intent(out) :: ierr
integer, intent(in) :: parent_comm
+ logical, optional, intent(in) :: verbosity
integer, optional, intent(out) :: spec_comm
integer, optional, intent(in) :: topology
! Other local variables
@@ -188,6 +189,10 @@ subroutine cart_create(dims, ierr, parent_comm, spec_comm, topology)
integer :: key ! to re-order processus in spec_comm
integer, dimension(1) :: nb_proc ! total number of processus
logical, dimension(1) :: period_1D = .false. ! periodicity in case of 1D mpi topology.
+ logical :: show_message
+
+ show_message = .true.
+ if(present(verbosity)) show_message = verbosity
! Duplicate parent_comm
call mpi_comm_dup(parent_comm, main_comm, ierr)
@@ -305,7 +310,7 @@ subroutine cart_create(dims, ierr, parent_comm, spec_comm, topology)
! Print some minimal information about the topology
- if (cart_rank == 0) then
+ if ((cart_rank == 0).and.show_message) then
write(*,'(a)') ''
write(*,'(6x,a)') '========== Topology used ========='
if (topology_dim == 0) then
diff --git a/test_ci.sh b/test_ci.sh
index 6d4c7e65d4ee25936afe3726269f547f0cd9a022..8521dead686422e6742ed1c3f1912f6182a14b32 100755
--- a/test_ci.sh
+++ b/test_ci.sh
@@ -1,12 +1,14 @@
#!/bin/bash
-set -e
+set -fe -o pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
if [ -z "$HYSOP_ROOT" ]; then
- HYSOP_ROOT=$(pwd)
+ HYSOP_ROOT="${SCRIPT_DIR}"
echo "Warning: HYSOP_ROOT has not been set."
- echo "Setting HYSOP_ROOT to '$HYSOP_ROOT'"
+ echo "Setting HYSOP_ROOT to '${HYSOP_ROOT}'"
fi
-$HYSOP_ROOT/ci/scripts/test.sh $HYSOP_ROOT $HYSOP_ROOT/hysop
+${HYSOP_ROOT}/ci/scripts/test.sh ${HYSOP_ROOT} ${HYSOP_ROOT}/hysop
exit 0
diff --git a/test_examples.sh b/test_examples.sh
index 3c99a0ce187863ec5b1a4f762d9390bda43cb6b0..b5dd68b5dfebd75a44210d2a0a264c97266f7a26 100755
--- a/test_examples.sh
+++ b/test_examples.sh
@@ -1,15 +1,17 @@
#!/bin/bash
-set -e
+set -fe -o pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
if [ -z "$HYSOP_ROOT" ]; then
- HYSOP_ROOT=$(pwd)
+ HYSOP_ROOT="${SCRIPT_DIR}"
echo "Warning: HYSOP_ROOT has not been set."
- echo "Setting HYSOP_ROOT to '$HYSOP_ROOT'"
+ echo "Setting HYSOP_ROOT to '${HYSOP_ROOT}'"
fi
-export DO_TESTS=false
-export DO_LONG_TESTS=false
-export DO_EXAMPLES=true
-$HYSOP_ROOT/ci/scripts/test.sh $HYSOP_ROOT $HYSOP_ROOT/hysop
+export RUN_TESTS=false
+export RUN_LONG_TESTS=false
+export RUN_EXAMPLES=true
+${HYSOP_ROOT}/ci/scripts/test.sh ${HYSOP_ROOT} ${HYSOP_ROOT}/hysop
exit 0