Mantaflow [Part 1]: Added preprocessed Mantaflow source files

Includes preprocessed Mantaflow source files for both OpenMP and TBB (if OpenMP is not present, TBB files will be used instead).

These files come directly from the Mantaflow repository. Future updates to the core fluid solver will take place by updating the files.

Reviewed By: sergey, mont29

Maniphest Tasks: T59995

Differential Revision: https://developer.blender.org/D3850

117 files changed, 65384 insertions, 0 deletions

diff --git a/extern/mantaflow/LICENSE b/extern/mantaflow/LICENSE
new file mode 100644
index 00000000000..a5e3b509f7d
--- /dev/null
+++ b/extern/mantaflow/LICENSE
@@ -0,0 +1,222 @@
+
+Copyright 2018, the mantaflow team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-------------------------------------------------------------------------
+
+                          Apache License
+                     Version 2.0, January 2004
+                  http://www.apache.org/licenses/
+
+-------------------------------------------------------------------------
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+	  Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+	  stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+	  that You distribute, all copyright, patent, trademark, and
+	  attribution notices from the Source form of the Work,
+	  excluding those notices that do not pertain to any part of
+	  the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+	  distribution, then any Derivative Works that You distribute must
+	  include a readable copy of the attribution notices contained
+	  within such NOTICE file, excluding those notices that do not
+	  pertain to any part of the Derivative Works, in at least one
+	  of the following places: within a NOTICE text file distributed
+	  as part of the Derivative Works; within the Source form or
+	  documentation, if provided along with the Derivative Works; or,
+	  within a display generated by the Derivative Works, if and
+	  wherever such third-party notices normally appear. The contents
+	  of the NOTICE file are for informational purposes only and
+	  do not modify the License. You may add Your own attribution
+	  notices within Derivative Works that You distribute, alongside
+	  or as an addendum to the NOTICE text from the Work, provided
+	  that such additional attribution notices cannot be construed
+	  as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+------------------------------------------------------------------------------
+
+APPENDIX: HOW TO APPLY THE APACHE LICENSE TO YOUR WORK
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification
+within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
diff --git a/extern/mantaflow/README.md b/extern/mantaflow/README.md
new file mode 100644
index 00000000000..d5753d07689
--- /dev/null
+++ b/extern/mantaflow/README.md
@@ -0,0 +1,11 @@
+# Mantaflow #

+

+Mantaflow is an open-source framework targeted at fluid simulation research in Computer Graphics.

+Its parallelized C++ solver core, python scene definition interface and plugin system allow for quickly prototyping and testing new algorithms. 

+

+In addition, it provides a toolbox of examples for deep learning experiments with fluids. E.g., it contains examples

+how to build convolutional neural network setups in conjunction with the [tensorflow framework](https://www.tensorflow.org).

+

+For more information on how to install, run and code with Mantaflow, please head over to our home page at

+[http://mantaflow.com](http://mantaflow.com)

+

diff --git a/extern/mantaflow/UPDATE.sh b/extern/mantaflow/UPDATE.sh
new file mode 100644
index 00000000000..28d96cdf6d8
--- /dev/null
+++ b/extern/mantaflow/UPDATE.sh
@@ -0,0 +1,102 @@
+#!/bin/bash
+#
+# ========================================================================================
+# UPDATING MANTAFLOW INSIDE BLENDER
+# ========================================================================================
+
+# ====================  1) ENVIRONMENT SETUP =============================================
+
+# YOUR INSTALLATION PATHS GO HERE:
+MANTA_INSTALLATION=/Users/sebbas/Developer/Mantaflow/mantaflowDevelop
+BLENDER_INSTALLATION=/Users/sebbas/Developer/Blender/fluid-mantaflow
+
+# Try to check out Mantaflow repository before building?
+CLEAN_REPOSITORY=0
+
+# Choose which multithreading platform to use for Mantaflow preprocessing
+USE_OMP=0
+USE_TBB=1
+
+if [[ "$USE_OMP" -eq "1" && "$USE_TBB" -eq "1" ]]; then
+  echo "Cannot build Mantaflow for OpenMP and TBB at the same time"
+  exit 1
+elif [[ "$USE_OMP" -eq "0" && "$USE_TBB" -eq "0" ]]; then
+  echo "WARNING: Building Mantaflow without multithreading"
+else
+  if [[ "$USE_OMP" -eq "1" ]]; then
+    echo "Building Mantaflow with OpenMP multithreading"
+  elif [[ "$USE_TBB" -eq "1" ]]; then
+    echo "Building Mantaflow with TBB multithreading"
+  fi
+fi
+
+# ==================== 2) BUILD MANTAFLOW ================================================
+
+# For OpenMP, we need non-default compiler to build Mantaflow on OSX
+if [[ "$USE_OMP" -eq "1" && "$OSTYPE" == "darwin"* ]]; then
+  export CC=/usr/local/opt/llvm/bin/clang
+  export CXX=/usr/local/opt/llvm/bin/clang++
+  export LDFLAGS=-L/usr/local/opt/llvm/lib
+fi
+
+cd $MANTA_INSTALLATION
+
+# Check-out manta repo from git?
+if [[ "$CLEAN_REPOSITORY" -eq "1" ]]; then
+  if cd mantaflowgit/; then git pull; else git clone git@bitbucket.org:thunil/mantaflowgit.git; cd mantaflowgit; fi
+  git checkout develop
+fi
+
+MANTA_BUILD_PATH=$MANTA_INSTALLATION/mantaflowgit/build_blender/
+mkdir -p $MANTA_BUILD_PATH
+cd $MANTA_BUILD_PATH
+cmake .. -DGUI=OFF -DOPENMP=$USE_OMP -DTBB=$USE_TBB -DBLENDER=ON -DPREPDEBUG=ON && make -j8
+
+# ==================== 3) COPY MANTAFLOW FILES TO BLENDER ROOT ===========================
+
+mkdir -p $BLENDER_INSTALLATION/blender/tmp/dependencies/ && cp -Rf $MANTA_INSTALLATION/mantaflowgit/dependencies/cnpy "$_"
+mkdir -p $BLENDER_INSTALLATION/blender/tmp/helper/ && cp -Rf $MANTA_INSTALLATION/mantaflowgit/source/util "$_"
+mkdir -p $BLENDER_INSTALLATION/blender/tmp/helper/ && cp -Rf $MANTA_INSTALLATION/mantaflowgit/source/pwrapper "$_"
+mkdir -p $BLENDER_INSTALLATION/blender/tmp/preprocessed/ && cp -Rf $MANTA_INSTALLATION/mantaflowgit/build_blender/pp/source/. "$_"
+
+# Remove some files that are not need in Blender
+rm $BLENDER_INSTALLATION/blender/tmp/dependencies/cnpy/example1.cpp
+rm $BLENDER_INSTALLATION/blender/tmp/helper/pwrapper/pymain.cpp
+rm $BLENDER_INSTALLATION/blender/tmp/preprocessed/*.reg
+rm $BLENDER_INSTALLATION/blender/tmp/preprocessed/python/*.reg
+rm $BLENDER_INSTALLATION/blender/tmp/preprocessed/fileio/*.reg
+
+# ==================== 4) CLANG-FORMAT ===================================================
+
+cd $BLENDER_INSTALLATION/blender/tmp/
+
+echo "Applying clang format to Mantaflow source files"
+find . -iname *.h -o -iname *.cpp | xargs clang-format --verbose -i -style=file
+find . -iname *.h -o -iname *.cpp | xargs dos2unix --verbose
+
+# ==================== 5) MOVE MANTAFLOW FILES TO EXTERN/ ================================
+
+BLENDER_MANTA_EXTERN=$BLENDER_INSTALLATION/blender/extern/mantaflow/
+BLENDER_TMP=$BLENDER_INSTALLATION/blender/tmp
+BLENDER_TMP_DEP=$BLENDER_TMP/dependencies
+BLENDER_TMP_HLP=$BLENDER_TMP/helper
+BLENDER_TMP_PP=$BLENDER_TMP/preprocessed
+
+# Move files from tmp dir to extern/
+cp -Rf $BLENDER_TMP_DEP $BLENDER_MANTA_EXTERN
+cp -Rf $BLENDER_TMP_HLP $BLENDER_MANTA_EXTERN
+cp -Rf $BLENDER_TMP_PP $BLENDER_MANTA_EXTERN
+
+# Copy the Mantaflow license and readme files as well
+cp -Rf $MANTA_INSTALLATION/mantaflowgit/LICENSE $BLENDER_MANTA_EXTERN
+cp -Rf $MANTA_INSTALLATION/mantaflowgit/README.md $BLENDER_MANTA_EXTERN
+
+# Cleanup left over dir
+rm -r $BLENDER_TMP
+
+echo "Successfully copied new Mantaflow files to" $BLENDER_INSTALLATION/blender/extern/mantaflow/
+
+# ==================== 6) CHECK CMAKE SETUP ==============================================
+
+# Make sure that all files copied from Mantaflow are listed in intern/mantaflow/CMakeLists.txt
+# Especially if new source files / plugins were added to Mantaflow.
diff --git a/extern/mantaflow/dependencies/cnpy/LICENSE b/extern/mantaflow/dependencies/cnpy/LICENSE
new file mode 100644
index 00000000000..e60eadbccb3
--- /dev/null
+++ b/extern/mantaflow/dependencies/cnpy/LICENSE
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Carl Rogers, 2011
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/extern/mantaflow/dependencies/cnpy/cnpy.cpp b/extern/mantaflow/dependencies/cnpy/cnpy.cpp
new file mode 100644
index 00000000000..7f0ce21ece8
--- /dev/null
+++ b/extern/mantaflow/dependencies/cnpy/cnpy.cpp
@@ -0,0 +1,385 @@
+// Copyright (C) 2011  Carl Rogers
+// Released under MIT License
+// license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php
+
+#include "cnpy.h"
+#include <complex>
+#include <cstdlib>
+#include <algorithm>
+#include <cstring>
+#include <iomanip>
+#include <stdint.h>
+#include <stdexcept>
+#include <regex>
+
+char cnpy::BigEndianTest()
+{
+  int x = 1;
+  return (((char *)&x)[0]) ? '<' : '>';
+}
+
+char cnpy::map_type(const std::type_info &t)
+{
+  if (t == typeid(float))
+    return 'f';
+  if (t == typeid(double))
+    return 'f';
+  if (t == typeid(long double))
+    return 'f';
+
+  if (t == typeid(int))
+    return 'i';
+  if (t == typeid(char))
+    return 'i';
+  if (t == typeid(short))
+    return 'i';
+  if (t == typeid(long))
+    return 'i';
+  if (t == typeid(long long))
+    return 'i';
+
+  if (t == typeid(unsigned char))
+    return 'u';
+  if (t == typeid(unsigned short))
+    return 'u';
+  if (t == typeid(unsigned long))
+    return 'u';
+  if (t == typeid(unsigned long long))
+    return 'u';
+  if (t == typeid(unsigned int))
+    return 'u';
+
+  if (t == typeid(bool))
+    return 'b';
+
+  if (t == typeid(std::complex<float>))
+    return 'c';
+  if (t == typeid(std::complex<double>))
+    return 'c';
+  if (t == typeid(std::complex<long double>))
+    return 'c';
+
+  else
+    return '?';
+}
+
+template<> std::vector<char> &cnpy::operator+=(std::vector<char> &lhs, const std::string rhs)
+{
+  lhs.insert(lhs.end(), rhs.begin(), rhs.end());
+  return lhs;
+}
+
+template<> std::vector<char> &cnpy::operator+=(std::vector<char> &lhs, const char *rhs)
+{
+  // write in little endian
+  size_t len = strlen(rhs);
+  lhs.reserve(len);
+  for (size_t byte = 0; byte < len; byte++) {
+    lhs.push_back(rhs[byte]);
+  }
+  return lhs;
+}
+
+void cnpy::parse_npy_header(unsigned char *buffer,
+                            size_t &word_size,
+                            std::vector<size_t> &shape,
+                            bool &fortran_order)
+{
+  // std::string magic_string(buffer,6);
+  uint8_t major_version = *reinterpret_cast<uint8_t *>(buffer + 6);
+  uint8_t minor_version = *reinterpret_cast<uint8_t *>(buffer + 7);
+  uint16_t header_len = *reinterpret_cast<uint16_t *>(buffer + 8);
+  std::string header(reinterpret_cast<char *>(buffer + 9), header_len);
+
+  size_t loc1, loc2;
+
+  // fortran order
+  loc1 = header.find("fortran_order") + 16;
+  fortran_order = (header.substr(loc1, 4) == "True" ? true : false);
+
+  // shape
+  loc1 = header.find("(");
+  loc2 = header.find(")");
+
+  std::regex num_regex("[0-9][0-9]*");
+  std::smatch sm;
+  shape.clear();
+
+  std::string str_shape = header.substr(loc1 + 1, loc2 - loc1 - 1);
+  while (std::regex_search(str_shape, sm, num_regex)) {
+    shape.push_back(std::stoi(sm[0].str()));
+    str_shape = sm.suffix().str();
+  }
+
+  // endian, word size, data type
+  // byte order code | stands for not applicable.
+  // not sure when this applies except for byte array
+  loc1 = header.find("descr") + 9;
+  bool littleEndian = (header[loc1] == '<' || header[loc1] == '|' ? true : false);
+  assert(littleEndian);
+
+  // char type = header[loc1+1];
+  // assert(type == map_type(T));
+
+  std::string str_ws = header.substr(loc1 + 2);
+  loc2 = str_ws.find("'");
+  word_size = atoi(str_ws.substr(0, loc2).c_str());
+}
+
+void cnpy::parse_npy_header(FILE *fp,
+                            size_t &word_size,
+                            std::vector<size_t> &shape,
+                            bool &fortran_order)
+{
+  char buffer[256];
+  size_t res = fread(buffer, sizeof(char), 11, fp);
+  if (res != 11)
+    throw std::runtime_error("parse_npy_header: failed fread");
+  std::string header = fgets(buffer, 256, fp);
+  assert(header[header.size() - 1] == '\n');
+
+  size_t loc1, loc2;
+
+  // fortran order
+  loc1 = header.find("fortran_order");
+  if (loc1 == std::string::npos)
+    throw std::runtime_error("parse_npy_header: failed to find header keyword: 'fortran_order'");
+  loc1 += 16;
+  fortran_order = (header.substr(loc1, 4) == "True" ? true : false);
+
+  // shape
+  loc1 = header.find("(");
+  loc2 = header.find(")");
+  if (loc1 == std::string::npos || loc2 == std::string::npos)
+    throw std::runtime_error("parse_npy_header: failed to find header keyword: '(' or ')'");
+
+  std::regex num_regex("[0-9][0-9]*");
+  std::smatch sm;
+  shape.clear();
+
+  std::string str_shape = header.substr(loc1 + 1, loc2 - loc1 - 1);
+  while (std::regex_search(str_shape, sm, num_regex)) {
+    shape.push_back(std::stoi(sm[0].str()));
+    str_shape = sm.suffix().str();
+  }
+
+  // endian, word size, data type
+  // byte order code | stands for not applicable.
+  // not sure when this applies except for byte array
+  loc1 = header.find("descr");
+  if (loc1 == std::string::npos)
+    throw std::runtime_error("parse_npy_header: failed to find header keyword: 'descr'");
+  loc1 += 9;
+  bool littleEndian = (header[loc1] == '<' || header[loc1] == '|' ? true : false);
+  assert(littleEndian);
+
+  // char type = header[loc1+1];
+  // assert(type == map_type(T));
+
+  std::string str_ws = header.substr(loc1 + 2);
+  loc2 = str_ws.find("'");
+  word_size = atoi(str_ws.substr(0, loc2).c_str());
+}
+
+void cnpy::parse_zip_footer(FILE *fp,
+                            uint16_t &nrecs,
+                            size_t &global_header_size,
+                            size_t &global_header_offset)
+{
+  std::vector<char> footer(22);
+  fseek(fp, -22, SEEK_END);
+  size_t res = fread(&footer[0], sizeof(char), 22, fp);
+  if (res != 22)
+    throw std::runtime_error("parse_zip_footer: failed fread");
+
+  uint16_t disk_no, disk_start, nrecs_on_disk, comment_len;
+  disk_no = *(uint16_t *)&footer[4];
+  disk_start = *(uint16_t *)&footer[6];
+  nrecs_on_disk = *(uint16_t *)&footer[8];
+  nrecs = *(uint16_t *)&footer[10];
+  global_header_size = *(uint32_t *)&footer[12];
+  global_header_offset = *(uint32_t *)&footer[16];
+  comment_len = *(uint16_t *)&footer[20];
+
+  assert(disk_no == 0);
+  assert(disk_start == 0);
+  assert(nrecs_on_disk == nrecs);
+  assert(comment_len == 0);
+}
+
+cnpy::NpyArray load_the_npy_file(FILE *fp)
+{
+  std::vector<size_t> shape;
+  size_t word_size;
+  bool fortran_order;
+  cnpy::parse_npy_header(fp, word_size, shape, fortran_order);
+
+  cnpy::NpyArray arr(shape, word_size, fortran_order);
+  size_t nread = fread(arr.data<char>(), 1, arr.num_bytes(), fp);
+  if (nread != arr.num_bytes())
+    throw std::runtime_error("load_the_npy_file: failed fread");
+  return arr;
+}
+
+cnpy::NpyArray load_the_npz_array(FILE *fp, uint32_t compr_bytes, uint32_t uncompr_bytes)
+{
+
+  std::vector<unsigned char> buffer_compr(compr_bytes);
+  std::vector<unsigned char> buffer_uncompr(uncompr_bytes);
+  size_t nread = fread(&buffer_compr[0], 1, compr_bytes, fp);
+  if (nread != compr_bytes)
+    throw std::runtime_error("load_the_npy_file: failed fread");
+
+  int err;
+  z_stream d_stream;
+
+  d_stream.zalloc = Z_NULL;
+  d_stream.zfree = Z_NULL;
+  d_stream.opaque = Z_NULL;
+  d_stream.avail_in = 0;
+  d_stream.next_in = Z_NULL;
+  err = inflateInit2(&d_stream, -MAX_WBITS);
+
+  d_stream.avail_in = compr_bytes;
+  d_stream.next_in = &buffer_compr[0];
+  d_stream.avail_out = uncompr_bytes;
+  d_stream.next_out = &buffer_uncompr[0];
+
+  err = inflate(&d_stream, Z_FINISH);
+  err = inflateEnd(&d_stream);
+
+  std::vector<size_t> shape;
+  size_t word_size;
+  bool fortran_order;
+  cnpy::parse_npy_header(&buffer_uncompr[0], word_size, shape, fortran_order);
+
+  cnpy::NpyArray array(shape, word_size, fortran_order);
+
+  size_t offset = uncompr_bytes - array.num_bytes();
+  memcpy(array.data<unsigned char>(), &buffer_uncompr[0] + offset, array.num_bytes());
+
+  return array;
+}
+
+cnpy::npz_t cnpy::npz_load(std::string fname)
+{
+  FILE *fp = fopen(fname.c_str(), "rb");
+
+  if (!fp) {
+    throw std::runtime_error("npz_load: Error! Unable to open file " + fname + "!");
+  }
+
+  cnpy::npz_t arrays;
+
+  while (1) {
+    std::vector<char> local_header(30);
+    size_t headerres = fread(&local_header[0], sizeof(char), 30, fp);
+    if (headerres != 30)
+      throw std::runtime_error("npz_load: failed fread");
+
+    // if we've reached the global header, stop reading
+    if (local_header[2] != 0x03 || local_header[3] != 0x04)
+      break;
+
+    // read in the variable name
+    uint16_t name_len = *(uint16_t *)&local_header[26];
+    std::string varname(name_len, ' ');
+    size_t vname_res = fread(&varname[0], sizeof(char), name_len, fp);
+    if (vname_res != name_len)
+      throw std::runtime_error("npz_load: failed fread");
+
+    // erase the lagging .npy
+    varname.erase(varname.end() - 4, varname.end());
+
+    // read in the extra field
+    uint16_t extra_field_len = *(uint16_t *)&local_header[28];
+    if (extra_field_len > 0) {
+      std::vector<char> buff(extra_field_len);
+      size_t efield_res = fread(&buff[0], sizeof(char), extra_field_len, fp);
+      if (efield_res != extra_field_len)
+        throw std::runtime_error("npz_load: failed fread");
+    }
+
+    uint16_t compr_method = *reinterpret_cast<uint16_t *>(&local_header[0] + 8);
+    uint32_t compr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0] + 18);
+    uint32_t uncompr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0] + 22);
+
+    if (compr_method == 0) {
+      arrays[varname] = load_the_npy_file(fp);
+    }
+    else {
+      arrays[varname] = load_the_npz_array(fp, compr_bytes, uncompr_bytes);
+    }
+  }
+
+  fclose(fp);
+  return arrays;
+}
+
+cnpy::NpyArray cnpy::npz_load(std::string fname, std::string varname)
+{
+  FILE *fp = fopen(fname.c_str(), "rb");
+
+  if (!fp)
+    throw std::runtime_error("npz_load: Unable to open file " + fname);
+
+  while (1) {
+    std::vector<char> local_header(30);
+    size_t header_res = fread(&local_header[0], sizeof(char), 30, fp);
+    if (header_res != 30)
+      throw std::runtime_error("npz_load: failed fread");
+
+    // if we've reached the global header, stop reading
+    if (local_header[2] != 0x03 || local_header[3] != 0x04)
+      break;
+
+    // read in the variable name
+    uint16_t name_len = *(uint16_t *)&local_header[26];
+    std::string vname(name_len, ' ');
+    size_t vname_res = fread(&vname[0], sizeof(char), name_len, fp);
+    if (vname_res != name_len)
+      throw std::runtime_error("npz_load: failed fread");
+    vname.erase(vname.end() - 4, vname.end());  // erase the lagging .npy
+
+    // read in the extra field
+    uint16_t extra_field_len = *(uint16_t *)&local_header[28];
+    fseek(fp, extra_field_len, SEEK_CUR);  // skip past the extra field
+
+    uint16_t compr_method = *reinterpret_cast<uint16_t *>(&local_header[0] + 8);
+    uint32_t compr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0] + 18);
+    uint32_t uncompr_bytes = *reinterpret_cast<uint32_t *>(&local_header[0] + 22);
+
+    if (vname == varname) {
+      NpyArray array = (compr_method == 0) ? load_the_npy_file(fp) :
+                                             load_the_npz_array(fp, compr_bytes, uncompr_bytes);
+      fclose(fp);
+      return array;
+    }
+    else {
+      // skip past the data
+      // uint32_t size = *(uint32_t*) &local_header[22];
+      uint32_t size = *(uint32_t *)&local_header[18];  // using index 18 instead of 22 enables
+                                                       // support for compressed data
+      fseek(fp, size, SEEK_CUR);
+    }
+  }
+
+  fclose(fp);
+
+  // if we get here, we haven't found the variable in the file
+  throw std::runtime_error("npz_load: Variable name " + varname + " not found in " + fname);
+}
+
+cnpy::NpyArray cnpy::npy_load(std::string fname)
+{
+
+  FILE *fp = fopen(fname.c_str(), "rb");
+
+  if (!fp)
+    throw std::runtime_error("npy_load: Unable to open file " + fname);
+
+  NpyArray arr = load_the_npy_file(fp);
+
+  fclose(fp);
+  return arr;
+}
diff --git a/extern/mantaflow/dependencies/cnpy/cnpy.h b/extern/mantaflow/dependencies/cnpy/cnpy.h
new file mode 100644
index 00000000000..e4b6365cb6f
--- /dev/null
+++ b/extern/mantaflow/dependencies/cnpy/cnpy.h
@@ -0,0 +1,310 @@
+// Copyright (C) 2011  Carl Rogers
+// Released under MIT License
+// license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php
+
+#ifndef LIBCNPY_H_
+#define LIBCNPY_H_
+
+#include <string>
+#include <stdexcept>
+#include <sstream>
+#include <vector>
+#include <cstdio>
+#include <typeinfo>
+#include <iostream>
+#include <cassert>
+#include <zlib.h>
+#include <map>
+#include <memory>
+#include <stdint.h>
+#include <numeric>
+
+namespace cnpy {
+
+struct NpyArray {
+  NpyArray(const std::vector<size_t> &_shape, size_t _word_size, bool _fortran_order)
+      : shape(_shape), word_size(_word_size), fortran_order(_fortran_order)
+  {
+    num_vals = 1;
+    for (size_t i = 0; i < shape.size(); i++)
+      num_vals *= shape[i];
+    data_holder = std::shared_ptr<std::vector<char>>(new std::vector<char>(num_vals * word_size));
+  }
+
+  NpyArray() : shape(0), word_size(0), fortran_order(0), num_vals(0)
+  {
+  }
+
+  template<typename T> T *data()
+  {
+    return reinterpret_cast<T *>(&(*data_holder)[0]);
+  }
+
+  template<typename T> const T *data() const
+  {
+    return reinterpret_cast<T *>(&(*data_holder)[0]);
+  }
+
+  template<typename T> std::vector<T> as_vec() const
+  {
+    const T *p = data<T>();
+    return std::vector<T>(p, p + num_vals);
+  }
+
+  size_t num_bytes() const
+  {
+    return data_holder->size();
+  }
+
+  std::shared_ptr<std::vector<char>> data_holder;
+  std::vector<size_t> shape;
+  size_t word_size;
+  bool fortran_order;
+  size_t num_vals;
+};
+
+using npz_t = std::map<std::string, NpyArray>;
+
+char BigEndianTest();
+char map_type(const std::type_info &t);
+template<typename T> std::vector<char> create_npy_header(const std::vector<size_t> &shape);
+void parse_npy_header(FILE *fp,
+                      size_t &word_size,
+                      std::vector<size_t> &shape,
+                      bool &fortran_order);
+void parse_npy_header(unsigned char *buffer,
+                      size_t &word_size,
+                      std::vector<size_t> &shape,
+                      bool &fortran_order);
+void parse_zip_footer(FILE *fp,
+                      uint16_t &nrecs,
+                      size_t &global_header_size,
+                      size_t &global_header_offset);
+npz_t npz_load(std::string fname);
+NpyArray npz_load(std::string fname, std::string varname);
+NpyArray npy_load(std::string fname);
+
+template<typename T> std::vector<char> &operator+=(std::vector<char> &lhs, const T rhs)
+{
+  // write in little endian
+  for (size_t byte = 0; byte < sizeof(T); byte++) {
+    char val = *((char *)&rhs + byte);
+    lhs.push_back(val);
+  }
+  return lhs;
+}
+
+template<> std::vector<char> &operator+=(std::vector<char> &lhs, const std::string rhs);
+template<> std::vector<char> &operator+=(std::vector<char> &lhs, const char *rhs);
+
+template<typename T>
+void npy_save(std::string fname,
+              const T *data,
+              const std::vector<size_t> shape,
+              std::string mode = "w")
+{
+  FILE *fp = NULL;
+  std::vector<size_t> true_data_shape;  // if appending, the shape of existing + new data
+
+  if (mode == "a")
+    fp = fopen(fname.c_str(), "r+b");
+
+  if (fp) {
+    // file exists. we need to append to it. read the header, modify the array size
+    size_t word_size;
+    bool fortran_order;
+    parse_npy_header(fp, word_size, true_data_shape, fortran_order);
+    assert(!fortran_order);
+
+    if (word_size != sizeof(T)) {
+      std::cout << "libnpy error: " << fname << " has word size " << word_size
+                << " but npy_save appending data sized " << sizeof(T) << "\n";
+      assert(word_size == sizeof(T));
+    }
+    if (true_data_shape.size() != shape.size()) {
+      std::cout << "libnpy error: npy_save attempting to append misdimensioned data to " << fname
+                << "\n";
+      assert(true_data_shape.size() != shape.size());
+    }
+
+    for (size_t i = 1; i < shape.size(); i++) {
+      if (shape[i] != true_data_shape[i]) {
+        std::cout << "libnpy error: npy_save attempting to append misshaped data to " << fname
+                  << "\n";
+        assert(shape[i] == true_data_shape[i]);
+      }
+    }
+    true_data_shape[0] += shape[0];
+  }
+  else {
+    fp = fopen(fname.c_str(), "wb");
+    true_data_shape = shape;
+  }
+
+  std::vector<char> header = create_npy_header<T>(true_data_shape);
+  size_t nels = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<size_t>());
+
+  fseek(fp, 0, SEEK_SET);
+  fwrite(&header[0], sizeof(char), header.size(), fp);
+  fseek(fp, 0, SEEK_END);
+  fwrite(data, sizeof(T), nels, fp);
+  fclose(fp);
+}
+
+template<typename T>
+void npz_save(std::string zipname,
+              std::string fname,
+              const T *data,
+              const std::vector<size_t> &shape,
+              std::string mode = "w")
+{
+  // first, append a .npy to the fname
+  fname += ".npy";
+
+  // now, on with the show
+  FILE *fp = NULL;
+  uint16_t nrecs = 0;
+  size_t global_header_offset = 0;
+  std::vector<char> global_header;
+
+  if (mode == "a")
+    fp = fopen(zipname.c_str(), "r+b");
+
+  if (fp) {
+    // zip file exists. we need to add a new npy file to it.
+    // first read the footer. this gives us the offset and size of the global header
+    // then read and store the global header.
+    // below, we will write the the new data at the start of the global header then append the
+    // global header and footer below it
+    size_t global_header_size;
+    parse_zip_footer(fp, nrecs, global_header_size, global_header_offset);
+    fseek(fp, global_header_offset, SEEK_SET);
+    global_header.resize(global_header_size);
+    size_t res = fread(&global_header[0], sizeof(char), global_header_size, fp);
+    if (res != global_header_size) {
+      throw std::runtime_error("npz_save: header read error while adding to existing zip");
+    }
+    fseek(fp, global_header_offset, SEEK_SET);
+  }
+  else {
+    fp = fopen(zipname.c_str(), "wb");
+  }
+
+  std::vector<char> npy_header = create_npy_header<T>(shape);
+
+  size_t nels = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<size_t>());
+  size_t nbytes = nels * sizeof(T) + npy_header.size();
+
+  // get the CRC of the data to be added
+  uint32_t crc = crc32(0L, (uint8_t *)&npy_header[0], npy_header.size());
+  crc = crc32(crc, (uint8_t *)data, nels * sizeof(T));
+
+  // build the local header
+  std::vector<char> local_header;
+  local_header += "PK";                    // first part of sig
+  local_header += (uint16_t)0x0403;        // second part of sig
+  local_header += (uint16_t)20;            // min version to extract
+  local_header += (uint16_t)0;             // general purpose bit flag
+  local_header += (uint16_t)0;             // compression method
+  local_header += (uint16_t)0;             // file last mod time
+  local_header += (uint16_t)0;             // file last mod date
+  local_header += (uint32_t)crc;           // crc
+  local_header += (uint32_t)nbytes;        // compressed size
+  local_header += (uint32_t)nbytes;        // uncompressed size
+  local_header += (uint16_t)fname.size();  // fname length
+  local_header += (uint16_t)0;             // extra field length
+  local_header += fname;
+
+  // build global header
+  global_header += "PK";              // first part of sig
+  global_header += (uint16_t)0x0201;  // second part of sig
+  global_header += (uint16_t)20;      // version made by
+  global_header.insert(global_header.end(), local_header.begin() + 4, local_header.begin() + 30);
+  global_header += (uint16_t)0;  // file comment length
+  global_header += (uint16_t)0;  // disk number where file starts
+  global_header += (uint16_t)0;  // internal file attributes
+  global_header += (uint32_t)0;  // external file attributes
+  global_header += (uint32_t)
+      global_header_offset;  // relative offset of local file header, since it begins where the
+                             // global header used to begin
+  global_header += fname;
+
+  // build footer
+  std::vector<char> footer;
+  footer += "PK";                            // first part of sig
+  footer += (uint16_t)0x0605;                // second part of sig
+  footer += (uint16_t)0;                     // number of this disk
+  footer += (uint16_t)0;                     // disk where footer starts
+  footer += (uint16_t)(nrecs + 1);           // number of records on this disk
+  footer += (uint16_t)(nrecs + 1);           // total number of records
+  footer += (uint32_t)global_header.size();  // nbytes of global headers
+  footer += (uint32_t)(global_header_offset + nbytes +
+                       local_header.size());  // offset of start of global headers, since global
+                                              // header now starts after newly written array
+  footer += (uint16_t)0;  // zip file comment length
+
+  // write everything
+  fwrite(&local_header[0], sizeof(char), local_header.size(), fp);
+  fwrite(&npy_header[0], sizeof(char), npy_header.size(), fp);
+  fwrite(data, sizeof(T), nels, fp);
+  fwrite(&global_header[0], sizeof(char), global_header.size(), fp);
+  fwrite(&footer[0], sizeof(char), footer.size(), fp);
+  fclose(fp);
+}
+
+template<typename T>
+void npy_save(std::string fname, const std::vector<T> data, std::string mode = "w")
+{
+  std::vector<size_t> shape;
+  shape.push_back(data.size());
+  npy_save(fname, &data[0], shape, mode);
+}
+
+template<typename T>
+void npz_save(std::string zipname,
+              std::string fname,
+              const std::vector<T> data,
+              std::string mode = "w")
+{
+  std::vector<size_t> shape;
+  shape.push_back(data.size());
+  npz_save(zipname, fname, &data[0], shape, mode);
+}
+
+template<typename T> std::vector<char> create_npy_header(const std::vector<size_t> &shape)
+{
+
+  std::vector<char> dict;
+  dict += "{'descr': '";
+  dict += BigEndianTest();
+  dict += map_type(typeid(T));
+  dict += std::to_string(sizeof(T));
+  dict += "', 'fortran_order': False, 'shape': (";
+  dict += std::to_string(shape[0]);
+  for (size_t i = 1; i < shape.size(); i++) {
+    dict += ", ";
+    dict += std::to_string(shape[i]);
+  }
+  if (shape.size() == 1)
+    dict += ",";
+  dict += "), }";
+  // pad with spaces so that preamble+dict is modulo 16 bytes. preamble is 10 bytes. dict needs to
+  // end with \n
+  int remainder = 16 - (10 + dict.size()) % 16;
+  dict.insert(dict.end(), remainder, ' ');
+  dict.back() = '\n';
+
+  std::vector<char> header;
+  header += (char)0x93;
+  header += "NUMPY";
+  header += (char)0x01;  // major version of numpy format
+  header += (char)0x00;  // minor version of numpy format
+  header += (uint16_t)dict.size();
+  header.insert(header.end(), dict.begin(), dict.end());
+
+  return header;
+}
+
+}  // namespace cnpy
+
+#endif
diff --git a/extern/mantaflow/helper/pwrapper/manta.h b/extern/mantaflow/helper/pwrapper/manta.h
new file mode 100644
index 00000000000..efbca6cc493
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/manta.h
@@ -0,0 +1,31 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Include pwrapper headers
+ *
+ ******************************************************************************/
+
+#ifndef _MANTA_H
+#define _MANTA_H
+
+// Remove preprocessor keywords, so there won't infere with autocompletion etc.
+#define KERNEL(...) extern int i, j, k, idx, X, Y, Z;
+#define PYTHON(...)
+#define returns(X) extern X;
+#define alias typedef
+
+#include "general.h"
+#include "vectorbase.h"
+#include "vector4d.h"
+#include "registry.h"
+#include "pclass.h"
+#include "pconvert.h"
+#include "fluidsolver.h"
+
+#endif
diff --git a/extern/mantaflow/helper/pwrapper/numpyWrap.cpp b/extern/mantaflow/helper/pwrapper/numpyWrap.cpp
new file mode 100644
index 00000000000..d2ddb21be70
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/numpyWrap.cpp
@@ -0,0 +1,132 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2017-2018 Steffen Wiewel, Moritz Becher, Rachel Chu
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Convert mantaflow grids to/from numpy arrays
+ *
+ ******************************************************************************/
+
+#include "manta.h"
+#include "pythonInclude.h"
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include "numpy/arrayobject.h"
+
+namespace Manta {
+
+#if PY_VERSION_HEX < 0x03000000
+PyMODINIT_FUNC initNumpy()
+{
+  import_array();
+}
+#endif
+
+// ------------------------------------------------------------------------
+// Class Functions
+// ------------------------------------------------------------------------
+PyArrayContainer::PyArrayContainer(void *_pParentPyArray) : pParentPyArray(_pParentPyArray)
+{
+  ExtractData(pParentPyArray);
+}
+// ------------------------------------------------------------------------
+PyArrayContainer::PyArrayContainer(const PyArrayContainer &_Other)
+    : pParentPyArray(_Other.pParentPyArray)
+{
+  ExtractData(pParentPyArray);
+  Py_INCREF(pParentPyArray);
+}
+// ------------------------------------------------------------------------
+PyArrayContainer::~PyArrayContainer()
+{
+  Py_DECREF(pParentPyArray);
+}
+// ------------------------------------------------------------------------
+PyArrayContainer &PyArrayContainer::operator=(const PyArrayContainer &_Other)
+{
+  if (this != &_Other) {
+    // DecRef the existing resource
+    Py_DECREF(pParentPyArray);
+
+    // Relink new data
+    pParentPyArray = _Other.pParentPyArray;
+    ExtractData(pParentPyArray);
+    Py_INCREF(pParentPyArray);
+  }
+  return *this;
+}
+// ------------------------------------------------------------------------
+void PyArrayContainer::ExtractData(void *_pParentPyArray)
+{
+  PyArrayObject *pParent = reinterpret_cast<PyArrayObject *>(pParentPyArray);
+
+  int numDims = PyArray_NDIM(pParent);
+  long *pDims = (long *)PyArray_DIMS(pParent);
+
+  pData = PyArray_DATA(pParent);
+  TotalSize = PyArray_SIZE(pParent);
+  Dims = std::vector<long>(&pDims[0], &pDims[numDims]);
+
+  int iDataType = PyArray_TYPE(pParent);
+  switch (iDataType) {
+    case NPY_FLOAT:
+      DataType = N_FLOAT;
+      break;
+    case NPY_DOUBLE:
+      DataType = N_DOUBLE;
+      break;
+    case NPY_INT:
+      DataType = N_INT;
+      break;
+    default:
+      errMsg("unknown type of Numpy array");
+      break;
+  }
+}
+
+// ------------------------------------------------------------------------
+// Conversion Functions
+// ------------------------------------------------------------------------
+
+template<> PyArrayContainer fromPy<PyArrayContainer>(PyObject *obj)
+{
+  if (PyArray_API == NULL) {
+    // python 3 uses the return value
+#if PY_VERSION_HEX >= 0x03000000
+    import_array();
+#else
+    initNumpy();
+#endif
+  }
+
+  if (!PyArray_Check(obj)) {
+    errMsg("argument is not an numpy array");
+  }
+
+  PyArrayObject *obj_p = reinterpret_cast<PyArrayObject *>(
+      PyArray_CheckFromAny(obj,
+                           NULL,
+                           0,
+                           0,
+                           /*NPY_ARRAY_ENSURECOPY*/ NPY_ARRAY_C_CONTIGUOUS |
+                               NPY_ARRAY_ENSUREARRAY | NPY_ARRAY_NOTSWAPPED,
+                           NULL));
+  PyArrayContainer container = PyArrayContainer(obj_p);
+
+  return container;
+}
+
+// template<> PyArrayContainer* fromPyPtr<PyArrayContainer>(PyObject* obj, std::vector<void*>* tmp)
+// {
+// 	if (!tmp) throw Error("dynamic de-ref not supported for this type");
+// 	void* ptr = malloc(sizeof(PyArrayContainer));
+// 	tmp->push_back(ptr);
+
+// 	*((PyArrayContainer*) ptr) = fromPy<PyArrayContainer>(obj);
+// 	return (PyArrayContainer*) ptr;
+// }
+}  // namespace Manta
diff --git a/extern/mantaflow/helper/pwrapper/numpyWrap.h b/extern/mantaflow/helper/pwrapper/numpyWrap.h
new file mode 100644
index 00000000000..c92a2eaaa97
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/numpyWrap.h
@@ -0,0 +1,86 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2017 Steffen Wiewel, Moritz Baecher, Rachel Chu
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Convert mantaflow grids to/from numpy arrays
+ *
+ ******************************************************************************/
+
+#ifdef _PCONVERT_H
+#  ifndef _NUMPYCONVERT_H
+#    define _NUMPYCONVERT_H
+
+enum NumpyTypes {
+  N_BOOL = 0,
+  N_BYTE,
+  N_UBYTE,
+  N_SHORT,
+  N_USHORT,
+  N_INT,
+  N_UINT,
+  N_LONG,
+  N_ULONG,
+  N_LONGLONG,
+  N_ULONGLONG,
+  N_FLOAT,
+  N_DOUBLE,
+  N_LONGDOUBLE,
+  N_CFLOAT,
+  N_CDOUBLE,
+  N_CLONGDOUBLE,
+  N_OBJECT = 17,
+  N_STRING,
+  N_UNICODE,
+  N_VOID,
+  /*
+   * New 1.6 types appended, may be integrated
+   * into the above in 2.0.
+   */
+  N_DATETIME,
+  N_TIMEDELTA,
+  N_HALF,
+
+  N_NTYPES,
+  N_NOTYPE,
+  N_CHAR,          /* special flag */
+  N_USERDEF = 256, /* leave room for characters */
+
+  /* The number of types not including the new 1.6 types */
+  N_NTYPES_ABI_COMPATIBLE = 21
+};
+
+namespace Manta {
+class PyArrayContainer {
+ public:
+  /// Constructors
+  PyArrayContainer(void *_pParentPyArray);
+  PyArrayContainer(const PyArrayContainer &_Other);
+  ~PyArrayContainer();
+  /// Operators
+  PyArrayContainer &operator=(const PyArrayContainer &_Other);
+
+ private:
+  void ExtractData(void *_pParentPyArray);
+
+ public:
+  void *pData;
+  NumpyTypes DataType;
+  unsigned int TotalSize;
+  std::vector<long> Dims;
+
+ private:
+  void *pParentPyArray;
+};
+
+// template<> PyArrayContainer* fromPyPtr<PyArrayContainer>(PyObject* obj, std::vector<void*>*
+// tmp);
+template<> PyArrayContainer fromPy<PyArrayContainer>(PyObject *obj);
+}  // namespace Manta
+
+#  endif
+#endif
diff --git a/extern/mantaflow/helper/pwrapper/pclass.cpp b/extern/mantaflow/helper/pwrapper/pclass.cpp
new file mode 100644
index 00000000000..a95254ebe11
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/pclass.cpp
@@ -0,0 +1,220 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Functions for property setting/getting via python
+ *
+ ******************************************************************************/
+
+#include "pythonInclude.h"
+#include "structmember.h"
+#include "manta.h"
+#include "general.h"
+#include "timing.h"
+
+#ifdef GUI
+#  include <QMutex>
+#else
+class QMutex {
+ public:
+  void lock(){};
+  void unlock(){};
+  bool tryLock()
+  {
+    return true;
+  };
+};
+#endif
+
+using namespace std;
+namespace Manta {
+
+//******************************************************************************
+// Free functions
+
+void pbPreparePlugin(FluidSolver *parent, const string &name, bool doTime)
+{
+  if (doTime)
+    TimingData::instance().start(parent, name);
+}
+
+void pbFinalizePlugin(FluidSolver *parent, const string &name, bool doTime)
+{
+  if (doTime)
+    TimingData::instance().stop(parent, name);
+
+  // GUI update, also print name of parent if there's more than one
+  std::ostringstream msg;
+  if (name != "FluidSolver::step") {
+    if (parent && (parent->getNumInstances() > 0))
+      msg << parent->getName() << string(".");
+    msg << name;
+  }
+  updateQtGui(false, 0, 0., msg.str());
+
+  debMsg(name << " done", 3);
+  // name unnamed PbClass Objects from var name
+  PbClass::renameObjects();
+}
+
+void pbSetError(const string &fn, const string &ex)
+{
+  debMsg("Error in " << fn, 1);
+  if (!ex.empty())
+    PyErr_SetString(PyExc_RuntimeError, ex.c_str());
+}
+
+//******************************************************************************
+// Helpers
+
+string PbTypeVec::str() const
+{
+  if (T.empty())
+    return "";
+  string s = "<";
+  for (int i = 0; i < (int)T.size(); i++) {
+    s += T[i].str();
+    s += (i != (int)T.size() - 1) ? ',' : '>';
+  }
+  return s;
+}
+string PbType::str() const
+{
+  if (S == "float")
+    return "Real";
+  if (S == "manta.vec3")
+    return "Vec3";
+  return S;
+}
+
+//******************************************************************************
+// PbClass
+
+vector<PbClass *> PbClass::mInstances;
+
+PbClass::PbClass(FluidSolver *parent, const string &name, PyObject *obj)
+    : mMutex(NULL), mParent(parent), mPyObject(obj), mName(name), mHidden(false)
+{
+  mMutex = new QMutex();
+}
+
+PbClass::PbClass(const PbClass &a)
+    : mMutex(NULL), mParent(a.mParent), mPyObject(0), mName("_unnamed"), mHidden(false)
+{
+  mMutex = new QMutex();
+}
+
+PbClass::~PbClass()
+{
+  for (vector<PbClass *>::iterator it = mInstances.begin(); it != mInstances.end(); ++it) {
+    if (*it == this) {
+      mInstances.erase(it);
+      break;
+    }
+  }
+  delete mMutex;
+}
+
+void PbClass::lock()
+{
+  mMutex->lock();
+}
+void PbClass::unlock()
+{
+  mMutex->unlock();
+}
+bool PbClass::tryLock()
+{
+  return mMutex->tryLock();
+}
+
+PbClass *PbClass::getInstance(int idx)
+{
+  if (idx < 0 || idx > (int)mInstances.size())
+    errMsg("PbClass::getInstance(): invalid index");
+  return mInstances[idx];
+}
+
+int PbClass::getNumInstances()
+{
+  return mInstances.size();
+}
+
+bool PbClass::isNullRef(PyObject *obj)
+{
+  return PyLong_Check(obj) && PyLong_AsDouble(obj) == 0;
+}
+
+bool PbClass::isNoneRef(PyObject *obj)
+{
+  return (obj == Py_None);
+}
+
+void PbClass::registerObject(PyObject *obj, PbArgs *args)
+{
+  // cross link
+  Pb::setReference(this, obj);
+  mPyObject = obj;
+
+  mInstances.push_back(this);
+
+  if (args) {
+    string _name = args->getOpt<std::string>("name", -1, "");
+    if (!_name.empty())
+      setName(_name);
+  }
+}
+
+PbClass *PbClass::createPyObject(const string &classname,
+                                 const string &name,
+                                 PbArgs &args,
+                                 PbClass *parent)
+{
+  return Pb::createPy(classname, name, args, parent);
+}
+
+void PbClass::checkParent()
+{
+  if (getParent() == NULL) {
+    errMsg("New class " + mName + ": no parent given -- specify using parent=xxx !");
+  }
+}
+//! Assign unnamed PbClass objects their Python variable name
+void PbClass::renameObjects()
+{
+  PyObject *sys_mod_dict = PyImport_GetModuleDict();
+  PyObject *loc_mod = PyMapping_GetItemString(sys_mod_dict, (char *)"__main__");
+  if (!loc_mod)
+    return;
+  PyObject *locdict = PyObject_GetAttrString(loc_mod, "__dict__");
+  if (!locdict)
+    return;
+
+  // iterate all PbClass instances
+  for (size_t i = 0; i < mInstances.size(); i++) {
+    PbClass *obj = mInstances[i];
+    if (obj->getName().empty()) {
+      // empty, try to find instance in module local dictionary
+
+      PyObject *lkey, *lvalue;
+      Py_ssize_t lpos = 0;
+      while (PyDict_Next(locdict, &lpos, &lkey, &lvalue)) {
+        if (lvalue == obj->mPyObject) {
+          string varName = fromPy<string>(PyObject_Str(lkey));
+          obj->setName(varName);
+          // cout << "assigning variable name '" << varName << "' to unnamed instance" << endl;
+          break;
+        }
+      }
+    }
+  }
+  Py_DECREF(locdict);
+  Py_DECREF(loc_mod);
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/helper/pwrapper/pclass.h b/extern/mantaflow/helper/pwrapper/pclass.h
new file mode 100644
index 00000000000..b34103ca9a7
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/pclass.h
@@ -0,0 +1,126 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Base class for all Python-exposed classes
+ *
+ ******************************************************************************/
+
+// -----------------------------------------------------------------
+// NOTE:
+// Do not include this file in user code, include "manta.h" instead
+// -----------------------------------------------------------------
+
+#ifdef _MANTA_H
+#  ifndef _PTYPE_H
+#    define _PTYPE_H
+
+#    include <string>
+#    include <vector>
+#    include <map>
+
+class QMutex;
+
+namespace Manta {
+struct PbClassData;
+class FluidSolver;
+class PbArgs;
+
+struct PbType {
+  std::string S;
+  std::string str() const;
+};
+struct PbTypeVec {
+  std::vector<PbType> T;
+  std::string str() const;
+};
+
+//! Base class for all classes exposed to Python
+class PbClass {
+ public:
+  PbClass(FluidSolver *parent, const std::string &name = "", PyObject *obj = NULL);
+  PbClass(const PbClass &a);
+  virtual ~PbClass();
+
+  // basic property setter/getters
+  void setName(const std::string &name)
+  {
+    mName = name;
+  }
+  std::string getName() const
+  {
+    return mName;
+  }
+  PyObject *getPyObject() const
+  {
+    return mPyObject;
+  }
+  void registerObject(PyObject *obj, PbArgs *args);
+  FluidSolver *getParent() const
+  {
+    return mParent;
+  }
+  void setParent(FluidSolver *v)
+  {
+    mParent = v;
+  }
+  void checkParent();
+
+  // hidden flag for GUI, debug output
+  inline bool isHidden()
+  {
+    return mHidden;
+  }
+  inline void setHidden(bool v)
+  {
+    mHidden = v;
+  }
+
+  void lock();
+  void unlock();
+  bool tryLock();
+
+  // PbClass instance registry
+  static int getNumInstances();
+  static PbClass *getInstance(int index);
+  static void renameObjects();
+
+  // converters
+  static bool isNullRef(PyObject *o);
+  static bool isNoneRef(PyObject *o);
+  static PbClass *createPyObject(const std::string &classname,
+                                 const std::string &name,
+                                 PbArgs &args,
+                                 PbClass *parent);
+  inline bool canConvertTo(const std::string &classname)
+  {
+    return Pb::canConvert(mPyObject, classname);
+  }
+
+ protected:
+  QMutex *mMutex;
+  FluidSolver *mParent;
+  PyObject *mPyObject;
+  std::string mName;
+  bool mHidden;
+
+  static std::vector<PbClass *> mInstances;
+};
+
+//!\cond Register
+
+void pbFinalizePlugin(FluidSolver *parent, const std::string &name, bool doTime = true);
+void pbPreparePlugin(FluidSolver *parent, const std::string &name, bool doTime = true);
+void pbSetError(const std::string &fn, const std::string &ex);
+
+//!\endcond
+
+}  // namespace Manta
+
+#  endif
+#endif
diff --git a/extern/mantaflow/helper/pwrapper/pconvert.cpp b/extern/mantaflow/helper/pwrapper/pconvert.cpp
new file mode 100644
index 00000000000..c8c92cbf585
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/pconvert.cpp
@@ -0,0 +1,568 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Python argument wrappers and conversion tools
+ *
+ ******************************************************************************/
+
+#include "pythonInclude.h"
+#include <sstream>
+#include <algorithm>
+#include "vectorbase.h"
+#include "manta.h"
+
+using namespace std;
+
+//******************************************************************************
+// Explicit definition and instantiation of python object converters
+
+namespace Manta {
+
+extern PyTypeObject PbVec3Type;
+extern PyTypeObject PbVec4Type;
+
+struct PbVec3 {
+  PyObject_HEAD float data[3];
+};
+
+struct PbVec4 {
+  PyObject_HEAD float data[4];
+};
+
+PyObject *getPyNone()
+{
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+PyObject *incref(PyObject *obj)
+{
+  Py_INCREF(obj);
+  return obj;
+}
+
+/*template<> PyObject* toPy<PyObject*>(PyObject* obj) {
+  return obj;
+}*/
+template<> PyObject *toPy<int>(const int &v)
+{
+  return PyLong_FromLong(v);
+}
+/*template<> PyObject* toPy<char*>(const (char*) & val) {
+  return PyUnicode_DecodeLatin1(val,strlen(val),"replace");
+}*/
+template<> PyObject *toPy<string>(const string &val)
+{
+  return PyUnicode_DecodeLatin1(val.c_str(), val.length(), "replace");
+}
+template<> PyObject *toPy<float>(const float &v)
+{
+  return PyFloat_FromDouble(v);
+}
+template<> PyObject *toPy<double>(const double &v)
+{
+  return PyFloat_FromDouble(v);
+}
+template<> PyObject *toPy<bool>(const bool &v)
+{
+  return PyBool_FromLong(v);
+}
+template<> PyObject *toPy<Vec3i>(const Vec3i &v)
+{
+  float x = (float)v.x, y = (float)v.y, z = (float)v.z;
+  return PyObject_CallFunction((PyObject *)&PbVec3Type, (char *)"fff", x, y, z);
+}
+template<> PyObject *toPy<Vec3>(const Vec3 &v)
+{
+  float x = (float)v.x, y = (float)v.y, z = (float)v.z;
+  return PyObject_CallFunction((PyObject *)&PbVec3Type, (char *)"fff", x, y, z);
+}
+template<> PyObject *toPy<Vec4i>(const Vec4i &v)
+{
+  float x = (float)v.x, y = (float)v.y, z = (float)v.z;
+  return PyObject_CallFunction((PyObject *)&PbVec4Type, (char *)"ffff", x, y, z);
+}
+template<> PyObject *toPy<Vec4>(const Vec4 &v)
+{
+  float x = (float)v.x, y = (float)v.y, z = (float)v.z;
+  return PyObject_CallFunction((PyObject *)&PbVec4Type, (char *)"ffff", x, y, z);
+}
+template<> PyObject *toPy<PbClass *>(const PbClass_Ptr &obj)
+{
+  return obj->getPyObject();
+}
+
+template<> float fromPy<float>(PyObject *obj)
+{
+#if PY_MAJOR_VERSION <= 2
+  if (PyInt_Check(obj))
+    return PyInt_AsLong(obj);
+#endif
+  if (PyFloat_Check(obj))
+    return PyFloat_AsDouble(obj);
+  if (PyLong_Check(obj))
+    return PyLong_AsDouble(obj);
+  errMsg("argument is not a float");
+}
+template<> double fromPy<double>(PyObject *obj)
+{
+#if PY_MAJOR_VERSION <= 2
+  if (PyInt_Check(obj))
+    return PyInt_AsLong(obj);
+#endif
+  if (PyFloat_Check(obj))
+    return PyFloat_AsDouble(obj);
+  if (PyLong_Check(obj))
+    return PyLong_AsDouble(obj);
+  errMsg("argument is not a double");
+}
+template<> PyObject *fromPy<PyObject *>(PyObject *obj)
+{
+  return obj;
+}
+template<> int fromPy<int>(PyObject *obj)
+{
+#if PY_MAJOR_VERSION <= 2
+  if (PyInt_Check(obj))
+    return PyInt_AsLong(obj);
+#endif
+  if (PyLong_Check(obj))
+    return PyLong_AsDouble(obj);
+  if (PyFloat_Check(obj)) {
+    double a = PyFloat_AsDouble(obj);
+    if (fabs(a - floor(a + 0.5)) > 1e-5)
+      errMsg("argument is not an int");
+    return (int)(a + 0.5);
+  }
+  errMsg("argument is not an int");
+}
+template<> string fromPy<string>(PyObject *obj)
+{
+  if (PyUnicode_Check(obj))
+    return PyBytes_AsString(PyUnicode_AsLatin1String(obj));
+#if PY_MAJOR_VERSION <= 2
+  else if (PyString_Check(obj))
+    return PyString_AsString(obj);
+#endif
+  else
+    errMsg("argument is not a string");
+}
+template<> const char *fromPy<const char *>(PyObject *obj)
+{
+  if (PyUnicode_Check(obj))
+    return PyBytes_AsString(PyUnicode_AsLatin1String(obj));
+#if PY_MAJOR_VERSION <= 2
+  else if (PyString_Check(obj))
+    return PyString_AsString(obj);
+#endif
+  else
+    errMsg("argument is not a string");
+}
+template<> bool fromPy<bool>(PyObject *obj)
+{
+  if (!PyBool_Check(obj))
+    errMsg("argument is not a boolean");
+  return PyLong_AsLong(obj) != 0;
+}
+template<> Vec3 fromPy<Vec3>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec3Type)) {
+    return Vec3(((PbVec3 *)obj)->data);
+  }
+  else if (PyTuple_Check(obj) && PyTuple_Size(obj) == 3) {
+    return Vec3(fromPy<Real>(PyTuple_GetItem(obj, 0)),
+                fromPy<Real>(PyTuple_GetItem(obj, 1)),
+                fromPy<Real>(PyTuple_GetItem(obj, 2)));
+  }
+  errMsg("argument is not a Vec3");
+}
+template<> Vec3i fromPy<Vec3i>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec3Type)) {
+    return toVec3iChecked(((PbVec3 *)obj)->data);
+  }
+  else if (PyTuple_Check(obj) && PyTuple_Size(obj) == 3) {
+    return Vec3i(fromPy<int>(PyTuple_GetItem(obj, 0)),
+                 fromPy<int>(PyTuple_GetItem(obj, 1)),
+                 fromPy<int>(PyTuple_GetItem(obj, 2)));
+  }
+  errMsg("argument is not a Vec3i");
+}
+template<> Vec4 fromPy<Vec4>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec4Type)) {
+    return Vec4(((PbVec4 *)obj)->data);
+  }
+  else if (PyTuple_Check(obj) && PyTuple_Size(obj) == 4) {
+    return Vec4(fromPy<Real>(PyTuple_GetItem(obj, 0)),
+                fromPy<Real>(PyTuple_GetItem(obj, 1)),
+                fromPy<Real>(PyTuple_GetItem(obj, 2)),
+                fromPy<Real>(PyTuple_GetItem(obj, 3)));
+  }
+  errMsg("argument is not a Vec4");
+}
+template<> Vec4i fromPy<Vec4i>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec4Type)) {
+    return toVec4i(((PbVec4 *)obj)->data);
+  }
+  else if (PyTuple_Check(obj) && PyTuple_Size(obj) == 4) {
+    return Vec4i(fromPy<int>(PyTuple_GetItem(obj, 0)),
+                 fromPy<int>(PyTuple_GetItem(obj, 1)),
+                 fromPy<int>(PyTuple_GetItem(obj, 2)),
+                 fromPy<int>(PyTuple_GetItem(obj, 3)));
+  }
+  errMsg("argument is not a Vec4i");
+}
+template<> PbType fromPy<PbType>(PyObject *obj)
+{
+  PbType pb = {""};
+  if (!PyType_Check(obj))
+    return pb;
+
+  const char *tname = ((PyTypeObject *)obj)->tp_name;
+  pb.S = tname;
+  return pb;
+}
+template<> PbTypeVec fromPy<PbTypeVec>(PyObject *obj)
+{
+  PbTypeVec vec;
+  if (PyType_Check(obj)) {
+    vec.T.push_back(fromPy<PbType>(obj));
+  }
+  else if (PyTuple_Check(obj)) {
+    int sz = PyTuple_Size(obj);
+    for (int i = 0; i < sz; i++)
+      vec.T.push_back(fromPy<PbType>(PyTuple_GetItem(obj, i)));
+  }
+  else
+    errMsg("argument is not a type tuple");
+  return vec;
+}
+
+template<class T> T *tmpAlloc(PyObject *obj, std::vector<void *> *tmp)
+{
+  if (!tmp)
+    throw Error("dynamic de-ref not supported for this type");
+  void *ptr = malloc(sizeof(T));
+  tmp->push_back(ptr);
+
+  *((T *)ptr) = fromPy<T>(obj);
+  return (T *)ptr;
+}
+template<> float *fromPyPtr<float>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<float>(obj, tmp);
+}
+template<> double *fromPyPtr<double>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<double>(obj, tmp);
+}
+template<> int *fromPyPtr<int>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<int>(obj, tmp);
+}
+template<> std::string *fromPyPtr<std::string>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<std::string>(obj, tmp);
+}
+template<> bool *fromPyPtr<bool>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<bool>(obj, tmp);
+}
+template<> Vec3 *fromPyPtr<Vec3>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<Vec3>(obj, tmp);
+}
+template<> Vec3i *fromPyPtr<Vec3i>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<Vec3i>(obj, tmp);
+}
+template<> Vec4 *fromPyPtr<Vec4>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<Vec4>(obj, tmp);
+}
+template<> Vec4i *fromPyPtr<Vec4i>(PyObject *obj, std::vector<void *> *tmp)
+{
+  return tmpAlloc<Vec4i>(obj, tmp);
+}
+
+template<> bool isPy<float>(PyObject *obj)
+{
+#if PY_MAJOR_VERSION <= 2
+  if (PyInt_Check(obj))
+    return true;
+#endif
+  return PyFloat_Check(obj) || PyLong_Check(obj);
+}
+template<> bool isPy<double>(PyObject *obj)
+{
+#if PY_MAJOR_VERSION <= 2
+  if (PyInt_Check(obj))
+    return true;
+#endif
+  return PyFloat_Check(obj) || PyLong_Check(obj);
+}
+template<> bool isPy<PyObject *>(PyObject *obj)
+{
+  return true;
+}
+template<> bool isPy<int>(PyObject *obj)
+{
+#if PY_MAJOR_VERSION <= 2
+  if (PyInt_Check(obj))
+    return true;
+#endif
+  if (PyLong_Check(obj))
+    return true;
+  if (PyFloat_Check(obj)) {
+    double a = PyFloat_AsDouble(obj);
+    return fabs(a - floor(a + 0.5)) < 1e-5;
+  }
+  return false;
+}
+template<> bool isPy<string>(PyObject *obj)
+{
+  if (PyUnicode_Check(obj))
+    return true;
+#if PY_MAJOR_VERSION <= 2
+  if (PyString_Check(obj))
+    return true;
+#endif
+  return false;
+}
+template<> bool isPy<const char *>(PyObject *obj)
+{
+  if (PyUnicode_Check(obj))
+    return true;
+#if PY_MAJOR_VERSION <= 2
+  if (PyString_Check(obj))
+    return true;
+#endif
+  return false;
+}
+template<> bool isPy<bool>(PyObject *obj)
+{
+  return PyBool_Check(obj);
+}
+template<> bool isPy<Vec3>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec3Type))
+    return true;
+  if (PyTuple_Check(obj) && PyTuple_Size(obj) == 3) {
+    return isPy<Real>(PyTuple_GetItem(obj, 0)) && isPy<Real>(PyTuple_GetItem(obj, 1)) &&
+           isPy<Real>(PyTuple_GetItem(obj, 2));
+  }
+  return false;
+}
+template<> bool isPy<Vec3i>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec3Type))
+    return true;
+  if (PyTuple_Check(obj) && PyTuple_Size(obj) == 3) {
+    return isPy<int>(PyTuple_GetItem(obj, 0)) && isPy<int>(PyTuple_GetItem(obj, 1)) &&
+           isPy<int>(PyTuple_GetItem(obj, 2));
+  }
+  return false;
+}
+template<> bool isPy<Vec4>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec4Type))
+    return true;
+  if (PyTuple_Check(obj) && PyTuple_Size(obj) == 4) {
+    return isPy<Real>(PyTuple_GetItem(obj, 0)) && isPy<Real>(PyTuple_GetItem(obj, 1)) &&
+           isPy<Real>(PyTuple_GetItem(obj, 2)) && isPy<Real>(PyTuple_GetItem(obj, 3));
+  }
+  return false;
+}
+template<> bool isPy<Vec4i>(PyObject *obj)
+{
+  if (PyObject_IsInstance(obj, (PyObject *)&PbVec4Type))
+    return true;
+  if (PyTuple_Check(obj) && PyTuple_Size(obj) == 4) {
+    return isPy<int>(PyTuple_GetItem(obj, 0)) && isPy<int>(PyTuple_GetItem(obj, 1)) &&
+           isPy<int>(PyTuple_GetItem(obj, 2)) && isPy<int>(PyTuple_GetItem(obj, 3));
+  }
+  return false;
+}
+template<> bool isPy<PbType>(PyObject *obj)
+{
+  return PyType_Check(obj);
+}
+
+//******************************************************************************
+// PbArgs class defs
+
+PbArgs PbArgs::EMPTY(NULL, NULL);
+
+PbArgs::PbArgs(PyObject *linarg, PyObject *dict) : mLinArgs(0), mKwds(0)
+{
+  setup(linarg, dict);
+}
+PbArgs::~PbArgs()
+{
+  for (int i = 0; i < (int)mTmpStorage.size(); i++)
+    free(mTmpStorage[i]);
+  mTmpStorage.clear();
+}
+
+void PbArgs::copy(PbArgs &a)
+{
+  mKwds = a.mKwds;
+  mData = a.mData;
+  mLinData = a.mLinData;
+  mLinArgs = a.mLinArgs;
+}
+void PbArgs::clear()
+{
+  mLinArgs = 0;
+  mKwds = 0;
+  mData.clear();
+  mLinData.clear();
+}
+
+PbArgs &PbArgs::operator=(const PbArgs &a)
+{
+  //    mLinArgs = 0;
+  //    mKwds = 0;
+  return *this;
+}
+
+void PbArgs::setup(PyObject *linarg, PyObject *dict)
+{
+  if (dict) {
+    PyObject *key, *value;
+    Py_ssize_t pos = 0;
+    while (PyDict_Next(dict, &pos, &key, &value)) {
+      DataElement el;
+      el.obj = value;
+      el.visited = false;
+      mData[fromPy<string>(key)] = el;
+    }
+    mKwds = dict;
+  }
+  if (linarg) {
+    size_t len = PyTuple_Size(linarg);
+    for (size_t i = 0; i < len; i++) {
+      DataElement el;
+      el.obj = PyTuple_GetItem(linarg, i);
+      el.visited = false;
+      mLinData.push_back(el);
+    }
+    mLinArgs = linarg;
+  }
+}
+
+void PbArgs::addLinArg(PyObject *obj)
+{
+  DataElement el = {obj, false};
+  mLinData.push_back(el);
+}
+
+void PbArgs::check()
+{
+  if (has("nocheck"))
+    return;
+
+  for (map<string, DataElement>::iterator it = mData.begin(); it != mData.end(); it++) {
+    if (!it->second.visited)
+      errMsg("Argument '" + it->first + "' unknown");
+  }
+  for (size_t i = 0; i < mLinData.size(); i++) {
+    if (!mLinData[i].visited) {
+      stringstream s;
+      s << "Function does not read argument number #" << i;
+      errMsg(s.str());
+    }
+  }
+}
+
+FluidSolver *PbArgs::obtainParent()
+{
+  FluidSolver *solver = getPtrOpt<FluidSolver>("solver", -1, NULL);
+  if (solver != 0)
+    return solver;
+
+  for (map<string, DataElement>::iterator it = mData.begin(); it != mData.end(); it++) {
+    PbClass *obj = Pb::objFromPy(it->second.obj);
+
+    if (obj) {
+      if (solver == NULL)
+        solver = obj->getParent();
+    }
+  }
+  for (vector<DataElement>::iterator it = mLinData.begin(); it != mLinData.end(); it++) {
+    PbClass *obj = Pb::objFromPy(it->obj);
+
+    if (obj) {
+      if (solver == NULL)
+        solver = obj->getParent();
+    }
+  }
+
+  return solver;
+}
+
+void PbArgs::visit(int number, const string &key)
+{
+  if (number >= 0 && number < (int)mLinData.size())
+    mLinData[number].visited = true;
+  map<string, DataElement>::iterator lu = mData.find(key);
+  if (lu != mData.end())
+    lu->second.visited = true;
+}
+
+PyObject *PbArgs::getItem(const std::string &key, bool strict, ArgLocker *lk)
+{
+  map<string, DataElement>::iterator lu = mData.find(key);
+  if (lu == mData.end()) {
+    if (strict)
+      errMsg("Argument '" + key + "' is not defined.");
+    return NULL;
+  }
+  PbClass *pbo = Pb::objFromPy(lu->second.obj);
+  // try to lock
+  if (pbo && lk)
+    lk->add(pbo);
+  return lu->second.obj;
+}
+
+PyObject *PbArgs::getItem(size_t number, bool strict, ArgLocker *lk)
+{
+  if (number >= mLinData.size()) {
+    if (!strict)
+      return NULL;
+    stringstream s;
+    s << "Argument number #" << number << " not specified.";
+    errMsg(s.str());
+  }
+  PbClass *pbo = Pb::objFromPy(mLinData[number].obj);
+  // try to lock
+  if (pbo && lk)
+    lk->add(pbo);
+  return mLinData[number].obj;
+}
+
+//******************************************************************************
+// ArgLocker class defs
+
+void ArgLocker::add(PbClass *p)
+{
+  if (find(locks.begin(), locks.end(), p) == locks.end()) {
+    locks.push_back(p);
+    p->lock();
+  }
+}
+ArgLocker::~ArgLocker()
+{
+  for (size_t i = 0; i < locks.size(); i++)
+    locks[i]->unlock();
+  locks.clear();
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/helper/pwrapper/pconvert.h b/extern/mantaflow/helper/pwrapper/pconvert.h
new file mode 100644
index 00000000000..9c72b8b57b9
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/pconvert.h
@@ -0,0 +1,251 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Python argument wrappers and conversion tools
+ *
+ ******************************************************************************/
+
+// -----------------------------------------------------------------
+// NOTE:
+// Do not include this file in user code, include "manta.h" instead
+// -----------------------------------------------------------------
+
+#ifdef _MANTA_H
+#  ifndef _PCONVERT_H
+#    define _PCONVERT_H
+
+#    include <string>
+#    include <map>
+#    include <vector>
+
+namespace Manta {
+template<class T> class Grid;
+
+//! Locks the given PbClass Arguments until ArgLocker goes out of scope
+struct ArgLocker {
+  void add(PbClass *p);
+  ~ArgLocker();
+  std::vector<PbClass *> locks;
+};
+
+PyObject *getPyNone();
+
+// for PbClass-derived classes
+template<class T> T *fromPyPtr(PyObject *obj, std::vector<void *> *tmp)
+{
+  if (PbClass::isNullRef(obj) || PbClass::isNoneRef(obj))
+    return 0;
+  PbClass *pbo = Pb::objFromPy(obj);
+  const std::string &type = Namify<T>::S;
+  if (!pbo || !(pbo->canConvertTo(type)))
+    throw Error("can't convert argument to " + type + "*");
+  return (T *)(pbo);
+}
+
+template<> float *fromPyPtr<float>(PyObject *obj, std::vector<void *> *tmp);
+template<> double *fromPyPtr<double>(PyObject *obj, std::vector<void *> *tmp);
+template<> int *fromPyPtr<int>(PyObject *obj, std::vector<void *> *tmp);
+template<> std::string *fromPyPtr<std::string>(PyObject *obj, std::vector<void *> *tmp);
+template<> bool *fromPyPtr<bool>(PyObject *obj, std::vector<void *> *tmp);
+template<> Vec3 *fromPyPtr<Vec3>(PyObject *obj, std::vector<void *> *tmp);
+template<> Vec3i *fromPyPtr<Vec3i>(PyObject *obj, std::vector<void *> *tmp);
+template<> Vec4 *fromPyPtr<Vec4>(PyObject *obj, std::vector<void *> *tmp);
+template<> Vec4i *fromPyPtr<Vec4i>(PyObject *obj, std::vector<void *> *tmp);
+
+PyObject *incref(PyObject *obj);
+template<class T> PyObject *toPy(const T &v)
+{
+  PyObject *obj = v.getPyObject();
+  if (obj) {
+    return incref(obj);
+  }
+  T *co = new T(v);
+  const std::string &type = Namify<typename remove_pointers<T>::type>::S;
+  return Pb::copyObject(co, type);
+}
+template<class T> bool isPy(PyObject *obj)
+{
+  if (PbClass::isNullRef(obj) || PbClass::isNoneRef(obj))
+    return false;
+  PbClass *pbo = Pb::objFromPy(obj);
+  const std::string &type = Namify<typename remove_pointers<T>::type>::S;
+  return pbo && pbo->canConvertTo(type);
+}
+
+template<class T> T fromPy(PyObject *obj)
+{
+  throw Error(
+      "Unknown type conversion. Did you pass a PbClass by value? Instead always pass "
+      "grids/particlesystems/etc. by reference or using a pointer.");
+}
+
+// builtin types
+template<> float fromPy<float>(PyObject *obj);
+template<> double fromPy<double>(PyObject *obj);
+template<> int fromPy<int>(PyObject *obj);
+template<> PyObject *fromPy<PyObject *>(PyObject *obj);
+template<> std::string fromPy<std::string>(PyObject *obj);
+template<> const char *fromPy<const char *>(PyObject *obj);
+template<> bool fromPy<bool>(PyObject *obj);
+template<> Vec3 fromPy<Vec3>(PyObject *obj);
+template<> Vec3i fromPy<Vec3i>(PyObject *obj);
+template<> Vec4 fromPy<Vec4>(PyObject *obj);
+template<> Vec4i fromPy<Vec4i>(PyObject *obj);
+template<> PbType fromPy<PbType>(PyObject *obj);
+template<> PbTypeVec fromPy<PbTypeVec>(PyObject *obj);
+
+template<> PyObject *toPy<int>(const int &v);
+template<> PyObject *toPy<std::string>(const std::string &val);
+template<> PyObject *toPy<float>(const float &v);
+template<> PyObject *toPy<double>(const double &v);
+template<> PyObject *toPy<bool>(const bool &v);
+template<> PyObject *toPy<Vec3i>(const Vec3i &v);
+template<> PyObject *toPy<Vec3>(const Vec3 &v);
+template<> PyObject *toPy<Vec4i>(const Vec4i &v);
+template<> PyObject *toPy<Vec4>(const Vec4 &v);
+typedef PbClass *PbClass_Ptr;
+template<> PyObject *toPy<PbClass *>(const PbClass_Ptr &obj);
+
+template<> bool isPy<float>(PyObject *obj);
+template<> bool isPy<double>(PyObject *obj);
+template<> bool isPy<int>(PyObject *obj);
+template<> bool isPy<PyObject *>(PyObject *obj);
+template<> bool isPy<std::string>(PyObject *obj);
+template<> bool isPy<const char *>(PyObject *obj);
+template<> bool isPy<bool>(PyObject *obj);
+template<> bool isPy<Vec3>(PyObject *obj);
+template<> bool isPy<Vec3i>(PyObject *obj);
+template<> bool isPy<Vec4>(PyObject *obj);
+template<> bool isPy<Vec4i>(PyObject *obj);
+template<> bool isPy<PbType>(PyObject *obj);
+
+//! Encapsulation of python arguments
+class PbArgs {
+ public:
+  PbArgs(PyObject *linargs = NULL, PyObject *dict = NULL);
+  ~PbArgs();
+  void setup(PyObject *linargs = NULL, PyObject *dict = NULL);
+
+  void check();
+  FluidSolver *obtainParent();
+
+  inline int numLinArgs()
+  {
+    return mLinData.size();
+  }
+
+  inline bool has(const std::string &key)
+  {
+    return getItem(key, false) != NULL;
+  }
+  inline void deleteItem(const std::string &key)
+  {
+    if (mData.find(key) != mData.end())
+      mData.erase(mData.find(key));
+  }
+
+  inline PyObject *linArgs()
+  {
+    return mLinArgs;
+  }
+  inline PyObject *kwds()
+  {
+    return mKwds;
+  }
+
+  void addLinArg(PyObject *obj);
+
+  template<class T> inline void add(const std::string &key, T arg)
+  {
+    DataElement el = {toPy(arg), false};
+    mData[key] = el;
+  }
+  template<class T> inline T get(const std::string &key, int number = -1, ArgLocker *lk = NULL)
+  {
+    visit(number, key);
+    PyObject *o = getItem(key, false, lk);
+    if (o)
+      return fromPy<T>(o);
+    o = getItem(number, false, lk);
+    if (o)
+      return fromPy<T>(o);
+    errMsg("Argument '" + key + "' is not defined.");
+  }
+  template<class T>
+  inline T getOpt(const std::string &key, int number, T defarg, ArgLocker *lk = NULL)
+  {
+    visit(number, key);
+    PyObject *o = getItem(key, false, lk);
+    if (o)
+      return fromPy<T>(o);
+    if (number >= 0)
+      o = getItem(number, false, lk);
+    return (o) ? fromPy<T>(o) : defarg;
+  }
+  template<class T>
+  inline T *getPtrOpt(const std::string &key, int number, T *defarg, ArgLocker *lk = NULL)
+  {
+    visit(number, key);
+    PyObject *o = getItem(key, false, lk);
+    if (o)
+      return fromPyPtr<T>(o, &mTmpStorage);
+    if (number >= 0)
+      o = getItem(number, false, lk);
+    return o ? fromPyPtr<T>(o, &mTmpStorage) : defarg;
+  }
+  template<class T> inline T *getPtr(const std::string &key, int number = -1, ArgLocker *lk = NULL)
+  {
+    visit(number, key);
+    PyObject *o = getItem(key, false, lk);
+    if (o)
+      return fromPyPtr<T>(o, &mTmpStorage);
+    o = getItem(number, false, lk);
+    if (o)
+      return fromPyPtr<T>(o, &mTmpStorage);
+    errMsg("Argument '" + key + "' is not defined.");
+  }
+
+  // automatic template type deduction
+  template<class T> bool typeCheck(int num, const std::string &name)
+  {
+    PyObject *o = getItem(name, false, 0);
+    if (!o)
+      o = getItem(num, false, 0);
+    return o ? isPy<typename remove_pointers<T>::type>(o) : false;
+  }
+
+  PbArgs &operator=(const PbArgs &a);  // dummy
+  void copy(PbArgs &a);
+  void clear();
+  void visit(int num, const std::string &key);
+
+  static PbArgs EMPTY;
+
+ protected:
+  PyObject *getItem(const std::string &key, bool strict, ArgLocker *lk = NULL);
+  PyObject *getItem(size_t number, bool strict, ArgLocker *lk = NULL);
+
+  struct DataElement {
+    PyObject *obj;
+    bool visited;
+  };
+  std::map<std::string, DataElement> mData;
+  std::vector<DataElement> mLinData;
+  PyObject *mLinArgs, *mKwds;
+  std::vector<void *> mTmpStorage;
+};
+
+}  // namespace Manta
+
+#    if NUMPY == 1
+#      include "numpyWrap.h"
+#    endif
+
+#  endif
+#endif
diff --git a/extern/mantaflow/helper/pwrapper/pvec3.cpp b/extern/mantaflow/helper/pwrapper/pvec3.cpp
new file mode 100644
index 00000000000..69bde2a2ad0
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/pvec3.cpp
@@ -0,0 +1,414 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Vec3 class extension for python
+ *
+ ******************************************************************************/
+
+#include "pythonInclude.h"
+#include <string>
+#include <sstream>
+#include "vectorbase.h"
+#include "structmember.h"
+#include "manta.h"
+
+using namespace std;
+
+namespace Manta {
+
+extern PyTypeObject PbVec3Type;
+
+struct PbVec3 {
+  PyObject_HEAD float data[3];
+};
+
+static void PbVec3Dealloc(PbVec3 *self)
+{
+  Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *PbVec3New(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+  return type->tp_alloc(type, 0);
+}
+
+static int PbVec3Init(PbVec3 *self, PyObject *args, PyObject *kwds)
+{
+
+  float x1 = numeric_limits<float>::quiet_NaN(), x2 = x1, x3 = x1;
+  if (!PyArg_ParseTuple(args, "|fff", &x1, &x2, &x3))
+    return -1;
+
+  if (!c_isnan(x1)) {
+    self->data[0] = x1;
+    if (!c_isnan(x2) && !c_isnan(x3)) {
+      self->data[1] = x2;
+      self->data[2] = x3;
+    }
+    else {
+      if (!c_isnan(x2) || !c_isnan(x3)) {
+        errMsg("Invalid partial init of vec3");
+      }
+      self->data[1] = x1;
+      self->data[2] = x1;
+    }
+  }
+  else {
+    self->data[0] = 0;
+    self->data[1] = 0;
+    self->data[2] = 0;
+  }
+  return 0;
+}
+
+static PyObject *PbVec3Repr(PbVec3 *self)
+{
+  Manta::Vec3 v(self->data[0], self->data[1], self->data[2]);
+  return PyUnicode_FromFormat(v.toString().c_str());
+}
+
+static PyMemberDef PbVec3Members[] = {
+    {(char *)"x", T_FLOAT, offsetof(PbVec3, data), 0, (char *)"X"},
+    {(char *)"y", T_FLOAT, offsetof(PbVec3, data) + sizeof(float), 0, (char *)"Y"},
+    {(char *)"z", T_FLOAT, offsetof(PbVec3, data) + sizeof(float) * 2, 0, (char *)"Z"},
+    {NULL}  // Sentinel
+};
+
+static PyMethodDef PbVec3Methods[] = {
+    //{"name", (PyCFunction)Noddy_name, METH_NOARGS, "Return the name, combining the first and last
+    //name" },
+    {NULL}  // Sentinel
+};
+
+// operator overloads
+
+inline PyObject *PbNew(const Vec3 &a)
+{
+  PbVec3 *obj = (PbVec3 *)PbVec3New(&PbVec3Type, 0, 0);
+  obj->data[0] = a.x;
+  obj->data[1] = a.y;
+  obj->data[2] = a.z;
+  return (PyObject *)obj;
+}
+
+#define CONVERTVEC(obj) \
+  Vec3 v##obj; \
+  if (PyObject_TypeCheck(obj, &PbVec3Type)) \
+    v##obj = Vec3(&(((PbVec3 *)obj)->data[0])); \
+  else if (PyFloat_Check(obj)) \
+    v##obj = Vec3(PyFloat_AsDouble(obj)); \
+  else if (PyLong_Check(obj)) \
+    v##obj = Vec3(PyLong_AsDouble(obj)); \
+  else { \
+    Py_INCREF(Py_NotImplemented); \
+    return Py_NotImplemented; \
+  }
+
+#define OPHEADER \
+  if (!PyObject_TypeCheck(a, &PbVec3Type) && !PyObject_TypeCheck(b, &PbVec3Type)) { \
+    Py_INCREF(Py_NotImplemented); \
+    return Py_NotImplemented; \
+  } \
+  CONVERTVEC(a) \
+  CONVERTVEC(b)
+
+#define OPHEADER1 \
+  if (!PyObject_TypeCheck(a, &PbVec3Type)) { \
+    Py_INCREF(Py_NotImplemented); \
+    return Py_NotImplemented; \
+  } \
+  CONVERTVEC(a)
+
+PyObject *PbVec3Add(PyObject *a, PyObject *b)
+{
+  OPHEADER
+  return PbNew(va + vb);
+}
+
+PyObject *PbVec3Sub(PyObject *a, PyObject *b)
+{
+  OPHEADER
+  return PbNew(va - vb);
+}
+
+PyObject *PbVec3Mult(PyObject *a, PyObject *b)
+{
+  OPHEADER
+  return PbNew(va * vb);
+}
+
+PyObject *PbVec3Div(PyObject *a, PyObject *b)
+{
+  OPHEADER
+  return PbNew(va / vb);
+}
+
+PyObject *PbVec3Negative(PyObject *a)
+{
+  OPHEADER1
+  return PbNew(-va);
+}
+
+// numbers are defined subtely different in Py3 (WTF?)
+#if PY_MAJOR_VERSION >= 3
+static PyNumberMethods PbVec3NumberMethods = {
+    (binaryfunc)PbVec3Add,      // binaryfunc nb_add;
+    (binaryfunc)PbVec3Sub,      // binaryfunc nb_sub;
+    (binaryfunc)PbVec3Mult,     // binaryfunc nb_mult;
+    0,                          // binaryfunc nb_remainder;
+    0,                          // binaryfunc nb_divmod;
+    0,                          // ternaryfunc nb_power;
+    (unaryfunc)PbVec3Negative,  // unaryfunc nb_negative;
+    0,                          // unaryfunc nb_positive;
+    0,                          // unaryfunc nb_absolute;
+    0,                          // inquiry nb_bool;
+    0,                          // unaryfunc nb_invert;
+    0,                          // binaryfunc nb_lshift;
+    0,                          // binaryfunc nb_rshift;
+    0,                          // binaryfunc nb_and;
+    0,                          // binaryfunc nb_xor;
+    0,                          // binaryfunc nb_or;
+    0,                          // unaryfunc nb_int;
+    0,                          // void *nb_reserved;
+    0,                          // unaryfunc nb_float;
+    0,                          // binaryfunc nb_inplace_add;
+    0,                          // binaryfunc nb_inplace_subtract;
+    0,                          // binaryfunc nb_inplace_multiply;
+    0,                          // binaryfunc nb_inplace_remainder;
+    0,                          // ternaryfunc nb_inplace_power;
+    0,                          // binaryfunc nb_inplace_lshift;
+    0,                          // binaryfunc nb_inplace_rshift;
+    0,                          // binaryfunc nb_inplace_and;
+    0,                          // binaryfunc nb_inplace_xor;
+    0,                          // binaryfunc nb_inplace_or;
+
+    0,                      // binaryfunc nb_floor_divide;
+    (binaryfunc)PbVec3Div,  // binaryfunc nb_true_divide;
+    0,                      // binaryfunc nb_inplace_floor_divide;
+    0,                      // binaryfunc nb_inplace_true_divide;
+
+    0  // unaryfunc nb_index;
+};
+#else
+static PyNumberMethods PbVec3NumberMethods = {
+    (binaryfunc)PbVec3Add,      // binaryfunc nb_add;
+    (binaryfunc)PbVec3Sub,      // binaryfunc nb_sub;
+    (binaryfunc)PbVec3Mult,     // binaryfunc nb_mult;
+    0,                          // binaryfunc nb_divide;
+    0,                          // binaryfunc nb_remainder;
+    0,                          // binaryfunc nb_divmod;
+    0,                          // ternaryfunc nb_power;
+    (unaryfunc)PbVec3Negative,  // unaryfunc nb_negative;
+    0,                          // unaryfunc nb_positive;
+    0,                          // unaryfunc nb_absolute;
+    0,                          // inquiry nb_nonzero;
+    0,                          // unaryfunc nb_invert;
+    0,                          // binaryfunc nb_lshift;
+    0,                          // binaryfunc nb_rshift;
+    0,                          // binaryfunc nb_and;
+    0,                          // binaryfunc nb_xor;
+    0,                          // binaryfunc nb_or;
+    0,                          // coercion nb_coerce;
+    0,                          // unaryfunc nb_int;
+    0,                          // unaryfunc nb_long;
+    0,                          // unaryfunc nb_float;
+    0,                          // unaryfunc nb_oct;
+    0,                          // unaryfunc nb_hex;
+    0,                          // binaryfunc nb_inplace_add;
+    0,                          // binaryfunc nb_inplace_subtract;
+    0,                          // binaryfunc nb_inplace_multiply;
+    0,                          // binaryfunc nb_inplace_divide;
+    0,                          // binaryfunc nb_inplace_remainder;
+    0,                          // ternaryfunc nb_inplace_power;
+    0,                          // binaryfunc nb_inplace_lshift;
+    0,                          // binaryfunc nb_inplace_rshift;
+    0,                          // binaryfunc nb_inplace_and;
+    0,                          // binaryfunc nb_inplace_xor;
+    0,                          // binaryfunc nb_inplace_or;
+    0,                          // binaryfunc nb_floor_divide;
+    (binaryfunc)PbVec3Div,      // binaryfunc nb_true_divide;
+    0,                          // binaryfunc nb_inplace_floor_divide;
+    0,                          // binaryfunc nb_inplace_true_divide;
+    0,                          // unaryfunc nb_index;
+};
+#endif
+
+PyTypeObject PbVec3Type = {
+    PyVarObject_HEAD_INIT(NULL, 0) "manta.vec3", /* tp_name */
+    sizeof(PbVec3),                              /* tp_basicsize */
+    0,                                           /* tp_itemsize */
+    (destructor)PbVec3Dealloc,                   /* tp_dealloc */
+    0,                                           /* tp_print */
+    0,                                           /* tp_getattr */
+    0,                                           /* tp_setattr */
+    0,                                           /* tp_reserved */
+    (reprfunc)PbVec3Repr,                        /* tp_repr */
+    &PbVec3NumberMethods,                        /* tp_as_number */
+    0,                                           /* tp_as_sequence */
+    0,                                           /* tp_as_mapping */
+    0,                                           /* tp_hash  */
+    0,                                           /* tp_call */
+    0,                                           /* tp_str */
+    0,                                           /* tp_getattro */
+    0,                                           /* tp_setattro */
+    0,                                           /* tp_as_buffer */
+#if PY_MAJOR_VERSION >= 3
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+#else
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES, /* tp_flags */
+#endif
+    "float vector type",  /* tp_doc */
+    0,                    /* tp_traverse */
+    0,                    /* tp_clear */
+    0,                    /* tp_richcompare */
+    0,                    /* tp_weaklistoffset */
+    0,                    /* tp_iter */
+    0,                    /* tp_iternext */
+    PbVec3Methods,        /* tp_methods */
+    PbVec3Members,        /* tp_members */
+    0,                    /* tp_getset */
+    0,                    /* tp_base */
+    0,                    /* tp_dict */
+    0,                    /* tp_descr_get */
+    0,                    /* tp_descr_set */
+    0,                    /* tp_dictoffset */
+    (initproc)PbVec3Init, /* tp_init */
+    0,                    /* tp_alloc */
+    PbVec3New,            /* tp_new */
+};
+
+inline PyObject *castPy(PyTypeObject *p)
+{
+  return reinterpret_cast<PyObject *>(static_cast<void *>(p));
+}
+
+// 4d vector
+
+extern PyTypeObject PbVec4Type;
+
+struct PbVec4 {
+  PyObject_HEAD float data[4];
+};
+
+static PyMethodDef PbVec4Methods[] = {
+    {NULL}  // Sentinel
+};
+
+static PyMemberDef PbVec4Members[] = {
+    {(char *)"x", T_FLOAT, offsetof(PbVec4, data), 0, (char *)"X"},
+    {(char *)"y", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 1, 0, (char *)"Y"},
+    {(char *)"z", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 2, 0, (char *)"Z"},
+    {(char *)"t", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 3, 0, (char *)"T"},
+    {NULL}  // Sentinel
+};
+
+static void PbVec4Dealloc(PbVec4 *self)
+{
+  Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *PbVec4New(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+  return type->tp_alloc(type, 0);
+}
+
+static int PbVec4Init(PbVec4 *self, PyObject *args, PyObject *kwds)
+{
+
+  float x1 = numeric_limits<float>::quiet_NaN(), x2 = x1, x3 = x1, x4 = x1;
+  if (!PyArg_ParseTuple(args, "|ffff", &x1, &x2, &x3, &x4))
+    return -1;
+
+  if (!c_isnan(x1)) {
+    self->data[0] = x1;
+    if (!c_isnan(x2) && !c_isnan(x3) && !c_isnan(x4)) {
+      self->data[1] = x2;
+      self->data[2] = x3;
+      self->data[3] = x4;
+    }
+    else {
+      if (!c_isnan(x2) || !c_isnan(x3) || !c_isnan(x4)) {
+        errMsg("Invalid partial init of vec4");
+      }
+      self->data[1] = self->data[2] = self->data[3] = x1;
+    }
+  }
+  else {
+    self->data[0] = self->data[1] = self->data[2] = self->data[3] = 0;
+  }
+  return 0;
+}
+
+static PyObject *PbVec4Repr(PbVec4 *self)
+{
+  Manta::Vec4 v(self->data[0], self->data[1], self->data[2], self->data[3]);
+  return PyUnicode_FromFormat(v.toString().c_str());
+}
+
+PyTypeObject PbVec4Type = {
+    PyVarObject_HEAD_INIT(NULL, 0) "manta.vec4", /* tp_name */
+    sizeof(PbVec4),                              /* tp_basicsize */
+    0,                                           /* tp_itemsize */
+    (destructor)PbVec4Dealloc,                   /* tp_dealloc */
+    0,                                           /* tp_print */
+    0,                                           /* tp_getattr */
+    0,                                           /* tp_setattr */
+    0,                                           /* tp_reserved */
+    (reprfunc)PbVec4Repr,                        /* tp_repr */
+    NULL,                                        // &PbVec4NumberMethods,      /* tp_as_number */
+    0,                                           /* tp_as_sequence */
+    0,                                           /* tp_as_mapping */
+    0,                                           /* tp_hash  */
+    0,                                           /* tp_call */
+    0,                                           /* tp_str */
+    0,                                           /* tp_getattro */
+    0,                                           /* tp_setattro */
+    0,                                           /* tp_as_buffer */
+#if PY_MAJOR_VERSION >= 3
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+#else
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES, /* tp_flags */
+#endif
+    "float vector type",  /* tp_doc */
+    0,                    /* tp_traverse */
+    0,                    /* tp_clear */
+    0,                    /* tp_richcompare */
+    0,                    /* tp_weaklistoffset */
+    0,                    /* tp_iter */
+    0,                    /* tp_iternext */
+    PbVec4Methods,        /* tp_methods */
+    PbVec4Members,        /* tp_members */
+    0,                    /* tp_getset */
+    0,                    /* tp_base */
+    0,                    /* tp_dict */
+    0,                    /* tp_descr_get */
+    0,                    /* tp_descr_set */
+    0,                    /* tp_dictoffset */
+    (initproc)PbVec4Init, /* tp_init */
+    0,                    /* tp_alloc */
+    PbVec4New,            /* tp_new */
+};
+
+// register
+
+void PbVecInitialize(PyObject *module)
+{
+  if (PyType_Ready(&PbVec3Type) < 0)
+    errMsg("can't initialize Vec3 type");
+  Py_INCREF(castPy(&PbVec3Type));
+  PyModule_AddObject(module, "vec3", (PyObject *)&PbVec3Type);
+
+  if (PyType_Ready(&PbVec4Type) < 0)
+    errMsg("can't initialize Vec4 type");
+  Py_INCREF(castPy(&PbVec4Type));
+  PyModule_AddObject(module, "vec4", (PyObject *)&PbVec4Type);
+}
+const static Pb::Register _REG(PbVecInitialize);
+
+}  // namespace Manta
diff --git a/extern/mantaflow/helper/pwrapper/pythonInclude.h b/extern/mantaflow/helper/pwrapper/pythonInclude.h
new file mode 100644
index 00000000000..0f78c6641d2
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/pythonInclude.h
@@ -0,0 +1,48 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Base class for particle systems
+ *
+ ******************************************************************************/
+
+#ifndef _PYTHONINCLUDE_H
+#define _PYTHONINCLUDE_H
+
+#if defined(WIN32) || defined(_WIN32)
+
+// note - we have to include these first!
+#  include <string>
+#  include <vector>
+#  include <iostream>
+
+#endif
+
+// the PYTHON_DEBUG_WITH_RELEASE define enables linking with python debug libraries
+#if (defined(_DEBUG) || (DEBUG == 1)) && defined(DEBUG_PYTHON_WITH_RELEASE)
+
+// special handling, disable linking with debug version of python libs
+#  undef _DEBUG
+#  define NDEBUG
+#  include <Python.h>
+#  if NUMPY == 1
+#    define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#    include "numpy/arrayobject.h"
+#  endif
+#  define _DEBUG
+#  undef NDEBUG
+
+#else
+#  include <Python.h>
+#  if NUMPY == 1
+#    define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#    include "numpy/arrayobject.h"
+#  endif
+#endif
+
+#endif
diff --git a/extern/mantaflow/helper/pwrapper/registry.cpp b/extern/mantaflow/helper/pwrapper/registry.cpp
new file mode 100644
index 00000000000..332b9e158ac
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/registry.cpp
@@ -0,0 +1,784 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Auto python registry
+ *
+ ******************************************************************************/
+
+#include <string.h>
+#include "pythonInclude.h"
+#include "structmember.h"
+#include "manta.h"
+
+using namespace std;
+
+const string gDefaultModuleName = "manta";
+
+namespace Pb {
+
+//******************************************************************************
+// Custom object definition
+
+struct Method {
+  Method(const string &n, const string &d, GenericFunction f) : name(n), doc(d), func(f)
+  {
+  }
+  string name, doc;
+  GenericFunction func;
+
+  PyMethodDef def()
+  {
+    PyMethodDef def = {&name[0], (PyCFunction)func, METH_VARARGS | METH_KEYWORDS, &doc[0]};
+    return def;
+  }
+};
+struct GetSet {
+  GetSet() : getter(0), setter(0)
+  {
+  }
+  GetSet(const string &n, const string &d, Getter g, Setter s)
+      : name(n), doc(d), getter(g), setter(s)
+  {
+  }
+  string name, doc;
+  Getter getter;
+  Setter setter;
+
+  PyGetSetDef def()
+  {
+    PyGetSetDef def = {&name[0], getter, setter, &doc[0], NULL};
+    return def;
+  }
+};
+
+struct ClassData {
+  string cName, pyName;
+  string cPureName, cTemplate;
+  InitFunc init;
+  PyTypeObject typeInfo;
+  PyNumberMethods numInfo;
+  // PySequenceMethods seqInfo;
+  vector<Method> methods;
+  map<string, GetSet> getset;
+  map<string, OperatorFunction> ops;
+  ClassData *baseclass;
+  string baseclassName;
+  Constructor constructor;
+
+  vector<PyMethodDef> genMethods;
+  vector<PyGetSetDef> genGetSet;
+};
+
+struct PbObject {
+  PyObject_HEAD Manta::PbClass *instance;
+  ClassData *classdef;
+};
+
+//******************************************************
+// Internal wrapper class
+
+//! Registers all classes and methods exposed to Python.
+/*! This class is only used internally by Pb:: framwork.
+ *  Please use the functionality of PbClass to lookup and translate pointers. */
+class WrapperRegistry {
+ public:
+  static WrapperRegistry &instance();
+  void addClass(const std::string &name,
+                const std::string &internalName,
+                const std::string &baseclass);
+  void addEnumEntry(const std::string &name, int value);
+  void addExternalInitializer(InitFunc func);
+  void addMethod(const std::string &classname,
+                 const std::string &methodname,
+                 GenericFunction method);
+  void addOperator(const std::string &classname,
+                   const std::string &methodname,
+                   OperatorFunction method);
+  void addConstructor(const std::string &classname, Constructor method);
+  void addGetSet(const std::string &classname,
+                 const std::string &property,
+                 Getter getfunc,
+                 Setter setfunc);
+  void addPythonPath(const std::string &path);
+  void addPythonCode(const std::string &file, const std::string &code);
+  PyObject *createPyObject(const std::string &classname,
+                           const std::string &name,
+                           Manta::PbArgs &args,
+                           Manta::PbClass *parent);
+  void construct(const std::string &scriptname, const vector<string> &args);
+  void cleanup();
+  void renameObjects();
+  void runPreInit();
+  PyObject *initModule();
+  ClassData *lookup(const std::string &name);
+  bool canConvert(ClassData *from, ClassData *to);
+
+ private:
+  ClassData *getOrConstructClass(const string &name);
+  void registerBaseclasses();
+  void registerDummyTypes();
+  void registerMeta();
+  void addConstants(PyObject *module);
+  void registerOperators(ClassData *cls);
+  void addParentMethods(ClassData *cls, ClassData *base);
+  WrapperRegistry();
+  std::map<std::string, ClassData *> mClasses;
+  std::vector<ClassData *> mClassList;
+  std::vector<InitFunc> mExtInitializers;
+  std::vector<std::string> mPaths;
+  std::string mCode, mScriptName;
+  std::vector<std::string> args;
+  std::map<std::string, int> mEnumValues;
+};
+
+//******************************************************************************
+// Callback functions
+
+PyObject *cbGetClass(PbObject *self, void *cl)
+{
+  return Manta::toPy(self->classdef->cPureName);
+}
+
+PyObject *cbGetTemplate(PbObject *self, void *cl)
+{
+  return Manta::toPy(self->classdef->cTemplate);
+}
+
+PyObject *cbGetCName(PbObject *self, void *cl)
+{
+  return Manta::toPy(self->classdef->cName);
+}
+
+void cbDealloc(PbObject *self)
+{
+  // cout << "dealloc " << self->instance->getName() << " " << self->classdef->cName << endl;
+  if (self->instance) {
+#ifndef BLENDER
+    // don't delete top-level objects
+    if (self->instance->getParent() != self->instance)
+      delete self->instance;
+#else
+    // in Blender we *have* to delete all objects
+    delete self->instance;
+#endif
+  }
+  Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+PyObject *cbNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+  PbObject *self = (PbObject *)type->tp_alloc(type, 0);
+  if (self != NULL) {
+    // lookup and link classdef
+    self->classdef = WrapperRegistry::instance().lookup(type->tp_name);
+    self->instance = NULL;
+    // cout << "creating " << self->classdef->cName << endl;
+  }
+  else
+    errMsg("can't allocate new python class object");
+  return (PyObject *)self;
+}
+
+int cbDisableConstructor(PyObject *self, PyObject *args, PyObject *kwds)
+{
+  errMsg("Can't instantiate a class template without template arguments");
+  return -1;
+}
+
+PyMODINIT_FUNC PyInit_Main(void)
+{
+  MantaEnsureRegistration();
+#if PY_MAJOR_VERSION >= 3
+  return WrapperRegistry::instance().initModule();
+#else
+  WrapperRegistry::instance().initModule();
+#endif
+}
+
+//******************************************************
+// WrapperRegistry
+
+WrapperRegistry::WrapperRegistry()
+{
+  addClass("__modclass__", "__modclass__", "");
+  addClass("PbClass", "PbClass", "");
+}
+
+ClassData *WrapperRegistry::getOrConstructClass(const string &classname)
+{
+  map<string, ClassData *>::iterator it = mClasses.find(classname);
+
+  if (it != mClasses.end())
+    return it->second;
+  ClassData *data = new ClassData;
+  data->cName = classname;
+  data->cPureName = classname;
+  data->cTemplate = "";
+  size_t tplIdx = classname.find('<');
+  if (tplIdx != string::npos) {
+    data->cPureName = classname.substr(0, tplIdx);
+    data->cTemplate = classname.substr(tplIdx + 1, classname.find('>') - tplIdx - 1);
+  }
+  data->baseclass = NULL;
+  data->constructor = cbDisableConstructor;
+  mClasses[classname] = data;
+  mClassList.push_back(data);
+  return data;
+}
+
+void replaceAll(string &source, string const &find, string const &replace)
+{
+  for (string::size_type i = 0; (i = source.find(find, i)) != std::string::npos;) {
+    source.replace(i, find.length(), replace);
+    i += replace.length() - find.length() + 1;
+  }
+}
+
+void WrapperRegistry::addClass(const string &pyName,
+                               const string &internalName,
+                               const string &baseclass)
+{
+  ClassData *data = getOrConstructClass(internalName);
+
+  // regularize python name
+  string pythonName = pyName;
+  replaceAll(pythonName, "<", "_");
+  replaceAll(pythonName, ">", "");
+  replaceAll(pythonName, ",", "_");
+
+  if (data->pyName.empty())
+    data->pyName = pythonName;
+  mClasses[pythonName] = data;
+  if (!baseclass.empty())
+    data->baseclassName = baseclass;
+}
+
+void WrapperRegistry::addEnumEntry(const string &name, int value)
+{
+  /// Gather static definitions to add them as static python objects afterwards
+  if (mEnumValues.insert(std::make_pair(name, value)).second == false) {
+    errMsg("Enum entry '" + name + "' already existing...");
+  }
+}
+
+void WrapperRegistry::addExternalInitializer(InitFunc func)
+{
+  mExtInitializers.push_back(func);
+}
+
+void WrapperRegistry::addPythonPath(const string &path)
+{
+  mPaths.push_back(path);
+}
+
+void WrapperRegistry::addPythonCode(const string &file, const string &code)
+{
+  mCode += code + "\n";
+}
+
+void WrapperRegistry::addGetSet(const string &classname,
+                                const string &property,
+                                Getter getfunc,
+                                Setter setfunc)
+{
+  ClassData *classdef = getOrConstructClass(classname);
+  GetSet &def = classdef->getset[property];
+  if (def.name.empty()) {
+    def.name = property;
+    def.doc = property;
+  }
+  if (getfunc)
+    def.getter = getfunc;
+  if (setfunc)
+    def.setter = setfunc;
+}
+
+void WrapperRegistry::addMethod(const string &classname,
+                                const string &methodname,
+                                GenericFunction func)
+{
+  string aclass = classname;
+  if (aclass.empty())
+    aclass = "__modclass__";
+
+  ClassData *classdef = getOrConstructClass(aclass);
+  for (int i = 0; i < (int)classdef->methods.size(); i++)
+    if (classdef->methods[i].name == methodname)
+      return;  // avoid duplicates
+  classdef->methods.push_back(Method(methodname, methodname, func));
+}
+
+void WrapperRegistry::addOperator(const string &classname,
+                                  const string &methodname,
+                                  OperatorFunction func)
+{
+  if (classname.empty())
+    errMsg("PYTHON operators have to be defined within classes.");
+
+  string op = methodname.substr(8);
+  ClassData *classdef = getOrConstructClass(classname);
+  classdef->ops[op] = func;
+}
+
+void WrapperRegistry::addConstructor(const string &classname, Constructor func)
+{
+  ClassData *classdef = getOrConstructClass(classname);
+  classdef->constructor = func;
+}
+
+void WrapperRegistry::addParentMethods(ClassData *cur, ClassData *base)
+{
+  if (base == 0)
+    return;
+
+  for (vector<Method>::iterator it = base->methods.begin(); it != base->methods.end(); ++it)
+    addMethod(cur->cName, it->name, it->func);
+
+  for (map<string, GetSet>::iterator it = base->getset.begin(); it != base->getset.end(); ++it)
+    addGetSet(cur->cName, it->first, it->second.getter, it->second.setter);
+
+  for (map<string, OperatorFunction>::iterator it = base->ops.begin(); it != base->ops.end(); ++it)
+    cur->ops[it->first] = it->second;
+
+  addParentMethods(cur, base->baseclass);
+}
+
+void WrapperRegistry::registerBaseclasses()
+{
+  for (int i = 0; i < (int)mClassList.size(); i++) {
+    string bname = mClassList[i]->baseclassName;
+    if (!bname.empty()) {
+      mClassList[i]->baseclass = lookup(bname);
+      if (!mClassList[i]->baseclass)
+        errMsg("Registering class '" + mClassList[i]->cName + "' : Base class '" + bname +
+               "' not found");
+    }
+  }
+
+  for (int i = 0; i < (int)mClassList.size(); i++) {
+    addParentMethods(mClassList[i], mClassList[i]->baseclass);
+  }
+}
+
+void WrapperRegistry::registerMeta()
+{
+  for (int i = 0; i < (int)mClassList.size(); i++) {
+    mClassList[i]->getset["_class"] = GetSet("_class", "C class name", (Getter)cbGetClass, 0);
+    mClassList[i]->getset["_cname"] = GetSet("_cname", "Full C name", (Getter)cbGetCName, 0);
+    mClassList[i]->getset["_T"] = GetSet("_T", "C template argument", (Getter)cbGetTemplate, 0);
+  }
+}
+
+void WrapperRegistry::registerOperators(ClassData *cls)
+{
+  PyNumberMethods &num = cls->numInfo;
+  for (map<string, OperatorFunction>::iterator it = cls->ops.begin(); it != cls->ops.end(); it++) {
+    const string &op = it->first;
+    OperatorFunction func = it->second;
+    if (op == "+=")
+      num.nb_inplace_add = func;
+    else if (op == "-=")
+      num.nb_inplace_subtract = func;
+    else if (op == "*=")
+      num.nb_inplace_multiply = func;
+    else if (op == "+")
+      num.nb_add = func;
+    else if (op == "-")
+      num.nb_subtract = func;
+    else if (op == "*")
+      num.nb_multiply = func;
+#if PY_MAJOR_VERSION < 3
+    else if (op == "/=")
+      num.nb_inplace_divide = func;
+    else if (op == "/")
+      num.nb_divide = func;
+#else
+    else if (op == "/=")
+      num.nb_inplace_true_divide = func;
+    else if (op == "/")
+      num.nb_true_divide = func;
+#endif
+    else
+      errMsg("PYTHON operator " + op + " not supported");
+  }
+}
+
+void WrapperRegistry::registerDummyTypes()
+{
+  vector<string> add;
+  for (vector<ClassData *>::iterator it = mClassList.begin(); it != mClassList.end(); ++it) {
+    string cName = (*it)->cName;
+    if (cName.find('<') != string::npos)
+      add.push_back(cName.substr(0, cName.find('<')));
+  }
+  for (int i = 0; i < (int)add.size(); i++)
+    addClass(add[i], add[i], "");
+}
+
+ClassData *WrapperRegistry::lookup(const string &name)
+{
+  for (map<string, ClassData *>::iterator it = mClasses.begin(); it != mClasses.end(); ++it) {
+    if (it->first == name || it->second->cName == name)
+      return it->second;
+  }
+  return NULL;
+}
+
+void WrapperRegistry::cleanup()
+{
+  for (vector<ClassData *>::iterator it = mClassList.begin(); it != mClassList.end(); ++it) {
+    delete *it;
+  }
+  mClasses.clear();
+  mClassList.clear();
+}
+
+WrapperRegistry &WrapperRegistry::instance()
+{
+  static WrapperRegistry inst;
+  return inst;
+}
+
+bool WrapperRegistry::canConvert(ClassData *from, ClassData *to)
+{
+  if (from == to)
+    return true;
+  if (from->baseclass)
+    return canConvert(from->baseclass, to);
+  return false;
+}
+
+void WrapperRegistry::addConstants(PyObject *module)
+{
+  // expose arguments
+  PyObject *list = PyList_New(args.size());
+  for (int i = 0; i < (int)args.size(); i++)
+    PyList_SET_ITEM(list, i, Manta::toPy(args[i]));
+  PyModule_AddObject(module, "args", list);
+  PyModule_AddObject(module, "SCENEFILE", Manta::toPy(mScriptName));
+
+  // expose compile flags
+#ifdef DEBUG
+  PyModule_AddObject(module, "DEBUG", Manta::toPy<bool>(true));
+#else
+  PyModule_AddObject(module, "DEBUG", Manta::toPy<bool>(false));
+#endif
+#ifdef MANTA_MT
+  PyModule_AddObject(module, "MT", Manta::toPy<bool>(true));
+#else
+  PyModule_AddObject(module, "MT", Manta::toPy<bool>(false));
+#endif
+#ifdef GUI
+  PyModule_AddObject(module, "GUI", Manta::toPy<bool>(true));
+#else
+  PyModule_AddObject(module, "GUI", Manta::toPy<bool>(false));
+#endif
+#if FLOATINGPOINT_PRECISION == 2
+  PyModule_AddObject(module, "DOUBLEPRECISION", Manta::toPy<bool>(true));
+#else
+  PyModule_AddObject(module, "DOUBLEPRECISION", Manta::toPy<bool>(false));
+#endif
+  // cuda off for now
+  PyModule_AddObject(module, "CUDA", Manta::toPy<bool>(false));
+
+  // expose enum entries
+  std::map<std::string, int>::iterator it;
+  for (it = mEnumValues.begin(); it != mEnumValues.end(); it++) {
+    PyModule_AddObject(module, it->first.c_str(), Manta::toPy(it->second));
+    // Alternative would be:
+    // e.g. PyModule_AddIntConstant(module, "FlagFluid", 1);
+  }
+}
+
+void WrapperRegistry::runPreInit()
+{
+  // add python directories to path
+  PyObject *sys_path = PySys_GetObject((char *)"path");
+  for (size_t i = 0; i < mPaths.size(); i++) {
+    PyObject *path = Manta::toPy(mPaths[i]);
+    if (sys_path == NULL || path == NULL || PyList_Append(sys_path, path) < 0) {
+      errMsg("unable to set python path");
+    }
+    Py_DECREF(path);
+  }
+  if (!mCode.empty()) {
+    mCode = "from manta import *\n" + mCode;
+    PyRun_SimpleString(mCode.c_str());
+  }
+}
+
+PyObject *WrapperRegistry::createPyObject(const string &classname,
+                                          const string &name,
+                                          Manta::PbArgs &args,
+                                          Manta::PbClass *parent)
+{
+  ClassData *classdef = lookup(classname);
+  if (!classdef)
+    errMsg("Class " + classname + " doesn't exist.");
+
+  // create object
+  PyObject *obj = cbNew(&classdef->typeInfo, NULL, NULL);
+  PbObject *self = (PbObject *)obj;
+  PyObject *nkw = 0;
+
+  if (args.kwds())
+    nkw = PyDict_Copy(args.kwds());
+  else
+    nkw = PyDict_New();
+
+  PyObject *nocheck = Py_BuildValue("s", "yes");
+  PyDict_SetItemString(nkw, "nocheck", nocheck);
+  if (parent)
+    PyDict_SetItemString(nkw, "parent", parent->getPyObject());
+
+  // create instance
+  if (self->classdef->constructor(obj, args.linArgs(), nkw) < 0)
+    errMsg("error raised in constructor");  // assume condition is already set
+
+  Py_DECREF(nkw);
+  Py_DECREF(nocheck);
+  self->instance->setName(name);
+
+  return obj;
+}
+
+// prepare typeinfo and register python module
+void WrapperRegistry::construct(const string &scriptname, const vector<string> &args)
+{
+  mScriptName = scriptname;
+  this->args = args;
+
+  registerBaseclasses();
+  registerMeta();
+  registerDummyTypes();
+
+  // work around for certain gcc versions, cast to char*
+  PyImport_AppendInittab((char *)gDefaultModuleName.c_str(), PyInit_Main);
+}
+
+inline PyObject *castPy(PyTypeObject *p)
+{
+  return reinterpret_cast<PyObject *>(static_cast<void *>(p));
+}
+
+PyObject *WrapperRegistry::initModule()
+{
+  // generate and terminate all method lists
+  PyMethodDef sentinelFunc = {NULL, NULL, 0, NULL};
+  PyGetSetDef sentinelGetSet = {NULL, NULL, NULL, NULL, NULL};
+  for (int i = 0; i < (int)mClassList.size(); i++) {
+    ClassData *cls = mClassList[i];
+    cls->genMethods.clear();
+    cls->genGetSet.clear();
+    for (vector<Method>::iterator i2 = cls->methods.begin(); i2 != cls->methods.end(); ++i2)
+      cls->genMethods.push_back(i2->def());
+    for (map<string, GetSet>::iterator i2 = cls->getset.begin(); i2 != cls->getset.end(); ++i2)
+      cls->genGetSet.push_back(i2->second.def());
+
+    cls->genMethods.push_back(sentinelFunc);
+    cls->genGetSet.push_back(sentinelGetSet);
+  }
+
+  // prepare module info
+#if PY_MAJOR_VERSION >= 3
+  static PyModuleDef MainModule = {PyModuleDef_HEAD_INIT,
+                                   gDefaultModuleName.c_str(),
+                                   "Bridge module to the C++ solver",
+                                   -1,
+                                   NULL,
+                                   NULL,
+                                   NULL,
+                                   NULL,
+                                   NULL};
+  // get generic methods (plugin functions)
+  MainModule.m_methods = &mClasses["__modclass__"]->genMethods[0];
+
+  // create module
+  PyObject *module = PyModule_Create(&MainModule);
+#else
+  PyObject *module = Py_InitModule(gDefaultModuleName.c_str(),
+                                   &mClasses["__modclass__"]->genMethods[0]);
+#endif
+  if (module == NULL)
+    return NULL;
+
+  // load classes
+  for (vector<ClassData *>::iterator it = mClassList.begin(); it != mClassList.end(); ++it) {
+    ClassData &data = **it;
+    char *nameptr = (char *)data.pyName.c_str();
+
+    // define numeric substruct
+    PyNumberMethods *num = 0;
+    if (!data.ops.empty()) {
+      num = &data.numInfo;
+      memset(num, 0, sizeof(PyNumberMethods));
+      registerOperators(&data);
+    }
+
+    // define python classinfo
+    PyTypeObject t = {
+        PyVarObject_HEAD_INIT(NULL, 0)(char *) data.pyName.c_str(),  // tp_name
+        sizeof(PbObject),                                            // tp_basicsize
+        0,                                                           // tp_itemsize
+        (destructor)cbDealloc,                                       // tp_dealloc
+        0,                                                           // tp_print
+        0,                                                           // tp_getattr
+        0,                                                           // tp_setattr
+        0,                                                           // tp_reserved
+        0,                                                           // tp_repr
+        num,                                                         // tp_as_number
+        0,                                                           // tp_as_sequence
+        0,                                                           // tp_as_mapping
+        0,                                                           // tp_hash
+        0,                                                           // tp_call
+        0,                                                           // tp_str
+        0,                                                           // tp_getattro
+        0,                                                           // tp_setattro
+        0,                                                           // tp_as_buffer
+        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                    // tp_flags
+        nameptr,                                                     // tp_doc
+        0,                                                           // tp_traverse
+        0,                                                           // tp_clear
+        0,                                                           // tp_richcompare
+        0,                                                           // tp_weaklistoffset
+        0,                                                           // tp_iter
+        0,                                                           // tp_iternext
+        &data.genMethods[0],                                         // tp_methods
+        0,                                                           // tp_members
+        &data.genGetSet[0],                                          // tp_getset
+        0,                                                           // tp_base
+        0,                                                           // tp_dict
+        0,                                                           // tp_descr_get
+        0,                                                           // tp_descr_set
+        0,                                                           // tp_dictoffset
+        (initproc)(data.constructor),                                // tp_init
+        0,                                                           // tp_alloc
+        cbNew                                                        // tp_new
+    };
+    data.typeInfo = t;
+
+    if (PyType_Ready(&data.typeInfo) < 0)
+      continue;
+
+    for (map<string, ClassData *>::iterator i2 = mClasses.begin(); i2 != mClasses.end(); ++i2) {
+      if (*it != i2->second)
+        continue;
+      // register all aliases
+      Py_INCREF(castPy(&data.typeInfo));
+      PyModule_AddObject(module, (char *)i2->first.c_str(), (PyObject *)&data.typeInfo);
+    }
+  }
+
+  // externals
+  for (vector<InitFunc>::iterator it = mExtInitializers.begin(); it != mExtInitializers.end();
+       ++it) {
+    (*it)(module);
+  }
+
+  addConstants(module);
+
+  return module;
+}
+
+//******************************************************
+// Register members and exposed functions
+
+void setup(const std::string &filename, const std::vector<std::string> &args)
+{
+  WrapperRegistry::instance().construct(filename, args);
+  Py_Initialize();
+  WrapperRegistry::instance().runPreInit();
+}
+
+void finalize()
+{
+  Py_Finalize();
+  WrapperRegistry::instance().cleanup();
+}
+
+bool canConvert(PyObject *obj, const string &classname)
+{
+  ClassData *from = ((PbObject *)obj)->classdef;
+  ClassData *dest = WrapperRegistry::instance().lookup(classname);
+  if (!dest)
+    errMsg("Classname '" + classname + "' is not registered.");
+  return WrapperRegistry::instance().canConvert(from, dest);
+}
+
+Manta::PbClass *objFromPy(PyObject *obj)
+{
+  if (Py_TYPE(obj)->tp_dealloc != (destructor)cbDealloc)  // not a manta object
+    return NULL;
+
+  return ((PbObject *)obj)->instance;
+}
+
+PyObject *copyObject(Manta::PbClass *cls, const string &classname)
+{
+  ClassData *classdef = WrapperRegistry::instance().lookup(classname);
+  assertMsg(classdef, "python class " + classname + " does not exist.");
+
+  // allocate new object
+  PbObject *obj = (PbObject *)classdef->typeInfo.tp_alloc(&(classdef->typeInfo), 0);
+  assertMsg(obj, "cannot allocate new python object");
+
+  obj->classdef = classdef;
+  cls->registerObject((PyObject *)obj, 0);
+
+  return cls->getPyObject();
+}
+
+Manta::PbClass *createPy(const std::string &classname,
+                         const std::string &name,
+                         Manta::PbArgs &args,
+                         Manta::PbClass *parent)
+{
+  PyObject *obj = WrapperRegistry::instance().createPyObject(classname, name, args, parent);
+  return ((PbObject *)obj)->instance;
+}
+
+void setReference(Manta::PbClass *cls, PyObject *obj)
+{
+  ((PbObject *)obj)->instance = cls;
+}
+
+Register::Register(const string &className, const string &funcName, GenericFunction func)
+{
+  WrapperRegistry::instance().addMethod(className, funcName, func);
+}
+Register::Register(const string &className, const string &funcName, OperatorFunction func)
+{
+  WrapperRegistry::instance().addOperator(className, funcName, func);
+}
+Register::Register(const string &className, const string &funcName, Constructor func)
+{
+  WrapperRegistry::instance().addConstructor(className, func);
+}
+Register::Register(const string &className, const string &property, Getter getter, Setter setter)
+{
+  WrapperRegistry::instance().addGetSet(className, property, getter, setter);
+}
+Register::Register(const string &className, const string &pyName, const string &baseClass)
+{
+  WrapperRegistry::instance().addClass(pyName, className, baseClass);
+}
+Register::Register(const string &name, const int value)
+{
+  WrapperRegistry::instance().addEnumEntry(name, value);
+}
+Register::Register(const string &file, const string &pythonCode)
+{
+  WrapperRegistry::instance().addPythonCode(file, pythonCode);
+}
+Register::Register(InitFunc func)
+{
+  WrapperRegistry::instance().addExternalInitializer(func);
+}
+
+}  // namespace Pb
diff --git a/extern/mantaflow/helper/pwrapper/registry.h b/extern/mantaflow/helper/pwrapper/registry.h
new file mode 100644
index 00000000000..139863df85d
--- /dev/null
+++ b/extern/mantaflow/helper/pwrapper/registry.h
@@ -0,0 +1,106 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Auto python registry
+ *
+ ******************************************************************************/
+
+#ifndef _REGISTRY_H
+#define _REGISTRY_H
+
+#include <string>
+#include <vector>
+
+// forward declaration to minimize Python.h includes
+#ifndef PyObject_HEAD
+#  ifndef PyObject_Fake
+struct _object;
+typedef _object PyObject;
+#    define PyObject_Fake
+#  endif
+#endif
+
+namespace Manta {
+class PbClass;
+class PbArgs;
+}  // namespace Manta
+
+// **************************************************
+//                      NOTE
+// Everything in this file is intend only for internal
+// use by the generated wrappers or pclass/pconvert.
+// For user code, use the functionality exposed in
+// pclass.h / pconvert.h instead.
+// **************************************************
+
+// Used to turn names into strings
+namespace Manta {
+template<class T> struct Namify {
+  static const char *S;
+};
+}  // namespace Manta
+namespace Pb {
+
+// internal registry access
+void setup(const std::string &filename, const std::vector<std::string> &args);
+void finalize();
+bool canConvert(PyObject *obj, const std::string &to);
+Manta::PbClass *objFromPy(PyObject *obj);
+Manta::PbClass *createPy(const std::string &classname,
+                         const std::string &name,
+                         Manta::PbArgs &args,
+                         Manta::PbClass *parent);
+void setReference(Manta::PbClass *cls, PyObject *obj);
+PyObject *copyObject(Manta::PbClass *cls, const std::string &classname);
+void MantaEnsureRegistration();
+
+#ifdef BLENDER
+#  ifdef PyMODINIT_FUNC
+PyMODINIT_FUNC PyInit_Main(void);
+#  endif
+#endif
+
+// callback type
+typedef void (*InitFunc)(PyObject *);
+typedef PyObject *(*GenericFunction)(PyObject *self, PyObject *args, PyObject *kwds);
+typedef PyObject *(*OperatorFunction)(PyObject *self, PyObject *o);
+typedef int (*Constructor)(PyObject *self, PyObject *args, PyObject *kwds);
+typedef PyObject *(*Getter)(PyObject *self, void *closure);
+typedef int (*Setter)(PyObject *self, PyObject *value, void *closure);
+
+//! Auto registry of python methods and classes
+struct Register {
+  //! register method
+  Register(const std::string &className, const std::string &funcName, GenericFunction func);
+  //! register operator
+  Register(const std::string &className, const std::string &funcName, OperatorFunction func);
+  //! register constructor
+  Register(const std::string &className, const std::string &funcName, Constructor func);
+  //! register getter/setter
+  Register(const std::string &className,
+           const std::string &property,
+           Getter getter,
+           Setter setter);
+  //! register class
+  Register(const std::string &className, const std::string &pyName, const std::string &baseClass);
+  //! register enum entry
+  Register(const std::string &name, const int value);
+  //! register python code
+  Register(const std::string &file, const std::string &pythonCode);
+  //! register external code
+  Register(InitFunc func);
+};
+
+#define KEEP_UNUSED(var) \
+  do { \
+    (void)var; \
+  } while (false);
+
+}  // namespace Pb
+#endif
diff --git a/extern/mantaflow/helper/util/integrator.h b/extern/mantaflow/helper/util/integrator.h
new file mode 100644
index 00000000000..5b1b02a5197
--- /dev/null
+++ b/extern/mantaflow/helper/util/integrator.h
@@ -0,0 +1,79 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Helper functions for simple integration
+ *
+ ******************************************************************************/
+
+#ifndef _INTEGRATE_H
+#define _INTEGRATE_H
+
+#include <vector>
+#include "vectorbase.h"
+#include "kernel.h"
+
+namespace Manta {
+
+enum IntegrationMode { IntEuler = 0, IntRK2, IntRK4 };
+
+//! Integrate a particle set with a given velocity kernel
+template<class VelKernel> void integratePointSet(VelKernel &k, int mode)
+{
+  typedef typename VelKernel::type0 PosType;
+  PosType &x = k.getArg0();
+  const std::vector<Vec3> &u = k.getRet();
+  const int N = x.size();
+
+  if (mode == IntEuler) {
+    for (int i = 0; i < N; i++)
+      x[i].pos += u[i];
+  }
+  else if (mode == IntRK2) {
+    PosType x0(x);
+
+    for (int i = 0; i < N; i++)
+      x[i].pos = x0[i].pos + 0.5 * u[i];
+
+    k.run();
+    for (int i = 0; i < N; i++)
+      x[i].pos = x0[i].pos + u[i];
+  }
+  else if (mode == IntRK4) {
+    PosType x0(x);
+    std::vector<Vec3> uTotal(u);
+
+    for (int i = 0; i < N; i++)
+      x[i].pos = x0[i].pos + 0.5 * u[i];
+
+    k.run();
+    for (int i = 0; i < N; i++) {
+      x[i].pos = x0[i].pos + 0.5 * u[i];
+      uTotal[i] += 2 * u[i];
+    }
+
+    k.run();
+    for (int i = 0; i < N; i++) {
+      x[i].pos = x0[i].pos + u[i];
+      uTotal[i] += 2 * u[i];
+    }
+
+    k.run();
+    for (int i = 0; i < N; i++)
+      x[i].pos = x0[i].pos + (Real)(1. / 6.) * (uTotal[i] + u[i]);
+  }
+  else
+    errMsg("unknown integration type");
+
+  // for(int i=0; i<N; i++) std::cout << x[i].pos.y-x[0].pos.y << std::endl;
+  // std::cout << "<><><>" << std::endl;
+}
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/interpol.h b/extern/mantaflow/helper/util/interpol.h
new file mode 100644
index 00000000000..24d5d2ada06
--- /dev/null
+++ b/extern/mantaflow/helper/util/interpol.h
@@ -0,0 +1,324 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Helper functions for interpolation
+ *
+ ******************************************************************************/
+
+#ifndef _INTERPOL_H
+#define _INTERPOL_H
+
+#include "vectorbase.h"
+
+// Grid values are stored at i+0.5, j+0.5, k+0.5
+// MAC grid values are stored at i,j+0.5,k+0.5 (for x) ...
+
+namespace Manta {
+
+inline Vec3 fdTangent(const Vec3 &p0, const Vec3 &p1, const Vec3 &p2)
+{
+  return 0.5 * (getNormalized(p2 - p1) + getNormalized(p1 - p0));
+}
+
+inline Vec3 crTangent(const Vec3 &p0, const Vec3 &p1, const Vec3 &p2)
+{
+  return 0.5 * (p2 - p0);
+}
+
+inline Vec3 hermiteSpline(const Vec3 &p0, const Vec3 &p1, const Vec3 &m0, const Vec3 &m1, Real t)
+{
+  const Real t2 = t * t, t3 = t2 * t;
+  return (2.0 * t3 - 3.0 * t2 + 1.0) * p0 + (t3 - 2.0 * t2 + t) * m0 +
+         (-2.0 * t3 + 3.0 * t2) * p1 + (t3 - t2) * m1;
+}
+
+static inline void checkIndexInterpol(const Vec3i &size, IndexInt idx)
+{
+  if (idx < 0 || idx > (IndexInt)size.x * size.y * size.z) {
+    std::ostringstream s;
+    s << "Grid interpol dim " << size << " : index " << idx << " out of bound ";
+    errMsg(s.str());
+  }
+}
+
+// ----------------------------------------------------------------------
+// Grid interpolators
+// ----------------------------------------------------------------------
+
+#define BUILD_INDEX \
+  Real px = pos.x - 0.5f, py = pos.y - 0.5f, pz = pos.z - 0.5f; \
+  int xi = (int)px; \
+  int yi = (int)py; \
+  int zi = (int)pz; \
+  Real s1 = px - (Real)xi, s0 = 1. - s1; \
+  Real t1 = py - (Real)yi, t0 = 1. - t1; \
+  Real f1 = pz - (Real)zi, f0 = 1. - f1; \
+  /* clamp to border */ \
+  if (px < 0.) { \
+    xi = 0; \
+    s0 = 1.0; \
+    s1 = 0.0; \
+  } \
+  if (py < 0.) { \
+    yi = 0; \
+    t0 = 1.0; \
+    t1 = 0.0; \
+  } \
+  if (pz < 0.) { \
+    zi = 0; \
+    f0 = 1.0; \
+    f1 = 0.0; \
+  } \
+  if (xi >= size.x - 1) { \
+    xi = size.x - 2; \
+    s0 = 0.0; \
+    s1 = 1.0; \
+  } \
+  if (yi >= size.y - 1) { \
+    yi = size.y - 2; \
+    t0 = 0.0; \
+    t1 = 1.0; \
+  } \
+  if (size.z > 1) { \
+    if (zi >= size.z - 1) { \
+      zi = size.z - 2; \
+      f0 = 0.0; \
+      f1 = 1.0; \
+    } \
+  } \
+  const int X = 1; \
+  const int Y = size.x;
+
+template<class T> inline T interpol(const T *data, const Vec3i &size, const int Z, const Vec3 &pos)
+{
+  BUILD_INDEX
+  IndexInt idx = (IndexInt)xi + (IndexInt)Y * yi + (IndexInt)Z * zi;
+  DEBUG_ONLY(checkIndexInterpol(size, idx));
+  DEBUG_ONLY(checkIndexInterpol(size, idx + X + Y + Z));
+
+  return ((data[idx] * t0 + data[idx + Y] * t1) * s0 +
+          (data[idx + X] * t0 + data[idx + X + Y] * t1) * s1) *
+             f0 +
+         ((data[idx + Z] * t0 + data[idx + Y + Z] * t1) * s0 +
+          (data[idx + X + Z] * t0 + data[idx + X + Y + Z] * t1) * s1) *
+             f1;
+}
+
+template<int c>
+inline Real interpolComponent(const Vec3 *data, const Vec3i &size, const int Z, const Vec3 &pos)
+{
+  BUILD_INDEX
+  IndexInt idx = (IndexInt)xi + (IndexInt)Y * yi + (IndexInt)Z * zi;
+  DEBUG_ONLY(checkIndexInterpol(size, idx));
+  DEBUG_ONLY(checkIndexInterpol(size, idx + X + Y + Z));
+
+  return ((data[idx][c] * t0 + data[idx + Y][c] * t1) * s0 +
+          (data[idx + X][c] * t0 + data[idx + X + Y][c] * t1) * s1) *
+             f0 +
+         ((data[idx + Z][c] * t0 + data[idx + Y + Z][c] * t1) * s0 +
+          (data[idx + X + Z][c] * t0 + data[idx + X + Y + Z][c] * t1) * s1) *
+             f1;
+}
+
+template<class T>
+inline void setInterpol(
+    T *data, const Vec3i &size, const int Z, const Vec3 &pos, const T &v, Real *sumBuffer)
+{
+  BUILD_INDEX
+  IndexInt idx = (IndexInt)xi + (IndexInt)Y * yi + (IndexInt)Z * zi;
+  DEBUG_ONLY(checkIndexInterpol(size, idx));
+  DEBUG_ONLY(checkIndexInterpol(size, idx + X + Y + Z));
+
+  T *ref = &data[idx];
+  Real *sum = &sumBuffer[idx];
+  Real s0f0 = s0 * f0, s1f0 = s1 * f0, s0f1 = s0 * f1, s1f1 = s1 * f1;
+  Real w0 = t0 * s0f0, wx = t0 * s1f0, wy = t1 * s0f0, wxy = t1 * s1f0;
+  Real wz = t0 * s0f1, wxz = t0 * s1f1, wyz = t1 * s0f1, wxyz = t1 * s1f1;
+
+  sum[Z] += wz;
+  sum[X + Z] += wxz;
+  sum[Y + Z] += wyz;
+  sum[X + Y + Z] += wxyz;
+  ref[Z] += wz * v;
+  ref[X + Z] += wxz * v;
+  ref[Y + Z] += wyz * v;
+  ref[X + Y + Z] += wxyz * v;
+  sum[0] += w0;
+  sum[X] += wx;
+  sum[Y] += wy;
+  sum[X + Y] += wxy;
+  ref[0] += w0 * v;
+  ref[X] += wx * v;
+  ref[Y] += wy * v;
+  ref[X + Y] += wxy * v;
+}
+
+#define BUILD_INDEX_SHIFT \
+  BUILD_INDEX \
+  /* shifted coords */ \
+  int s_xi = (int)pos.x, s_yi = (int)pos.y, s_zi = (int)pos.z; \
+  Real s_s1 = pos.x - (Real)s_xi, s_s0 = 1. - s_s1; \
+  Real s_t1 = pos.y - (Real)s_yi, s_t0 = 1. - s_t1; \
+  Real s_f1 = pos.z - (Real)s_zi, s_f0 = 1. - s_f1; \
+  /* clamp to border */ \
+  if (pos.x < 0) { \
+    s_xi = 0; \
+    s_s0 = 1.0; \
+    s_s1 = 0.0; \
+  } \
+  if (pos.y < 0) { \
+    s_yi = 0; \
+    s_t0 = 1.0; \
+    s_t1 = 0.0; \
+  } \
+  if (pos.z < 0) { \
+    s_zi = 0; \
+    s_f0 = 1.0; \
+    s_f1 = 0.0; \
+  } \
+  if (s_xi >= size.x - 1) { \
+    s_xi = size.x - 2; \
+    s_s0 = 0.0; \
+    s_s1 = 1.0; \
+  } \
+  if (s_yi >= size.y - 1) { \
+    s_yi = size.y - 2; \
+    s_t0 = 0.0; \
+    s_t1 = 1.0; \
+  } \
+  if (size.z > 1) { \
+    if (s_zi >= size.z - 1) { \
+      s_zi = size.z - 2; \
+      s_f0 = 0.0; \
+      s_f1 = 1.0; \
+    } \
+  }
+
+inline Vec3 interpolMAC(const Vec3 *data, const Vec3i &size, const int Z, const Vec3 &pos)
+{
+  BUILD_INDEX_SHIFT;
+  DEBUG_ONLY(checkIndexInterpol(size, (zi * (IndexInt)size.y + yi) * (IndexInt)size.x + xi));
+  DEBUG_ONLY(checkIndexInterpol(
+      size, (s_zi * (IndexInt)size.y + s_yi) * (IndexInt)size.x + s_xi + X + Y + Z));
+
+  // process individual components
+  Vec3 ret(0.);
+  {  // X
+    const Vec3 *ref = &data[((zi * size.y + yi) * size.x + s_xi)];
+    ret.x = f0 * ((ref[0].x * t0 + ref[Y].x * t1) * s_s0 +
+                  (ref[X].x * t0 + ref[X + Y].x * t1) * s_s1) +
+            f1 * ((ref[Z].x * t0 + ref[Z + Y].x * t1) * s_s0 +
+                  (ref[X + Z].x * t0 + ref[X + Y + Z].x * t1) * s_s1);
+  }
+  {  // Y
+    const Vec3 *ref = &data[((zi * size.y + s_yi) * size.x + xi)];
+    ret.y = f0 * ((ref[0].y * s_t0 + ref[Y].y * s_t1) * s0 +
+                  (ref[X].y * s_t0 + ref[X + Y].y * s_t1) * s1) +
+            f1 * ((ref[Z].y * s_t0 + ref[Z + Y].y * s_t1) * s0 +
+                  (ref[X + Z].y * s_t0 + ref[X + Y + Z].y * s_t1) * s1);
+  }
+  {  // Z
+    const Vec3 *ref = &data[((s_zi * size.y + yi) * size.x + xi)];
+    ret.z = s_f0 *
+                ((ref[0].z * t0 + ref[Y].z * t1) * s0 + (ref[X].z * t0 + ref[X + Y].z * t1) * s1) +
+            s_f1 * ((ref[Z].z * t0 + ref[Z + Y].z * t1) * s0 +
+                    (ref[X + Z].z * t0 + ref[X + Y + Z].z * t1) * s1);
+  }
+  return ret;
+}
+
+inline void setInterpolMAC(
+    Vec3 *data, const Vec3i &size, const int Z, const Vec3 &pos, const Vec3 &val, Vec3 *sumBuffer)
+{
+  BUILD_INDEX_SHIFT;
+  DEBUG_ONLY(checkIndexInterpol(size, (zi * (IndexInt)size.y + yi) * (IndexInt)size.x + xi));
+  DEBUG_ONLY(checkIndexInterpol(
+      size, (s_zi * (IndexInt)size.y + s_yi) * (IndexInt)size.x + s_xi + X + Y + Z));
+
+  // process individual components
+  {  // X
+    const IndexInt idx = (IndexInt)(zi * size.y + yi) * size.x + s_xi;
+    Vec3 *ref = &data[idx], *sum = &sumBuffer[idx];
+    Real s0f0 = s_s0 * f0, s1f0 = s_s1 * f0, s0f1 = s_s0 * f1, s1f1 = s_s1 * f1;
+    Real w0 = t0 * s0f0, wx = t0 * s1f0, wy = t1 * s0f0, wxy = t1 * s1f0;
+    Real wz = t0 * s0f1, wxz = t0 * s1f1, wyz = t1 * s0f1, wxyz = t1 * s1f1;
+
+    sum[Z].x += wz;
+    sum[X + Z].x += wxz;
+    sum[Y + Z].x += wyz;
+    sum[X + Y + Z].x += wxyz;
+    ref[Z].x += wz * val.x;
+    ref[X + Z].x += wxz * val.x;
+    ref[Y + Z].x += wyz * val.x;
+    ref[X + Y + Z].x += wxyz * val.x;
+    sum[0].x += w0;
+    sum[X].x += wx;
+    sum[Y].x += wy;
+    sum[X + Y].x += wxy;
+    ref[0].x += w0 * val.x;
+    ref[X].x += wx * val.x;
+    ref[Y].x += wy * val.x;
+    ref[X + Y].x += wxy * val.x;
+  }
+  {  // Y
+    const IndexInt idx = (IndexInt)(zi * size.y + s_yi) * size.x + xi;
+    Vec3 *ref = &data[idx], *sum = &sumBuffer[idx];
+    Real s0f0 = s0 * f0, s1f0 = s1 * f0, s0f1 = s0 * f1, s1f1 = s1 * f1;
+    Real w0 = s_t0 * s0f0, wx = s_t0 * s1f0, wy = s_t1 * s0f0, wxy = s_t1 * s1f0;
+    Real wz = s_t0 * s0f1, wxz = s_t0 * s1f1, wyz = s_t1 * s0f1, wxyz = s_t1 * s1f1;
+
+    sum[Z].y += wz;
+    sum[X + Z].y += wxz;
+    sum[Y + Z].y += wyz;
+    sum[X + Y + Z].y += wxyz;
+    ref[Z].y += wz * val.y;
+    ref[X + Z].y += wxz * val.y;
+    ref[Y + Z].y += wyz * val.y;
+    ref[X + Y + Z].y += wxyz * val.y;
+    sum[0].y += w0;
+    sum[X].y += wx;
+    sum[Y].y += wy;
+    sum[X + Y].y += wxy;
+    ref[0].y += w0 * val.y;
+    ref[X].y += wx * val.y;
+    ref[Y].y += wy * val.y;
+    ref[X + Y].y += wxy * val.y;
+  }
+  {  // Z
+    const IndexInt idx = (IndexInt)(s_zi * size.y + yi) * size.x + xi;
+    Vec3 *ref = &data[idx], *sum = &sumBuffer[idx];
+    Real s0f0 = s0 * s_f0, s1f0 = s1 * s_f0, s0f1 = s0 * s_f1, s1f1 = s1 * s_f1;
+    Real w0 = t0 * s0f0, wx = t0 * s1f0, wy = t1 * s0f0, wxy = t1 * s1f0;
+    Real wz = t0 * s0f1, wxz = t0 * s1f1, wyz = t1 * s0f1, wxyz = t1 * s1f1;
+
+    sum[0].z += w0;
+    sum[X].z += wx;
+    sum[Y].z += wy;
+    sum[X + Y].z += wxy;
+    sum[Z].z += wz;
+    sum[X + Z].z += wxz;
+    sum[Y + Z].z += wyz;
+    sum[X + Y + Z].z += wxyz;
+    ref[0].z += w0 * val.z;
+    ref[X].z += wx * val.z;
+    ref[Y].z += wy * val.z;
+    ref[X + Y].z += wxy * val.z;
+    ref[Z].z += wz * val.z;
+    ref[X + Z].z += wxz * val.z;
+    ref[Y + Z].z += wyz * val.z;
+    ref[X + Y + Z].z += wxyz * val.z;
+  }
+}
+
+#undef BUILD_INDEX
+#undef BUILD_INDEX_SHIFT
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/interpolHigh.h b/extern/mantaflow/helper/util/interpolHigh.h
new file mode 100644
index 00000000000..c2a77442b9c
--- /dev/null
+++ b/extern/mantaflow/helper/util/interpolHigh.h
@@ -0,0 +1,204 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Helper functions for higher order interpolation
+ *
+ ******************************************************************************/
+
+#ifndef _INTERPOLHIGH_H
+#define _INTERPOLHIGH_H
+
+#include "vectorbase.h"
+
+namespace Manta {
+
+template<class T> inline T cubicInterp(const Real interp, const T *points)
+{
+  T d0 = (points[2] - points[0]) * 0.5;
+  T d1 = (points[3] - points[1]) * 0.5;
+  T deltak = (points[2] - points[1]);
+
+  // disabled: if (deltak * d0 < 0.0) d0 = 0;
+  // disabled: if (deltak * d1 < 0.0) d1 = 0;
+
+  T a0 = points[1];
+  T a1 = d0;
+  T a2 = 3.0 * deltak - 2.0 * d0 - d1;
+  T a3 = -2.0 * deltak + d0 + d1;
+
+  Real squared = interp * interp;
+  Real cubed = squared * interp;
+  return a3 * cubed + a2 * squared + a1 * interp + a0;
+}
+
+template<class T> inline T interpolCubic2D(const T *data, const Vec3i &size, const Vec3 &pos)
+{
+  const Real px = pos.x - 0.5f, py = pos.y - 0.5f;
+
+  const int x1 = (int)px;
+  const int x2 = x1 + 1;
+  const int x3 = x1 + 2;
+  const int x0 = x1 - 1;
+
+  const int y1 = (int)py;
+  const int y2 = y1 + 1;
+  const int y3 = y1 + 2;
+  const int y0 = y1 - 1;
+
+  if (x0 < 0 || y0 < 0 || x3 >= size[0] || y3 >= size[1]) {
+    return interpol(data, size, 0, pos);
+  }
+
+  const Real xInterp = px - x1;
+  const Real yInterp = py - y1;
+
+  const int y0x = y0 * size[0];
+  const int y1x = y1 * size[0];
+  const int y2x = y2 * size[0];
+  const int y3x = y3 * size[0];
+
+  const T p0[] = {data[x0 + y0x], data[x1 + y0x], data[x2 + y0x], data[x3 + y0x]};
+  const T p1[] = {data[x0 + y1x], data[x1 + y1x], data[x2 + y1x], data[x3 + y1x]};
+  const T p2[] = {data[x0 + y2x], data[x1 + y2x], data[x2 + y2x], data[x3 + y2x]};
+  const T p3[] = {data[x0 + y3x], data[x1 + y3x], data[x2 + y3x], data[x3 + y3x]};
+
+  const T finalPoints[] = {cubicInterp(xInterp, p0),
+                           cubicInterp(xInterp, p1),
+                           cubicInterp(xInterp, p2),
+                           cubicInterp(xInterp, p3)};
+
+  return cubicInterp(yInterp, finalPoints);
+}
+
+template<class T>
+inline T interpolCubic(const T *data, const Vec3i &size, const int Z, const Vec3 &pos)
+{
+  if (Z == 0)
+    return interpolCubic2D(data, size, pos);
+
+  const Real px = pos.x - 0.5f, py = pos.y - 0.5f, pz = pos.z - 0.5f;
+
+  const int x1 = (int)px;
+  const int x2 = x1 + 1;
+  const int x3 = x1 + 2;
+  const int x0 = x1 - 1;
+
+  const int y1 = (int)py;
+  const int y2 = y1 + 1;
+  const int y3 = y1 + 2;
+  const int y0 = y1 - 1;
+
+  const int z1 = (int)pz;
+  const int z2 = z1 + 1;
+  const int z3 = z1 + 2;
+  const int z0 = z1 - 1;
+
+  if (x0 < 0 || y0 < 0 || z0 < 0 || x3 >= size[0] || y3 >= size[1] || z3 >= size[2]) {
+    return interpol(data, size, Z, pos);
+  }
+
+  const Real xInterp = px - x1;
+  const Real yInterp = py - y1;
+  const Real zInterp = pz - z1;
+
+  const int slabsize = size[0] * size[1];
+  const int z0Slab = z0 * slabsize;
+  const int z1Slab = z1 * slabsize;
+  const int z2Slab = z2 * slabsize;
+  const int z3Slab = z3 * slabsize;
+
+  const int y0x = y0 * size[0];
+  const int y1x = y1 * size[0];
+  const int y2x = y2 * size[0];
+  const int y3x = y3 * size[0];
+
+  const int y0z0 = y0x + z0Slab;
+  const int y1z0 = y1x + z0Slab;
+  const int y2z0 = y2x + z0Slab;
+  const int y3z0 = y3x + z0Slab;
+
+  const int y0z1 = y0x + z1Slab;
+  const int y1z1 = y1x + z1Slab;
+  const int y2z1 = y2x + z1Slab;
+  const int y3z1 = y3x + z1Slab;
+
+  const int y0z2 = y0x + z2Slab;
+  const int y1z2 = y1x + z2Slab;
+  const int y2z2 = y2x + z2Slab;
+  const int y3z2 = y3x + z2Slab;
+
+  const int y0z3 = y0x + z3Slab;
+  const int y1z3 = y1x + z3Slab;
+  const int y2z3 = y2x + z3Slab;
+  const int y3z3 = y3x + z3Slab;
+
+  // get the z0 slice
+  const T p0[] = {data[x0 + y0z0], data[x1 + y0z0], data[x2 + y0z0], data[x3 + y0z0]};
+  const T p1[] = {data[x0 + y1z0], data[x1 + y1z0], data[x2 + y1z0], data[x3 + y1z0]};
+  const T p2[] = {data[x0 + y2z0], data[x1 + y2z0], data[x2 + y2z0], data[x3 + y2z0]};
+  const T p3[] = {data[x0 + y3z0], data[x1 + y3z0], data[x2 + y3z0], data[x3 + y3z0]};
+
+  // get the z1 slice
+  const T p4[] = {data[x0 + y0z1], data[x1 + y0z1], data[x2 + y0z1], data[x3 + y0z1]};
+  const T p5[] = {data[x0 + y1z1], data[x1 + y1z1], data[x2 + y1z1], data[x3 + y1z1]};
+  const T p6[] = {data[x0 + y2z1], data[x1 + y2z1], data[x2 + y2z1], data[x3 + y2z1]};
+  const T p7[] = {data[x0 + y3z1], data[x1 + y3z1], data[x2 + y3z1], data[x3 + y3z1]};
+
+  // get the z2 slice
+  const T p8[] = {data[x0 + y0z2], data[x1 + y0z2], data[x2 + y0z2], data[x3 + y0z2]};
+  const T p9[] = {data[x0 + y1z2], data[x1 + y1z2], data[x2 + y1z2], data[x3 + y1z2]};
+  const T p10[] = {data[x0 + y2z2], data[x1 + y2z2], data[x2 + y2z2], data[x3 + y2z2]};
+  const T p11[] = {data[x0 + y3z2], data[x1 + y3z2], data[x2 + y3z2], data[x3 + y3z2]};
+
+  // get the z3 slice
+  const T p12[] = {data[x0 + y0z3], data[x1 + y0z3], data[x2 + y0z3], data[x3 + y0z3]};
+  const T p13[] = {data[x0 + y1z3], data[x1 + y1z3], data[x2 + y1z3], data[x3 + y1z3]};
+  const T p14[] = {data[x0 + y2z3], data[x1 + y2z3], data[x2 + y2z3], data[x3 + y2z3]};
+  const T p15[] = {data[x0 + y3z3], data[x1 + y3z3], data[x2 + y3z3], data[x3 + y3z3]};
+
+  // interpolate
+  const T z0Points[] = {cubicInterp(xInterp, p0),
+                        cubicInterp(xInterp, p1),
+                        cubicInterp(xInterp, p2),
+                        cubicInterp(xInterp, p3)};
+  const T z1Points[] = {cubicInterp(xInterp, p4),
+                        cubicInterp(xInterp, p5),
+                        cubicInterp(xInterp, p6),
+                        cubicInterp(xInterp, p7)};
+  const T z2Points[] = {cubicInterp(xInterp, p8),
+                        cubicInterp(xInterp, p9),
+                        cubicInterp(xInterp, p10),
+                        cubicInterp(xInterp, p11)};
+  const T z3Points[] = {cubicInterp(xInterp, p12),
+                        cubicInterp(xInterp, p13),
+                        cubicInterp(xInterp, p14),
+                        cubicInterp(xInterp, p15)};
+
+  const T finalPoints[] = {cubicInterp(yInterp, z0Points),
+                           cubicInterp(yInterp, z1Points),
+                           cubicInterp(yInterp, z2Points),
+                           cubicInterp(yInterp, z3Points)};
+
+  return cubicInterp(zInterp, finalPoints);
+}
+
+inline Vec3 interpolCubicMAC(const Vec3 *data, const Vec3i &size, const int Z, const Vec3 &pos)
+{
+  // warning - not yet optimized...
+  Real vx = interpolCubic<Vec3>(data, size, Z, pos + Vec3(0.5, 0, 0))[0];
+  Real vy = interpolCubic<Vec3>(data, size, Z, pos + Vec3(0, 0.5, 0))[1];
+  Real vz = 0.f;
+  if (Z != 0)
+    vz = interpolCubic<Vec3>(data, size, Z, pos + Vec3(0, 0, 0.5))[2];
+  return Vec3(vx, vy, vz);
+}
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/matrixbase.h b/extern/mantaflow/helper/util/matrixbase.h
new file mode 100644
index 00000000000..9875998f0be
--- /dev/null
+++ b/extern/mantaflow/helper/util/matrixbase.h
@@ -0,0 +1,394 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2015 Kiwon Um, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * GNU General Public License (GPL)
+ * http://www.gnu.org/licenses
+ *
+ * Matrix (3x3) class
+ *
+ ******************************************************************************/
+
+#ifndef MATRIXBASE_H
+#define MATRIXBASE_H
+
+#include "vectorbase.h"
+
+namespace Manta {
+
+template<typename T> class Matrix3x3 {
+ public:
+  // NOTE: default is the identity matrix!
+  explicit Matrix3x3(const T &p00 = 1,
+                     const T &p01 = 0,
+                     const T &p02 = 0,
+                     const T &p10 = 0,
+                     const T &p11 = 1,
+                     const T &p12 = 0,
+                     const T &p20 = 0,
+                     const T &p21 = 0,
+                     const T &p22 = 1)
+  {
+    v[0][0] = p00;
+    v[0][1] = p01;
+    v[0][2] = p02;
+    v[1][0] = p10;
+    v[1][1] = p11;
+    v[1][2] = p12;
+    v[2][0] = p20;
+    v[2][1] = p21;
+    v[2][2] = p22;
+  }
+
+  explicit Matrix3x3(const Vector3D<T> &diag)
+  {
+    v[0][0] = diag.x;
+    v[0][1] = 0;
+    v[0][2] = 0;
+    v[1][0] = 0;
+    v[1][1] = diag.y;
+    v[1][2] = 0;
+    v[2][0] = 0;
+    v[2][1] = 0;
+    v[2][2] = diag.z;
+  }
+
+  Matrix3x3(const Vector3D<T> &c0, const Vector3D<T> &c1, const Vector3D<T> &c2)
+  {
+    v[0][0] = c0.x;
+    v[0][1] = c1.x;
+    v[0][2] = c2.x;
+    v[1][0] = c0.y;
+    v[1][1] = c1.y;
+    v[1][2] = c2.y;
+    v[2][0] = c0.z;
+    v[2][1] = c1.z;
+    v[2][2] = c2.z;
+  }
+
+  // assignment operators
+  Matrix3x3 &operator+=(const Matrix3x3 &m)
+  {
+    v00 += m.v00;
+    v01 += m.v01;
+    v02 += m.v02;
+    v10 += m.v10;
+    v11 += m.v11;
+    v12 += m.v12;
+    v20 += m.v20;
+    v21 += m.v21;
+    v22 += m.v22;
+    return *this;
+  }
+  Matrix3x3 &operator-=(const Matrix3x3 &m)
+  {
+    v00 -= m.v00;
+    v01 -= m.v01;
+    v02 -= m.v02;
+    v10 -= m.v10;
+    v11 -= m.v11;
+    v12 -= m.v12;
+    v20 -= m.v20;
+    v21 -= m.v21;
+    v22 -= m.v22;
+    return *this;
+  }
+  Matrix3x3 &operator*=(const T s)
+  {
+    v00 *= s;
+    v01 *= s;
+    v02 *= s;
+    v10 *= s;
+    v11 *= s;
+    v12 *= s;
+    v20 *= s;
+    v21 *= s;
+    v22 *= s;
+    return *this;
+  }
+  Matrix3x3 &operator/=(const T s)
+  {
+    v00 /= s;
+    v01 /= s;
+    v02 /= s;
+    v10 /= s;
+    v11 /= s;
+    v12 /= s;
+    v20 /= s;
+    v21 /= s;
+    v22 /= s;
+    return *this;
+  }
+
+  // binary operators
+  Matrix3x3 operator+(const Matrix3x3 &m) const
+  {
+    return Matrix3x3(*this) += m;
+  }
+  Matrix3x3 operator-(const Matrix3x3 &m) const
+  {
+    return Matrix3x3(*this) -= m;
+  }
+  Matrix3x3 operator*(const Matrix3x3 &m) const
+  {
+    return Matrix3x3(v00 * m.v00 + v01 * m.v10 + v02 * m.v20,
+                     v00 * m.v01 + v01 * m.v11 + v02 * m.v21,
+                     v00 * m.v02 + v01 * m.v12 + v02 * m.v22,
+
+                     v10 * m.v00 + v11 * m.v10 + v12 * m.v20,
+                     v10 * m.v01 + v11 * m.v11 + v12 * m.v21,
+                     v10 * m.v02 + v11 * m.v12 + v12 * m.v22,
+
+                     v20 * m.v00 + v21 * m.v10 + v22 * m.v20,
+                     v20 * m.v01 + v21 * m.v11 + v22 * m.v21,
+                     v20 * m.v02 + v21 * m.v12 + v22 * m.v22);
+  }
+  Matrix3x3 operator*(const T s) const
+  {
+    return Matrix3x3(*this) *= s;
+  }
+  Vector3D<T> operator*(const Vector3D<T> &v) const
+  {
+    return Vector3D<T>(v00 * v.x + v01 * v.y + v02 * v.z,
+                       v10 * v.x + v11 * v.y + v12 * v.z,
+                       v20 * v.x + v21 * v.y + v22 * v.z);
+  }
+  Vector3D<T> transposedMul(const Vector3D<T> &v) const
+  {
+    // M^T*v
+    return Vector3D<T>(v00 * v.x + v10 * v.y + v20 * v.z,
+                       v01 * v.x + v11 * v.y + v21 * v.z,
+                       v02 * v.x + v12 * v.y + v22 * v.z);
+  }
+  Matrix3x3 transposedMul(const Matrix3x3 &m) const
+  {
+    // M^T*M
+    return Matrix3x3(v00 * m.v00 + v10 * m.v10 + v20 * m.v20,
+                     v00 * m.v01 + v10 * m.v11 + v20 * m.v21,
+                     v00 * m.v02 + v10 * m.v12 + v20 * m.v22,
+
+                     v01 * m.v00 + v11 * m.v10 + v21 * m.v20,
+                     v01 * m.v01 + v11 * m.v11 + v21 * m.v21,
+                     v01 * m.v02 + v11 * m.v12 + v21 * m.v22,
+
+                     v02 * m.v00 + v12 * m.v10 + v22 * m.v20,
+                     v02 * m.v01 + v12 * m.v11 + v22 * m.v21,
+                     v02 * m.v02 + v12 * m.v12 + v22 * m.v22);
+  }
+  Matrix3x3 mulTranspose(const Matrix3x3 &m) const
+  {
+    // M*m^T
+    return Matrix3x3(v00 * m.v00 + v01 * m.v01 + v02 * m.v02,
+                     v00 * m.v10 + v01 * m.v11 + v02 * m.v12,
+                     v00 * m.v20 + v01 * m.v21 + v02 * m.v22,
+
+                     v10 * m.v00 + v11 * m.v01 + v12 * m.v02,
+                     v10 * m.v10 + v11 * m.v11 + v12 * m.v12,
+                     v10 * m.v20 + v11 * m.v21 + v12 * m.v22,
+
+                     v20 * m.v00 + v21 * m.v01 + v22 * m.v02,
+                     v20 * m.v10 + v21 * m.v11 + v22 * m.v12,
+                     v20 * m.v20 + v21 * m.v21 + v22 * m.v22);
+  }
+
+  bool operator==(const Matrix3x3 &m) const
+  {
+    return (v00 == m.v00 && v01 == m.v01 && v02 == m.v02 && v10 == m.v10 && v11 == m.v11 &&
+            v12 == m.v12 && v20 == m.v20 && v21 == m.v21 && v22 == m.v22);
+  }
+
+  const T &operator()(const int r, const int c) const
+  {
+    return v[r][c];
+  }
+  T &operator()(const int r, const int c)
+  {
+    return const_cast<T &>(const_cast<const Matrix3x3 &>(*this)(r, c));
+  }
+
+  T trace() const
+  {
+    return v00 + v11 + v22;
+  }
+  T sumSqr() const
+  {
+    return (v00 * v00 + v01 * v01 + v02 * v02 + v10 * v10 + v11 * v11 + v12 * v12 + v20 * v20 +
+            v21 * v21 + v22 * v22);
+  }
+
+  Real determinant() const
+  {
+    return (v00 * v11 * v22 - v00 * v12 * v21 + v01 * v12 * v20 - v01 * v10 * v22 +
+            v02 * v10 * v21 - v02 * v11 * v20);
+  }
+  Matrix3x3 &transpose()
+  {
+    return *this = transposed();
+  }
+  Matrix3x3 transposed() const
+  {
+    return Matrix3x3(v00, v10, v20, v01, v11, v21, v02, v12, v22);
+  }
+  Matrix3x3 &invert()
+  {
+    return *this = inverse();
+  }
+  Matrix3x3 inverse() const
+  {
+    const Real det = determinant();  // FIXME: assert(det);
+    const Real idet = 1e0 / det;
+    return Matrix3x3(idet * (v11 * v22 - v12 * v21),
+                     idet * (v02 * v21 - v01 * v22),
+                     idet * (v01 * v12 - v02 * v11),
+                     idet * (v12 * v20 - v10 * v22),
+                     idet * (v00 * v22 - v02 * v20),
+                     idet * (v02 * v10 - v00 * v12),
+                     idet * (v10 * v21 - v11 * v20),
+                     idet * (v01 * v20 - v00 * v21),
+                     idet * (v00 * v11 - v01 * v10));
+  }
+  bool getInverse(Matrix3x3 &inv) const
+  {
+    const Real det = determinant();
+    if (det == 0e0)
+      return false;  // FIXME: is it likely to happen the floating error?
+
+    const Real idet = 1e0 / det;
+    inv.v00 = idet * (v11 * v22 - v12 * v21);
+    inv.v01 = idet * (v02 * v21 - v01 * v22);
+    inv.v02 = idet * (v01 * v12 - v02 * v11);
+
+    inv.v10 = idet * (v12 * v20 - v10 * v22);
+    inv.v11 = idet * (v00 * v22 - v02 * v20);
+    inv.v12 = idet * (v02 * v10 - v00 * v12);
+
+    inv.v20 = idet * (v10 * v21 - v11 * v20);
+    inv.v21 = idet * (v01 * v20 - v00 * v21);
+    inv.v22 = idet * (v00 * v11 - v01 * v10);
+
+    return true;
+  }
+
+  Real normOne() const
+  {
+    // the maximum absolute column sum of the matrix
+    return max(std::fabs(v00) + std::fabs(v10) + std::fabs(v20),
+               std::fabs(v01) + std::fabs(v11) + std::fabs(v21),
+               std::fabs(v02) + std::fabs(v12) + std::fabs(v22));
+  }
+  Real normInf() const
+  {
+    // the maximum absolute row sum of the matrix
+    return max(std::fabs(v00) + std::fabs(v01) + std::fabs(v02),
+               std::fabs(v10) + std::fabs(v11) + std::fabs(v12),
+               std::fabs(v20) + std::fabs(v21) + std::fabs(v22));
+  }
+
+  Vector3D<T> eigenvalues() const
+  {
+    Vector3D<T> eigen;
+
+    const Real b = -v00 - v11 - v22;
+    const Real c = v00 * (v11 + v22) + v11 * v22 - v12 * v21 - v01 * v10 - v02 * v20;
+    Real d = -v00 * (v11 * v22 - v12 * v21) - v20 * (v01 * v12 - v11 * v02) -
+             v10 * (v02 * v21 - v22 * v01);
+    const Real f = (3.0 * c - b * b) / 3.0;
+    const Real g = (2.0 * b * b * b - 9.0 * b * c + 27.0 * d) / 27.0;
+    const Real h = g * g / 4.0 + f * f * f / 27.0;
+
+    Real sign;
+    if (h > 0) {
+      Real r = -g / 2.0 + std::sqrt(h);
+      if (r < 0) {
+        r = -r;
+        sign = -1.0;
+      }
+      else
+        sign = 1.0;
+      Real s = sign * std::pow(r, 1.0 / 3.0);
+      Real t = -g / 2.0 - std::sqrt(h);
+      if (t < 0) {
+        t = -t;
+        sign = -1.0;
+      }
+      else
+        sign = 1.0;
+      Real u = sign * std::pow(t, 1.0 / 3.0);
+      eigen[0] = (s + u) - b / 3.0;
+      eigen[1] = eigen[2] = 0;
+    }
+    else if (h == 0) {
+      if (d < 0) {
+        d = -d;
+        sign = -1.0;
+      }
+      sign = 1.0;
+      eigen[0] = -1.0 * sign * std::pow(d, 1.0 / 3.0);
+      eigen[1] = eigen[2] = 0;
+    }
+    else {
+      const Real i = std::sqrt(g * g / 4.0 - h);
+      const Real j = std::pow(i, 1.0 / 3.0);
+      const Real k = std::acos(-g / (2.0 * i));
+      const Real l = -j;
+      const Real m = std::cos(k / 3.0);
+      const Real n = std::sqrt(3.0) * std::sin(k / 3.0);
+      const Real p = -b / 3.0;
+      eigen[0] = 2e0 * j * m + p;
+      eigen[1] = l * (m + n) + p;
+      eigen[2] = l * (m - n) + p;
+    }
+
+    return eigen;
+  }
+
+  static Matrix3x3 I()
+  {
+    return Matrix3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);
+  }
+
+#ifdef _WIN32
+#  pragma warning(disable : 4201)
+#endif
+  union {
+    struct {
+      T v00, v01, v02, v10, v11, v12, v20, v21, v22;
+    };
+    T v[3][3];
+    T v1[9];
+  };
+#ifdef _WIN32
+#  pragma warning(default : 4201)
+#endif
+};
+
+template<typename T1, typename T> inline Matrix3x3<T> operator*(const T1 s, const Matrix3x3<T> &m)
+{
+  return m * static_cast<T>(s);
+}
+
+template<typename T> inline Matrix3x3<T> crossProductMatrix(const Vector3D<T> &v)
+{
+  return Matrix3x3<T>(0, -v.z, v.y, v.z, 0, -v.x, -v.y, v.x, 0);
+}
+
+template<typename T> inline Matrix3x3<T> outerProduct(const Vector3D<T> &a, const Vector3D<T> &b)
+{
+  return Matrix3x3<T>(a.x * b.x,
+                      a.x * b.y,
+                      a.x * b.z,
+                      a.y * b.x,
+                      a.y * b.y,
+                      a.y * b.z,
+                      a.z * b.x,
+                      a.z * b.y,
+                      a.z * b.z);
+}
+
+typedef Matrix3x3<Real> Matrix3x3f;
+
+}  // namespace Manta
+
+#endif /* MATRIXBASE_H */
diff --git a/extern/mantaflow/helper/util/mcubes.h b/extern/mantaflow/helper/util/mcubes.h
new file mode 100644
index 00000000000..bd1c780e932
--- /dev/null
+++ b/extern/mantaflow/helper/util/mcubes.h
@@ -0,0 +1,308 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Marching cubes lookup indices
+ *
+ ******************************************************************************/
+
+#ifndef _MCUBES_H_
+#define _MCUBES_H_
+
+static const int mcEdges[24] = {0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6,
+                                6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7};
+
+static const int cubieOffsetX[8] = {0, 1, 1, 0, 0, 1, 1, 0};
+static const int cubieOffsetY[8] = {0, 0, 1, 1, 0, 0, 1, 1};
+static const int cubieOffsetZ[8] = {0, 0, 0, 0, 1, 1, 1, 1};
+
+/* which edges are needed ? */
+/* cf. http://astronomy.swin.edu.au/~pbourke/modelling/polygonise/ */
+static const short mcEdgeTable[256] = {
+    0x0,   0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a,
+    0xd03, 0xe09, 0xf00, 0x190, 0x99,  0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, 0x99c, 0x895,
+    0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90, 0x230, 0x339, 0x33,  0x13a, 0x636, 0x73f, 0x435,
+    0x53c, 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30, 0x3a0, 0x2a9, 0x1a3, 0xaa,
+    0x7a6, 0x6af, 0x5a5, 0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0, 0x460,
+    0x569, 0x663, 0x76a, 0x66,  0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963,
+    0xa69, 0xb60, 0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff,  0x3f5, 0x2fc, 0xdfc, 0xcf5, 0xfff,
+    0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0, 0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55,  0x15c,
+    0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950, 0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6,
+    0x2cf, 0x1c5, 0xcc,  0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0, 0x8c0, 0x9c9,
+    0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, 0xcc,  0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9,
+    0x7c0, 0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x55,  0x35f, 0x256,
+    0x55a, 0x453, 0x759, 0x650, 0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, 0x2fc,
+    0x3f5, 0xff,  0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0, 0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f,
+    0xd65, 0xc6c, 0x36c, 0x265, 0x16f, 0x66,  0x76a, 0x663, 0x569, 0x460, 0xca0, 0xda9, 0xea3,
+    0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa,  0x1a3, 0x2a9, 0x3a0,
+    0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636, 0x13a,
+    0x33,  0x339, 0x230, 0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, 0x69c, 0x795,
+    0x49f, 0x596, 0x29a, 0x393, 0x99,  0x190, 0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905,
+    0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0};
+
+/* triangles for the 256 intersection possibilities */
+/* cf. http://astronomy.swin.edu.au/~pbourke/modelling/polygonise/ */
+static const short mcTriTable[256][16] = {
+    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+    {3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+    {3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+    {3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+    {9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
+    {9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+    {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+    {8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+    {9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+    {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
+    {3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
+    {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
+    {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+    {4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+    {9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+    {5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+    {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
+    {9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+    {0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+    {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
+    {10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
+    {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
+    {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+    {5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+    {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+    {0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
+    {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
+    {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
+    {2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+    {7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
+    {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+    {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
+    {11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+    {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
+    {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
+    {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
+    {11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+    {1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
+    {9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+    {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
+    {2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+    {0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+    {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
+    {6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+    {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
+    {6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+    {5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
+    {1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+    {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+    {6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
+    {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
+    {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
+    {3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+    {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+    {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
+    {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
+    {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+    {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
+    {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
+    {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
+    {10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
+    {10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+    {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+    {1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+    {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
+    {0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+    {10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
+    {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+    {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
+    {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
+    {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
+    {3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+    {6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+    {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
+    {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
+    {10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+    {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
+    {7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+    {7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+    {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
+    {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
+    {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
+    {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
+    {0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
+    {7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+    {10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+    {2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+    {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
+    {7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+    {2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
+    {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
+    {10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+    {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
+    {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
+    {7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+    {6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+    {8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
+    {6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
+    {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
+    {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
+    {8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+    {0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
+    {1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+    {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
+    {10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+    {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
+    {10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+    {5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+    {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
+    {9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+    {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
+    {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
+    {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
+    {7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
+    {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
+    {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
+    {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
+    {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
+    {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
+    {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
+    {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
+    {6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+    {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
+    {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
+    {6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
+    {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
+    {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
+    {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
+    {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
+    {9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
+    {1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
+    {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
+    {0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
+    {5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
+    {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
+    {11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
+    {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
+    {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
+    {2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+    {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
+    {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
+    {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
+    {1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+    {9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+    {9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+    {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
+    {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
+    {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
+    {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
+    {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
+    {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
+    {9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
+    {5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+    {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
+    {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
+    {8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
+    {9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+    {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
+    {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
+    {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
+    {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
+    {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
+    {11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+    {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
+    {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
+    {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
+    {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
+    {1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+    {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
+    {4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+    {0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+    {3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+    {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
+    {0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+    {9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
+    {1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}};
+
+#endif
\ No newline at end of file
diff --git a/extern/mantaflow/helper/util/quaternion.h b/extern/mantaflow/helper/util/quaternion.h
new file mode 100644
index 00000000000..c4e161baee2
--- /dev/null
+++ b/extern/mantaflow/helper/util/quaternion.h
@@ -0,0 +1,103 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Basic quaternion class
+ *
+ ******************************************************************************/
+
+#ifndef _QUATERNION_H
+#define _QUATERNION_H
+
+#include "vectorbase.h"
+
+namespace Manta {
+
+//! Very basic quaternion class
+class Quaternion {
+ public:
+  //! default constructor
+  Quaternion() : x(0), y(0), z(0), w(0)
+  {
+  }
+
+  //! copy constructor
+  Quaternion(const Quaternion &q) : x(q.x), y(q.y), z(q.z), w(q.w)
+  {
+  }
+
+  //! construct a quaternion from members
+  Quaternion(Real _x, Real _y, Real _z, Real _w) : x(_x), y(_y), z(_z), w(_w)
+  {
+  }
+
+  //! construct a quaternion from imag/real parts
+  Quaternion(Vec3 i, Real r) : x(i.x), y(i.y), z(i.z), w(r)
+  {
+  }
+
+  //! Assign operator
+  inline Quaternion &operator=(const Quaternion &q)
+  {
+    x = q.x;
+    y = q.y;
+    z = q.z;
+    w = q.w;
+    return *this;
+  }
+
+  //! Assign multiplication operator
+  inline Quaternion &operator*=(const Real a)
+  {
+    x *= a;
+    y *= a;
+    z *= a;
+    w *= a;
+    return *this;
+  }
+
+  //! return inverse quaternion
+  inline Quaternion inverse() const
+  {
+    Real mag = 1.0 / (x * x + y * y + z * z + w * w);
+    return Quaternion(-x * mag, -y * mag, -z * mag, w * mag);
+  }
+
+  //! imaginary part accessor
+  inline Vec3 imag()
+  {
+    return Vec3(x, y, z);
+  }
+
+  // imaginary part
+  Real x;
+  Real y;
+  Real z;
+
+  // real part
+  Real w;
+};
+
+//! Multiplication operator
+inline Quaternion operator*(const Quaternion &q1, const Quaternion &q2)
+{
+  return Quaternion(q2.w * q1.x + q2.x * q1.w + q2.y * q1.z - q2.z * q1.y,
+                    q2.w * q1.y + q2.y * q1.w + q2.z * q1.x - q2.x * q1.z,
+                    q2.w * q1.z + q2.z * q1.w + q2.x * q1.y - q2.y * q1.x,
+                    q2.w * q1.w - q2.x * q1.x - q2.y * q1.y - q2.z * q1.z);
+}
+
+//! Multiplication operator
+inline Quaternion operator*(const Quaternion &q, const Real a)
+{
+  return Quaternion(q.x * a, q.y * a, q.z * a, q.w * a);
+}
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/randomstream.h b/extern/mantaflow/helper/util/randomstream.h
new file mode 100644
index 00000000000..35b9c7d8858
--- /dev/null
+++ b/extern/mantaflow/helper/util/randomstream.h
@@ -0,0 +1,429 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Random numbers
+ *
+ * Based on an example by Makoto Matsumoto, Takuji Nishimura, Shawn Cokus, and Richard J. Wagner
+ *
+ ******************************************************************************/
+
+#ifndef _RANDOMSTREAM_H
+#define _RANDOMSTREAM_H
+
+namespace Manta {
+
+#include <iostream>
+#include <stdio.h>
+#include <time.h>
+#include "vectorbase.h"
+
+class MTRand {
+  // Data
+ public:
+  typedef unsigned long uint32;  // unsigned integer type, at least 32 bits
+
+  enum { N = 624 };       // length of state vector
+  enum { SAVE = N + 1 };  // length of array for save()
+
+ protected:
+  enum { M = 397 };  // period parameter
+
+  uint32 state[N];  // internal state
+  uint32 *pNext;    // next value to get from state
+  int left;         // number of values left before reload needed
+
+  // Methods
+ public:
+  MTRand(const uint32 &oneSeed);                               // initialize with a simple uint32
+  MTRand(uint32 *const bigSeed, uint32 const seedLength = N);  // or an array
+  MTRand();  // auto-initialize with /dev/urandom or time() and clock()
+
+  // Do NOT use for CRYPTOGRAPHY without securely hashing several returned
+  // values together, otherwise the generator state can be learned after
+  // reading 624 consecutive values.
+
+  // Access to 32-bit random numbers
+  double rand();                       // real number in [0,1]
+  double rand(const double &n);        // real number in [0,n]
+  double randExc();                    // real number in [0,1)
+  double randExc(const double &n);     // real number in [0,n)
+  double randDblExc();                 // real number in (0,1)
+  double randDblExc(const double &n);  // real number in (0,n)
+  uint32 randInt();                    // integer in [0,2^32-1]
+  uint32 randInt(const uint32 &n);     // integer in [0,n] for n < 2^32
+  double operator()()
+  {
+    return rand();
+  }  // same as rand()
+
+  // Access to 53-bit random numbers (capacity of IEEE double precision)
+  double rand53();  // real number in [0,1)
+
+  // Access to nonuniform random number distributions
+  double randNorm(const double &mean = 0.0, const double &variance = 1.0);
+
+  // Re-seeding functions with same behavior as initializers
+  void seed(const uint32 oneSeed);
+  void seed(uint32 *const bigSeed, const uint32 seedLength = N);
+  void seed();
+
+  // Saving and loading generator state
+  void save(uint32 *saveArray) const;  // to array of size SAVE
+  void load(uint32 *const loadArray);  // from such array
+  friend std::ostream &operator<<(std::ostream &os, const MTRand &mtrand);
+  friend std::istream &operator>>(std::istream &is, MTRand &mtrand);
+
+ protected:
+  void initialize(const uint32 oneSeed);
+  void reload();
+  uint32 hiBit(const uint32 &u) const
+  {
+    return u & 0x80000000UL;
+  }
+  uint32 loBit(const uint32 &u) const
+  {
+    return u & 0x00000001UL;
+  }
+  uint32 loBits(const uint32 &u) const
+  {
+    return u & 0x7fffffffUL;
+  }
+  uint32 mixBits(const uint32 &u, const uint32 &v) const
+  {
+    return hiBit(u) | loBits(v);
+  }
+  uint32 twist(const uint32 &m, const uint32 &s0, const uint32 &s1) const
+  {
+    return m ^ (mixBits(s0, s1) >> 1) ^ (-loBit(s1) & 0x9908b0dfUL);
+  }
+  static uint32 hash(time_t t, clock_t c);
+};
+
+inline MTRand::MTRand(const uint32 &oneSeed)
+{
+  seed(oneSeed);
+}
+
+inline MTRand::MTRand(uint32 *const bigSeed, const uint32 seedLength)
+{
+  seed(bigSeed, seedLength);
+}
+
+inline MTRand::MTRand()
+{
+  seed();
+}
+
+inline double MTRand::rand()
+{
+  return double(randInt()) * (1.0 / 4294967295.0);
+}
+
+inline double MTRand::rand(const double &n)
+{
+  return rand() * n;
+}
+
+inline double MTRand::randExc()
+{
+  return double(randInt()) * (1.0 / 4294967296.0);
+}
+
+inline double MTRand::randExc(const double &n)
+{
+  return randExc() * n;
+}
+
+inline double MTRand::randDblExc()
+{
+  return (double(randInt()) + 0.5) * (1.0 / 4294967296.0);
+}
+
+inline double MTRand::randDblExc(const double &n)
+{
+  return randDblExc() * n;
+}
+
+inline double MTRand::rand53()
+{
+  uint32 a = randInt() >> 5, b = randInt() >> 6;
+  return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);  // by Isaku Wada
+}
+
+inline double MTRand::randNorm(const double &mean, const double &variance)
+{
+  // Return a real number from a normal (Gaussian) distribution with given
+  // mean and variance by Box-Muller method
+  double r = sqrt(-2.0 * log(1.0 - randDblExc())) * variance;
+  double phi = 2.0 * 3.14159265358979323846264338328 * randExc();
+  return mean + r * cos(phi);
+}
+
+inline MTRand::uint32 MTRand::randInt()
+{
+  // Pull a 32-bit integer from the generator state
+  // Every other access function simply transforms the numbers extracted here
+
+  if (left == 0)
+    reload();
+  --left;
+
+  uint32 s1;
+  s1 = *pNext++;
+  s1 ^= (s1 >> 11);
+  s1 ^= (s1 << 7) & 0x9d2c5680UL;
+  s1 ^= (s1 << 15) & 0xefc60000UL;
+  return (s1 ^ (s1 >> 18));
+}
+
+inline MTRand::uint32 MTRand::randInt(const uint32 &n)
+{
+  // Find which bits are used in n
+  // Optimized by Magnus Jonsson (magnus@smartelectronix.com)
+  uint32 used = n;
+  used |= used >> 1;
+  used |= used >> 2;
+  used |= used >> 4;
+  used |= used >> 8;
+  used |= used >> 16;
+
+  // Draw numbers until one is found in [0,n]
+  uint32 i;
+  do
+    i = randInt() & used;  // toss unused bits to shorten search
+  while (i > n);
+  return i;
+}
+
+inline void MTRand::seed(const uint32 oneSeed)
+{
+  // Seed the generator with a simple uint32
+  initialize(oneSeed);
+  reload();
+}
+
+inline void MTRand::seed(uint32 *const bigSeed, const uint32 seedLength)
+{
+  // Seed the generator with an array of uint32's
+  // There are 2^19937-1 possible initial states.  This function allows
+  // all of those to be accessed by providing at least 19937 bits (with a
+  // default seed length of N = 624 uint32's).  Any bits above the lower 32
+  // in each element are discarded.
+  // Just call seed() if you want to get array from /dev/urandom
+  initialize(19650218UL);
+  const unsigned int Nenum = N;
+  int i = 1;
+  uint32 j = 0;
+  int k = (Nenum > seedLength ? Nenum : seedLength);
+  for (; k; --k) {
+    state[i] = state[i] ^ ((state[i - 1] ^ (state[i - 1] >> 30)) * 1664525UL);
+    state[i] += (bigSeed[j] & 0xffffffffUL) + j;
+    state[i] &= 0xffffffffUL;
+    ++i;
+    ++j;
+    if (i >= N) {
+      state[0] = state[N - 1];
+      i = 1;
+    }
+    if (j >= seedLength)
+      j = 0;
+  }
+  for (k = N - 1; k; --k) {
+    state[i] = state[i] ^ ((state[i - 1] ^ (state[i - 1] >> 30)) * 1566083941UL);
+    state[i] -= i;
+    state[i] &= 0xffffffffUL;
+    ++i;
+    if (i >= N) {
+      state[0] = state[N - 1];
+      i = 1;
+    }
+  }
+  state[0] = 0x80000000UL;  // MSB is 1, assuring non-zero initial array
+  reload();
+}
+
+inline void MTRand::seed()
+{
+  // Seed the generator with an array from /dev/urandom if available
+  // Otherwise use a hash of time() and clock() values
+
+  // First try getting an array from /dev/urandom
+  FILE *urandom = fopen("/dev/urandom", "rb");
+  if (urandom) {
+    uint32 bigSeed[N];
+    uint32 *s = bigSeed;
+    int i = N;
+    bool success = true;
+    while (success && i--)
+      success = fread(s++, sizeof(uint32), 1, urandom);
+    fclose(urandom);
+    if (success) {
+      seed(bigSeed, N);
+      return;
+    }
+  }
+
+  // Was not successful, so use time() and clock() instead
+  seed(hash(time(NULL), clock()));
+}
+
+inline void MTRand::initialize(const uint32 intseed)
+{
+  // Initialize generator state with seed
+  // See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
+  // In previous versions, most significant bits (MSBs) of the seed affect
+  // only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
+  uint32 *s = state;
+  uint32 *r = state;
+  int i = 1;
+  *s++ = intseed & 0xffffffffUL;
+  for (; i < N; ++i) {
+    *s++ = (1812433253UL * (*r ^ (*r >> 30)) + i) & 0xffffffffUL;
+    r++;
+  }
+}
+
+inline void MTRand::reload()
+{
+  // Generate N new values in state
+  // Made clearer and faster by Matthew Bellew (matthew.bellew@home.com)
+  uint32 *p = state;
+  int i;
+  for (i = N - M; i--; ++p)
+    *p = twist(p[M], p[0], p[1]);
+  for (i = M; --i; ++p)
+    *p = twist(p[M - N], p[0], p[1]);
+  *p = twist(p[M - N], p[0], state[0]);
+
+  left = N, pNext = state;
+}
+
+inline MTRand::uint32 MTRand::hash(time_t t, clock_t c)
+{
+  // Get a uint32 from t and c
+  // Better than uint32(x) in case x is floating point in [0,1]
+  // Based on code by Lawrence Kirby (fred@genesis.demon.co.uk)
+
+  static uint32 differ = 0;  // guarantee time-based seeds will change
+
+  uint32 h1 = 0;
+  unsigned char *p = (unsigned char *)&t;
+  for (size_t i = 0; i < sizeof(t); ++i) {
+    h1 *= std::numeric_limits<unsigned char>::max() + 2U;
+    h1 += p[i];
+  }
+  uint32 h2 = 0;
+  p = (unsigned char *)&c;
+  for (size_t j = 0; j < sizeof(c); ++j) {
+    h2 *= std::numeric_limits<unsigned char>::max() + 2U;
+    h2 += p[j];
+  }
+  return (h1 + differ++) ^ h2;
+}
+
+inline void MTRand::save(uint32 *saveArray) const
+{
+  uint32 *sa = saveArray;
+  const uint32 *s = state;
+  int i = N;
+  for (; i--; *sa++ = *s++) {
+  }
+  *sa = left;
+}
+
+inline void MTRand::load(uint32 *const loadArray)
+{
+  uint32 *s = state;
+  uint32 *la = loadArray;
+  int i = N;
+  for (; i--; *s++ = *la++) {
+  }
+  left = *la;
+  pNext = &state[N - left];
+}
+
+inline std::ostream &operator<<(std::ostream &os, const MTRand &mtrand)
+{
+  const MTRand::uint32 *s = mtrand.state;
+  int i = mtrand.N;
+  for (; i--; os << *s++ << "\t") {
+  }
+  return os << mtrand.left;
+}
+
+inline std::istream &operator>>(std::istream &is, MTRand &mtrand)
+{
+  MTRand::uint32 *s = mtrand.state;
+  int i = mtrand.N;
+  for (; i--; is >> *s++) {
+  }
+  is >> mtrand.left;
+  mtrand.pNext = &mtrand.state[mtrand.N - mtrand.left];
+  return is;
+}
+
+// simple interface to mersenne twister
+class RandomStream {
+ public:
+  inline RandomStream(long seed) : mtr(seed){};
+  ~RandomStream()
+  {
+  }
+
+  /*! get a random number from the stream */
+  inline double getDouble(void)
+  {
+    return mtr.rand();
+  };
+  inline float getFloat(void)
+  {
+    return (float)mtr.rand();
+  };
+
+  inline float getFloat(float min, float max)
+  {
+    return mtr.rand(max - min) + min;
+  };
+  inline float getRandNorm(float mean, float var)
+  {
+    return mtr.randNorm(mean, var);
+  };
+
+#if FLOATINGPOINT_PRECISION == 1
+  inline Real getReal()
+  {
+    return getFloat();
+  }
+
+#else
+  inline Real getReal()
+  {
+    return getDouble();
+  }
+#endif
+
+  inline Vec3 getVec3()
+  {
+    Real a = getReal(), b = getReal(), c = getReal();
+    return Vec3(a, b, c);
+  }
+  inline Vec3 getVec3Norm()
+  {
+    Vec3 a = getVec3();
+    normalize(a);
+    return a;
+  }
+
+ private:
+  MTRand mtr;
+};
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/rcmatrix.h b/extern/mantaflow/helper/util/rcmatrix.h
new file mode 100644
index 00000000000..39951cece2e
--- /dev/null
+++ b/extern/mantaflow/helper/util/rcmatrix.h
@@ -0,0 +1,1112 @@
+//
+//  Helper matrix class, RCMatrix.h
+//  Required for PD optimizations (guiding)
+//  Thanks to Ryoichi Ando, and Robert Bridson
+//
+
+#ifndef RCMATRIX3_H
+#define RCMATRIX3_H
+
+#include <iterator>
+#include <cassert>
+#include <vector>
+#include <fstream>
+
+// index type
+#define int_index long long
+
+// link to omp & tbb for now
+#if OPENMP == 1 || TBB == 1
+#  define MANTA_ENABLE_PARALLEL 0
+// allow the preconditioner to be computed in parallel? (can lead to slightly non-deterministic
+// results)
+#  define MANTA_ENABLE_PARALLEL_PC 0
+// use c++11 code?
+#  define MANTA_USE_CPP11 1
+#else
+#  define MANTA_ENABLE_PARALLEL 0
+#  define MANTA_ENABLE_PARALLEL_PC 0
+#  define MANTA_USE_CPP11 0
+#endif
+
+#if MANTA_ENABLE_PARALLEL == 1
+#  include <thread>
+#  include <algorithm>
+
+static const int manta_num_threads = std::thread::hardware_concurrency();
+
+// For clang
+#  define parallel_for(total_size) \
+    { \
+      int_index parallel_array_size = (total_size); \
+      std::vector<std::thread> threads(manta_num_threads); \
+      for (int thread_number = 0; thread_number < manta_num_threads; thread_number++) { \
+  threads[thread_number] = std::thread([&](int_index parallel_array_size, int_index thread_number ) { \
+		for( int_index parallel_index=thread_number; parallel_index < parallel_array_size; parallel_index += manta_num_threads ) {
+
+#  define parallel_end \
+    } \
+    },parallel_array_size,thread_number); \
+    } \
+    for (auto &thread : threads) \
+      thread.join(); \
+    }
+
+#  define parallel_block \
+    { \
+      std::vector<std::thread> threads; \
+      {
+
+#  define do_parallel threads.push_back( std::thread([&]() {
+#  define do_end \
+    } ) );
+
+#  define block_end \
+    } \
+    for (auto &thread : threads) { \
+      thread.join(); \
+    } \
+    }
+
+#else
+
+#  define parallel_for(size) \
+    { \
+      int thread_number = 0; \
+      int_index parallel_index = 0; \
+      for (int_index parallel_index = 0; parallel_index < (int_index)size; parallel_index++) {
+#  define parallel_end \
+    } \
+    thread_number = parallel_index = 0; \
+    }
+
+#  define parallel_block
+#  define do_parallel
+#  define do_end
+#  define block_end
+
+#endif
+
+#include "vectorbase.h"
+
+namespace Manta {
+
+static const unsigned default_expected_none_zeros = 7;
+
+template<class N, class T> struct RCMatrix {
+  struct RowEntry {
+    std::vector<N> index;
+    std::vector<T> value;
+  };
+  RCMatrix() : n(0), expected_none_zeros(default_expected_none_zeros)
+  {
+  }
+  RCMatrix(N size, N expected_none_zeros = default_expected_none_zeros)
+      : n(0), expected_none_zeros(expected_none_zeros)
+  {
+    resize(size);
+  }
+  RCMatrix(const RCMatrix &m) : n(0), expected_none_zeros(default_expected_none_zeros)
+  {
+    init(m);
+  }
+  RCMatrix &operator=(const RCMatrix &m)
+  {
+    expected_none_zeros = m.expected_none_zeros;
+    init(m);
+    return *this;
+  }
+  RCMatrix &operator=(RCMatrix &&m)
+  {
+    matrix = m.matrix;
+    offsets = m.offsets;
+    expected_none_zeros = m.expected_none_zeros;
+    n = m.n;
+    m.n = 0;
+    m.matrix.clear();
+    m.offsets.clear();
+    return *this;
+  }
+  RCMatrix(RCMatrix &&m)
+      : n(m.n), expected_none_zeros(m.expected_none_zeros), matrix(m.matrix), offsets(m.offsets)
+  {
+    m.n = 0;
+    m.matrix.clear();
+    m.offsets.clear();
+  }
+  void init(const RCMatrix &m)
+  {
+    expected_none_zeros = m.expected_none_zeros;
+    resize(m.n);
+    parallel_for(n)
+    {
+      N i = parallel_index;
+      if (m.matrix[i]) {
+        alloc_row(i);
+        matrix[i]->index = m.matrix[i]->index;
+        matrix[i]->value = m.matrix[i]->value;
+      }
+      else {
+        dealloc_row(i);
+      }
+    }
+    parallel_end
+  }
+  ~RCMatrix()
+  {
+    clear();
+  }
+  void clear()
+  {
+    for (N i = 0; i < n; i++) {
+      dealloc_row(i);
+      matrix[i] = NULL;
+      if (offsets.size())
+        offsets[i] = 0;
+    }
+  };
+  bool empty(N i) const
+  {
+    return matrix[i] == NULL;
+  }
+  N row_nonzero_size(N i) const
+  {
+    return matrix[i] == NULL ? 0 : matrix[i]->index.size();
+  }
+  void resize(N size, N expected_none_zeros = 0)
+  {
+    if (!expected_none_zeros) {
+      expected_none_zeros = this->expected_none_zeros;
+    }
+    if (n > size) {
+      // Shrinking
+      for (N i = size ? size - 1 : 0; i < n; i++)
+        dealloc_row(i);
+      matrix.resize(size);
+    }
+    else if (n < size) {
+      // Expanding
+      matrix.resize(size);
+      for (N i = n; i < size; i++) {
+        matrix[i] = NULL;
+        if (offsets.size())
+          offsets[i] = 0;
+      }
+    }
+    n = size;
+  }
+  void alloc_row(N i)
+  {
+    assert(i < n);
+    if (!matrix[i]) {
+      matrix[i] = new RowEntry;
+      matrix[i]->index.reserve(expected_none_zeros);
+      matrix[i]->value.reserve(expected_none_zeros);
+      if (offsets.size())
+        offsets[i] = 0;
+    }
+  }
+  void dealloc_row(N i)
+  {
+    assert(i < n);
+    if (matrix[i]) {
+      if (offsets.empty() || !offsets[i])
+        delete matrix[i];
+      matrix[i] = NULL;
+      if (offsets.size())
+        offsets[i] = 0;
+    }
+  }
+  T operator()(N i, N j) const
+  {
+    assert(i < n);
+    for (Iterator it = row_begin(i); it; ++it) {
+      if (it.index() == j)
+        return it.value();
+    }
+    return T(0.0);
+  }
+  void add_to_element_checked(N i, N j, T val)
+  {
+    if ((i < 0) || (j < 0) || (i >= n) || (j >= n))
+      return;
+    add_to_element(i, j, val);
+  }
+  void add_to_element(N i, N j, T increment_value)
+  {
+    if (std::abs(increment_value) > VECTOR_EPSILON) {
+      assert(i < n);
+      assert(offsets.empty() || offsets[i] == 0);
+      alloc_row(i);
+      std::vector<N> &index = matrix[i]->index;
+      std::vector<T> &value = matrix[i]->value;
+      for (N k = 0; k < (N)index.size(); ++k) {
+        if (index[k] == j) {
+          value[k] += increment_value;
+          return;
+        }
+        else if (index[k] > j) {
+          index.insert(index.begin() + k, j);
+          value.insert(value.begin() + k, increment_value);
+          return;
+        }
+      }
+      index.push_back(j);
+      value.push_back(increment_value);
+    }
+  }
+
+  void set_element(N i, N j, T v)
+  {
+    if (std::abs(v) > VECTOR_EPSILON) {
+      assert(i < n);
+      assert(offsets.empty() || offsets[i] == 0);
+      alloc_row(i);
+      std::vector<N> &index = matrix[i]->index;
+      std::vector<T> &value = matrix[i]->value;
+      for (N k = 0; k < (N)index.size(); ++k) {
+        if (index[k] == j) {
+          value[k] = v;
+          return;
+        }
+        else if (index[k] > j) {
+          index.insert(index.begin() + k, j);
+          value.insert(value.begin() + k, v);
+          return;
+        }
+      }
+      index.push_back(j);
+      value.push_back(v);
+    }
+  }
+
+  // Make sure that j is the biggest column in the row, no duplication allowed
+  void fix_element(N i, N j, T v)
+  {
+    if (std::abs(v) > VECTOR_EPSILON) {
+      assert(i < n);
+      assert(offsets.empty() || offsets[i] == 0);
+      alloc_row(i);
+      std::vector<N> &index = matrix[i]->index;
+      std::vector<T> &value = matrix[i]->value;
+      index.push_back(j);
+      value.push_back(v);
+    }
+  }
+  int_index trim_zero_entries(double e = VECTOR_EPSILON)
+  {
+    std::vector<int_index> deleted_entries(n, 0);
+    parallel_for(n)
+    {
+      N i = parallel_index;
+      if (matrix[i]) {
+        std::vector<N> &index = matrix[i]->index;
+        std::vector<T> &value = matrix[i]->value;
+        N head = 0;
+        N k = 0;
+        for (k = 0; k < index.size(); ++k) {
+          if (std::abs(value[k]) > e) {
+            index[head] = index[k];
+            value[head] = value[k];
+            ++head;
+          }
+        }
+        if (head != k) {
+          index.erase(index.begin() + head, index.end());
+          value.erase(value.begin() + head, value.end());
+          deleted_entries[i] += k - head;
+        }
+        if (!offsets.size() && !head) {
+          remove_row(i);
+        }
+      }
+    }
+    parallel_end
+        //
+        int_index sum_deleted(0);
+    for (int_index i = 0; i < n; i++)
+      sum_deleted += deleted_entries[i];
+    return sum_deleted;
+  }
+  void remove_reference(N i)
+  {
+    if (offsets.size() && offsets[i] && matrix[i]) {
+      RowEntry *save = matrix[i];
+      matrix[i] = new RowEntry;
+      *matrix[i] = *save;
+      for (N &index : matrix[i]->index)
+        index += offsets[i];
+      offsets[i] = 0;
+    }
+  }
+  void remove_row(N i)
+  {
+    dealloc_row(i);
+  }
+  bool is_symmetric(double e = VECTOR_EPSILON) const
+  {
+    std::vector<bool> flags(n, true);
+    parallel_for(n)
+    {
+      N i = parallel_index;
+      bool flag = true;
+      for (Iterator it = row_begin(i); it; ++it) {
+        N index = it.index();
+        T value = it.value();
+        if (std::abs(value) > e) {
+          bool found_entry = false;
+          for (Iterator it_i = row_begin(index); it_i; ++it_i) {
+            if (it_i.index() == i) {
+              found_entry = true;
+              if (std::abs(value - it_i.value()) > e) {
+                flag = false;
+                break;
+              }
+            }
+          }
+          if (!found_entry)
+            flag = false;
+          if (!flag)
+            break;
+        }
+      }
+      flags[i] = flag;
+    }
+    parallel_end for (N i = 0; i < matrix.size(); ++i)
+    {
+      if (!flags[i])
+        return false;
+    }
+    return true;
+  }
+
+  void expand()
+  {
+    if (offsets.empty())
+      return;
+    for (N i = 1; i < n; i++) {
+      if (offsets[i]) {
+        RowEntry *ref = matrix[i];
+        matrix[i] = new RowEntry;
+        *matrix[i] = *ref;
+        for (N j = 0; j < (N)matrix[i]->index.size(); j++) {
+          matrix[i]->index[j] += offsets[i];
+        }
+      }
+    }
+    offsets.resize(0);
+  }
+
+  N column(N i) const
+  {
+    return empty(i) ? 0 : row_begin(i, row_nonzero_size(i) - 1).index();
+  }
+  N getColumnSize() const
+  {
+    N max_column(0);
+    auto column = [&](N i) {
+      N max_column(0);
+      for (Iterator it = row_begin(i); it; ++it)
+        max_column = std::max(max_column, it.index());
+      return max_column + 1;
+    };
+    for (N i = 0; i < n; i++)
+      max_column = std::max(max_column, column(i));
+    return max_column;
+  }
+  N getNonzeroSize() const
+  {
+    N nonzeros(0);
+    for (N i = 0; i < n; ++i) {
+      nonzeros += row_nonzero_size(i);
+    }
+    return nonzeros;
+  }
+  class Iterator : std::iterator<std::input_iterator_tag, T> {
+   public:
+    Iterator(const RowEntry *rowEntry, N k, N offset) : rowEntry(rowEntry), k(k), offset(offset)
+    {
+    }
+    operator bool() const
+    {
+      return rowEntry != NULL && k < (N)rowEntry->index.size();
+    }
+    Iterator &operator++()
+    {
+      ++k;
+      return *this;
+    }
+    T value() const
+    {
+      return rowEntry->value[k];
+    }
+    N index() const
+    {
+      return rowEntry->index[k] + offset;
+    }
+    N index_raw() const
+    {
+      return rowEntry->index[k];
+    }
+    N size() const
+    {
+      return rowEntry == NULL ? 0 : rowEntry->index.size();
+    }
+
+   protected:
+    const RowEntry *rowEntry;
+    N k, offset;
+  };
+  Iterator row_begin(N n, N k = 0) const
+  {
+    return Iterator(matrix[n], k, offsets.size() ? offsets[n] : 0);
+  }
+  class DynamicIterator : public Iterator {
+   public:
+    DynamicIterator(RowEntry *rowEntry, N k, N offset)
+        : rowEntry(rowEntry), Iterator(rowEntry, k, offset)
+    {
+    }
+    void setValue(T value)
+    {
+      rowEntry->value[Iterator::k] = value;
+    }
+    void setIndex(N index)
+    {
+      rowEntry->index[Iterator::k] = index;
+    }
+
+   protected:
+    RowEntry *rowEntry;
+  };
+  DynamicIterator dynamic_row_begin(N n, N k = 0)
+  {
+    N offset = offsets.size() ? offsets[n] : 0;
+    if (offset) {
+      printf("---- Warning ----\n");
+      printf("Dynamic iterator is not allowed for referenced rows.\n");
+      printf("You should be very careful otherwise this causes some bugs.\n");
+      printf(
+          "We encourage you that you convert this row into a raw format, then loop over it...\n");
+      printf("-----------------\n");
+      exit(0);
+    }
+    return DynamicIterator(matrix[n], k, offset);
+  }
+  RCMatrix transpose(N rowsize = 0,
+                     unsigned expected_none_zeros = default_expected_none_zeros) const
+  {
+    if (!rowsize)
+      rowsize = getColumnSize();
+    RCMatrix result(rowsize, expected_none_zeros);
+    for (N i = 0; i < n; i++) {
+      for (Iterator it = row_begin(i); it; ++it)
+        result.fix_element(it.index(), i, it.value());
+    }
+#if MANTA_USE_CPP11 == 1
+    return std::move(result);
+#else
+    return result;
+#endif
+  }
+
+  RCMatrix getKtK() const
+  {
+    RCMatrix m = transpose();
+    RCMatrix result(n, expected_none_zeros);
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      for (Iterator it_A = m.row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        assert(j < n);
+        T a = it_A.value();
+        if (std::abs(a) > VECTOR_EPSILON) {
+          for (Iterator it_B = row_begin(j); it_B; ++it_B) {
+            // result.add_to_element(i,it_B.index(),it_B.value()*a);
+            double value = it_B.value() * a;
+            if (std::abs(value) > VECTOR_EPSILON)
+              result.add_to_element(i, it_B.index(), value);
+          }
+        }
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix operator*(const RCMatrix &m) const
+  {
+    RCMatrix result(n, expected_none_zeros);
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        assert(j < m.n);
+        T a = it_A.value();
+        if (std::abs(a) > VECTOR_EPSILON) {
+          for (Iterator it_B = m.row_begin(j); it_B; ++it_B) {
+            // result.add_to_element(i,it_B.index(),it_B.value()*a);
+            double value = it_B.value() * a;
+            if (std::abs(value) > VECTOR_EPSILON)
+              result.add_to_element(i, it_B.index(), value);
+          }
+        }
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix sqrt() const
+  {
+    RCMatrix result(n, expected_none_zeros);
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        result.set_element(i, j, std::sqrt(it_A.value()));
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix operator*(const double k) const
+  {
+    RCMatrix result(n, expected_none_zeros);
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        result.add_to_element(i, j, it_A.value() * k);
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix applyKernel(const RCMatrix &kernel, const int nx, const int ny) const
+  {
+    RCMatrix result(n, expected_none_zeros);
+    // find center position of kernel (half of kernel size)
+    int kCols = kernel.n, kRows = kernel.n, rows = nx, cols = ny;
+    int kCenterX = kCols / 2;
+    int kCenterY = kRows / 2;
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      if (i >= rows)
+        break;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        if (j >= cols)
+          break;
+        for (int m = 0; m < kRows; ++m) {    // kernel rows
+          int mm = kRows - 1 - m;            // row index of flipped kernel
+          for (int n = 0; n < kCols; ++n) {  // kernel columns
+            int nn = kCols - 1 - n;          // column index of flipped kernel
+            // index of input signal, used for checking boundary
+            int ii = i + (m - kCenterY);
+            int jj = j + (n - kCenterX);
+            // ignore input samples which are out of bound
+            if (ii >= 0 && ii < rows && jj >= 0 && jj < cols)
+              result.add_to_element(i, j, (*this)(ii, jj) * kernel(mm, nn));
+          }
+        }
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix applyHorizontalKernel(const RCMatrix &kernel, const int nx, const int ny) const
+  {
+    RCMatrix result(n, expected_none_zeros);
+    // find center position of kernel (half of kernel size)
+    int kCols = kernel.n, kRows = 1, rows = nx, cols = ny;
+    int kCenterX = kCols / 2;
+    int kCenterY = kRows / 2;
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      if (i >= rows)
+        break;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        if (j >= cols)
+          break;
+        for (int m = 0; m < kRows; ++m) {    // kernel rows
+          int mm = kRows - 1 - m;            // row index of flipped kernel
+          for (int n = 0; n < kCols; ++n) {  // kernel columns
+            int nn = kCols - 1 - n;          // column index of flipped kernel
+            // index of input signal, used for checking boundary
+            int ii = i + (m - kCenterY);
+            int jj = j + (n - kCenterX);
+            // ignore input samples which are out of bound
+            if (ii >= 0 && ii < rows && jj >= 0 && jj < cols)
+              result.add_to_element(i, j, (*this)(ii, jj) * kernel(mm, nn));
+          }
+        }
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix applyVerticalKernel(const RCMatrix &kernel, const int nx, const int ny) const
+  {
+    RCMatrix result(n, expected_none_zeros);
+    // find center position of kernel (half of kernel size)
+    int kCols = 1, kRows = kernel.n, rows = nx, cols = ny;
+    int kCenterX = kCols / 2;
+    int kCenterY = kRows / 2;
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      if (i >= rows)
+        break;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        if (j >= cols)
+          break;
+        for (int m = 0; m < kRows; ++m) {    // kernel rows
+          int mm = kRows - 1 - m;            // row index of flipped kernel
+          for (int n = 0; n < kCols; ++n) {  // kernel columns
+            int nn = kCols - 1 - n;          // column index of flipped kernel
+            // index of input signal, used for checking boundary
+            int ii = i + (m - kCenterY);
+            int jj = j + (n - kCenterX);
+            // ignore input samples which are out of bound
+            if (ii >= 0 && ii < rows && jj >= 0 && jj < cols)
+              result.add_to_element(i, j, (*this)(ii, jj) * kernel(mm, nn));
+          }
+        }
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix applySeparableKernel(const RCMatrix &kernelH,
+                                const RCMatrix &kernelV,
+                                const int nx,
+                                const int ny) const
+  {
+    return applyHorizontalKernel(kernelH, nx, ny).applyVerticalKernel(kernelV, nx, ny);
+  }
+
+  RCMatrix applySeparableKernelTwice(const RCMatrix &kernelH,
+                                     const RCMatrix &kernelV,
+                                     const int nx,
+                                     const int ny) const
+  {
+    return applySeparableKernel(kernelH, kernelV, nx, ny)
+        .applySeparableKernel(kernelH, kernelV, nx, ny);
+  }
+
+  std::vector<T> operator*(const std::vector<T> &rhs) const
+  {
+    std::vector<T> result(n, 0.0);
+    multiply(rhs, result);
+#if MANTA_USE_CPP11 == 1
+    return std::move(result);
+#else
+    return result;
+#endif
+  }
+  void multiply(const std::vector<T> &rhs, std::vector<T> &result) const
+  {
+    result.resize(n);
+    for (N i = 0; i < n; i++) {
+      T new_value = 0.0;
+      for (Iterator it = row_begin(i); it; ++it) {
+        N j_index = it.index();
+        assert(j_index < rhs.size());
+        new_value += rhs[j_index] * it.value();
+      }
+      result[i] = new_value;
+    }
+  }
+  RCMatrix operator+(const RCMatrix &m) const
+  {
+    RCMatrix A(*this);
+    return std::move(A.add(m));
+  }
+  RCMatrix &add(const RCMatrix &m)
+  {
+    if (m.n > n)
+      resize(m.n);
+    parallel_for(m.n)
+    {
+      N i = parallel_index;
+      for (Iterator it = m.row_begin(i); it; ++it) {
+        add_to_element(i, it.index(), it.value());
+      }
+    }
+    parallel_end return *this;
+  }
+  RCMatrix operator-(const RCMatrix &m) const
+  {
+    RCMatrix A(*this);
+    return std::move(A.sub(m));
+  }
+  RCMatrix &sub(const RCMatrix &m)
+  {
+    if (m.n > n)
+      resize(m.n);
+    parallel_for(m.n)
+    {
+      N i = parallel_index;
+      for (Iterator it = m.row_begin(i); it; ++it) {
+        add_to_element(i, it.index(), -it.value());
+      }
+    }
+    parallel_end return *this;
+  }
+  RCMatrix &replace(const RCMatrix &m, int rowInd, int colInd)
+  {
+    if (m.n > n)
+      resize(m.n);
+    parallel_for(m.n)
+    {
+      N i = parallel_index;
+      for (Iterator it = m.row_begin(i); it; ++it) {
+        set_element(i + rowInd, it.index() + colInd, it.value());
+      }
+    }
+    parallel_end return *this;
+  }
+  Real max_residual(const std::vector<T> &lhs, const std::vector<T> &rhs) const
+  {
+    std::vector<T> r = operator*(lhs);
+    Real max_residual = 0.0;
+    for (N i = 0; i < rhs.size(); i++) {
+      if (!empty(i))
+        max_residual = std::max(max_residual, std::abs(r[i] - rhs[i]));
+    }
+    return max_residual;
+  }
+  std::vector<T> residual_vector(const std::vector<T> &lhs, const std::vector<T> &rhs) const
+  {
+    std::vector<T> result = operator*(lhs);
+    assert(result.size() == rhs.size());
+    for (N i = 0; i < result.size(); i++) {
+      result[i] = std::abs(result[i] - rhs[i]);
+    }
+#if MANTA_USE_CPP11 == 1
+    return std::move(result);
+#else
+    return result;
+#endif
+  }
+  T norm() const
+  {
+    T result(0.0);
+    for (N i = 0; i < n; ++i) {
+      for (Iterator it = row_begin(i); it; ++it) {
+        result = std::max(result, std::abs(it.value()));
+      }
+    }
+    return result;
+  }
+
+  T norm_L2_sqr() const
+  {
+    T result(0.0);
+    for (N i = 0; i < n; ++i) {
+      for (Iterator it = row_begin(i); it; ++it) {
+        result += (it.value()) * (it.value());
+      }
+    }
+    return result;
+  }
+
+  void write_matlab(std::ostream &output,
+                    unsigned int rows,
+                    unsigned int columns,
+                    const char *variable_name)
+  {
+    output << variable_name << "=sparse([";
+    for (N i = 0; i < n; ++i) {
+      if (matrix[i]) {
+        const std::vector<N> &index = matrix[i]->index;
+        for (N j = 0; j < (N)index.size(); ++j) {
+          output << i + 1 << " ";
+        }
+      }
+    }
+    output << "],...\n  [";
+    for (N i = 0; i < n; ++i) {
+      if (matrix[i]) {
+        const std::vector<N> &index = matrix[i]->index;
+        for (N j = 0; j < (N)index.size(); ++j) {
+          output << index[j] + (offsets.empty() ? 0 : offsets[i]) + 1 << " ";
+        }
+      }
+    }
+    output << "],...\n  [";
+    for (N i = 0; i < n; ++i) {
+      if (matrix[i]) {
+        const std::vector<T> &value = matrix[i]->value;
+        for (N j = 0; j < value.size(); ++j) {
+          output << value[j] << " ";
+        }
+      }
+    }
+    output << "], " << rows << ", " << columns << ");" << std::endl;
+  };
+  void export_matlab(std::string filename, std::string name)
+  {
+    // Export this matrix
+    std::ofstream file;
+    file.open(filename.c_str());
+    write_matlab(file, n, getColumnSize(), name.c_str());
+    file.close();
+  }
+  void print_readable(std::string name, bool printNonZero = true)
+  {
+    std::cout << name << " \n";
+    for (int i = 0; i < n; ++i) {
+      for (int j = 0; j < n; ++j) {
+        if (printNonZero) {
+          if ((*this)(i, j) == 0) {
+            std::cout << "  .";
+            continue;
+          }
+        }
+        else {
+          if ((*this)(i, j) == 0) {
+            continue;
+          }
+        }
+
+        if ((*this)(i, j) >= 0)
+          std::cout << " ";
+        std::cout << " " << (*this)(i, j);
+      }
+      std::cout << " \n";
+    }
+  }
+  ///
+  N n;
+  N expected_none_zeros;
+  std::vector<RowEntry *> matrix;
+  std::vector<int> offsets;
+};
+
+template<class N, class T>
+static inline RCMatrix<N, T> operator*(const std::vector<T> &diagonal, const RCMatrix<N, T> &A)
+{
+  RCMatrix<N, T> result(A);
+  parallel_for(result.n)
+  {
+    N row(parallel_index);
+    for (auto it = result.dynamic_row_begin(row); it; ++it) {
+      it.setValue(it.value() * diagonal[row]);
+    }
+  }
+  parallel_end return std::move(result);
+}
+
+template<class N, class T> struct RCFixedMatrix {
+  std::vector<N> rowstart;
+  std::vector<N> index;
+  std::vector<T> value;
+  N n;
+  N max_rowlength;
+  //
+  RCFixedMatrix() : n(0), max_rowlength(0)
+  {
+  }
+  RCFixedMatrix(const RCMatrix<N, T> &matrix)
+  {
+    n = matrix.n;
+    rowstart.resize(n + 1);
+    rowstart[0] = 0;
+    max_rowlength = 0;
+    for (N i = 0; i < n; i++) {
+      if (!matrix.empty(i)) {
+        rowstart[i + 1] = rowstart[i] + matrix.row_nonzero_size(i);
+        max_rowlength = std::max(max_rowlength, rowstart[i + 1] - rowstart[i]);
+      }
+      else {
+        rowstart[i + 1] = rowstart[i];
+      }
+    }
+    value.resize(rowstart[n]);
+    index.resize(rowstart[n]);
+    N j = 0;
+    for (N i = 0; i < n; i++) {
+      for (typename RCMatrix<N, T>::Iterator it = matrix.row_begin(i); it; ++it) {
+        value[j] = it.value();
+        index[j] = it.index();
+        ++j;
+      }
+    }
+  }
+  class Iterator : std::iterator<std::input_iterator_tag, T> {
+   public:
+    Iterator(N start, N end, const std::vector<N> &index, const std::vector<T> &value)
+        : index_array(index), value_array(value), k(start), start(start), end(end)
+    {
+    }
+    operator bool() const
+    {
+      return k < end;
+    }
+    Iterator &operator++()
+    {
+      ++k;
+      return *this;
+    }
+    T value() const
+    {
+      return value_array[k];
+    }
+    N index() const
+    {
+      return index_array[k];
+    }
+    N size() const
+    {
+      return end - start;
+    }
+
+   private:
+    const std::vector<N> &index_array;
+    const std::vector<T> &value_array;
+    N k, start, end;
+  };
+  Iterator row_begin(N n) const
+  {
+    return Iterator(rowstart[n], rowstart[n + 1], index, value);
+  }
+  std::vector<T> operator*(const std::vector<T> &rhs) const
+  {
+    std::vector<T> result(n, 0.0);
+    multiply(rhs, result);
+#if MANTA_USE_CPP11 == 1
+    return std::move(result);
+#else
+    return result;
+#endif
+  }
+  void multiply(const std::vector<T> &rhs, std::vector<T> &result) const
+  {
+    result.resize(n);
+    parallel_for(n)
+    {
+      N i = parallel_index;
+      T new_value = 0.0;
+      for (Iterator it = row_begin(i); it; ++it) {
+        N j_index = it.index();
+        assert(j_index < rhs.size());
+        new_value += rhs[j_index] * it.value();
+      }
+      result[i] = new_value;
+    }
+    parallel_end
+  }
+  RCMatrix<N, T> operator*(const RCFixedMatrix &m) const
+  {
+    RCMatrix<N, T> result(n, max_rowlength);
+    // Run in parallel
+    parallel_for(result.n)
+    {
+      N i = parallel_index;
+      for (Iterator it_A = row_begin(i); it_A; ++it_A) {
+        N j = it_A.index();
+        assert(j < m.n);
+        T a = it_A.value();
+        if (std::abs(a) > VECTOR_EPSILON) {
+          for (Iterator it_B = m.row_begin(j); it_B; ++it_B) {
+            result.add_to_element(i, it_B.index(), it_B.value() * a);
+          }
+        }
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+
+  RCMatrix<N, T> toRCMatrix() const
+  {
+    RCMatrix<N, T> result(n, 0);
+    parallel_for(n)
+    {
+      N i = parallel_index;
+      N size = rowstart[i + 1] - rowstart[i];
+      result.matrix[i] = new typename RCMatrix<N, T>::RowEntry;
+      result.matrix[i]->index.resize(size);
+      result.matrix[i]->value.resize(size);
+      for (N j = 0; j < size; j++) {
+        result.matrix[i]->index[j] = index[rowstart[i] + j];
+        result.matrix[i]->value[j] = value[rowstart[i] + j];
+      }
+    }
+    parallel_end
+#if MANTA_USE_CPP11 == 1
+        return std::move(result);
+#else
+        return result;
+#endif
+  }
+};
+
+typedef RCMatrix<int, Real> Matrix;
+typedef RCFixedMatrix<int, Real> FixedMatrix;
+
+}  // namespace Manta
+
+#undef parallel_for
+#undef parallel_end
+
+#undef parallel_block
+#undef do_parallel
+#undef do_end
+#undef block_end
+
+#endif
diff --git a/extern/mantaflow/helper/util/simpleimage.cpp b/extern/mantaflow/helper/util/simpleimage.cpp
new file mode 100644
index 00000000000..9846fa5bd96
--- /dev/null
+++ b/extern/mantaflow/helper/util/simpleimage.cpp
@@ -0,0 +1,312 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Simple image IO
+ *
+ ******************************************************************************/
+
+#include "vectorbase.h"
+#include "simpleimage.h"
+
+namespace Manta {
+
+// write rectangle to ppm
+bool SimpleImage::writePpm(
+    std::string filename, int minx, int miny, int maxx, int maxy, bool invertXY)
+{
+  int w = maxx - minx;
+  int h = maxy - miny;
+
+  if (w <= 0 || h <= 0 || w > mSize[0] || h > mSize[1]) {
+    errMsg("SimpleImage::WritePPM Invalid rect: w="
+           << w << ", h=" << h << ", size=" << mSize[0] << "," << mSize[1] << " min/max: " << minx
+           << "," << miny << " to " << maxx << "," << maxy << ", resetting... ");
+    minx = miny = 0;
+    maxx = mSize[0] - 1;
+    maxy = mSize[1] - 1;
+    w = mSize[0] - 1;
+    h = mSize[1] - 1;
+  }
+
+  FILE *fp = fopen(filename.c_str(), "wb");
+  if (fp == NULL) {
+    errMsg("SimpleImage::WritePPM Unable to open '" << filename << "' for writing");
+    return false;
+  }
+  fprintf(fp, "P6\n%d %d\n255\n", w, h);
+
+  int pixCnt = 0;
+  for (int j = maxy - 1; j >= miny; j--)
+    for (int i = minx; i < maxx; i++) {
+      unsigned char col[3];
+      for (int l = 0; l < 3; l++) {
+        float val;
+        if (invertXY)
+          val = (float)get(j, i)[l];
+        else
+          val = (float)get(i, j)[l];
+
+        val = clamp(val, (float)0., (float)1.);
+        col[l] = (unsigned char)(255. * val);
+      }
+      // col[1] = col[2] = col[0];
+      // if (fwrite(col,1,3, fp) != 3) errMsg("SimpleImage::writePpm fwrite failed");
+      fwrite(col, 1, 3, fp);
+      pixCnt++;
+      // fprintf(stderr,"%d %d %d \n",col[0],i,j);
+    }
+
+  fclose(fp);
+  // debMsg("WritePPM Wrote '"<<filename<<"', region="<<minx<<","<<miny<<" to
+  // "<<maxx<<","<<maxy<<"; "<<pixCnt, 1);
+
+  return true;
+}
+
+bool SimpleImage::writePpm(std::string filename)
+{
+  return writePpm(filename, 0, 0, getSize()[0], getSize()[1]);
+}
+
+// read in a ppm file, and init the image accordingly
+bool SimpleImage::initFromPpm(std::string filename)
+{
+  // maximum length of a line of text
+  const int MAXLINE = 1024;
+
+  int filetype = 0;
+  enum { PGM, PPM };  // possible file types
+
+  FILE *fp;
+  char line[MAXLINE];
+  int size, rowsize;
+
+  // Read in file type
+  fp = fopen(filename.c_str(), "rb");
+  if (!fp) {
+    if (mAbortOnError)
+      debMsg("SimpleImage Error - unable to open file '" << filename << "' for reading", 1);
+    return 0;
+  }
+
+  // 1st line: PPM or PGM
+  if (fgets(line, MAXLINE, fp) == NULL) {
+    if (mAbortOnError)
+      debMsg("SimpleImage::initFromPpm fgets failed", 1);
+    return 0;
+  }
+
+  if (line[1] == '5')
+    filetype = PGM;
+  else if (line[1] == '6')
+    filetype = PPM;
+  else {
+    if (mAbortOnError)
+      debMsg("SimpleImage Error: need PPM or PGM file as input!", 1);
+    return 0;
+  }
+
+  // Read in width and height, & allocate space
+  // 2nd line: width height
+  if (fgets(line, MAXLINE, fp) == NULL) {
+    if (mAbortOnError)
+      errMsg("SimpleImage::initFromPpm fgets failed");
+    return 0;
+  }
+  int windW = 0, windH = 0;  // size of the window on the screen
+  int intsFound = sscanf(line, "%d %d", &windW, &windH);
+  if (intsFound == 1) {
+    // only X found, search on next line as well for Y...
+    if (sscanf(line, "%d", &windH) != 1) {
+      if (mAbortOnError)
+        errMsg("initFromPpm Ppm dimensions not found!" << windW << "," << windH);
+      return 0;
+    }
+    else {
+      // ok, found 2 lines
+      // debMsg("initFromPpm Ppm dimensions found!"<<windW<<","<<windH, 1);
+    }
+  }
+  else if (intsFound == 2) {
+    // ok!
+  }
+  else {
+    if (mAbortOnError)
+      errMsg("initFromPpm Ppm dimensions not found at all!" << windW << "," << windH);
+    return 0;
+  }
+
+  if (filetype == PGM) {
+    size = windH * windW;  // greymap: 1 byte per pixel
+    rowsize = windW;
+  }
+  else {
+    // filetype == PPM
+    size = windH * windW * 3;  // pixmap: 3 bytes per pixel
+    rowsize = windW * 3;
+  }
+
+  unsigned char *pic = new unsigned char[size];  // (GLubyte *)malloc (size);
+
+  // Read in maximum value (ignore) , could be scanned with sscanf as well, but this should be
+  // 255... 3rd line
+  if (fgets(line, MAXLINE, fp) == NULL) {
+    if (mAbortOnError)
+      errMsg("SimpleImage::initFromPpm fgets failed");
+    return 0;
+  }
+
+  // Read in the pixel array row-by-row: 1st row = top scanline */
+  unsigned char *ptr = NULL;
+  ptr = &pic[(windH - 1) * rowsize];
+  for (int i = windH; i > 0; i--) {
+    assertMsg(fread((void *)ptr, 1, rowsize, fp) == rowsize,
+              "SimpleImage::initFromPpm couldn't read data");
+    ptr -= rowsize;
+  }
+
+  // init image
+  this->init(windW, windH);
+  if (filetype == PGM) {
+    // grayscale
+    for (int i = 0; i < windW; i++) {
+      for (int j = 0; j < windH; j++) {
+        double r = (double)pic[(j * windW + i) * 1 + 0] / 255.;
+        (*this)(i, j) = Vec3(r, r, r);
+      }
+    }
+  }
+  else {
+    // convert grid to RGB vec's
+    for (int i = 0; i < windW; i++) {
+      for (int j = 0; j < windH; j++) {
+        // return mpData[y*mSize[0]+x];
+        double r = (double)pic[(j * windW + i) * 3 + 0] / 255.;
+        double g = (double)pic[(j * windW + i) * 3 + 1] / 255.;
+        double b = (double)pic[(j * windW + i) * 3 + 2] / 255.;
+
+        //(*this)(i,j) = Vec3(r,g,b);
+
+        // RGB values have to be rotated to get the right colors!?
+        // this might also be an artifact of photoshop export...?
+        (*this)(i, j) = Vec3(g, b, r);
+      }
+    }
+  }
+
+  delete[] pic;
+  fclose(fp);
+  return 1;
+}
+
+// check index is valid
+bool SimpleImage::indexIsValid(int i, int j)
+{
+  if (i < 0)
+    return false;
+  if (j < 0)
+    return false;
+  if (i >= mSize[0])
+    return false;
+  if (j >= mSize[1])
+    return false;
+  return true;
+}
+
+};  // namespace Manta
+
+//*****************************************************************************
+
+#include "grid.h"
+namespace Manta {
+
+// simple shaded output , note requires grid functionality!
+static void gridPrecompLight(const Grid<Real> &density, Grid<Real> &L, Vec3 light = Vec3(1, 1, 1))
+{
+  FOR_IJK(density)
+  {
+    Vec3 n = getGradient(density, i, j, k) * -1.;
+    normalize(n);
+
+    Real d = dot(light, n);
+    L(i, j, k) = d;
+  }
+}
+
+// simple shading with pre-computed gradient
+static inline void shadeCell(
+    Vec3 &dst, int shadeMode, Real src, Real light, int depthPos, Real depthInv)
+{
+  switch (shadeMode) {
+
+    case 1: {
+      // surfaces
+      Vec3 ambient = Vec3(0.1, 0.1, 0.1);
+      Vec3 diffuse = Vec3(0.9, 0.9, 0.9);
+      Real alpha = src;
+
+      // different color for depth?
+      diffuse[0] *= ((Real)depthPos * depthInv) * 0.7 + 0.3;
+      diffuse[1] *= ((Real)depthPos * depthInv) * 0.7 + 0.3;
+
+      Vec3 col = ambient + diffuse * light;
+
+      // img( 0+i, j ) = (1.-alpha) * img( 0+i, j ) + alpha * col;
+      dst = (1. - alpha) * dst + alpha * col;
+    } break;
+
+    default: {
+      // volumetrics / smoke
+      dst += depthInv * Vec3(src, src, src);
+    } break;
+  }
+}
+
+//! helper to project a grid intro an image (used for ppm export and GUI displauy)
+void projectImg(SimpleImage &img, const Grid<Real> &val, int shadeMode = 0, Real scale = 1.)
+{
+  Vec3i s = val.getSize();
+  Vec3 si = Vec3(1. / (Real)s[0], 1. / (Real)s[1], 1. / (Real)s[2]);
+
+  // init image size
+  int imgSx = s[0];
+  if (val.is3D())
+    imgSx += s[2] + s[0];  // mult views in 3D
+  img.init(imgSx, std::max(s[0], std::max(s[1], s[2])));
+
+  // precompute lighting
+  Grid<Real> L(val);
+  gridPrecompLight(val, L, Vec3(1, 1, 1));
+
+  FOR_IJK(val)
+  {
+    Vec3i idx(i, j, k);
+    shadeCell(img(0 + i, j), shadeMode, val(idx), L(idx), k, si[2]);
+  }
+
+  if (val.is3D()) {
+
+    FOR_IJK(val)
+    {
+      Vec3i idx(i, j, k);
+      shadeCell(img(s[0] + k, j), shadeMode, val(idx), L(idx), i, si[0]);
+    }
+
+    FOR_IJK(val)
+    {
+      Vec3i idx(i, j, k);
+      shadeCell(img(s[0] + s[2] + i, k), shadeMode, val(idx), L(idx), j, si[1]);
+    }
+
+  }  // 3d
+
+  img.mapRange(1. / scale);
+}
+
+};  // namespace Manta
diff --git a/extern/mantaflow/helper/util/simpleimage.h b/extern/mantaflow/helper/util/simpleimage.h
new file mode 100644
index 00000000000..d7e88b83f74
--- /dev/null
+++ b/extern/mantaflow/helper/util/simpleimage.h
@@ -0,0 +1,205 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Simple image IO
+ *
+ ******************************************************************************/
+
+#ifndef MANTA_SIMPLEIMAGE_H
+#define MANTA_SIMPLEIMAGE_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "manta.h"
+#include "vectorbase.h"
+
+namespace Manta {
+
+//*****************************************************************************
+// simple 2d image class
+// template<class Scalar>
+class SimpleImage {
+ public:
+  // cons/des
+  SimpleImage() : mSize(-1), mpData(NULL), mAbortOnError(true){};
+  virtual ~SimpleImage()
+  {
+    if (mpData)
+      delete[] mpData;
+  };
+
+  //! set to constant
+  void reset(Real val = 0.)
+  {
+    const Vec3 v = Vec3(val);
+    for (int i = 0; i < mSize[0] * mSize[1]; i++)
+      mpData[i] = v;
+  }
+  //! init memory & reset to zero
+  void init(int x, int y)
+  {
+    mSize = Vec3i(x, y, 0);
+    mpData = new Vec3[x * y];
+    reset();
+  };
+
+  inline bool checkIndex(int x, int y)
+  {
+    if ((x < 0) || (y < 0) || (x > mSize[0] - 1) || (y > mSize[1] - 1)) {
+      errMsg("SimpleImage::operator() Invalid access to " << x << "," << y << ", size=" << mSize);
+      return false;
+    }
+    return true;
+  }
+
+  // access element
+  inline Vec3 &operator()(int x, int y)
+  {
+    DEBUG_ONLY(checkIndex(x, y));
+    return mpData[y * mSize[0] + x];
+  };
+  inline Vec3 &get(int x, int y)
+  {
+    return (*this)(x, y);
+  }
+  inline Vec3 &getMap(int x, int y, int z, int axis)
+  {
+    int i = x, j = y;
+    if (axis == 1)
+      j = z;
+    if (axis == 0) {
+      i = y;
+      j = z;
+    }
+    return get(i, j);
+  }
+
+  // output as string, debug
+  std::string toString()
+  {
+    std::ostringstream out;
+
+    for (int j = 0; j < mSize[1]; j++) {
+      for (int i = 0; i < mSize[0]; i++) {
+        // normal zyx order */
+        out << (*this)(i, j);
+        out << " ";
+      }
+      // if (format)
+      out << std::endl;
+    }
+
+    return out.str();
+  }
+
+  // multiply all values by f
+  void add(Vec3 f)
+  {
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        get(i, j) += f;
+      }
+  }
+  // multiply all values by f
+  void multiply(Real f)
+  {
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        get(i, j) *= f;
+      }
+  }
+  // map 0-f to 0-1 range, clamp
+  void mapRange(Real f)
+  {
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        get(i, j) /= f;
+        for (int c = 0; c < 3; ++c)
+          get(i, j)[c] = clamp(get(i, j)[c], (Real)0., (Real)1.);
+      }
+  }
+
+  // normalize max values
+  void normalizeMax()
+  {
+    Real max = normSquare(get(0, 0));
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        if (normSquare(get(i, j)) > max)
+          max = normSquare(get(i, j));
+      }
+    max = sqrt(max);
+    Real invMax = 1. / max;
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        get(i, j) *= invMax;
+      }
+  };
+
+  // normalize min and max values
+  void normalizeMinMax()
+  {
+    Real max = normSquare(get(0, 0));
+    Real min = max;
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        if (normSquare(get(i, j)) > max)
+          max = normSquare(get(i, j));
+        if (normSquare(get(i, j)) < min)
+          min = normSquare(get(i, j));
+      }
+    max = sqrt(max);
+    min = sqrt(min);
+    Real factor = 1. / (max - min);
+    for (int j = 0; j < mSize[1]; j++)
+      for (int i = 0; i < mSize[0]; i++) {
+        get(i, j) -= min;
+        get(i, j) *= factor;
+      }
+  };
+
+  void setAbortOnError(bool set)
+  {
+    mAbortOnError = set;
+  }
+
+  // ppm in/output
+
+  // write whole image
+  bool writePpm(std::string filename);
+  // write rectangle to ppm
+  bool writePpm(
+      std::string filename, int minx, int miny, int maxx, int maxy, bool invertXY = false);
+  // read in a ppm file, and init the image accordingly
+  bool initFromPpm(std::string filename);
+
+  // check index is valid
+  bool indexIsValid(int i, int j);
+
+  //! access
+  inline Vec3i getSize() const
+  {
+    return mSize;
+  }
+
+ protected:
+  //! size
+  Vec3i mSize;
+  //! data
+  Vec3 *mpData;
+  // make errors fatal, or continue?
+  bool mAbortOnError;
+
+};  // SimpleImage
+
+};  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/solvana.h b/extern/mantaflow/helper/util/solvana.h
new file mode 100644
index 00000000000..9dc1ec83654
--- /dev/null
+++ b/extern/mantaflow/helper/util/solvana.h
@@ -0,0 +1,214 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Analytical solutions to some problems
+ * generated using MATLAB symbolic math ccode
+ *
+ ******************************************************************************/
+
+#ifndef _SOLVANA_H
+#define _SOLVANA_H
+
+//! solves the equation [e1 e2 e3; 1 1 1]*x = g using least squares
+inline void SolveOverconstraint34(float e1x,
+                                  float e1y,
+                                  float e1z,
+                                  float e2x,
+                                  float e2y,
+                                  float e2z,
+                                  float e3x,
+                                  float e3y,
+                                  float e3z,
+                                  float g1,
+                                  float g2,
+                                  float g3,
+                                  float &x1,
+                                  float &x2,
+                                  float &x3)
+{
+  float e1x2 = e1x * e1x, e1y2 = e1y * e1y, e1z2 = e1z * e1z;
+  float e2x2 = e2x * e2x, e2y2 = e2y * e2y, e2z2 = e2z * e2z;
+  float e3x2 = e3x * e3x, e3y2 = e3y * e3y, e3z2 = e3z * e3z;
+  float e1xy = e1x * e1y, e1xz = e1x * e1z, e1yz = e1y * e1z;
+  float e2xy = e2x * e2y, e2xz = e2x * e2z, e2yz = e2y * e2z;
+  float e3xy = e3x * e3y, e3xz = e3x * e3z, e3yz = e3y * e3z;
+  float e12x = e1x * e2x, e12y = e1y * e2y, e12z = e1z * e2z;
+  float e13x = e1x * e3x, e13y = e1y * e3y, e13z = e1z * e3z;
+  float e23x = e2x * e3x, e23y = e2y * e3y, e23z = e2z * e3z;
+  float t1543 = e3y2 * e2x2;
+  float t1544 = e3x2 * e2y2;
+  float t1545 = e3z2 * e2x2;
+  float t1546 = e3x2 * e2z2;
+  float t1547 = e3z2 * e2y2;
+  float t1548 = e3y2 * e2z2;
+  float t1549 = e2y2 * e1x2;
+  float t1550 = e2x2 * e1y2;
+  float t1551 = e2z2 * e1x2;
+  float t1552 = e2x2 * e1z2;
+  float t1553 = e2z2 * e1y2;
+  float t1554 = e2y2 * e1z2;
+  float t1555 = e3y2 * e1x2;
+  float t1556 = e3x2 * e1y2;
+  float t1557 = e3z2 * e1x2;
+  float t1558 = e3x2 * e1z2;
+  float t1559 = e3z2 * e1y2;
+  float t1560 = e3y2 * e1z2;
+  float t1561 = e3z2 * e2y2 * e1x2;
+  float t1562 = e3y2 * e2z2 * e1x2;
+  float t1563 = e3z2 * e2x2 * e1y2;
+  float t1564 = e3x2 * e2z2 * e1y2;
+  float t1565 = e3y2 * e2x2 * e1z2;
+  float t1566 = e3x2 * e2y2 * e1z2;
+  float t1567 = e1xy * e2x * e3y * 2.0;
+  float t1568 = e1xy * e2y * e3x * 2.0;
+  float t1569 = e1xz * e2x * e3z * 2.0;
+  float t1570 = e1xz * e2z * e3x * 2.0;
+  float t1571 = e1yz * e2y * e3z * 2.0;
+  float t1572 = e1yz * e2z * e3y * 2.0;
+  float t1573 = e1x * e2xy * e3y * 2.0;
+  float t1574 = e1y * e2xy * e3x * 2.0;
+  float t1575 = e1x * e2xz * e3z * 2.0;
+  float t1576 = e1z * e2xz * e3x * 2.0;
+  float t1577 = e1y * e2yz * e3z * 2.0;
+  float t1578 = e1z * e2yz * e3y * 2.0;
+  float t1579 = e1x * e2y * e3xy * 2.0;
+  float t1580 = e1y * e2x * e3xy * 2.0;
+  float t1581 = e1x * e2z * e3xz * 2.0;
+  float t1582 = e1z * e2x * e3xz * 2.0;
+  float t1583 = e1y * e2z * e3yz * 2.0;
+  float t1584 = e1z * e2y * e3yz * 2.0;
+  float t1585 = e1xy * e2xz * e3yz * 2.0;
+  float t1586 = e1xy * e2yz * e3xz * 2.0;
+  float t1587 = e1xz * e2xy * e3yz * 2.0;
+  float t1588 = e1xz * e2yz * e3xy * 2.0;
+  float t1589 = e1yz * e2xy * e3xz * 2.0;
+  float t1590 = e1yz * e2xz * e3xy * 2.0;
+  float t1596 = e12x * e3y2 * 2.0;
+  float t1597 = e13x * e2y2 * 2.0;
+  float t1598 = e23x * e1y2 * 2.0;
+  float t1599 = e12x * e3z2 * 2.0;
+  float t1600 = e13x * e2z2 * 2.0;
+  float t1601 = e12y * e3x2 * 2.0;
+  float t1602 = e13y * e2x2 * 2.0;
+  float t1603 = e23y * e1x2 * 2.0;
+  float t1604 = e23x * e1z2 * 2.0;
+  float t1605 = e12y * e3z2 * 2.0;
+  float t1606 = e13y * e2z2 * 2.0;
+  float t1607 = e12z * e3x2 * 2.0;
+  float t1608 = e13z * e2x2 * 2.0;
+  float t1609 = e23z * e1x2 * 2.0;
+  float t1610 = e23y * e1z2 * 2.0;
+  float t1611 = e12z * e3y2 * 2.0;
+  float t1612 = e13z * e2y2 * 2.0;
+  float t1613 = e23z * e1y2 * 2.0;
+  float t1614 = e1xy * e2xy * 2.0;
+  float t1615 = e1xz * e2xz * 2.0;
+  float t1616 = e1yz * e2yz * 2.0;
+  float t1617 = e1xy * e3xy * 2.0;
+  float t1618 = e1xz * e3xz * 2.0;
+  float t1619 = e1yz * e3yz * 2.0;
+  float t1620 = e2xy * e3xy * 2.0;
+  float t1621 = e2xz * e3xz * 2.0;
+  float t1622 = e2yz * e3yz * 2.0;
+  float t1623 = e1xy * e2xy * e3z2 * 2.0;
+  float t1624 = e1xz * e2xz * e3y2 * 2.0;
+  float t1625 = e1yz * e2yz * e3x2 * 2.0;
+  float t1626 = e1xy * e3xy * e2z2 * 2.0;
+  float t1627 = e1xz * e3xz * e2y2 * 2.0;
+  float t1628 = e1yz * e3yz * e2x2 * 2.0;
+  float t1629 = e2xy * e3xy * e1z2 * 2.0;
+  float t1630 = e2xz * e3xz * e1y2 * 2.0;
+  float t1631 = e2yz * e3yz * e1x2 * 2.0;
+  float t1591 = t1550 + t1551 + t1560 + t1543 + t1552 + t1561 + t1570 + t1544 + t1553 + t1562 +
+                t1571 + t1580 + t1545 + t1554 + t1563 + t1572 + t1581 + t1590 + t1546 + t1555 +
+                t1564 + t1573 + t1582 + t1547 + t1556 + t1565 + t1574 + t1583 + t1548 + t1557 +
+                t1566 + t1575 + t1584 + t1549 + t1558 + t1567 + t1576 + t1585 + t1559 + t1568 +
+                t1577 + t1586 + t1569 + t1578 + t1587 - t1596 + t1579 + t1588 - t1597 + t1589 -
+                t1598 - t1599 - t1600 - t1601 - t1610 - t1602 - t1611 - t1620 - t1603 - t1612 -
+                t1621 - t1630 - t1604 - t1613 - t1622 - t1631 - t1605 - t1614 - t1623 - t1606 -
+                t1615 - t1624 - t1607 - t1616 - t1625 - t1608 - t1617 - t1626 - t1609 - t1618 -
+                t1627 - t1619 - t1628 - t1629;
+  float t1592 = 1.0 / t1591;
+  float t1635 = e13x * e2y2;
+  float t1636 = e13x * e2z2;
+  float t1637 = e13y * e2x2;
+  float t1638 = e13y * e2z2;
+  float t1639 = e13z * e2x2;
+  float t1640 = e13z * e2y2;
+  float t1653 = e23x * 2.0;
+  float t1654 = e23y * 2.0;
+  float t1655 = e23z * 2.0;
+  float t1641 = e3x2 + e3z2 + e3y2 + e2y2 + t1543 + e2z2 + t1544 + e2x2 + t1545 + t1546 + t1547 +
+                t1548 - t1620 - t1621 - t1622 - t1653 - t1654 - t1655;
+  float t1642 = e12x * e3y2;
+  float t1643 = e12x * e3z2;
+  float t1644 = e12y * e3x2;
+  float t1645 = e12y * e3z2;
+  float t1646 = e12z * e3x2;
+  float t1647 = e12z * e3y2;
+  float t1656 = e1x * e2y * e3xy;
+  float t1657 = e1y * e2x * e3xy;
+  float t1658 = e1x * e2z * e3xz;
+  float t1659 = e1z * e2x * e3xz;
+  float t1660 = e1y * e2z * e3yz;
+  float t1661 = e1z * e2y * e3yz;
+  float t1648 = e3x2 + e3z2 + e3y2 - e13x - e13y - e13z + e12x - e23y + e12y + t1642 - e23z -
+                t1660 + e12z + t1643 - t1661 + t1644 + t1645 + t1646 + t1647 - t1656 - t1657 -
+                e23x - t1658 - t1659;
+  float t1679 = e1x * e2xy * e3y;
+  float t1680 = e1y * e2xy * e3x;
+  float t1681 = e1x * e2xz * e3z;
+  float t1682 = e1z * e2xz * e3x;
+  float t1683 = e1y * e2yz * e3z;
+  float t1684 = e1z * e2yz * e3y;
+  float t1652 = e2y2 + e2z2 + e2x2 + e13x + e13y + e13z + t1640 - e12x - e23y - e12y - e23z -
+                e12z + t1635 - t1680 + t1636 - t1681 + t1637 - t1682 + t1638 - t1683 + t1639 -
+                t1684 - e23x - t1679;
+  float t1662 = e23x * e1y2;
+  float t1663 = e23y * e1x2;
+  float t1664 = e23x * e1z2;
+  float t1665 = e23z * e1x2;
+  float t1666 = e23y * e1z2;
+  float t1667 = e23z * e1y2;
+  float t1670 = e1xy * e2x * e3y;
+  float t1671 = e1xy * e2y * e3x;
+  float t1672 = e1xz * e2x * e3z;
+  float t1673 = e1xz * e2z * e3x;
+  float t1674 = e1yz * e2y * e3z;
+  float t1675 = e1yz * e2z * e3y;
+  float t1668 = e1x2 + e1y2 + e1z2 - e13x - e13y - e13z - e12x + e23y - e12y + e23z - e12z -
+                t1670 + t1662 - t1671 + t1663 - t1672 + t1664 - t1673 + t1665 - t1674 + t1666 -
+                t1675 + e23x + t1667;
+  float t1676 = e13x * 2.0;
+  float t1677 = e13y * 2.0;
+  float t1678 = e13z * 2.0;
+  float t1669 = e3x2 + e3z2 + e3y2 + t1560 + e1x2 + t1555 + e1y2 + t1556 + e1z2 + t1557 + t1558 +
+                t1559 - t1617 - t1618 - t1619 - t1676 - t1677 - t1678;
+  float t1686 = e12x * 2.0;
+  float t1687 = e12y * 2.0;
+  float t1688 = e12z * 2.0;
+  float t1685 = t1550 + t1551 + e2y2 + t1552 + e2z2 + t1553 + e2x2 + t1554 + e1x2 + e1y2 + e1z2 +
+                t1549 - t1614 - t1615 - t1616 - t1686 - t1687 - t1688;
+  x1 = -g2 * (-e1y * t1592 * t1641 + e2y * t1592 * t1648 + e3y * t1592 * t1652) -
+       g3 * (-e1z * t1592 * t1641 + e2z * t1592 * t1648 + e3z * t1592 * t1652) -
+       g1 * (-e1x * t1592 * t1641 + e2x * t1592 * t1648 +
+             e3x * t1592 *
+                 (e2y2 + e2z2 + e2x2 + e13x + e13y + e13z + t1640 + t1635 + t1636 + t1637 + t1638 +
+                  t1639 - e12x - e12y - e12z - e23x - e23y - e23z - e1x * e2xy * e3y -
+                  e1y * e2xy * e3x - e1x * e2xz * e3z - e1z * e2xz * e3x - e1y * e2yz * e3z -
+                  e1z * e2yz * e3y));
+  x2 = -g1 * (e1x * t1592 * t1648 - e2x * t1592 * t1669 + e3x * t1592 * t1668) -
+       g2 * (e1y * t1592 * t1648 - e2y * t1592 * t1669 + e3y * t1592 * t1668) -
+       g3 * (e1z * t1592 * t1648 - e2z * t1592 * t1669 + e3z * t1592 * t1668);
+  x3 = -g1 * (e1x * t1592 * t1652 + e2x * t1592 * t1668 - e3x * t1592 * t1685) -
+       g2 * (e1y * t1592 * t1652 + e2y * t1592 * t1668 - e3y * t1592 * t1685) -
+       g3 * (e1z * t1592 * t1652 + e2z * t1592 * t1668 - e3z * t1592 * t1685);
+}
+
+#endif
\ No newline at end of file
diff --git a/extern/mantaflow/helper/util/vector4d.cpp b/extern/mantaflow/helper/util/vector4d.cpp
new file mode 100644
index 00000000000..d342df607f5
--- /dev/null
+++ b/extern/mantaflow/helper/util/vector4d.cpp
@@ -0,0 +1,50 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Basic vector class
+ *
+ ******************************************************************************/
+
+#include "vector4d.h"
+
+using namespace std;
+
+namespace Manta {
+
+template<> const Vector4D<int> Vector4D<int>::Zero(0, 0, 0, 0);
+template<> const Vector4D<float> Vector4D<float>::Zero(0.f, 0.f, 0.f, 0.f);
+template<> const Vector4D<double> Vector4D<double>::Zero(0., 0., 0., 0.);
+template<>
+const Vector4D<float> Vector4D<float>::Invalid(numeric_limits<float>::quiet_NaN(),
+                                               numeric_limits<float>::quiet_NaN(),
+                                               numeric_limits<float>::quiet_NaN(),
+                                               numeric_limits<float>::quiet_NaN());
+template<>
+const Vector4D<double> Vector4D<double>::Invalid(numeric_limits<double>::quiet_NaN(),
+                                                 numeric_limits<double>::quiet_NaN(),
+                                                 numeric_limits<double>::quiet_NaN(),
+                                                 numeric_limits<double>::quiet_NaN());
+template<> bool Vector4D<float>::isValid() const
+{
+  return !c_isnan(x) && !c_isnan(y) && !c_isnan(z) && !c_isnan(t);
+}
+template<> bool Vector4D<double>::isValid() const
+{
+  return !c_isnan(x) && !c_isnan(y) && !c_isnan(z) && !c_isnan(t);
+}
+
+//! Specialization for readable ints
+template<> std::string Vector4D<int>::toString() const
+{
+  char buf[256];
+  snprintf(buf, 256, "[%d,%d,%d,%d]", (*this)[0], (*this)[1], (*this)[2], (*this)[3]);
+  return std::string(buf);
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/helper/util/vector4d.h b/extern/mantaflow/helper/util/vector4d.h
new file mode 100644
index 00000000000..c3d72ac8aff
--- /dev/null
+++ b/extern/mantaflow/helper/util/vector4d.h
@@ -0,0 +1,515 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 4D vector class
+ *
+ ******************************************************************************/
+
+#ifndef _VECTOR4D_H
+#define _VECTOR4D_H
+
+#include "vectorbase.h"
+
+namespace Manta {
+
+//! Basic inlined vector class
+template<class S> class Vector4D {
+ public:
+  //! Constructor
+  inline Vector4D() : x(0), y(0), z(0), t(0)
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector4D(const Vector4D<S> &v) : x(v.x), y(v.y), z(v.z), t(v.t)
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector4D(const float *v) : x((S)v[0]), y((S)v[1]), z((S)v[2]), t((S)v[3])
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector4D(const double *v) : x((S)v[0]), y((S)v[1]), z((S)v[2]), t((S)v[3])
+  {
+  }
+
+  //! Construct a vector from one S
+  inline Vector4D(S v) : x(v), y(v), z(v), t(v)
+  {
+  }
+
+  //! Construct a vector from three Ss
+  inline Vector4D(S vx, S vy, S vz, S vw) : x(vx), y(vy), z(vz), t(vw)
+  {
+  }
+
+  // Operators
+
+  //! Assignment operator
+  inline const Vector4D<S> &operator=(const Vector4D<S> &v)
+  {
+    x = v.x;
+    y = v.y;
+    z = v.z;
+    t = v.t;
+    return *this;
+  }
+  //! Assignment operator
+  inline const Vector4D<S> &operator=(S s)
+  {
+    x = y = z = t = s;
+    return *this;
+  }
+  //! Assign and add operator
+  inline const Vector4D<S> &operator+=(const Vector4D<S> &v)
+  {
+    x += v.x;
+    y += v.y;
+    z += v.z;
+    t += v.t;
+    return *this;
+  }
+  //! Assign and add operator
+  inline const Vector4D<S> &operator+=(S s)
+  {
+    x += s;
+    y += s;
+    z += s;
+    t += s;
+    return *this;
+  }
+  //! Assign and sub operator
+  inline const Vector4D<S> &operator-=(const Vector4D<S> &v)
+  {
+    x -= v.x;
+    y -= v.y;
+    z -= v.z;
+    t -= v.t;
+    return *this;
+  }
+  //! Assign and sub operator
+  inline const Vector4D<S> &operator-=(S s)
+  {
+    x -= s;
+    y -= s;
+    z -= s;
+    t -= s;
+    return *this;
+  }
+  //! Assign and mult operator
+  inline const Vector4D<S> &operator*=(const Vector4D<S> &v)
+  {
+    x *= v.x;
+    y *= v.y;
+    z *= v.z;
+    t *= v.t;
+    return *this;
+  }
+  //! Assign and mult operator
+  inline const Vector4D<S> &operator*=(S s)
+  {
+    x *= s;
+    y *= s;
+    z *= s;
+    t *= s;
+    return *this;
+  }
+  //! Assign and div operator
+  inline const Vector4D<S> &operator/=(const Vector4D<S> &v)
+  {
+    x /= v.x;
+    y /= v.y;
+    z /= v.z;
+    t /= v.t;
+    return *this;
+  }
+  //! Assign and div operator
+  inline const Vector4D<S> &operator/=(S s)
+  {
+    x /= s;
+    y /= s;
+    z /= s;
+    t /= s;
+    return *this;
+  }
+  //! Negation operator
+  inline Vector4D<S> operator-() const
+  {
+    return Vector4D<S>(-x, -y, -z, -t);
+  }
+
+  //! Get smallest component
+  // inline S min() const { return ( x<y ) ? ( ( x<z ) ? x:z ) : ( ( y<z ) ? y:z ); }
+  //! Get biggest component
+  // inline S max() const { return ( x>y ) ? ( ( x>z ) ? x:z ) : ( ( y>z ) ? y:z ); }
+
+  //! Test if all components are zero
+  inline bool empty()
+  {
+    return x == 0 && y == 0 && z == 0 && t == 0;
+  }
+
+  //! access operator
+  inline S &operator[](unsigned int i)
+  {
+    return value[i];
+  }
+  //! constant access operator
+  inline const S &operator[](unsigned int i) const
+  {
+    return value[i];
+  }
+
+  //! debug output vector to a string
+  std::string toString() const;
+
+  //! test if nans are present
+  bool isValid() const;
+
+  //! actual values
+  union {
+    S value[4];
+    struct {
+      S x;
+      S y;
+      S z;
+      S t;
+    };
+    struct {
+      S X;
+      S Y;
+      S Z;
+      S T;
+    };
+  };
+
+  // zero element
+  static const Vector4D<S> Zero, Invalid;
+
+ protected:
+};
+
+//************************************************************************
+// Additional operators
+//************************************************************************
+
+//! Addition operator
+template<class S> inline Vector4D<S> operator+(const Vector4D<S> &v1, const Vector4D<S> &v2)
+{
+  return Vector4D<S>(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.t + v2.t);
+}
+//! Addition operator
+template<class S, class S2> inline Vector4D<S> operator+(const Vector4D<S> &v, S2 s)
+{
+  return Vector4D<S>(v.x + s, v.y + s, v.z + s, v.t + s);
+}
+//! Addition operator
+template<class S, class S2> inline Vector4D<S> operator+(S2 s, const Vector4D<S> &v)
+{
+  return Vector4D<S>(v.x + s, v.y + s, v.z + s, v.t + s);
+}
+
+//! Subtraction operator
+template<class S> inline Vector4D<S> operator-(const Vector4D<S> &v1, const Vector4D<S> &v2)
+{
+  return Vector4D<S>(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.t - v2.t);
+}
+//! Subtraction operator
+template<class S, class S2> inline Vector4D<S> operator-(const Vector4D<S> &v, S2 s)
+{
+  return Vector4D<S>(v.x - s, v.y - s, v.z - s, v.t - s);
+}
+//! Subtraction operator
+template<class S, class S2> inline Vector4D<S> operator-(S2 s, const Vector4D<S> &v)
+{
+  return Vector4D<S>(s - v.x, s - v.y, s - v.z, s - v.t);
+}
+
+//! Multiplication operator
+template<class S> inline Vector4D<S> operator*(const Vector4D<S> &v1, const Vector4D<S> &v2)
+{
+  return Vector4D<S>(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z, v1.t * v2.t);
+}
+//! Multiplication operator
+template<class S, class S2> inline Vector4D<S> operator*(const Vector4D<S> &v, S2 s)
+{
+  return Vector4D<S>(v.x * s, v.y * s, v.z * s, v.t * s);
+}
+//! Multiplication operator
+template<class S, class S2> inline Vector4D<S> operator*(S2 s, const Vector4D<S> &v)
+{
+  return Vector4D<S>(s * v.x, s * v.y, s * v.z, s * v.t);
+}
+
+//! Division operator
+template<class S> inline Vector4D<S> operator/(const Vector4D<S> &v1, const Vector4D<S> &v2)
+{
+  return Vector4D<S>(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z, v1.t / v2.t);
+}
+//! Division operator
+template<class S, class S2> inline Vector4D<S> operator/(const Vector4D<S> &v, S2 s)
+{
+  return Vector4D<S>(v.x / s, v.y / s, v.z / s, v.t / s);
+}
+//! Division operator
+template<class S, class S2> inline Vector4D<S> operator/(S2 s, const Vector4D<S> &v)
+{
+  return Vector4D<S>(s / v.x, s / v.y, s / v.z, s / v.t);
+}
+
+//! Comparison operator
+template<class S> inline bool operator==(const Vector4D<S> &s1, const Vector4D<S> &s2)
+{
+  return s1.x == s2.x && s1.y == s2.y && s1.z == s2.z && s1.t == s2.t;
+}
+
+//! Comparison operator
+template<class S> inline bool operator!=(const Vector4D<S> &s1, const Vector4D<S> &s2)
+{
+  return s1.x != s2.x || s1.y != s2.y || s1.z != s2.z || s1.t != s2.t;
+}
+
+//************************************************************************
+// External functions
+//************************************************************************
+
+//! Dot product
+template<class S> inline S dot(const Vector4D<S> &t, const Vector4D<S> &v)
+{
+  return t.x * v.x + t.y * v.y + t.z * v.z + t.t * v.t;
+}
+
+//! Cross product
+/*template<class S>
+inline Vector4D<S> cross ( const Vector4D<S> &t, const Vector4D<S> &v ) {
+  NYI Vector4D<S> cp (
+    ( ( t.y*v.z ) - ( t.z*v.y ) ),
+    ( ( t.z*v.x ) - ( t.x*v.z ) ),
+    ( ( t.x*v.y ) - ( t.y*v.x ) ) );
+  return cp;
+}*/
+
+//! Compute the magnitude (length) of the vector
+template<class S> inline S norm(const Vector4D<S> &v)
+{
+  S l = v.x * v.x + v.y * v.y + v.z * v.z + v.t * v.t;
+  return (fabs(l - 1.) < VECTOR_EPSILON * VECTOR_EPSILON) ? 1. : sqrt(l);
+}
+
+//! Compute squared magnitude
+template<class S> inline S normSquare(const Vector4D<S> &v)
+{
+  return v.x * v.x + v.y * v.y + v.z * v.z + v.t * v.t;
+}
+
+//! Returns a normalized vector
+template<class S> inline Vector4D<S> getNormalized(const Vector4D<S> &v)
+{
+  S l = v.x * v.x + v.y * v.y + v.z * v.z + v.t * v.t;
+  if (fabs(l - 1.) < VECTOR_EPSILON * VECTOR_EPSILON)
+    return v; /* normalized "enough"... */
+  else if (l > VECTOR_EPSILON * VECTOR_EPSILON) {
+    S fac = 1. / sqrt(l);
+    return Vector4D<S>(v.x * fac, v.y * fac, v.z * fac, v.t * fac);
+  }
+  else
+    return Vector4D<S>((S)0);
+}
+
+//! Compute the norm of the vector and normalize it.
+/*! \return The value of the norm */
+template<class S> inline S normalize(Vector4D<S> &v)
+{
+  S norm;
+  S l = v.x * v.x + v.y * v.y + v.z * v.z + v.t * v.t;
+  if (fabs(l - 1.) < VECTOR_EPSILON * VECTOR_EPSILON) {
+    norm = 1.;
+  }
+  else if (l > VECTOR_EPSILON * VECTOR_EPSILON) {
+    norm = sqrt(l);
+    v *= 1. / norm;
+  }
+  else {
+    v = Vector4D<S>::Zero;
+    norm = 0.;
+  }
+  return (S)norm;
+}
+
+//! Outputs the object in human readable form as string
+template<class S> std::string Vector4D<S>::toString() const
+{
+  char buf[256];
+  snprintf(buf,
+           256,
+           "[%+4.6f,%+4.6f,%+4.6f,%+4.6f]",
+           (double)(*this)[0],
+           (double)(*this)[1],
+           (double)(*this)[2],
+           (double)(*this)[3]);
+  // for debugging, optionally increase precision:
+  // snprintf ( buf,256,"[%+4.16f,%+4.16f,%+4.16f,%+4.16f]", ( double ) ( *this ) [0], ( double ) (
+  // *this ) [1], ( double ) ( *this ) [2], ( double ) ( *this ) [3] );
+  return std::string(buf);
+}
+
+template<> std::string Vector4D<int>::toString() const;
+
+//! Outputs the object in human readable form to stream
+template<class S> std::ostream &operator<<(std::ostream &os, const Vector4D<S> &i)
+{
+  os << i.toString();
+  return os;
+}
+
+//! Reads the contents of the object from a stream
+template<class S> std::istream &operator>>(std::istream &is, Vector4D<S> &i)
+{
+  char c;
+  char dummy[4];
+  is >> c >> i[0] >> dummy >> i[1] >> dummy >> i[2] >> dummy >> i[3] >> c;
+  return is;
+}
+
+/**************************************************************************/
+// Define default vector alias
+/**************************************************************************/
+
+//! 3D vector class of type Real (typically float)
+typedef Vector4D<Real> Vec4;
+
+//! 3D vector class of type int
+typedef Vector4D<int> Vec4i;
+
+//! convert to Real Vector
+template<class T> inline Vec4 toVec4(T v)
+{
+  return Vec4(v[0], v[1], v[2], v[3]);
+}
+template<class T> inline Vec4i toVec4i(T v)
+{
+  return Vec4i(v[0], v[1], v[2], v[3]);
+}
+
+/**************************************************************************/
+// Specializations for common math functions
+/**************************************************************************/
+
+template<> inline Vec4 clamp<Vec4>(const Vec4 &a, const Vec4 &b, const Vec4 &c)
+{
+  return Vec4(
+      clamp(a.x, b.x, c.x), clamp(a.y, b.y, c.y), clamp(a.z, b.z, c.z), clamp(a.t, b.t, c.t));
+}
+template<> inline Vec4 safeDivide<Vec4>(const Vec4 &a, const Vec4 &b)
+{
+  return Vec4(
+      safeDivide(a.x, b.x), safeDivide(a.y, b.y), safeDivide(a.z, b.z), safeDivide(a.t, b.t));
+}
+template<> inline Vec4 nmod<Vec4>(const Vec4 &a, const Vec4 &b)
+{
+  return Vec4(nmod(a.x, b.x), nmod(a.y, b.y), nmod(a.z, b.z), nmod(a.t, b.t));
+}
+
+/**************************************************************************/
+// 4d interpolation (note only 4d here, 2d/3d interpolations are in interpol.h)
+/**************************************************************************/
+
+#define BUILD_INDEX_4D \
+  Real px = pos.x - 0.5f, py = pos.y - 0.5f, pz = pos.z - 0.5f, pt = pos.t - 0.5f; \
+  int xi = (int)px; \
+  int yi = (int)py; \
+  int zi = (int)pz; \
+  int ti = (int)pt; \
+  Real s1 = px - (Real)xi, s0 = 1. - s1; \
+  Real t1 = py - (Real)yi, t0 = 1. - t1; \
+  Real f1 = pz - (Real)zi, f0 = 1. - f1; \
+  Real g1 = pt - (Real)ti, g0 = 1. - g1; \
+  /* clamp to border */ \
+  if (px < 0.) { \
+    xi = 0; \
+    s0 = 1.0; \
+    s1 = 0.0; \
+  } \
+  if (py < 0.) { \
+    yi = 0; \
+    t0 = 1.0; \
+    t1 = 0.0; \
+  } \
+  if (pz < 0.) { \
+    zi = 0; \
+    f0 = 1.0; \
+    f1 = 0.0; \
+  } \
+  if (pt < 0.) { \
+    ti = 0; \
+    g0 = 1.0; \
+    g1 = 0.0; \
+  } \
+  if (xi >= size.x - 1) { \
+    xi = size.x - 2; \
+    s0 = 0.0; \
+    s1 = 1.0; \
+  } \
+  if (yi >= size.y - 1) { \
+    yi = size.y - 2; \
+    t0 = 0.0; \
+    t1 = 1.0; \
+  } \
+  if (zi >= size.z - 1) { \
+    zi = size.z - 2; \
+    f0 = 0.0; \
+    f1 = 1.0; \
+  } \
+  if (ti >= size.t - 1) { \
+    ti = size.t - 2; \
+    g0 = 0.0; \
+    g1 = 1.0; \
+  } \
+  const int sX = 1; \
+  const int sY = size.x;
+
+static inline void checkIndexInterpol4d(const Vec4i &size, int idx)
+{
+  if (idx < 0 || idx > size.x * size.y * size.z * size.t) {
+    std::ostringstream s;
+    s << "Grid interpol4d dim " << size << " : index " << idx << " out of bound ";
+    errMsg(s.str());
+  }
+}
+
+template<class T>
+inline T interpol4d(
+    const T *data, const Vec4i &size, const IndexInt sZ, const IndexInt sT, const Vec4 &pos)
+{
+  BUILD_INDEX_4D
+  IndexInt idx = (IndexInt)xi + sY * (IndexInt)yi + sZ * (IndexInt)zi + sT * (IndexInt)ti;
+  DEBUG_ONLY(checkIndexInterpol4d(size, idx));
+  DEBUG_ONLY(checkIndexInterpol4d(size, idx + sX + sY + sZ + sT));
+
+  return (((data[idx] * t0 + data[idx + sY] * t1) * s0 +
+           (data[idx + sX] * t0 + data[idx + sX + sY] * t1) * s1) *
+              f0 +
+          ((data[idx + sZ] * t0 + data[idx + sY + sZ] * t1) * s0 +
+           (data[idx + sX + sZ] * t0 + data[idx + sX + sY + sZ] * t1) * s1) *
+              f1) *
+             g0 +
+         (((data[idx + sT] * t0 + data[idx + sT + sY] * t1) * s0 +
+           (data[idx + sT + sX] * t0 + data[idx + sT + sX + sY] * t1) * s1) *
+              f0 +
+          ((data[idx + sT + sZ] * t0 + data[idx + sT + sY + sZ] * t1) * s0 +
+           (data[idx + sT + sX + sZ] * t0 + data[idx + sT + sX + sY + sZ] * t1) * s1) *
+              f1) *
+             g1;
+}
+
+};  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/helper/util/vectorbase.cpp b/extern/mantaflow/helper/util/vectorbase.cpp
new file mode 100644
index 00000000000..413ae086d1c
--- /dev/null
+++ b/extern/mantaflow/helper/util/vectorbase.cpp
@@ -0,0 +1,49 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Basic vector class
+ *
+ ******************************************************************************/
+
+#include "vectorbase.h"
+
+using namespace std;
+
+namespace Manta {
+
+template<> const Vector3D<int> Vector3D<int>::Zero(0, 0, 0);
+template<> const Vector3D<float> Vector3D<float>::Zero(0.f, 0.f, 0.f);
+template<> const Vector3D<double> Vector3D<double>::Zero(0., 0., 0.);
+template<>
+const Vector3D<float> Vector3D<float>::Invalid(numeric_limits<float>::quiet_NaN(),
+                                               numeric_limits<float>::quiet_NaN(),
+                                               numeric_limits<float>::quiet_NaN());
+template<>
+const Vector3D<double> Vector3D<double>::Invalid(numeric_limits<double>::quiet_NaN(),
+                                                 numeric_limits<double>::quiet_NaN(),
+                                                 numeric_limits<double>::quiet_NaN());
+
+template<> bool Vector3D<float>::isValid() const
+{
+  return !c_isnan(x) && !c_isnan(y) && !c_isnan(z);
+}
+template<> bool Vector3D<double>::isValid() const
+{
+  return !c_isnan(x) && !c_isnan(y) && !c_isnan(z);
+}
+
+//! Specialization for readable ints
+template<> std::string Vector3D<int>::toString() const
+{
+  char buf[256];
+  snprintf(buf, 256, "[%d,%d,%d]", (*this)[0], (*this)[1], (*this)[2]);
+  return std::string(buf);
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/helper/util/vectorbase.h b/extern/mantaflow/helper/util/vectorbase.h
new file mode 100644
index 00000000000..a3135431eb3
--- /dev/null
+++ b/extern/mantaflow/helper/util/vectorbase.h
@@ -0,0 +1,679 @@
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2016 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Basic vector class
+ *
+ ******************************************************************************/
+
+#ifndef _VECTORBASE_H
+#define _VECTORBASE_H
+
+// get rid of windos min/max defines
+#if defined(WIN32) || defined(_WIN32)
+#  define NOMINMAX
+#endif
+
+#include <stdio.h>
+#include <string>
+#include <limits>
+#include <iostream>
+#include "general.h"
+
+// if min/max are still around...
+#if defined(WIN32) || defined(_WIN32)
+#  undef min
+#  undef max
+#endif
+
+// redefine usage of some windows functions
+#if defined(WIN32) || defined(_WIN32)
+#  ifndef snprintf
+#    define snprintf _snprintf
+#  endif
+#endif
+
+// use which fp-precision? 1=float, 2=double
+#ifndef FLOATINGPOINT_PRECISION
+#  define FLOATINGPOINT_PRECISION 1
+#endif
+
+// VECTOR_EPSILON is the minimal vector length
+// In order to be able to discriminate floating point values near zero, and
+// to be sure not to fail a comparison because of roundoff errors, use this
+// value as a threshold.
+#if FLOATINGPOINT_PRECISION == 1
+typedef float Real;
+#  define VECTOR_EPSILON (1e-6f)
+#else
+typedef double Real;
+#  define VECTOR_EPSILON (1e-10)
+#endif
+
+#ifndef M_PI
+#  define M_PI 3.1415926536
+#endif
+#ifndef M_E
+#  define M_E 2.7182818284
+#endif
+
+namespace Manta {
+
+//! Basic inlined vector class
+template<class S> class Vector3D {
+ public:
+  //! Constructor
+  inline Vector3D() : x(0), y(0), z(0)
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector3D(const Vector3D<S> &v) : x(v.x), y(v.y), z(v.z)
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector3D(const int *v) : x((S)v[0]), y((S)v[1]), z((S)v[2])
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector3D(const float *v) : x((S)v[0]), y((S)v[1]), z((S)v[2])
+  {
+  }
+
+  //! Copy-Constructor
+  inline Vector3D(const double *v) : x((S)v[0]), y((S)v[1]), z((S)v[2])
+  {
+  }
+
+  //! Construct a vector from one S
+  inline Vector3D(S v) : x(v), y(v), z(v)
+  {
+  }
+
+  //! Construct a vector from three Ss
+  inline Vector3D(S vx, S vy, S vz) : x(vx), y(vy), z(vz)
+  {
+  }
+
+  // Operators
+
+  //! Assignment operator
+  inline const Vector3D<S> &operator=(const Vector3D<S> &v)
+  {
+    x = v.x;
+    y = v.y;
+    z = v.z;
+    return *this;
+  }
+  //! Assignment operator
+  inline const Vector3D<S> &operator=(S s)
+  {
+    x = y = z = s;
+    return *this;
+  }
+  //! Assign and add operator
+  inline const Vector3D<S> &operator+=(const Vector3D<S> &v)
+  {
+    x += v.x;
+    y += v.y;
+    z += v.z;
+    return *this;
+  }
+  //! Assign and add operator
+  inline const Vector3D<S> &operator+=(S s)
+  {
+    x += s;
+    y += s;
+    z += s;
+    return *this;
+  }
+  //! Assign and sub operator
+  inline const Vector3D<S> &operator-=(const Vector3D<S> &v)
+  {
+    x -= v.x;
+    y -= v.y;
+    z -= v.z;
+    return *this;
+  }
+  //! Assign and sub operator
+  inline const Vector3D<S> &operator-=(S s)
+  {
+    x -= s;
+    y -= s;
+    z -= s;
+    return *this;
+  }
+  //! Assign and mult operator
+  inline const Vector3D<S> &operator*=(const Vector3D<S> &v)
+  {
+    x *= v.x;
+    y *= v.y;
+    z *= v.z;
+    return *this;
+  }
+  //! Assign and mult operator
+  inline const Vector3D<S> &operator*=(S s)
+  {
+    x *= s;
+    y *= s;
+    z *= s;
+    return *this;
+  }
+  //! Assign and div operator
+  inline const Vector3D<S> &operator/=(const Vector3D<S> &v)
+  {
+    x /= v.x;
+    y /= v.y;
+    z /= v.z;
+    return *this;
+  }
+  //! Assign and div operator
+  inline const Vector3D<S> &operator/=(S s)
+  {
+    x /= s;
+    y /= s;
+    z /= s;
+    return *this;
+  }
+  //! Negation operator
+  inline Vector3D<S> operator-() const
+  {
+    return Vector3D<S>(-x, -y, -z);
+  }
+
+  //! Get smallest component
+  inline S min() const
+  {
+    return (x < y) ? ((x < z) ? x : z) : ((y < z) ? y : z);
+  }
+  //! Get biggest component
+  inline S max() const
+  {
+    return (x > y) ? ((x > z) ? x : z) : ((y > z) ? y : z);
+  }
+
+  //! Test if all components are zero
+  inline bool empty()
+  {
+    return x == 0 && y == 0 && z == 0;
+  }
+
+  //! access operator
+  inline S &operator[](unsigned int i)
+  {
+    return value[i];
+  }
+  //! constant access operator
+  inline const S &operator[](unsigned int i) const
+  {
+    return value[i];
+  }
+
+  //! debug output vector to a string
+  std::string toString() const;
+
+  //! test if nans are present
+  bool isValid() const;
+
+  //! actual values
+  union {
+    S value[3];
+    struct {
+      S x;
+      S y;
+      S z;
+    };
+    struct {
+      S X;
+      S Y;
+      S Z;
+    };
+  };
+
+  //! zero element
+  static const Vector3D<S> Zero, Invalid;
+
+  //! For compatibility with 4d vectors (discards 4th comp)
+  inline Vector3D(S vx, S vy, S vz, S vDummy) : x(vx), y(vy), z(vz)
+  {
+  }
+
+ protected:
+};
+
+//! helper to check whether float/double value is non-zero
+inline bool notZero(Real f)
+{
+  if (std::abs(f) > VECTOR_EPSILON)
+    return true;
+  return false;
+}
+
+//************************************************************************
+// Additional operators
+//************************************************************************
+
+//! Addition operator
+template<class S> inline Vector3D<S> operator+(const Vector3D<S> &v1, const Vector3D<S> &v2)
+{
+  return Vector3D<S>(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
+}
+//! Addition operator
+template<class S, class S2> inline Vector3D<S> operator+(const Vector3D<S> &v, S2 s)
+{
+  return Vector3D<S>(v.x + s, v.y + s, v.z + s);
+}
+//! Addition operator
+template<class S, class S2> inline Vector3D<S> operator+(S2 s, const Vector3D<S> &v)
+{
+  return Vector3D<S>(v.x + s, v.y + s, v.z + s);
+}
+
+//! Subtraction operator
+template<class S> inline Vector3D<S> operator-(const Vector3D<S> &v1, const Vector3D<S> &v2)
+{
+  return Vector3D<S>(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
+}
+//! Subtraction operator
+template<class S, class S2> inline Vector3D<S> operator-(const Vector3D<S> &v, S2 s)
+{
+  return Vector3D<S>(v.x - s, v.y - s, v.z - s);
+}
+//! Subtraction operator
+template<class S, class S2> inline Vector3D<S> operator-(S2 s, const Vector3D<S> &v)
+{
+  return Vector3D<S>(s - v.x, s - v.y, s - v.z);
+}
+
+//! Multiplication operator
+template<class S> inline Vector3D<S> operator*(const Vector3D<S> &v1, const Vector3D<S> &v2)
+{
+  return Vector3D<S>(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
+}
+//! Multiplication operator
+template<class S, class S2> inline Vector3D<S> operator*(const Vector3D<S> &v, S2 s)
+{
+  return Vector3D<S>(v.x * s, v.y * s, v.z * s);
+}
+//! Multiplication operator
+template<class S, class S2> inline Vector3D<S> operator*(S2 s, const Vector3D<S> &v)
+{
+  return Vector3D<S>(s * v.x, s * v.y, s * v.z);
+}
+
+//! Division operator
+template<class S> inline Vector3D<S> operator/(const Vector3D<S> &v1, const Vector3D<S> &v2)
+{
+  return Vector3D<S>(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z);
+}
+//! Division operator
+template<class S, class S2> inline Vector3D<S> operator/(const Vector3D<S> &v, S2 s)
+{
+  return Vector3D<S>(v.x / s, v.y / s, v.z / s);
+}
+//! Division operator
+template<class S, class S2> inline Vector3D<S> operator/(S2 s, const Vector3D<S> &v)
+{
+  return Vector3D<S>(s / v.x, s / v.y, s / v.z);
+}
+
+//! Comparison operator
+template<class S> inline bool operator==(const Vector3D<S> &s1, const Vector3D<S> &s2)
+{
+  return s1.x == s2.x && s1.y == s2.y && s1.z == s2.z;
+}
+
+//! Comparison operator
+template<class S> inline bool operator!=(const Vector3D<S> &s1, const Vector3D<S> &s2)
+{
+  return s1.x != s2.x || s1.y != s2.y || s1.z != s2.z;
+}
+
+//************************************************************************
+// External functions
+//************************************************************************
+
+//! Min operator
+template<class S> inline Vector3D<S> vmin(const Vector3D<S> &s1, const Vector3D<S> &s2)
+{
+  return Vector3D<S>(std::min(s1.x, s2.x), std::min(s1.y, s2.y), std::min(s1.z, s2.z));
+}
+
+//! Min operator
+template<class S, class S2> inline Vector3D<S> vmin(const Vector3D<S> &s1, S2 s2)
+{
+  return Vector3D<S>(std::min(s1.x, s2), std::min(s1.y, s2), std::min(s1.z, s2));
+}
+
+//! Min operator
+template<class S1, class S> inline Vector3D<S> vmin(S1 s1, const Vector3D<S> &s2)
+{
+  return Vector3D<S>(std::min(s1, s2.x), std::min(s1, s2.y), std::min(s1, s2.z));
+}
+
+//! Max operator
+template<class S> inline Vector3D<S> vmax(const Vector3D<S> &s1, const Vector3D<S> &s2)
+{
+  return Vector3D<S>(std::max(s1.x, s2.x), std::max(s1.y, s2.y), std::max(s1.z, s2.z));
+}
+
+//! Max operator
+template<class S, class S2> inline Vector3D<S> vmax(const Vector3D<S> &s1, S2 s2)
+{
+  return Vector3D<S>(std::max(s1.x, s2), std::max(s1.y, s2), std::max(s1.z, s2));
+}
+
+//! Max operator
+template<class S1, class S> inline Vector3D<S> vmax(S1 s1, const Vector3D<S> &s2)
+{
+  return Vector3D<S>(std::max(s1, s2.x), std::max(s1, s2.y), std::max(s1, s2.z));
+}
+
+//! Dot product
+template<class S> inline S dot(const Vector3D<S> &t, const Vector3D<S> &v)
+{
+  return t.x * v.x + t.y * v.y + t.z * v.z;
+}
+
+//! Cross product
+template<class S> inline Vector3D<S> cross(const Vector3D<S> &t, const Vector3D<S> &v)
+{
+  Vector3D<S> cp(
+      ((t.y * v.z) - (t.z * v.y)), ((t.z * v.x) - (t.x * v.z)), ((t.x * v.y) - (t.y * v.x)));
+  return cp;
+}
+
+//! Project a vector into a plane, defined by its normal
+/*! Projects a vector into a plane normal to the given vector, which must
+  have unit length. Self is modified.
+  \param v The vector to project
+  \param n The plane normal
+  \return The projected vector */
+template<class S>
+inline const Vector3D<S> &projectNormalTo(const Vector3D<S> &v, const Vector3D<S> &n)
+{
+  S sprod = dot(v, n);
+  return v - n * dot(v, n);
+}
+
+//! Compute the magnitude (length) of the vector
+//! (clamps to 0 and 1 with VECTOR_EPSILON)
+template<class S> inline S norm(const Vector3D<S> &v)
+{
+  S l = v.x * v.x + v.y * v.y + v.z * v.z;
+  if (l <= VECTOR_EPSILON * VECTOR_EPSILON)
+    return (0.);
+  return (fabs(l - 1.) < VECTOR_EPSILON * VECTOR_EPSILON) ? 1. : sqrt(l);
+}
+
+//! Compute squared magnitude
+template<class S> inline S normSquare(const Vector3D<S> &v)
+{
+  return v.x * v.x + v.y * v.y + v.z * v.z;
+}
+
+//! compatibility, allow use of int, Real and Vec inputs with norm/normSquare
+inline Real norm(const Real v)
+{
+  return fabs(v);
+}
+inline Real normSquare(const Real v)
+{
+  return square(v);
+}
+inline Real norm(const int v)
+{
+  return abs(v);
+}
+inline Real normSquare(const int v)
+{
+  return square(v);
+}
+
+//! Returns a normalized vector
+template<class S> inline Vector3D<S> getNormalized(const Vector3D<S> &v)
+{
+  S l = v.x * v.x + v.y * v.y + v.z * v.z;
+  if (fabs(l - 1.) < VECTOR_EPSILON * VECTOR_EPSILON)
+    return v; /* normalized "enough"... */
+  else if (l > VECTOR_EPSILON * VECTOR_EPSILON) {
+    S fac = 1. / sqrt(l);
+    return Vector3D<S>(v.x * fac, v.y * fac, v.z * fac);
+  }
+  else
+    return Vector3D<S>((S)0);
+}
+
+//! Compute the norm of the vector and normalize it.
+/*! \return The value of the norm */
+template<class S> inline S normalize(Vector3D<S> &v)
+{
+  S norm;
+  S l = v.x * v.x + v.y * v.y + v.z * v.z;
+  if (fabs(l - 1.) < VECTOR_EPSILON * VECTOR_EPSILON) {
+    norm = 1.;
+  }
+  else if (l > VECTOR_EPSILON * VECTOR_EPSILON) {
+    norm = sqrt(l);
+    v *= 1. / norm;
+  }
+  else {
+    v = Vector3D<S>::Zero;
+    norm = 0.;
+  }
+  return (S)norm;
+}
+
+//! Obtain an orthogonal vector
+/*! Compute a vector that is orthonormal to the given vector.
+ *  Nothing else can be assumed for the direction of the new vector.
+ *  \return The orthonormal vector */
+template<class S> Vector3D<S> getOrthogonalVector(const Vector3D<S> &v)
+{
+  // Determine the  component with max. absolute value
+  int maxIndex = (fabs(v.x) > fabs(v.y)) ? 0 : 1;
+  maxIndex = (fabs(v[maxIndex]) > fabs(v.z)) ? maxIndex : 2;
+
+  // Choose another axis than the one with max. component and project
+  // orthogonal to self
+  Vector3D<S> o(0.0);
+  o[(maxIndex + 1) % 3] = 1;
+
+  Vector3D<S> c = cross(v, o);
+  normalize(c);
+  return c;
+}
+
+//! Convert vector to polar coordinates
+/*! Stable vector to angle conversion
+ *\param v vector to convert
+  \param phi unique angle [0,2PI]
+  \param theta unique angle [0,PI]
+ */
+template<class S> inline void vecToAngle(const Vector3D<S> &v, S &phi, S &theta)
+{
+  if (fabs(v.y) < VECTOR_EPSILON)
+    theta = M_PI / 2;
+  else if (fabs(v.x) < VECTOR_EPSILON && fabs(v.z) < VECTOR_EPSILON)
+    theta = (v.y >= 0) ? 0 : M_PI;
+  else
+    theta = atan(sqrt(v.x * v.x + v.z * v.z) / v.y);
+  if (theta < 0)
+    theta += M_PI;
+
+  if (fabs(v.x) < VECTOR_EPSILON)
+    phi = M_PI / 2;
+  else
+    phi = atan(v.z / v.x);
+  if (phi < 0)
+    phi += M_PI;
+  if (fabs(v.z) < VECTOR_EPSILON)
+    phi = (v.x >= 0) ? 0 : M_PI;
+  else if (v.z < 0)
+    phi += M_PI;
+}
+
+//! Compute vector reflected at a surface
+/*! Compute a vector, that is self (as an incoming vector)
+ * reflected at a surface with a distinct normal vector.
+ * Note that the normal is reversed, if the scalar product with it is positive.
+  \param t The incoming vector
+  \param n The surface normal
+  \return The new reflected vector
+  */
+template<class S> inline Vector3D<S> reflectVector(const Vector3D<S> &t, const Vector3D<S> &n)
+{
+  Vector3D<S> nn = (dot(t, n) > 0.0) ? (n * -1.0) : n;
+  return (t - nn * (2.0 * dot(nn, t)));
+}
+
+//! Compute vector refracted at a surface
+/*! \param t The incoming vector
+ *  \param n The surface normal
+ *  \param nt The "inside" refraction index
+ *  \param nair The "outside" refraction index
+ *  \param refRefl Set to 1 on total reflection
+ *  \return The refracted vector
+ */
+template<class S>
+inline Vector3D<S> refractVector(
+    const Vector3D<S> &t, const Vector3D<S> &normal, S nt, S nair, int &refRefl)
+{
+  // from Glassner's book, section 5.2 (Heckberts method)
+  S eta = nair / nt;
+  S n = -dot(t, normal);
+  S tt = 1.0 + eta * eta * (n * n - 1.0);
+  if (tt < 0.0) {
+    // we have total reflection!
+    refRefl = 1;
+  }
+  else {
+    // normal reflection
+    tt = eta * n - sqrt(tt);
+    return (t * eta + normal * tt);
+  }
+  return t;
+}
+
+//! Outputs the object in human readable form as string
+template<class S> std::string Vector3D<S>::toString() const
+{
+  char buf[256];
+  snprintf(buf,
+           256,
+           "[%+4.6f,%+4.6f,%+4.6f]",
+           (double)(*this)[0],
+           (double)(*this)[1],
+           (double)(*this)[2]);
+  // for debugging, optionally increase precision:
+  // snprintf ( buf,256,"[%+4.16f,%+4.16f,%+4.16f]", ( double ) ( *this ) [0], ( double ) ( *this )
+  // [1], ( double ) ( *this ) [2] );
+  return std::string(buf);
+}
+
+template<> std::string Vector3D<int>::toString() const;
+
+//! Outputs the object in human readable form to stream
+/*! Output format [x,y,z] */
+template<class S> std::ostream &operator<<(std::ostream &os, const Vector3D<S> &i)
+{
+  os << i.toString();
+  return os;
+}
+
+//! Reads the contents of the object from a stream
+/*! Input format [x,y,z] */
+template<class S> std::istream &operator>>(std::istream &is, Vector3D<S> &i)
+{
+  char c;
+  char dummy[3];
+  is >> c >> i[0] >> dummy >> i[1] >> dummy >> i[2] >> c;
+  return is;
+}
+
+/**************************************************************************/
+// Define default vector alias
+/**************************************************************************/
+
+//! 3D vector class of type Real (typically float)
+typedef Vector3D<Real> Vec3;
+
+//! 3D vector class of type int
+typedef Vector3D<int> Vec3i;
+
+//! convert to Real Vector
+template<class T> inline Vec3 toVec3(T v)
+{
+  return Vec3(v[0], v[1], v[2]);
+}
+
+//! convert to int Vector
+template<class T> inline Vec3i toVec3i(T v)
+{
+  return Vec3i((int)v[0], (int)v[1], (int)v[2]);
+}
+
+//! convert to int Vector
+template<class T> inline Vec3i toVec3i(T v0, T v1, T v2)
+{
+  return Vec3i((int)v0, (int)v1, (int)v2);
+}
+
+//! round, and convert to int Vector
+template<class T> inline Vec3i toVec3iRound(T v)
+{
+  return Vec3i((int)round(v[0]), (int)round(v[1]), (int)round(v[2]));
+}
+
+//! convert to int Vector if values are close enough to an int
+template<class T> inline Vec3i toVec3iChecked(T v)
+{
+  Vec3i ret;
+  for (size_t i = 0; i < 3; i++) {
+    Real a = v[i];
+    if (fabs(a - floor(a + 0.5)) > 1e-5)
+      errMsg("argument is not an int, cannot convert");
+    ret[i] = (int)(a + 0.5);
+  }
+  return ret;
+}
+
+//! convert to double Vector
+template<class T> inline Vector3D<double> toVec3d(T v)
+{
+  return Vector3D<double>(v[0], v[1], v[2]);
+}
+
+//! convert to float Vector
+template<class T> inline Vector3D<float> toVec3f(T v)
+{
+  return Vector3D<float>(v[0], v[1], v[2]);
+}
+
+/**************************************************************************/
+// Specializations for common math functions
+/**************************************************************************/
+
+template<> inline Vec3 clamp<Vec3>(const Vec3 &a, const Vec3 &b, const Vec3 &c)
+{
+  return Vec3(clamp(a.x, b.x, c.x), clamp(a.y, b.y, c.y), clamp(a.z, b.z, c.z));
+}
+template<> inline Vec3 safeDivide<Vec3>(const Vec3 &a, const Vec3 &b)
+{
+  return Vec3(safeDivide(a.x, b.x), safeDivide(a.y, b.y), safeDivide(a.z, b.z));
+}
+template<> inline Vec3 nmod<Vec3>(const Vec3 &a, const Vec3 &b)
+{
+  return Vec3(nmod(a.x, b.x), nmod(a.y, b.y), nmod(a.z, b.z));
+}
+
+};  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/commonkernels.h b/extern/mantaflow/preprocessed/commonkernels.h
new file mode 100644
index 00000000000..7fa6f185146
--- /dev/null
+++ b/extern/mantaflow/preprocessed/commonkernels.h
@@ -0,0 +1,1300 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Common grid kernels
+ *
+ ******************************************************************************/
+
+#ifndef _COMMONKERNELS_H
+#define _COMMONKERNELS_H
+
+#include "general.h"
+#include "kernel.h"
+#include "grid.h"
+
+namespace Manta {
+
+//! Kernel: Invert real values, if positive and fluid
+
+struct InvertCheckFluid : public KernelBase {
+  InvertCheckFluid(const FlagGrid &flags, Grid<Real> &grid)
+      : KernelBase(&flags, 0), flags(flags), grid(grid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const FlagGrid &flags, Grid<Real> &grid) const
+  {
+    if (flags.isFluid(idx) && grid[idx] > 0)
+      grid[idx] = 1.0 / grid[idx];
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel InvertCheckFluid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, grid);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &grid;
+};
+
+//! Kernel: Squared sum over grid
+
+struct GridSumSqr : public KernelBase {
+  GridSumSqr(const Grid<Real> &grid) : KernelBase(&grid, 0), grid(grid), sum(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &grid, double &sum)
+  {
+    sum += square((double)grid[idx]);
+  }
+  inline operator double()
+  {
+    return sum;
+  }
+  inline double &getRet()
+  {
+    return sum;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel GridSumSqr ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, grid, sum);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  GridSumSqr(GridSumSqr &o, tbb::split) : KernelBase(o), grid(o.grid), sum(0)
+  {
+  }
+  void join(const GridSumSqr &o)
+  {
+    sum += o.sum;
+  }
+  const Grid<Real> &grid;
+  double sum;
+};
+
+//! Kernel: rotation operator \nabla x v for centered vector fields
+
+struct CurlOp : public KernelBase {
+  CurlOp(const Grid<Vec3> &grid, Grid<Vec3> &dst) : KernelBase(&grid, 1), grid(grid), dst(dst)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<Vec3> &grid, Grid<Vec3> &dst) const
+  {
+    Vec3 v = Vec3(0.,
+                  0.,
+                  0.5 * ((grid(i + 1, j, k).y - grid(i - 1, j, k).y) -
+                         (grid(i, j + 1, k).x - grid(i, j - 1, k).x)));
+    if (dst.is3D()) {
+      v[0] = 0.5 * ((grid(i, j + 1, k).z - grid(i, j - 1, k).z) -
+                    (grid(i, j, k + 1).y - grid(i, j, k - 1).y));
+      v[1] = 0.5 * ((grid(i, j, k + 1).x - grid(i, j, k - 1).x) -
+                    (grid(i + 1, j, k).z - grid(i - 1, j, k).z));
+    }
+    dst(i, j, k) = v;
+  }
+  inline const Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline Grid<Vec3> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel CurlOp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, grid, dst);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, grid, dst);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<Vec3> &grid;
+  Grid<Vec3> &dst;
+};
+;
+
+//! Kernel: divergence operator (from MAC grid)
+
+struct DivergenceOpMAC : public KernelBase {
+  DivergenceOpMAC(Grid<Real> &div, const MACGrid &grid) : KernelBase(&div, 1), div(div), grid(grid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &div, const MACGrid &grid) const
+  {
+    Vec3 del = Vec3(grid(i + 1, j, k).x, grid(i, j + 1, k).y, 0.) - grid(i, j, k);
+    if (grid.is3D())
+      del[2] += grid(i, j, k + 1).z;
+    else
+      del[2] = 0.;
+    div(i, j, k) = del.x + del.y + del.z;
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return div;
+  }
+  typedef Grid<Real> type0;
+  inline const MACGrid &getArg1()
+  {
+    return grid;
+  }
+  typedef MACGrid type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel DivergenceOpMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, div, grid);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, div, grid);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &div;
+  const MACGrid &grid;
+};
+
+//! Kernel: gradient operator for MAC grid
+struct GradientOpMAC : public KernelBase {
+  GradientOpMAC(MACGrid &gradient, const Grid<Real> &grid)
+      : KernelBase(&gradient, 1), gradient(gradient), grid(grid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, MACGrid &gradient, const Grid<Real> &grid) const
+  {
+    Vec3 grad = (Vec3(grid(i, j, k)) - Vec3(grid(i - 1, j, k), grid(i, j - 1, k), 0.));
+    if (grid.is3D())
+      grad[2] -= grid(i, j, k - 1);
+    else
+      grad[2] = 0.;
+    gradient(i, j, k) = grad;
+  }
+  inline MACGrid &getArg0()
+  {
+    return gradient;
+  }
+  typedef MACGrid type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel GradientOpMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, gradient, grid);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, gradient, grid);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MACGrid &gradient;
+  const Grid<Real> &grid;
+};
+
+//! Kernel: centered gradient operator
+struct GradientOp : public KernelBase {
+  GradientOp(Grid<Vec3> &gradient, const Grid<Real> &grid)
+      : KernelBase(&gradient, 1), gradient(gradient), grid(grid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Vec3> &gradient, const Grid<Real> &grid) const
+  {
+    Vec3 grad = 0.5 * Vec3(grid(i + 1, j, k) - grid(i - 1, j, k),
+                           grid(i, j + 1, k) - grid(i, j - 1, k),
+                           0.);
+    if (grid.is3D())
+      grad[2] = 0.5 * (grid(i, j, k + 1) - grid(i, j, k - 1));
+    gradient(i, j, k) = grad;
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return gradient;
+  }
+  typedef Grid<Vec3> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel GradientOp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, gradient, grid);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, gradient, grid);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Vec3> &gradient;
+  const Grid<Real> &grid;
+};
+
+//! Kernel: Laplace operator
+struct LaplaceOp : public KernelBase {
+  LaplaceOp(Grid<Real> &laplace, const Grid<Real> &grid)
+      : KernelBase(&laplace, 1), laplace(laplace), grid(grid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &laplace, const Grid<Real> &grid) const
+  {
+    laplace(i, j, k) = grid(i + 1, j, k) - 2.0 * grid(i, j, k) + grid(i - 1, j, k);
+    laplace(i, j, k) += grid(i, j + 1, k) - 2.0 * grid(i, j, k) + grid(i, j - 1, k);
+    if (grid.is3D()) {
+      laplace(i, j, k) += grid(i, j, k + 1) - 2.0 * grid(i, j, k) + grid(i, j, k - 1);
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return laplace;
+  }
+  typedef Grid<Real> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel LaplaceOp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, laplace, grid);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, laplace, grid);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &laplace;
+  const Grid<Real> &grid;
+};
+
+//! Kernel: Curvature operator
+struct CurvatureOp : public KernelBase {
+  CurvatureOp(Grid<Real> &curv, const Grid<Real> &grid, const Real h)
+      : KernelBase(&curv, 1), curv(curv), grid(grid), h(h)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &curv, const Grid<Real> &grid, const Real h) const
+  {
+    const Real over_h = 1.0 / h;
+    const Real x = 0.5 * (grid(i + 1, j, k) - grid(i - 1, j, k)) * over_h;
+    const Real y = 0.5 * (grid(i, j + 1, k) - grid(i, j - 1, k)) * over_h;
+    const Real xx = (grid(i + 1, j, k) - 2.0 * grid(i, j, k) + grid(i - 1, j, k)) * over_h *
+                    over_h;
+    const Real yy = (grid(i, j + 1, k) - 2.0 * grid(i, j, k) + grid(i, j - 1, k)) * over_h *
+                    over_h;
+    const Real xy = 0.25 *
+                    (grid(i + 1, j + 1, k) + grid(i - 1, j - 1, k) - grid(i - 1, j + 1, k) -
+                     grid(i + 1, j - 1, k)) *
+                    over_h * over_h;
+    curv(i, j, k) = x * x * yy + y * y * xx - 2.0 * x * y * xy;
+    Real denom = x * x + y * y;
+    if (grid.is3D()) {
+      const Real z = 0.5 * (grid(i, j, k + 1) - grid(i, j, k - 1)) * over_h;
+      const Real zz = (grid(i, j, k + 1) - 2.0 * grid(i, j, k) + grid(i, j, k - 1)) * over_h *
+                      over_h;
+      const Real xz = 0.25 *
+                      (grid(i + 1, j, k + 1) + grid(i - 1, j, k - 1) - grid(i - 1, j, k + 1) -
+                       grid(i + 1, j, k - 1)) *
+                      over_h * over_h;
+      const Real yz = 0.25 *
+                      (grid(i, j + 1, k + 1) + grid(i, j - 1, k - 1) - grid(i, j + 1, k - 1) -
+                       grid(i, j - 1, k + 1)) *
+                      over_h * over_h;
+      curv(i, j, k) += x * x * zz + z * z * xx + y * y * zz + z * z * yy -
+                       2.0 * (x * z * xz + y * z * yz);
+      denom += z * z;
+    }
+    curv(i, j, k) /= std::pow(std::max(denom, VECTOR_EPSILON), 1.5);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return curv;
+  }
+  typedef Grid<Real> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type1;
+  inline const Real &getArg2()
+  {
+    return h;
+  }
+  typedef Real type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel CurvatureOp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, curv, grid, h);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, curv, grid, h);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &curv;
+  const Grid<Real> &grid;
+  const Real h;
+};
+
+//! Kernel: get component at MAC positions
+struct GetShiftedComponent : public KernelBase {
+  GetShiftedComponent(const Grid<Vec3> &grid, Grid<Real> &comp, int dim)
+      : KernelBase(&grid, 1), grid(grid), comp(comp), dim(dim)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<Vec3> &grid, Grid<Real> &comp, int dim) const
+  {
+    Vec3i ishift(i, j, k);
+    ishift[dim]--;
+    comp(i, j, k) = 0.5 * (grid(i, j, k)[dim] + grid(ishift)[dim]);
+  }
+  inline const Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return comp;
+  }
+  typedef Grid<Real> type1;
+  inline int &getArg2()
+  {
+    return dim;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel GetShiftedComponent ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, grid, comp, dim);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, grid, comp, dim);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<Vec3> &grid;
+  Grid<Real> &comp;
+  int dim;
+};
+;
+
+//! Kernel: get component (not shifted)
+struct GetComponent : public KernelBase {
+  GetComponent(const Grid<Vec3> &grid, Grid<Real> &comp, int dim)
+      : KernelBase(&grid, 0), grid(grid), comp(comp), dim(dim)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Vec3> &grid, Grid<Real> &comp, int dim) const
+  {
+    comp[idx] = grid[idx][dim];
+  }
+  inline const Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return comp;
+  }
+  typedef Grid<Real> type1;
+  inline int &getArg2()
+  {
+    return dim;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel GetComponent ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, grid, comp, dim);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const Grid<Vec3> &grid;
+  Grid<Real> &comp;
+  int dim;
+};
+;
+
+//! Kernel: get norm of centered grid
+struct GridNorm : public KernelBase {
+  GridNorm(Grid<Real> &n, const Grid<Vec3> &grid) : KernelBase(&n, 0), n(n), grid(grid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Real> &n, const Grid<Vec3> &grid) const
+  {
+    n[idx] = norm(grid[idx]);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return n;
+  }
+  typedef Grid<Real> type0;
+  inline const Grid<Vec3> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel GridNorm ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, n, grid);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &n;
+  const Grid<Vec3> &grid;
+};
+;
+
+//! Kernel: set component (not shifted)
+struct SetComponent : public KernelBase {
+  SetComponent(Grid<Vec3> &grid, const Grid<Real> &comp, int dim)
+      : KernelBase(&grid, 0), grid(grid), comp(comp), dim(dim)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Vec3> &grid, const Grid<Real> &comp, int dim) const
+  {
+    grid[idx][dim] = comp[idx];
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return comp;
+  }
+  typedef Grid<Real> type1;
+  inline int &getArg2()
+  {
+    return dim;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel SetComponent ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, grid, comp, dim);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Vec3> &grid;
+  const Grid<Real> &comp;
+  int dim;
+};
+;
+
+//! Kernel: compute centered velocity field from MAC
+struct GetCentered : public KernelBase {
+  GetCentered(Grid<Vec3> &center, const MACGrid &vel)
+      : KernelBase(&center, 1), center(center), vel(vel)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Vec3> &center, const MACGrid &vel) const
+  {
+    Vec3 v = 0.5 * (vel(i, j, k) + Vec3(vel(i + 1, j, k).x, vel(i, j + 1, k).y, 0.));
+    if (vel.is3D())
+      v[2] += 0.5 * vel(i, j, k + 1).z;
+    else
+      v[2] = 0.;
+    center(i, j, k) = v;
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return center;
+  }
+  typedef Grid<Vec3> type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel GetCentered ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, center, vel);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, center, vel);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Vec3> &center;
+  const MACGrid &vel;
+};
+;
+
+//! Kernel: compute MAC from centered velocity field
+struct GetMAC : public KernelBase {
+  GetMAC(MACGrid &vel, const Grid<Vec3> &center) : KernelBase(&vel, 1), vel(vel), center(center)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, MACGrid &vel, const Grid<Vec3> &center) const
+  {
+    Vec3 v = 0.5 * (center(i, j, k) + Vec3(center(i - 1, j, k).x, center(i, j - 1, k).y, 0.));
+    if (vel.is3D())
+      v[2] += 0.5 * center(i, j, k - 1).z;
+    else
+      v[2] = 0.;
+    vel(i, j, k) = v;
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline const Grid<Vec3> &getArg1()
+  {
+    return center;
+  }
+  typedef Grid<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel GetMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, center);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, center);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MACGrid &vel;
+  const Grid<Vec3> &center;
+};
+;
+
+//! Fill in the domain boundary cells (i,j,k=0/size-1) from the neighboring cells
+struct FillInBoundary : public KernelBase {
+  FillInBoundary(Grid<Vec3> &grid, int g) : KernelBase(&grid, 0), grid(grid), g(g)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Vec3> &grid, int g) const
+  {
+    if (i == 0)
+      grid(i, j, k) = grid(i + 1, j, k);
+    if (j == 0)
+      grid(i, j, k) = grid(i, j + 1, k);
+    if (k == 0)
+      grid(i, j, k) = grid(i, j, k + 1);
+    if (i == grid.getSizeX() - 1)
+      grid(i, j, k) = grid(i - 1, j, k);
+    if (j == grid.getSizeY() - 1)
+      grid(i, j, k) = grid(i, j - 1, k);
+    if (k == grid.getSizeZ() - 1)
+      grid(i, j, k) = grid(i, j, k - 1);
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline int &getArg1()
+  {
+    return g;
+  }
+  typedef int type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel FillInBoundary ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, g);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, g);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Vec3> &grid;
+  int g;
+};
+
+// ****************************************************************************
+
+// helper functions for converting mex data to manta grids and back (for matlab integration)
+
+// MAC grids
+
+struct kn_conv_mex_in_to_MAC : public KernelBase {
+  kn_conv_mex_in_to_MAC(const double *p_lin_array, MACGrid *p_result)
+      : KernelBase(p_result, 0), p_lin_array(p_lin_array), p_result(p_result)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const double *p_lin_array, MACGrid *p_result) const
+  {
+    int ijk = i + j * p_result->getSizeX() + k * p_result->getSizeX() * p_result->getSizeY();
+    const int n = p_result->getSizeX() * p_result->getSizeY() * p_result->getSizeZ();
+
+    p_result->get(i, j, k).x = p_lin_array[ijk];
+    p_result->get(i, j, k).y = p_lin_array[ijk + n];
+    p_result->get(i, j, k).z = p_lin_array[ijk + 2 * n];
+  }
+  inline const double *getArg0()
+  {
+    return p_lin_array;
+  }
+  typedef double type0;
+  inline MACGrid *getArg1()
+  {
+    return p_result;
+  }
+  typedef MACGrid type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn_conv_mex_in_to_MAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, p_lin_array, p_result);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, p_lin_array, p_result);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const double *p_lin_array;
+  MACGrid *p_result;
+};
+
+struct kn_conv_MAC_to_mex_out : public KernelBase {
+  kn_conv_MAC_to_mex_out(const MACGrid *p_mac, double *p_result)
+      : KernelBase(p_mac, 0), p_mac(p_mac), p_result(p_result)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const MACGrid *p_mac, double *p_result) const
+  {
+    int ijk = i + j * p_mac->getSizeX() + k * p_mac->getSizeX() * p_mac->getSizeY();
+    const int n = p_mac->getSizeX() * p_mac->getSizeY() * p_mac->getSizeZ();
+
+    p_result[ijk] = p_mac->get(i, j, k).x;
+    p_result[ijk + n] = p_mac->get(i, j, k).y;
+    p_result[ijk + 2 * n] = p_mac->get(i, j, k).z;
+  }
+  inline const MACGrid *getArg0()
+  {
+    return p_mac;
+  }
+  typedef MACGrid type0;
+  inline double *getArg1()
+  {
+    return p_result;
+  }
+  typedef double type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn_conv_MAC_to_mex_out ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, p_mac, p_result);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, p_mac, p_result);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const MACGrid *p_mac;
+  double *p_result;
+};
+
+// Vec3 Grids
+
+struct kn_conv_mex_in_to_Vec3 : public KernelBase {
+  kn_conv_mex_in_to_Vec3(const double *p_lin_array, Grid<Vec3> *p_result)
+      : KernelBase(p_result, 0), p_lin_array(p_lin_array), p_result(p_result)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const double *p_lin_array, Grid<Vec3> *p_result) const
+  {
+    int ijk = i + j * p_result->getSizeX() + k * p_result->getSizeX() * p_result->getSizeY();
+    const int n = p_result->getSizeX() * p_result->getSizeY() * p_result->getSizeZ();
+
+    p_result->get(i, j, k).x = p_lin_array[ijk];
+    p_result->get(i, j, k).y = p_lin_array[ijk + n];
+    p_result->get(i, j, k).z = p_lin_array[ijk + 2 * n];
+  }
+  inline const double *getArg0()
+  {
+    return p_lin_array;
+  }
+  typedef double type0;
+  inline Grid<Vec3> *getArg1()
+  {
+    return p_result;
+  }
+  typedef Grid<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn_conv_mex_in_to_Vec3 ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, p_lin_array, p_result);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, p_lin_array, p_result);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const double *p_lin_array;
+  Grid<Vec3> *p_result;
+};
+
+struct kn_conv_Vec3_to_mex_out : public KernelBase {
+  kn_conv_Vec3_to_mex_out(const Grid<Vec3> *p_Vec3, double *p_result)
+      : KernelBase(p_Vec3, 0), p_Vec3(p_Vec3), p_result(p_result)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<Vec3> *p_Vec3, double *p_result) const
+  {
+    int ijk = i + j * p_Vec3->getSizeX() + k * p_Vec3->getSizeX() * p_Vec3->getSizeY();
+    const int n = p_Vec3->getSizeX() * p_Vec3->getSizeY() * p_Vec3->getSizeZ();
+
+    p_result[ijk] = p_Vec3->get(i, j, k).x;
+    p_result[ijk + n] = p_Vec3->get(i, j, k).y;
+    p_result[ijk + 2 * n] = p_Vec3->get(i, j, k).z;
+  }
+  inline const Grid<Vec3> *getArg0()
+  {
+    return p_Vec3;
+  }
+  typedef Grid<Vec3> type0;
+  inline double *getArg1()
+  {
+    return p_result;
+  }
+  typedef double type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn_conv_Vec3_to_mex_out ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, p_Vec3, p_result);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, p_Vec3, p_result);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const Grid<Vec3> *p_Vec3;
+  double *p_result;
+};
+
+// Real Grids
+
+struct kn_conv_mex_in_to_Real : public KernelBase {
+  kn_conv_mex_in_to_Real(const double *p_lin_array, Grid<Real> *p_result)
+      : KernelBase(p_result, 0), p_lin_array(p_lin_array), p_result(p_result)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const double *p_lin_array, Grid<Real> *p_result) const
+  {
+    int ijk = i + j * p_result->getSizeX() + k * p_result->getSizeX() * p_result->getSizeY();
+
+    p_result->get(i, j, k) = p_lin_array[ijk];
+  }
+  inline const double *getArg0()
+  {
+    return p_lin_array;
+  }
+  typedef double type0;
+  inline Grid<Real> *getArg1()
+  {
+    return p_result;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn_conv_mex_in_to_Real ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, p_lin_array, p_result);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, p_lin_array, p_result);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const double *p_lin_array;
+  Grid<Real> *p_result;
+};
+
+struct kn_conv_Real_to_mex_out : public KernelBase {
+  kn_conv_Real_to_mex_out(const Grid<Real> *p_grid, double *p_result)
+      : KernelBase(p_grid, 0), p_grid(p_grid), p_result(p_result)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<Real> *p_grid, double *p_result) const
+  {
+    int ijk = i + j * p_grid->getSizeX() + k * p_grid->getSizeX() * p_grid->getSizeY();
+
+    p_result[ijk] = p_grid->get(i, j, k);
+  }
+  inline const Grid<Real> *getArg0()
+  {
+    return p_grid;
+  }
+  typedef Grid<Real> type0;
+  inline double *getArg1()
+  {
+    return p_result;
+  }
+  typedef double type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn_conv_Real_to_mex_out ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, p_grid, p_result);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, p_grid, p_result);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const Grid<Real> *p_grid;
+  double *p_result;
+};
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/commonkernels.h.reg.cpp b/extern/mantaflow/preprocessed/commonkernels.h.reg.cpp
new file mode 100644
index 00000000000..0a7a55b7147
--- /dev/null
+++ b/extern/mantaflow/preprocessed/commonkernels.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "commonkernels.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_2()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/conjugategrad.cpp b/extern/mantaflow/preprocessed/conjugategrad.cpp
new file mode 100644
index 00000000000..ac317402a49
--- /dev/null
+++ b/extern/mantaflow/preprocessed/conjugategrad.cpp
@@ -0,0 +1,719 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Conjugate gradient solver, for pressure and viscosity
+ *
+ ******************************************************************************/
+
+#include "conjugategrad.h"
+#include "commonkernels.h"
+
+using namespace std;
+namespace Manta {
+
+const int CG_DEBUGLEVEL = 3;
+
+//*****************************************************************************
+//  Precondition helpers
+
+//! Preconditioning a la Wavelet Turbulence (needs 4 add. grids)
+void InitPreconditionIncompCholesky(const FlagGrid &flags,
+                                    Grid<Real> &A0,
+                                    Grid<Real> &Ai,
+                                    Grid<Real> &Aj,
+                                    Grid<Real> &Ak,
+                                    Grid<Real> &orgA0,
+                                    Grid<Real> &orgAi,
+                                    Grid<Real> &orgAj,
+                                    Grid<Real> &orgAk)
+{
+  // compute IC according to Golub and Van Loan
+  A0.copyFrom(orgA0);
+  Ai.copyFrom(orgAi);
+  Aj.copyFrom(orgAj);
+  Ak.copyFrom(orgAk);
+
+  FOR_IJK(A0)
+  {
+    if (flags.isFluid(i, j, k)) {
+      const IndexInt idx = A0.index(i, j, k);
+      A0[idx] = sqrt(A0[idx]);
+
+      // correct left and top stencil in other entries
+      // for i = k+1:n
+      //  if (A(i,k) != 0)
+      //    A(i,k) = A(i,k) / A(k,k)
+      Real invDiagonal = 1.0f / A0[idx];
+      Ai[idx] *= invDiagonal;
+      Aj[idx] *= invDiagonal;
+      Ak[idx] *= invDiagonal;
+
+      // correct the right and bottom stencil in other entries
+      // for j = k+1:n
+      //   for i = j:n
+      //      if (A(i,j) != 0)
+      //        A(i,j) = A(i,j) - A(i,k) * A(j,k)
+      A0(i + 1, j, k) -= square(Ai[idx]);
+      A0(i, j + 1, k) -= square(Aj[idx]);
+      A0(i, j, k + 1) -= square(Ak[idx]);
+    }
+  }
+
+  // invert A0 for faster computation later
+  InvertCheckFluid(flags, A0);
+};
+
+//! Preconditioning using modified IC ala Bridson (needs 1 add. grid)
+void InitPreconditionModifiedIncompCholesky2(const FlagGrid &flags,
+                                             Grid<Real> &Aprecond,
+                                             Grid<Real> &A0,
+                                             Grid<Real> &Ai,
+                                             Grid<Real> &Aj,
+                                             Grid<Real> &Ak)
+{
+  // compute IC according to Golub and Van Loan
+  Aprecond.clear();
+
+  FOR_IJK(flags)
+  {
+    if (!flags.isFluid(i, j, k))
+      continue;
+
+    const Real tau = 0.97;
+    const Real sigma = 0.25;
+
+    // compute modified incomplete cholesky
+    Real e = 0.;
+    e = A0(i, j, k) - square(Ai(i - 1, j, k) * Aprecond(i - 1, j, k)) -
+        square(Aj(i, j - 1, k) * Aprecond(i, j - 1, k)) -
+        square(Ak(i, j, k - 1) * Aprecond(i, j, k - 1));
+    e -= tau *
+         (Ai(i - 1, j, k) * (Aj(i - 1, j, k) + Ak(i - 1, j, k)) * square(Aprecond(i - 1, j, k)) +
+          Aj(i, j - 1, k) * (Ai(i, j - 1, k) + Ak(i, j - 1, k)) * square(Aprecond(i, j - 1, k)) +
+          Ak(i, j, k - 1) * (Ai(i, j, k - 1) + Aj(i, j, k - 1)) * square(Aprecond(i, j, k - 1)) +
+          0.);
+
+    // stability cutoff
+    if (e < sigma * A0(i, j, k))
+      e = A0(i, j, k);
+
+    Aprecond(i, j, k) = 1. / sqrt(e);
+  }
+};
+
+//! Preconditioning using multigrid ala Dick et al.
+void InitPreconditionMultigrid(
+    GridMg *MG, Grid<Real> &A0, Grid<Real> &Ai, Grid<Real> &Aj, Grid<Real> &Ak, Real mAccuracy)
+{
+  // build multigrid hierarchy if necessary
+  if (!MG->isASet())
+    MG->setA(&A0, &Ai, &Aj, &Ak);
+  MG->setCoarsestLevelAccuracy(mAccuracy * 1E-4);
+  MG->setSmoothing(1, 1);
+};
+
+//! Apply WT-style ICP
+void ApplyPreconditionIncompCholesky(Grid<Real> &dst,
+                                     Grid<Real> &Var1,
+                                     const FlagGrid &flags,
+                                     Grid<Real> &A0,
+                                     Grid<Real> &Ai,
+                                     Grid<Real> &Aj,
+                                     Grid<Real> &Ak,
+                                     Grid<Real> &orgA0,
+                                     Grid<Real> &orgAi,
+                                     Grid<Real> &orgAj,
+                                     Grid<Real> &orgAk)
+{
+
+  // forward substitution
+  FOR_IJK(dst)
+  {
+    if (!flags.isFluid(i, j, k))
+      continue;
+    dst(i, j, k) = A0(i, j, k) *
+                   (Var1(i, j, k) - dst(i - 1, j, k) * Ai(i - 1, j, k) -
+                    dst(i, j - 1, k) * Aj(i, j - 1, k) - dst(i, j, k - 1) * Ak(i, j, k - 1));
+  }
+
+  // backward substitution
+  FOR_IJK_REVERSE(dst)
+  {
+    const IndexInt idx = A0.index(i, j, k);
+    if (!flags.isFluid(idx))
+      continue;
+    dst[idx] = A0[idx] * (dst[idx] - dst(i + 1, j, k) * Ai[idx] - dst(i, j + 1, k) * Aj[idx] -
+                          dst(i, j, k + 1) * Ak[idx]);
+  }
+}
+
+//! Apply Bridson-style mICP
+void ApplyPreconditionModifiedIncompCholesky2(Grid<Real> &dst,
+                                              Grid<Real> &Var1,
+                                              const FlagGrid &flags,
+                                              Grid<Real> &Aprecond,
+                                              Grid<Real> &A0,
+                                              Grid<Real> &Ai,
+                                              Grid<Real> &Aj,
+                                              Grid<Real> &Ak)
+{
+  // forward substitution
+  FOR_IJK(dst)
+  {
+    if (!flags.isFluid(i, j, k))
+      continue;
+    const Real p = Aprecond(i, j, k);
+    dst(i, j, k) = p *
+                   (Var1(i, j, k) - dst(i - 1, j, k) * Ai(i - 1, j, k) * Aprecond(i - 1, j, k) -
+                    dst(i, j - 1, k) * Aj(i, j - 1, k) * Aprecond(i, j - 1, k) -
+                    dst(i, j, k - 1) * Ak(i, j, k - 1) * Aprecond(i, j, k - 1));
+  }
+
+  // backward substitution
+  FOR_IJK_REVERSE(dst)
+  {
+    const IndexInt idx = A0.index(i, j, k);
+    if (!flags.isFluid(idx))
+      continue;
+    const Real p = Aprecond[idx];
+    dst[idx] = p * (dst[idx] - dst(i + 1, j, k) * Ai[idx] * p - dst(i, j + 1, k) * Aj[idx] * p -
+                    dst(i, j, k + 1) * Ak[idx] * p);
+  }
+}
+
+//! Perform one Multigrid VCycle
+void ApplyPreconditionMultigrid(GridMg *pMG, Grid<Real> &dst, Grid<Real> &Var1)
+{
+  // one VCycle on "A*dst = Var1" with initial guess dst=0
+  pMG->setRhs(Var1);
+  pMG->doVCycle(dst);
+}
+
+//*****************************************************************************
+// Kernels
+
+//! Kernel: Compute the dot product between two Real grids
+/*! Uses double precision internally */
+
+struct GridDotProduct : public KernelBase {
+  GridDotProduct(const Grid<Real> &a, const Grid<Real> &b)
+      : KernelBase(&a, 0), a(a), b(b), result(0.0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &a, const Grid<Real> &b, double &result)
+  {
+    result += (a[idx] * b[idx]);
+  }
+  inline operator double()
+  {
+    return result;
+  }
+  inline double &getRet()
+  {
+    return result;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return a;
+  }
+  typedef Grid<Real> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return b;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel GridDotProduct ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, a, b, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  GridDotProduct(GridDotProduct &o, tbb::split) : KernelBase(o), a(o.a), b(o.b), result(0.0)
+  {
+  }
+  void join(const GridDotProduct &o)
+  {
+    result += o.result;
+  }
+  const Grid<Real> &a;
+  const Grid<Real> &b;
+  double result;
+};
+;
+
+//! Kernel: compute residual (init) and add to sigma
+
+struct InitSigma : public KernelBase {
+  InitSigma(const FlagGrid &flags, Grid<Real> &dst, Grid<Real> &rhs, Grid<Real> &temp)
+      : KernelBase(&flags, 0), flags(flags), dst(dst), rhs(rhs), temp(temp), sigma(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const FlagGrid &flags,
+                 Grid<Real> &dst,
+                 Grid<Real> &rhs,
+                 Grid<Real> &temp,
+                 double &sigma)
+  {
+    const double res = rhs[idx] - temp[idx];
+    dst[idx] = (Real)res;
+
+    // only compute residual in fluid region
+    if (flags.isFluid(idx))
+      sigma += res * res;
+  }
+  inline operator double()
+  {
+    return sigma;
+  }
+  inline double &getRet()
+  {
+    return sigma;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<Real> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return rhs;
+  }
+  typedef Grid<Real> type2;
+  inline Grid<Real> &getArg3()
+  {
+    return temp;
+  }
+  typedef Grid<Real> type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel InitSigma ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, dst, rhs, temp, sigma);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  InitSigma(InitSigma &o, tbb::split)
+      : KernelBase(o), flags(o.flags), dst(o.dst), rhs(o.rhs), temp(o.temp), sigma(0)
+  {
+  }
+  void join(const InitSigma &o)
+  {
+    sigma += o.sigma;
+  }
+  const FlagGrid &flags;
+  Grid<Real> &dst;
+  Grid<Real> &rhs;
+  Grid<Real> &temp;
+  double sigma;
+};
+;
+
+//! Kernel: update search vector
+
+struct UpdateSearchVec : public KernelBase {
+  UpdateSearchVec(Grid<Real> &dst, Grid<Real> &src, Real factor)
+      : KernelBase(&dst, 0), dst(dst), src(src), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Real> &dst, Grid<Real> &src, Real factor) const
+  {
+    dst[idx] = src[idx] + factor * dst[idx];
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return dst;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return src;
+  }
+  typedef Grid<Real> type1;
+  inline Real &getArg2()
+  {
+    return factor;
+  }
+  typedef Real type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel UpdateSearchVec ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, dst, src, factor);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &dst;
+  Grid<Real> &src;
+  Real factor;
+};
+
+//*****************************************************************************
+//  CG class
+
+template<class APPLYMAT>
+GridCg<APPLYMAT>::GridCg(Grid<Real> &dst,
+                         Grid<Real> &rhs,
+                         Grid<Real> &residual,
+                         Grid<Real> &search,
+                         const FlagGrid &flags,
+                         Grid<Real> &tmp,
+                         Grid<Real> *pA0,
+                         Grid<Real> *pAi,
+                         Grid<Real> *pAj,
+                         Grid<Real> *pAk)
+    : GridCgInterface(),
+      mInited(false),
+      mIterations(0),
+      mDst(dst),
+      mRhs(rhs),
+      mResidual(residual),
+      mSearch(search),
+      mFlags(flags),
+      mTmp(tmp),
+      mpA0(pA0),
+      mpAi(pAi),
+      mpAj(pAj),
+      mpAk(pAk),
+      mPcMethod(PC_None),
+      mpPCA0(nullptr),
+      mpPCAi(nullptr),
+      mpPCAj(nullptr),
+      mpPCAk(nullptr),
+      mMG(nullptr),
+      mSigma(0.),
+      mAccuracy(VECTOR_EPSILON),
+      mResNorm(1e20)
+{
+}
+
+template<class APPLYMAT> void GridCg<APPLYMAT>::doInit()
+{
+  mInited = true;
+  mIterations = 0;
+
+  mDst.clear();
+  mResidual.copyFrom(mRhs);  // p=0, residual = b
+
+  if (mPcMethod == PC_ICP) {
+    assertMsg(mDst.is3D(), "ICP only supports 3D grids so far");
+    InitPreconditionIncompCholesky(
+        mFlags, *mpPCA0, *mpPCAi, *mpPCAj, *mpPCAk, *mpA0, *mpAi, *mpAj, *mpAk);
+    ApplyPreconditionIncompCholesky(
+        mTmp, mResidual, mFlags, *mpPCA0, *mpPCAi, *mpPCAj, *mpPCAk, *mpA0, *mpAi, *mpAj, *mpAk);
+  }
+  else if (mPcMethod == PC_mICP) {
+    assertMsg(mDst.is3D(), "mICP only supports 3D grids so far");
+    InitPreconditionModifiedIncompCholesky2(mFlags, *mpPCA0, *mpA0, *mpAi, *mpAj, *mpAk);
+    ApplyPreconditionModifiedIncompCholesky2(
+        mTmp, mResidual, mFlags, *mpPCA0, *mpA0, *mpAi, *mpAj, *mpAk);
+  }
+  else if (mPcMethod == PC_MGP) {
+    InitPreconditionMultigrid(mMG, *mpA0, *mpAi, *mpAj, *mpAk, mAccuracy);
+    ApplyPreconditionMultigrid(mMG, mTmp, mResidual);
+  }
+  else {
+    mTmp.copyFrom(mResidual);
+  }
+
+  mSearch.copyFrom(mTmp);
+
+  mSigma = GridDotProduct(mTmp, mResidual);
+}
+
+template<class APPLYMAT> bool GridCg<APPLYMAT>::iterate()
+{
+  if (!mInited)
+    doInit();
+
+  mIterations++;
+
+  // create matrix application operator passed as template argument,
+  // this could reinterpret the mpA pointers (not so clean right now)
+  // tmp = applyMat(search)
+
+  APPLYMAT(mFlags, mTmp, mSearch, *mpA0, *mpAi, *mpAj, *mpAk);
+
+  // alpha = sigma/dot(tmp, search)
+  Real dp = GridDotProduct(mTmp, mSearch);
+  Real alpha = 0.;
+  if (fabs(dp) > 0.)
+    alpha = mSigma / (Real)dp;
+
+  gridScaledAdd<Real, Real>(mDst, mSearch, alpha);     // dst += search * alpha
+  gridScaledAdd<Real, Real>(mResidual, mTmp, -alpha);  // residual += tmp * -alpha
+
+  if (mPcMethod == PC_ICP)
+    ApplyPreconditionIncompCholesky(
+        mTmp, mResidual, mFlags, *mpPCA0, *mpPCAi, *mpPCAj, *mpPCAk, *mpA0, *mpAi, *mpAj, *mpAk);
+  else if (mPcMethod == PC_mICP)
+    ApplyPreconditionModifiedIncompCholesky2(
+        mTmp, mResidual, mFlags, *mpPCA0, *mpA0, *mpAi, *mpAj, *mpAk);
+  else if (mPcMethod == PC_MGP)
+    ApplyPreconditionMultigrid(mMG, mTmp, mResidual);
+  else
+    mTmp.copyFrom(mResidual);
+
+  // use the l2 norm of the residual for convergence check? (usually max norm is recommended
+  // instead)
+  if (this->mUseL2Norm) {
+    mResNorm = GridSumSqr(mResidual).sum;
+  }
+  else {
+    mResNorm = mResidual.getMaxAbs();
+  }
+
+  // abort here to safe some work...
+  if (mResNorm < mAccuracy) {
+    mSigma = mResNorm;  // this will be returned later on to the caller...
+    return false;
+  }
+
+  Real sigmaNew = GridDotProduct(mTmp, mResidual);
+  Real beta = sigmaNew / mSigma;
+
+  // search =  tmp + beta * search
+  UpdateSearchVec(mSearch, mTmp, beta);
+
+  debMsg("GridCg::iterate i=" << mIterations << " sigmaNew=" << sigmaNew << " sigmaLast=" << mSigma
+                              << " alpha=" << alpha << " beta=" << beta << " ",
+         CG_DEBUGLEVEL);
+  mSigma = sigmaNew;
+
+  if (!(mResNorm < 1e35)) {
+    if (mPcMethod == PC_MGP) {
+      // diverging solves can be caused by the static multigrid mode, we cannot detect this here,
+      // though only the pressure solve call "knows" whether the MG is static or dynamics...
+      debMsg(
+          "GridCg::iterate: Warning - this diverging solve can be caused by the 'static' mode of "
+          "the MG preconditioner. If the static mode is active, try switching to dynamic.",
+          1);
+    }
+    errMsg("GridCg::iterate: The CG solver diverged, residual norm > 1e30, stopping.");
+  }
+
+  // debMsg("PB-CG-Norms::p"<<sqrt( GridOpNormNosqrt(mpDst, mpFlags).getValue() ) <<"
+  // search"<<sqrt( GridOpNormNosqrt(mpSearch, mpFlags).getValue(), CG_DEBUGLEVEL ) <<" res"<<sqrt(
+  // GridOpNormNosqrt(mpResidual, mpFlags).getValue() ) <<" tmp"<<sqrt( GridOpNormNosqrt(mpTmp,
+  // mpFlags).getValue() ), CG_DEBUGLEVEL ); // debug
+  return true;
+}
+
+template<class APPLYMAT> void GridCg<APPLYMAT>::solve(int maxIter)
+{
+  for (int iter = 0; iter < maxIter; iter++) {
+    if (!iterate())
+      iter = maxIter;
+  }
+  return;
+}
+
+static bool gPrint2dWarning = true;
+template<class APPLYMAT>
+void GridCg<APPLYMAT>::setICPreconditioner(
+    PreconditionType method, Grid<Real> *A0, Grid<Real> *Ai, Grid<Real> *Aj, Grid<Real> *Ak)
+{
+  assertMsg(method == PC_ICP || method == PC_mICP,
+            "GridCg<APPLYMAT>::setICPreconditioner: Invalid method specified.");
+
+  mPcMethod = method;
+  if ((!A0->is3D())) {
+    if (gPrint2dWarning) {
+      debMsg("ICP/mICP pre-conditioning only supported in 3D for now, disabling it.", 1);
+      gPrint2dWarning = false;
+    }
+    mPcMethod = PC_None;
+  }
+  mpPCA0 = A0;
+  mpPCAi = Ai;
+  mpPCAj = Aj;
+  mpPCAk = Ak;
+}
+
+template<class APPLYMAT>
+void GridCg<APPLYMAT>::setMGPreconditioner(PreconditionType method, GridMg *MG)
+{
+  assertMsg(method == PC_MGP, "GridCg<APPLYMAT>::setMGPreconditioner: Invalid method specified.");
+
+  mPcMethod = method;
+
+  mMG = MG;
+}
+
+// explicit instantiation
+template class GridCg<ApplyMatrix>;
+template class GridCg<ApplyMatrix2D>;
+
+//*****************************************************************************
+// diffusion for real and vec grids, e.g. for viscosity
+
+//! do a CG solve for diffusion; note: diffusion coefficient alpha given in grid space,
+//  rescale in python file for discretization independence (or physical correspondence)
+//  see lidDrivenCavity.py for an example
+
+void cgSolveDiffusion(const FlagGrid &flags,
+                      GridBase &grid,
+                      Real alpha = 0.25,
+                      Real cgMaxIterFac = 1.0,
+                      Real cgAccuracy = 1e-4)
+{
+  // reserve temp grids
+  FluidSolver *parent = flags.getParent();
+  Grid<Real> rhs(parent);
+  Grid<Real> residual(parent), search(parent), tmp(parent);
+  Grid<Real> A0(parent), Ai(parent), Aj(parent), Ak(parent);
+
+  // setup matrix and boundaries
+  FlagGrid flagsDummy(parent);
+  flagsDummy.setConst(FlagGrid::TypeFluid);
+  MakeLaplaceMatrix(flagsDummy, A0, Ai, Aj, Ak);
+
+  FOR_IJK(flags)
+  {
+    if (flags.isObstacle(i, j, k)) {
+      Ai(i, j, k) = Aj(i, j, k) = Ak(i, j, k) = 0.0;
+      A0(i, j, k) = 1.0;
+    }
+    else {
+      Ai(i, j, k) *= alpha;
+      Aj(i, j, k) *= alpha;
+      Ak(i, j, k) *= alpha;
+      A0(i, j, k) *= alpha;
+      A0(i, j, k) += 1.;
+    }
+  }
+
+  GridCgInterface *gcg;
+  // note , no preconditioning for now...
+  const int maxIter = (int)(cgMaxIterFac * flags.getSize().max()) * (flags.is3D() ? 1 : 4);
+
+  if (grid.getType() & GridBase::TypeReal) {
+    Grid<Real> &u = ((Grid<Real> &)grid);
+    rhs.copyFrom(u);
+    if (flags.is3D())
+      gcg = new GridCg<ApplyMatrix>(u, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+    else
+      gcg = new GridCg<ApplyMatrix2D>(u, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+
+    gcg->setAccuracy(cgAccuracy);
+    gcg->solve(maxIter);
+
+    debMsg("FluidSolver::solveDiffusion iterations:" << gcg->getIterations()
+                                                     << ", res:" << gcg->getSigma(),
+           CG_DEBUGLEVEL);
+  }
+  else if ((grid.getType() & GridBase::TypeVec3) || (grid.getType() & GridBase::TypeVec3)) {
+    Grid<Vec3> &vec = ((Grid<Vec3> &)grid);
+    Grid<Real> u(parent);
+
+    // core solve is same as for a regular real grid
+    if (flags.is3D())
+      gcg = new GridCg<ApplyMatrix>(u, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+    else
+      gcg = new GridCg<ApplyMatrix2D>(u, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+    gcg->setAccuracy(cgAccuracy);
+
+    // diffuse every component separately
+    for (int component = 0; component < (grid.is3D() ? 3 : 2); ++component) {
+      getComponent(vec, u, component);
+      gcg->forceReinit();
+
+      rhs.copyFrom(u);
+      gcg->solve(maxIter);
+      debMsg("FluidSolver::solveDiffusion vec3, iterations:" << gcg->getIterations()
+                                                             << ", res:" << gcg->getSigma(),
+             CG_DEBUGLEVEL);
+
+      setComponent(u, vec, component);
+    }
+  }
+  else {
+    errMsg("cgSolveDiffusion: Grid Type is not supported (only Real, Vec3, MAC, or Levelset)");
+  }
+
+  delete gcg;
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "cgSolveDiffusion", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      GridBase &grid = *_args.getPtr<GridBase>("grid", 1, &_lock);
+      Real alpha = _args.getOpt<Real>("alpha", 2, 0.25, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 3, 1.0, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-4, &_lock);
+      _retval = getPyNone();
+      cgSolveDiffusion(flags, grid, alpha, cgMaxIterFac, cgAccuracy);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "cgSolveDiffusion", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("cgSolveDiffusion", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_cgSolveDiffusion("", "cgSolveDiffusion", _W_0);
+extern "C" {
+void PbRegister_cgSolveDiffusion()
+{
+  KEEP_UNUSED(_RP_cgSolveDiffusion);
+}
+}
+
+};  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/conjugategrad.h b/extern/mantaflow/preprocessed/conjugategrad.h
new file mode 100644
index 00000000000..58ccff28179
--- /dev/null
+++ b/extern/mantaflow/preprocessed/conjugategrad.h
@@ -0,0 +1,479 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Conjugate gradient solver
+ *
+ ******************************************************************************/
+
+#ifndef _CONJUGATEGRADIENT_H
+#define _CONJUGATEGRADIENT_H
+
+#include "vectorbase.h"
+#include "grid.h"
+#include "kernel.h"
+#include "multigrid.h"
+
+namespace Manta {
+
+static const bool CG_DEBUG = false;
+
+//! Basic CG interface
+class GridCgInterface {
+ public:
+  enum PreconditionType { PC_None = 0, PC_ICP, PC_mICP, PC_MGP };
+
+  GridCgInterface() : mUseL2Norm(true){};
+  virtual ~GridCgInterface(){};
+
+  // solving functions
+  virtual bool iterate() = 0;
+  virtual void solve(int maxIter) = 0;
+
+  // precond
+  virtual void setICPreconditioner(
+      PreconditionType method, Grid<Real> *A0, Grid<Real> *Ai, Grid<Real> *Aj, Grid<Real> *Ak) = 0;
+  virtual void setMGPreconditioner(PreconditionType method, GridMg *MG) = 0;
+
+  // access
+  virtual Real getSigma() const = 0;
+  virtual Real getIterations() const = 0;
+  virtual Real getResNorm() const = 0;
+  virtual void setAccuracy(Real set) = 0;
+  virtual Real getAccuracy() const = 0;
+
+  //! force reinit upon next iterate() call, can be used for doing multiple solves
+  virtual void forceReinit() = 0;
+
+  void setUseL2Norm(bool set)
+  {
+    mUseL2Norm = set;
+  }
+
+ protected:
+  // use l2 norm of residualfor threshold? (otherwise uses max norm)
+  bool mUseL2Norm;
+};
+
+//! Run single iteration of the cg solver
+/*! the template argument determines the type of matrix multiplication,
+  typically a ApplyMatrix kernel, another one is needed e.g. for the
+  mesh-based wave equation solver */
+template<class APPLYMAT> class GridCg : public GridCgInterface {
+ public:
+  //! constructor
+  GridCg(Grid<Real> &dst,
+         Grid<Real> &rhs,
+         Grid<Real> &residual,
+         Grid<Real> &search,
+         const FlagGrid &flags,
+         Grid<Real> &tmp,
+         Grid<Real> *A0,
+         Grid<Real> *pAi,
+         Grid<Real> *pAj,
+         Grid<Real> *pAk);
+  ~GridCg()
+  {
+  }
+
+  void doInit();
+  bool iterate();
+  void solve(int maxIter);
+  //! init pointers, and copy values from "normal" matrix
+  void setICPreconditioner(
+      PreconditionType method, Grid<Real> *A0, Grid<Real> *Ai, Grid<Real> *Aj, Grid<Real> *Ak);
+  void setMGPreconditioner(PreconditionType method, GridMg *MG);
+  void forceReinit()
+  {
+    mInited = false;
+  }
+
+  // Accessors
+  Real getSigma() const
+  {
+    return mSigma;
+  }
+  Real getIterations() const
+  {
+    return mIterations;
+  }
+
+  Real getResNorm() const
+  {
+    return mResNorm;
+  }
+
+  void setAccuracy(Real set)
+  {
+    mAccuracy = set;
+  }
+  Real getAccuracy() const
+  {
+    return mAccuracy;
+  }
+
+ protected:
+  bool mInited;
+  int mIterations;
+  // grids
+  Grid<Real> &mDst;
+  Grid<Real> &mRhs;
+  Grid<Real> &mResidual;
+  Grid<Real> &mSearch;
+  const FlagGrid &mFlags;
+  Grid<Real> &mTmp;
+
+  Grid<Real> *mpA0, *mpAi, *mpAj, *mpAk;
+
+  PreconditionType mPcMethod;
+  //! preconditioning grids
+  Grid<Real> *mpPCA0, *mpPCAi, *mpPCAj, *mpPCAk;
+  GridMg *mMG;
+
+  //! sigma / residual
+  Real mSigma;
+  //! accuracy of solver (max. residuum)
+  Real mAccuracy;
+  //! norm of the residual
+  Real mResNorm;
+};  // GridCg
+
+//! Kernel: Apply symmetric stored Matrix
+
+struct ApplyMatrix : public KernelBase {
+  ApplyMatrix(const FlagGrid &flags,
+              Grid<Real> &dst,
+              const Grid<Real> &src,
+              Grid<Real> &A0,
+              Grid<Real> &Ai,
+              Grid<Real> &Aj,
+              Grid<Real> &Ak)
+      : KernelBase(&flags, 0), flags(flags), dst(dst), src(src), A0(A0), Ai(Ai), Aj(Aj), Ak(Ak)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const FlagGrid &flags,
+                 Grid<Real> &dst,
+                 const Grid<Real> &src,
+                 Grid<Real> &A0,
+                 Grid<Real> &Ai,
+                 Grid<Real> &Aj,
+                 Grid<Real> &Ak) const
+  {
+    if (!flags.isFluid(idx)) {
+      dst[idx] = src[idx];
+      return;
+    }
+
+    dst[idx] = src[idx] * A0[idx] + src[idx - X] * Ai[idx - X] + src[idx + X] * Ai[idx] +
+               src[idx - Y] * Aj[idx - Y] + src[idx + Y] * Aj[idx] + src[idx - Z] * Ak[idx - Z] +
+               src[idx + Z] * Ak[idx];
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return src;
+  }
+  typedef Grid<Real> type2;
+  inline Grid<Real> &getArg3()
+  {
+    return A0;
+  }
+  typedef Grid<Real> type3;
+  inline Grid<Real> &getArg4()
+  {
+    return Ai;
+  }
+  typedef Grid<Real> type4;
+  inline Grid<Real> &getArg5()
+  {
+    return Aj;
+  }
+  typedef Grid<Real> type5;
+  inline Grid<Real> &getArg6()
+  {
+    return Ak;
+  }
+  typedef Grid<Real> type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyMatrix ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, dst, src, A0, Ai, Aj, Ak);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &dst;
+  const Grid<Real> &src;
+  Grid<Real> &A0;
+  Grid<Real> &Ai;
+  Grid<Real> &Aj;
+  Grid<Real> &Ak;
+};
+
+//! Kernel: Apply symmetric stored Matrix. 2D version
+
+struct ApplyMatrix2D : public KernelBase {
+  ApplyMatrix2D(const FlagGrid &flags,
+                Grid<Real> &dst,
+                const Grid<Real> &src,
+                Grid<Real> &A0,
+                Grid<Real> &Ai,
+                Grid<Real> &Aj,
+                Grid<Real> &Ak)
+      : KernelBase(&flags, 0), flags(flags), dst(dst), src(src), A0(A0), Ai(Ai), Aj(Aj), Ak(Ak)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const FlagGrid &flags,
+                 Grid<Real> &dst,
+                 const Grid<Real> &src,
+                 Grid<Real> &A0,
+                 Grid<Real> &Ai,
+                 Grid<Real> &Aj,
+                 Grid<Real> &Ak) const
+  {
+    unusedParameter(Ak);  // only there for parameter compatibility with ApplyMatrix
+
+    if (!flags.isFluid(idx)) {
+      dst[idx] = src[idx];
+      return;
+    }
+
+    dst[idx] = src[idx] * A0[idx] + src[idx - X] * Ai[idx - X] + src[idx + X] * Ai[idx] +
+               src[idx - Y] * Aj[idx - Y] + src[idx + Y] * Aj[idx];
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return src;
+  }
+  typedef Grid<Real> type2;
+  inline Grid<Real> &getArg3()
+  {
+    return A0;
+  }
+  typedef Grid<Real> type3;
+  inline Grid<Real> &getArg4()
+  {
+    return Ai;
+  }
+  typedef Grid<Real> type4;
+  inline Grid<Real> &getArg5()
+  {
+    return Aj;
+  }
+  typedef Grid<Real> type5;
+  inline Grid<Real> &getArg6()
+  {
+    return Ak;
+  }
+  typedef Grid<Real> type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyMatrix2D ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, dst, src, A0, Ai, Aj, Ak);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &dst;
+  const Grid<Real> &src;
+  Grid<Real> &A0;
+  Grid<Real> &Ai;
+  Grid<Real> &Aj;
+  Grid<Real> &Ak;
+};
+
+//! Kernel: Construct the matrix for the poisson equation
+
+struct MakeLaplaceMatrix : public KernelBase {
+  MakeLaplaceMatrix(const FlagGrid &flags,
+                    Grid<Real> &A0,
+                    Grid<Real> &Ai,
+                    Grid<Real> &Aj,
+                    Grid<Real> &Ak,
+                    const MACGrid *fractions = 0)
+      : KernelBase(&flags, 1), flags(flags), A0(A0), Ai(Ai), Aj(Aj), Ak(Ak), fractions(fractions)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &A0,
+                 Grid<Real> &Ai,
+                 Grid<Real> &Aj,
+                 Grid<Real> &Ak,
+                 const MACGrid *fractions = 0) const
+  {
+    if (!flags.isFluid(i, j, k))
+      return;
+
+    if (!fractions) {
+      // diagonal, A0
+      if (!flags.isObstacle(i - 1, j, k))
+        A0(i, j, k) += 1.;
+      if (!flags.isObstacle(i + 1, j, k))
+        A0(i, j, k) += 1.;
+      if (!flags.isObstacle(i, j - 1, k))
+        A0(i, j, k) += 1.;
+      if (!flags.isObstacle(i, j + 1, k))
+        A0(i, j, k) += 1.;
+      if (flags.is3D() && !flags.isObstacle(i, j, k - 1))
+        A0(i, j, k) += 1.;
+      if (flags.is3D() && !flags.isObstacle(i, j, k + 1))
+        A0(i, j, k) += 1.;
+
+      // off-diagonal entries
+      if (flags.isFluid(i + 1, j, k))
+        Ai(i, j, k) = -1.;
+      if (flags.isFluid(i, j + 1, k))
+        Aj(i, j, k) = -1.;
+      if (flags.is3D() && flags.isFluid(i, j, k + 1))
+        Ak(i, j, k) = -1.;
+    }
+    else {
+      // diagonal
+      A0(i, j, k) += fractions->get(i, j, k).x;
+      A0(i, j, k) += fractions->get(i + 1, j, k).x;
+      A0(i, j, k) += fractions->get(i, j, k).y;
+      A0(i, j, k) += fractions->get(i, j + 1, k).y;
+      if (flags.is3D())
+        A0(i, j, k) += fractions->get(i, j, k).z;
+      if (flags.is3D())
+        A0(i, j, k) += fractions->get(i, j, k + 1).z;
+
+      // off-diagonal entries
+      if (flags.isFluid(i + 1, j, k))
+        Ai(i, j, k) = -fractions->get(i + 1, j, k).x;
+      if (flags.isFluid(i, j + 1, k))
+        Aj(i, j, k) = -fractions->get(i, j + 1, k).y;
+      if (flags.is3D() && flags.isFluid(i, j, k + 1))
+        Ak(i, j, k) = -fractions->get(i, j, k + 1).z;
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return A0;
+  }
+  typedef Grid<Real> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return Ai;
+  }
+  typedef Grid<Real> type2;
+  inline Grid<Real> &getArg3()
+  {
+    return Aj;
+  }
+  typedef Grid<Real> type3;
+  inline Grid<Real> &getArg4()
+  {
+    return Ak;
+  }
+  typedef Grid<Real> type4;
+  inline const MACGrid *getArg5()
+  {
+    return fractions;
+  }
+  typedef MACGrid type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel MakeLaplaceMatrix ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, A0, Ai, Aj, Ak, fractions);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, A0, Ai, Aj, Ak, fractions);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &A0;
+  Grid<Real> &Ai;
+  Grid<Real> &Aj;
+  Grid<Real> &Ak;
+  const MACGrid *fractions;
+};
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/conjugategrad.h.reg.cpp b/extern/mantaflow/preprocessed/conjugategrad.h.reg.cpp
new file mode 100644
index 00000000000..d152fe8f113
--- /dev/null
+++ b/extern/mantaflow/preprocessed/conjugategrad.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "conjugategrad.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_3()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/edgecollapse.cpp b/extern/mantaflow/preprocessed/edgecollapse.cpp
new file mode 100644
index 00000000000..72c76ca9200
--- /dev/null
+++ b/extern/mantaflow/preprocessed/edgecollapse.cpp
@@ -0,0 +1,700 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Mesh edge collapse and subdivision
+ *
+ ******************************************************************************/
+
+/******************************************************************************/
+// Copyright note:
+//
+// These functions (C) Chris Wojtan
+// Long-term goal is to unify with his split&merge codebase
+//
+/******************************************************************************/
+
+#include "edgecollapse.h"
+#include <queue>
+
+using namespace std;
+
+namespace Manta {
+
+// 8-point butterfly subdivision scheme (as described by Brochu&Bridson 2009)
+Vec3 ButterflySubdivision(Mesh &m, const Corner &ca, const Corner &cb)
+{
+  Vec3 p = m.nodes(m.corners(ca.prev).node).pos + m.nodes(m.corners(ca.next).node).pos;
+  Vec3 q = m.nodes(ca.node).pos + m.nodes(cb.node).pos;
+  Vec3 r = m.nodes(m.corners(m.corners(ca.next).opposite).node).pos +
+           m.nodes(m.corners(m.corners(ca.prev).opposite).node).pos +
+           m.nodes(m.corners(m.corners(cb.next).opposite).node).pos +
+           m.nodes(m.corners(m.corners(cb.prev).opposite).node).pos;
+  return (8 * p + 2 * q - r) / 16.0;
+}
+
+// Modified Butterfly Subdivision Scheme from:
+// Interpolating Subdivision for Meshes with Arbitrary Topology
+// Denis Zorin, Peter Schroder, and Wim Sweldens
+// input the Corner that satisfies the following:
+//      c.prev.node is the extraordinary vertex,
+//      and c.next.node is the other vertex involved in the subdivision
+Vec3 OneSidedButterflySubdivision(Mesh &m, const int valence, const Corner &c)
+{
+  Vec3 out;
+  Vec3 p0 = m.nodes(m.corners(c.prev).node).pos;
+  Vec3 p1 = m.nodes(m.corners(c.next).node).pos;
+
+  if (valence == 3) {
+    Vec3 p2 = m.nodes(c.node).pos;
+    Vec3 p3 = m.nodes(m.corners(m.corners(c.next).opposite).node).pos;
+    out = (5.0 / 12.0) * p1 - (1.0 / 12.0) * (p2 + p3) + 0.75 * p0;
+  }
+  else if (valence == 4) {
+    Vec3 p2 = m.nodes(m.corners(m.corners(c.next).opposite).node).pos;
+    out = 0.375 * p1 - 0.125 * p2 + 0.75 * p0;
+  }
+  else {
+    // rotate around extraordinary vertex,
+    // calculate subdivision weights,
+    // and interpolate vertex position
+    double rv = 1.0 / (double)valence;
+    out = 0.0;
+    int current = c.prev;
+    for (int j = 0; j < valence; j++) {
+      double s = (0.25 + cos(2 * M_PI * j * rv) + 0.5 * cos(4 * M_PI * j * rv)) * rv;
+      Vec3 p = m.nodes(m.corners(m.corners(current).prev).node).pos;
+
+      out += s * p;
+      current = m.corners(m.corners(m.corners(current).next).opposite).next;
+    }
+    out += 0.75 * m.nodes(m.corners(c.prev).node).pos;
+  }
+  return out;
+}
+
+// Modified Butterfly Subdivision Scheme from:
+// Interpolating Subdivision for Meshes with Arbitrary Topology
+// Denis Zorin, Peter Schroder, and Wim Sweldens
+Vec3 ModifiedButterflySubdivision(Mesh &m,
+                                  const Corner &ca,
+                                  const Corner &cb,
+                                  const Vec3 &fallback)
+{
+  // calculate the valence of the two parent vertices
+  int start = ca.prev;
+  int current = start;
+  int valenceA = 0;
+  do {
+    valenceA++;
+    int op = m.corners(m.corners(current).next).opposite;
+    if (op < 0)
+      return fallback;
+    current = m.corners(op).next;
+  } while (current != start);
+  start = ca.next;
+  current = start;
+  int valenceB = 0;
+  do {
+    valenceB++;
+    int op = m.corners(m.corners(current).next).opposite;
+    if (op < 0)
+      return fallback;
+    current = m.corners(op).next;
+  } while (current != start);
+
+  // if both vertices have valence 6, use butterfly subdivision
+  if (valenceA == 6 && valenceB == 6) {
+    return ButterflySubdivision(m, ca, cb);
+  }
+  else if (valenceA == 6)  // use a one-sided scheme
+  {
+    return OneSidedButterflySubdivision(m, valenceB, cb);
+  }
+  else if (valenceB == 6)  // use a one-sided scheme
+  {
+    return OneSidedButterflySubdivision(m, valenceA, ca);
+  }
+  else  // average the results from two one-sided schemes
+  {
+    return 0.5 * (OneSidedButterflySubdivision(m, valenceA, ca) +
+                  OneSidedButterflySubdivision(m, valenceB, cb));
+  }
+}
+
+bool gAbort = false;
+
+// collapse an edge on triangle "trinum".
+// "which" is 0,1, or 2,
+// where which==0 is the triangle edge from p0 to p1,
+// which==1 is the triangle edge from p1 to p2,
+// and which==2 is the triangle edge from p2 to p0,
+void CollapseEdge(Mesh &m,
+                  const int trinum,
+                  const int which,
+                  const Vec3 &edgevect,
+                  const Vec3 &endpoint,
+                  vector<int> &deletedNodes,
+                  std::map<int, bool> &taintedTris,
+                  int &numCollapses,
+                  bool doTubeCutting)
+{
+  if (gAbort)
+    return;
+  // I wanted to draw a pretty picture of an edge collapse,
+  // but I don't know how to make wacky angled lines in ASCII.
+  // Instead, I will show the before case and tell you what needs to be done.
+
+  //      BEFORE:
+  //              *
+  //             / \.
+  //            /C0 \.
+  //           /     \.
+  //          /       \.
+  //         /    B    \.
+  //        /           \.
+  //       /C1        C2 \.
+  // P0 *---------------* P1
+  //       \C2        C1 /
+  //        \           /
+  //         \    A    /
+  //          \       /
+  //           \     /
+  //            \C0 /
+  //             \ /
+  //              *
+  //
+  //  We are going to collapse the edge between P0 and P1
+  //      by deleting P1,
+  //      and taking all references to P1,
+  //          and rerouting them to P0 instead
+  //
+  //  What we need to do:
+  //      Move position of P0
+  //      Preserve connectivity in both triangles:
+  //          (C1.opposite).opposite = C2.o
+  //          (C2.opposite).opposite = C1.o
+  //      Delete references to Corners of deleted triangles in both P0 and P1's Corner list
+  //      Reassign references to P1:
+  //          loop through P1 triangles:
+  //              rename P1 references to P0 in p lists.
+  //              rename Corner.v references
+  //      Copy P1's list of Corners over to P0's list of Corners
+  //      Delete P1
+
+  Corner ca_old[3], cb_old[3];
+  ca_old[0] = m.corners(trinum, which);
+  ca_old[1] = m.corners(ca_old[0].next);
+  ca_old[2] = m.corners(ca_old[0].prev);
+  bool haveB = false;
+  if (ca_old[0].opposite >= 0) {
+    cb_old[0] = m.corners(ca_old[0].opposite);
+    cb_old[1] = m.corners(cb_old[0].next);
+    cb_old[2] = m.corners(cb_old[0].prev);
+    haveB = true;
+  }
+  if (!haveB) {
+    // for now, don't collapse
+    return;
+  }
+
+  int P0 = ca_old[2].node;
+  int P1 = ca_old[1].node;
+
+  ///////////////
+  // avoid creating nonmanifold edges
+  bool nonmanifold = false;
+  bool nonmanifold2 = false;
+
+  set<int> &ring0 = m.get1Ring(P0).nodes;
+  set<int> &ring1 = m.get1Ring(P1).nodes;
+
+  // check for intersections of the 1-rings of P0,P1
+  int cl = 0, commonVert = -1;
+  for (set<int>::iterator it = ring1.begin(); it != ring1.end(); ++it)
+    if (ring0.find(*it) != ring0.end()) {
+      cl++;
+      if (*it != ca_old[0].node && *it != cb_old[0].node)
+        commonVert = *it;
+    }
+
+  nonmanifold = cl > 2;
+  nonmanifold2 = cl > 3;
+
+  if (nonmanifold && ca_old[1].opposite >= 0 && cb_old[1].opposite >= 0 &&
+      ca_old[2].opposite >= 0 &&
+      cb_old[2].opposite >= 0)  // collapsing this edge would create a non-manifold edge
+  {
+    if (nonmanifold2)
+      return;
+
+    bool topTet = false;
+    bool botTet = false;
+    // check if collapsing this edge will collapse a tet.
+    if (m.corners(ca_old[1].opposite).node == m.corners(ca_old[2].opposite).node)
+      botTet = true;
+
+    if (m.corners(cb_old[1].opposite).node == m.corners(cb_old[2].opposite).node)
+      topTet = true;
+
+    if (topTet ^ botTet) {
+
+      // safe pyramid case.
+      // collapse the whole tet!
+      // First collapse the top of the pyramid,
+      // then carry on collapsing the original verts.
+      Corner cc_old[3], cd_old[3];
+      if (botTet)
+        cc_old[0] = m.corners(ca_old[1].opposite);
+      else  // topTet
+        cc_old[0] = cb_old[2];
+      cc_old[1] = m.corners(cc_old[0].next);
+      cc_old[2] = m.corners(cc_old[0].prev);
+      if (cc_old[0].opposite < 0)
+        return;
+      cd_old[0] = m.corners(cc_old[0].opposite);
+      cd_old[1] = m.corners(cd_old[0].next);
+      cd_old[2] = m.corners(cd_old[0].prev);
+      int P2 = cc_old[2].node;
+      int P3 = cc_old[1].node;
+
+      // update tri props of all adjacent triangles of P0,P1 (do before CT updates!)
+      for (int i = 0; i < m.numTriChannels(); i++) {
+      };  // TODO: handleTriPropertyEdgeCollapse(trinum, P2,P3,  cc_old[0], cd_old[0]);
+
+      m.mergeNode(P2, P3);
+
+      // Preserve connectivity in both triangles
+      if (cc_old[1].opposite >= 0)
+        m.corners(cc_old[1].opposite).opposite = cc_old[2].opposite;
+      if (cc_old[2].opposite >= 0)
+        m.corners(cc_old[2].opposite).opposite = cc_old[1].opposite;
+      if (cd_old[1].opposite >= 0)
+        m.corners(cd_old[1].opposite).opposite = cd_old[2].opposite;
+      if (cd_old[2].opposite >= 0)
+        m.corners(cd_old[2].opposite).opposite = cd_old[1].opposite;
+
+      ////////////////////
+      // mark the two triangles and the one node for deletion
+      int tmpTrinum = cc_old[0].tri;
+      int tmpOthertri = cd_old[0].tri;
+      m.removeTriFromLookup(tmpTrinum);
+      m.removeTriFromLookup(tmpOthertri);
+      taintedTris[tmpTrinum] = true;
+      taintedTris[tmpOthertri] = true;
+      deletedNodes.push_back(P3);
+
+      numCollapses++;
+
+      // recompute Corners for triangles A and B
+      if (botTet)
+        ca_old[0] = m.corners(ca_old[2].opposite);
+      else
+        ca_old[0] = m.corners(ca_old[1].prev);
+      ca_old[1] = m.corners(ca_old[0].next);
+      ca_old[2] = m.corners(ca_old[0].prev);
+      cb_old[0] = m.corners(ca_old[0].opposite);
+      cb_old[1] = m.corners(cb_old[0].next);
+      cb_old[2] = m.corners(cb_old[0].prev);
+
+      ///////////////
+      // avoid creating nonmanifold edges... again
+      ring0 = m.get1Ring(ca_old[2].node).nodes;
+      ring1 = m.get1Ring(ca_old[1].node).nodes;
+
+      // check for intersections of the 1-rings of P0,P1
+      cl = 0;
+      for (set<int>::iterator it = ring1.begin(); it != ring1.end(); ++it)
+        if (*it != ca_old[0].node && ring0.find(*it) != ring0.end())
+          cl++;
+
+      if (cl > 2) {  // nonmanifold
+        // this can happen if collapsing the first tet leads to another similar collapse that
+        // requires the collapse of a tet. for now, just move on and pick this up later.
+
+        // if the original component was very small, this first collapse could have led to a tiny
+        // piece of nonmanifold geometry. in this case, just delete everything that remains.
+        if (m.corners(ca_old[0].opposite).tri == cb_old[0].tri &&
+            m.corners(ca_old[1].opposite).tri == cb_old[0].tri &&
+            m.corners(ca_old[2].opposite).tri == cb_old[0].tri) {
+          taintedTris[ca_old[0].tri] = true;
+          taintedTris[cb_old[0].tri] = true;
+          m.removeTriFromLookup(ca_old[0].tri);
+          m.removeTriFromLookup(cb_old[0].tri);
+          deletedNodes.push_back(ca_old[0].node);
+          deletedNodes.push_back(ca_old[1].node);
+          deletedNodes.push_back(ca_old[2].node);
+        }
+        return;
+      }
+    }
+    else if (topTet && botTet && ca_old[1].opposite >= 0 && ca_old[2].opposite >= 0 &&
+             cb_old[1].opposite >= 0 && cb_old[2].opposite >= 0) {
+      if (!(m.corners(ca_old[1].opposite).node == m.corners(ca_old[2].opposite).node &&
+            m.corners(cb_old[1].opposite).node == m.corners(cb_old[2].opposite).node &&
+            (m.corners(ca_old[1].opposite).node == m.corners(cb_old[1].opposite).node ||
+             (m.corners(ca_old[1].opposite).node == cb_old[0].node &&
+              m.corners(cb_old[1].opposite).node == ca_old[0].node)))) {
+        // just collapse one for now.
+
+        // collapse the whole tet!
+        // First collapse the top of the pyramid,
+        // then carry on collapsing the original verts.
+        Corner cc_old[3], cd_old[3];
+
+        // collapse top
+        {
+          cc_old[0] = m.corners(ca_old[1].opposite);
+          cc_old[1] = m.corners(cc_old[0].next);
+          cc_old[2] = m.corners(cc_old[0].prev);
+          if (cc_old[0].opposite < 0)
+            return;
+          cd_old[0] = m.corners(cc_old[0].opposite);
+          cd_old[1] = m.corners(cd_old[0].next);
+          cd_old[2] = m.corners(cd_old[0].prev);
+          int P2 = cc_old[2].node;
+          int P3 = cc_old[1].node;
+
+          // update tri props of all adjacent triangles of P0,P1 (do before CT updates!)
+          // TODO: handleTriPropertyEdgeCollapse(trinum, P2,P3,  cc_old[0], cd_old[0]);
+
+          m.mergeNode(P2, P3);
+
+          // Preserve connectivity in both triangles
+          if (cc_old[1].opposite >= 0)
+            m.corners(cc_old[1].opposite).opposite = cc_old[2].opposite;
+          if (cc_old[2].opposite >= 0)
+            m.corners(cc_old[2].opposite).opposite = cc_old[1].opposite;
+          if (cd_old[1].opposite >= 0)
+            m.corners(cd_old[1].opposite).opposite = cd_old[2].opposite;
+          if (cd_old[2].opposite >= 0)
+            m.corners(cd_old[2].opposite).opposite = cd_old[1].opposite;
+
+          ////////////////////
+          // mark the two triangles and the one node for deletion
+          int tmpTrinum = cc_old[0].tri;
+          int tmpOthertri = cd_old[0].tri;
+          taintedTris[tmpTrinum] = true;
+          taintedTris[tmpOthertri] = true;
+          m.removeTriFromLookup(tmpTrinum);
+          m.removeTriFromLookup(tmpOthertri);
+          deletedNodes.push_back(P3);
+
+          numCollapses++;
+        }
+        // then collapse bottom
+        {
+          // cc_old[0] = [ca_old[1].opposite;
+          cc_old[0] = cb_old[2];
+          cc_old[1] = m.corners(cc_old[0].next);
+          cc_old[2] = m.corners(cc_old[0].prev);
+          if (cc_old[0].opposite < 0)
+            return;
+          cd_old[0] = m.corners(cc_old[0].opposite);
+          cd_old[1] = m.corners(cd_old[0].next);
+          cd_old[2] = m.corners(cd_old[0].prev);
+          int P2 = cc_old[2].node;
+          int P3 = cc_old[1].node;
+
+          // update tri props of all adjacent triangles of P0,P1 (do before CT updates!)
+          // TODO: handleTriPropertyEdgeCollapse(trinum, P2,P3,  cc_old[0], cd_old[0]);
+
+          m.mergeNode(P2, P3);
+
+          // Preserve connectivity in both triangles
+          if (cc_old[1].opposite >= 0)
+            m.corners(cc_old[1].opposite).opposite = cc_old[2].opposite;
+          if (cc_old[2].opposite >= 0)
+            m.corners(cc_old[2].opposite).opposite = cc_old[1].opposite;
+          if (cd_old[1].opposite >= 0)
+            m.corners(cd_old[1].opposite).opposite = cd_old[2].opposite;
+          if (cd_old[2].opposite >= 0)
+            m.corners(cd_old[2].opposite).opposite = cd_old[1].opposite;
+
+          ////////////////////
+          // mark the two triangles and the one node for deletion
+          int tmpTrinum = cc_old[0].tri;
+          int tmpOthertri = cd_old[0].tri;
+          taintedTris[tmpTrinum] = true;
+          taintedTris[tmpOthertri] = true;
+          deletedNodes.push_back(P3);
+
+          numCollapses++;
+        }
+
+        // Though we've collapsed a lot of stuff, we still haven't collapsed the original edge.
+        // At this point we still haven't guaranteed that this original collapse weill be safe.
+        // quit for now, and we'll catch the remaining short edges the next time this function is
+        // called.
+        return;
+      }
+    }
+    else if (doTubeCutting) {
+      // tube case
+      // cout<<"CollapseEdge:tube case" << endl;
+
+      // find the edges that touch the common vert
+      int P2 = commonVert;
+      int P1P2 = -1, P2P1, P2P0 = -1, P0P2 = -1;  // corners across from the cutting seam
+      int start = ca_old[0].next;
+      int end = cb_old[0].prev;
+      int current = start;
+      do {
+        // rotate around vertex P1 counter-clockwise
+        int op = m.corners(m.corners(current).next).opposite;
+        if (op < 0)
+          errMsg("tube cutting failed, no opposite");
+        current = m.corners(op).next;
+
+        if (m.corners(m.corners(current).prev).node == commonVert)
+          P1P2 = m.corners(current).next;
+      } while (current != end);
+
+      start = ca_old[0].prev;
+      end = cb_old[0].next;
+      current = start;
+      do {
+        // rotate around vertex P0 clockwise
+        int op = m.corners(m.corners(current).prev).opposite;
+        if (op < 0)
+          errMsg("tube cutting failed, no opposite");
+
+        current = m.corners(op).prev;
+        if (m.corners(m.corners(current).next).node == commonVert)
+          P2P0 = m.corners(current).prev;
+      } while (current != end);
+
+      if (P1P2 < 0 || P2P0 < 0)
+        errMsg("tube cutting failed, ill geometry");
+
+      P2P1 = m.corners(P1P2).opposite;
+      P0P2 = m.corners(P2P0).opposite;
+
+      // duplicate vertices on the top half of the cut,
+      // and use them to split the tube at this seam
+      int P0b = m.addNode(Node(m.nodes(P0).pos));
+      int P1b = m.addNode(Node(m.nodes(P1).pos));
+      int P2b = m.addNode(Node(m.nodes(P2).pos));
+      for (int i = 0; i < m.numNodeChannels(); i++) {
+        m.nodeChannel(i)->addInterpol(P0, P0, 0.5);
+        m.nodeChannel(i)->addInterpol(P1, P1, 0.5);
+        m.nodeChannel(i)->addInterpol(P2, P2, 0.5);
+      }
+
+      // offset the verts in the normal directions to avoid self intersections
+      Vec3 offsetVec = cross(m.nodes(P1).pos - m.nodes(P0).pos, m.nodes(P2).pos - m.nodes(P0).pos);
+      normalize(offsetVec);
+      offsetVec *= 0.01;  // HACK:
+      m.nodes(P0).pos -= offsetVec;
+      m.nodes(P1).pos -= offsetVec;
+      m.nodes(P2).pos -= offsetVec;
+      m.nodes(P0b).pos += offsetVec;
+      m.nodes(P1b).pos += offsetVec;
+      m.nodes(P2b).pos += offsetVec;
+
+      // create a list of all triangles which touch P0, P1, and P2 from the top,
+      map<int, bool> topTris;
+      start = cb_old[0].next;
+      end = m.corners(P0P2).prev;
+      current = start;
+      topTris[start / 3] = true;
+      do {
+        // rotate around vertex P0 counter-clockwise
+        current = m.corners(m.corners(m.corners(current).next).opposite).next;
+        topTris[current / 3] = true;
+      } while (current != end);
+      start = m.corners(P0P2).next;
+      end = m.corners(P2P1).prev;
+      current = start;
+      topTris[start / 3] = true;
+      do {
+        // rotate around vertex P0 counter-clockwise
+        current = m.corners(m.corners(m.corners(current).next).opposite).next;
+        topTris[current / 3] = true;
+      } while (current != end);
+      start = m.corners(P2P1).next;
+      end = cb_old[0].prev;
+      current = start;
+      topTris[start / 3] = true;
+      do {
+        // rotate around vertex P0 counter-clockwise
+        current = m.corners(m.corners(m.corners(current).next).opposite).next;
+        topTris[current / 3] = true;
+      } while (current != end);
+
+      // create two new triangles,
+      int Ta = m.addTri(Triangle(P0, P1, P2));
+      int Tb = m.addTri(Triangle(P1b, P0b, P2b));
+      for (int i = 0; i < m.numTriChannels(); i++) {
+        m.triChannel(i)->addNew();
+        m.triChannel(i)->addNew();
+      }
+
+      // sew the tris to close the cut on each side
+      for (int c = 0; c < 3; c++)
+        m.addCorner(Corner(Ta, m.tris(Ta).c[c]));
+      for (int c = 0; c < 3; c++)
+        m.addCorner(Corner(Tb, m.tris(Tb).c[c]));
+      for (int c = 0; c < 3; c++) {
+        m.corners(Ta, c).next = 3 * Ta + ((c + 1) % 3);
+        m.corners(Ta, c).prev = 3 * Ta + ((c + 2) % 3);
+        m.corners(Tb, c).next = 3 * Tb + ((c + 1) % 3);
+        m.corners(Tb, c).prev = 3 * Tb + ((c + 2) % 3);
+      }
+      m.corners(Ta, 0).opposite = P1P2;
+      m.corners(Ta, 1).opposite = P2P0;
+      m.corners(Ta, 2).opposite = ca_old[1].prev;
+      m.corners(Tb, 0).opposite = P0P2;
+      m.corners(Tb, 1).opposite = P2P1;
+      m.corners(Tb, 2).opposite = cb_old[1].prev;
+      for (int c = 0; c < 3; c++) {
+        m.corners(m.corners(Ta, c).opposite).opposite = 3 * Ta + c;
+        m.corners(m.corners(Tb, c).opposite).opposite = 3 * Tb + c;
+      }
+      // replace P0,P1,P2 on the top with P0b,P1b,P2b.
+      for (map<int, bool>::iterator tti = topTris.begin(); tti != topTris.end(); tti++) {
+        // cout << "H " << tti->first << " : " << m.tris(tti->first).c[0] << " " <<
+        // m.tris(tti->first).c[1] << " " << m.tris(tti->first).c[2] << " " << endl;
+        for (int i = 0; i < 3; i++) {
+          int cn = m.tris(tti->first).c[i];
+          set<int> &ring = m.get1Ring(cn).nodes;
+
+          if (ring.find(P0) != ring.end() && cn != P0 && cn != P1 && cn != P2 && cn != P0b &&
+              cn != P1b && cn != P2b) {
+            ring.erase(P0);
+            ring.insert(P0b);
+            m.get1Ring(P0).nodes.erase(cn);
+            m.get1Ring(P0b).nodes.insert(cn);
+          }
+          if (ring.find(P1) != ring.end() && cn != P0 && cn != P1 && cn != P2 && cn != P0b &&
+              cn != P1b && cn != P2b) {
+            ring.erase(P1);
+            ring.insert(P1b);
+            m.get1Ring(P1).nodes.erase(cn);
+            m.get1Ring(P1b).nodes.insert(cn);
+          }
+          if (ring.find(P2) != ring.end() && cn != P0 && cn != P1 && cn != P2 && cn != P0b &&
+              cn != P1b && cn != P2b) {
+            ring.erase(P2);
+            ring.insert(P2b);
+            m.get1Ring(P2).nodes.erase(cn);
+            m.get1Ring(P2b).nodes.insert(cn);
+          }
+          if (cn == P0) {
+            m.tris(tti->first).c[i] = P0b;
+            m.corners(tti->first, i).node = P0b;
+            m.get1Ring(P0).tris.erase(tti->first);
+            m.get1Ring(P0b).tris.insert(tti->first);
+          }
+          else if (cn == P1) {
+            m.tris(tti->first).c[i] = P1b;
+            m.corners(tti->first, i).node = P1b;
+            m.get1Ring(P1).tris.erase(tti->first);
+            m.get1Ring(P1b).tris.insert(tti->first);
+          }
+          else if (cn == P2) {
+            m.tris(tti->first).c[i] = P2b;
+            m.corners(tti->first, i).node = P2b;
+            m.get1Ring(P2).tris.erase(tti->first);
+            m.get1Ring(P2b).tris.insert(tti->first);
+          }
+        }
+      }
+
+      // m.sanityCheck(true, &deletedNodes, &taintedTris);
+
+      return;
+    }
+    return;
+  }
+  if (ca_old[1].opposite >= 0 && ca_old[2].opposite >= 0 && cb_old[1].opposite >= 0 &&
+      cb_old[2].opposite >= 0 && ca_old[0].opposite >= 0 && cb_old[0].opposite >= 0 &&
+      ((m.corners(ca_old[1].opposite).node ==
+            m.corners(ca_old[2].opposite).node &&  // two-pyramid tubey case (6 tris, 5 verts)
+        m.corners(cb_old[1].opposite).node == m.corners(cb_old[2].opposite).node &&
+        (m.corners(ca_old[1].opposite).node == m.corners(cb_old[1].opposite).node ||
+         (m.corners(ca_old[1].opposite).node == cb_old[0].node &&  // single tetrahedron case
+          m.corners(cb_old[1].opposite).node == ca_old[0].node))) ||
+       (m.corners(ca_old[0].opposite).tri == m.corners(cb_old[0].opposite).tri &&
+        m.corners(ca_old[1].opposite).tri == m.corners(cb_old[0].opposite).tri &&
+        m.corners(ca_old[2].opposite).tri ==
+            m.corners(cb_old[0].opposite).tri  // nonmanifold: 2 tris, 3 verts
+        && m.corners(cb_old[0].opposite).tri == m.corners(ca_old[0].opposite).tri &&
+        m.corners(cb_old[1].opposite).tri == m.corners(ca_old[0].opposite).tri &&
+        m.corners(cb_old[2].opposite).tri == m.corners(ca_old[0].opposite).tri))) {
+    // both top and bottom are closed pyramid caps, or it is a single tet
+    // delete the whole component!
+    // flood fill to mark all triangles in the component
+    map<int, bool> markedTris;
+    queue<int> triQ;
+    triQ.push(trinum);
+    markedTris[trinum] = true;
+    int iters = 0;
+    while (!triQ.empty()) {
+      int trival = triQ.front();
+      triQ.pop();
+      for (int i = 0; i < 3; i++) {
+        int newtri = m.corners(m.corners(trival, i).opposite).tri;
+        if (markedTris.find(newtri) == markedTris.end()) {
+          triQ.push(newtri);
+          markedTris[newtri] = true;
+        }
+      }
+      iters++;
+    }
+    map<int, bool> markedverts;
+    for (map<int, bool>::iterator mit = markedTris.begin(); mit != markedTris.end(); mit++) {
+      taintedTris[mit->first] = true;
+      markedverts[m.tris(mit->first).c[0]] = true;
+      markedverts[m.tris(mit->first).c[1]] = true;
+      markedverts[m.tris(mit->first).c[2]] = true;
+    }
+    for (map<int, bool>::iterator mit = markedverts.begin(); mit != markedverts.end(); mit++)
+      deletedNodes.push_back(mit->first);
+    return;
+  }
+
+  //////////////////////////
+  // begin original edge collapse
+
+  // update tri props of all adjacent triangles of P0,P1 (do before CT updates!)
+  // TODO: handleTriPropertyEdgeCollapse(trinum, P0,P1,  ca_old[0], cb_old[0]);
+
+  m.mergeNode(P0, P1);
+
+  // Move position of P0
+  m.nodes(P0).pos = endpoint + 0.5 * edgevect;
+
+  // Preserve connectivity in both triangles
+  if (ca_old[1].opposite >= 0)
+    m.corners(ca_old[1].opposite).opposite = ca_old[2].opposite;
+  if (ca_old[2].opposite >= 0)
+    m.corners(ca_old[2].opposite).opposite = ca_old[1].opposite;
+  if (haveB && cb_old[1].opposite >= 0)
+    m.corners(cb_old[1].opposite).opposite = cb_old[2].opposite;
+  if (haveB && cb_old[2].opposite >= 0)
+    m.corners(cb_old[2].opposite).opposite = cb_old[1].opposite;
+
+  ////////////////////
+  // mark the two triangles and the one node for deletion
+  taintedTris[ca_old[0].tri] = true;
+  m.removeTriFromLookup(ca_old[0].tri);
+  if (haveB) {
+    taintedTris[cb_old[0].tri] = true;
+    m.removeTriFromLookup(cb_old[0].tri);
+  }
+  deletedNodes.push_back(P1);
+  numCollapses++;
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/edgecollapse.h b/extern/mantaflow/preprocessed/edgecollapse.h
new file mode 100644
index 00000000000..c482255c6ce
--- /dev/null
+++ b/extern/mantaflow/preprocessed/edgecollapse.h
@@ -0,0 +1,51 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Mesh edge collapse and subdivision
+ *
+ ******************************************************************************/
+
+/******************************************************************************/
+// Copyright note:
+//
+// These functions (C) Chris Wojtan
+// Long-term goal is to unify with his split&merge codebase
+//
+/******************************************************************************/
+
+#ifndef _EDGECOLLAPSE_H
+#define _EDGECOLLAPSE_H
+
+#include "mesh.h"
+
+namespace Manta {
+
+void CollapseEdge(Mesh &mesh,
+                  const int trinum,
+                  const int which,
+                  const Vec3 &edgevect,
+                  const Vec3 &endpoint,
+                  std::vector<int> &deletedNodes,
+                  std::map<int, bool> &taintedTris,
+                  int &numCollapses,
+                  bool doTubeCutting);
+
+Vec3 ModifiedButterflySubdivision(Mesh &mesh,
+                                  const Corner &ca,
+                                  const Corner &cb,
+                                  const Vec3 &fallback);
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/edgecollapse.h.reg.cpp b/extern/mantaflow/preprocessed/edgecollapse.h.reg.cpp
new file mode 100644
index 00000000000..002756b3a9c
--- /dev/null
+++ b/extern/mantaflow/preprocessed/edgecollapse.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "edgecollapse.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_19()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/fastmarch.cpp b/extern/mantaflow/preprocessed/fastmarch.cpp
new file mode 100644
index 00000000000..7792ddafe6a
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fastmarch.cpp
@@ -0,0 +1,1200 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Fast marching and extrapolation
+ *
+ ******************************************************************************/
+
+#include "fastmarch.h"
+#include "levelset.h"
+#include "kernel.h"
+#include <algorithm>
+
+using namespace std;
+
+namespace Manta {
+
+template<class COMP, int TDIR>
+FastMarch<COMP, TDIR>::FastMarch(const FlagGrid &flags,
+                                 Grid<int> &fmFlags,
+                                 Grid<Real> &levelset,
+                                 Real maxTime,
+                                 MACGrid *velTransport)
+    : mLevelset(levelset), mFlags(flags), mFmFlags(fmFlags)
+{
+  if (velTransport)
+    mVelTransport.initMarching(velTransport, &flags);
+
+  mMaxTime = maxTime * TDIR;
+}
+
+// helper for individual components to calculateDistance
+template<class COMP, int TDIR>
+template<int C>
+Real FastMarch<COMP, TDIR>::calcWeights(int &okcnt, int &invcnt, Real *v, const Vec3i &idx)
+{
+  Real val = 0.;
+  Vec3i idxPlus(idx), idxMinus(idx);
+  idxPlus[C]++;
+  idxMinus[C]--;
+
+  mWeights[C * 2] = mWeights[C * 2 + 1] = 0.;
+  if (mFmFlags(idxPlus) == FlagInited) {
+    // somewhat arbitrary - choose +1 value over -1 ...
+    val = mLevelset(idxPlus);
+    v[okcnt] = val;
+    okcnt++;
+    mWeights[C * 2] = 1.;
+  }
+  else if (mFmFlags(idxMinus) == FlagInited) {
+    val = mLevelset(idxMinus);
+    v[okcnt] = val;
+    okcnt++;
+    mWeights[C * 2 + 1] = 1.;
+  }
+  else {
+    invcnt++;
+  }
+  return val;
+}
+
+template<class COMP, int TDIR>
+inline Real FastMarch<COMP, TDIR>::calculateDistance(const Vec3i &idx)
+{
+  // int invflag = 0;
+  int invcnt = 0;
+  Real v[3];
+  int okcnt = 0;
+
+  Real aVal = calcWeights<0>(okcnt, invcnt, v, idx);
+  Real bVal = calcWeights<1>(okcnt, invcnt, v, idx);
+  Real cVal = 0.;
+  if (mLevelset.is3D())
+    cVal = calcWeights<2>(okcnt, invcnt, v, idx);
+  else {
+    invcnt++;
+    mWeights[4] = mWeights[5] = 0.;
+  }
+
+  Real ret = InvalidTime();
+  switch (invcnt) {
+    case 0: {
+      // take all values
+      const Real ca = v[0], cb = v[1], cc = v[2];
+      const Real csqrt = max(0.,
+                             -2. * (ca * ca + cb * cb - cb * cc + cc * cc - ca * (cb + cc)) + 3);
+      // clamp to make sure the sqrt is valid
+      ret = 0.333333 * (ca + cb + cc + TDIR * sqrt(csqrt));
+
+      // weights needed for transport (transpTouch)
+      mWeights[0] *= fabs(ret - ca);
+      mWeights[1] *= fabs(ret - ca);
+      mWeights[2] *= fabs(ret - cb);
+      mWeights[3] *= fabs(ret - cb);
+      mWeights[4] *= fabs(ret - cc);
+      mWeights[5] *= fabs(ret - cc);
+
+      Real norm = 0.0;  // try to force normalization
+      for (int i = 0; i < 6; i++) {
+        norm += mWeights[i];
+      }
+      norm = 1.0 / norm;
+      for (int i = 0; i < 6; i++) {
+        mWeights[i] *= norm;
+      }
+
+    } break;
+    case 1: {
+      // take just the 2 ok values
+      // t=0.5*( a+b+ (2*g*g-(b-a)*(b-a))^0.5)
+      const Real csqrt = max(0., 2. - (v[1] - v[0]) * (v[1] - v[0]));
+      // clamp to make sure the sqrt is valid
+      ret = 0.5 * (v[0] + v[1] + TDIR * sqrt(csqrt));
+
+      // weights needed for transport (transpTouch)
+      mWeights[0] *= fabs(ret - aVal);
+      mWeights[1] *= fabs(ret - aVal);
+      mWeights[2] *= fabs(ret - bVal);
+      mWeights[3] *= fabs(ret - bVal);
+      mWeights[4] *= fabs(ret - cVal);
+      mWeights[5] *= fabs(ret - cVal);
+
+      Real norm = 0.0;  // try to force normalization
+      for (int i = 0; i < 6; i++) {
+        norm += mWeights[i];
+      }
+      norm = 1.0 / norm;
+      for (int i = 0; i < 6; i++) {
+        mWeights[i] *= norm;
+      }
+      // */
+
+    } break;
+    case 2: {
+      // just use the one remaining value
+      ret = v[0] + (Real)(TDIR);  // direction = +- 1
+    } break;
+    default:
+      errMsg("FastMarch :: Invalid invcnt");
+      break;
+  }
+  return ret;
+}
+
+template<class COMP, int TDIR>
+void FastMarch<COMP, TDIR>::addToList(const Vec3i &p, const Vec3i &src)
+{
+  if (!mLevelset.isInBounds(p, 1))
+    return;
+  const IndexInt idx = mLevelset.index(p);
+
+  // already known value, value alreay set to valid value? skip cell...
+  if (mFmFlags[idx] == FlagInited)
+    return;
+
+  // discard by source time now , TODO do instead before calling all addtolists?
+  Real srct = mLevelset(src);
+  if (COMP::compare(srct, mMaxTime))
+    return;
+
+  Real ttime = calculateDistance(p);
+
+  // remove old entry if larger
+  bool found = false;
+
+  Real oldt = mLevelset[idx];
+  if (mFmFlags[idx] == FlagIsOnHeap) {
+    found = true;
+    // is old time better?
+    if (COMP::compare(ttime, oldt))
+      return;
+  }
+
+  // update field
+  mFmFlags[idx] = FlagIsOnHeap;
+  mLevelset[idx] = ttime;
+  // debug info std::cout<<"set "<< idx <<","<< ttime <<"\n";
+
+  if (mVelTransport.isInitialized())
+    mVelTransport.transpTouch(p.x, p.y, p.z, mWeights, ttime);
+
+  // the following adds entries to the heap of active cells
+  // current: (!found) , previous: always add, might lead to duplicate
+  //     entries, but the earlier will be handled earlier, the second one will skip to the
+  //     FlagInited check above
+  if (!found) {
+    // add list entry with source value
+    COMP entry;
+    entry.p = p;
+    entry.time = mLevelset[idx];
+
+    mHeap.push(entry);
+    // debug info std::cout<<"push "<< entry.p <<","<< entry.time <<"\n";
+  }
+}
+
+//! Enforce delta_phi = 0 on boundaries
+
+struct SetLevelsetBoundaries : public KernelBase {
+  SetLevelsetBoundaries(Grid<Real> &phi) : KernelBase(&phi, 0), phi(phi)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &phi)
+  {
+    if (i == 0)
+      phi(i, j, k) = phi(1, j, k);
+    if (i == maxX - 1)
+      phi(i, j, k) = phi(i - 1, j, k);
+
+    if (j == 0)
+      phi(i, j, k) = phi(i, 1, k);
+    if (j == maxY - 1)
+      phi(i, j, k) = phi(i, j - 1, k);
+
+    if (phi.is3D()) {
+      if (k == 0)
+        phi(i, j, k) = phi(i, j, 1);
+      if (k == maxZ - 1)
+        phi(i, j, k) = phi(i, j, k - 1);
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel SetLevelsetBoundaries ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void run()
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    for (int k = minZ; k < maxZ; k++)
+      for (int j = 0; j < _maxY; j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, phi);
+  }
+  Grid<Real> &phi;
+};
+
+/*****************************************************************************/
+//! Walk...
+template<class COMP, int TDIR> void FastMarch<COMP, TDIR>::performMarching()
+{
+  mReheapVal = 0.0;
+  while (mHeap.size() > 0) {
+
+    const COMP &ce = mHeap.top();
+    Vec3i p = ce.p;
+    mFmFlags(p) = FlagInited;
+    mHeap.pop();
+    // debug info std::cout<<"pop "<< ce.p <<","<< ce.time <<"\n";
+
+    addToList(Vec3i(p.x - 1, p.y, p.z), p);
+    addToList(Vec3i(p.x + 1, p.y, p.z), p);
+    addToList(Vec3i(p.x, p.y - 1, p.z), p);
+    addToList(Vec3i(p.x, p.y + 1, p.z), p);
+    if (mLevelset.is3D()) {
+      addToList(Vec3i(p.x, p.y, p.z - 1), p);
+      addToList(Vec3i(p.x, p.y, p.z + 1), p);
+    }
+  }
+
+  // set boundary for plain array
+  SetLevelsetBoundaries setls(mLevelset);
+  setls.getArg0();  // get rid of compiler warning...
+}
+
+// explicit instantiation
+template class FastMarch<FmHeapEntryIn, -1>;
+template class FastMarch<FmHeapEntryOut, +1>;
+
+/*****************************************************************************/
+// simpler extrapolation functions (primarily for FLIP)
+
+struct knExtrapolateMACSimple : public KernelBase {
+  knExtrapolateMACSimple(MACGrid &vel, int distance, Grid<int> &tmp, const int d, const int c)
+      : KernelBase(&vel, 1), vel(vel), distance(distance), tmp(tmp), d(d), c(c)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &vel,
+                 int distance,
+                 Grid<int> &tmp,
+                 const int d,
+                 const int c) const
+  {
+    static const Vec3i nb[6] = {Vec3i(1, 0, 0),
+                                Vec3i(-1, 0, 0),
+                                Vec3i(0, 1, 0),
+                                Vec3i(0, -1, 0),
+                                Vec3i(0, 0, 1),
+                                Vec3i(0, 0, -1)};
+    const int dim = (vel.is3D() ? 3 : 2);
+
+    if (tmp(i, j, k) != 0)
+      return;
+
+    // copy from initialized neighbors
+    Vec3i p(i, j, k);
+    int nbs = 0;
+    Real avgVel = 0.;
+    for (int n = 0; n < 2 * dim; ++n) {
+      if (tmp(p + nb[n]) == d) {
+        // vel(p)[c] = (c+1.)*0.1;
+        avgVel += vel(p + nb[n])[c];
+        nbs++;
+      }
+    }
+
+    if (nbs > 0) {
+      tmp(p) = d + 1;
+      vel(p)[c] = avgVel / nbs;
+    }
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline int &getArg1()
+  {
+    return distance;
+  }
+  typedef int type1;
+  inline Grid<int> &getArg2()
+  {
+    return tmp;
+  }
+  typedef Grid<int> type2;
+  inline const int &getArg3()
+  {
+    return d;
+  }
+  typedef int type3;
+  inline const int &getArg4()
+  {
+    return c;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knExtrapolateMACSimple ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, distance, tmp, d, c);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, distance, tmp, d, c);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MACGrid &vel;
+  int distance;
+  Grid<int> &tmp;
+  const int d;
+  const int c;
+};
+//! copy velocity into domain side, note - don't read & write same grid, hence velTmp copy
+
+struct knExtrapolateIntoBnd : public KernelBase {
+  knExtrapolateIntoBnd(FlagGrid &flags, MACGrid &vel, const MACGrid &velTmp)
+      : KernelBase(&flags, 0), flags(flags), vel(vel), velTmp(velTmp)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, FlagGrid &flags, MACGrid &vel, const MACGrid &velTmp) const
+  {
+    int c = 0;
+    Vec3 v(0, 0, 0);
+    const bool isObs = flags.isObstacle(i, j, k);
+    if (i == 0) {
+      v = velTmp(i + 1, j, k);
+      if (isObs && v[0] < 0.)
+        v[0] = 0.;
+      c++;
+    }
+    else if (i == (flags.getSizeX() - 1)) {
+      v = velTmp(i - 1, j, k);
+      if (isObs && v[0] > 0.)
+        v[0] = 0.;
+      c++;
+    }
+    if (j == 0) {
+      v = velTmp(i, j + 1, k);
+      if (isObs && v[1] < 0.)
+        v[1] = 0.;
+      c++;
+    }
+    else if (j == (flags.getSizeY() - 1)) {
+      v = velTmp(i, j - 1, k);
+      if (isObs && v[1] > 0.)
+        v[1] = 0.;
+      c++;
+    }
+    if (flags.is3D()) {
+      if (k == 0) {
+        v = velTmp(i, j, k + 1);
+        if (isObs && v[2] < 0.)
+          v[2] = 0.;
+        c++;
+      }
+      else if (k == (flags.getSizeZ() - 1)) {
+        v = velTmp(i, j, k - 1);
+        if (isObs && v[2] > 0.)
+          v[2] = 0.;
+        c++;
+      }
+    }
+    if (c > 0) {
+      vel(i, j, k) = v / (Real)c;
+    }
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return velTmp;
+  }
+  typedef MACGrid type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knExtrapolateIntoBnd ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, vel, velTmp);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, vel, velTmp);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  FlagGrid &flags;
+  MACGrid &vel;
+  const MACGrid &velTmp;
+};
+
+// todo - use getGradient instead?
+inline Vec3 getNormal(const Grid<Real> &data, int i, int j, int k)
+{
+  if (i > data.getSizeX() - 2)
+    i = data.getSizeX() - 2;
+  if (i < 1)
+    i = 1;
+  if (j > data.getSizeY() - 2)
+    j = data.getSizeY() - 2;
+  if (j < 1)
+    j = 1;
+
+  int kd = 1;
+  if (data.is3D()) {
+    if (k > data.getSizeZ() - 2)
+      k = data.getSizeZ() - 2;
+    if (k < 1)
+      k = 1;
+  }
+  else {
+    kd = 0;
+  }
+
+  return Vec3(data(i + 1, j, k) - data(i - 1, j, k),
+              data(i, j + 1, k) - data(i, j - 1, k),
+              data(i, j, k + kd) - data(i, j, k - kd));
+}
+
+struct knUnprojectNormalComp : public KernelBase {
+  knUnprojectNormalComp(FlagGrid &flags, MACGrid &vel, Grid<Real> &phi, Real maxDist)
+      : KernelBase(&flags, 1), flags(flags), vel(vel), phi(phi), maxDist(maxDist)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, FlagGrid &flags, MACGrid &vel, Grid<Real> &phi, Real maxDist) const
+  {
+    // apply inside, within range near obstacle surface
+    if (phi(i, j, k) > 0. || phi(i, j, k) < -maxDist)
+      return;
+
+    Vec3 n = getNormal(phi, i, j, k);
+    Vec3 v = vel(i, j, k);
+    if (dot(n, v) < 0.) {
+      normalize(n);
+      Real l = dot(n, v);
+      vel(i, j, k) -= n * l;
+    }
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline Grid<Real> &getArg2()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type2;
+  inline Real &getArg3()
+  {
+    return maxDist;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knUnprojectNormalComp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, phi, maxDist);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, phi, maxDist);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  FlagGrid &flags;
+  MACGrid &vel;
+  Grid<Real> &phi;
+  Real maxDist;
+};
+// a simple extrapolation step , used for cases where there's no levelset
+// (note, less accurate than fast marching extrapolation.)
+// into obstacle is a special mode for second order obstable boundaries (extrapolating
+// only fluid velocities, not those at obstacles)
+
+void extrapolateMACSimple(FlagGrid &flags,
+                          MACGrid &vel,
+                          int distance = 4,
+                          LevelsetGrid *phiObs = NULL,
+                          bool intoObs = false)
+{
+  Grid<int> tmp(flags.getParent());
+  int dim = (flags.is3D() ? 3 : 2);
+
+  for (int c = 0; c < dim; ++c) {
+    Vec3i dir = 0;
+    dir[c] = 1;
+    tmp.clear();
+
+    // remove all fluid cells (not touching obstacles)
+    FOR_IJK_BND(flags, 1)
+    {
+      Vec3i p(i, j, k);
+      bool mark = false;
+      if (!intoObs) {
+        if (flags.isFluid(p) || flags.isFluid(p - dir))
+          mark = true;
+      }
+      else {
+        if ((flags.isFluid(p) || flags.isFluid(p - dir)) && (!flags.isObstacle(p)) &&
+            (!flags.isObstacle(p - dir)))
+          mark = true;
+      }
+
+      if (mark)
+        tmp(p) = 1;
+    }
+
+    // extrapolate for distance
+    for (int d = 1; d < 1 + distance; ++d) {
+      knExtrapolateMACSimple(vel, distance, tmp, d, c);
+    }  // d
+  }
+
+  if (phiObs) {
+    knUnprojectNormalComp(flags, vel, *phiObs, distance);
+  }
+
+  // copy tangential values into sides of domain
+  MACGrid velTmp(flags.getParent());
+  velTmp.copyFrom(vel);
+  knExtrapolateIntoBnd(flags, vel, velTmp);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "extrapolateMACSimple", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      int distance = _args.getOpt<int>("distance", 2, 4, &_lock);
+      LevelsetGrid *phiObs = _args.getPtrOpt<LevelsetGrid>("phiObs", 3, NULL, &_lock);
+      bool intoObs = _args.getOpt<bool>("intoObs", 4, false, &_lock);
+      _retval = getPyNone();
+      extrapolateMACSimple(flags, vel, distance, phiObs, intoObs);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "extrapolateMACSimple", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("extrapolateMACSimple", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_extrapolateMACSimple("", "extrapolateMACSimple", _W_0);
+extern "C" {
+void PbRegister_extrapolateMACSimple()
+{
+  KEEP_UNUSED(_RP_extrapolateMACSimple);
+}
+}
+
+struct knExtrapolateMACFromWeight : public KernelBase {
+  knExtrapolateMACFromWeight(
+      MACGrid &vel, Grid<Vec3> &weight, int distance, const int d, const int c)
+      : KernelBase(&vel, 1), vel(vel), weight(weight), distance(distance), d(d), c(c)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &vel,
+                 Grid<Vec3> &weight,
+                 int distance,
+                 const int d,
+                 const int c) const
+  {
+    static const Vec3i nb[6] = {Vec3i(1, 0, 0),
+                                Vec3i(-1, 0, 0),
+                                Vec3i(0, 1, 0),
+                                Vec3i(0, -1, 0),
+                                Vec3i(0, 0, 1),
+                                Vec3i(0, 0, -1)};
+    const int dim = (vel.is3D() ? 3 : 2);
+
+    if (weight(i, j, k)[c] != 0)
+      return;
+
+    // copy from initialized neighbors
+    Vec3i p(i, j, k);
+    int nbs = 0;
+    Real avgVel = 0.;
+    for (int n = 0; n < 2 * dim; ++n) {
+      if (weight(p + nb[n])[c] == d) {
+        avgVel += vel(p + nb[n])[c];
+        nbs++;
+      }
+    }
+
+    if (nbs > 0) {
+      weight(p)[c] = d + 1;
+      vel(p)[c] = avgVel / nbs;
+    }
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline Grid<Vec3> &getArg1()
+  {
+    return weight;
+  }
+  typedef Grid<Vec3> type1;
+  inline int &getArg2()
+  {
+    return distance;
+  }
+  typedef int type2;
+  inline const int &getArg3()
+  {
+    return d;
+  }
+  typedef int type3;
+  inline const int &getArg4()
+  {
+    return c;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knExtrapolateMACFromWeight ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, weight, distance, d, c);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, weight, distance, d, c);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MACGrid &vel;
+  Grid<Vec3> &weight;
+  int distance;
+  const int d;
+  const int c;
+};
+
+// same as extrapolateMACSimple, but uses weight vec3 grid instead of flags to check
+// for valid values (to be used in combination with mapPartsToMAC)
+// note - the weight grid values are destroyed! the function is necessary due to discrepancies
+// between velocity mapping on surface-levelset / fluid-flag creation. With this
+// extrapolation we make sure the fluid region is covered by initial velocities
+
+void extrapolateMACFromWeight(MACGrid &vel, Grid<Vec3> &weight, int distance = 2)
+{
+  const int dim = (vel.is3D() ? 3 : 2);
+
+  for (int c = 0; c < dim; ++c) {
+    Vec3i dir = 0;
+    dir[c] = 1;
+
+    // reset weight values to 0 (uninitialized), and 1 (initialized inner values)
+    FOR_IJK_BND(vel, 1)
+    {
+      Vec3i p(i, j, k);
+      if (weight(p)[c] > 0.)
+        weight(p)[c] = 1.0;
+    }
+
+    // extrapolate for distance
+    for (int d = 1; d < 1 + distance; ++d) {
+      knExtrapolateMACFromWeight(vel, weight, distance, d, c);
+    }  // d
+  }
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "extrapolateMACFromWeight", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Vec3> &weight = *_args.getPtr<Grid<Vec3>>("weight", 1, &_lock);
+      int distance = _args.getOpt<int>("distance", 2, 2, &_lock);
+      _retval = getPyNone();
+      extrapolateMACFromWeight(vel, weight, distance);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "extrapolateMACFromWeight", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("extrapolateMACFromWeight", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_extrapolateMACFromWeight("", "extrapolateMACFromWeight", _W_1);
+extern "C" {
+void PbRegister_extrapolateMACFromWeight()
+{
+  KEEP_UNUSED(_RP_extrapolateMACFromWeight);
+}
+}
+
+// simple extrapolation functions for levelsets
+
+static const Vec3i nb[6] = {Vec3i(1, 0, 0),
+                            Vec3i(-1, 0, 0),
+                            Vec3i(0, 1, 0),
+                            Vec3i(0, -1, 0),
+                            Vec3i(0, 0, 1),
+                            Vec3i(0, 0, -1)};
+
+template<class S> struct knExtrapolateLsSimple : public KernelBase {
+  knExtrapolateLsSimple(Grid<S> &val, int distance, Grid<int> &tmp, const int d, S direction)
+      : KernelBase(&val, 1), val(val), distance(distance), tmp(tmp), d(d), direction(direction)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<S> &val,
+                 int distance,
+                 Grid<int> &tmp,
+                 const int d,
+                 S direction) const
+  {
+    const int dim = (val.is3D() ? 3 : 2);
+    if (tmp(i, j, k) != 0)
+      return;
+
+    // copy from initialized neighbors
+    Vec3i p(i, j, k);
+    int nbs = 0;
+    S avg(0.);
+    for (int n = 0; n < 2 * dim; ++n) {
+      if (tmp(p + nb[n]) == d) {
+        avg += val(p + nb[n]);
+        nbs++;
+      }
+    }
+
+    if (nbs > 0) {
+      tmp(p) = d + 1;
+      val(p) = avg / nbs + direction;
+    }
+  }
+  inline Grid<S> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<S> type0;
+  inline int &getArg1()
+  {
+    return distance;
+  }
+  typedef int type1;
+  inline Grid<int> &getArg2()
+  {
+    return tmp;
+  }
+  typedef Grid<int> type2;
+  inline const int &getArg3()
+  {
+    return d;
+  }
+  typedef int type3;
+  inline S &getArg4()
+  {
+    return direction;
+  }
+  typedef S type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knExtrapolateLsSimple ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, val, distance, tmp, d, direction);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, val, distance, tmp, d, direction);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<S> &val;
+  int distance;
+  Grid<int> &tmp;
+  const int d;
+  S direction;
+};
+
+template<class S> struct knSetRemaining : public KernelBase {
+  knSetRemaining(Grid<S> &phi, Grid<int> &tmp, S distance)
+      : KernelBase(&phi, 1), phi(phi), tmp(tmp), distance(distance)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<S> &phi, Grid<int> &tmp, S distance) const
+  {
+    if (tmp(i, j, k) != 0)
+      return;
+    phi(i, j, k) = distance;
+  }
+  inline Grid<S> &getArg0()
+  {
+    return phi;
+  }
+  typedef Grid<S> type0;
+  inline Grid<int> &getArg1()
+  {
+    return tmp;
+  }
+  typedef Grid<int> type1;
+  inline S &getArg2()
+  {
+    return distance;
+  }
+  typedef S type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetRemaining ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, phi, tmp, distance);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, phi, tmp, distance);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<S> &phi;
+  Grid<int> &tmp;
+  S distance;
+};
+
+void extrapolateLsSimple(Grid<Real> &phi, int distance = 4, bool inside = false)
+{
+  Grid<int> tmp(phi.getParent());
+  tmp.clear();
+  const int dim = (phi.is3D() ? 3 : 2);
+
+  // by default, march outside
+  Real direction = 1.;
+  if (!inside) {
+    // mark all inside
+    FOR_IJK_BND(phi, 1)
+    {
+      if (phi(i, j, k) < 0.) {
+        tmp(i, j, k) = 1;
+      }
+    }
+  }
+  else {
+    direction = -1.;
+    FOR_IJK_BND(phi, 1)
+    {
+      if (phi(i, j, k) > 0.) {
+        tmp(i, j, k) = 1;
+      }
+    }
+  }
+  // + first layer around
+  FOR_IJK_BND(phi, 1)
+  {
+    Vec3i p(i, j, k);
+    if (tmp(p))
+      continue;
+    for (int n = 0; n < 2 * dim; ++n) {
+      if (tmp(p + nb[n]) == 1) {
+        tmp(i, j, k) = 2;
+        n = 2 * dim;
+      }
+    }
+  }
+
+  // extrapolate for distance
+  for (int d = 2; d < 1 + distance; ++d) {
+    knExtrapolateLsSimple<Real>(phi, distance, tmp, d, direction);
+  }
+
+  // set all remaining cells to max
+  knSetRemaining<Real>(phi, tmp, Real(direction * (distance + 2)));
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "extrapolateLsSimple", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 0, &_lock);
+      int distance = _args.getOpt<int>("distance", 1, 4, &_lock);
+      bool inside = _args.getOpt<bool>("inside", 2, false, &_lock);
+      _retval = getPyNone();
+      extrapolateLsSimple(phi, distance, inside);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "extrapolateLsSimple", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("extrapolateLsSimple", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_extrapolateLsSimple("", "extrapolateLsSimple", _W_2);
+extern "C" {
+void PbRegister_extrapolateLsSimple()
+{
+  KEEP_UNUSED(_RP_extrapolateLsSimple);
+}
+}
+
+// extrapolate centered vec3 values from marked fluid cells
+
+void extrapolateVec3Simple(Grid<Vec3> &vel, Grid<Real> &phi, int distance = 4, bool inside = false)
+{
+  Grid<int> tmp(vel.getParent());
+  tmp.clear();
+  const int dim = (vel.is3D() ? 3 : 2);
+
+  // mark initial cells, by default, march outside
+  if (!inside) {
+    // mark all inside
+    FOR_IJK_BND(phi, 1)
+    {
+      if (phi(i, j, k) < 0.) {
+        tmp(i, j, k) = 1;
+      }
+    }
+  }
+  else {
+    FOR_IJK_BND(phi, 1)
+    {
+      if (phi(i, j, k) > 0.) {
+        tmp(i, j, k) = 1;
+      }
+    }
+  }
+  // + first layer next to initial cells
+  FOR_IJK_BND(vel, 1)
+  {
+    Vec3i p(i, j, k);
+    if (tmp(p))
+      continue;
+    for (int n = 0; n < 2 * dim; ++n) {
+      if (tmp(p + nb[n]) == 1) {
+        tmp(i, j, k) = 2;
+        n = 2 * dim;
+      }
+    }
+  }
+
+  for (int d = 2; d < 1 + distance; ++d) {
+    knExtrapolateLsSimple<Vec3>(vel, distance, tmp, d, Vec3(0.));
+  }
+  knSetRemaining<Vec3>(vel, tmp, Vec3(0.));
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "extrapolateVec3Simple", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 0, &_lock);
+      Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 1, &_lock);
+      int distance = _args.getOpt<int>("distance", 2, 4, &_lock);
+      bool inside = _args.getOpt<bool>("inside", 3, false, &_lock);
+      _retval = getPyNone();
+      extrapolateVec3Simple(vel, phi, distance, inside);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "extrapolateVec3Simple", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("extrapolateVec3Simple", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_extrapolateVec3Simple("", "extrapolateVec3Simple", _W_3);
+extern "C" {
+void PbRegister_extrapolateVec3Simple()
+{
+  KEEP_UNUSED(_RP_extrapolateVec3Simple);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/fastmarch.h b/extern/mantaflow/preprocessed/fastmarch.h
new file mode 100644
index 00000000000..8d0511cc06d
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fastmarch.h
@@ -0,0 +1,241 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Fast marching
+ *
+ ******************************************************************************/
+
+#ifndef _FASTMARCH_H
+#define _FASTMARCH_H
+
+#include <queue>
+#include "levelset.h"
+
+namespace Manta {
+
+//! Fast marching. Transport certain values
+//  This class exists in two versions: for scalar, and for vector values - the only difference are
+//  flag checks i transpTouch (for simplicity in separate classes)
+
+template<class GRID, class T>
+inline T fmInterpolateNeighbors(GRID *mpVal, int x, int y, int z, Real *weights)
+{
+  T val(0.);
+  if (weights[0] > 0.0)
+    val += mpVal->get(x + 1, y + 0, z + 0) * weights[0];
+  if (weights[1] > 0.0)
+    val += mpVal->get(x - 1, y + 0, z + 0) * weights[1];
+  if (weights[2] > 0.0)
+    val += mpVal->get(x + 0, y + 1, z + 0) * weights[2];
+  if (weights[3] > 0.0)
+    val += mpVal->get(x + 0, y - 1, z + 0) * weights[3];
+  if (mpVal->is3D()) {
+    if (weights[4] > 0.0)
+      val += mpVal->get(x + 0, y + 0, z + 1) * weights[4];
+    if (weights[5] > 0.0)
+      val += mpVal->get(x + 0, y + 0, z - 1) * weights[5];
+  }
+  return val;
+}
+
+template<class GRID, class T> class FmValueTransportScalar {
+ public:
+  FmValueTransportScalar() : mpVal(0), mpFlags(0){};
+  ~FmValueTransportScalar(){};
+  void initMarching(GRID *val, FlagGrid *flags)
+  {
+    mpVal = val;
+    mpFlags = flags;
+  }
+  inline bool isInitialized()
+  {
+    return mpVal != 0;
+  }
+
+  //! cell is touched by marching from source cell
+  inline void transpTouch(int x, int y, int z, Real *weights, Real time)
+  {
+    if (!mpVal || !mpFlags->isEmpty(x, y, z))
+      return;
+    T val = fmInterpolateNeighbors<GRID, T>(mpVal, x, y, z, weights);
+    (*mpVal)(x, y, z) = val;
+  };
+
+ protected:
+  GRID *mpVal;
+  FlagGrid *mpFlags;
+};
+
+template<class GRID, class T> class FmValueTransportVec3 {
+ public:
+  FmValueTransportVec3() : mpVal(0), mpFlags(0){};
+  ~FmValueTransportVec3(){};
+  inline bool isInitialized()
+  {
+    return mpVal != 0;
+  }
+  void initMarching(GRID *val, const FlagGrid *flags)
+  {
+    mpVal = val;
+    mpFlags = flags;
+  }
+
+  //! cell is touched by marching from source cell
+  inline void transpTouch(int x, int y, int z, Real *weights, Real time)
+  {
+    if (!mpVal || !mpFlags->isEmpty(x, y, z))
+      return;
+
+    T val = fmInterpolateNeighbors<GRID, T>(mpVal, x, y, z, weights);
+
+    // set velocity components if adjacent is empty
+    if (mpFlags->isEmpty(x - 1, y, z))
+      (*mpVal)(x, y, z).x = val.x;
+    if (mpFlags->isEmpty(x, y - 1, z))
+      (*mpVal)(x, y, z).y = val.y;
+    if (mpVal->is3D()) {
+      if (mpFlags->isEmpty(x, y, z - 1))
+        (*mpVal)(x, y, z).z = val.z;
+    }
+  };
+
+ protected:
+  GRID *mpVal;
+  const FlagGrid *mpFlags;
+};
+
+class FmHeapEntryOut {
+ public:
+  Vec3i p;
+  // quick time access for sorting
+  Real time;
+  static inline bool compare(const Real x, const Real y)
+  {
+    return x > y;
+  }
+
+  inline bool operator<(const FmHeapEntryOut &o) const
+  {
+    const Real d = fabs((time) - ((o.time)));
+    if (d > 0.)
+      return (time) > ((o.time));
+    if (p.z != o.p.z)
+      return p.z > o.p.z;
+    if (p.y != o.p.y)
+      return p.y > o.p.y;
+    return p.x > o.p.x;
+  };
+};
+
+class FmHeapEntryIn {
+ public:
+  Vec3i p;
+  // quick time access for sorting
+  Real time;
+  static inline bool compare(const Real x, const Real y)
+  {
+    return x < y;
+  }
+
+  inline bool operator<(const FmHeapEntryIn &o) const
+  {
+    const Real d = fabs((time) - ((o.time)));
+    if (d > 0.)
+      return (time) < ((o.time));
+    if (p.z != o.p.z)
+      return p.z < o.p.z;
+    if (p.y != o.p.y)
+      return p.y < o.p.y;
+    return p.x < o.p.x;
+  };
+};
+
+//! fast marching algorithm wrapper class
+template<class T, int TDIR> class FastMarch {
+
+ public:
+  // MSVC doesn't allow static const variables in template classes
+  static inline Real InvalidTime()
+  {
+    return -1000;
+  }
+  static inline Real InvtOffset()
+  {
+    return 500;
+  }
+
+  enum SpecialValues { FlagInited = 1, FlagIsOnHeap = 2 };
+
+  FastMarch(const FlagGrid &flags,
+            Grid<int> &fmFlags,
+            Grid<Real> &levelset,
+            Real maxTime,
+            MACGrid *velTransport = NULL);
+  ~FastMarch()
+  {
+  }
+
+  //! advect level set function with given velocity */
+  void performMarching();
+
+  //! test value for invalidity
+  inline bool isInvalid(Real v) const
+  {
+    return (v <= InvalidTime());
+  }
+
+  void addToList(const Vec3i &p, const Vec3i &src);
+
+  //! convert phi to time value
+  inline Real phi2time(Real phival)
+  {
+    return (phival - InvalidTime() + InvtOffset()) * -1.0;
+  }
+
+  //! ... and back
+  inline Real time2phi(Real tval)
+  {
+    return (InvalidTime() - InvtOffset() - tval);
+  }
+
+  inline Real _phi(int i, int j, int k)
+  {
+    return mLevelset(i, j, k);
+  }
+
+ protected:
+  Grid<Real> &mLevelset;
+  const FlagGrid &mFlags;
+  Grid<int> &mFmFlags;
+
+  //! velocity extrpolation
+  FmValueTransportVec3<MACGrid, Vec3> mVelTransport;
+
+  //! maximal time to march for
+  Real mMaxTime;
+
+  //! fast marching list
+  std::priority_queue<T, std::vector<T>, std::less<T>> mHeap;
+  Real mReheapVal;
+
+  //! weights for touching points
+  Real mWeights[6];
+
+  template<int C> inline Real calcWeights(int &okCnt, int &invcnt, Real *v, const Vec3i &idx);
+
+  inline Real calculateDistance(const Vec3i &pos);
+};
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/fastmarch.h.reg.cpp b/extern/mantaflow/preprocessed/fastmarch.h.reg.cpp
new file mode 100644
index 00000000000..903637af502
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fastmarch.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "fastmarch.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_5()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/fileio/iogrids.cpp b/extern/mantaflow/preprocessed/fileio/iogrids.cpp
new file mode 100644
index 00000000000..2f6cdaa6209
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fileio/iogrids.cpp
@@ -0,0 +1,1524 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2016 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Loading and writing grids and meshes to disk
+ *
+ ******************************************************************************/
+
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <cstring>
+
+#if NO_ZLIB != 1
+extern "C" {
+#  include <zlib.h>
+}
+#endif
+
+#if OPENVDB == 1
+#  include "openvdb/openvdb.h"
+#endif
+
+#include "cnpy.h"
+#include "mantaio.h"
+#include "grid.h"
+#include "vector4d.h"
+#include "grid4d.h"
+
+using namespace std;
+
+namespace Manta {
+
+static const int STR_LEN_GRID = 252;
+
+//! uni file header, v4
+typedef struct {
+  int dimX, dimY, dimZ;                        // grid size
+  int gridType, elementType, bytesPerElement;  // data type info
+  char info[STR_LEN_GRID];                     // mantaflow build information
+  int dimT;                                    // optionally store forth dimension for 4d grids
+  unsigned long long timestamp;                // creation time
+} UniHeader;
+
+// note: header v4 only uses 4 bytes of the info string to store the fourth dimension, not needed
+// for pdata
+
+//*****************************************************************************
+// conversion functions for double precision
+// (note - uni files always store single prec. values)
+//*****************************************************************************
+
+#if NO_ZLIB != 1
+template<class GRIDT> void gridConvertWrite(gzFile &gzf, GRIDT &grid, void *ptr, UniHeader &head)
+{
+  errMsg("gridConvertWrite: unknown type, not yet supported");
+}
+
+template<> void gridConvertWrite(gzFile &gzf, Grid<int> &grid, void *ptr, UniHeader &head)
+{
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  gzwrite(gzf, &grid[0], sizeof(int) * head.dimX * head.dimY * head.dimZ);
+}
+template<> void gridConvertWrite(gzFile &gzf, Grid<double> &grid, void *ptr, UniHeader &head)
+{
+  head.bytesPerElement = sizeof(float);
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i, ++ptrf) {
+    *ptrf = (float)grid[i];
+  }
+  gzwrite(gzf, ptr, sizeof(float) * head.dimX * head.dimY * head.dimZ);
+}
+template<>
+void gridConvertWrite(gzFile &gzf, Grid<Vector3D<double>> &grid, void *ptr, UniHeader &head)
+{
+  head.bytesPerElement = sizeof(Vector3D<float>);
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i) {
+    for (int c = 0; c < 3; ++c) {
+      *ptrf = (float)grid[i][c];
+      ptrf++;
+    }
+  }
+  gzwrite(gzf, ptr, sizeof(Vector3D<float>) * head.dimX * head.dimY * head.dimZ);
+}
+
+template<> void gridConvertWrite(gzFile &gzf, Grid4d<int> &grid, void *ptr, UniHeader &head)
+{
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  gzwrite(gzf, &grid[0], sizeof(int) * head.dimX * head.dimY * head.dimZ * head.dimT);
+}
+template<> void gridConvertWrite(gzFile &gzf, Grid4d<double> &grid, void *ptr, UniHeader &head)
+{
+  head.bytesPerElement = sizeof(float);
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  float *ptrf = (float *)ptr;
+  IndexInt s = grid.getStrideT() * grid.getSizeT();
+  for (IndexInt i = 0; i < s; ++i, ++ptrf) {
+    *ptrf = (float)grid[i];
+  }
+  gzwrite(gzf, ptr, sizeof(float) * s);
+}
+template<>
+void gridConvertWrite(gzFile &gzf, Grid4d<Vector3D<double>> &grid, void *ptr, UniHeader &head)
+{
+  head.bytesPerElement = sizeof(Vector3D<float>);
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  float *ptrf = (float *)ptr;
+  IndexInt s = grid.getStrideT() * grid.getSizeT();
+  for (IndexInt i = 0; i < s; ++i) {
+    for (int c = 0; c < 3; ++c) {
+      *ptrf = (float)grid[i][c];
+      ptrf++;
+    }
+  }
+  gzwrite(gzf, ptr, sizeof(Vector3D<float>) * s);
+}
+template<>
+void gridConvertWrite(gzFile &gzf, Grid4d<Vector4D<double>> &grid, void *ptr, UniHeader &head)
+{
+  head.bytesPerElement = sizeof(Vector4D<float>);
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  float *ptrf = (float *)ptr;
+  IndexInt s = grid.getStrideT() * grid.getSizeT();
+  for (IndexInt i = 0; i < s; ++i) {
+    for (int c = 0; c < 4; ++c) {
+      *ptrf = (float)grid[i][c];
+      ptrf++;
+    }
+  }
+  gzwrite(gzf, ptr, sizeof(Vector4D<float>) * s);
+}
+
+template<class T> void gridReadConvert(gzFile &gzf, Grid<T> &grid, void *ptr, int bytesPerElement)
+{
+  errMsg("gridReadConvert: unknown type, not yet supported");
+}
+
+template<> void gridReadConvert<int>(gzFile &gzf, Grid<int> &grid, void *ptr, int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(int) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  assertMsg(bytesPerElement == sizeof(int),
+            "grid element size doesn't match " << bytesPerElement << " vs " << sizeof(int));
+  // easy, nothing to do for ints
+  memcpy(&(grid[0]), ptr, sizeof(int) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+}
+
+template<>
+void gridReadConvert<double>(gzFile &gzf, Grid<double> &grid, void *ptr, int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(float) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  assertMsg(bytesPerElement == sizeof(float),
+            "grid element size doesn't match " << bytesPerElement << " vs " << sizeof(float));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i, ++ptrf) {
+    grid[i] = (double)(*ptrf);
+  }
+}
+
+template<>
+void gridReadConvert<Vec3>(gzFile &gzf, Grid<Vec3> &grid, void *ptr, int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(Vector3D<float>) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  assertMsg(bytesPerElement == sizeof(Vector3D<float>),
+            "grid element size doesn't match " << bytesPerElement << " vs "
+                                               << sizeof(Vector3D<float>));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i) {
+    Vec3 v;
+    for (int c = 0; c < 3; ++c) {
+      v[c] = double(*ptrf);
+      ptrf++;
+    }
+    grid[i] = v;
+  }
+}
+
+template<class T>
+void gridReadConvert4d(gzFile &gzf, Grid4d<T> &grid, void *ptr, int bytesPerElement, int t)
+{
+  errMsg("gridReadConvert4d: unknown type, not yet supported");
+}
+
+template<>
+void gridReadConvert4d<int>(gzFile &gzf, Grid4d<int> &grid, void *ptr, int bytesPerElement, int t)
+{
+  gzread(gzf, ptr, sizeof(int) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  assertMsg(bytesPerElement == sizeof(int),
+            "grid element size doesn't match " << bytesPerElement << " vs " << sizeof(int));
+  // nothing to do for ints
+  memcpy(&(grid[grid.getSizeX() * grid.getSizeY() * grid.getSizeZ() * t]),
+         ptr,
+         sizeof(int) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+}
+
+template<>
+void gridReadConvert4d<double>(
+    gzFile &gzf, Grid4d<double> &grid, void *ptr, int bytesPerElement, int t)
+{
+  assertMsg(bytesPerElement == sizeof(float),
+            "grid element size doesn't match " << bytesPerElement << " vs " << sizeof(float));
+
+  float *ptrf = (float *)ptr;
+  gzread(gzf, ptr, sizeof(float) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  for (IndexInt i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i, ++ptrf) {
+    grid[grid.getSizeX() * grid.getSizeY() * grid.getSizeZ() * t + i] = (double)(*ptrf);
+  }
+}
+
+template<>
+void gridReadConvert4d<Vec3>(
+    gzFile &gzf, Grid4d<Vec3> &grid, void *ptr, int bytesPerElement, int t)
+{
+  assertMsg(bytesPerElement == sizeof(Vector3D<float>),
+            "grid element size doesn't match " << bytesPerElement << " vs " << sizeof(float));
+
+  gzread(gzf, ptr, sizeof(Vector3D<float>) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  float *ptrf = (float *)ptr;
+  for (IndexInt i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i) {
+    Vec3 v;
+    for (int c = 0; c < 3; ++c) {
+      v[c] = double(*ptrf);
+      ptrf++;
+    }
+    grid[grid.getSizeX() * grid.getSizeY() * grid.getSizeZ() * t + i] = v;
+  }
+}
+
+template<>
+void gridReadConvert4d<Vec4>(
+    gzFile &gzf, Grid4d<Vec4> &grid, void *ptr, int bytesPerElement, int t)
+{
+  assertMsg(bytesPerElement == sizeof(Vector4D<float>),
+            "grid element size doesn't match " << bytesPerElement << " vs " << sizeof(float));
+
+  gzread(gzf, ptr, sizeof(Vector4D<float>) * grid.getSizeX() * grid.getSizeY() * grid.getSizeZ());
+  float *ptrf = (float *)ptr;
+  for (IndexInt i = 0; i < grid.getSizeX() * grid.getSizeY() * grid.getSizeZ(); ++i) {
+    Vec4 v;
+    for (int c = 0; c < 4; ++c) {
+      v[c] = double(*ptrf);
+      ptrf++;
+    }
+    grid[grid.getSizeX() * grid.getSizeY() * grid.getSizeZ() * t + i] = v;
+  }
+}
+
+// make sure compatible grid types dont lead to errors...
+static int unifyGridType(int type)
+{
+  // real <> levelset
+  if (type & GridBase::TypeReal)
+    type |= GridBase::TypeLevelset;
+  if (type & GridBase::TypeLevelset)
+    type |= GridBase::TypeReal;
+  // vec3 <> mac
+  if (type & GridBase::TypeVec3)
+    type |= GridBase::TypeMAC;
+  if (type & GridBase::TypeMAC)
+    type |= GridBase::TypeVec3;
+  return type;
+}
+
+#endif  // NO_ZLIB!=1
+
+//*****************************************************************************
+// grid data
+//*****************************************************************************
+
+template<class T> void writeGridTxt(const string &name, Grid<T> *grid)
+{
+  debMsg("writing grid " << grid->getName() << " to text file " << name, 1);
+
+  ofstream ofs(name.c_str());
+  if (!ofs.good())
+    errMsg("writeGridTxt: can't open file " << name);
+  FOR_IJK(*grid)
+  {
+    ofs << Vec3i(i, j, k) << " = " << (*grid)(i, j, k) << "\n";
+  }
+  ofs.close();
+}
+
+template<class T> void writeGridRaw(const string &name, Grid<T> *grid)
+{
+  debMsg("writing grid " << grid->getName() << " to raw file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("writeGridRaw: can't open file " << name);
+  gzwrite(gzf, &((*grid)[0]), sizeof(T) * grid->getSizeX() * grid->getSizeY() * grid->getSizeZ());
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+template<class T> void readGridRaw(const string &name, Grid<T> *grid)
+{
+  debMsg("reading grid " << grid->getName() << " from raw file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (!gzf)
+    errMsg("readGridRaw: can't open file " << name);
+
+  IndexInt bytes = sizeof(T) * grid->getSizeX() * grid->getSizeY() * grid->getSizeZ();
+  IndexInt readBytes = gzread(gzf, &((*grid)[0]), bytes);
+  assertMsg(bytes == readBytes,
+            "can't read raw file, stream length does not match, " << bytes << " vs " << readBytes);
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+//! legacy headers for reading old files
+typedef struct {
+  int dimX, dimY, dimZ;
+  int frames, elements, elementType, bytesPerElement, bytesPerFrame;
+} UniLegacyHeader;
+
+typedef struct {
+  int dimX, dimY, dimZ;
+  int gridType, elementType, bytesPerElement;
+} UniLegacyHeader2;
+
+typedef struct {
+  int dimX, dimY, dimZ;
+  int gridType, elementType, bytesPerElement;
+  char info[256];
+  unsigned long long timestamp;
+} UniLegacyHeader3;
+
+//! for auto-init & check of results of test runs , optionally returns info string of header
+void getUniFileSize(const string &name, int &x, int &y, int &z, int *t, std::string *info)
+{
+  x = y = z = 0;
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (gzf) {
+    char ID[5] = {0, 0, 0, 0, 0};
+    gzread(gzf, ID, 4);
+
+    // v3
+    if ((!strcmp(ID, "MNT2")) || (!strcmp(ID, "M4T2"))) {
+      UniLegacyHeader3 head;
+      assertMsg(gzread(gzf, &head, sizeof(UniLegacyHeader3)) == sizeof(UniLegacyHeader3),
+                "can't read file, no header present");
+      x = head.dimX;
+      y = head.dimY;
+      z = head.dimZ;
+
+      // optionally , read fourth dim
+      if ((!strcmp(ID, "M4T2")) && t) {
+        int dimT = 0;
+        gzread(gzf, &dimT, sizeof(int));
+        (*t) = dimT;
+      }
+    }
+
+    // v4
+    if ((!strcmp(ID, "MNT3")) || (!strcmp(ID, "M4T3"))) {
+      UniHeader head;
+      assertMsg(gzread(gzf, &head, sizeof(UniHeader)) == sizeof(UniHeader),
+                "can't read file, no header present");
+      x = head.dimX;
+      y = head.dimY;
+      z = head.dimZ;
+      if (t)
+        (*t) = head.dimT;
+    }
+
+    gzclose(gzf);
+  }
+#endif
+  if (info) {
+    std::ostringstream out;
+    out << x << "," << y << "," << z;
+    if (t && (*t) > 0)
+      out << "," << (*t);
+    *info = out.str();
+  }
+}
+Vec3 getUniFileSize(const string &name)
+{
+  int x, y, z;
+  getUniFileSize(name, x, y, z);
+  return Vec3(Real(x), Real(y), Real(z));
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getUniFileSize", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const string &name = _args.get<string>("name", 0, &_lock);
+      _retval = toPy(getUniFileSize(name));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getUniFileSize", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getUniFileSize", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getUniFileSize("", "getUniFileSize", _W_0);
+extern "C" {
+void PbRegister_getUniFileSize()
+{
+  KEEP_UNUSED(_RP_getUniFileSize);
+}
+}
+
+//! for test run debugging
+void printUniFileInfoString(const string &name)
+{
+  std::string info("<file not found>");
+  int x = -1, y = -1, z = -1, t = -1;
+  // use getUniFileSize to parse the different headers
+  getUniFileSize(name, x, y, z, &t, &info);
+  debMsg("File '" << name << "' info: " << info, 1);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "printUniFileInfoString", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const string &name = _args.get<string>("name", 0, &_lock);
+      _retval = getPyNone();
+      printUniFileInfoString(name);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "printUniFileInfoString", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("printUniFileInfoString", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_printUniFileInfoString("", "printUniFileInfoString", _W_1);
+extern "C" {
+void PbRegister_printUniFileInfoString()
+{
+  KEEP_UNUSED(_RP_printUniFileInfoString);
+}
+}
+
+// actual read/write functions
+
+template<class T> void writeGridUni(const string &name, Grid<T> *grid)
+{
+  debMsg("Writing grid " << grid->getName() << " to uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  char ID[5] = "MNT3";
+  UniHeader head;
+  head.dimX = grid->getSizeX();
+  head.dimY = grid->getSizeY();
+  head.dimZ = grid->getSizeZ();
+  head.dimT = 0;
+  head.gridType = grid->getType();
+  head.bytesPerElement = sizeof(T);
+  snprintf(head.info, STR_LEN_GRID, "%s", buildInfoString().c_str());
+  MuTime stamp;
+  head.timestamp = stamp.time;
+
+  if (grid->getType() & GridBase::TypeInt)
+    head.elementType = 0;
+  else if (grid->getType() & GridBase::TypeReal)
+    head.elementType = 1;
+  else if (grid->getType() & GridBase::TypeVec3)
+    head.elementType = 2;
+  else
+    errMsg("writeGridUni: unknown element type");
+
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("writeGridUni: can't open file " << name);
+
+  gzwrite(gzf, ID, 4);
+#  if FLOATINGPOINT_PRECISION != 1
+  // always write float values, even if compiled with double precision...
+  Grid<T> temp(grid->getParent());
+  // "misuse" temp grid as storage for floating point values (we have double, so it will always
+  // fit)
+  gridConvertWrite(gzf, *grid, &(temp[0]), head);
+#  else
+  void *ptr = &((*grid)[0]);
+  gzwrite(gzf, &head, sizeof(UniHeader));
+  gzwrite(gzf, ptr, sizeof(T) * head.dimX * head.dimY * head.dimZ);
+#  endif
+  gzclose(gzf);
+
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+template<class T> void readGridUni(const string &name, Grid<T> *grid)
+{
+  debMsg("Reading grid " << grid->getName() << " from uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (!gzf)
+    errMsg("readGridUni: can't open file " << name);
+
+  char ID[5] = {0, 0, 0, 0, 0};
+  gzread(gzf, ID, 4);
+
+  if (!strcmp(ID, "DDF2")) {
+    // legacy file format
+    UniLegacyHeader head;
+    assertMsg(gzread(gzf, &head, sizeof(UniLegacyHeader)) == sizeof(UniLegacyHeader),
+              "can't read file, no header present");
+    assertMsg(head.dimX == grid->getSizeX() && head.dimY == grid->getSizeY() &&
+                  head.dimZ == grid->getSizeZ(),
+              "grid dim doesn't match");
+    assertMsg(head.bytesPerElement * head.elements == sizeof(T), "grid type doesn't match");
+    // skip flags
+    int numEl = head.dimX * head.dimY * head.dimZ;
+    gzseek(gzf, numEl, SEEK_CUR);
+    // actual grid read
+    gzread(gzf, &((*grid)[0]), sizeof(T) * numEl);
+  }
+  else if (!strcmp(ID, "MNT1")) {
+    // legacy file format 2
+    UniLegacyHeader2 head;
+    assertMsg(gzread(gzf, &head, sizeof(UniLegacyHeader2)) == sizeof(UniLegacyHeader2),
+              "can't read file, no header present");
+    assertMsg(head.dimX == grid->getSizeX() && head.dimY == grid->getSizeY() &&
+                  head.dimZ == grid->getSizeZ(),
+              "grid dim doesn't match, " << Vec3(head.dimX, head.dimY, head.dimZ) << " vs "
+                                         << grid->getSize());
+    assertMsg(head.gridType == grid->getType(),
+              "grid type doesn't match " << head.gridType << " vs " << grid->getType());
+    assertMsg(head.bytesPerElement == sizeof(T),
+              "grid element size doesn't match " << head.bytesPerElement << " vs " << sizeof(T));
+    gzread(gzf, &((*grid)[0]), sizeof(T) * head.dimX * head.dimY * head.dimZ);
+  }
+  else if (!strcmp(ID, "MNT2")) {
+    // a bit ugly, almost identical to MNT3
+    UniLegacyHeader3 head;
+    assertMsg(gzread(gzf, &head, sizeof(UniLegacyHeader3)) == sizeof(UniLegacyHeader3),
+              "can't read file, no header present");
+    assertMsg(head.dimX == grid->getSizeX() && head.dimY == grid->getSizeY() &&
+                  head.dimZ == grid->getSizeZ(),
+              "grid dim doesn't match, " << Vec3(head.dimX, head.dimY, head.dimZ) << " vs "
+                                         << grid->getSize());
+    assertMsg(unifyGridType(head.gridType) == unifyGridType(grid->getType()),
+              "grid type doesn't match " << head.gridType << " vs " << grid->getType());
+#  if FLOATINGPOINT_PRECISION != 1
+    Grid<T> temp(grid->getParent());
+    void *ptr = &(temp[0]);
+    gridReadConvert<T>(gzf, *grid, ptr, head.bytesPerElement);
+#  else
+    assertMsg(head.bytesPerElement == sizeof(T),
+              "grid element size doesn't match " << head.bytesPerElement << " vs " << sizeof(T));
+    gzread(gzf, &((*grid)[0]), sizeof(T) * head.dimX * head.dimY * head.dimZ);
+#  endif
+  }
+  else if (!strcmp(ID, "MNT3")) {
+    // current file format
+    UniHeader head;
+    assertMsg(gzread(gzf, &head, sizeof(UniHeader)) == sizeof(UniHeader),
+              "can't read file, no header present");
+    assertMsg(head.dimX == grid->getSizeX() && head.dimY == grid->getSizeY() &&
+                  head.dimZ == grid->getSizeZ(),
+              "grid dim doesn't match, " << Vec3(head.dimX, head.dimY, head.dimZ) << " vs "
+                                         << grid->getSize());
+    assertMsg(unifyGridType(head.gridType) == unifyGridType(grid->getType()),
+              "grid type doesn't match " << head.gridType << " vs " << grid->getType());
+#  if FLOATINGPOINT_PRECISION != 1
+    // convert float to double
+    Grid<T> temp(grid->getParent());
+    void *ptr = &(temp[0]);
+    gridReadConvert<T>(gzf, *grid, ptr, head.bytesPerElement);
+#  else
+    assertMsg(head.bytesPerElement == sizeof(T),
+              "grid element size doesn't match " << head.bytesPerElement << " vs " << sizeof(T));
+    gzread(gzf, &((*grid)[0]), sizeof(T) * head.dimX * head.dimY * head.dimZ);
+#  endif
+  }
+  else {
+    errMsg("readGridUni: Unknown header '" << ID << "' ");
+  }
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+template<class T> void writeGridVol(const string &name, Grid<T> *grid)
+{
+  debMsg("writing grid " << grid->getName() << " to vol file " << name, 1);
+  errMsg("writeGridVol: Type not yet supported!");
+}
+
+struct volHeader {
+  char ID[3];
+  char version;
+  int encoding;
+  int dimX, dimY, dimZ;
+  int channels;
+  Vec3 bboxMin, bboxMax;
+};
+
+template<> void writeGridVol<Real>(const string &name, Grid<Real> *grid)
+{
+  debMsg("writing real grid " << grid->getName() << " to vol file " << name, 1);
+
+  volHeader header;
+  header.ID[0] = 'V';
+  header.ID[1] = 'O';
+  header.ID[2] = 'L';
+  header.version = 3;
+  header.encoding = 1;  // float32 precision
+  header.dimX = grid->getSizeX();
+  header.dimY = grid->getSizeY();
+  header.dimZ = grid->getSizeZ();
+  header.channels = 1;  // only 1 channel
+  header.bboxMin = Vec3(-0.5);
+  header.bboxMax = Vec3(0.5);
+
+  FILE *fp = fopen(name.c_str(), "wb");
+  if (fp == NULL) {
+    errMsg("writeGridVol: Cannot open '" << name << "'");
+    return;
+  }
+
+  fwrite(&header, sizeof(volHeader), 1, fp);
+
+#if FLOATINGPOINT_PRECISION == 1
+  // for float, write one big chunk
+  fwrite(&(*grid)[0], sizeof(float), grid->getSizeX() * grid->getSizeY() * grid->getSizeZ(), fp);
+#else
+  // explicitly convert each entry to float - we might have double precision in mantaflow
+  FOR_IDX(*grid)
+  {
+    float value = (*grid)[idx];
+    fwrite(&value, sizeof(float), 1, fp);
+  }
+#endif
+
+  fclose(fp);
+};
+
+template<class T> void readGridVol(const string &name, Grid<T> *grid)
+{
+  debMsg("writing grid " << grid->getName() << " to vol file " << name, 1);
+  errMsg("readGridVol: Type not yet supported!");
+}
+
+template<> void readGridVol<Real>(const string &name, Grid<Real> *grid)
+{
+  debMsg("reading real grid " << grid->getName() << " from vol file " << name, 1);
+
+  volHeader header;
+  FILE *fp = fopen(name.c_str(), "rb");
+  if (fp == NULL) {
+    errMsg("readGridVol: Cannot open '" << name << "'");
+    return;
+  }
+
+  // note, only very basic file format checks here!
+  assertMsg(fread(&header, 1, sizeof(volHeader), fp) == sizeof(volHeader),
+            "can't read file, no header present");
+  if (header.dimX != grid->getSizeX() || header.dimY != grid->getSizeY() ||
+      header.dimZ != grid->getSizeZ())
+    errMsg("grid dim doesn't match, " << Vec3(header.dimX, header.dimY, header.dimZ) << " vs "
+                                      << grid->getSize());
+#if FLOATINGPOINT_PRECISION != 1
+  errMsg("readGridVol: Double precision not yet supported");
+#else
+  const unsigned int s = sizeof(float) * header.dimX * header.dimY * header.dimZ;
+  assertMsg(fread(&((*grid)[0]), 1, s, fp) == s, "can't read file, no / not enough data");
+#endif
+
+  fclose(fp);
+};
+
+// 4d grids IO
+
+template<class T> void writeGrid4dUni(const string &name, Grid4d<T> *grid)
+{
+  debMsg("writing grid4d " << grid->getName() << " to uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  char ID[5] = "M4T3";
+  UniHeader head;
+  head.dimX = grid->getSizeX();
+  head.dimY = grid->getSizeY();
+  head.dimZ = grid->getSizeZ();
+  head.dimT = grid->getSizeT();
+  head.gridType = grid->getType();
+  head.bytesPerElement = sizeof(T);
+  snprintf(head.info, STR_LEN_GRID, "%s", buildInfoString().c_str());
+  MuTime stamp;
+  stamp.get();
+  head.timestamp = stamp.time;
+
+  if (grid->getType() & Grid4dBase::TypeInt)
+    head.elementType = 0;
+  else if (grid->getType() & Grid4dBase::TypeReal)
+    head.elementType = 1;
+  else if (grid->getType() & Grid4dBase::TypeVec3)
+    head.elementType = 2;
+  else if (grid->getType() & Grid4dBase::TypeVec4)
+    head.elementType = 2;
+  else
+    errMsg("writeGrid4dUni: unknown element type");
+
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("writeGrid4dUni: can't open file " << name);
+
+  gzwrite(gzf, ID, 4);
+#  if FLOATINGPOINT_PRECISION != 1
+  Grid4d<T> temp(grid->getParent());
+  gridConvertWrite<Grid4d<T>>(gzf, *grid, &(temp[0]), head);
+#  else
+  gzwrite(gzf, &head, sizeof(UniHeader));
+
+  // can be too large - write in chunks
+  for (int t = 0; t < head.dimT; ++t) {
+    void *ptr = &((*grid)[head.dimX * head.dimY * head.dimZ * t]);
+    gzwrite(gzf, ptr, sizeof(T) * head.dimX * head.dimY * head.dimZ * 1);
+  }
+#  endif
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+//! note, reading 4d uni grids is slightly more complicated than 3d ones
+//! as it optionally supports sliced reading
+template<class T>
+void readGrid4dUni(
+    const string &name, Grid4d<T> *grid, int readTslice, Grid4d<T> *slice, void **fileHandle)
+{
+  if (grid)
+    debMsg("reading grid " << grid->getName() << " from uni file " << name, 1);
+  if (slice)
+    debMsg("reading slice " << slice->getName() << ",t=" << readTslice << " from uni file "
+                            << name,
+           1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = NULL;
+  char ID[5] = {0, 0, 0, 0, 0};
+
+  // optionally - reuse file handle, if valid one is passed in fileHandle pointer...
+  if ((!fileHandle) || (fileHandle && (*fileHandle == NULL))) {
+    gzf = gzopen(name.c_str(), "rb");
+    if (!gzf)
+      errMsg("readGrid4dUni: can't open file " << name);
+
+    gzread(gzf, ID, 4);
+    if (fileHandle) {
+      *fileHandle = gzf;
+    }
+  }
+  else {
+    // optimized read - reduced sanity checks
+    gzf = (gzFile)(*fileHandle);
+    void *ptr = &((*slice)[0]);
+    gzread(gzf, ptr, sizeof(T) * slice->getStrideT() * 1);  // quick and dirty...
+    return;
+  }
+
+  if ((!strcmp(ID, "M4T2")) || (!strcmp(ID, "M4T3"))) {
+    int headerSize = -1;
+
+    // current file format
+    UniHeader head;
+    if (!strcmp(ID, "M4T3")) {
+      headerSize = sizeof(UniHeader);
+      assertMsg(gzread(gzf, &head, sizeof(UniHeader)) == sizeof(UniHeader),
+                "can't read file, no 4d header present");
+      if (FLOATINGPOINT_PRECISION == 1)
+        assertMsg(head.bytesPerElement == sizeof(T),
+                  "4d grid element size doesn't match " << head.bytesPerElement << " vs "
+                                                        << sizeof(T));
+    }
+    // old header
+    if (!strcmp(ID, "M4T2")) {
+      UniLegacyHeader3 lhead;
+      headerSize = sizeof(UniLegacyHeader3) + sizeof(int);
+      assertMsg(gzread(gzf, &lhead, sizeof(UniLegacyHeader3)) == sizeof(UniLegacyHeader3),
+                "can't read file, no 4dl header present");
+      if (FLOATINGPOINT_PRECISION == 1)
+        assertMsg(lhead.bytesPerElement == sizeof(T),
+                  "4d grid element size doesn't match " << lhead.bytesPerElement << " vs "
+                                                        << sizeof(T));
+
+      int fourthDim = 0;
+      gzread(gzf, &fourthDim, sizeof(fourthDim));
+
+      head.dimX = lhead.dimX;
+      head.dimY = lhead.dimY;
+      head.dimZ = lhead.dimZ;
+      head.dimT = fourthDim;
+      head.gridType = lhead.gridType;
+    }
+
+    if (readTslice < 0) {
+      assertMsg(head.dimX == grid->getSizeX() && head.dimY == grid->getSizeY() &&
+                    head.dimZ == grid->getSizeZ(),
+                "grid dim doesn't match, " << Vec3(head.dimX, head.dimY, head.dimZ) << " vs "
+                                           << grid->getSize());
+      assertMsg(unifyGridType(head.gridType) == unifyGridType(grid->getType()),
+                "grid type doesn't match " << head.gridType << " vs " << grid->getType());
+
+      // read full 4d grid
+      assertMsg(head.dimT == grid->getSizeT(),
+                "grid dim4 doesn't match, " << head.dimT << " vs " << grid->getSize());
+
+      // can be too large - read in chunks
+#  if FLOATINGPOINT_PRECISION != 1
+      Grid4d<T> temp(grid->getParent());
+      void *ptr = &(temp[0]);
+      for (int t = 0; t < head.dimT; ++t) {
+        gridReadConvert4d<T>(gzf, *grid, ptr, head.bytesPerElement, t);
+      }
+#  else
+      for (int t = 0; t < head.dimT; ++t) {
+        void *ptr = &((*grid)[head.dimX * head.dimY * head.dimZ * t]);
+        gzread(gzf, ptr, sizeof(T) * head.dimX * head.dimY * head.dimZ * 1);
+      }
+#  endif
+    }
+    else {
+      // read chosen slice only
+      assertMsg(head.dimX == slice->getSizeX() && head.dimY == slice->getSizeY() &&
+                    head.dimZ == slice->getSizeZ(),
+                "grid dim doesn't match, " << Vec3(head.dimX, head.dimY, head.dimZ) << " vs "
+                                           << slice->getSize());
+      assertMsg(unifyGridType(head.gridType) == unifyGridType(slice->getType()),
+                "grid type doesn't match " << head.gridType << " vs " << slice->getType());
+
+#  if FLOATINGPOINT_PRECISION != 1
+      errMsg("readGrid4dUni: NYI (2)");  // slice read not yet supported for double
+#  else
+      assertMsg(slice, "No 3d slice grid data given");
+      assertMsg(readTslice < head.dimT,
+                "grid dim4 slice too large " << readTslice << " vs " << head.dimT);
+      void *ptr = &((*slice)[0]);
+      gzseek(gzf,
+             sizeof(T) * head.dimX * head.dimY * head.dimZ * readTslice + headerSize + 4,
+             SEEK_SET);
+      gzread(gzf, ptr, sizeof(T) * head.dimX * head.dimY * head.dimZ * 1);
+#  endif
+    }
+  }
+  else {
+    debMsg("Unknown header!", 1);
+  }
+
+  if (!fileHandle) {
+    gzclose(gzf);
+  }
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+void readGrid4dUniCleanup(void **fileHandle)
+{
+  gzFile gzf = NULL;
+  if (fileHandle) {
+    gzf = (gzFile)(*fileHandle);
+    gzclose(gzf);
+    *fileHandle = NULL;
+  }
+}
+
+template<class T> void writeGrid4dRaw(const string &name, Grid4d<T> *grid)
+{
+  debMsg("writing grid4d " << grid->getName() << " to raw file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("writeGrid4dRaw: can't open file " << name);
+  gzwrite(gzf,
+          &((*grid)[0]),
+          sizeof(T) * grid->getSizeX() * grid->getSizeY() * grid->getSizeZ() * grid->getSizeT());
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+template<class T> void readGrid4dRaw(const string &name, Grid4d<T> *grid)
+{
+  debMsg("reading grid4d " << grid->getName() << " from raw file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (!gzf)
+    errMsg("readGrid4dRaw: can't open file " << name);
+
+  IndexInt bytes = sizeof(T) * grid->getSizeX() * grid->getSizeY() * grid->getSizeZ() *
+                   grid->getSizeT();
+  IndexInt readBytes = gzread(gzf, &((*grid)[0]), bytes);
+  assertMsg(bytes == readBytes,
+            "can't read raw file, stream length does not match, " << bytes << " vs " << readBytes);
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+//*****************************************************************************
+// optional openvdb export
+
+#if OPENVDB == 1
+
+template<class T> void writeGridVDB(const string &name, Grid<T> *grid)
+{
+  debMsg("Writing grid " << grid->getName() << " to vdb file " << name << " not yet supported!",
+         1);
+}
+
+template<class T> void readGridVDB(const string &name, Grid<T> *grid)
+{
+  debMsg("Reading grid " << grid->getName() << " from vdb file " << name << " not yet supported!",
+         1);
+}
+
+template<> void writeGridVDB(const string &name, Grid<Real> *grid)
+{
+  debMsg("Writing real grid " << grid->getName() << " to vdb file " << name, 1);
+
+  // Create an empty floating-point grid with background value 0.
+  openvdb::initialize();
+  openvdb::FloatGrid::Ptr gridVDB = openvdb::FloatGrid::create();
+  gridVDB->setTransform(
+      openvdb::math::Transform::createLinearTransform(1. / grid->getSizeX()));  // voxel size
+
+  // Get an accessor for coordinate-based access to voxels.
+  openvdb::FloatGrid::Accessor accessor = gridVDB->getAccessor();
+
+  // Identify the grid as a level set.
+  gridVDB->setGridClass(openvdb::GRID_FOG_VOLUME);
+
+  // Name the grid "density".
+  gridVDB->setName(grid->getName());
+
+  openvdb::io::File file(name);
+
+  FOR_IJK(*grid)
+  {
+    openvdb::Coord xyz(i, j, k);
+    accessor.setValue(xyz, (*grid)(i, j, k));
+  }
+
+  // Add the grid pointer to a container.
+  openvdb::GridPtrVec gridsVDB;
+  gridsVDB.push_back(gridVDB);
+
+  // Write out the contents of the container.
+  file.write(gridsVDB);
+  file.close();
+};
+
+template<> void readGridVDB(const string &name, Grid<Real> *grid)
+{
+  debMsg("Reading real grid " << grid->getName() << " from vdb file " << name, 1);
+
+  openvdb::initialize();
+  openvdb::io::File file(name);
+  file.open();
+
+  openvdb::GridBase::Ptr baseGrid;
+  for (openvdb::io::File::NameIterator nameIter = file.beginName(); nameIter != file.endName();
+       ++nameIter) {
+#  ifndef BLENDER
+    // Read in only the grid we are interested in.
+    if (nameIter.gridName() == grid->getName()) {
+      baseGrid = file.readGrid(nameIter.gridName());
+    }
+    else {
+      debMsg("skipping grid " << nameIter.gridName(), 1);
+    }
+#  else
+    // For Blender, skip name check and pick first grid from loop
+    baseGrid = file.readGrid(nameIter.gridName());
+    break;
+#  endif
+  }
+  file.close();
+  openvdb::FloatGrid::Ptr gridVDB = openvdb::gridPtrCast<openvdb::FloatGrid>(baseGrid);
+
+  openvdb::FloatGrid::Accessor accessor = gridVDB->getAccessor();
+
+  FOR_IJK(*grid)
+  {
+    openvdb::Coord xyz(i, j, k);
+    float v = accessor.getValue(xyz);
+    (*grid)(i, j, k) = v;
+  }
+};
+
+template<> void writeGridVDB(const string &name, Grid<Vec3> *grid)
+{
+  debMsg("Writing vec3 grid " << grid->getName() << " to vdb file " << name, 1);
+
+  openvdb::initialize();
+  openvdb::Vec3SGrid::Ptr gridVDB = openvdb::Vec3SGrid::create();
+  // note , warning - velocity content currently not scaled...
+  gridVDB->setTransform(
+      openvdb::math::Transform::createLinearTransform(1. / grid->getSizeX()));  // voxel size
+  openvdb::Vec3SGrid::Accessor accessor = gridVDB->getAccessor();
+
+  // MAC or regular vec grid?
+  if (grid->getType() & GridBase::TypeMAC)
+    gridVDB->setGridClass(openvdb::GRID_STAGGERED);
+  else
+    gridVDB->setGridClass(openvdb::GRID_UNKNOWN);
+
+  gridVDB->setName(grid->getName());
+
+  openvdb::io::File file(name);
+  FOR_IJK(*grid)
+  {
+    openvdb::Coord xyz(i, j, k);
+    Vec3 v = (*grid)(i, j, k);
+    openvdb::Vec3f vo((float)v[0], (float)v[1], (float)v[2]);
+    accessor.setValue(xyz, vo);
+  }
+
+  openvdb::GridPtrVec gridsVDB;
+  gridsVDB.push_back(gridVDB);
+
+  file.write(gridsVDB);
+  file.close();
+};
+
+template<> void readGridVDB(const string &name, Grid<Vec3> *grid)
+{
+  debMsg("Reading vec3 grid " << grid->getName() << " from vdb file " << name, 1);
+
+  openvdb::initialize();
+  openvdb::io::File file(name);
+  file.open();
+
+  openvdb::GridBase::Ptr baseGrid;
+  for (openvdb::io::File::NameIterator nameIter = file.beginName(); nameIter != file.endName();
+       ++nameIter) {
+#  ifndef BLENDER
+    // Read in only the grid we are interested in.
+    if (nameIter.gridName() == grid->getName()) {
+      baseGrid = file.readGrid(nameIter.gridName());
+    }
+    else {
+      debMsg("skipping grid " << nameIter.gridName(), 1);
+    }
+#  else
+    // For Blender, skip name check and pick first grid from loop
+    baseGrid = file.readGrid(nameIter.gridName());
+    break;
+#  endif
+  }
+  file.close();
+  openvdb::Vec3SGrid::Ptr gridVDB = openvdb::gridPtrCast<openvdb::Vec3SGrid>(baseGrid);
+
+  openvdb::Vec3SGrid::Accessor accessor = gridVDB->getAccessor();
+
+  FOR_IJK(*grid)
+  {
+    openvdb::Coord xyz(i, j, k);
+    openvdb::Vec3f v = accessor.getValue(xyz);
+    (*grid)(i, j, k).x = (float)v[0];
+    (*grid)(i, j, k).y = (float)v[1];
+    (*grid)(i, j, k).z = (float)v[2];
+  }
+};
+
+#endif  // OPENVDB==1
+
+//*****************************************************************************
+// npz file support (warning - read works, but write generates uncompressed npz; i.e. not
+// recommended for large volumes)
+
+template<class T> void writeGridNumpy(const string &name, Grid<T> *grid)
+{
+#if NO_ZLIB == 1
+  debMsg("file format not supported without zlib", 1);
+  return;
+#endif
+#if FLOATINGPOINT_PRECISION != 1
+  errMsg("writeGridNumpy: Double precision not yet supported");
+#endif
+
+  // find suffix to differentiate between npy <-> npz , TODO: check for actual "npy" string
+  std::string::size_type idx;
+  bool bUseNpz = false;
+  idx = name.rfind('.');
+  if (idx != std::string::npos) {
+    bUseNpz = name.substr(idx + 1) == "npz";
+    debMsg("Writing grid " << grid->getName() << " to npz file " << name, 1);
+  }
+  else {
+    debMsg("Writing grid " << grid->getName() << " to npy file " << name, 1);
+  }
+
+  // storage code
+  size_t uDim = 1;
+  if (grid->getType() & GridBase::TypeInt || grid->getType() & GridBase::TypeReal ||
+      grid->getType() & GridBase::TypeLevelset)
+    uDim = 1;
+  else if (grid->getType() & GridBase::TypeVec3 || grid->getType() & GridBase::TypeMAC)
+    uDim = 3;
+  else
+    errMsg("writeGridNumpy: unknown element type");
+
+  const std::vector<size_t> shape = {static_cast<size_t>(grid->getSizeZ()),
+                                     static_cast<size_t>(grid->getSizeY()),
+                                     static_cast<size_t>(grid->getSizeX()),
+                                     uDim};
+
+  if (bUseNpz) {
+    // note, the following generates a zip file without compression
+    if (grid->getType() & GridBase::TypeVec3 || grid->getType() & GridBase::TypeMAC) {
+      // cast to float* for export!
+      float *ptr = (float *)&((*grid)[0]);
+      cnpy::npz_save(name, "arr_0", ptr, shape, "w");
+    }
+    else {
+      T *ptr = &((*grid)[0]);
+      cnpy::npz_save(name, "arr_0", ptr, shape, "w");
+    }
+  }
+  else {
+    cnpy::npy_save(name, &grid[0], shape, "w");
+  }
+};
+
+template<class T> void readGridNumpy(const string &name, Grid<T> *grid)
+{
+#if NO_ZLIB == 1
+  debMsg("file format not supported without zlib", 1);
+  return;
+#endif
+#if FLOATINGPOINT_PRECISION != 1
+  errMsg("readGridNumpy: Double precision not yet supported");
+#endif
+
+  // find suffix to differentiate between npy <-> npz
+  std::string::size_type idx;
+  bool bUseNpz = false;
+  idx = name.rfind('.');
+  if (idx != std::string::npos) {
+    bUseNpz = name.substr(idx + 1) == "npz";
+    debMsg("Reading grid " << grid->getName() << " as npz file " << name, 1);
+  }
+  else {
+    debMsg("Reading grid " << grid->getName() << " as npy file " << name, 1);
+  }
+
+  cnpy::NpyArray gridArr;
+  if (bUseNpz) {
+    cnpy::npz_t fNpz = cnpy::npz_load(name);
+    gridArr = fNpz["arr_0"];
+  }
+  else {
+    gridArr = cnpy::npy_load(name);
+  }
+
+  // Check the file meta information
+  assertMsg(gridArr.shape[2] == grid->getSizeX() && gridArr.shape[1] == grid->getSizeY() &&
+                gridArr.shape[0] == grid->getSizeZ(),
+            "grid dim doesn't match, "
+                << Vec3(gridArr.shape[2], gridArr.shape[1], gridArr.shape[0]) << " vs "
+                << grid->getSize());
+  size_t uDim = 1;
+  if (grid->getType() & GridBase::TypeInt || grid->getType() & GridBase::TypeReal ||
+      grid->getType() & GridBase::TypeLevelset)
+    uDim = 1;
+  else if (grid->getType() & GridBase::TypeVec3 || grid->getType() & GridBase::TypeMAC)
+    uDim = 3;
+  else
+    errMsg("readGridNumpy: unknown element type");
+  assertMsg(gridArr.shape[3] == uDim,
+            "grid data dim doesn't match, " << gridArr.shape[3] << " vs " << uDim);
+
+  if (grid->getType() & GridBase::TypeVec3 || grid->getType() & GridBase::TypeMAC) {
+    // treated as float* for export , thus consider 3 elements
+    assertMsg(3 * gridArr.word_size == sizeof(T),
+              "vec3 grid data size doesn't match, " << 3 * gridArr.word_size << " vs "
+                                                    << sizeof(T));
+  }
+  else {
+    assertMsg(gridArr.word_size == sizeof(T),
+              "grid data size doesn't match, " << gridArr.word_size << " vs " << sizeof(T));
+  }
+
+  // copy back, TODO: beautify...
+  memcpy(&((*grid)[0]),
+         gridArr.data<T>(),
+         sizeof(T) * grid->getSizeX() * grid->getSizeY() * grid->getSizeZ());
+};
+
+// adopted from getUniFileSize
+void getNpzFileSize(
+    const string &name, int &x, int &y, int &z, int *t = NULL, std::string *info = NULL)
+{
+  x = y = z = 0;
+#if NO_ZLIB != 1
+  debMsg("file format not supported without zlib", 1);
+  return;
+#endif
+#if FLOATINGPOINT_PRECISION != 1
+  errMsg("getNpzFileSize: Double precision not yet supported");
+#endif
+  // find suffix to differentiate between npy <-> npz
+  cnpy::NpyArray gridArr;
+  cnpy::npz_t fNpz = cnpy::npz_load(name);
+  gridArr = fNpz["arr_0"];
+
+  z = gridArr.shape[0];
+  y = gridArr.shape[1];
+  x = gridArr.shape[2];
+  if (t)
+    (*t) = 0;  // unused for now
+}
+Vec3 getNpzFileSize(const string &name)
+{
+  int x, y, z;
+  getNpzFileSize(name, x, y, z);
+  return Vec3(Real(x), Real(y), Real(z));
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getNpzFileSize", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const string &name = _args.get<string>("name", 0, &_lock);
+      _retval = toPy(getNpzFileSize(name));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getNpzFileSize", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getNpzFileSize", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getNpzFileSize("", "getNpzFileSize", _W_2);
+extern "C" {
+void PbRegister_getNpzFileSize()
+{
+  KEEP_UNUSED(_RP_getNpzFileSize);
+}
+}
+
+//*****************************************************************************
+// helper functions
+
+void quantizeReal(Real &v, const Real step)
+{
+  int q = int(v / step + step * 0.5);
+  double qd = q * (double)step;
+  v = (Real)qd;
+}
+struct knQuantize : public KernelBase {
+  knQuantize(Grid<Real> &grid, Real step) : KernelBase(&grid, 0), grid(grid), step(step)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Real> &grid, Real step) const
+  {
+    quantizeReal(grid(idx), step);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type0;
+  inline Real &getArg1()
+  {
+    return step;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knQuantize ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, grid, step);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &grid;
+  Real step;
+};
+void quantizeGrid(Grid<Real> &grid, Real step)
+{
+  knQuantize(grid, step);
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "quantizeGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 0, &_lock);
+      Real step = _args.get<Real>("step", 1, &_lock);
+      _retval = getPyNone();
+      quantizeGrid(grid, step);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "quantizeGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("quantizeGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_quantizeGrid("", "quantizeGrid", _W_3);
+extern "C" {
+void PbRegister_quantizeGrid()
+{
+  KEEP_UNUSED(_RP_quantizeGrid);
+}
+}
+
+struct knQuantizeVec3 : public KernelBase {
+  knQuantizeVec3(Grid<Vec3> &grid, Real step) : KernelBase(&grid, 0), grid(grid), step(step)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Vec3> &grid, Real step) const
+  {
+    for (int c = 0; c < 3; ++c)
+      quantizeReal(grid(idx)[c], step);
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline Real &getArg1()
+  {
+    return step;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knQuantizeVec3 ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, grid, step);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Vec3> &grid;
+  Real step;
+};
+void quantizeGridVec3(Grid<Vec3> &grid, Real step)
+{
+  knQuantizeVec3(grid, step);
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "quantizeGridVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &grid = *_args.getPtr<Grid<Vec3>>("grid", 0, &_lock);
+      Real step = _args.get<Real>("step", 1, &_lock);
+      _retval = getPyNone();
+      quantizeGridVec3(grid, step);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "quantizeGridVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("quantizeGridVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_quantizeGridVec3("", "quantizeGridVec3", _W_4);
+extern "C" {
+void PbRegister_quantizeGridVec3()
+{
+  KEEP_UNUSED(_RP_quantizeGridVec3);
+}
+}
+
+// explicit instantiation
+template void writeGridRaw<int>(const string &name, Grid<int> *grid);
+template void writeGridRaw<Real>(const string &name, Grid<Real> *grid);
+template void writeGridRaw<Vec3>(const string &name, Grid<Vec3> *grid);
+template void writeGridUni<int>(const string &name, Grid<int> *grid);
+template void writeGridUni<Real>(const string &name, Grid<Real> *grid);
+template void writeGridUni<Vec3>(const string &name, Grid<Vec3> *grid);
+template void writeGridVol<int>(const string &name, Grid<int> *grid);
+template void writeGridVol<Vec3>(const string &name, Grid<Vec3> *grid);
+template void writeGridTxt<int>(const string &name, Grid<int> *grid);
+template void writeGridTxt<Real>(const string &name, Grid<Real> *grid);
+template void writeGridTxt<Vec3>(const string &name, Grid<Vec3> *grid);
+
+template void readGridRaw<int>(const string &name, Grid<int> *grid);
+template void readGridRaw<Real>(const string &name, Grid<Real> *grid);
+template void readGridRaw<Vec3>(const string &name, Grid<Vec3> *grid);
+template void readGridUni<int>(const string &name, Grid<int> *grid);
+template void readGridUni<Real>(const string &name, Grid<Real> *grid);
+template void readGridUni<Vec3>(const string &name, Grid<Vec3> *grid);
+template void readGridVol<int>(const string &name, Grid<int> *grid);
+template void readGridVol<Vec3>(const string &name, Grid<Vec3> *grid);
+
+template void readGrid4dUni<int>(
+    const string &name, Grid4d<int> *grid, int readTslice, Grid4d<int> *slice, void **fileHandle);
+template void readGrid4dUni<Real>(const string &name,
+                                  Grid4d<Real> *grid,
+                                  int readTslice,
+                                  Grid4d<Real> *slice,
+                                  void **fileHandle);
+template void readGrid4dUni<Vec3>(const string &name,
+                                  Grid4d<Vec3> *grid,
+                                  int readTslice,
+                                  Grid4d<Vec3> *slice,
+                                  void **fileHandle);
+template void readGrid4dUni<Vec4>(const string &name,
+                                  Grid4d<Vec4> *grid,
+                                  int readTslice,
+                                  Grid4d<Vec4> *slice,
+                                  void **fileHandle);
+template void writeGrid4dUni<int>(const string &name, Grid4d<int> *grid);
+template void writeGrid4dUni<Real>(const string &name, Grid4d<Real> *grid);
+template void writeGrid4dUni<Vec3>(const string &name, Grid4d<Vec3> *grid);
+template void writeGrid4dUni<Vec4>(const string &name, Grid4d<Vec4> *grid);
+
+template void readGrid4dRaw<int>(const string &name, Grid4d<int> *grid);
+template void readGrid4dRaw<Real>(const string &name, Grid4d<Real> *grid);
+template void readGrid4dRaw<Vec3>(const string &name, Grid4d<Vec3> *grid);
+template void readGrid4dRaw<Vec4>(const string &name, Grid4d<Vec4> *grid);
+template void writeGrid4dRaw<int>(const string &name, Grid4d<int> *grid);
+template void writeGrid4dRaw<Real>(const string &name, Grid4d<Real> *grid);
+template void writeGrid4dRaw<Vec3>(const string &name, Grid4d<Vec3> *grid);
+template void writeGrid4dRaw<Vec4>(const string &name, Grid4d<Vec4> *grid);
+
+template void writeGridNumpy<int>(const string &name, Grid<int> *grid);
+template void writeGridNumpy<Real>(const string &name, Grid<Real> *grid);
+template void writeGridNumpy<Vec3>(const string &name, Grid<Vec3> *grid);
+template void readGridNumpy<int>(const string &name, Grid<int> *grid);
+template void readGridNumpy<Real>(const string &name, Grid<Real> *grid);
+template void readGridNumpy<Vec3>(const string &name, Grid<Vec3> *grid);
+
+#if OPENVDB == 1
+template void writeGridVDB<int>(const string &name, Grid<int> *grid);
+template void writeGridVDB<Vec3>(const string &name, Grid<Vec3> *grid);
+template void writeGridVDB<Real>(const string &name, Grid<Real> *grid);
+
+template void readGridVDB<int>(const string &name, Grid<int> *grid);
+template void readGridVDB<Vec3>(const string &name, Grid<Vec3> *grid);
+template void readGridVDB<Real>(const string &name, Grid<Real> *grid);
+#endif  // OPENVDB==1
+
+}  // namespace Manta
+
+namespace Manta {
+
+}
diff --git a/extern/mantaflow/preprocessed/fileio/iomeshes.cpp b/extern/mantaflow/preprocessed/fileio/iomeshes.cpp
new file mode 100644
index 00000000000..fc57e2a8c2b
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fileio/iomeshes.cpp
@@ -0,0 +1,490 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2016 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Loading and writing grids and meshes to disk
+ *
+ ******************************************************************************/
+
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#if NO_ZLIB != 1
+extern "C" {
+#  include <zlib.h>
+}
+#endif
+
+#include "mantaio.h"
+#include "grid.h"
+#include "mesh.h"
+#include "vortexsheet.h"
+#include <cstring>
+
+using namespace std;
+
+namespace Manta {
+
+static const int STR_LEN_PDATA = 256;
+
+//! mdata uni header, v3  (similar to grid header and mdata header)
+typedef struct {
+  int dim;               // number of vertices
+  int dimX, dimY, dimZ;  // underlying solver resolution (all data in local coordinates!)
+  int elementType, bytesPerElement;  // type id and byte size
+  char info[STR_LEN_PDATA];          // mantaflow build information
+  unsigned long long timestamp;      // creation time
+} UniMeshHeader;
+
+//*****************************************************************************
+// conversion functions for double precision
+// (note - uni files always store single prec. values)
+//*****************************************************************************
+
+#if NO_ZLIB != 1
+
+template<class T>
+void mdataConvertWrite(gzFile &gzf, MeshDataImpl<T> &mdata, void *ptr, UniMeshHeader &head)
+{
+  errMsg("mdataConvertWrite: unknown type, not yet supported");
+}
+
+template<>
+void mdataConvertWrite(gzFile &gzf, MeshDataImpl<int> &mdata, void *ptr, UniMeshHeader &head)
+{
+  gzwrite(gzf, &head, sizeof(UniMeshHeader));
+  gzwrite(gzf, &mdata[0], sizeof(int) * head.dim);
+}
+template<>
+void mdataConvertWrite(gzFile &gzf, MeshDataImpl<double> &mdata, void *ptr, UniMeshHeader &head)
+{
+  head.bytesPerElement = sizeof(float);
+  gzwrite(gzf, &head, sizeof(UniMeshHeader));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < mdata.size(); ++i, ++ptrf) {
+    *ptrf = (float)mdata[i];
+  }
+  gzwrite(gzf, ptr, sizeof(float) * head.dim);
+}
+template<>
+void mdataConvertWrite(gzFile &gzf, MeshDataImpl<Vec3> &mdata, void *ptr, UniMeshHeader &head)
+{
+  head.bytesPerElement = sizeof(Vector3D<float>);
+  gzwrite(gzf, &head, sizeof(UniMeshHeader));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < mdata.size(); ++i) {
+    for (int c = 0; c < 3; ++c) {
+      *ptrf = (float)mdata[i][c];
+      ptrf++;
+    }
+  }
+  gzwrite(gzf, ptr, sizeof(Vector3D<float>) * head.dim);
+}
+
+template<class T>
+void mdataReadConvert(gzFile &gzf, MeshDataImpl<T> &grid, void *ptr, int bytesPerElement)
+{
+  errMsg("mdataReadConvert: unknown mdata type, not yet supported");
+}
+
+template<>
+void mdataReadConvert<int>(gzFile &gzf, MeshDataImpl<int> &mdata, void *ptr, int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(int) * mdata.size());
+  assertMsg(bytesPerElement == sizeof(int),
+            "mdata element size doesn't match " << bytesPerElement << " vs " << sizeof(int));
+  // int dont change in double precision mode - copy over
+  memcpy(&(mdata[0]), ptr, sizeof(int) * mdata.size());
+}
+
+template<>
+void mdataReadConvert<double>(gzFile &gzf,
+                              MeshDataImpl<double> &mdata,
+                              void *ptr,
+                              int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(float) * mdata.size());
+  assertMsg(bytesPerElement == sizeof(float),
+            "mdata element size doesn't match " << bytesPerElement << " vs " << sizeof(float));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < mdata.size(); ++i, ++ptrf) {
+    mdata[i] = double(*ptrf);
+  }
+}
+
+template<>
+void mdataReadConvert<Vec3>(gzFile &gzf, MeshDataImpl<Vec3> &mdata, void *ptr, int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(Vector3D<float>) * mdata.size());
+  assertMsg(bytesPerElement == sizeof(Vector3D<float>),
+            "mdata element size doesn't match " << bytesPerElement << " vs "
+                                                << sizeof(Vector3D<float>));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < mdata.size(); ++i) {
+    Vec3 v;
+    for (int c = 0; c < 3; ++c) {
+      v[c] = double(*ptrf);
+      ptrf++;
+    }
+    mdata[i] = v;
+  }
+}
+
+#endif  // NO_ZLIB!=1
+
+//*****************************************************************************
+// mesh data
+//*****************************************************************************
+
+void readBobjFile(const string &name, Mesh *mesh, bool append)
+{
+  debMsg("reading mesh file " << name, 1);
+  if (!append)
+    mesh->clear();
+  else
+    errMsg("readBobj: append not yet implemented!");
+
+#if NO_ZLIB != 1
+  const Real dx = mesh->getParent()->getDx();
+  const Vec3 gs = toVec3(mesh->getParent()->getGridSize());
+
+  gzFile gzf = gzopen(name.c_str(), "rb1");  // do some compression
+  if (!gzf)
+    errMsg("readBobj: unable to open file");
+
+  // read vertices
+  int num = 0;
+  gzread(gzf, &num, sizeof(int));
+  mesh->resizeNodes(num);
+  debMsg("read mesh , verts " << num, 1);
+  for (int i = 0; i < num; i++) {
+    Vector3D<float> pos;
+    gzread(gzf, &pos.value[0], sizeof(float) * 3);
+    mesh->nodes(i).pos = toVec3(pos);
+
+    // convert to grid space
+    mesh->nodes(i).pos /= dx;
+    mesh->nodes(i).pos += gs * 0.5;
+  }
+
+  // normals
+  num = 0;
+  gzread(gzf, &num, sizeof(int));
+  for (int i = 0; i < num; i++) {
+    Vector3D<float> pos;
+    gzread(gzf, &pos.value[0], sizeof(float) * 3);
+    mesh->nodes(i).normal = toVec3(pos);
+  }
+
+  // read tris
+  num = 0;
+  gzread(gzf, &num, sizeof(int));
+  mesh->resizeTris(num);
+  for (int t = 0; t < num; t++) {
+    for (int j = 0; j < 3; j++) {
+      int trip = 0;
+      gzread(gzf, &trip, sizeof(int));
+      mesh->tris(t).c[j] = trip;
+    }
+  }
+  // note - vortex sheet info ignored for now... (see writeBobj)
+  gzclose(gzf);
+  debMsg("read mesh , triangles " << mesh->numTris() << ", vertices " << mesh->numNodes() << " ",
+         1);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+void writeBobjFile(const string &name, Mesh *mesh)
+{
+  debMsg("writing mesh file " << name, 1);
+#if NO_ZLIB != 1
+  const Real dx = mesh->getParent()->getDx();
+  const Vec3i gs = mesh->getParent()->getGridSize();
+
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("writeBobj: unable to open file");
+
+  // write vertices
+  int numVerts = mesh->numNodes();
+  gzwrite(gzf, &numVerts, sizeof(int));
+  for (int i = 0; i < numVerts; i++) {
+    Vector3D<float> pos = toVec3f(mesh->nodes(i).pos);
+    // normalize to unit cube around 0
+    pos -= toVec3f(gs) * 0.5;
+    pos *= dx;
+    gzwrite(gzf, &pos.value[0], sizeof(float) * 3);
+  }
+
+  // normals
+  mesh->computeVertexNormals();
+  gzwrite(gzf, &numVerts, sizeof(int));
+  for (int i = 0; i < numVerts; i++) {
+    Vector3D<float> pos = toVec3f(mesh->nodes(i).normal);
+    gzwrite(gzf, &pos.value[0], sizeof(float) * 3);
+  }
+
+  // write tris
+  int numTris = mesh->numTris();
+  gzwrite(gzf, &numTris, sizeof(int));
+  for (int t = 0; t < numTris; t++) {
+    for (int j = 0; j < 3; j++) {
+      int trip = mesh->tris(t).c[j];
+      gzwrite(gzf, &trip, sizeof(int));
+    }
+  }
+
+  // per vertex smoke densities
+  if (mesh->getType() == Mesh::TypeVortexSheet) {
+    VortexSheetMesh *vmesh = (VortexSheetMesh *)mesh;
+    int densId[4] = {0, 'v', 'd', 'e'};
+    gzwrite(gzf, &densId[0], sizeof(int) * 4);
+
+    // compute densities
+    vector<float> triDensity(numTris);
+    for (int tri = 0; tri < numTris; tri++) {
+      Real area = vmesh->getFaceArea(tri);
+      if (area > 0)
+        triDensity[tri] = vmesh->sheet(tri).smokeAmount;
+    }
+
+    // project triangle data to vertex
+    vector<int> triPerVertex(numVerts);
+    vector<float> density(numVerts);
+    for (int tri = 0; tri < numTris; tri++) {
+      for (int c = 0; c < 3; c++) {
+        int vertex = mesh->tris(tri).c[c];
+        density[vertex] += triDensity[tri];
+        triPerVertex[vertex]++;
+      }
+    }
+
+    // averaged smoke densities
+    for (int point = 0; point < numVerts; point++) {
+      float dens = 0;
+      if (triPerVertex[point] > 0)
+        dens = density[point] / triPerVertex[point];
+      gzwrite(gzf, &dens, sizeof(float));
+    }
+  }
+
+  // vertex flags
+  if (mesh->getType() == Mesh::TypeVortexSheet) {
+    int Id[4] = {0, 'v', 'x', 'f'};
+    gzwrite(gzf, &Id[0], sizeof(int) * 4);
+
+    // averaged smoke densities
+    for (int point = 0; point < numVerts; point++) {
+      float alpha = (mesh->nodes(point).flags & Mesh::NfMarked) ? 1 : 0;
+      gzwrite(gzf, &alpha, sizeof(float));
+    }
+  }
+
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+void readObjFile(const std::string &name, Mesh *mesh, bool append)
+{
+  ifstream ifs(name.c_str());
+
+  if (!ifs.good())
+    errMsg("can't open file '" + name + "'");
+
+  if (!append)
+    mesh->clear();
+  int nodebase = mesh->numNodes();
+  int cnt = nodebase;
+  while (ifs.good() && !ifs.eof()) {
+    string id;
+    ifs >> id;
+
+    if (id[0] == '#') {
+      // comment
+      getline(ifs, id);
+      continue;
+    }
+    if (id == "vt") {
+      // tex coord, ignore
+    }
+    else if (id == "vn") {
+      // normals
+      if (!mesh->numNodes())
+        errMsg("invalid amount of nodes");
+      Node n = mesh->nodes(cnt);
+      ifs >> n.normal.x >> n.normal.y >> n.normal.z;
+      cnt++;
+    }
+    else if (id == "v") {
+      // vertex
+      Node n;
+      ifs >> n.pos.x >> n.pos.y >> n.pos.z;
+      mesh->addNode(n);
+    }
+    else if (id == "g") {
+      // group
+      string group;
+      ifs >> group;
+    }
+    else if (id == "f") {
+      // face
+      string face;
+      Triangle t;
+      for (int i = 0; i < 3; i++) {
+        ifs >> face;
+        if (face.find('/') != string::npos)
+          face = face.substr(0, face.find('/'));  // ignore other indices
+        int idx = atoi(face.c_str()) - 1;
+        if (idx < 0)
+          errMsg("invalid face encountered");
+        idx += nodebase;
+        t.c[i] = idx;
+      }
+      mesh->addTri(t);
+    }
+    else {
+      // whatever, ignore
+    }
+    // kill rest of line
+    getline(ifs, id);
+  }
+  ifs.close();
+}
+
+// write regular .obj file, in line with bobj.gz output (but only verts & tris for now)
+void writeObjFile(const string &name, Mesh *mesh)
+{
+  const Real dx = mesh->getParent()->getDx();
+  const Vec3i gs = mesh->getParent()->getGridSize();
+
+  ofstream ofs(name.c_str());
+  if (!ofs.good())
+    errMsg("writeObjFile: can't open file " << name);
+
+  ofs << "o MantaMesh\n";
+
+  // write vertices
+  int numVerts = mesh->numNodes();
+  for (int i = 0; i < numVerts; i++) {
+    Vector3D<float> pos = toVec3f(mesh->nodes(i).pos);
+    // normalize to unit cube around 0
+    pos -= toVec3f(gs) * 0.5;
+    pos *= dx;
+    ofs << "v " << pos.value[0] << " " << pos.value[1] << " " << pos.value[2] << " "
+        << "\n";
+  }
+
+  // write normals
+  for (int i = 0; i < numVerts; i++) {
+    Vector3D<float> n = toVec3f(mesh->nodes(i).normal);
+    // normalize to unit cube around 0
+    ofs << "vn " << n.value[0] << " " << n.value[1] << " " << n.value[2] << " "
+        << "\n";
+  }
+
+  // write tris
+  int numTris = mesh->numTris();
+  for (int t = 0; t < numTris; t++) {
+    ofs << "f " << (mesh->tris(t).c[0] + 1) << " " << (mesh->tris(t).c[1] + 1) << " "
+        << (mesh->tris(t).c[2] + 1) << " "
+        << "\n";
+  }
+
+  ofs.close();
+}
+
+template<class T> void readMdataUni(const std::string &name, MeshDataImpl<T> *mdata)
+{
+  debMsg("reading mesh data " << mdata->getName() << " from uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (!gzf)
+    errMsg("can't open file " << name);
+
+  char ID[5] = {0, 0, 0, 0, 0};
+  gzread(gzf, ID, 4);
+
+  if (!strcmp(ID, "MD01")) {
+    UniMeshHeader head;
+    assertMsg(gzread(gzf, &head, sizeof(UniMeshHeader)) == sizeof(UniMeshHeader),
+              "can't read file, no header present");
+    assertMsg(head.dim == mdata->size(), "mdata size doesn't match");
+#  if FLOATINGPOINT_PRECISION != 1
+    MeshDataImpl<T> temp(mdata->getParent());
+    temp.resize(mdata->size());
+    mdataReadConvert<T>(gzf, *mdata, &(temp[0]), head.bytesPerElement);
+#  else
+    assertMsg(((head.bytesPerElement == sizeof(T)) && (head.elementType == 1)),
+              "mdata type doesn't match");
+    IndexInt bytes = sizeof(T) * head.dim;
+    IndexInt readBytes = gzread(gzf, &(mdata->get(0)), sizeof(T) * head.dim);
+    assertMsg(bytes == readBytes,
+              "can't read uni file, stream length does not match, " << bytes << " vs "
+                                                                    << readBytes);
+#  endif
+  }
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+template<class T> void writeMdataUni(const std::string &name, MeshDataImpl<T> *mdata)
+{
+  debMsg("writing mesh data " << mdata->getName() << " to uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  char ID[5] = "MD01";
+  UniMeshHeader head;
+  head.dim = mdata->size();
+  head.bytesPerElement = sizeof(T);
+  head.elementType = 1;  // 1 for mesh data, todo - add sub types?
+  snprintf(head.info, STR_LEN_PDATA, "%s", buildInfoString().c_str());
+  MuTime stamp;
+  head.timestamp = stamp.time;
+
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("can't open file " << name);
+  gzwrite(gzf, ID, 4);
+
+#  if FLOATINGPOINT_PRECISION != 1
+  // always write float values, even if compiled with double precision (as for grids)
+  MeshDataImpl<T> temp(mdata->getParent());
+  temp.resize(mdata->size());
+  mdataConvertWrite(gzf, *mdata, &(temp[0]), head);
+#  else
+  gzwrite(gzf, &head, sizeof(UniMeshHeader));
+  gzwrite(gzf, &(mdata->get(0)), sizeof(T) * head.dim);
+#  endif
+  gzclose(gzf);
+
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+// explicit instantiation
+template void writeMdataUni<int>(const std::string &name, MeshDataImpl<int> *mdata);
+template void writeMdataUni<Real>(const std::string &name, MeshDataImpl<Real> *mdata);
+template void writeMdataUni<Vec3>(const std::string &name, MeshDataImpl<Vec3> *mdata);
+template void readMdataUni<int>(const std::string &name, MeshDataImpl<int> *mdata);
+template void readMdataUni<Real>(const std::string &name, MeshDataImpl<Real> *mdata);
+template void readMdataUni<Vec3>(const std::string &name, MeshDataImpl<Vec3> *mdata);
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/fileio/ioparticles.cpp b/extern/mantaflow/preprocessed/fileio/ioparticles.cpp
new file mode 100644
index 00000000000..432cbc9f100
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fileio/ioparticles.cpp
@@ -0,0 +1,342 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2016 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Loading and writing grids and meshes to disk
+ *
+ ******************************************************************************/
+
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <cstring>
+#if NO_ZLIB != 1
+extern "C" {
+#  include <zlib.h>
+}
+#endif
+
+#include "mantaio.h"
+#include "grid.h"
+#include "particle.h"
+#include "vector4d.h"
+#include "grid4d.h"
+
+using namespace std;
+
+namespace Manta {
+
+static const int STR_LEN_PDATA = 256;
+
+//! pdata uni header, v3  (similar to grid header)
+typedef struct {
+  int dim;               // number of partilces
+  int dimX, dimY, dimZ;  // underlying solver resolution (all data in local coordinates!)
+  int elementType, bytesPerElement;  // type id and byte size
+  char info[STR_LEN_PDATA];          // mantaflow build information
+  unsigned long long timestamp;      // creation time
+} UniPartHeader;
+
+//*****************************************************************************
+// conversion functions for double precision
+// (note - uni files always store single prec. values)
+//*****************************************************************************
+
+#if NO_ZLIB != 1
+
+template<class T>
+void pdataConvertWrite(gzFile &gzf, ParticleDataImpl<T> &pdata, void *ptr, UniPartHeader &head)
+{
+  errMsg("pdataConvertWrite: unknown type, not yet supported");
+}
+
+template<>
+void pdataConvertWrite(gzFile &gzf, ParticleDataImpl<int> &pdata, void *ptr, UniPartHeader &head)
+{
+  gzwrite(gzf, &head, sizeof(UniPartHeader));
+  gzwrite(gzf, &pdata[0], sizeof(int) * head.dim);
+}
+template<>
+void pdataConvertWrite(gzFile &gzf,
+                       ParticleDataImpl<double> &pdata,
+                       void *ptr,
+                       UniPartHeader &head)
+{
+  head.bytesPerElement = sizeof(float);
+  gzwrite(gzf, &head, sizeof(UniPartHeader));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < pdata.size(); ++i, ++ptrf) {
+    *ptrf = (float)pdata[i];
+  }
+  gzwrite(gzf, ptr, sizeof(float) * head.dim);
+}
+template<>
+void pdataConvertWrite(gzFile &gzf, ParticleDataImpl<Vec3> &pdata, void *ptr, UniPartHeader &head)
+{
+  head.bytesPerElement = sizeof(Vector3D<float>);
+  gzwrite(gzf, &head, sizeof(UniPartHeader));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < pdata.size(); ++i) {
+    for (int c = 0; c < 3; ++c) {
+      *ptrf = (float)pdata[i][c];
+      ptrf++;
+    }
+  }
+  gzwrite(gzf, ptr, sizeof(Vector3D<float>) * head.dim);
+}
+
+template<class T>
+void pdataReadConvert(gzFile &gzf, ParticleDataImpl<T> &grid, void *ptr, int bytesPerElement)
+{
+  errMsg("pdataReadConvert: unknown pdata type, not yet supported");
+}
+
+template<>
+void pdataReadConvert<int>(gzFile &gzf,
+                           ParticleDataImpl<int> &pdata,
+                           void *ptr,
+                           int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(int) * pdata.size());
+  assertMsg(bytesPerElement == sizeof(int),
+            "pdata element size doesn't match " << bytesPerElement << " vs " << sizeof(int));
+  // int dont change in double precision mode - copy over
+  memcpy(&(pdata[0]), ptr, sizeof(int) * pdata.size());
+}
+
+template<>
+void pdataReadConvert<double>(gzFile &gzf,
+                              ParticleDataImpl<double> &pdata,
+                              void *ptr,
+                              int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(float) * pdata.size());
+  assertMsg(bytesPerElement == sizeof(float),
+            "pdata element size doesn't match " << bytesPerElement << " vs " << sizeof(float));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < pdata.size(); ++i, ++ptrf) {
+    pdata[i] = double(*ptrf);
+  }
+}
+
+template<>
+void pdataReadConvert<Vec3>(gzFile &gzf,
+                            ParticleDataImpl<Vec3> &pdata,
+                            void *ptr,
+                            int bytesPerElement)
+{
+  gzread(gzf, ptr, sizeof(Vector3D<float>) * pdata.size());
+  assertMsg(bytesPerElement == sizeof(Vector3D<float>),
+            "pdata element size doesn't match " << bytesPerElement << " vs "
+                                                << sizeof(Vector3D<float>));
+  float *ptrf = (float *)ptr;
+  for (int i = 0; i < pdata.size(); ++i) {
+    Vec3 v;
+    for (int c = 0; c < 3; ++c) {
+      v[c] = double(*ptrf);
+      ptrf++;
+    }
+    pdata[i] = v;
+  }
+}
+
+#endif  // NO_ZLIB!=1
+
+//*****************************************************************************
+// particles and particle data
+//*****************************************************************************
+
+static const int PartSysSize = sizeof(Vector3D<float>) + sizeof(int);
+
+void writeParticlesUni(const std::string &name, const BasicParticleSystem *parts)
+{
+  debMsg("writing particles " << parts->getName() << " to uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  char ID[5] = "PB02";
+  UniPartHeader head;
+  head.dim = parts->size();
+  Vec3i gridSize = parts->getParent()->getGridSize();
+  head.dimX = gridSize.x;
+  head.dimY = gridSize.y;
+  head.dimZ = gridSize.z;
+  head.bytesPerElement = PartSysSize;
+  head.elementType = 0;  // 0 for base data
+  snprintf(head.info, STR_LEN_PDATA, "%s", buildInfoString().c_str());
+  MuTime stamp;
+  head.timestamp = stamp.time;
+
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("can't open file " << name);
+
+  gzwrite(gzf, ID, 4);
+#  if FLOATINGPOINT_PRECISION != 1
+  // warning - hard coded conversion of byte size here...
+  gzwrite(gzf, &head, sizeof(UniPartHeader));
+  for (int i = 0; i < parts->size(); ++i) {
+    Vector3D<float> pos = toVec3f((*parts)[i].pos);
+    int flag = (*parts)[i].flag;
+    gzwrite(gzf, &pos, sizeof(Vector3D<float>));
+    gzwrite(gzf, &flag, sizeof(int));
+  }
+#  else
+  assertMsg(sizeof(BasicParticleData) == PartSysSize, "particle data size doesn't match");
+  gzwrite(gzf, &head, sizeof(UniPartHeader));
+  gzwrite(gzf, &((*parts)[0]), PartSysSize * head.dim);
+#  endif
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+void readParticlesUni(const std::string &name, BasicParticleSystem *parts)
+{
+  debMsg("reading particles " << parts->getName() << " from uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (!gzf)
+    errMsg("can't open file " << name);
+
+  char ID[5] = {0, 0, 0, 0, 0};
+  gzread(gzf, ID, 4);
+
+  if (!strcmp(ID, "PB01")) {
+    errMsg("particle uni file format v01 not supported anymore");
+  }
+  else if (!strcmp(ID, "PB02")) {
+    // current file format
+    UniPartHeader head;
+    assertMsg(gzread(gzf, &head, sizeof(UniPartHeader)) == sizeof(UniPartHeader),
+              "can't read file, no header present");
+    assertMsg(((head.bytesPerElement == PartSysSize) && (head.elementType == 0)),
+              "particle type doesn't match");
+
+    // re-allocate all data
+    parts->resizeAll(head.dim);
+
+    assertMsg(head.dim == parts->size(), "particle size doesn't match");
+#  if FLOATINGPOINT_PRECISION != 1
+    for (int i = 0; i < parts->size(); ++i) {
+      Vector3D<float> pos;
+      int flag;
+      gzread(gzf, &pos, sizeof(Vector3D<float>));
+      gzread(gzf, &flag, sizeof(int));
+      (*parts)[i].pos = toVec3d(pos);
+      (*parts)[i].flag = flag;
+    }
+#  else
+    assertMsg(sizeof(BasicParticleData) == PartSysSize, "particle data size doesn't match");
+    IndexInt bytes = PartSysSize * head.dim;
+    IndexInt readBytes = gzread(gzf, &(parts->getData()[0]), bytes);
+    assertMsg(bytes == readBytes,
+              "can't read uni file, stream length does not match, " << bytes << " vs "
+                                                                    << readBytes);
+#  endif
+
+    parts->transformPositions(Vec3i(head.dimX, head.dimY, head.dimZ),
+                              parts->getParent()->getGridSize());
+  }
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+template<class T> void writePdataUni(const std::string &name, ParticleDataImpl<T> *pdata)
+{
+  debMsg("writing particle data " << pdata->getName() << " to uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  char ID[5] = "PD01";
+  UniPartHeader head;
+  head.dim = pdata->size();
+  Vec3i gridSize = pdata->getParent()->getGridSize();
+  head.dimX = gridSize.x;
+  head.dimY = gridSize.y;
+  head.dimZ = gridSize.z;
+  head.bytesPerElement = sizeof(T);
+  head.elementType = 1;  // 1 for particle data, todo - add sub types?
+  snprintf(head.info, STR_LEN_PDATA, "%s", buildInfoString().c_str());
+  MuTime stamp;
+  head.timestamp = stamp.time;
+
+  gzFile gzf = gzopen(name.c_str(), "wb1");  // do some compression
+  if (!gzf)
+    errMsg("can't open file " << name);
+  gzwrite(gzf, ID, 4);
+
+#  if FLOATINGPOINT_PRECISION != 1
+  // always write float values, even if compiled with double precision (as for grids)
+  ParticleDataImpl<T> temp(pdata->getParent());
+  temp.resize(pdata->size());
+  pdataConvertWrite(gzf, *pdata, &(temp[0]), head);
+#  else
+  gzwrite(gzf, &head, sizeof(UniPartHeader));
+  gzwrite(gzf, &(pdata->get(0)), sizeof(T) * head.dim);
+#  endif
+  gzclose(gzf);
+
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+};
+
+template<class T> void readPdataUni(const std::string &name, ParticleDataImpl<T> *pdata)
+{
+  debMsg("reading particle data " << pdata->getName() << " from uni file " << name, 1);
+
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "rb");
+  if (!gzf)
+    errMsg("can't open file " << name);
+
+  char ID[5] = {0, 0, 0, 0, 0};
+  gzread(gzf, ID, 4);
+
+  if (!strcmp(ID, "PD01")) {
+    UniPartHeader head;
+    assertMsg(gzread(gzf, &head, sizeof(UniPartHeader)) == sizeof(UniPartHeader),
+              "can't read file, no header present");
+    assertMsg(head.dim == pdata->size(), "pdata size doesn't match");
+#  if FLOATINGPOINT_PRECISION != 1
+    ParticleDataImpl<T> temp(pdata->getParent());
+    temp.resize(pdata->size());
+    pdataReadConvert<T>(gzf, *pdata, &(temp[0]), head.bytesPerElement);
+#  else
+    assertMsg(((head.bytesPerElement == sizeof(T)) && (head.elementType == 1)),
+              "pdata type doesn't match");
+    IndexInt bytes = sizeof(T) * head.dim;
+    IndexInt readBytes = gzread(gzf, &(pdata->get(0)), sizeof(T) * head.dim);
+    assertMsg(bytes == readBytes,
+              "can't read uni file, stream length does not match, " << bytes << " vs "
+                                                                    << readBytes);
+#  endif
+  }
+  gzclose(gzf);
+#else
+  debMsg("file format not supported without zlib", 1);
+#endif
+}
+
+// explicit instantiation
+template void writePdataUni<int>(const std::string &name, ParticleDataImpl<int> *pdata);
+template void writePdataUni<Real>(const std::string &name, ParticleDataImpl<Real> *pdata);
+template void writePdataUni<Vec3>(const std::string &name, ParticleDataImpl<Vec3> *pdata);
+template void readPdataUni<int>(const std::string &name, ParticleDataImpl<int> *pdata);
+template void readPdataUni<Real>(const std::string &name, ParticleDataImpl<Real> *pdata);
+template void readPdataUni<Vec3>(const std::string &name, ParticleDataImpl<Vec3> *pdata);
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/fileio/mantaio.h b/extern/mantaflow/preprocessed/fileio/mantaio.h
new file mode 100644
index 00000000000..8bb0a5af6a4
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fileio/mantaio.h
@@ -0,0 +1,81 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Loading and writing grids and meshes to disk
+ *
+ ******************************************************************************/
+
+#ifndef _FILEIO_H
+#define _FILEIO_H
+
+#include <string>
+
+namespace Manta {
+
+// forward decl.
+class Mesh;
+class FlagGrid;
+template<class T> class Grid;
+template<class T> class Grid4d;
+class BasicParticleSystem;
+template<class T> class ParticleDataImpl;
+template<class T> class MeshDataImpl;
+
+void writeObjFile(const std::string &name, Mesh *mesh);
+void writeBobjFile(const std::string &name, Mesh *mesh);
+void readObjFile(const std::string &name, Mesh *mesh, bool append);
+void readBobjFile(const std::string &name, Mesh *mesh, bool append);
+
+template<class T> void writeGridRaw(const std::string &name, Grid<T> *grid);
+template<class T> void writeGridUni(const std::string &name, Grid<T> *grid);
+template<class T> void writeGridVol(const std::string &name, Grid<T> *grid);
+template<class T> void writeGridTxt(const std::string &name, Grid<T> *grid);
+
+#if OPENVDB == 1
+template<class T> void writeGridVDB(const std::string &name, Grid<T> *grid);
+template<class T> void readGridVDB(const std::string &name, Grid<T> *grid);
+#endif  // OPENVDB==1
+template<class T> void writeGridNumpy(const std::string &name, Grid<T> *grid);
+template<class T> void readGridNumpy(const std::string &name, Grid<T> *grid);
+
+template<class T> void readGridUni(const std::string &name, Grid<T> *grid);
+template<class T> void readGridRaw(const std::string &name, Grid<T> *grid);
+template<class T> void readGridVol(const std::string &name, Grid<T> *grid);
+
+template<class T> void writeGrid4dUni(const std::string &name, Grid4d<T> *grid);
+template<class T>
+void readGrid4dUni(const std::string &name,
+                   Grid4d<T> *grid,
+                   int readTslice = -1,
+                   Grid4d<T> *slice = NULL,
+                   void **fileHandle = NULL);
+void readGrid4dUniCleanup(void **fileHandle);
+template<class T> void writeGrid4dRaw(const std::string &name, Grid4d<T> *grid);
+template<class T> void readGrid4dRaw(const std::string &name, Grid4d<T> *grid);
+
+void writeParticlesUni(const std::string &name, const BasicParticleSystem *parts);
+void readParticlesUni(const std::string &name, BasicParticleSystem *parts);
+
+template<class T> void writePdataUni(const std::string &name, ParticleDataImpl<T> *pdata);
+template<class T> void readPdataUni(const std::string &name, ParticleDataImpl<T> *pdata);
+
+template<class T> void writeMdataUni(const std::string &name, MeshDataImpl<T> *mdata);
+template<class T> void readMdataUni(const std::string &name, MeshDataImpl<T> *mdata);
+
+void getUniFileSize(
+    const std::string &name, int &x, int &y, int &z, int *t = NULL, std::string *info = NULL);
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/fileio/mantaio.h.reg.cpp b/extern/mantaflow/preprocessed/fileio/mantaio.h.reg.cpp
new file mode 100644
index 00000000000..6520786181e
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fileio/mantaio.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "fileio/mantaio.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_18()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/fluidsolver.cpp b/extern/mantaflow/preprocessed/fluidsolver.cpp
new file mode 100644
index 00000000000..814d5444b15
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fluidsolver.cpp
@@ -0,0 +1,397 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Main class for the fluid solver
+ *
+ ******************************************************************************/
+
+#include "fluidsolver.h"
+#include "grid.h"
+#include <sstream>
+#include <fstream>
+
+using namespace std;
+namespace Manta {
+
+//******************************************************************************
+// Gridstorage-related members
+
+template<class T> void FluidSolver::GridStorage<T>::free()
+{
+  if (used != 0)
+    errMsg("can't clean grid cache, some grids are still in use");
+  for (size_t i = 0; i < grids.size(); i++)
+    delete[] grids[i];
+  grids.clear();
+}
+template<class T> T *FluidSolver::GridStorage<T>::get(Vec3i size)
+{
+  if ((int)grids.size() <= used) {
+    debMsg("FluidSolver::GridStorage::get Allocating new " << size.x << "," << size.y << ","
+                                                           << size.z << " ",
+           3);
+    grids.push_back(new T[(long long)(size.x) * size.y * size.z]);
+  }
+  if (used > 200)
+    errMsg("too many temp grids used -- are they released properly ?");
+  return grids[used++];
+}
+template<class T> void FluidSolver::GridStorage<T>::release(T *ptr)
+{
+  // rewrite pointer, as it may have changed due to swap operations
+  used--;
+  if (used < 0)
+    errMsg("temp grid inconsistency");
+  grids[used] = ptr;
+}
+
+template<> int *FluidSolver::getGridPointer<int>()
+{
+  return mGridsInt.get(mGridSize);
+}
+template<> Real *FluidSolver::getGridPointer<Real>()
+{
+  return mGridsReal.get(mGridSize);
+}
+template<> Vec3 *FluidSolver::getGridPointer<Vec3>()
+{
+  return mGridsVec.get(mGridSize);
+}
+template<> Vec4 *FluidSolver::getGridPointer<Vec4>()
+{
+  return mGridsVec4.get(mGridSize);
+}
+template<> void FluidSolver::freeGridPointer<int>(int *ptr)
+{
+  mGridsInt.release(ptr);
+}
+template<> void FluidSolver::freeGridPointer<Real>(Real *ptr)
+{
+  mGridsReal.release(ptr);
+}
+template<> void FluidSolver::freeGridPointer<Vec3>(Vec3 *ptr)
+{
+  mGridsVec.release(ptr);
+}
+template<> void FluidSolver::freeGridPointer<Vec4>(Vec4 *ptr)
+{
+  mGridsVec4.release(ptr);
+}
+
+// 4d data (work around for now, convert to 1d length)
+
+template<> int *FluidSolver::getGrid4dPointer<int>()
+{
+  return mGrids4dInt.get(Vec3i(mGridSize[0] * mGridSize[1], mGridSize[2], mFourthDim));
+}
+template<> Real *FluidSolver::getGrid4dPointer<Real>()
+{
+  return mGrids4dReal.get(Vec3i(mGridSize[0] * mGridSize[1], mGridSize[2], mFourthDim));
+}
+template<> Vec3 *FluidSolver::getGrid4dPointer<Vec3>()
+{
+  return mGrids4dVec.get(Vec3i(mGridSize[0] * mGridSize[1], mGridSize[2], mFourthDim));
+}
+template<> Vec4 *FluidSolver::getGrid4dPointer<Vec4>()
+{
+  return mGrids4dVec4.get(Vec3i(mGridSize[0] * mGridSize[1], mGridSize[2], mFourthDim));
+}
+template<> void FluidSolver::freeGrid4dPointer<int>(int *ptr)
+{
+  mGrids4dInt.release(ptr);
+}
+template<> void FluidSolver::freeGrid4dPointer<Real>(Real *ptr)
+{
+  mGrids4dReal.release(ptr);
+}
+template<> void FluidSolver::freeGrid4dPointer<Vec3>(Vec3 *ptr)
+{
+  mGrids4dVec.release(ptr);
+}
+template<> void FluidSolver::freeGrid4dPointer<Vec4>(Vec4 *ptr)
+{
+  mGrids4dVec4.release(ptr);
+}
+
+//******************************************************************************
+// FluidSolver members
+
+FluidSolver::FluidSolver(Vec3i gridsize, int dim, int fourthDim)
+    : PbClass(this),
+      mDt(1.0),
+      mTimeTotal(0.),
+      mFrame(0),
+      mCflCond(1000),
+      mDtMin(1.),
+      mDtMax(1.),
+      mFrameLength(1.),
+      mGridSize(gridsize),
+      mDim(dim),
+      mTimePerFrame(0.),
+      mLockDt(false),
+      mFourthDim(fourthDim)
+{
+  if (dim == 4 && mFourthDim > 0)
+    errMsg("Don't create 4D solvers, use 3D with fourth-dim parameter >0 instead.");
+  assertMsg(dim == 2 || dim == 3, "Only 2D and 3D solvers allowed.");
+  assertMsg(dim != 2 || gridsize.z == 1, "Trying to create 2D solver with size.z != 1");
+}
+
+FluidSolver::~FluidSolver()
+{
+  mGridsInt.free();
+  mGridsReal.free();
+  mGridsVec.free();
+  mGridsVec4.free();
+
+  mGrids4dInt.free();
+  mGrids4dReal.free();
+  mGrids4dVec.free();
+  mGrids4dVec4.free();
+}
+
+PbClass *FluidSolver::create(PbType t, PbTypeVec T, const string &name)
+{
+#if NOPYTHON != 1
+  _args.add("nocheck", true);
+  if (t.str() == "")
+    errMsg(
+        "Need to specify object type. Use e.g. Solver.create(FlagGrid, ...) or "
+        "Solver.create(type=FlagGrid, ...)");
+
+  PbClass *ret = PbClass::createPyObject(t.str() + T.str(), name, _args, this);
+#else
+  PbClass *ret = NULL;
+#endif
+  return ret;
+}
+
+void FluidSolver::step()
+{
+  // update simulation time with adaptive time stepping
+  // (use eps value to prevent roundoff errors)
+  mTimePerFrame += mDt;
+  mTimeTotal += mDt;
+
+  if ((mTimePerFrame + VECTOR_EPSILON) > mFrameLength) {
+    mFrame++;
+
+    // re-calc total time, prevent drift...
+    mTimeTotal = (double)mFrame * mFrameLength;
+    mTimePerFrame = 0.;
+    mLockDt = false;
+  }
+
+  updateQtGui(true, mFrame, mTimeTotal, "FluidSolver::step");
+}
+
+void FluidSolver::printMemInfo()
+{
+  std::ostringstream msg;
+  msg << "Allocated grids: int " << mGridsInt.used << "/" << mGridsInt.grids.size() << ", ";
+  msg << "                 real " << mGridsReal.used << "/" << mGridsReal.grids.size() << ", ";
+  msg << "                 vec3 " << mGridsVec.used << "/" << mGridsVec.grids.size() << ". ";
+  msg << "                 vec4 " << mGridsVec4.used << "/" << mGridsVec4.grids.size() << ". ";
+  if (supports4D()) {
+    msg << "Allocated 4d grids: int " << mGrids4dInt.used << "/" << mGrids4dInt.grids.size()
+        << ", ";
+    msg << "                    real " << mGrids4dReal.used << "/" << mGrids4dReal.grids.size()
+        << ", ";
+    msg << "                    vec3 " << mGrids4dVec.used << "/" << mGrids4dVec.grids.size()
+        << ". ";
+    msg << "                    vec4 " << mGrids4dVec4.used << "/" << mGrids4dVec4.grids.size()
+        << ". ";
+  }
+  printf("%s\n", msg.str().c_str());
+}
+
+//! warning, uses 10^-4 epsilon values, thus only use around "regular" FPS time scales, e.g. 30
+//! frames per time unit pass max magnitude of current velocity as maxvel, not yet scaled by dt!
+void FluidSolver::adaptTimestep(Real maxVel)
+{
+  const Real mvt = maxVel * mDt;
+  if (!mLockDt) {
+    // calculate current timestep from maxvel, clamp range
+    mDt = std::max(std::min(mDt * (Real)(mCflCond / (mvt + 1e-05)), mDtMax), mDtMin);
+    if ((mTimePerFrame + mDt * 1.05) > mFrameLength) {
+      // within 5% of full step? add epsilon to prevent roundoff errors...
+      mDt = (mFrameLength - mTimePerFrame) + 1e-04;
+    }
+    else if ((mTimePerFrame + mDt + mDtMin) > mFrameLength ||
+             (mTimePerFrame + (mDt * 1.25)) > mFrameLength) {
+      // avoid tiny timesteps and strongly varying ones, do 2 medium size ones if necessary...
+      mDt = (mFrameLength - mTimePerFrame + 1e-04) * 0.5;
+      mLockDt = true;
+    }
+  }
+  debMsg("Frame " << mFrame << ", max vel per step: " << mvt << " , dt: " << mDt << ", frame time "
+                  << mTimePerFrame << "/" << mFrameLength << "; lock:" << mLockDt,
+         2);
+
+  // sanity check
+  assertMsg((mDt > (mDtMin / 2.)), "Invalid dt encountered! Shouldnt happen...");
+}
+
+//******************************************************************************
+// Generic helpers (no PYTHON funcs in general.cpp, thus they're here...)
+
+//! helper to unify printing from python scripts and printing internal messages (optionally pass
+//! debug level to control amount of output)
+void mantaMsg(const std::string &out, int level = 1)
+{
+  debMsg(out, level);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mantaMsg", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const std::string &out = _args.get<std::string>("out", 0, &_lock);
+      int level = _args.getOpt<int>("level", 1, 1, &_lock);
+      _retval = getPyNone();
+      mantaMsg(out, level);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mantaMsg", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mantaMsg", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mantaMsg("", "mantaMsg", _W_0);
+extern "C" {
+void PbRegister_mantaMsg()
+{
+  KEEP_UNUSED(_RP_mantaMsg);
+}
+}
+
+std::string printBuildInfo()
+{
+  string infoString = buildInfoString();
+  debMsg("Build info: " << infoString.c_str() << " ", 1);
+  return infoString;
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "printBuildInfo", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      _retval = toPy(printBuildInfo());
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "printBuildInfo", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("printBuildInfo", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_printBuildInfo("", "printBuildInfo", _W_1);
+extern "C" {
+void PbRegister_printBuildInfo()
+{
+  KEEP_UNUSED(_RP_printBuildInfo);
+}
+}
+
+//! set debug level for messages (0 off, 1 regular, higher = more, up to 10)
+void setDebugLevel(int level = 1)
+{
+  gDebugLevel = level;
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setDebugLevel", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      int level = _args.getOpt<int>("level", 0, 1, &_lock);
+      _retval = getPyNone();
+      setDebugLevel(level);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setDebugLevel", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setDebugLevel", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setDebugLevel("", "setDebugLevel", _W_2);
+extern "C" {
+void PbRegister_setDebugLevel()
+{
+  KEEP_UNUSED(_RP_setDebugLevel);
+}
+}
+
+//! helper function to check for numpy compilation
+void assertNumpy()
+{
+#if NUMPY == 1
+  // all good, nothing to do...
+#else
+  errMsg("This scene requires numpy support. Enable compilation in cmake with \"-DNUMPY=1\" ");
+#endif
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "assertNumpy", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      _retval = getPyNone();
+      assertNumpy();
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "assertNumpy", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("assertNumpy", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_assertNumpy("", "assertNumpy", _W_3);
+extern "C" {
+void PbRegister_assertNumpy()
+{
+  KEEP_UNUSED(_RP_assertNumpy);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/fluidsolver.h b/extern/mantaflow/preprocessed/fluidsolver.h
new file mode 100644
index 00000000000..d01f87082b6
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fluidsolver.h
@@ -0,0 +1,395 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Main class for the fluid solver
+ *
+ ******************************************************************************/
+
+#ifndef _FLUIDSOLVER_H
+#define _FLUIDSOLVER_H
+
+#include "manta.h"
+#include "vectorbase.h"
+#include "vector4d.h"
+#include <vector>
+#include <map>
+
+namespace Manta {
+
+//! Encodes grid size, timstep etc.
+
+class FluidSolver : public PbClass {
+ public:
+  FluidSolver(Vec3i gridSize, int dim = 3, int fourthDim = -1);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "FluidSolver::FluidSolver", !noTiming);
+      {
+        ArgLocker _lock;
+        Vec3i gridSize = _args.get<Vec3i>("gridSize", 0, &_lock);
+        int dim = _args.getOpt<int>("dim", 1, 3, &_lock);
+        int fourthDim = _args.getOpt<int>("fourthDim", 2, -1, &_lock);
+        obj = new FluidSolver(gridSize, dim, fourthDim);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "FluidSolver::FluidSolver", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("FluidSolver::FluidSolver", e.what());
+      return -1;
+    }
+  }
+
+  virtual ~FluidSolver();
+
+  // accessors
+  Vec3i getGridSize()
+  {
+    return mGridSize;
+  }
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FluidSolver::getGridSize", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getGridSize());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FluidSolver::getGridSize", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FluidSolver::getGridSize", e.what());
+      return 0;
+    }
+  }
+
+  inline Real getDt() const
+  {
+    return mDt;
+  }
+  inline Real getDx() const
+  {
+    return 1.0 / mGridSize.max();
+  }
+  inline Real getTime() const
+  {
+    return mTimeTotal;
+  }
+
+  //! Check dimensionality
+  inline bool is2D() const
+  {
+    return mDim == 2;
+  }
+  //! Check dimensionality (3d or above)
+  inline bool is3D() const
+  {
+    return mDim == 3;
+  }
+
+  void printMemInfo();
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FluidSolver::printMemInfo", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->printMemInfo();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FluidSolver::printMemInfo", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FluidSolver::printMemInfo", e.what());
+      return 0;
+    }
+  }
+
+  //! Advance the solver one timestep, update GUI if present
+  void step();
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FluidSolver::step", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->step();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FluidSolver::step", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FluidSolver::step", e.what());
+      return 0;
+    }
+  }
+
+  //! Update the timestep size based on given maximal velocity magnitude
+  void adaptTimestep(Real maxVel);
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FluidSolver::adaptTimestep", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real maxVel = _args.get<Real>("maxVel", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->adaptTimestep(maxVel);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FluidSolver::adaptTimestep", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FluidSolver::adaptTimestep", e.what());
+      return 0;
+    }
+  }
+
+  //! create a object with the solver as its parent
+  PbClass *create(PbType type, PbTypeVec T = PbTypeVec(), const std::string &name = "");
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FluidSolver::create", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        PbType type = _args.get<PbType>("type", 0, &_lock);
+        PbTypeVec T = _args.getOpt<PbTypeVec>("T", 1, PbTypeVec(), &_lock);
+        const std::string &name = _args.getOpt<std::string>("name", 2, "", &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->create(type, T, name));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FluidSolver::create", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FluidSolver::create", e.what());
+      return 0;
+    }
+  }
+
+  // temp grid and plugin functions: you shouldn't call this manually
+  template<class T> T *getGridPointer();
+  template<class T> void freeGridPointer(T *ptr);
+
+  //! expose animation time to python
+  Real mDt;
+  static PyObject *_GET_mDt(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mDt);
+  }
+  static int _SET_mDt(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mDt = fromPy<Real>(val);
+    return 0;
+  }
+
+  Real mTimeTotal;
+  static PyObject *_GET_mTimeTotal(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mTimeTotal);
+  }
+  static int _SET_mTimeTotal(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mTimeTotal = fromPy<Real>(val);
+    return 0;
+  }
+
+  int mFrame;
+  static PyObject *_GET_mFrame(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mFrame);
+  }
+  static int _SET_mFrame(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mFrame = fromPy<int>(val);
+    return 0;
+  }
+
+  //! parameters for adaptive time stepping
+  Real mCflCond;
+  static PyObject *_GET_mCflCond(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mCflCond);
+  }
+  static int _SET_mCflCond(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mCflCond = fromPy<Real>(val);
+    return 0;
+  }
+
+  Real mDtMin;
+  static PyObject *_GET_mDtMin(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mDtMin);
+  }
+  static int _SET_mDtMin(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mDtMin = fromPy<Real>(val);
+    return 0;
+  }
+
+  Real mDtMax;
+  static PyObject *_GET_mDtMax(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mDtMax);
+  }
+  static int _SET_mDtMax(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mDtMax = fromPy<Real>(val);
+    return 0;
+  }
+
+  Real mFrameLength;
+  static PyObject *_GET_mFrameLength(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mFrameLength);
+  }
+  static int _SET_mFrameLength(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mFrameLength = fromPy<Real>(val);
+    return 0;
+  }
+
+  //! Per frame duration. Blender needs access in order to restore value in new solver object
+  Real mTimePerFrame;
+  static PyObject *_GET_mTimePerFrame(PyObject *self, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    return toPy(pbo->mTimePerFrame);
+  }
+  static int _SET_mTimePerFrame(PyObject *self, PyObject *val, void *cl)
+  {
+    FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(self));
+    pbo->mTimePerFrame = fromPy<Real>(val);
+    return 0;
+  }
+
+ protected:
+  Vec3i mGridSize;
+  const int mDim;
+  bool mLockDt;
+
+  //! subclass for managing grid memory
+  //! stored as a stack to allow fast allocation
+  template<class T> struct GridStorage {
+    GridStorage() : used(0)
+    {
+    }
+    T *get(Vec3i size);
+    void free();
+    void release(T *ptr);
+
+    std::vector<T *> grids;
+    int used;
+  };
+
+  //! memory for regular (3d) grids
+  GridStorage<int> mGridsInt;
+  GridStorage<Real> mGridsReal;
+  GridStorage<Vec3> mGridsVec;
+
+  //! 4d data section, only required for simulations working with space-time data
+
+ public:
+  //! 4D enabled? note, there's intentionally no "is4D" function, there are only 3D solvers that
+  //! also support 4D of a certain size
+  inline bool supports4D() const
+  {
+    return mFourthDim > 0;
+  }
+  //! fourth dimension size
+  inline int getFourthDim() const
+  {
+    return mFourthDim;
+  }
+  //! 4d data allocation
+  template<class T> T *getGrid4dPointer();
+  template<class T> void freeGrid4dPointer(T *ptr);
+
+ protected:
+  //! 4d size. Note - 4d is not treated like going from 2d to 3d! 4D grids are a separate data
+  //! type. Normally all grids are forced to have the same size. In contrast, a solver can create
+  //! and work with 3D as well as 4D grids, when fourth-dim is >0.
+  int mFourthDim;
+
+  //! 4d grid storage
+  GridStorage<Vec4> mGridsVec4;
+  GridStorage<int> mGrids4dInt;
+  GridStorage<Real> mGrids4dReal;
+  GridStorage<Vec3> mGrids4dVec;
+  GridStorage<Vec4> mGrids4dVec4;
+ public:
+  PbArgs _args;
+}
+#define _C_FluidSolver
+;
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/fluidsolver.h.reg.cpp b/extern/mantaflow/preprocessed/fluidsolver.h.reg.cpp
new file mode 100644
index 00000000000..764c7c59021
--- /dev/null
+++ b/extern/mantaflow/preprocessed/fluidsolver.h.reg.cpp
@@ -0,0 +1,70 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "fluidsolver.h"
+namespace Manta {
+#ifdef _C_FluidSolver
+static const Pb::Register _R_6("FluidSolver", "Solver", "PbClass");
+template<> const char *Namify<FluidSolver>::S = "FluidSolver";
+static const Pb::Register _R_7("FluidSolver", "FluidSolver", FluidSolver::_W_0);
+static const Pb::Register _R_8("FluidSolver", "getGridSize", FluidSolver::_W_1);
+static const Pb::Register _R_9("FluidSolver", "printMemInfo", FluidSolver::_W_2);
+static const Pb::Register _R_10("FluidSolver", "step", FluidSolver::_W_3);
+static const Pb::Register _R_11("FluidSolver", "adaptTimestep", FluidSolver::_W_4);
+static const Pb::Register _R_12("FluidSolver", "create", FluidSolver::_W_5);
+static const Pb::Register _R_13("FluidSolver",
+                                "timestep",
+                                FluidSolver::_GET_mDt,
+                                FluidSolver::_SET_mDt);
+static const Pb::Register _R_14("FluidSolver",
+                                "timeTotal",
+                                FluidSolver::_GET_mTimeTotal,
+                                FluidSolver::_SET_mTimeTotal);
+static const Pb::Register _R_15("FluidSolver",
+                                "frame",
+                                FluidSolver::_GET_mFrame,
+                                FluidSolver::_SET_mFrame);
+static const Pb::Register _R_16("FluidSolver",
+                                "cfl",
+                                FluidSolver::_GET_mCflCond,
+                                FluidSolver::_SET_mCflCond);
+static const Pb::Register _R_17("FluidSolver",
+                                "timestepMin",
+                                FluidSolver::_GET_mDtMin,
+                                FluidSolver::_SET_mDtMin);
+static const Pb::Register _R_18("FluidSolver",
+                                "timestepMax",
+                                FluidSolver::_GET_mDtMax,
+                                FluidSolver::_SET_mDtMax);
+static const Pb::Register _R_19("FluidSolver",
+                                "frameLength",
+                                FluidSolver::_GET_mFrameLength,
+                                FluidSolver::_SET_mFrameLength);
+static const Pb::Register _R_20("FluidSolver",
+                                "timePerFrame",
+                                FluidSolver::_GET_mTimePerFrame,
+                                FluidSolver::_SET_mTimePerFrame);
+#endif
+extern "C" {
+void PbRegister_file_6()
+{
+  KEEP_UNUSED(_R_6);
+  KEEP_UNUSED(_R_7);
+  KEEP_UNUSED(_R_8);
+  KEEP_UNUSED(_R_9);
+  KEEP_UNUSED(_R_10);
+  KEEP_UNUSED(_R_11);
+  KEEP_UNUSED(_R_12);
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/general.cpp b/extern/mantaflow/preprocessed/general.cpp
new file mode 100644
index 00000000000..266e6c8719d
--- /dev/null
+++ b/extern/mantaflow/preprocessed/general.cpp
@@ -0,0 +1,167 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2016 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Globally used macros and functions (e.g. time measurements),
+ * and doxygen documentation collection.
+ *
+ ******************************************************************************/
+
+/*! \mainpage Welcome to mantaflow!
+ *
+ *  Here you can find the auto-generated documentation of the mantaflow framework.
+ *
+ *  One of the most useful parts is probably the list of python functions, classes and the C++
+ * kernels. Those can be found found in the ''Modules'' section. For python functions the
+ * parameters (e.g. Grids, Real or int values) are automatically transferred to and from python.
+ * Thus, this list is a good reference how to call the functions used in the example scenes.
+ *
+ */
+
+// Define plugin documentation group
+// all kernels, plugin functions and classes will automatically be added to this group
+//! @defgroup Plugins Functions callable from Python
+//! @defgroup PyClasses Classes exposed to Python
+//! @defgroup Kernels Computation Kernels
+
+#include "general.h"
+#if defined(WIN32) || defined(_WIN32)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h>
+#  undef WIN32_LEAN_AND_MEAN
+#  undef NOMINMAX
+#else
+#  include <sys/time.h>
+#  include "gitinfo.h"
+#endif
+
+using namespace std;
+
+namespace Manta {
+
+int gDebugLevel = 1;
+
+void MuTime::get()
+{
+#if defined(WIN32) || defined(_WIN32)
+  LARGE_INTEGER liTimerFrequency;
+  QueryPerformanceFrequency(&liTimerFrequency);
+  LARGE_INTEGER liLastTime;
+  QueryPerformanceCounter(&liLastTime);
+  time = (INT)(((double)liLastTime.QuadPart / liTimerFrequency.QuadPart) * 1000);
+#else
+  struct timeval tv;
+  struct timezone tz;
+  tz.tz_minuteswest = 0;
+  tz.tz_dsttime = 0;
+  gettimeofday(&tv, &tz);
+  time = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
+#endif
+}
+
+MuTime MuTime::update()
+{
+  MuTime o = *this;
+  get();
+  return *this - o;
+}
+
+string MuTime::toString()
+{
+  stringstream ss;
+  ss << *this;
+  return ss.str();
+}
+
+ostream &operator<<(ostream &os, const MuTime &t)
+{
+  unsigned long ms = (unsigned long)((double)t.time / (60.0 * 1000.0));
+  unsigned long ss = (unsigned long)(((double)t.time / 1000.0) - ((double)ms * 60.0));
+  int ps = (int)(((double)t.time - (double)ss * 1000.0) / 1.0);
+
+  if (ms > 0) {
+    os << ms << "m" << ss << "s";
+  }
+  else {
+    if (ps > 0) {
+      os << ss << ".";
+      if (ps < 10) {
+        os << "0";
+      }
+      if (ps < 100) {
+        os << "0";
+      }
+      os << ps << "s";
+    }
+    else {
+      os << ss << "s";
+    }
+  }
+  return os;
+}
+
+//! print info about this mantaflow build, used eg by printBuildInfo in fluidsolver.cpp
+std::string buildInfoString()
+{
+  std::ostringstream infoStr;
+#ifndef MANTAVERSION
+#  define MANTAVERSION "<unknown-version>"
+#endif
+  infoStr << "mantaflow " << MANTAVERSION;
+
+  // os
+#if defined(WIN32) || defined(_WIN32)
+  infoStr << " win";
+#endif
+#ifdef __APPLE__
+  infoStr << " mac";
+#endif
+#ifdef LINUX
+  infoStr << " linux";
+#endif
+
+  // 32/64 bit
+  if (sizeof(size_t) == 8)
+    infoStr << " 64bit";
+  else
+    infoStr << " 32bit";
+
+    // fp precision
+#if FLOATINGPOINT_PRECISION == 2
+  infoStr << " fp2";
+#else
+  infoStr << " fp1";
+#endif
+
+  // other compile switches
+#ifdef DEBUG
+  infoStr << " debug";
+#endif
+#ifdef OPENMP
+  infoStr << " omp";
+#endif
+
+  // repository info (git commit id)
+#ifndef MANTA_GIT_VERSION
+#  define MANTA_GIT_VERSION "<unknown-commit>"
+#endif
+  infoStr << " " << MANTA_GIT_VERSION;
+
+  infoStr << " from " << __DATE__ << ", " << __TIME__;
+  return infoStr.str();
+}
+
+//! note - generic PYTHON helpers in fluidsolver.cpp , no python bindings here
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/general.h b/extern/mantaflow/preprocessed/general.h
new file mode 100644
index 00000000000..7a840517cef
--- /dev/null
+++ b/extern/mantaflow/preprocessed/general.h
@@ -0,0 +1,247 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Globally used macros and functions
+ *
+ ******************************************************************************/
+
+#ifndef _GENERAL_H
+#define _GENERAL_H
+
+#include <iostream>
+#include <sstream>
+#include <cmath>
+#include <algorithm>
+
+namespace Manta {
+
+// ui data exchange
+#ifdef GUI
+// defined in qtmain.cpp
+extern void updateQtGui(bool full, int frame, float time, const std::string &curPlugin);
+#else
+// dummy function if GUI is not enabled
+inline void updateQtGui(bool full, int frame, float time, const std::string &curPlugin)
+{
+}
+#endif
+
+// activate debug mode if _DEBUG is defined (eg for windows)
+#ifndef DEBUG
+#  ifdef _DEBUG
+#    define DEBUG 1
+#  endif  // _DEBUG
+#endif    // DEBUG
+
+// Standard exception
+class Error : public std::exception {
+ public:
+  Error(const std::string &s) : mS(s)
+  {
+#ifdef DEBUG
+    // print error
+    std::cerr << "Aborting: " << s << " \n";
+    // then force immedieate crash in debug mode
+    *(volatile int *)(0) = 1;
+#endif
+  }
+  virtual ~Error() throw()
+  {
+  }
+  virtual const char *what() const throw()
+  {
+    return mS.c_str();
+  }
+
+ private:
+  std::string mS;
+};
+
+// mark unused parameter variables
+#define unusedParameter(x) ((void)x)
+
+// Debug output functions and macros
+extern int gDebugLevel;
+
+#define MSGSTREAM \
+  std::ostringstream msg; \
+  msg.precision(7); \
+  msg.width(9);
+#define debMsg(mStr, level) \
+  if (_chklevel(level)) { \
+    MSGSTREAM; \
+    msg << mStr; \
+    std::cout << msg.str() << std::endl; \
+  }
+inline bool _chklevel(int level = 0)
+{
+  return gDebugLevel >= level;
+}
+
+// error and assertation macros
+#ifdef DEBUG
+#  define DEBUG_ONLY(a) a
+#else
+#  define DEBUG_ONLY(a)
+#endif
+#define throwError(msg) \
+  { \
+    std::ostringstream __s; \
+    __s << msg << std::endl << "Error raised in " << __FILE__ << ":" << __LINE__; \
+    throw Manta::Error(__s.str()); \
+  }
+#define errMsg(msg) throwError(msg);
+#define assertMsg(cond, msg) \
+  if (!(cond)) \
+  throwError(msg)
+#define assertDeb(cond, msg) DEBUG_ONLY(assertMsg(cond, msg))
+
+// for compatibility with blender, blender only defines WITH_FLUID, make sure we have "BLENDER"
+#ifndef BLENDER
+#  ifdef WITH_FLUID
+#    define BLENDER 1
+#  endif
+#endif
+
+// common type for indexing large grids
+typedef long long IndexInt;
+
+// template tricks
+template<typename T> struct remove_pointers {
+  typedef T type;
+};
+
+template<typename T> struct remove_pointers<T *> {
+  typedef T type;
+};
+
+template<typename T> struct remove_pointers<T &> {
+  typedef T type;
+};
+
+// Commonly used enums and types
+//! Timing class for preformance measuring
+struct MuTime {
+  MuTime()
+  {
+    get();
+  }
+  MuTime operator-(const MuTime &a)
+  {
+    MuTime b;
+    b.time = time - a.time;
+    return b;
+  };
+  MuTime operator+(const MuTime &a)
+  {
+    MuTime b;
+    b.time = time + a.time;
+    return b;
+  };
+  MuTime operator/(unsigned long a)
+  {
+    MuTime b;
+    b.time = time / a;
+    return b;
+  };
+  MuTime &operator+=(const MuTime &a)
+  {
+    time += a.time;
+    return *this;
+  }
+  MuTime &operator-=(const MuTime &a)
+  {
+    time -= a.time;
+    return *this;
+  }
+  MuTime &operator/=(unsigned long a)
+  {
+    time /= a;
+    return *this;
+  }
+  std::string toString();
+
+  void clear()
+  {
+    time = 0;
+  }
+  void get();
+  MuTime update();
+
+  unsigned long time;
+};
+std::ostream &operator<<(std::ostream &os, const MuTime &t);
+
+//! generate a string with infos about the current mantaflow build
+std::string buildInfoString();
+
+// Some commonly used math helpers
+template<class T> inline T square(T a)
+{
+  return a * a;
+}
+template<class T> inline T cubed(T a)
+{
+  return a * a * a;
+}
+
+template<class T> inline T clamp(const T &val, const T &vmin, const T &vmax)
+{
+  if (val < vmin)
+    return vmin;
+  if (val > vmax)
+    return vmax;
+  return val;
+}
+
+template<class T> inline T nmod(const T &a, const T &b);
+template<> inline int nmod(const int &a, const int &b)
+{
+  int c = a % b;
+  return (c < 0) ? (c + b) : c;
+}
+template<> inline float nmod(const float &a, const float &b)
+{
+  float c = std::fmod(a, b);
+  return (c < 0) ? (c + b) : c;
+}
+template<> inline double nmod(const double &a, const double &b)
+{
+  double c = std::fmod(a, b);
+  return (c < 0) ? (c + b) : c;
+}
+
+template<class T> inline T safeDivide(const T &a, const T &b);
+template<> inline int safeDivide<int>(const int &a, const int &b)
+{
+  return (b) ? (a / b) : a;
+}
+template<> inline float safeDivide<float>(const float &a, const float &b)
+{
+  return (b) ? (a / b) : a;
+}
+template<> inline double safeDivide<double>(const double &a, const double &b)
+{
+  return (b) ? (a / b) : a;
+}
+
+inline bool c_isnan(float c)
+{
+  volatile float d = c;
+  return d != d;
+}
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/general.h.reg.cpp b/extern/mantaflow/preprocessed/general.h.reg.cpp
new file mode 100644
index 00000000000..cab2c4782b0
--- /dev/null
+++ b/extern/mantaflow/preprocessed/general.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "general.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_1()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/gitinfo.h b/extern/mantaflow/preprocessed/gitinfo.h
new file mode 100644
index 00000000000..154f928dc2f
--- /dev/null
+++ b/extern/mantaflow/preprocessed/gitinfo.h
@@ -0,0 +1,3 @@
+
+
+#define MANTA_GIT_VERSION "commit 761849c592daaea320f9026768b5a0750528009c"
diff --git a/extern/mantaflow/preprocessed/grid.cpp b/extern/mantaflow/preprocessed/grid.cpp
new file mode 100644
index 00000000000..c21d56d8879
--- /dev/null
+++ b/extern/mantaflow/preprocessed/grid.cpp
@@ -0,0 +1,2939 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Grid representation
+ *
+ ******************************************************************************/
+
+#include "grid.h"
+#include "levelset.h"
+#include "kernel.h"
+#include "mantaio.h"
+#include <limits>
+#include <sstream>
+#include <cstring>
+
+#include "commonkernels.h"
+
+using namespace std;
+namespace Manta {
+
+//******************************************************************************
+// GridBase members
+
+GridBase::GridBase(FluidSolver *parent) : PbClass(parent), mType(TypeNone)
+{
+  checkParent();
+  m3D = getParent()->is3D();
+}
+
+//******************************************************************************
+// Grid<T> members
+
+// helpers to set type
+template<class T> inline GridBase::GridType typeList()
+{
+  return GridBase::TypeNone;
+}
+template<> inline GridBase::GridType typeList<Real>()
+{
+  return GridBase::TypeReal;
+}
+template<> inline GridBase::GridType typeList<int>()
+{
+  return GridBase::TypeInt;
+}
+template<> inline GridBase::GridType typeList<Vec3>()
+{
+  return GridBase::TypeVec3;
+}
+
+template<class T>
+Grid<T>::Grid(FluidSolver *parent, bool show) : GridBase(parent), externalData(false)
+{
+  mType = typeList<T>();
+  mSize = parent->getGridSize();
+  mData = parent->getGridPointer<T>();
+
+  mStrideZ = parent->is2D() ? 0 : (mSize.x * mSize.y);
+  mDx = 1.0 / mSize.max();
+  clear();
+  setHidden(!show);
+}
+
+template<class T>
+Grid<T>::Grid(FluidSolver *parent, T *data, bool show)
+    : GridBase(parent), mData(data), externalData(true)
+{
+  mType = typeList<T>();
+  mSize = parent->getGridSize();
+
+  mStrideZ = parent->is2D() ? 0 : (mSize.x * mSize.y);
+  mDx = 1.0 / mSize.max();
+
+  setHidden(!show);
+}
+
+template<class T> Grid<T>::Grid(const Grid<T> &a) : GridBase(a.getParent()), externalData(false)
+{
+  mSize = a.mSize;
+  mType = a.mType;
+  mStrideZ = a.mStrideZ;
+  mDx = a.mDx;
+  FluidSolver *gp = a.getParent();
+  mData = gp->getGridPointer<T>();
+  memcpy(mData, a.mData, sizeof(T) * a.mSize.x * a.mSize.y * a.mSize.z);
+}
+
+template<class T> Grid<T>::~Grid()
+{
+  if (!externalData) {
+    mParent->freeGridPointer<T>(mData);
+  }
+}
+
+template<class T> void Grid<T>::clear()
+{
+  memset(mData, 0, sizeof(T) * mSize.x * mSize.y * mSize.z);
+}
+
+template<class T> void Grid<T>::swap(Grid<T> &other)
+{
+  if (other.getSizeX() != getSizeX() || other.getSizeY() != getSizeY() ||
+      other.getSizeZ() != getSizeZ())
+    errMsg("Grid::swap(): Grid dimensions mismatch.");
+
+  if (externalData || other.externalData)
+    errMsg("Grid::swap(): Cannot swap if one grid stores externalData.");
+
+  T *dswap = other.mData;
+  other.mData = mData;
+  mData = dswap;
+}
+
+template<class T> void Grid<T>::load(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".raw")
+    readGridRaw(name, this);
+  else if (ext == ".uni")
+    readGridUni(name, this);
+  else if (ext == ".vol")
+    readGridVol(name, this);
+  else if (ext == ".npz")
+    readGridNumpy(name, this);
+#if OPENVDB == 1
+  else if (ext == ".vdb")
+    readGridVDB(name, this);
+#endif  // OPENVDB==1
+  else
+    errMsg("file '" + name + "' filetype not supported");
+}
+
+template<class T> void Grid<T>::save(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".raw")
+    writeGridRaw(name, this);
+  else if (ext == ".uni")
+    writeGridUni(name, this);
+  else if (ext == ".vol")
+    writeGridVol(name, this);
+#if OPENVDB == 1
+  else if (ext == ".vdb")
+    writeGridVDB(name, this);
+#endif  // OPENVDB==1
+  else if (ext == ".npz")
+    writeGridNumpy(name, this);
+  else if (ext == ".txt")
+    writeGridTxt(name, this);
+  else
+    errMsg("file '" + name + "' filetype not supported");
+}
+
+//******************************************************************************
+// Grid<T> operators
+
+//! Kernel: Compute min value of Real grid
+
+struct CompMinReal : public KernelBase {
+  CompMinReal(const Grid<Real> &val)
+      : KernelBase(&val, 0), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &val, Real &minVal)
+  {
+    if (val[idx] < minVal)
+      minVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMinReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMinReal(CompMinReal &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMinReal &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const Grid<Real> &val;
+  Real minVal;
+};
+
+//! Kernel: Compute max value of Real grid
+
+struct CompMaxReal : public KernelBase {
+  CompMaxReal(const Grid<Real> &val)
+      : KernelBase(&val, 0), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &val, Real &maxVal)
+  {
+    if (val[idx] > maxVal)
+      maxVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMaxReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMaxReal(CompMaxReal &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMaxReal &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const Grid<Real> &val;
+  Real maxVal;
+};
+
+//! Kernel: Compute min value of int grid
+
+struct CompMinInt : public KernelBase {
+  CompMinInt(const Grid<int> &val)
+      : KernelBase(&val, 0), val(val), minVal(std::numeric_limits<int>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<int> &val, int &minVal)
+  {
+    if (val[idx] < minVal)
+      minVal = val[idx];
+  }
+  inline operator int()
+  {
+    return minVal;
+  }
+  inline int &getRet()
+  {
+    return minVal;
+  }
+  inline const Grid<int> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<int> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMinInt ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMinInt(CompMinInt &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<int>::max())
+  {
+  }
+  void join(const CompMinInt &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const Grid<int> &val;
+  int minVal;
+};
+
+//! Kernel: Compute max value of int grid
+
+struct CompMaxInt : public KernelBase {
+  CompMaxInt(const Grid<int> &val)
+      : KernelBase(&val, 0), val(val), maxVal(-std::numeric_limits<int>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<int> &val, int &maxVal)
+  {
+    if (val[idx] > maxVal)
+      maxVal = val[idx];
+  }
+  inline operator int()
+  {
+    return maxVal;
+  }
+  inline int &getRet()
+  {
+    return maxVal;
+  }
+  inline const Grid<int> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<int> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMaxInt ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMaxInt(CompMaxInt &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<int>::max())
+  {
+  }
+  void join(const CompMaxInt &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const Grid<int> &val;
+  int maxVal;
+};
+
+//! Kernel: Compute min norm of vec grid
+
+struct CompMinVec : public KernelBase {
+  CompMinVec(const Grid<Vec3> &val)
+      : KernelBase(&val, 0), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Vec3> &val, Real &minVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s < minVal)
+      minVal = s;
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline const Grid<Vec3> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<Vec3> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMinVec ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMinVec(CompMinVec &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMinVec &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const Grid<Vec3> &val;
+  Real minVal;
+};
+
+//! Kernel: Compute max norm of vec grid
+
+struct CompMaxVec : public KernelBase {
+  CompMaxVec(const Grid<Vec3> &val)
+      : KernelBase(&val, 0), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Vec3> &val, Real &maxVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s > maxVal)
+      maxVal = s;
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline const Grid<Vec3> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid<Vec3> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMaxVec ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMaxVec(CompMaxVec &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMaxVec &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const Grid<Vec3> &val;
+  Real maxVal;
+};
+
+template<class T> Grid<T> &Grid<T>::copyFrom(const Grid<T> &a, bool copyType)
+{
+  assertMsg(a.mSize.x == mSize.x && a.mSize.y == mSize.y && a.mSize.z == mSize.z,
+            "different grid resolutions " << a.mSize << " vs " << this->mSize);
+  memcpy(mData, a.mData, sizeof(T) * mSize.x * mSize.y * mSize.z);
+  if (copyType)
+    mType = a.mType;  // copy type marker
+  return *this;
+}
+/*template<class T> Grid<T>& Grid<T>::operator= (const Grid<T>& a) {
+  note: do not use , use copyFrom instead
+}*/
+
+template<class T> struct knGridSetConstReal : public KernelBase {
+  knGridSetConstReal(Grid<T> &me, T val) : KernelBase(&me, 0), me(me), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, T val) const
+  {
+    me[idx] = val;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline T &getArg1()
+  {
+    return val;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridSetConstReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, val);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  T val;
+};
+template<class T> struct knGridAddConstReal : public KernelBase {
+  knGridAddConstReal(Grid<T> &me, T val) : KernelBase(&me, 0), me(me), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, T val) const
+  {
+    me[idx] += val;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline T &getArg1()
+  {
+    return val;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridAddConstReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, val);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  T val;
+};
+template<class T> struct knGridMultConst : public KernelBase {
+  knGridMultConst(Grid<T> &me, T val) : KernelBase(&me, 0), me(me), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, T val) const
+  {
+    me[idx] *= val;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline T &getArg1()
+  {
+    return val;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridMultConst ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, val);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  T val;
+};
+
+template<class T> struct knGridSafeDiv : public KernelBase {
+  knGridSafeDiv(Grid<T> &me, const Grid<T> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const Grid<T> &other) const
+  {
+    me[idx] = safeDivide(me[idx], other[idx]);
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<T> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridSafeDiv ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<T> &other;
+};
+// KERNEL(idx) template<class T> void gridSafeDiv (Grid<T>& me, const Grid<T>& other) { me[idx] =
+// safeDivide(me[idx], other[idx]); }
+
+template<class T> struct knGridClamp : public KernelBase {
+  knGridClamp(Grid<T> &me, const T &min, const T &max)
+      : KernelBase(&me, 0), me(me), min(min), max(max)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const T &min, const T &max) const
+  {
+    me[idx] = clamp(me[idx], min, max);
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const T &getArg1()
+  {
+    return min;
+  }
+  typedef T type1;
+  inline const T &getArg2()
+  {
+    return max;
+  }
+  typedef T type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridClamp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, min, max);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const T &min;
+  const T &max;
+};
+
+template<typename T> inline void stomp(T &v, const T &th)
+{
+  if (v < th)
+    v = 0;
+}
+template<> inline void stomp<Vec3>(Vec3 &v, const Vec3 &th)
+{
+  if (v[0] < th[0])
+    v[0] = 0;
+  if (v[1] < th[1])
+    v[1] = 0;
+  if (v[2] < th[2])
+    v[2] = 0;
+}
+template<class T> struct knGridStomp : public KernelBase {
+  knGridStomp(Grid<T> &me, const T &threshold) : KernelBase(&me, 0), me(me), threshold(threshold)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const T &threshold) const
+  {
+    stomp(me[idx], threshold);
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const T &getArg1()
+  {
+    return threshold;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridStomp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, threshold);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const T &threshold;
+};
+
+template<class T> struct knPermuteAxes : public KernelBase {
+  knPermuteAxes(Grid<T> &self, Grid<T> &target, int axis0, int axis1, int axis2)
+      : KernelBase(&self, 0), self(self), target(target), axis0(axis0), axis1(axis1), axis2(axis2)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, Grid<T> &self, Grid<T> &target, int axis0, int axis1, int axis2) const
+  {
+    int i0 = axis0 == 0 ? i : (axis0 == 1 ? j : k);
+    int i1 = axis1 == 0 ? i : (axis1 == 1 ? j : k);
+    int i2 = axis2 == 0 ? i : (axis2 == 1 ? j : k);
+    target(i0, i1, i2) = self(i, j, k);
+  }
+  inline Grid<T> &getArg0()
+  {
+    return self;
+  }
+  typedef Grid<T> type0;
+  inline Grid<T> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<T> type1;
+  inline int &getArg2()
+  {
+    return axis0;
+  }
+  typedef int type2;
+  inline int &getArg3()
+  {
+    return axis1;
+  }
+  typedef int type3;
+  inline int &getArg4()
+  {
+    return axis2;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPermuteAxes ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, self, target, axis0, axis1, axis2);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, self, target, axis0, axis1, axis2);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> &self;
+  Grid<T> &target;
+  int axis0;
+  int axis1;
+  int axis2;
+};
+
+template<class T> Grid<T> &Grid<T>::safeDivide(const Grid<T> &a)
+{
+  knGridSafeDiv<T>(*this, a);
+  return *this;
+}
+
+template<class T> int Grid<T>::getGridType()
+{
+  return static_cast<int>(mType);
+}
+
+template<class T> void Grid<T>::add(const Grid<T> &a)
+{
+  gridAdd<T, T>(*this, a);
+}
+template<class T> void Grid<T>::sub(const Grid<T> &a)
+{
+  gridSub<T, T>(*this, a);
+}
+template<class T> void Grid<T>::addScaled(const Grid<T> &a, const T &factor)
+{
+  gridScaledAdd<T, T>(*this, a, factor);
+}
+template<class T> void Grid<T>::setConst(T a)
+{
+  knGridSetConstReal<T>(*this, T(a));
+}
+template<class T> void Grid<T>::addConst(T a)
+{
+  knGridAddConstReal<T>(*this, T(a));
+}
+template<class T> void Grid<T>::multConst(T a)
+{
+  knGridMultConst<T>(*this, a);
+}
+
+template<class T> void Grid<T>::mult(const Grid<T> &a)
+{
+  gridMult<T, T>(*this, a);
+}
+
+template<class T> void Grid<T>::clamp(Real min, Real max)
+{
+  knGridClamp<T>(*this, T(min), T(max));
+}
+template<class T> void Grid<T>::stomp(const T &threshold)
+{
+  knGridStomp<T>(*this, threshold);
+}
+template<class T> void Grid<T>::permuteAxes(int axis0, int axis1, int axis2)
+{
+  if (axis0 == axis1 || axis0 == axis2 || axis1 == axis2 || axis0 > 2 || axis1 > 2 || axis2 > 2 ||
+      axis0 < 0 || axis1 < 0 || axis2 < 0)
+    return;
+  Vec3i size = mParent->getGridSize();
+  assertMsg(mParent->is2D() ? size.x == size.y : size.x == size.y && size.y == size.z,
+            "Grid must be cubic!");
+  Grid<T> tmp(mParent);
+  knPermuteAxes<T>(*this, tmp, axis0, axis1, axis2);
+  this->swap(tmp);
+}
+template<class T>
+void Grid<T>::permuteAxesCopyToGrid(int axis0, int axis1, int axis2, Grid<T> &out)
+{
+  if (axis0 == axis1 || axis0 == axis2 || axis1 == axis2 || axis0 > 2 || axis1 > 2 || axis2 > 2 ||
+      axis0 < 0 || axis1 < 0 || axis2 < 0)
+    return;
+  assertMsg(this->getGridType() == out.getGridType(), "Grids must have same data type!");
+  Vec3i size = mParent->getGridSize();
+  Vec3i sizeTarget = out.getParent()->getGridSize();
+  assertMsg(sizeTarget[axis0] == size[0] && sizeTarget[axis1] == size[1] &&
+                sizeTarget[axis2] == size[2],
+            "Permuted grids must have the same dimensions!");
+  knPermuteAxes<T>(*this, out, axis0, axis1, axis2);
+}
+
+template<> Real Grid<Real>::getMax() const
+{
+  return CompMaxReal(*this);
+}
+template<> Real Grid<Real>::getMin() const
+{
+  return CompMinReal(*this);
+}
+template<> Real Grid<Real>::getMaxAbs() const
+{
+  Real amin = CompMinReal(*this);
+  Real amax = CompMaxReal(*this);
+  return max(fabs(amin), fabs(amax));
+}
+template<> Real Grid<Vec3>::getMax() const
+{
+  return sqrt(CompMaxVec(*this));
+}
+template<> Real Grid<Vec3>::getMin() const
+{
+  return sqrt(CompMinVec(*this));
+}
+template<> Real Grid<Vec3>::getMaxAbs() const
+{
+  return sqrt(CompMaxVec(*this));
+}
+template<> Real Grid<int>::getMax() const
+{
+  return (Real)CompMaxInt(*this);
+}
+template<> Real Grid<int>::getMin() const
+{
+  return (Real)CompMinInt(*this);
+}
+template<> Real Grid<int>::getMaxAbs() const
+{
+  int amin = CompMinInt(*this);
+  int amax = CompMaxInt(*this);
+  return max(fabs((Real)amin), fabs((Real)amax));
+}
+template<class T> std::string Grid<T>::getDataPointer()
+{
+  std::ostringstream out;
+  out << mData;
+  return out.str();
+}
+
+// L1 / L2 functions
+
+//! calculate L1 norm for whole grid with non-parallelized loop
+template<class GRID> Real loop_calcL1Grid(const GRID &grid, int bnd)
+{
+  double accu = 0.;
+  FOR_IJKT_BND(grid, bnd)
+  {
+    accu += norm(grid(i, j, k, t));
+  }
+  return (Real)accu;
+}
+
+//! calculate L2 norm for whole grid with non-parallelized loop
+// note - kernels "could" be used here, but they can't be templated at the moment (also, that would
+// mean the bnd parameter is fixed)
+template<class GRID> Real loop_calcL2Grid(const GRID &grid, int bnd)
+{
+  double accu = 0.;
+  FOR_IJKT_BND(grid, bnd)
+  {
+    accu += normSquare(grid(i, j, k, t));  // supported for real and vec3,4 types
+  }
+  return (Real)sqrt(accu);
+}
+
+//! compute L1 norm of whole grid content (note, not parallel at the moment)
+template<class T> Real Grid<T>::getL1(int bnd)
+{
+  return loop_calcL1Grid<Grid<T>>(*this, bnd);
+}
+//! compute L2 norm of whole grid content (note, not parallel at the moment)
+template<class T> Real Grid<T>::getL2(int bnd)
+{
+  return loop_calcL2Grid<Grid<T>>(*this, bnd);
+}
+
+struct knCountCells : public KernelBase {
+  knCountCells(const FlagGrid &flags, int flag, int bnd, Grid<Real> *mask)
+      : KernelBase(&flags, 0), flags(flags), flag(flag), bnd(bnd), mask(mask), cnt(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const FlagGrid &flags, int flag, int bnd, Grid<Real> *mask, int &cnt)
+  {
+    if (mask)
+      (*mask)(i, j, k) = 0.;
+    if (bnd > 0 && (!flags.isInBounds(Vec3i(i, j, k), bnd)))
+      return;
+    if (flags(i, j, k) & flag) {
+      cnt++;
+      if (mask)
+        (*mask)(i, j, k) = 1.;
+    }
+  }
+  inline operator int()
+  {
+    return cnt;
+  }
+  inline int &getRet()
+  {
+    return cnt;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline int &getArg1()
+  {
+    return flag;
+  }
+  typedef int type1;
+  inline int &getArg2()
+  {
+    return bnd;
+  }
+  typedef int type2;
+  inline Grid<Real> *getArg3()
+  {
+    return mask;
+  }
+  typedef Grid<Real> type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCountCells ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, flag, bnd, mask, cnt);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, flag, bnd, mask, cnt);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_reduce(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  knCountCells(knCountCells &o, tbb::split)
+      : KernelBase(o), flags(o.flags), flag(o.flag), bnd(o.bnd), mask(o.mask), cnt(0)
+  {
+  }
+  void join(const knCountCells &o)
+  {
+    cnt += o.cnt;
+  }
+  const FlagGrid &flags;
+  int flag;
+  int bnd;
+  Grid<Real> *mask;
+  int cnt;
+};
+
+//! count number of cells of a certain type flag (can contain multiple bits, checks if any one of
+//! them is set - not all!)
+int FlagGrid::countCells(int flag, int bnd, Grid<Real> *mask)
+{
+  return knCountCells(*this, flag, bnd, mask);
+}
+
+// compute maximal diference of two cells in the grid
+// used for testing system
+
+Real gridMaxDiff(Grid<Real> &g1, Grid<Real> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJK(g1)
+  {
+    maxVal = std::max(maxVal, (double)fabs(g1(i, j, k) - g2(i, j, k)));
+  }
+  return maxVal;
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "gridMaxDiff", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &g1 = *_args.getPtr<Grid<Real>>("g1", 0, &_lock);
+      Grid<Real> &g2 = *_args.getPtr<Grid<Real>>("g2", 1, &_lock);
+      _retval = toPy(gridMaxDiff(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "gridMaxDiff", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("gridMaxDiff", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_gridMaxDiff("", "gridMaxDiff", _W_0);
+extern "C" {
+void PbRegister_gridMaxDiff()
+{
+  KEEP_UNUSED(_RP_gridMaxDiff);
+}
+}
+
+Real gridMaxDiffInt(Grid<int> &g1, Grid<int> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJK(g1)
+  {
+    maxVal = std::max(maxVal, (double)fabs((double)g1(i, j, k) - g2(i, j, k)));
+  }
+  return maxVal;
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "gridMaxDiffInt", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<int> &g1 = *_args.getPtr<Grid<int>>("g1", 0, &_lock);
+      Grid<int> &g2 = *_args.getPtr<Grid<int>>("g2", 1, &_lock);
+      _retval = toPy(gridMaxDiffInt(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "gridMaxDiffInt", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("gridMaxDiffInt", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_gridMaxDiffInt("", "gridMaxDiffInt", _W_1);
+extern "C" {
+void PbRegister_gridMaxDiffInt()
+{
+  KEEP_UNUSED(_RP_gridMaxDiffInt);
+}
+}
+
+Real gridMaxDiffVec3(Grid<Vec3> &g1, Grid<Vec3> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJK(g1)
+  {
+    // accumulate differences with double precision
+    // note - don't use norm here! should be as precise as possible...
+    double d = 0.;
+    for (int c = 0; c < 3; ++c) {
+      d += fabs((double)g1(i, j, k)[c] - (double)g2(i, j, k)[c]);
+    }
+    maxVal = std::max(maxVal, d);
+    // maxVal = std::max(maxVal, (double)fabs( norm(g1(i,j,k)-g2(i,j,k)) ));
+  }
+  return maxVal;
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "gridMaxDiffVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &g1 = *_args.getPtr<Grid<Vec3>>("g1", 0, &_lock);
+      Grid<Vec3> &g2 = *_args.getPtr<Grid<Vec3>>("g2", 1, &_lock);
+      _retval = toPy(gridMaxDiffVec3(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "gridMaxDiffVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("gridMaxDiffVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_gridMaxDiffVec3("", "gridMaxDiffVec3", _W_2);
+extern "C" {
+void PbRegister_gridMaxDiffVec3()
+{
+  KEEP_UNUSED(_RP_gridMaxDiffVec3);
+}
+}
+
+// simple helper functions to copy (convert) mac to vec3 , and levelset to real grids
+// (are assumed to be the same for running the test cases - in general they're not!)
+
+void copyMacToVec3(MACGrid &source, Grid<Vec3> &target)
+{
+  FOR_IJK(target)
+  {
+    target(i, j, k) = source(i, j, k);
+  }
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "copyMacToVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      _retval = getPyNone();
+      copyMacToVec3(source, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "copyMacToVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("copyMacToVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_copyMacToVec3("", "copyMacToVec3", _W_3);
+extern "C" {
+void PbRegister_copyMacToVec3()
+{
+  KEEP_UNUSED(_RP_copyMacToVec3);
+}
+}
+
+void convertMacToVec3(MACGrid &source, Grid<Vec3> &target)
+{
+  debMsg("Deprecated - do not use convertMacToVec3... use copyMacToVec3 instead", 1);
+  copyMacToVec3(source, target);
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "convertMacToVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      _retval = getPyNone();
+      convertMacToVec3(source, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "convertMacToVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("convertMacToVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_convertMacToVec3("", "convertMacToVec3", _W_4);
+extern "C" {
+void PbRegister_convertMacToVec3()
+{
+  KEEP_UNUSED(_RP_convertMacToVec3);
+}
+}
+
+//! vec3->mac grid conversion , but with full resampling
+void resampleVec3ToMac(Grid<Vec3> &source, MACGrid &target)
+{
+  FOR_IJK_BND(target, 1)
+  {
+    target(i, j, k)[0] = 0.5 * (source(i - 1, j, k)[0] + source(i, j, k))[0];
+    target(i, j, k)[1] = 0.5 * (source(i, j - 1, k)[1] + source(i, j, k))[1];
+    if (target.is3D()) {
+      target(i, j, k)[2] = 0.5 * (source(i, j, k - 1)[2] + source(i, j, k))[2];
+    }
+  }
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "resampleVec3ToMac", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
+      MACGrid &target = *_args.getPtr<MACGrid>("target", 1, &_lock);
+      _retval = getPyNone();
+      resampleVec3ToMac(source, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "resampleVec3ToMac", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("resampleVec3ToMac", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_resampleVec3ToMac("", "resampleVec3ToMac", _W_5);
+extern "C" {
+void PbRegister_resampleVec3ToMac()
+{
+  KEEP_UNUSED(_RP_resampleVec3ToMac);
+}
+}
+
+//! mac->vec3 grid conversion , with full resampling
+void resampleMacToVec3(MACGrid &source, Grid<Vec3> &target)
+{
+  FOR_IJK_BND(target, 1)
+  {
+    target(i, j, k) = source.getCentered(i, j, k);
+  }
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "resampleMacToVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      _retval = getPyNone();
+      resampleMacToVec3(source, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "resampleMacToVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("resampleMacToVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_resampleMacToVec3("", "resampleMacToVec3", _W_6);
+extern "C" {
+void PbRegister_resampleMacToVec3()
+{
+  KEEP_UNUSED(_RP_resampleMacToVec3);
+}
+}
+
+void copyLevelsetToReal(LevelsetGrid &source, Grid<Real> &target)
+{
+  FOR_IJK(target)
+  {
+    target(i, j, k) = source(i, j, k);
+  }
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "copyLevelsetToReal", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      LevelsetGrid &source = *_args.getPtr<LevelsetGrid>("source", 0, &_lock);
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
+      _retval = getPyNone();
+      copyLevelsetToReal(source, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "copyLevelsetToReal", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("copyLevelsetToReal", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_copyLevelsetToReal("", "copyLevelsetToReal", _W_7);
+extern "C" {
+void PbRegister_copyLevelsetToReal()
+{
+  KEEP_UNUSED(_RP_copyLevelsetToReal);
+}
+}
+
+void copyVec3ToReal(Grid<Vec3> &source,
+                    Grid<Real> &targetX,
+                    Grid<Real> &targetY,
+                    Grid<Real> &targetZ)
+{
+  FOR_IJK(source)
+  {
+    targetX(i, j, k) = source(i, j, k).x;
+    targetY(i, j, k) = source(i, j, k).y;
+    targetZ(i, j, k) = source(i, j, k).z;
+  }
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "copyVec3ToReal", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
+      Grid<Real> &targetX = *_args.getPtr<Grid<Real>>("targetX", 1, &_lock);
+      Grid<Real> &targetY = *_args.getPtr<Grid<Real>>("targetY", 2, &_lock);
+      Grid<Real> &targetZ = *_args.getPtr<Grid<Real>>("targetZ", 3, &_lock);
+      _retval = getPyNone();
+      copyVec3ToReal(source, targetX, targetY, targetZ);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "copyVec3ToReal", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("copyVec3ToReal", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_copyVec3ToReal("", "copyVec3ToReal", _W_8);
+extern "C" {
+void PbRegister_copyVec3ToReal()
+{
+  KEEP_UNUSED(_RP_copyVec3ToReal);
+}
+}
+
+void copyRealToVec3(Grid<Real> &sourceX,
+                    Grid<Real> &sourceY,
+                    Grid<Real> &sourceZ,
+                    Grid<Vec3> &target)
+{
+  FOR_IJK(target)
+  {
+    target(i, j, k).x = sourceX(i, j, k);
+    target(i, j, k).y = sourceY(i, j, k);
+    target(i, j, k).z = sourceZ(i, j, k);
+  }
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "copyRealToVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &sourceX = *_args.getPtr<Grid<Real>>("sourceX", 0, &_lock);
+      Grid<Real> &sourceY = *_args.getPtr<Grid<Real>>("sourceY", 1, &_lock);
+      Grid<Real> &sourceZ = *_args.getPtr<Grid<Real>>("sourceZ", 2, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 3, &_lock);
+      _retval = getPyNone();
+      copyRealToVec3(sourceX, sourceY, sourceZ, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "copyRealToVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("copyRealToVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_copyRealToVec3("", "copyRealToVec3", _W_9);
+extern "C" {
+void PbRegister_copyRealToVec3()
+{
+  KEEP_UNUSED(_RP_copyRealToVec3);
+}
+}
+
+void convertLevelsetToReal(LevelsetGrid &source, Grid<Real> &target)
+{
+  debMsg("Deprecated - do not use convertLevelsetToReal... use copyLevelsetToReal instead", 1);
+  copyLevelsetToReal(source, target);
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "convertLevelsetToReal", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      LevelsetGrid &source = *_args.getPtr<LevelsetGrid>("source", 0, &_lock);
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
+      _retval = getPyNone();
+      convertLevelsetToReal(source, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "convertLevelsetToReal", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("convertLevelsetToReal", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_convertLevelsetToReal("", "convertLevelsetToReal", _W_10);
+extern "C" {
+void PbRegister_convertLevelsetToReal()
+{
+  KEEP_UNUSED(_RP_convertLevelsetToReal);
+}
+}
+
+template<class T> void Grid<T>::printGrid(int zSlice, bool printIndex, int bnd)
+{
+  std::ostringstream out;
+  out << std::endl;
+  FOR_IJK_BND(*this, bnd)
+  {
+    IndexInt idx = (*this).index(i, j, k);
+    if ((zSlice >= 0 && k == zSlice) || (zSlice < 0)) {
+      out << " ";
+      if (printIndex && this->is3D())
+        out << "  " << i << "," << j << "," << k << ":";
+      if (printIndex && !this->is3D())
+        out << "  " << i << "," << j << ":";
+      out << (*this)[idx];
+      if (i == (*this).getSizeX() - 1 - bnd)
+        out << std::endl;
+    }
+  }
+  out << endl;
+  debMsg("Printing " << this->getName() << out.str().c_str(), 1);
+}
+
+//! helper to swap components of a grid (eg for data import)
+void swapComponents(Grid<Vec3> &vel, int c1 = 0, int c2 = 1, int c3 = 2)
+{
+  FOR_IJK(vel)
+  {
+    Vec3 v = vel(i, j, k);
+    vel(i, j, k)[0] = v[c1];
+    vel(i, j, k)[1] = v[c2];
+    vel(i, j, k)[2] = v[c3];
+  }
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "swapComponents", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 0, &_lock);
+      int c1 = _args.getOpt<int>("c1", 1, 0, &_lock);
+      int c2 = _args.getOpt<int>("c2", 2, 1, &_lock);
+      int c3 = _args.getOpt<int>("c3", 3, 2, &_lock);
+      _retval = getPyNone();
+      swapComponents(vel, c1, c2, c3);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "swapComponents", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("swapComponents", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_swapComponents("", "swapComponents", _W_11);
+extern "C" {
+void PbRegister_swapComponents()
+{
+  KEEP_UNUSED(_RP_swapComponents);
+}
+}
+
+// helper functions for UV grid data (stored grid coordinates as Vec3 values, and uv weight in
+// entry zero)
+
+// make uv weight accesible in python
+Real getUvWeight(Grid<Vec3> &uv)
+{
+  return uv[0][0];
+}
+static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getUvWeight", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &uv = *_args.getPtr<Grid<Vec3>>("uv", 0, &_lock);
+      _retval = toPy(getUvWeight(uv));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getUvWeight", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getUvWeight", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getUvWeight("", "getUvWeight", _W_12);
+extern "C" {
+void PbRegister_getUvWeight()
+{
+  KEEP_UNUSED(_RP_getUvWeight);
+}
+}
+
+// note - right now the UV grids have 0 values at the border after advection... could be fixed with
+// an extrapolation step...
+
+// compute normalized modulo interval
+static inline Real computeUvGridTime(Real t, Real resetTime)
+{
+  return fmod((t / resetTime), (Real)1.);
+}
+// create ramp function in 0..1 range with half frequency
+static inline Real computeUvRamp(Real t)
+{
+  Real uvWeight = 2. * t;
+  if (uvWeight > 1.)
+    uvWeight = 2. - uvWeight;
+  return uvWeight;
+}
+
+struct knResetUvGrid : public KernelBase {
+  knResetUvGrid(Grid<Vec3> &target, const Vec3 *offset)
+      : KernelBase(&target, 0), target(target), offset(offset)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Vec3> &target, const Vec3 *offset) const
+  {
+    Vec3 coord = Vec3((Real)i, (Real)j, (Real)k);
+    if (offset)
+      coord += (*offset);
+    target(i, j, k) = coord;
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return target;
+  }
+  typedef Grid<Vec3> type0;
+  inline const Vec3 *getArg1()
+  {
+    return offset;
+  }
+  typedef Vec3 type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knResetUvGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, target, offset);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, target, offset);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Vec3> &target;
+  const Vec3 *offset;
+};
+
+void resetUvGrid(Grid<Vec3> &target, const Vec3 *offset = NULL)
+{
+  knResetUvGrid reset(target,
+                      offset);  // note, llvm complains about anonymous declaration here... ?
+}
+static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "resetUvGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 0, &_lock);
+      const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 1, NULL, &_lock);
+      _retval = getPyNone();
+      resetUvGrid(target, offset);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "resetUvGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("resetUvGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_resetUvGrid("", "resetUvGrid", _W_13);
+extern "C" {
+void PbRegister_resetUvGrid()
+{
+  KEEP_UNUSED(_RP_resetUvGrid);
+}
+}
+
+void updateUvWeight(
+    Real resetTime, int index, int numUvs, Grid<Vec3> &uv, const Vec3 *offset = NULL)
+{
+  const Real t = uv.getParent()->getTime();
+  Real timeOff = resetTime / (Real)numUvs;
+
+  Real lastt = computeUvGridTime(t + (Real)index * timeOff - uv.getParent()->getDt(), resetTime);
+  Real currt = computeUvGridTime(t + (Real)index * timeOff, resetTime);
+  Real uvWeight = computeUvRamp(currt);
+
+  // normalize the uvw weights , note: this is a bit wasteful...
+  Real uvWTotal = 0.;
+  for (int i = 0; i < numUvs; ++i) {
+    uvWTotal += computeUvRamp(computeUvGridTime(t + (Real)i * timeOff, resetTime));
+  }
+  if (uvWTotal <= VECTOR_EPSILON) {
+    uvWeight = uvWTotal = 1.;
+  }
+  else
+    uvWeight /= uvWTotal;
+
+  // check for reset
+  if (currt < lastt)
+    knResetUvGrid reset(uv, offset);
+
+  // write new weight value to grid
+  uv[0] = Vec3(uvWeight, 0., 0.);
+
+  // print info about uv weights?
+  debMsg("Uv grid " << index << "/" << numUvs << " t=" << currt << " w=" << uvWeight
+                    << ", reset:" << (int)(currt < lastt),
+         2);
+}
+static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "updateUvWeight", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Real resetTime = _args.get<Real>("resetTime", 0, &_lock);
+      int index = _args.get<int>("index", 1, &_lock);
+      int numUvs = _args.get<int>("numUvs", 2, &_lock);
+      Grid<Vec3> &uv = *_args.getPtr<Grid<Vec3>>("uv", 3, &_lock);
+      const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 4, NULL, &_lock);
+      _retval = getPyNone();
+      updateUvWeight(resetTime, index, numUvs, uv, offset);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "updateUvWeight", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("updateUvWeight", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_updateUvWeight("", "updateUvWeight", _W_14);
+extern "C" {
+void PbRegister_updateUvWeight()
+{
+  KEEP_UNUSED(_RP_updateUvWeight);
+}
+}
+
+template<class T> struct knSetBoundary : public KernelBase {
+  knSetBoundary(Grid<T> &grid, T value, int w)
+      : KernelBase(&grid, 0), grid(grid), value(value), w(w)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<T> &grid, T value, int w) const
+  {
+    bool bnd = (i <= w || i >= grid.getSizeX() - 1 - w || j <= w || j >= grid.getSizeY() - 1 - w ||
+                (grid.is3D() && (k <= w || k >= grid.getSizeZ() - 1 - w)));
+    if (bnd)
+      grid(i, j, k) = value;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  inline int &getArg2()
+  {
+    return w;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetBoundary ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, value, w);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, value, w);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> &grid;
+  T value;
+  int w;
+};
+
+template<class T> void Grid<T>::setBound(T value, int boundaryWidth)
+{
+  knSetBoundary<T>(*this, value, boundaryWidth);
+}
+
+template<class T> struct knSetBoundaryNeumann : public KernelBase {
+  knSetBoundaryNeumann(Grid<T> &grid, int w) : KernelBase(&grid, 0), grid(grid), w(w)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<T> &grid, int w) const
+  {
+    bool set = false;
+    int si = i, sj = j, sk = k;
+    if (i <= w) {
+      si = w + 1;
+      set = true;
+    }
+    if (i >= grid.getSizeX() - 1 - w) {
+      si = grid.getSizeX() - 1 - w - 1;
+      set = true;
+    }
+    if (j <= w) {
+      sj = w + 1;
+      set = true;
+    }
+    if (j >= grid.getSizeY() - 1 - w) {
+      sj = grid.getSizeY() - 1 - w - 1;
+      set = true;
+    }
+    if (grid.is3D()) {
+      if (k <= w) {
+        sk = w + 1;
+        set = true;
+      }
+      if (k >= grid.getSizeZ() - 1 - w) {
+        sk = grid.getSizeZ() - 1 - w - 1;
+        set = true;
+      }
+    }
+    if (set)
+      grid(i, j, k) = grid(si, sj, sk);
+  }
+  inline Grid<T> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<T> type0;
+  inline int &getArg1()
+  {
+    return w;
+  }
+  typedef int type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetBoundaryNeumann ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, w);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, w);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> &grid;
+  int w;
+};
+
+template<class T> void Grid<T>::setBoundNeumann(int boundaryWidth)
+{
+  knSetBoundaryNeumann<T>(*this, boundaryWidth);
+}
+
+//! kernel to set velocity components of mac grid to value for a boundary of w cells
+struct knSetBoundaryMAC : public KernelBase {
+  knSetBoundaryMAC(Grid<Vec3> &grid, Vec3 value, int w)
+      : KernelBase(&grid, 0), grid(grid), value(value), w(w)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Vec3> &grid, Vec3 value, int w) const
+  {
+    if (i <= w || i >= grid.getSizeX() - w || j <= w - 1 || j >= grid.getSizeY() - 1 - w ||
+        (grid.is3D() && (k <= w - 1 || k >= grid.getSizeZ() - 1 - w)))
+      grid(i, j, k).x = value.x;
+    if (i <= w - 1 || i >= grid.getSizeX() - 1 - w || j <= w || j >= grid.getSizeY() - w ||
+        (grid.is3D() && (k <= w - 1 || k >= grid.getSizeZ() - 1 - w)))
+      grid(i, j, k).y = value.y;
+    if (i <= w - 1 || i >= grid.getSizeX() - 1 - w || j <= w - 1 || j >= grid.getSizeY() - 1 - w ||
+        (grid.is3D() && (k <= w || k >= grid.getSizeZ() - w)))
+      grid(i, j, k).z = value.z;
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline Vec3 &getArg1()
+  {
+    return value;
+  }
+  typedef Vec3 type1;
+  inline int &getArg2()
+  {
+    return w;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetBoundaryMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, value, w);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, value, w);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Vec3> &grid;
+  Vec3 value;
+  int w;
+};
+
+//! only set normal velocity components of mac grid to value for a boundary of w cells
+struct knSetBoundaryMACNorm : public KernelBase {
+  knSetBoundaryMACNorm(Grid<Vec3> &grid, Vec3 value, int w)
+      : KernelBase(&grid, 0), grid(grid), value(value), w(w)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Vec3> &grid, Vec3 value, int w) const
+  {
+    if (i <= w || i >= grid.getSizeX() - w)
+      grid(i, j, k).x = value.x;
+    if (j <= w || j >= grid.getSizeY() - w)
+      grid(i, j, k).y = value.y;
+    if ((grid.is3D() && (k <= w || k >= grid.getSizeZ() - w)))
+      grid(i, j, k).z = value.z;
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<Vec3> type0;
+  inline Vec3 &getArg1()
+  {
+    return value;
+  }
+  typedef Vec3 type1;
+  inline int &getArg2()
+  {
+    return w;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetBoundaryMACNorm ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, value, w);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, value, w);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Vec3> &grid;
+  Vec3 value;
+  int w;
+};
+
+//! set velocity components of mac grid to value for a boundary of w cells (optionally only normal
+//! values)
+void MACGrid::setBoundMAC(Vec3 value, int boundaryWidth, bool normalOnly)
+{
+  if (!normalOnly)
+    knSetBoundaryMAC(*this, value, boundaryWidth);
+  else
+    knSetBoundaryMACNorm(*this, value, boundaryWidth);
+}
+
+//! helper kernels for getGridAvg
+
+struct knGridTotalSum : public KernelBase {
+  knGridTotalSum(const Grid<Real> &a, FlagGrid *flags)
+      : KernelBase(&a, 0), a(a), flags(flags), result(0.0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &a, FlagGrid *flags, double &result)
+  {
+    if (flags) {
+      if (flags->isFluid(idx))
+        result += a[idx];
+    }
+    else {
+      result += a[idx];
+    }
+  }
+  inline operator double()
+  {
+    return result;
+  }
+  inline double &getRet()
+  {
+    return result;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return a;
+  }
+  typedef Grid<Real> type0;
+  inline FlagGrid *getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGridTotalSum ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, a, flags, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  knGridTotalSum(knGridTotalSum &o, tbb::split)
+      : KernelBase(o), a(o.a), flags(o.flags), result(0.0)
+  {
+  }
+  void join(const knGridTotalSum &o)
+  {
+    result += o.result;
+  }
+  const Grid<Real> &a;
+  FlagGrid *flags;
+  double result;
+};
+
+struct knCountFluidCells : public KernelBase {
+  knCountFluidCells(FlagGrid &flags) : KernelBase(&flags, 0), flags(flags), numEmpty(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, FlagGrid &flags, int &numEmpty)
+  {
+    if (flags.isFluid(idx))
+      numEmpty++;
+  }
+  inline operator int()
+  {
+    return numEmpty;
+  }
+  inline int &getRet()
+  {
+    return numEmpty;
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCountFluidCells ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, numEmpty);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  knCountFluidCells(knCountFluidCells &o, tbb::split) : KernelBase(o), flags(o.flags), numEmpty(0)
+  {
+  }
+  void join(const knCountFluidCells &o)
+  {
+    numEmpty += o.numEmpty;
+  }
+  FlagGrid &flags;
+  int numEmpty;
+};
+
+//! averaged value for all cells (if flags are given, only for fluid cells)
+
+Real getGridAvg(Grid<Real> &source, FlagGrid *flags = NULL)
+{
+  double sum = knGridTotalSum(source, flags);
+
+  double cells;
+  if (flags) {
+    cells = knCountFluidCells(*flags);
+  }
+  else {
+    cells = source.getSizeX() * source.getSizeY() * source.getSizeZ();
+  }
+
+  if (cells > 0.)
+    sum *= 1. / cells;
+  else
+    sum = -1.;
+  return sum;
+}
+static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getGridAvg", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
+      FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, NULL, &_lock);
+      _retval = toPy(getGridAvg(source, flags));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getGridAvg", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getGridAvg", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getGridAvg("", "getGridAvg", _W_15);
+extern "C" {
+void PbRegister_getGridAvg()
+{
+  KEEP_UNUSED(_RP_getGridAvg);
+}
+}
+
+//! transfer data between real and vec3 grids
+
+struct knGetComponent : public KernelBase {
+  knGetComponent(const Grid<Vec3> &source, Grid<Real> &target, int component)
+      : KernelBase(&source, 0), source(source), target(target), component(component)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Vec3> &source, Grid<Real> &target, int component) const
+  {
+    target[idx] = source[idx][component];
+  }
+  inline const Grid<Vec3> &getArg0()
+  {
+    return source;
+  }
+  typedef Grid<Vec3> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<Real> type1;
+  inline int &getArg2()
+  {
+    return component;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGetComponent ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, source, target, component);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const Grid<Vec3> &source;
+  Grid<Real> &target;
+  int component;
+};
+void getComponent(const Grid<Vec3> &source, Grid<Real> &target, int component)
+{
+  knGetComponent(source, target, component);
+}
+static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getComponent", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
+      int component = _args.get<int>("component", 2, &_lock);
+      _retval = getPyNone();
+      getComponent(source, target, component);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getComponent", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getComponent", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getComponent("", "getComponent", _W_16);
+extern "C" {
+void PbRegister_getComponent()
+{
+  KEEP_UNUSED(_RP_getComponent);
+}
+}
+
+struct knSetComponent : public KernelBase {
+  knSetComponent(const Grid<Real> &source, Grid<Vec3> &target, int component)
+      : KernelBase(&source, 0), source(source), target(target), component(component)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &source, Grid<Vec3> &target, int component) const
+  {
+    target[idx][component] = source[idx];
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return source;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Vec3> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<Vec3> type1;
+  inline int &getArg2()
+  {
+    return component;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetComponent ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, source, target, component);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const Grid<Real> &source;
+  Grid<Vec3> &target;
+  int component;
+};
+void setComponent(const Grid<Real> &source, Grid<Vec3> &target, int component)
+{
+  knSetComponent(source, target, component);
+}
+static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setComponent", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      int component = _args.get<int>("component", 2, &_lock);
+      _retval = getPyNone();
+      setComponent(source, target, component);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setComponent", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setComponent", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setComponent("", "setComponent", _W_17);
+extern "C" {
+void PbRegister_setComponent()
+{
+  KEEP_UNUSED(_RP_setComponent);
+}
+}
+
+//******************************************************************************
+// Specialization classes
+
+void FlagGrid::InitMinXWall(const int &boundaryWidth, Grid<Real> &phiWalls)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(phiWalls)
+  {
+    phiWalls(i, j, k) = std::min(i - w - .5, (double)phiWalls(i, j, k));
+  }
+}
+
+void FlagGrid::InitMaxXWall(const int &boundaryWidth, Grid<Real> &phiWalls)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(phiWalls)
+  {
+    phiWalls(i, j, k) = std::min(mSize.x - i - 1.5 - w, (double)phiWalls(i, j, k));
+  }
+}
+
+void FlagGrid::InitMinYWall(const int &boundaryWidth, Grid<Real> &phiWalls)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(phiWalls)
+  {
+    phiWalls(i, j, k) = std::min(j - w - .5, (double)phiWalls(i, j, k));
+  }
+}
+
+void FlagGrid::InitMaxYWall(const int &boundaryWidth, Grid<Real> &phiWalls)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(phiWalls)
+  {
+    phiWalls(i, j, k) = std::min(mSize.y - j - 1.5 - w, (double)phiWalls(i, j, k));
+  }
+}
+
+void FlagGrid::InitMinZWall(const int &boundaryWidth, Grid<Real> &phiWalls)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(phiWalls)
+  {
+    phiWalls(i, j, k) = std::min(k - w - .5, (double)phiWalls(i, j, k));
+  }
+}
+
+void FlagGrid::InitMaxZWall(const int &boundaryWidth, Grid<Real> &phiWalls)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(phiWalls)
+  {
+    phiWalls(i, j, k) = std::min(mSize.z - k - 1.5 - w, (double)phiWalls(i, j, k));
+  }
+}
+
+void FlagGrid::initDomain(const int &boundaryWidth,
+                          const string &wallIn,
+                          const string &openIn,
+                          const string &inflowIn,
+                          const string &outflowIn,
+                          Grid<Real> *phiWalls)
+{
+
+  int types[6] = {0};
+  bool set[6] = {false};
+  // make sure we have at least 6 entries
+  string wall = wallIn;
+  wall.append("      ");
+  string open = openIn;
+  open.append("      ");
+  string inflow = inflowIn;
+  inflow.append("      ");
+  string outflow = outflowIn;
+  outflow.append("      ");
+
+  if (phiWalls)
+    phiWalls->setConst(1000000000);
+
+  for (int i = 0; i < 6; ++i) {
+    // min x-direction
+    if (!set[0]) {
+      if (open[i] == 'x') {
+        types[0] = TypeOpen;
+        set[0] = true;
+      }
+      else if (inflow[i] == 'x') {
+        types[0] = TypeInflow;
+        set[0] = true;
+      }
+      else if (outflow[i] == 'x') {
+        types[0] = TypeOutflow;
+        set[0] = true;
+      }
+      else if (wall[i] == 'x') {
+        types[0] = TypeObstacle;
+        if (phiWalls)
+          InitMinXWall(boundaryWidth, *phiWalls);
+        set[0] = true;
+      }
+    }
+    // max x-direction
+    if (!set[1]) {
+      if (open[i] == 'X') {
+        types[1] = TypeOpen;
+        set[1] = true;
+      }
+      else if (inflow[i] == 'X') {
+        types[1] = TypeInflow;
+        set[1] = true;
+      }
+      else if (outflow[i] == 'X') {
+        types[1] = TypeOutflow;
+        set[1] = true;
+      }
+      else if (wall[i] == 'X') {
+        types[1] = TypeObstacle;
+        if (phiWalls)
+          InitMaxXWall(boundaryWidth, *phiWalls);
+        set[1] = true;
+      }
+    }
+    // min y-direction
+    if (!set[2]) {
+      if (open[i] == 'y') {
+        types[2] = TypeOpen;
+        set[2] = true;
+      }
+      else if (inflow[i] == 'y') {
+        types[2] = TypeInflow;
+        set[2] = true;
+      }
+      else if (outflow[i] == 'y') {
+        types[2] = TypeOutflow;
+        set[2] = true;
+      }
+      else if (wall[i] == 'y') {
+        types[2] = TypeObstacle;
+        if (phiWalls)
+          InitMinYWall(boundaryWidth, *phiWalls);
+        set[2] = true;
+      }
+    }
+    // max y-direction
+    if (!set[3]) {
+      if (open[i] == 'Y') {
+        types[3] = TypeOpen;
+        set[3] = true;
+      }
+      else if (inflow[i] == 'Y') {
+        types[3] = TypeInflow;
+        set[3] = true;
+      }
+      else if (outflow[i] == 'Y') {
+        types[3] = TypeOutflow;
+        set[3] = true;
+      }
+      else if (wall[i] == 'Y') {
+        types[3] = TypeObstacle;
+        if (phiWalls)
+          InitMaxYWall(boundaryWidth, *phiWalls);
+        set[3] = true;
+      }
+    }
+    if (this->is3D()) {
+      // min z-direction
+      if (!set[4]) {
+        if (open[i] == 'z') {
+          types[4] = TypeOpen;
+          set[4] = true;
+        }
+        else if (inflow[i] == 'z') {
+          types[4] = TypeInflow;
+          set[4] = true;
+        }
+        else if (outflow[i] == 'z') {
+          types[4] = TypeOutflow;
+          set[4] = true;
+        }
+        else if (wall[i] == 'z') {
+          types[4] = TypeObstacle;
+          if (phiWalls)
+            InitMinZWall(boundaryWidth, *phiWalls);
+          set[4] = true;
+        }
+      }
+      // max z-direction
+      if (!set[5]) {
+        if (open[i] == 'Z') {
+          types[5] = TypeOpen;
+          set[5] = true;
+        }
+        else if (inflow[i] == 'Z') {
+          types[5] = TypeInflow;
+          set[5] = true;
+        }
+        else if (outflow[i] == 'Z') {
+          types[5] = TypeOutflow;
+          set[5] = true;
+        }
+        else if (wall[i] == 'Z') {
+          types[5] = TypeObstacle;
+          if (phiWalls)
+            InitMaxZWall(boundaryWidth, *phiWalls);
+          set[5] = true;
+        }
+      }
+    }
+  }
+
+  setConst(TypeEmpty);
+  initBoundaries(boundaryWidth, types);
+}
+
+void FlagGrid::initBoundaries(const int &boundaryWidth, const int *types)
+{
+  const int w = boundaryWidth;
+  FOR_IJK(*this)
+  {
+    bool bnd = (i <= w);
+    if (bnd)
+      mData[index(i, j, k)] = types[0];
+    bnd = (i >= mSize.x - 1 - w);
+    if (bnd)
+      mData[index(i, j, k)] = types[1];
+    bnd = (j <= w);
+    if (bnd)
+      mData[index(i, j, k)] = types[2];
+    bnd = (j >= mSize.y - 1 - w);
+    if (bnd)
+      mData[index(i, j, k)] = types[3];
+    if (is3D()) {
+      bnd = (k <= w);
+      if (bnd)
+        mData[index(i, j, k)] = types[4];
+      bnd = (k >= mSize.z - 1 - w);
+      if (bnd)
+        mData[index(i, j, k)] = types[5];
+    }
+  }
+}
+
+void FlagGrid::updateFromLevelset(LevelsetGrid &levelset)
+{
+  FOR_IDX(*this)
+  {
+    if (!isObstacle(idx) && !isOutflow(idx)) {
+      const Real phi = levelset[idx];
+      if (phi <= levelset.invalidTimeValue())
+        continue;
+
+      mData[idx] &= ~(TypeEmpty | TypeFluid);            // clear empty/fluid flags
+      mData[idx] |= (phi <= 0) ? TypeFluid : TypeEmpty;  // set resepctive flag
+    }
+  }
+}
+
+void FlagGrid::fillGrid(int type)
+{
+  FOR_IDX(*this)
+  {
+    if ((mData[idx] & TypeObstacle) == 0 && (mData[idx] & TypeInflow) == 0 &&
+        (mData[idx] & TypeOutflow) == 0 && (mData[idx] & TypeOpen) == 0)
+      mData[idx] = (mData[idx] & ~(TypeEmpty | TypeFluid)) | type;
+  }
+}
+
+// flag grid helper
+
+bool isIsolatedFluidCell(const IndexInt idx, const FlagGrid &flags)
+{
+  if (!flags.isFluid(idx))
+    return false;
+  if (flags.isFluid(idx - flags.getStrideX()))
+    return false;
+  if (flags.isFluid(idx + flags.getStrideX()))
+    return false;
+  if (flags.isFluid(idx - flags.getStrideY()))
+    return false;
+  if (flags.isFluid(idx + flags.getStrideY()))
+    return false;
+  if (!flags.is3D())
+    return true;
+  if (flags.isFluid(idx - flags.getStrideZ()))
+    return false;
+  if (flags.isFluid(idx + flags.getStrideZ()))
+    return false;
+  return true;
+}
+
+struct knMarkIsolatedFluidCell : public KernelBase {
+  knMarkIsolatedFluidCell(FlagGrid &flags, const int mark)
+      : KernelBase(&flags, 0), flags(flags), mark(mark)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, FlagGrid &flags, const int mark) const
+  {
+    if (isIsolatedFluidCell(idx, flags))
+      flags[idx] = mark;
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const int &getArg1()
+  {
+    return mark;
+  }
+  typedef int type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMarkIsolatedFluidCell ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, mark);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  FlagGrid &flags;
+  const int mark;
+};
+
+void markIsolatedFluidCell(FlagGrid &flags, const int mark)
+{
+  knMarkIsolatedFluidCell(flags, mark);
+}
+static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "markIsolatedFluidCell", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const int mark = _args.get<int>("mark", 1, &_lock);
+      _retval = getPyNone();
+      markIsolatedFluidCell(flags, mark);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "markIsolatedFluidCell", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("markIsolatedFluidCell", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_markIsolatedFluidCell("", "markIsolatedFluidCell", _W_18);
+extern "C" {
+void PbRegister_markIsolatedFluidCell()
+{
+  KEEP_UNUSED(_RP_markIsolatedFluidCell);
+}
+}
+
+void copyMACData(
+    const MACGrid &source, MACGrid &target, const FlagGrid &flags, const int flag, const int bnd)
+{
+  assertMsg(source.getSize().x == target.getSize().x && source.getSize().y == target.getSize().y &&
+                source.getSize().z == target.getSize().z,
+            "different grid resolutions " << source.getSize() << " vs " << target.getSize());
+
+  // Grid<Real> divGrid(target.getParent());
+  // DivergenceOpMAC(divGrid, target);
+  // Real fDivOrig = GridSumSqr(divGrid);
+
+  FOR_IJK_BND(target, bnd)
+  {
+    if (flags.get(i, j, k) & flag) {
+      target(i, j, k) = source(i, j, k);
+    }
+  }
+
+  // DivergenceOpMAC(divGrid, target);
+  // Real fDivTransfer = GridSumSqr(divGrid);
+  // std::cout << "Divergence: " << fDivOrig << " -> " << fDivTransfer << std::endl;
+}
+static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "copyMACData", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
+      MACGrid &target = *_args.getPtr<MACGrid>("target", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      const int flag = _args.get<int>("flag", 3, &_lock);
+      const int bnd = _args.get<int>("bnd", 4, &_lock);
+      _retval = getPyNone();
+      copyMACData(source, target, flags, flag, bnd);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "copyMACData", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("copyMACData", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_copyMACData("", "copyMACData", _W_19);
+extern "C" {
+void PbRegister_copyMACData()
+{
+  KEEP_UNUSED(_RP_copyMACData);
+}
+}
+
+// explicit instantiation
+template class Grid<int>;
+template class Grid<Real>;
+template class Grid<Vec3>;
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/grid.h b/extern/mantaflow/preprocessed/grid.h
new file mode 100644
index 00000000000..bd4e0f99f85
--- /dev/null
+++ b/extern/mantaflow/preprocessed/grid.h
@@ -0,0 +1,2260 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Grid representation
+ *
+ ******************************************************************************/
+
+#ifndef _GRID_H
+#define _GRID_H
+
+#include "manta.h"
+#include "vectorbase.h"
+#include "interpol.h"
+#include "interpolHigh.h"
+#include "kernel.h"
+
+namespace Manta {
+class LevelsetGrid;
+
+//! Base class for all grids
+class GridBase : public PbClass {
+ public:
+  enum GridType {
+    TypeNone = 0,
+    TypeReal = 1,
+    TypeInt = 2,
+    TypeVec3 = 4,
+    TypeMAC = 8,
+    TypeLevelset = 16,
+    TypeFlags = 32
+  };
+
+  GridBase(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "GridBase::GridBase", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new GridBase(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "GridBase::GridBase", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::GridBase", e.what());
+      return -1;
+    }
+  }
+
+  //! Get the grids X dimension
+  inline int getSizeX() const
+  {
+    return mSize.x;
+  }
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::getSizeX", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeX());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::getSizeX", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::getSizeX", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids Y dimension
+  inline int getSizeY() const
+  {
+    return mSize.y;
+  }
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::getSizeY", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeY());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::getSizeY", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::getSizeY", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids Z dimension
+  inline int getSizeZ() const
+  {
+    return mSize.z;
+  }
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::getSizeZ", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeZ());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::getSizeZ", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::getSizeZ", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids dimensions
+  inline Vec3i getSize() const
+  {
+    return mSize;
+  }
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::getSize", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSize());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::getSize", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::getSize", e.what());
+      return 0;
+    }
+  }
+
+  //! Get Stride in X dimension
+  inline IndexInt getStrideX() const
+  {
+    return 1;
+  }
+  //! Get Stride in Y dimension
+  inline IndexInt getStrideY() const
+  {
+    return mSize.x;
+  }
+  //! Get Stride in Z dimension
+  inline IndexInt getStrideZ() const
+  {
+    return mStrideZ;
+  }
+
+  inline Real getDx() const
+  {
+    return mDx;
+  }
+
+  //! Check if indices are within bounds, otherwise error (should only be called when debugging)
+  inline void checkIndex(int i, int j, int k) const;
+  //! Check if indices are within bounds, otherwise error (should only be called when debugging)
+  inline void checkIndex(IndexInt idx) const;
+  //! Check if index is within given boundaries
+  inline bool isInBounds(const Vec3i &p, int bnd) const;
+  //! Check if index is within given boundaries
+  inline bool isInBounds(const Vec3i &p) const;
+  //! Check if index is within given boundaries
+  inline bool isInBounds(const Vec3 &p, int bnd = 0) const
+  {
+    return isInBounds(toVec3i(p), bnd);
+  }
+  //! Check if linear index is in the range of the array
+  inline bool isInBounds(IndexInt idx) const;
+
+  //! Get the type of grid
+  inline GridType getType() const
+  {
+    return mType;
+  }
+  //! Check dimensionality
+  inline bool is3D() const
+  {
+    return m3D;
+  }
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::is3D", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->is3D());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::is3D", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::is3D", e.what());
+      return 0;
+    }
+  }
+
+  //! Get index into the data
+  inline IndexInt index(int i, int j, int k) const
+  {
+    DEBUG_ONLY(checkIndex(i, j, k));
+    return (IndexInt)i + (IndexInt)mSize.x * j + (IndexInt)mStrideZ * k;
+  }
+  //! Get index into the data
+  inline IndexInt index(const Vec3i &pos) const
+  {
+    DEBUG_ONLY(checkIndex(pos.x, pos.y, pos.z));
+    return (IndexInt)pos.x + (IndexInt)mSize.x * pos.y + (IndexInt)mStrideZ * pos.z;
+  }
+
+  //! grid4d compatibility functions
+  inline bool is4D() const
+  {
+    return false;
+  }
+  static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::is4D", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->is4D());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::is4D", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::is4D", e.what());
+      return 0;
+    }
+  }
+
+  inline int getSizeT() const
+  {
+    return 1;
+  }
+  static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::getSizeT", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeT());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::getSizeT", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::getSizeT", e.what());
+      return 0;
+    }
+  }
+
+  inline int getStrideT() const
+  {
+    return 0;
+  }
+  static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "GridBase::getStrideT", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getStrideT());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "GridBase::getStrideT", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("GridBase::getStrideT", e.what());
+      return 0;
+    }
+  }
+
+  inline int index(int i, int j, int k, int unused) const
+  {
+    return index(i, j, k);
+  }
+  inline bool isInBounds(int i, int j, int k, int t, int bnd) const
+  {
+    if (t != 0)
+      return false;
+    return isInBounds(Vec3i(i, j, k), bnd);
+  }
+
+ protected:
+  GridType mType;
+  Vec3i mSize;
+  Real mDx;
+  bool m3D;  // precomputed Z shift: to ensure 2D compatibility, always use this instead of sx*sy !
+  IndexInt mStrideZ;
+ public:
+  PbArgs _args;
+}
+#define _C_GridBase
+;
+
+//! Grid class
+
+template<class T> class Grid : public GridBase {
+ public:
+  //! init new grid, values are set to zero
+  Grid(FluidSolver *parent, bool show = true);
+  static int _W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Grid::Grid", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        bool show = _args.getOpt<bool>("show", 1, true, &_lock);
+        obj = new Grid(parent, show);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Grid::Grid", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::Grid", e.what());
+      return -1;
+    }
+  }
+
+  //! init new grid with an existing array
+  Grid(FluidSolver *parent, T *data, bool show = true);
+  //! create new & copy content from another grid
+  Grid(const Grid<T> &a);
+  //! return memory to solver
+  virtual ~Grid();
+
+  typedef T BASETYPE;
+  typedef GridBase BASETYPE_GRID;
+
+  void save(std::string name);
+  static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::save", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->save(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::save", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::save", e.what());
+      return 0;
+    }
+  }
+
+  void load(std::string name);
+  static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::load", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->load(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::load", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::load", e.what());
+      return 0;
+    }
+  }
+
+  //! set all cells to zero
+  void clear();
+  static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::clear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clear();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::clear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::clear", e.what());
+      return 0;
+    }
+  }
+
+  //! all kinds of access functions, use grid(), grid[] or grid.get()
+  //! access data
+  inline T get(int i, int j, int k) const
+  {
+    return mData[index(i, j, k)];
+  }
+  //! access data
+  inline T &get(int i, int j, int k)
+  {
+    return mData[index(i, j, k)];
+  }
+  //! access data
+  inline T get(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline T get(const Vec3i &pos) const
+  {
+    return mData[index(pos)];
+  }
+  //! access data
+  inline T &operator()(int i, int j, int k)
+  {
+    return mData[index(i, j, k)];
+  }
+  //! access data
+  inline T operator()(int i, int j, int k) const
+  {
+    return mData[index(i, j, k)];
+  }
+  //! access data
+  inline T &operator()(IndexInt idx)
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline T operator()(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline T &operator()(const Vec3i &pos)
+  {
+    return mData[index(pos)];
+  }
+  //! access data
+  inline T operator()(const Vec3i &pos) const
+  {
+    return mData[index(pos)];
+  }
+  //! access data
+  inline T &operator[](IndexInt idx)
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline const T operator[](IndexInt idx) const
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+
+  // interpolated access
+  inline T getInterpolated(const Vec3 &pos) const
+  {
+    return interpol<T>(mData, mSize, mStrideZ, pos);
+  }
+  inline void setInterpolated(const Vec3 &pos, const T &val, Grid<Real> &sumBuffer) const
+  {
+    setInterpol<T>(mData, mSize, mStrideZ, pos, val, &sumBuffer[0]);
+  }
+  // higher order interpolation (1=linear, 2=cubic)
+  inline T getInterpolatedHi(const Vec3 &pos, int order) const
+  {
+    switch (order) {
+      case 1:
+        return interpol<T>(mData, mSize, mStrideZ, pos);
+      case 2:
+        return interpolCubic<T>(mData, mSize, mStrideZ, pos);
+      default:
+        assertMsg(false, "Unknown interpolation order " << order);
+    }
+    return T(0.);  // should never be reached, just to prevent compiler warnings
+  }
+
+  // assignment / copy
+
+  //! warning - do not use "=" for grids in python, this copies the reference! not the grid
+  //! content...
+  // Grid<T>& operator=(const Grid<T>& a);
+  //! copy content from other grid (use this one instead of operator= !)
+  Grid<T> &copyFrom(const Grid<T> &a, bool copyType = true);
+  static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::copyFrom", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
+        bool copyType = _args.getOpt<bool>("copyType", 1, true, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->copyFrom(a, copyType));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::copyFrom", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::copyFrom", e.what());
+      return 0;
+    }
+  }
+  // old: { *this = a; }
+
+  // helper functions to work with grids in scene files
+
+  //! get grid type
+  int getGridType();
+  static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getGridType", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getGridType());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getGridType", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getGridType", e.what());
+      return 0;
+    }
+  }
+
+  //! add/subtract other grid
+  void add(const Grid<T> &a);
+  static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::add", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->add(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::add", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::add", e.what());
+      return 0;
+    }
+  }
+
+  void sub(const Grid<T> &a);
+  static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::sub", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->sub(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::sub", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::sub", e.what());
+      return 0;
+    }
+  }
+
+  //! set all cells to constant value
+  void setConst(T s);
+  static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::setConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::setConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::setConst", e.what());
+      return 0;
+    }
+  }
+
+  //! add constant to all grid cells
+  void addConst(T s);
+  static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::addConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::addConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::addConst", e.what());
+      return 0;
+    }
+  }
+
+  //! add scaled other grid to current one (note, only "Real" factor, "T" type not supported here!)
+  void addScaled(const Grid<T> &a, const T &factor);
+  static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::addScaled", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
+        const T &factor = *_args.getPtr<T>("factor", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addScaled(a, factor);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::addScaled", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::addScaled", e.what());
+      return 0;
+    }
+  }
+
+  //! multiply contents of grid
+  void mult(const Grid<T> &a);
+  static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::mult", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->mult(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::mult", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::mult", e.what());
+      return 0;
+    }
+  }
+
+  //! multiply each cell by a constant scalar value
+  void multConst(T s);
+  static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::multConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->multConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::multConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::multConst", e.what());
+      return 0;
+    }
+  }
+
+  //! clamp content to range (for vec3, clamps each component separately)
+  void clamp(Real min, Real max);
+  static PyObject *_W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::clamp", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real min = _args.get<Real>("min", 0, &_lock);
+        Real max = _args.get<Real>("max", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clamp(min, max);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::clamp", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::clamp", e.what());
+      return 0;
+    }
+  }
+
+  //! reduce small values to zero
+  void stomp(const T &threshold);
+  static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::stomp", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const T &threshold = *_args.getPtr<T>("threshold", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->stomp(threshold);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::stomp", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::stomp", e.what());
+      return 0;
+    }
+  }
+
+  //! permute grid axes, e.g. switch y with z (0,2,1)
+  void permuteAxes(int axis0, int axis1, int axis2);
+  static PyObject *_W_24(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::permuteAxes", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int axis0 = _args.get<int>("axis0", 0, &_lock);
+        int axis1 = _args.get<int>("axis1", 1, &_lock);
+        int axis2 = _args.get<int>("axis2", 2, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->permuteAxes(axis0, axis1, axis2);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::permuteAxes", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::permuteAxes", e.what());
+      return 0;
+    }
+  }
+
+  //! permute grid axes, e.g. switch y with z (0,2,1)
+  void permuteAxesCopyToGrid(int axis0, int axis1, int axis2, Grid<T> &out);
+  static PyObject *_W_25(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::permuteAxesCopyToGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int axis0 = _args.get<int>("axis0", 0, &_lock);
+        int axis1 = _args.get<int>("axis1", 1, &_lock);
+        int axis2 = _args.get<int>("axis2", 2, &_lock);
+        Grid<T> &out = *_args.getPtr<Grid<T>>("out", 3, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->permuteAxesCopyToGrid(axis0, axis1, axis2, out);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::permuteAxesCopyToGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::permuteAxesCopyToGrid", e.what());
+      return 0;
+    }
+  }
+
+  // common compound operators
+  //! get absolute max value in grid
+  Real getMaxAbs() const;
+  static PyObject *_W_26(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getMaxAbs", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMaxAbs());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getMaxAbs", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getMaxAbs", e.what());
+      return 0;
+    }
+  }
+
+  //! get max value in grid
+  Real getMax() const;
+  static PyObject *_W_27(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getMax", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMax());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getMax", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getMax", e.what());
+      return 0;
+    }
+  }
+
+  //! get min value in grid
+  Real getMin() const;
+  static PyObject *_W_28(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getMin", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMin());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getMin", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getMin", e.what());
+      return 0;
+    }
+  }
+
+  //! calculate L1 norm of grid content
+  Real getL1(int bnd = 0);
+  static PyObject *_W_29(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getL1", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int bnd = _args.getOpt<int>("bnd", 0, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getL1(bnd));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getL1", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getL1", e.what());
+      return 0;
+    }
+  }
+
+  //! calculate L2 norm of grid content
+  Real getL2(int bnd = 0);
+  static PyObject *_W_30(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getL2", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int bnd = _args.getOpt<int>("bnd", 0, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getL2(bnd));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getL2", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getL2", e.what());
+      return 0;
+    }
+  }
+
+  //! set all boundary cells to constant value (Dirichlet)
+  void setBound(T value, int boundaryWidth = 1);
+  static PyObject *_W_31(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::setBound", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T value = _args.get<T>("value", 0, &_lock);
+        int boundaryWidth = _args.getOpt<int>("boundaryWidth", 1, 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setBound(value, boundaryWidth);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::setBound", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::setBound", e.what());
+      return 0;
+    }
+  }
+
+  //! set all boundary cells to last inner value (Neumann)
+  void setBoundNeumann(int boundaryWidth = 1);
+  static PyObject *_W_32(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::setBoundNeumann", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setBoundNeumann(boundaryWidth);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::setBoundNeumann", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::setBoundNeumann", e.what());
+      return 0;
+    }
+  }
+
+  //! get data pointer of grid
+  std::string getDataPointer();
+  static PyObject *_W_33(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::getDataPointer", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getDataPointer());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::getDataPointer", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::getDataPointer", e.what());
+      return 0;
+    }
+  }
+
+  //! debugging helper, print grid from python. skip boundary of width bnd
+  void printGrid(int zSlice = -1, bool printIndex = false, int bnd = 1);
+  static PyObject *_W_34(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid::printGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int zSlice = _args.getOpt<int>("zSlice", 0, -1, &_lock);
+        bool printIndex = _args.getOpt<bool>("printIndex", 1, false, &_lock);
+        int bnd = _args.getOpt<int>("bnd", 2, 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->printGrid(zSlice, printIndex, bnd);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid::printGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid::printGrid", e.what());
+      return 0;
+    }
+  }
+
+  // c++ only operators
+  template<class S> Grid<T> &operator+=(const Grid<S> &a);
+  template<class S> Grid<T> &operator+=(const S &a);
+  template<class S> Grid<T> &operator-=(const Grid<S> &a);
+  template<class S> Grid<T> &operator-=(const S &a);
+  template<class S> Grid<T> &operator*=(const Grid<S> &a);
+  template<class S> Grid<T> &operator*=(const S &a);
+  template<class S> Grid<T> &operator/=(const Grid<S> &a);
+  template<class S> Grid<T> &operator/=(const S &a);
+  Grid<T> &safeDivide(const Grid<T> &a);
+
+  //! Swap data with another grid (no actual data is moved)
+  void swap(Grid<T> &other);
+
+  //! grid4d compatibility functions
+  inline T &operator()(int i, int j, int k, int unused)
+  {
+    return mData[index(i, j, k)];
+  }
+  inline T operator()(int i, int j, int k, int unused) const
+  {
+    return mData[index(i, j, k)];
+  }
+
+ protected:
+  T *mData;
+  bool externalData;  // True if mData is managed outside of the Fluidsolver
+ public:
+  PbArgs _args;
+}
+#define _C_Grid
+;
+
+// Python doesn't know about templates: explicit aliases needed
+
+//! Special function for staggered grids
+class MACGrid : public Grid<Vec3> {
+ public:
+  MACGrid(FluidSolver *parent, bool show = true) : Grid<Vec3>(parent, show)
+  {
+    mType = (GridType)(TypeMAC | TypeVec3);
+  }
+  static int _W_35(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "MACGrid::MACGrid", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        bool show = _args.getOpt<bool>("show", 1, true, &_lock);
+        obj = new MACGrid(parent, show);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "MACGrid::MACGrid", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("MACGrid::MACGrid", e.what());
+      return -1;
+    }
+  }
+
+  MACGrid(FluidSolver *parent, Vec3 *data, bool show = true) : Grid<Vec3>(parent, data, show)
+  {
+    mType = (GridType)(TypeMAC | TypeVec3);
+  }
+
+  // specialized functions for interpolating MAC information
+  inline Vec3 getCentered(int i, int j, int k) const;
+  inline Vec3 getCentered(const Vec3i &pos) const
+  {
+    return getCentered(pos.x, pos.y, pos.z);
+  }
+  inline Vec3 getAtMACX(int i, int j, int k) const;
+  inline Vec3 getAtMACY(int i, int j, int k) const;
+  inline Vec3 getAtMACZ(int i, int j, int k) const;
+  // interpolation
+  inline Vec3 getInterpolated(const Vec3 &pos) const
+  {
+    return interpolMAC(mData, mSize, mStrideZ, pos);
+  }
+  inline void setInterpolated(const Vec3 &pos, const Vec3 &val, Vec3 *tmp) const
+  {
+    return setInterpolMAC(mData, mSize, mStrideZ, pos, val, tmp);
+  }
+  inline Vec3 getInterpolatedHi(const Vec3 &pos, int order) const
+  {
+    switch (order) {
+      case 1:
+        return interpolMAC(mData, mSize, mStrideZ, pos);
+      case 2:
+        return interpolCubicMAC(mData, mSize, mStrideZ, pos);
+      default:
+        assertMsg(false, "Unknown interpolation order " << order);
+    }
+    return Vec3(0.);  // should never be reached, just to prevent compiler warnings
+  }
+  // specials for mac grid:
+  template<int comp> inline Real getInterpolatedComponent(Vec3 pos) const
+  {
+    return interpolComponent<comp>(mData, mSize, mStrideZ, pos);
+  }
+  template<int comp> inline Real getInterpolatedComponentHi(const Vec3 &pos, int order) const
+  {
+    switch (order) {
+      case 1:
+        return interpolComponent<comp>(mData, mSize, mStrideZ, pos);
+      case 2:
+        return interpolCubicMAC(mData, mSize, mStrideZ, pos)[comp];  // warning - not yet optimized
+      default:
+        assertMsg(false, "Unknown interpolation order " << order);
+    }
+    return 0.;  // should never be reached, just to prevent compiler warnings
+  }
+
+  //! set all boundary cells of a MAC grid to certain value (Dirchlet). Respects staggered grid
+  //! locations optionally, only set normal components
+  void setBoundMAC(Vec3 value, int boundaryWidth, bool normalOnly = false);
+  static PyObject *_W_36(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MACGrid *pbo = dynamic_cast<MACGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MACGrid::setBoundMAC", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Vec3 value = _args.get<Vec3>("value", 0, &_lock);
+        int boundaryWidth = _args.get<int>("boundaryWidth", 1, &_lock);
+        bool normalOnly = _args.getOpt<bool>("normalOnly", 2, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setBoundMAC(value, boundaryWidth, normalOnly);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MACGrid::setBoundMAC", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MACGrid::setBoundMAC", e.what());
+      return 0;
+    }
+  }
+
+ protected:
+ public:
+  PbArgs _args;
+}
+#define _C_MACGrid
+;
+
+//! Special functions for FlagGrid
+class FlagGrid : public Grid<int> {
+ public:
+  FlagGrid(FluidSolver *parent, int dim = 3, bool show = true) : Grid<int>(parent, show)
+  {
+    mType = (GridType)(TypeFlags | TypeInt);
+  }
+  static int _W_37(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "FlagGrid::FlagGrid", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        int dim = _args.getOpt<int>("dim", 1, 3, &_lock);
+        bool show = _args.getOpt<bool>("show", 2, true, &_lock);
+        obj = new FlagGrid(parent, dim, show);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "FlagGrid::FlagGrid", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("FlagGrid::FlagGrid", e.what());
+      return -1;
+    }
+  }
+
+  FlagGrid(FluidSolver *parent, int *data, int dim = 3, bool show = true)
+      : Grid<int>(parent, data, show)
+  {
+    mType = (GridType)(TypeFlags | TypeInt);
+  }
+
+  //! types of cells, in/outflow can be combined, e.g., TypeFluid|TypeInflow
+  enum CellType {
+    TypeNone = 0,
+    TypeFluid = 1,
+    TypeObstacle = 2,
+    TypeEmpty = 4,
+    TypeInflow = 8,
+    TypeOutflow = 16,
+    TypeOpen = 32,
+    TypeStick = 64,
+    TypeReserved = 256
+  };
+
+  //! access for particles
+  inline int getAt(const Vec3 &pos) const
+  {
+    return mData[index((int)pos.x, (int)pos.y, (int)pos.z)];
+  }
+
+  //! check for different flag types
+  inline bool isObstacle(IndexInt idx) const
+  {
+    return get(idx) & TypeObstacle;
+  }
+  inline bool isObstacle(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeObstacle;
+  }
+  inline bool isObstacle(const Vec3i &pos) const
+  {
+    return get(pos) & TypeObstacle;
+  }
+  inline bool isObstacle(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeObstacle;
+  }
+  inline bool isFluid(IndexInt idx) const
+  {
+    return get(idx) & TypeFluid;
+  }
+  inline bool isFluid(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeFluid;
+  }
+  inline bool isFluid(const Vec3i &pos) const
+  {
+    return get(pos) & TypeFluid;
+  }
+  inline bool isFluid(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeFluid;
+  }
+  inline bool isInflow(IndexInt idx) const
+  {
+    return get(idx) & TypeInflow;
+  }
+  inline bool isInflow(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeInflow;
+  }
+  inline bool isInflow(const Vec3i &pos) const
+  {
+    return get(pos) & TypeInflow;
+  }
+  inline bool isInflow(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeInflow;
+  }
+  inline bool isEmpty(IndexInt idx) const
+  {
+    return get(idx) & TypeEmpty;
+  }
+  inline bool isEmpty(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeEmpty;
+  }
+  inline bool isEmpty(const Vec3i &pos) const
+  {
+    return get(pos) & TypeEmpty;
+  }
+  inline bool isEmpty(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeEmpty;
+  }
+  inline bool isOutflow(IndexInt idx) const
+  {
+    return get(idx) & TypeOutflow;
+  }
+  inline bool isOutflow(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeOutflow;
+  }
+  inline bool isOutflow(const Vec3i &pos) const
+  {
+    return get(pos) & TypeOutflow;
+  }
+  inline bool isOutflow(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeOutflow;
+  }
+  inline bool isOpen(IndexInt idx) const
+  {
+    return get(idx) & TypeOpen;
+  }
+  inline bool isOpen(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeOpen;
+  }
+  inline bool isOpen(const Vec3i &pos) const
+  {
+    return get(pos) & TypeOpen;
+  }
+  inline bool isOpen(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeOpen;
+  }
+  inline bool isStick(IndexInt idx) const
+  {
+    return get(idx) & TypeStick;
+  }
+  inline bool isStick(int i, int j, int k) const
+  {
+    return get(i, j, k) & TypeStick;
+  }
+  inline bool isStick(const Vec3i &pos) const
+  {
+    return get(pos) & TypeStick;
+  }
+  inline bool isStick(const Vec3 &pos) const
+  {
+    return getAt(pos) & TypeStick;
+  }
+
+  void InitMinXWall(const int &boundaryWidth, Grid<Real> &phiWalls);
+  void InitMaxXWall(const int &boundaryWidth, Grid<Real> &phiWalls);
+  void InitMinYWall(const int &boundaryWidth, Grid<Real> &phiWalls);
+  void InitMaxYWall(const int &boundaryWidth, Grid<Real> &phiWalls);
+  void InitMinZWall(const int &boundaryWidth, Grid<Real> &phiWalls);
+  void InitMaxZWall(const int &boundaryWidth, Grid<Real> &phiWalls);
+  // Python callables
+
+  void initDomain(const int &boundaryWidth = 0,
+                  const std::string &wall = "xXyYzZ",
+                  const std::string &open = "      ",
+                  const std::string &inflow = "      ",
+                  const std::string &outflow = "      ",
+                  Grid<Real> *phiWalls = 0x00);
+  static PyObject *_W_38(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FlagGrid::initDomain", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const int &boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 0, &_lock);
+        const std::string &wall = _args.getOpt<std::string>("wall", 1, "xXyYzZ", &_lock);
+        const std::string &open = _args.getOpt<std::string>("open", 2, "      ", &_lock);
+        const std::string &inflow = _args.getOpt<std::string>("inflow", 3, "      ", &_lock);
+        const std::string &outflow = _args.getOpt<std::string>("outflow", 4, "      ", &_lock);
+        Grid<Real> *phiWalls = _args.getPtrOpt<Grid<Real>>("phiWalls", 5, 0x00, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->initDomain(boundaryWidth, wall, open, inflow, outflow, phiWalls);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FlagGrid::initDomain", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FlagGrid::initDomain", e.what());
+      return 0;
+    }
+  }
+
+  void initBoundaries(const int &boundaryWidth, const int *types);
+
+  //! set fluid flags inside levelset (liquids)
+  void updateFromLevelset(LevelsetGrid &levelset);
+  static PyObject *_W_39(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FlagGrid::updateFromLevelset", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->updateFromLevelset(levelset);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FlagGrid::updateFromLevelset", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FlagGrid::updateFromLevelset", e.what());
+      return 0;
+    }
+  }
+
+  //! set all cells (except obs/in/outflow) to type (fluid by default)
+  void fillGrid(int type = TypeFluid);
+  static PyObject *_W_40(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FlagGrid::fillGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int type = _args.getOpt<int>("type", 0, TypeFluid, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->fillGrid(type);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FlagGrid::fillGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FlagGrid::fillGrid", e.what());
+      return 0;
+    }
+  }
+
+  //! count no. of cells matching flags via "AND"
+  //! warning for large grids! only regular int returned (due to python interface)
+  //! optionally creates mask in RealGrid (1 where flag matches, 0 otherwise)
+  int countCells(int flag, int bnd = 0, Grid<Real> *mask = NULL);
+  static PyObject *_W_41(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "FlagGrid::countCells", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int flag = _args.get<int>("flag", 0, &_lock);
+        int bnd = _args.getOpt<int>("bnd", 1, 0, &_lock);
+        Grid<Real> *mask = _args.getPtrOpt<Grid<Real>>("mask", 2, NULL, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->countCells(flag, bnd, mask));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "FlagGrid::countCells", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("FlagGrid::countCells", e.what());
+      return 0;
+    }
+  }
+
+ public:
+  PbArgs _args;
+}
+#define _C_FlagGrid
+;
+
+//! helper to compute grid conversion factor between local coordinates of two grids
+inline Vec3 calcGridSizeFactor(Vec3i s1, Vec3i s2)
+{
+  return Vec3(Real(s1[0]) / s2[0], Real(s1[1]) / s2[1], Real(s1[2]) / s2[2]);
+}
+
+// prototypes for grid plugins
+void copyMacToVec3(MACGrid &source, Grid<Vec3> &target);
+void convertMacToVec3(MACGrid &source, Grid<Vec3> &target);
+void resampleVec3ToMac(Grid<Vec3> &source, MACGrid &target);
+void resampleMacToVec3(MACGrid &source, Grid<Vec3> &target);
+
+void getComponent(const Grid<Vec3> &source, Grid<Real> &target, int component);
+void setComponent(const Grid<Real> &source, Grid<Vec3> &target, int component);
+
+//******************************************************************************
+// Implementation of inline functions
+
+inline void GridBase::checkIndex(int i, int j, int k) const
+{
+  if (i < 0 || j < 0 || k < 0 || i >= mSize.x || j >= mSize.y || k >= mSize.z) {
+    std::ostringstream s;
+    s << "Grid " << mName << " dim " << mSize << " : index " << i << "," << j << "," << k
+      << " out of bound ";
+    errMsg(s.str());
+  }
+}
+
+inline void GridBase::checkIndex(IndexInt idx) const
+{
+  if (idx < 0 || idx >= mSize.x * mSize.y * mSize.z) {
+    std::ostringstream s;
+    s << "Grid " << mName << " dim " << mSize << " : index " << idx << " out of bound ";
+    errMsg(s.str());
+  }
+}
+
+bool GridBase::isInBounds(const Vec3i &p) const
+{
+  return (p.x >= 0 && p.y >= 0 && p.z >= 0 && p.x < mSize.x && p.y < mSize.y && p.z < mSize.z);
+}
+
+bool GridBase::isInBounds(const Vec3i &p, int bnd) const
+{
+  bool ret = (p.x >= bnd && p.y >= bnd && p.x < mSize.x - bnd && p.y < mSize.y - bnd);
+  if (this->is3D()) {
+    ret &= (p.z >= bnd && p.z < mSize.z - bnd);
+  }
+  else {
+    ret &= (p.z == 0);
+  }
+  return ret;
+}
+//! Check if linear index is in the range of the array
+bool GridBase::isInBounds(IndexInt idx) const
+{
+  if (idx < 0 || idx >= mSize.x * mSize.y * mSize.z) {
+    return false;
+  }
+  return true;
+}
+
+inline Vec3 MACGrid::getCentered(int i, int j, int k) const
+{
+  DEBUG_ONLY(checkIndex(i + 1, j + 1, k));
+  const IndexInt idx = index(i, j, k);
+  Vec3 v = Vec3(
+      0.5 * (mData[idx].x + mData[idx + 1].x), 0.5 * (mData[idx].y + mData[idx + mSize.x].y), 0.);
+  if (this->is3D()) {
+    DEBUG_ONLY(checkIndex(idx + mStrideZ));
+    v[2] = 0.5 * (mData[idx].z + mData[idx + mStrideZ].z);
+  }
+  return v;
+}
+
+inline Vec3 MACGrid::getAtMACX(int i, int j, int k) const
+{
+  DEBUG_ONLY(checkIndex(i - 1, j + 1, k));
+  const IndexInt idx = index(i, j, k);
+  Vec3 v = Vec3((mData[idx].x),
+                0.25 * (mData[idx].y + mData[idx - 1].y + mData[idx + mSize.x].y +
+                        mData[idx + mSize.x - 1].y),
+                0.);
+  if (this->is3D()) {
+    DEBUG_ONLY(checkIndex(idx + mStrideZ - 1));
+    v[2] = 0.25 * (mData[idx].z + mData[idx - 1].z + mData[idx + mStrideZ].z +
+                   mData[idx + mStrideZ - 1].z);
+  }
+  return v;
+}
+
+inline Vec3 MACGrid::getAtMACY(int i, int j, int k) const
+{
+  DEBUG_ONLY(checkIndex(i + 1, j - 1, k));
+  const IndexInt idx = index(i, j, k);
+  Vec3 v = Vec3(0.25 * (mData[idx].x + mData[idx - mSize.x].x + mData[idx + 1].x +
+                        mData[idx + 1 - mSize.x].x),
+                (mData[idx].y),
+                0.);
+  if (this->is3D()) {
+    DEBUG_ONLY(checkIndex(idx + mStrideZ - mSize.x));
+    v[2] = 0.25 * (mData[idx].z + mData[idx - mSize.x].z + mData[idx + mStrideZ].z +
+                   mData[idx + mStrideZ - mSize.x].z);
+  }
+  return v;
+}
+
+inline Vec3 MACGrid::getAtMACZ(int i, int j, int k) const
+{
+  const IndexInt idx = index(i, j, k);
+  DEBUG_ONLY(checkIndex(idx - mStrideZ));
+  DEBUG_ONLY(checkIndex(idx + mSize.x - mStrideZ));
+  Vec3 v = Vec3(0.25 * (mData[idx].x + mData[idx - mStrideZ].x + mData[idx + 1].x +
+                        mData[idx + 1 - mStrideZ].x),
+                0.25 * (mData[idx].y + mData[idx - mStrideZ].y + mData[idx + mSize.x].y +
+                        mData[idx + mSize.x - mStrideZ].y),
+                (mData[idx].z));
+  return v;
+}
+
+template<class T, class S> struct gridAdd : public KernelBase {
+  gridAdd(Grid<T> &me, const Grid<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const Grid<S> &other) const
+  {
+    me[idx] += other[idx];
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridAdd ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<S> &other;
+};
+template<class T, class S> struct gridSub : public KernelBase {
+  gridSub(Grid<T> &me, const Grid<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const Grid<S> &other) const
+  {
+    me[idx] -= other[idx];
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridSub ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<S> &other;
+};
+template<class T, class S> struct gridMult : public KernelBase {
+  gridMult(Grid<T> &me, const Grid<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const Grid<S> &other) const
+  {
+    me[idx] *= other[idx];
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridMult ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<S> &other;
+};
+template<class T, class S> struct gridDiv : public KernelBase {
+  gridDiv(Grid<T> &me, const Grid<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const Grid<S> &other) const
+  {
+    me[idx] /= other[idx];
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridDiv ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<S> &other;
+};
+template<class T, class S> struct gridAddScalar : public KernelBase {
+  gridAddScalar(Grid<T> &me, const S &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const S &other) const
+  {
+    me[idx] += other;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridAddScalar ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const S &other;
+};
+template<class T, class S> struct gridMultScalar : public KernelBase {
+  gridMultScalar(Grid<T> &me, const S &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const S &other) const
+  {
+    me[idx] *= other;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridMultScalar ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const S &other;
+};
+template<class T, class S> struct gridScaledAdd : public KernelBase {
+  gridScaledAdd(Grid<T> &me, const Grid<T> &other, const S &factor)
+      : KernelBase(&me, 0), me(me), other(other), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &me, const Grid<T> &other, const S &factor) const
+  {
+    me[idx] += factor * other[idx];
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<T> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<T> type1;
+  inline const S &getArg2()
+  {
+    return factor;
+  }
+  typedef S type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridScaledAdd ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, factor);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<T> &other;
+  const S &factor;
+};
+
+template<class T> struct gridSetConst : public KernelBase {
+  gridSetConst(Grid<T> &grid, T value) : KernelBase(&grid, 0), grid(grid), value(value)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<T> &grid, T value) const
+  {
+    grid[idx] = value;
+  }
+  inline Grid<T> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel gridSetConst ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, grid, value);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &grid;
+  T value;
+};
+
+template<class T> template<class S> Grid<T> &Grid<T>::operator+=(const Grid<S> &a)
+{
+  gridAdd<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator+=(const S &a)
+{
+  gridAddScalar<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator-=(const Grid<S> &a)
+{
+  gridSub<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator-=(const S &a)
+{
+  gridAddScalar<T, S>(*this, -a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator*=(const Grid<S> &a)
+{
+  gridMult<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator*=(const S &a)
+{
+  gridMultScalar<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator/=(const Grid<S> &a)
+{
+  gridDiv<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid<T> &Grid<T>::operator/=(const S &a)
+{
+  S rez((S)1.0 / a);
+  gridMultScalar<T, S>(*this, rez);
+  return *this;
+}
+
+//******************************************************************************
+// Other helper functions
+
+// compute gradient of a scalar grid
+inline Vec3 getGradient(const Grid<Real> &data, int i, int j, int k)
+{
+  Vec3 v;
+
+  if (i > data.getSizeX() - 2)
+    i = data.getSizeX() - 2;
+  if (j > data.getSizeY() - 2)
+    j = data.getSizeY() - 2;
+  if (i < 1)
+    i = 1;
+  if (j < 1)
+    j = 1;
+  v = Vec3(data(i + 1, j, k) - data(i - 1, j, k), data(i, j + 1, k) - data(i, j - 1, k), 0.);
+
+  if (data.is3D()) {
+    if (k > data.getSizeZ() - 2)
+      k = data.getSizeZ() - 2;
+    if (k < 1)
+      k = 1;
+    v[2] = data(i, j, k + 1) - data(i, j, k - 1);
+  }
+
+  return v;
+}
+
+// interpolate grid from one size to another size
+
+template<class S> struct knInterpolateGridTempl : public KernelBase {
+  knInterpolateGridTempl(Grid<S> &target,
+                         const Grid<S> &source,
+                         const Vec3 &sourceFactor,
+                         Vec3 offset,
+                         int orderSpace = 1)
+      : KernelBase(&target, 0),
+        target(target),
+        source(source),
+        sourceFactor(sourceFactor),
+        offset(offset),
+        orderSpace(orderSpace)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<S> &target,
+                 const Grid<S> &source,
+                 const Vec3 &sourceFactor,
+                 Vec3 offset,
+                 int orderSpace = 1) const
+  {
+    Vec3 pos = Vec3(i, j, k) * sourceFactor + offset;
+    if (!source.is3D())
+      pos[2] = 0;  // allow 2d -> 3d
+    target(i, j, k) = source.getInterpolatedHi(pos, orderSpace);
+  }
+  inline Grid<S> &getArg0()
+  {
+    return target;
+  }
+  typedef Grid<S> type0;
+  inline const Grid<S> &getArg1()
+  {
+    return source;
+  }
+  typedef Grid<S> type1;
+  inline const Vec3 &getArg2()
+  {
+    return sourceFactor;
+  }
+  typedef Vec3 type2;
+  inline Vec3 &getArg3()
+  {
+    return offset;
+  }
+  typedef Vec3 type3;
+  inline int &getArg4()
+  {
+    return orderSpace;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knInterpolateGridTempl ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, target, source, sourceFactor, offset, orderSpace);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, target, source, sourceFactor, offset, orderSpace);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<S> &target;
+  const Grid<S> &source;
+  const Vec3 &sourceFactor;
+  Vec3 offset;
+  int orderSpace;
+};
+// template glue code - choose interpolation based on template arguments
+template<class GRID> void interpolGridTempl(GRID &target, GRID &source)
+{
+  errMsg("interpolGridTempl - Only valid for specific instantiations");
+}
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/grid.h.reg.cpp b/extern/mantaflow/preprocessed/grid.h.reg.cpp
new file mode 100644
index 00000000000..d7f87604edf
--- /dev/null
+++ b/extern/mantaflow/preprocessed/grid.h.reg.cpp
@@ -0,0 +1,246 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "grid.h"
+namespace Manta {
+#ifdef _C_FlagGrid
+static const Pb::Register _R_26("FlagGrid", "FlagGrid", "Grid<int>");
+template<> const char *Namify<FlagGrid>::S = "FlagGrid";
+static const Pb::Register _R_27("FlagGrid", "FlagGrid", FlagGrid::_W_37);
+static const Pb::Register _R_28("FlagGrid", "initDomain", FlagGrid::_W_38);
+static const Pb::Register _R_29("FlagGrid", "updateFromLevelset", FlagGrid::_W_39);
+static const Pb::Register _R_30("FlagGrid", "fillGrid", FlagGrid::_W_40);
+static const Pb::Register _R_31("FlagGrid", "countCells", FlagGrid::_W_41);
+#endif
+#ifdef _C_Grid
+static const Pb::Register _R_32("Grid<int>", "Grid<int>", "GridBase");
+template<> const char *Namify<Grid<int>>::S = "Grid<int>";
+static const Pb::Register _R_33("Grid<int>", "Grid", Grid<int>::_W_9);
+static const Pb::Register _R_34("Grid<int>", "save", Grid<int>::_W_10);
+static const Pb::Register _R_35("Grid<int>", "load", Grid<int>::_W_11);
+static const Pb::Register _R_36("Grid<int>", "clear", Grid<int>::_W_12);
+static const Pb::Register _R_37("Grid<int>", "copyFrom", Grid<int>::_W_13);
+static const Pb::Register _R_38("Grid<int>", "getGridType", Grid<int>::_W_14);
+static const Pb::Register _R_39("Grid<int>", "add", Grid<int>::_W_15);
+static const Pb::Register _R_40("Grid<int>", "sub", Grid<int>::_W_16);
+static const Pb::Register _R_41("Grid<int>", "setConst", Grid<int>::_W_17);
+static const Pb::Register _R_42("Grid<int>", "addConst", Grid<int>::_W_18);
+static const Pb::Register _R_43("Grid<int>", "addScaled", Grid<int>::_W_19);
+static const Pb::Register _R_44("Grid<int>", "mult", Grid<int>::_W_20);
+static const Pb::Register _R_45("Grid<int>", "multConst", Grid<int>::_W_21);
+static const Pb::Register _R_46("Grid<int>", "clamp", Grid<int>::_W_22);
+static const Pb::Register _R_47("Grid<int>", "stomp", Grid<int>::_W_23);
+static const Pb::Register _R_48("Grid<int>", "permuteAxes", Grid<int>::_W_24);
+static const Pb::Register _R_49("Grid<int>", "permuteAxesCopyToGrid", Grid<int>::_W_25);
+static const Pb::Register _R_50("Grid<int>", "getMaxAbs", Grid<int>::_W_26);
+static const Pb::Register _R_51("Grid<int>", "getMax", Grid<int>::_W_27);
+static const Pb::Register _R_52("Grid<int>", "getMin", Grid<int>::_W_28);
+static const Pb::Register _R_53("Grid<int>", "getL1", Grid<int>::_W_29);
+static const Pb::Register _R_54("Grid<int>", "getL2", Grid<int>::_W_30);
+static const Pb::Register _R_55("Grid<int>", "setBound", Grid<int>::_W_31);
+static const Pb::Register _R_56("Grid<int>", "setBoundNeumann", Grid<int>::_W_32);
+static const Pb::Register _R_57("Grid<int>", "getDataPointer", Grid<int>::_W_33);
+static const Pb::Register _R_58("Grid<int>", "printGrid", Grid<int>::_W_34);
+static const Pb::Register _R_59("Grid<Real>", "Grid<Real>", "GridBase");
+template<> const char *Namify<Grid<Real>>::S = "Grid<Real>";
+static const Pb::Register _R_60("Grid<Real>", "Grid", Grid<Real>::_W_9);
+static const Pb::Register _R_61("Grid<Real>", "save", Grid<Real>::_W_10);
+static const Pb::Register _R_62("Grid<Real>", "load", Grid<Real>::_W_11);
+static const Pb::Register _R_63("Grid<Real>", "clear", Grid<Real>::_W_12);
+static const Pb::Register _R_64("Grid<Real>", "copyFrom", Grid<Real>::_W_13);
+static const Pb::Register _R_65("Grid<Real>", "getGridType", Grid<Real>::_W_14);
+static const Pb::Register _R_66("Grid<Real>", "add", Grid<Real>::_W_15);
+static const Pb::Register _R_67("Grid<Real>", "sub", Grid<Real>::_W_16);
+static const Pb::Register _R_68("Grid<Real>", "setConst", Grid<Real>::_W_17);
+static const Pb::Register _R_69("Grid<Real>", "addConst", Grid<Real>::_W_18);
+static const Pb::Register _R_70("Grid<Real>", "addScaled", Grid<Real>::_W_19);
+static const Pb::Register _R_71("Grid<Real>", "mult", Grid<Real>::_W_20);
+static const Pb::Register _R_72("Grid<Real>", "multConst", Grid<Real>::_W_21);
+static const Pb::Register _R_73("Grid<Real>", "clamp", Grid<Real>::_W_22);
+static const Pb::Register _R_74("Grid<Real>", "stomp", Grid<Real>::_W_23);
+static const Pb::Register _R_75("Grid<Real>", "permuteAxes", Grid<Real>::_W_24);
+static const Pb::Register _R_76("Grid<Real>", "permuteAxesCopyToGrid", Grid<Real>::_W_25);
+static const Pb::Register _R_77("Grid<Real>", "getMaxAbs", Grid<Real>::_W_26);
+static const Pb::Register _R_78("Grid<Real>", "getMax", Grid<Real>::_W_27);
+static const Pb::Register _R_79("Grid<Real>", "getMin", Grid<Real>::_W_28);
+static const Pb::Register _R_80("Grid<Real>", "getL1", Grid<Real>::_W_29);
+static const Pb::Register _R_81("Grid<Real>", "getL2", Grid<Real>::_W_30);
+static const Pb::Register _R_82("Grid<Real>", "setBound", Grid<Real>::_W_31);
+static const Pb::Register _R_83("Grid<Real>", "setBoundNeumann", Grid<Real>::_W_32);
+static const Pb::Register _R_84("Grid<Real>", "getDataPointer", Grid<Real>::_W_33);
+static const Pb::Register _R_85("Grid<Real>", "printGrid", Grid<Real>::_W_34);
+static const Pb::Register _R_86("Grid<Vec3>", "Grid<Vec3>", "GridBase");
+template<> const char *Namify<Grid<Vec3>>::S = "Grid<Vec3>";
+static const Pb::Register _R_87("Grid<Vec3>", "Grid", Grid<Vec3>::_W_9);
+static const Pb::Register _R_88("Grid<Vec3>", "save", Grid<Vec3>::_W_10);
+static const Pb::Register _R_89("Grid<Vec3>", "load", Grid<Vec3>::_W_11);
+static const Pb::Register _R_90("Grid<Vec3>", "clear", Grid<Vec3>::_W_12);
+static const Pb::Register _R_91("Grid<Vec3>", "copyFrom", Grid<Vec3>::_W_13);
+static const Pb::Register _R_92("Grid<Vec3>", "getGridType", Grid<Vec3>::_W_14);
+static const Pb::Register _R_93("Grid<Vec3>", "add", Grid<Vec3>::_W_15);
+static const Pb::Register _R_94("Grid<Vec3>", "sub", Grid<Vec3>::_W_16);
+static const Pb::Register _R_95("Grid<Vec3>", "setConst", Grid<Vec3>::_W_17);
+static const Pb::Register _R_96("Grid<Vec3>", "addConst", Grid<Vec3>::_W_18);
+static const Pb::Register _R_97("Grid<Vec3>", "addScaled", Grid<Vec3>::_W_19);
+static const Pb::Register _R_98("Grid<Vec3>", "mult", Grid<Vec3>::_W_20);
+static const Pb::Register _R_99("Grid<Vec3>", "multConst", Grid<Vec3>::_W_21);
+static const Pb::Register _R_100("Grid<Vec3>", "clamp", Grid<Vec3>::_W_22);
+static const Pb::Register _R_101("Grid<Vec3>", "stomp", Grid<Vec3>::_W_23);
+static const Pb::Register _R_102("Grid<Vec3>", "permuteAxes", Grid<Vec3>::_W_24);
+static const Pb::Register _R_103("Grid<Vec3>", "permuteAxesCopyToGrid", Grid<Vec3>::_W_25);
+static const Pb::Register _R_104("Grid<Vec3>", "getMaxAbs", Grid<Vec3>::_W_26);
+static const Pb::Register _R_105("Grid<Vec3>", "getMax", Grid<Vec3>::_W_27);
+static const Pb::Register _R_106("Grid<Vec3>", "getMin", Grid<Vec3>::_W_28);
+static const Pb::Register _R_107("Grid<Vec3>", "getL1", Grid<Vec3>::_W_29);
+static const Pb::Register _R_108("Grid<Vec3>", "getL2", Grid<Vec3>::_W_30);
+static const Pb::Register _R_109("Grid<Vec3>", "setBound", Grid<Vec3>::_W_31);
+static const Pb::Register _R_110("Grid<Vec3>", "setBoundNeumann", Grid<Vec3>::_W_32);
+static const Pb::Register _R_111("Grid<Vec3>", "getDataPointer", Grid<Vec3>::_W_33);
+static const Pb::Register _R_112("Grid<Vec3>", "printGrid", Grid<Vec3>::_W_34);
+#endif
+#ifdef _C_GridBase
+static const Pb::Register _R_113("GridBase", "GridBase", "PbClass");
+template<> const char *Namify<GridBase>::S = "GridBase";
+static const Pb::Register _R_114("GridBase", "GridBase", GridBase::_W_0);
+static const Pb::Register _R_115("GridBase", "getSizeX", GridBase::_W_1);
+static const Pb::Register _R_116("GridBase", "getSizeY", GridBase::_W_2);
+static const Pb::Register _R_117("GridBase", "getSizeZ", GridBase::_W_3);
+static const Pb::Register _R_118("GridBase", "getSize", GridBase::_W_4);
+static const Pb::Register _R_119("GridBase", "is3D", GridBase::_W_5);
+static const Pb::Register _R_120("GridBase", "is4D", GridBase::_W_6);
+static const Pb::Register _R_121("GridBase", "getSizeT", GridBase::_W_7);
+static const Pb::Register _R_122("GridBase", "getStrideT", GridBase::_W_8);
+#endif
+#ifdef _C_MACGrid
+static const Pb::Register _R_123("MACGrid", "MACGrid", "Grid<Vec3>");
+template<> const char *Namify<MACGrid>::S = "MACGrid";
+static const Pb::Register _R_124("MACGrid", "MACGrid", MACGrid::_W_35);
+static const Pb::Register _R_125("MACGrid", "setBoundMAC", MACGrid::_W_36);
+#endif
+static const Pb::Register _R_7("GridType_TypeNone", 0);
+static const Pb::Register _R_8("GridType_TypeReal", 1);
+static const Pb::Register _R_9("GridType_TypeInt", 2);
+static const Pb::Register _R_10("GridType_TypeVec3", 4);
+static const Pb::Register _R_11("GridType_TypeMAC", 8);
+static const Pb::Register _R_12("GridType_TypeLevelset", 16);
+static const Pb::Register _R_13("GridType_TypeFlags", 32);
+static const Pb::Register _R_14("Grid<int>", "IntGrid", "");
+static const Pb::Register _R_15("Grid<Real>", "RealGrid", "");
+static const Pb::Register _R_16("Grid<Vec3>", "VecGrid", "");
+static const Pb::Register _R_17("CellType_TypeNone", 0);
+static const Pb::Register _R_18("CellType_TypeFluid", 1);
+static const Pb::Register _R_19("CellType_TypeObstacle", 2);
+static const Pb::Register _R_20("CellType_TypeEmpty", 4);
+static const Pb::Register _R_21("CellType_TypeInflow", 8);
+static const Pb::Register _R_22("CellType_TypeOutflow", 16);
+static const Pb::Register _R_23("CellType_TypeOpen", 32);
+static const Pb::Register _R_24("CellType_TypeStick", 64);
+static const Pb::Register _R_25("CellType_TypeReserved", 256);
+extern "C" {
+void PbRegister_file_7()
+{
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+  KEEP_UNUSED(_R_33);
+  KEEP_UNUSED(_R_34);
+  KEEP_UNUSED(_R_35);
+  KEEP_UNUSED(_R_36);
+  KEEP_UNUSED(_R_37);
+  KEEP_UNUSED(_R_38);
+  KEEP_UNUSED(_R_39);
+  KEEP_UNUSED(_R_40);
+  KEEP_UNUSED(_R_41);
+  KEEP_UNUSED(_R_42);
+  KEEP_UNUSED(_R_43);
+  KEEP_UNUSED(_R_44);
+  KEEP_UNUSED(_R_45);
+  KEEP_UNUSED(_R_46);
+  KEEP_UNUSED(_R_47);
+  KEEP_UNUSED(_R_48);
+  KEEP_UNUSED(_R_49);
+  KEEP_UNUSED(_R_50);
+  KEEP_UNUSED(_R_51);
+  KEEP_UNUSED(_R_52);
+  KEEP_UNUSED(_R_53);
+  KEEP_UNUSED(_R_54);
+  KEEP_UNUSED(_R_55);
+  KEEP_UNUSED(_R_56);
+  KEEP_UNUSED(_R_57);
+  KEEP_UNUSED(_R_58);
+  KEEP_UNUSED(_R_59);
+  KEEP_UNUSED(_R_60);
+  KEEP_UNUSED(_R_61);
+  KEEP_UNUSED(_R_62);
+  KEEP_UNUSED(_R_63);
+  KEEP_UNUSED(_R_64);
+  KEEP_UNUSED(_R_65);
+  KEEP_UNUSED(_R_66);
+  KEEP_UNUSED(_R_67);
+  KEEP_UNUSED(_R_68);
+  KEEP_UNUSED(_R_69);
+  KEEP_UNUSED(_R_70);
+  KEEP_UNUSED(_R_71);
+  KEEP_UNUSED(_R_72);
+  KEEP_UNUSED(_R_73);
+  KEEP_UNUSED(_R_74);
+  KEEP_UNUSED(_R_75);
+  KEEP_UNUSED(_R_76);
+  KEEP_UNUSED(_R_77);
+  KEEP_UNUSED(_R_78);
+  KEEP_UNUSED(_R_79);
+  KEEP_UNUSED(_R_80);
+  KEEP_UNUSED(_R_81);
+  KEEP_UNUSED(_R_82);
+  KEEP_UNUSED(_R_83);
+  KEEP_UNUSED(_R_84);
+  KEEP_UNUSED(_R_85);
+  KEEP_UNUSED(_R_86);
+  KEEP_UNUSED(_R_87);
+  KEEP_UNUSED(_R_88);
+  KEEP_UNUSED(_R_89);
+  KEEP_UNUSED(_R_90);
+  KEEP_UNUSED(_R_91);
+  KEEP_UNUSED(_R_92);
+  KEEP_UNUSED(_R_93);
+  KEEP_UNUSED(_R_94);
+  KEEP_UNUSED(_R_95);
+  KEEP_UNUSED(_R_96);
+  KEEP_UNUSED(_R_97);
+  KEEP_UNUSED(_R_98);
+  KEEP_UNUSED(_R_99);
+  KEEP_UNUSED(_R_100);
+  KEEP_UNUSED(_R_101);
+  KEEP_UNUSED(_R_102);
+  KEEP_UNUSED(_R_103);
+  KEEP_UNUSED(_R_104);
+  KEEP_UNUSED(_R_105);
+  KEEP_UNUSED(_R_106);
+  KEEP_UNUSED(_R_107);
+  KEEP_UNUSED(_R_108);
+  KEEP_UNUSED(_R_109);
+  KEEP_UNUSED(_R_110);
+  KEEP_UNUSED(_R_111);
+  KEEP_UNUSED(_R_112);
+  KEEP_UNUSED(_R_113);
+  KEEP_UNUSED(_R_114);
+  KEEP_UNUSED(_R_115);
+  KEEP_UNUSED(_R_116);
+  KEEP_UNUSED(_R_117);
+  KEEP_UNUSED(_R_118);
+  KEEP_UNUSED(_R_119);
+  KEEP_UNUSED(_R_120);
+  KEEP_UNUSED(_R_121);
+  KEEP_UNUSED(_R_122);
+  KEEP_UNUSED(_R_123);
+  KEEP_UNUSED(_R_124);
+  KEEP_UNUSED(_R_125);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/grid4d.cpp b/extern/mantaflow/preprocessed/grid4d.cpp
new file mode 100644
index 00000000000..41d69b2d33a
--- /dev/null
+++ b/extern/mantaflow/preprocessed/grid4d.cpp
@@ -0,0 +1,1798 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Grid representation
+ *
+ ******************************************************************************/
+
+#include <limits>
+#include <sstream>
+#include <cstring>
+
+#include "grid4d.h"
+#include "levelset.h"
+#include "kernel.h"
+#include "mantaio.h"
+
+using namespace std;
+namespace Manta {
+
+//******************************************************************************
+// GridBase members
+
+Grid4dBase::Grid4dBase(FluidSolver *parent) : PbClass(parent), mType(TypeNone)
+{
+  checkParent();
+}
+
+//******************************************************************************
+// Grid4d<T> members
+
+// helpers to set type
+template<class T> inline Grid4dBase::Grid4dType typeList()
+{
+  return Grid4dBase::TypeNone;
+}
+template<> inline Grid4dBase::Grid4dType typeList<Real>()
+{
+  return Grid4dBase::TypeReal;
+}
+template<> inline Grid4dBase::Grid4dType typeList<int>()
+{
+  return Grid4dBase::TypeInt;
+}
+template<> inline Grid4dBase::Grid4dType typeList<Vec3>()
+{
+  return Grid4dBase::TypeVec3;
+}
+template<> inline Grid4dBase::Grid4dType typeList<Vec4>()
+{
+  return Grid4dBase::TypeVec4;
+}
+
+template<class T> Grid4d<T>::Grid4d(FluidSolver *parent, bool show) : Grid4dBase(parent)
+{
+  assertMsg(parent->is3D() && parent->supports4D(),
+            "To use 4d grids create a 3d solver with fourthDim>0");
+
+  mType = typeList<T>();
+  Vec3i s = parent->getGridSize();
+  mSize = Vec4i(s.x, s.y, s.z, parent->getFourthDim());
+  mData = parent->getGrid4dPointer<T>();
+  assertMsg(mData, "Couldnt allocate data pointer!");
+
+  mStrideZ = (mSize.x * mSize.y);
+  mStrideT = (mStrideZ * mSize.z);
+
+  Real sizemax = (Real)mSize[0];
+  for (int c = 1; c < 3; ++c)
+    if (mSize[c] > sizemax)
+      sizemax = mSize[c];
+  // note - the 4d component is ignored for dx! keep same scaling as for 3d...
+  mDx = 1.0 / sizemax;
+
+  clear();
+  setHidden(!show);
+}
+
+template<class T> Grid4d<T>::Grid4d(const Grid4d<T> &a) : Grid4dBase(a.getParent())
+{
+  mSize = a.mSize;
+  mType = a.mType;
+  mStrideZ = a.mStrideZ;
+  mStrideT = a.mStrideT;
+  mDx = a.mDx;
+  FluidSolver *gp = a.getParent();
+  mData = gp->getGrid4dPointer<T>();
+  assertMsg(mData, "Couldnt allocate data pointer!");
+
+  memcpy(mData, a.mData, sizeof(T) * a.mSize.x * a.mSize.y * a.mSize.z * a.mSize.t);
+}
+
+template<class T> Grid4d<T>::~Grid4d()
+{
+  mParent->freeGrid4dPointer<T>(mData);
+}
+
+template<class T> void Grid4d<T>::clear()
+{
+  memset(mData, 0, sizeof(T) * mSize.x * mSize.y * mSize.z * mSize.t);
+}
+
+template<class T> void Grid4d<T>::swap(Grid4d<T> &other)
+{
+  if (other.getSizeX() != getSizeX() || other.getSizeY() != getSizeY() ||
+      other.getSizeZ() != getSizeZ() || other.getSizeT() != getSizeT())
+    errMsg("Grid4d::swap(): Grid4d dimensions mismatch.");
+
+  T *dswap = other.mData;
+  other.mData = mData;
+  mData = dswap;
+}
+
+template<class T> void Grid4d<T>::load(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    readGrid4dUni(name, this);
+  else if (ext == ".raw")
+    readGrid4dRaw(name, this);
+  else
+    errMsg("file '" + name + "' filetype not supported");
+}
+
+template<class T> void Grid4d<T>::save(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    writeGrid4dUni(name, this);
+  else if (ext == ".raw")
+    writeGrid4dRaw(name, this);
+  else
+    errMsg("file '" + name + "' filetype not supported");
+}
+
+//******************************************************************************
+// Grid4d<T> operators
+
+//! Kernel: Compute min value of Real Grid4d
+
+struct kn4dMinReal : public KernelBase {
+  kn4dMinReal(Grid4d<Real> &val)
+      : KernelBase(&val, 0), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<Real> &val, Real &minVal)
+  {
+    if (val[idx] < minVal)
+      minVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline Grid4d<Real> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid4d<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMinReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  kn4dMinReal(kn4dMinReal &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const kn4dMinReal &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  Grid4d<Real> &val;
+  Real minVal;
+};
+
+//! Kernel: Compute max value of Real Grid4d
+
+struct kn4dMaxReal : public KernelBase {
+  kn4dMaxReal(Grid4d<Real> &val)
+      : KernelBase(&val, 0), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<Real> &val, Real &maxVal)
+  {
+    if (val[idx] > maxVal)
+      maxVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline Grid4d<Real> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid4d<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMaxReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  kn4dMaxReal(kn4dMaxReal &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const kn4dMaxReal &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  Grid4d<Real> &val;
+  Real maxVal;
+};
+
+//! Kernel: Compute min value of int Grid4d
+
+struct kn4dMinInt : public KernelBase {
+  kn4dMinInt(Grid4d<int> &val)
+      : KernelBase(&val, 0), val(val), minVal(std::numeric_limits<int>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<int> &val, int &minVal)
+  {
+    if (val[idx] < minVal)
+      minVal = val[idx];
+  }
+  inline operator int()
+  {
+    return minVal;
+  }
+  inline int &getRet()
+  {
+    return minVal;
+  }
+  inline Grid4d<int> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid4d<int> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMinInt ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  kn4dMinInt(kn4dMinInt &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<int>::max())
+  {
+  }
+  void join(const kn4dMinInt &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  Grid4d<int> &val;
+  int minVal;
+};
+
+//! Kernel: Compute max value of int Grid4d
+
+struct kn4dMaxInt : public KernelBase {
+  kn4dMaxInt(Grid4d<int> &val)
+      : KernelBase(&val, 0), val(val), maxVal(std::numeric_limits<int>::min())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<int> &val, int &maxVal)
+  {
+    if (val[idx] > maxVal)
+      maxVal = val[idx];
+  }
+  inline operator int()
+  {
+    return maxVal;
+  }
+  inline int &getRet()
+  {
+    return maxVal;
+  }
+  inline Grid4d<int> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid4d<int> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMaxInt ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  kn4dMaxInt(kn4dMaxInt &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(std::numeric_limits<int>::min())
+  {
+  }
+  void join(const kn4dMaxInt &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  Grid4d<int> &val;
+  int maxVal;
+};
+
+//! Kernel: Compute min norm of vec Grid4d
+
+template<class VEC> struct kn4dMinVec : public KernelBase {
+  kn4dMinVec(Grid4d<VEC> &val)
+      : KernelBase(&val, 0), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<VEC> &val, Real &minVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s < minVal)
+      minVal = s;
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline Grid4d<VEC> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid4d<VEC> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMinVec ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  kn4dMinVec(kn4dMinVec &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const kn4dMinVec &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  Grid4d<VEC> &val;
+  Real minVal;
+};
+
+//! Kernel: Compute max norm of vec Grid4d
+
+template<class VEC> struct kn4dMaxVec : public KernelBase {
+  kn4dMaxVec(Grid4d<VEC> &val)
+      : KernelBase(&val, 0), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<VEC> &val, Real &maxVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s > maxVal)
+      maxVal = s;
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline Grid4d<VEC> &getArg0()
+  {
+    return val;
+  }
+  typedef Grid4d<VEC> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMaxVec ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  kn4dMaxVec(kn4dMaxVec &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const kn4dMaxVec &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  Grid4d<VEC> &val;
+  Real maxVal;
+};
+
+template<class T> Grid4d<T> &Grid4d<T>::safeDivide(const Grid4d<T> &a)
+{
+  Grid4dSafeDiv<T>(*this, a);
+  return *this;
+}
+template<class T> Grid4d<T> &Grid4d<T>::copyFrom(const Grid4d<T> &a, bool copyType)
+{
+  assertMsg(a.mSize.x == mSize.x && a.mSize.y == mSize.y && a.mSize.z == mSize.z &&
+                a.mSize.t == mSize.t,
+            "different Grid4d resolutions " << a.mSize << " vs " << this->mSize);
+  memcpy(mData, a.mData, sizeof(T) * mSize.x * mSize.y * mSize.z * mSize.t);
+  if (copyType)
+    mType = a.mType;  // copy type marker
+  return *this;
+}
+/*template<class T> Grid4d<T>& Grid4d<T>::operator= (const Grid4d<T>& a) {
+  note: do not use , use copyFrom instead
+}*/
+
+template<class T> struct kn4dSetConstReal : public KernelBase {
+  kn4dSetConstReal(Grid4d<T> &me, T val) : KernelBase(&me, 0), me(me), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, T val) const
+  {
+    me[idx] = val;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline T &getArg1()
+  {
+    return val;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dSetConstReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, val);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  T val;
+};
+template<class T> struct kn4dAddConstReal : public KernelBase {
+  kn4dAddConstReal(Grid4d<T> &me, T val) : KernelBase(&me, 0), me(me), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, T val) const
+  {
+    me[idx] += val;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline T &getArg1()
+  {
+    return val;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dAddConstReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, val);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  T val;
+};
+template<class T> struct kn4dMultConst : public KernelBase {
+  kn4dMultConst(Grid4d<T> &me, T val) : KernelBase(&me, 0), me(me), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, T val) const
+  {
+    me[idx] *= val;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline T &getArg1()
+  {
+    return val;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dMultConst ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, val);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  T val;
+};
+template<class T> struct kn4dClamp : public KernelBase {
+  kn4dClamp(Grid4d<T> &me, T min, T max) : KernelBase(&me, 0), me(me), min(min), max(max)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, T min, T max) const
+  {
+    me[idx] = clamp(me[idx], min, max);
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline T &getArg1()
+  {
+    return min;
+  }
+  typedef T type1;
+  inline T &getArg2()
+  {
+    return max;
+  }
+  typedef T type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel kn4dClamp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, min, max);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  T min;
+  T max;
+};
+
+template<class T> void Grid4d<T>::add(const Grid4d<T> &a)
+{
+  Grid4dAdd<T, T>(*this, a);
+}
+template<class T> void Grid4d<T>::sub(const Grid4d<T> &a)
+{
+  Grid4dSub<T, T>(*this, a);
+}
+template<class T> void Grid4d<T>::addScaled(const Grid4d<T> &a, const T &factor)
+{
+  Grid4dScaledAdd<T, T>(*this, a, factor);
+}
+template<class T> void Grid4d<T>::setConst(T a)
+{
+  kn4dSetConstReal<T>(*this, T(a));
+}
+template<class T> void Grid4d<T>::addConst(T a)
+{
+  kn4dAddConstReal<T>(*this, T(a));
+}
+template<class T> void Grid4d<T>::multConst(T a)
+{
+  kn4dMultConst<T>(*this, a);
+}
+
+template<class T> void Grid4d<T>::mult(const Grid4d<T> &a)
+{
+  Grid4dMult<T, T>(*this, a);
+}
+
+template<class T> void Grid4d<T>::clamp(Real min, Real max)
+{
+  kn4dClamp<T>(*this, T(min), T(max));
+}
+
+template<> Real Grid4d<Real>::getMax()
+{
+  return kn4dMaxReal(*this);
+}
+template<> Real Grid4d<Real>::getMin()
+{
+  return kn4dMinReal(*this);
+}
+template<> Real Grid4d<Real>::getMaxAbs()
+{
+  Real amin = kn4dMinReal(*this);
+  Real amax = kn4dMaxReal(*this);
+  return max(fabs(amin), fabs(amax));
+}
+template<> Real Grid4d<Vec4>::getMax()
+{
+  return sqrt(kn4dMaxVec<Vec4>(*this));
+}
+template<> Real Grid4d<Vec4>::getMin()
+{
+  return sqrt(kn4dMinVec<Vec4>(*this));
+}
+template<> Real Grid4d<Vec4>::getMaxAbs()
+{
+  return sqrt(kn4dMaxVec<Vec4>(*this));
+}
+template<> Real Grid4d<int>::getMax()
+{
+  return (Real)kn4dMaxInt(*this);
+}
+template<> Real Grid4d<int>::getMin()
+{
+  return (Real)kn4dMinInt(*this);
+}
+template<> Real Grid4d<int>::getMaxAbs()
+{
+  int amin = kn4dMinInt(*this);
+  int amax = kn4dMaxInt(*this);
+  return max(fabs((Real)amin), fabs((Real)amax));
+}
+template<> Real Grid4d<Vec3>::getMax()
+{
+  return sqrt(kn4dMaxVec<Vec3>(*this));
+}
+template<> Real Grid4d<Vec3>::getMin()
+{
+  return sqrt(kn4dMinVec<Vec3>(*this));
+}
+template<> Real Grid4d<Vec3>::getMaxAbs()
+{
+  return sqrt(kn4dMaxVec<Vec3>(*this));
+}
+
+template<class T> void Grid4d<T>::printGrid(int zSlice, int tSlice, bool printIndex, int bnd)
+{
+  std::ostringstream out;
+  out << std::endl;
+  FOR_IJKT_BND(*this, bnd)
+  {
+    IndexInt idx = (*this).index(i, j, k, t);
+    if (((zSlice >= 0 && k == zSlice) || (zSlice < 0)) &&
+        ((tSlice >= 0 && t == tSlice) || (tSlice < 0))) {
+      out << " ";
+      if (printIndex)
+        out << "  " << i << "," << j << "," << k << "," << t << ":";
+      out << (*this)[idx];
+      if (i == (*this).getSizeX() - 1 - bnd) {
+        out << std::endl;
+        if (j == (*this).getSizeY() - 1 - bnd) {
+          out << std::endl;
+          if (k == (*this).getSizeZ() - 1 - bnd) {
+            out << std::endl;
+          }
+        }
+      }
+    }
+  }
+  out << endl;
+  debMsg("Printing '" << this->getName() << "' " << out.str().c_str() << " ", 1);
+}
+
+// helper to set/get components of vec4 Grids
+struct knGetComp4d : public KernelBase {
+  knGetComp4d(const Grid4d<Vec4> &src, Grid4d<Real> &dst, int c)
+      : KernelBase(&src, 0), src(src), dst(dst), c(c)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid4d<Vec4> &src, Grid4d<Real> &dst, int c) const
+  {
+    dst[idx] = src[idx][c];
+  }
+  inline const Grid4d<Vec4> &getArg0()
+  {
+    return src;
+  }
+  typedef Grid4d<Vec4> type0;
+  inline Grid4d<Real> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid4d<Real> type1;
+  inline int &getArg2()
+  {
+    return c;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGetComp4d ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, src, dst, c);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const Grid4d<Vec4> &src;
+  Grid4d<Real> &dst;
+  int c;
+};
+;
+struct knSetComp4d : public KernelBase {
+  knSetComp4d(const Grid4d<Real> &src, Grid4d<Vec4> &dst, int c)
+      : KernelBase(&src, 0), src(src), dst(dst), c(c)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid4d<Real> &src, Grid4d<Vec4> &dst, int c) const
+  {
+    dst[idx][c] = src[idx];
+  }
+  inline const Grid4d<Real> &getArg0()
+  {
+    return src;
+  }
+  typedef Grid4d<Real> type0;
+  inline Grid4d<Vec4> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid4d<Vec4> type1;
+  inline int &getArg2()
+  {
+    return c;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetComp4d ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, src, dst, c);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const Grid4d<Real> &src;
+  Grid4d<Vec4> &dst;
+  int c;
+};
+;
+void getComp4d(const Grid4d<Vec4> &src, Grid4d<Real> &dst, int c)
+{
+  knGetComp4d(src, dst, c);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getComp4d", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid4d<Vec4> &src = *_args.getPtr<Grid4d<Vec4>>("src", 0, &_lock);
+      Grid4d<Real> &dst = *_args.getPtr<Grid4d<Real>>("dst", 1, &_lock);
+      int c = _args.get<int>("c", 2, &_lock);
+      _retval = getPyNone();
+      getComp4d(src, dst, c);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getComp4d", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getComp4d", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getComp4d("", "getComp4d", _W_0);
+extern "C" {
+void PbRegister_getComp4d()
+{
+  KEEP_UNUSED(_RP_getComp4d);
+}
+}
+
+;
+void setComp4d(const Grid4d<Real> &src, Grid4d<Vec4> &dst, int c)
+{
+  knSetComp4d(src, dst, c);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setComp4d", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid4d<Real> &src = *_args.getPtr<Grid4d<Real>>("src", 0, &_lock);
+      Grid4d<Vec4> &dst = *_args.getPtr<Grid4d<Vec4>>("dst", 1, &_lock);
+      int c = _args.get<int>("c", 2, &_lock);
+      _retval = getPyNone();
+      setComp4d(src, dst, c);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setComp4d", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setComp4d", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setComp4d("", "setComp4d", _W_1);
+extern "C" {
+void PbRegister_setComp4d()
+{
+  KEEP_UNUSED(_RP_setComp4d);
+}
+}
+
+;
+
+template<class T> struct knSetBnd4d : public KernelBase {
+  knSetBnd4d(Grid4d<T> &grid, T value, int w)
+      : KernelBase(&grid, 0), grid(grid), value(value), w(w)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, int t, Grid4d<T> &grid, T value, int w) const
+  {
+    bool bnd = (i <= w || i >= grid.getSizeX() - 1 - w || j <= w || j >= grid.getSizeY() - 1 - w ||
+                k <= w || k >= grid.getSizeZ() - 1 - w || t <= w || t >= grid.getSizeT() - 1 - w);
+    if (bnd)
+      grid(i, j, k, t) = value;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid4d<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  inline int &getArg2()
+  {
+    return w;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetBnd4d ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ
+               << " "
+                  " t "
+               << minT << " - " << maxT,
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    if (maxT > 1) {
+      for (int t = __r.begin(); t != (int)__r.end(); t++)
+        for (int k = 0; k < maxZ; k++)
+          for (int j = 0; j < maxY; j++)
+            for (int i = 0; i < maxX; i++)
+              op(i, j, k, t, grid, value, w);
+    }
+    else if (maxZ > 1) {
+      const int t = 0;
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < maxY; j++)
+          for (int i = 0; i < maxX; i++)
+            op(i, j, k, t, grid, value, w);
+    }
+    else {
+      const int t = 0;
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < maxX; i++)
+          op(i, j, k, t, grid, value, w);
+    }
+  }
+  void run()
+  {
+    if (maxT > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minT, maxT), *this);
+    }
+    else if (maxZ > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    }
+    else {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+    }
+  }
+  Grid4d<T> &grid;
+  T value;
+  int w;
+};
+
+template<class T> void Grid4d<T>::setBound(T value, int boundaryWidth)
+{
+  knSetBnd4d<T>(*this, value, boundaryWidth);
+}
+
+template<class T> struct knSetBnd4dNeumann : public KernelBase {
+  knSetBnd4dNeumann(Grid4d<T> &grid, int w) : KernelBase(&grid, 0), grid(grid), w(w)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, int t, Grid4d<T> &grid, int w) const
+  {
+    bool set = false;
+    int si = i, sj = j, sk = k, st = t;
+    if (i <= w) {
+      si = w + 1;
+      set = true;
+    }
+    if (i >= grid.getSizeX() - 1 - w) {
+      si = grid.getSizeX() - 1 - w - 1;
+      set = true;
+    }
+    if (j <= w) {
+      sj = w + 1;
+      set = true;
+    }
+    if (j >= grid.getSizeY() - 1 - w) {
+      sj = grid.getSizeY() - 1 - w - 1;
+      set = true;
+    }
+    if (k <= w) {
+      sk = w + 1;
+      set = true;
+    }
+    if (k >= grid.getSizeZ() - 1 - w) {
+      sk = grid.getSizeZ() - 1 - w - 1;
+      set = true;
+    }
+    if (t <= w) {
+      st = w + 1;
+      set = true;
+    }
+    if (t >= grid.getSizeT() - 1 - w) {
+      st = grid.getSizeT() - 1 - w - 1;
+      set = true;
+    }
+    if (set)
+      grid(i, j, k, t) = grid(si, sj, sk, st);
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return grid;
+  }
+  typedef Grid4d<T> type0;
+  inline int &getArg1()
+  {
+    return w;
+  }
+  typedef int type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetBnd4dNeumann ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ
+               << " "
+                  " t "
+               << minT << " - " << maxT,
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    if (maxT > 1) {
+      for (int t = __r.begin(); t != (int)__r.end(); t++)
+        for (int k = 0; k < maxZ; k++)
+          for (int j = 0; j < maxY; j++)
+            for (int i = 0; i < maxX; i++)
+              op(i, j, k, t, grid, w);
+    }
+    else if (maxZ > 1) {
+      const int t = 0;
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < maxY; j++)
+          for (int i = 0; i < maxX; i++)
+            op(i, j, k, t, grid, w);
+    }
+    else {
+      const int t = 0;
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < maxX; i++)
+          op(i, j, k, t, grid, w);
+    }
+  }
+  void run()
+  {
+    if (maxT > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minT, maxT), *this);
+    }
+    else if (maxZ > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    }
+    else {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+    }
+  }
+  Grid4d<T> &grid;
+  int w;
+};
+
+template<class T> void Grid4d<T>::setBoundNeumann(int boundaryWidth)
+{
+  knSetBnd4dNeumann<T>(*this, boundaryWidth);
+}
+
+//******************************************************************************
+// testing helpers
+
+//! compute maximal diference of two cells in the grid, needed for testing system
+
+Real grid4dMaxDiff(Grid4d<Real> &g1, Grid4d<Real> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJKT_BND(g1, 0)
+  {
+    maxVal = std::max(maxVal, (double)fabs(g1(i, j, k, t) - g2(i, j, k, t)));
+  }
+  return maxVal;
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "grid4dMaxDiff", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Real> &g1 = *_args.getPtr<Grid4d<Real>>("g1", 0, &_lock);
+      Grid4d<Real> &g2 = *_args.getPtr<Grid4d<Real>>("g2", 1, &_lock);
+      _retval = toPy(grid4dMaxDiff(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "grid4dMaxDiff", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("grid4dMaxDiff", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_grid4dMaxDiff("", "grid4dMaxDiff", _W_2);
+extern "C" {
+void PbRegister_grid4dMaxDiff()
+{
+  KEEP_UNUSED(_RP_grid4dMaxDiff);
+}
+}
+
+Real grid4dMaxDiffInt(Grid4d<int> &g1, Grid4d<int> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJKT_BND(g1, 0)
+  {
+    maxVal = std::max(maxVal, (double)fabs((double)g1(i, j, k, t) - g2(i, j, k, t)));
+  }
+  return maxVal;
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "grid4dMaxDiffInt", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<int> &g1 = *_args.getPtr<Grid4d<int>>("g1", 0, &_lock);
+      Grid4d<int> &g2 = *_args.getPtr<Grid4d<int>>("g2", 1, &_lock);
+      _retval = toPy(grid4dMaxDiffInt(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "grid4dMaxDiffInt", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("grid4dMaxDiffInt", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_grid4dMaxDiffInt("", "grid4dMaxDiffInt", _W_3);
+extern "C" {
+void PbRegister_grid4dMaxDiffInt()
+{
+  KEEP_UNUSED(_RP_grid4dMaxDiffInt);
+}
+}
+
+Real grid4dMaxDiffVec3(Grid4d<Vec3> &g1, Grid4d<Vec3> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJKT_BND(g1, 0)
+  {
+    double d = 0.;
+    for (int c = 0; c < 3; ++c) {
+      d += fabs((double)g1(i, j, k, t)[c] - (double)g2(i, j, k, t)[c]);
+    }
+    maxVal = std::max(maxVal, d);
+  }
+  return maxVal;
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "grid4dMaxDiffVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Vec3> &g1 = *_args.getPtr<Grid4d<Vec3>>("g1", 0, &_lock);
+      Grid4d<Vec3> &g2 = *_args.getPtr<Grid4d<Vec3>>("g2", 1, &_lock);
+      _retval = toPy(grid4dMaxDiffVec3(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "grid4dMaxDiffVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("grid4dMaxDiffVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_grid4dMaxDiffVec3("", "grid4dMaxDiffVec3", _W_4);
+extern "C" {
+void PbRegister_grid4dMaxDiffVec3()
+{
+  KEEP_UNUSED(_RP_grid4dMaxDiffVec3);
+}
+}
+
+Real grid4dMaxDiffVec4(Grid4d<Vec4> &g1, Grid4d<Vec4> &g2)
+{
+  double maxVal = 0.;
+  FOR_IJKT_BND(g1, 0)
+  {
+    double d = 0.;
+    for (int c = 0; c < 4; ++c) {
+      d += fabs((double)g1(i, j, k, t)[c] - (double)g2(i, j, k, t)[c]);
+    }
+    maxVal = std::max(maxVal, d);
+  }
+  return maxVal;
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "grid4dMaxDiffVec4", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Vec4> &g1 = *_args.getPtr<Grid4d<Vec4>>("g1", 0, &_lock);
+      Grid4d<Vec4> &g2 = *_args.getPtr<Grid4d<Vec4>>("g2", 1, &_lock);
+      _retval = toPy(grid4dMaxDiffVec4(g1, g2));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "grid4dMaxDiffVec4", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("grid4dMaxDiffVec4", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_grid4dMaxDiffVec4("", "grid4dMaxDiffVec4", _W_5);
+extern "C" {
+void PbRegister_grid4dMaxDiffVec4()
+{
+  KEEP_UNUSED(_RP_grid4dMaxDiffVec4);
+}
+}
+
+// set a region to some value
+
+template<class S> struct knSetRegion4d : public KernelBase {
+  knSetRegion4d(Grid4d<S> &dst, Vec4 start, Vec4 end, S value)
+      : KernelBase(&dst, 0), dst(dst), start(start), end(end), value(value)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, int t, Grid4d<S> &dst, Vec4 start, Vec4 end, S value) const
+  {
+    Vec4 p(i, j, k, t);
+    for (int c = 0; c < 4; ++c)
+      if (p[c] < start[c] || p[c] > end[c])
+        return;
+    dst(i, j, k, t) = value;
+  }
+  inline Grid4d<S> &getArg0()
+  {
+    return dst;
+  }
+  typedef Grid4d<S> type0;
+  inline Vec4 &getArg1()
+  {
+    return start;
+  }
+  typedef Vec4 type1;
+  inline Vec4 &getArg2()
+  {
+    return end;
+  }
+  typedef Vec4 type2;
+  inline S &getArg3()
+  {
+    return value;
+  }
+  typedef S type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetRegion4d ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ
+               << " "
+                  " t "
+               << minT << " - " << maxT,
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    if (maxT > 1) {
+      for (int t = __r.begin(); t != (int)__r.end(); t++)
+        for (int k = 0; k < maxZ; k++)
+          for (int j = 0; j < maxY; j++)
+            for (int i = 0; i < maxX; i++)
+              op(i, j, k, t, dst, start, end, value);
+    }
+    else if (maxZ > 1) {
+      const int t = 0;
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < maxY; j++)
+          for (int i = 0; i < maxX; i++)
+            op(i, j, k, t, dst, start, end, value);
+    }
+    else {
+      const int t = 0;
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < maxX; i++)
+          op(i, j, k, t, dst, start, end, value);
+    }
+  }
+  void run()
+  {
+    if (maxT > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minT, maxT), *this);
+    }
+    else if (maxZ > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    }
+    else {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+    }
+  }
+  Grid4d<S> &dst;
+  Vec4 start;
+  Vec4 end;
+  S value;
+};
+//! simple init functions in 4d
+void setRegion4d(Grid4d<Real> &dst, Vec4 start, Vec4 end, Real value)
+{
+  knSetRegion4d<Real>(dst, start, end, value);
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setRegion4d", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Real> &dst = *_args.getPtr<Grid4d<Real>>("dst", 0, &_lock);
+      Vec4 start = _args.get<Vec4>("start", 1, &_lock);
+      Vec4 end = _args.get<Vec4>("end", 2, &_lock);
+      Real value = _args.get<Real>("value", 3, &_lock);
+      _retval = getPyNone();
+      setRegion4d(dst, start, end, value);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setRegion4d", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setRegion4d", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setRegion4d("", "setRegion4d", _W_6);
+extern "C" {
+void PbRegister_setRegion4d()
+{
+  KEEP_UNUSED(_RP_setRegion4d);
+}
+}
+
+//! simple init functions in 4d, vec4
+void setRegion4dVec4(Grid4d<Vec4> &dst, Vec4 start, Vec4 end, Vec4 value)
+{
+  knSetRegion4d<Vec4>(dst, start, end, value);
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setRegion4dVec4", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Vec4> &dst = *_args.getPtr<Grid4d<Vec4>>("dst", 0, &_lock);
+      Vec4 start = _args.get<Vec4>("start", 1, &_lock);
+      Vec4 end = _args.get<Vec4>("end", 2, &_lock);
+      Vec4 value = _args.get<Vec4>("value", 3, &_lock);
+      _retval = getPyNone();
+      setRegion4dVec4(dst, start, end, value);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setRegion4dVec4", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setRegion4dVec4", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setRegion4dVec4("", "setRegion4dVec4", _W_7);
+extern "C" {
+void PbRegister_setRegion4dVec4()
+{
+  KEEP_UNUSED(_RP_setRegion4dVec4);
+}
+}
+
+//! slow helper to visualize tests, get a 3d slice of a 4d grid
+void getSliceFrom4d(Grid4d<Real> &src, int srct, Grid<Real> &dst)
+{
+  const int bnd = 0;
+  if (!src.isInBounds(Vec4i(bnd, bnd, bnd, srct)))
+    return;
+
+  for (int k = bnd; k < src.getSizeZ() - bnd; k++)
+    for (int j = bnd; j < src.getSizeY() - bnd; j++)
+      for (int i = bnd; i < src.getSizeX() - bnd; i++) {
+        if (!dst.isInBounds(Vec3i(i, j, k)))
+          continue;
+        dst(i, j, k) = src(i, j, k, srct);
+      }
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getSliceFrom4d", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Real> &src = *_args.getPtr<Grid4d<Real>>("src", 0, &_lock);
+      int srct = _args.get<int>("srct", 1, &_lock);
+      Grid<Real> &dst = *_args.getPtr<Grid<Real>>("dst", 2, &_lock);
+      _retval = getPyNone();
+      getSliceFrom4d(src, srct, dst);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getSliceFrom4d", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getSliceFrom4d", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getSliceFrom4d("", "getSliceFrom4d", _W_8);
+extern "C" {
+void PbRegister_getSliceFrom4d()
+{
+  KEEP_UNUSED(_RP_getSliceFrom4d);
+}
+}
+
+//! slow helper to visualize tests, get a 3d slice of a 4d vec4 grid
+void getSliceFrom4dVec(Grid4d<Vec4> &src, int srct, Grid<Vec3> &dst, Grid<Real> *dstt = NULL)
+{
+  const int bnd = 0;
+  if (!src.isInBounds(Vec4i(bnd, bnd, bnd, srct)))
+    return;
+
+  for (int k = bnd; k < src.getSizeZ() - bnd; k++)
+    for (int j = bnd; j < src.getSizeY() - bnd; j++)
+      for (int i = bnd; i < src.getSizeX() - bnd; i++) {
+        if (!dst.isInBounds(Vec3i(i, j, k)))
+          continue;
+        for (int c = 0; c < 3; ++c)
+          dst(i, j, k)[c] = src(i, j, k, srct)[c];
+        if (dstt)
+          (*dstt)(i, j, k) = src(i, j, k, srct)[3];
+      }
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getSliceFrom4dVec", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Vec4> &src = *_args.getPtr<Grid4d<Vec4>>("src", 0, &_lock);
+      int srct = _args.get<int>("srct", 1, &_lock);
+      Grid<Vec3> &dst = *_args.getPtr<Grid<Vec3>>("dst", 2, &_lock);
+      Grid<Real> *dstt = _args.getPtrOpt<Grid<Real>>("dstt", 3, NULL, &_lock);
+      _retval = getPyNone();
+      getSliceFrom4dVec(src, srct, dst, dstt);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getSliceFrom4dVec", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getSliceFrom4dVec", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getSliceFrom4dVec("", "getSliceFrom4dVec", _W_9);
+extern "C" {
+void PbRegister_getSliceFrom4dVec()
+{
+  KEEP_UNUSED(_RP_getSliceFrom4dVec);
+}
+}
+
+//******************************************************************************
+// interpolation
+
+//! same as in grid.h , but takes an additional optional "desired" size
+static inline void gridFactor4d(
+    Vec4 s1, Vec4 s2, Vec4 optSize, Vec4 scale, Vec4 &srcFac, Vec4 &retOff)
+{
+  for (int c = 0; c < 4; c++) {
+    if (optSize[c] > 0.) {
+      s2[c] = optSize[c];
+    }
+  }
+  srcFac = calcGridSizeFactor4d(s1, s2) / scale;
+  retOff = -retOff * srcFac + srcFac * 0.5;
+}
+
+//! interpolate 4d grid from one size to another size
+// real valued offsets & scale
+
+template<class S> struct knInterpol4d : public KernelBase {
+  knInterpol4d(Grid4d<S> &target, Grid4d<S> &source, const Vec4 &srcFac, const Vec4 &offset)
+      : KernelBase(&target, 0), target(target), source(source), srcFac(srcFac), offset(offset)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 int t,
+                 Grid4d<S> &target,
+                 Grid4d<S> &source,
+                 const Vec4 &srcFac,
+                 const Vec4 &offset) const
+  {
+    Vec4 pos = Vec4(i, j, k, t) * srcFac + offset;
+    target(i, j, k, t) = source.getInterpolated(pos);
+  }
+  inline Grid4d<S> &getArg0()
+  {
+    return target;
+  }
+  typedef Grid4d<S> type0;
+  inline Grid4d<S> &getArg1()
+  {
+    return source;
+  }
+  typedef Grid4d<S> type1;
+  inline const Vec4 &getArg2()
+  {
+    return srcFac;
+  }
+  typedef Vec4 type2;
+  inline const Vec4 &getArg3()
+  {
+    return offset;
+  }
+  typedef Vec4 type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knInterpol4d ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ
+               << " "
+                  " t "
+               << minT << " - " << maxT,
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    if (maxT > 1) {
+      for (int t = __r.begin(); t != (int)__r.end(); t++)
+        for (int k = 0; k < maxZ; k++)
+          for (int j = 0; j < maxY; j++)
+            for (int i = 0; i < maxX; i++)
+              op(i, j, k, t, target, source, srcFac, offset);
+    }
+    else if (maxZ > 1) {
+      const int t = 0;
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < maxY; j++)
+          for (int i = 0; i < maxX; i++)
+            op(i, j, k, t, target, source, srcFac, offset);
+    }
+    else {
+      const int t = 0;
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < maxX; i++)
+          op(i, j, k, t, target, source, srcFac, offset);
+    }
+  }
+  void run()
+  {
+    if (maxT > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minT, maxT), *this);
+    }
+    else if (maxZ > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    }
+    else {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+    }
+  }
+  Grid4d<S> &target;
+  Grid4d<S> &source;
+  const Vec4 &srcFac;
+  const Vec4 &offset;
+};
+//! linearly interpolate data of a 4d grid
+
+void interpolateGrid4d(Grid4d<Real> &target,
+                       Grid4d<Real> &source,
+                       Vec4 offset = Vec4(0.),
+                       Vec4 scale = Vec4(1.),
+                       Vec4 size = Vec4(-1.))
+{
+  Vec4 srcFac(1.), off2 = offset;
+  gridFactor4d(toVec4(source.getSize()), toVec4(target.getSize()), size, scale, srcFac, off2);
+  knInterpol4d<Real>(target, source, srcFac, off2);
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "interpolateGrid4d", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Real> &target = *_args.getPtr<Grid4d<Real>>("target", 0, &_lock);
+      Grid4d<Real> &source = *_args.getPtr<Grid4d<Real>>("source", 1, &_lock);
+      Vec4 offset = _args.getOpt<Vec4>("offset", 2, Vec4(0.), &_lock);
+      Vec4 scale = _args.getOpt<Vec4>("scale", 3, Vec4(1.), &_lock);
+      Vec4 size = _args.getOpt<Vec4>("size", 4, Vec4(-1.), &_lock);
+      _retval = getPyNone();
+      interpolateGrid4d(target, source, offset, scale, size);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "interpolateGrid4d", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("interpolateGrid4d", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_interpolateGrid4d("", "interpolateGrid4d", _W_10);
+extern "C" {
+void PbRegister_interpolateGrid4d()
+{
+  KEEP_UNUSED(_RP_interpolateGrid4d);
+}
+}
+
+//! linearly interpolate vec4 data of a 4d grid
+
+void interpolateGrid4dVec(Grid4d<Vec4> &target,
+                          Grid4d<Vec4> &source,
+                          Vec4 offset = Vec4(0.),
+                          Vec4 scale = Vec4(1.),
+                          Vec4 size = Vec4(-1.))
+{
+  Vec4 srcFac(1.), off2 = offset;
+  gridFactor4d(toVec4(source.getSize()), toVec4(target.getSize()), size, scale, srcFac, off2);
+  knInterpol4d<Vec4>(target, source, srcFac, off2);
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "interpolateGrid4dVec", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid4d<Vec4> &target = *_args.getPtr<Grid4d<Vec4>>("target", 0, &_lock);
+      Grid4d<Vec4> &source = *_args.getPtr<Grid4d<Vec4>>("source", 1, &_lock);
+      Vec4 offset = _args.getOpt<Vec4>("offset", 2, Vec4(0.), &_lock);
+      Vec4 scale = _args.getOpt<Vec4>("scale", 3, Vec4(1.), &_lock);
+      Vec4 size = _args.getOpt<Vec4>("size", 4, Vec4(-1.), &_lock);
+      _retval = getPyNone();
+      interpolateGrid4dVec(target, source, offset, scale, size);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "interpolateGrid4dVec", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("interpolateGrid4dVec", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_interpolateGrid4dVec("", "interpolateGrid4dVec", _W_11);
+extern "C" {
+void PbRegister_interpolateGrid4dVec()
+{
+  KEEP_UNUSED(_RP_interpolateGrid4dVec);
+}
+}
+
+// explicit instantiation
+template class Grid4d<int>;
+template class Grid4d<Real>;
+template class Grid4d<Vec3>;
+template class Grid4d<Vec4>;
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/grid4d.h b/extern/mantaflow/preprocessed/grid4d.h
new file mode 100644
index 00000000000..c3a98788da3
--- /dev/null
+++ b/extern/mantaflow/preprocessed/grid4d.h
@@ -0,0 +1,1558 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Grid representation
+ *
+ ******************************************************************************/
+
+#ifndef _GRID4D_H
+#define _GRID4D_H
+
+#include "manta.h"
+#include "vectorbase.h"
+#include "vector4d.h"
+#include "kernel.h"
+
+namespace Manta {
+
+//! Base class for all grids
+class Grid4dBase : public PbClass {
+ public:
+  enum Grid4dType { TypeNone = 0, TypeReal = 1, TypeInt = 2, TypeVec3 = 4, TypeVec4 = 8 };
+
+  Grid4dBase(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Grid4dBase::Grid4dBase", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new Grid4dBase(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Grid4dBase::Grid4dBase", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::Grid4dBase", e.what());
+      return -1;
+    }
+  }
+
+  //! Get the grids X dimension
+  inline int getSizeX() const
+  {
+    return mSize.x;
+  }
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeX", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeX());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::getSizeX", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::getSizeX", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids Y dimension
+  inline int getSizeY() const
+  {
+    return mSize.y;
+  }
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeY", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeY());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::getSizeY", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::getSizeY", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids Z dimension
+  inline int getSizeZ() const
+  {
+    return mSize.z;
+  }
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeZ", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeZ());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::getSizeZ", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::getSizeZ", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids T dimension
+  inline int getSizeT() const
+  {
+    return mSize.t;
+  }
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeT", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSizeT());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::getSizeT", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::getSizeT", e.what());
+      return 0;
+    }
+  }
+
+  //! Get the grids dimensions
+  inline Vec4i getSize() const
+  {
+    return mSize;
+  }
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSize", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getSize());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::getSize", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::getSize", e.what());
+      return 0;
+    }
+  }
+
+  //! Get Stride in X dimension
+  inline IndexInt getStrideX() const
+  {
+    return 1;
+  }
+  //! Get Stride in Y dimension
+  inline IndexInt getStrideY() const
+  {
+    return mSize.x;
+  }
+  //! Get Stride in Z dimension
+  inline IndexInt getStrideZ() const
+  {
+    return mStrideZ;
+  }
+  //! Get Stride in T dimension
+  inline IndexInt getStrideT() const
+  {
+    return mStrideT;
+  }
+
+  inline Real getDx()
+  {
+    return mDx;
+  }
+
+  //! Check if indices are within bounds, otherwise error (should only be called when debugging)
+  inline void checkIndex(int i, int j, int k, int t) const;
+  //! Check if indices are within bounds, otherwise error (should only be called when debugging)
+  inline void checkIndex(IndexInt idx) const;
+  //! Check if index is within given boundaries
+  inline bool isInBounds(const Vec4i &p, int bnd) const;
+  //! Check if index is within given boundaries
+  inline bool isInBounds(const Vec4i &p) const;
+  //! Check if index is within given boundaries
+  inline bool isInBounds(const Vec4 &p, int bnd = 0) const
+  {
+    return isInBounds(toVec4i(p), bnd);
+  }
+  //! Check if linear index is in the range of the array
+  inline bool isInBounds(IndexInt idx) const;
+
+  //! Get the type of grid
+  inline Grid4dType getType() const
+  {
+    return mType;
+  }
+  //! Check dimensionality
+  inline bool is3D() const
+  {
+    return true;
+  }
+  static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::is3D", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->is3D());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::is3D", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::is3D", e.what());
+      return 0;
+    }
+  }
+
+  inline bool is4D() const
+  {
+    return true;
+  }
+  static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4dBase::is4D", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->is4D());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4dBase::is4D", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4dBase::is4D", e.what());
+      return 0;
+    }
+  }
+
+  //! 3d compatibility
+  inline bool isInBounds(int i, int j, int k, int t, int bnd) const
+  {
+    return isInBounds(Vec4i(i, j, k, t), bnd);
+  }
+
+  //! Get index into the data
+  inline IndexInt index(int i, int j, int k, int t) const
+  {
+    DEBUG_ONLY(checkIndex(i, j, k, t));
+    return (IndexInt)i + (IndexInt)mSize.x * j + (IndexInt)mStrideZ * k + (IndexInt)mStrideT * t;
+  }
+  //! Get index into the data
+  inline IndexInt index(const Vec4i &pos) const
+  {
+    DEBUG_ONLY(checkIndex(pos.x, pos.y, pos.z, pos.t));
+    return (IndexInt)pos.x + (IndexInt)mSize.x * pos.y + (IndexInt)mStrideZ * pos.z +
+           (IndexInt)mStrideT * pos.t;
+  }
+
+ protected:
+  Grid4dType mType;
+  Vec4i mSize;
+  Real mDx;
+  // precomputed Z,T shift: to ensure 2D compatibility, always use this instead of sx*sy !
+  IndexInt mStrideZ;
+  IndexInt mStrideT;
+ public:
+  PbArgs _args;
+}
+#define _C_Grid4dBase
+;
+
+//! Grid class
+
+template<class T> class Grid4d : public Grid4dBase {
+ public:
+  //! init new grid, values are set to zero
+  Grid4d(FluidSolver *parent, bool show = true);
+  static int _W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Grid4d::Grid4d", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        bool show = _args.getOpt<bool>("show", 1, true, &_lock);
+        obj = new Grid4d(parent, show);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Grid4d::Grid4d", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::Grid4d", e.what());
+      return -1;
+    }
+  }
+
+  //! create new & copy content from another grid
+  Grid4d(const Grid4d<T> &a);
+  //! return memory to solver
+  virtual ~Grid4d();
+
+  typedef T BASETYPE;
+  typedef Grid4dBase BASETYPE_GRID;
+
+  void save(std::string name);
+  static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::save", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->save(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::save", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::save", e.what());
+      return 0;
+    }
+  }
+
+  void load(std::string name);
+  static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::load", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->load(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::load", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::load", e.what());
+      return 0;
+    }
+  }
+
+  //! set all cells to zero
+  void clear();
+  static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::clear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clear();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::clear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::clear", e.what());
+      return 0;
+    }
+  }
+
+  //! all kinds of access functions, use grid(), grid[] or grid.get()
+  //! access data
+  inline T get(int i, int j, int k, int t) const
+  {
+    return mData[index(i, j, k, t)];
+  }
+  //! access data
+  inline T &get(int i, int j, int k, int t)
+  {
+    return mData[index(i, j, k, t)];
+  }
+  //! access data
+  inline T get(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline T get(const Vec4i &pos) const
+  {
+    return mData[index(pos)];
+  }
+  //! access data
+  inline T &operator()(int i, int j, int k, int t)
+  {
+    return mData[index(i, j, k, t)];
+  }
+  //! access data
+  inline T operator()(int i, int j, int k, int t) const
+  {
+    return mData[index(i, j, k, t)];
+  }
+  //! access data
+  inline T &operator()(IndexInt idx)
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline T operator()(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline T &operator()(const Vec4i &pos)
+  {
+    return mData[index(pos)];
+  }
+  //! access data
+  inline T operator()(const Vec4i &pos) const
+  {
+    return mData[index(pos)];
+  }
+  //! access data
+  inline T &operator[](IndexInt idx)
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+  //! access data
+  inline const T operator[](IndexInt idx) const
+  {
+    DEBUG_ONLY(checkIndex(idx));
+    return mData[idx];
+  }
+
+  // interpolated access
+  inline T getInterpolated(const Vec4 &pos) const
+  {
+    return interpol4d<T>(mData, mSize, mStrideZ, mStrideT, pos);
+  }
+
+  // assignment / copy
+
+  //! warning - do not use "=" for grids in python, this copies the reference! not the grid
+  //! content...
+  // Grid4d<T>& operator=(const Grid4d<T>& a);
+  //! copy content from other grid (use this one instead of operator= !)
+  Grid4d<T> &copyFrom(const Grid4d<T> &a, bool copyType = true);
+  static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::copyFrom", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
+        bool copyType = _args.getOpt<bool>("copyType", 1, true, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->copyFrom(a, copyType));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::copyFrom", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::copyFrom", e.what());
+      return 0;
+    }
+  }
+  // old: { *this = a; }
+
+  // helper functions to work with grids in scene files
+
+  //! add/subtract other grid
+  void add(const Grid4d<T> &a);
+  static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::add", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->add(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::add", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::add", e.what());
+      return 0;
+    }
+  }
+
+  void sub(const Grid4d<T> &a);
+  static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::sub", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->sub(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::sub", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::sub", e.what());
+      return 0;
+    }
+  }
+
+  //! set all cells to constant value
+  void setConst(T s);
+  static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::setConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::setConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::setConst", e.what());
+      return 0;
+    }
+  }
+
+  //! add constant to all grid cells
+  void addConst(T s);
+  static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::addConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::addConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::addConst", e.what());
+      return 0;
+    }
+  }
+
+  //! add scaled other grid to current one (note, only "Real" factor, "T" type not supported here!)
+  void addScaled(const Grid4d<T> &a, const T &factor);
+  static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::addScaled", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
+        const T &factor = *_args.getPtr<T>("factor", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addScaled(a, factor);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::addScaled", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::addScaled", e.what());
+      return 0;
+    }
+  }
+
+  //! multiply contents of grid
+  void mult(const Grid4d<T> &a);
+  static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::mult", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->mult(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::mult", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::mult", e.what());
+      return 0;
+    }
+  }
+
+  //! multiply each cell by a constant scalar value
+  void multConst(T s);
+  static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::multConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->multConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::multConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::multConst", e.what());
+      return 0;
+    }
+  }
+
+  //! clamp content to range (for vec3, clamps each component separately)
+  void clamp(Real min, Real max);
+  static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::clamp", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real min = _args.get<Real>("min", 0, &_lock);
+        Real max = _args.get<Real>("max", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clamp(min, max);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::clamp", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::clamp", e.what());
+      return 0;
+    }
+  }
+
+  // common compound operators
+  //! get absolute max value in grid
+  Real getMaxAbs();
+  static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::getMaxAbs", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMaxAbs());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::getMaxAbs", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::getMaxAbs", e.what());
+      return 0;
+    }
+  }
+
+  //! get max value in grid
+  Real getMax();
+  static PyObject *_W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::getMax", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMax());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::getMax", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::getMax", e.what());
+      return 0;
+    }
+  }
+
+  //! get min value in grid
+  Real getMin();
+  static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::getMin", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMin());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::getMin", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::getMin", e.what());
+      return 0;
+    }
+  }
+
+  //! set all boundary cells to constant value (Dirichlet)
+  void setBound(T value, int boundaryWidth = 1);
+  static PyObject *_W_24(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::setBound", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T value = _args.get<T>("value", 0, &_lock);
+        int boundaryWidth = _args.getOpt<int>("boundaryWidth", 1, 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setBound(value, boundaryWidth);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::setBound", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::setBound", e.what());
+      return 0;
+    }
+  }
+
+  //! set all boundary cells to last inner value (Neumann)
+  void setBoundNeumann(int boundaryWidth = 1);
+  static PyObject *_W_25(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::setBoundNeumann", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setBoundNeumann(boundaryWidth);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::setBoundNeumann", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::setBoundNeumann", e.what());
+      return 0;
+    }
+  }
+
+  //! debugging helper, print grid from Python
+  void printGrid(int zSlice = -1, int tSlice = -1, bool printIndex = false, int bnd = 0);
+  static PyObject *_W_26(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Grid4d::printGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int zSlice = _args.getOpt<int>("zSlice", 0, -1, &_lock);
+        int tSlice = _args.getOpt<int>("tSlice", 1, -1, &_lock);
+        bool printIndex = _args.getOpt<bool>("printIndex", 2, false, &_lock);
+        int bnd = _args.getOpt<int>("bnd", 3, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->printGrid(zSlice, tSlice, printIndex, bnd);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Grid4d::printGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Grid4d::printGrid", e.what());
+      return 0;
+    }
+  }
+
+  // c++ only operators
+  template<class S> Grid4d<T> &operator+=(const Grid4d<S> &a);
+  template<class S> Grid4d<T> &operator+=(const S &a);
+  template<class S> Grid4d<T> &operator-=(const Grid4d<S> &a);
+  template<class S> Grid4d<T> &operator-=(const S &a);
+  template<class S> Grid4d<T> &operator*=(const Grid4d<S> &a);
+  template<class S> Grid4d<T> &operator*=(const S &a);
+  template<class S> Grid4d<T> &operator/=(const Grid4d<S> &a);
+  template<class S> Grid4d<T> &operator/=(const S &a);
+  Grid4d<T> &safeDivide(const Grid4d<T> &a);
+
+  //! Swap data with another grid (no actual data is moved)
+  void swap(Grid4d<T> &other);
+
+ protected:
+  T *mData;
+ public:
+  PbArgs _args;
+}
+#define _C_Grid4d
+;
+
+// Python doesn't know about templates: explicit aliases needed
+
+//! helper to compute grid conversion factor between local coordinates of two grids
+inline Vec4 calcGridSizeFactor4d(Vec4i s1, Vec4i s2)
+{
+  return Vec4(Real(s1[0]) / s2[0], Real(s1[1]) / s2[1], Real(s1[2]) / s2[2], Real(s1[3]) / s2[3]);
+}
+inline Vec4 calcGridSizeFactor4d(Vec4 s1, Vec4 s2)
+{
+  return Vec4(s1[0] / s2[0], s1[1] / s2[1], s1[2] / s2[2], s1[3] / s2[3]);
+}
+
+// prototypes for grid plugins
+void getComponent4d(const Grid4d<Vec4> &src, Grid4d<Real> &dst, int c);
+void setComponent4d(const Grid4d<Real> &src, Grid4d<Vec4> &dst, int c);
+
+//******************************************************************************
+// Implementation of inline functions
+
+inline void Grid4dBase::checkIndex(int i, int j, int k, int t) const
+{
+  if (i < 0 || j < 0 || i >= mSize.x || j >= mSize.y || k < 0 || k >= mSize.z || t < 0 ||
+      t >= mSize.t) {
+    std::ostringstream s;
+    s << "Grid4d " << mName << " dim " << mSize << " : index " << i << "," << j << "," << k << ","
+      << t << " out of bound ";
+    errMsg(s.str());
+  }
+}
+
+inline void Grid4dBase::checkIndex(IndexInt idx) const
+{
+  if (idx < 0 || idx >= mSize.x * mSize.y * mSize.z * mSize.t) {
+    std::ostringstream s;
+    s << "Grid4d " << mName << " dim " << mSize << " : index " << idx << " out of bound ";
+    errMsg(s.str());
+  }
+}
+
+bool Grid4dBase::isInBounds(const Vec4i &p) const
+{
+  return (p.x >= 0 && p.y >= 0 && p.z >= 0 && p.t >= 0 && p.x < mSize.x && p.y < mSize.y &&
+          p.z < mSize.z && p.t < mSize.t);
+}
+
+bool Grid4dBase::isInBounds(const Vec4i &p, int bnd) const
+{
+  bool ret = (p.x >= bnd && p.y >= bnd && p.x < mSize.x - bnd && p.y < mSize.y - bnd);
+  ret &= (p.z >= bnd && p.z < mSize.z - bnd);
+  ret &= (p.t >= bnd && p.t < mSize.t - bnd);
+  return ret;
+}
+//! Check if linear index is in the range of the array
+bool Grid4dBase::isInBounds(IndexInt idx) const
+{
+  if (idx < 0 || idx >= mSize.x * mSize.y * mSize.z * mSize.t) {
+    return false;
+  }
+  return true;
+}
+
+// note - ugly, mostly copied from normal GRID!
+
+template<class T, class S> struct Grid4dAdd : public KernelBase {
+  Grid4dAdd(Grid4d<T> &me, const Grid4d<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const Grid4d<S> &other) const
+  {
+    me[idx] += other[idx];
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const Grid4d<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid4d<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dAdd ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const Grid4d<S> &other;
+};
+template<class T, class S> struct Grid4dSub : public KernelBase {
+  Grid4dSub(Grid4d<T> &me, const Grid4d<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const Grid4d<S> &other) const
+  {
+    me[idx] -= other[idx];
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const Grid4d<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid4d<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dSub ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const Grid4d<S> &other;
+};
+template<class T, class S> struct Grid4dMult : public KernelBase {
+  Grid4dMult(Grid4d<T> &me, const Grid4d<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const Grid4d<S> &other) const
+  {
+    me[idx] *= other[idx];
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const Grid4d<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid4d<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dMult ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const Grid4d<S> &other;
+};
+template<class T, class S> struct Grid4dDiv : public KernelBase {
+  Grid4dDiv(Grid4d<T> &me, const Grid4d<S> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const Grid4d<S> &other) const
+  {
+    me[idx] /= other[idx];
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const Grid4d<S> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid4d<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dDiv ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const Grid4d<S> &other;
+};
+template<class T, class S> struct Grid4dAddScalar : public KernelBase {
+  Grid4dAddScalar(Grid4d<T> &me, const S &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const S &other) const
+  {
+    me[idx] += other;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dAddScalar ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const S &other;
+};
+template<class T, class S> struct Grid4dMultScalar : public KernelBase {
+  Grid4dMultScalar(Grid4d<T> &me, const S &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const S &other) const
+  {
+    me[idx] *= other;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dMultScalar ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const S &other;
+};
+template<class T, class S> struct Grid4dScaledAdd : public KernelBase {
+  Grid4dScaledAdd(Grid4d<T> &me, const Grid4d<T> &other, const S &factor)
+      : KernelBase(&me, 0), me(me), other(other), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const Grid4d<T> &other, const S &factor) const
+  {
+    me[idx] += factor * other[idx];
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const Grid4d<T> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid4d<T> type1;
+  inline const S &getArg2()
+  {
+    return factor;
+  }
+  typedef S type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dScaledAdd ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, factor);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const Grid4d<T> &other;
+  const S &factor;
+};
+
+template<class T> struct Grid4dSafeDiv : public KernelBase {
+  Grid4dSafeDiv(Grid4d<T> &me, const Grid4d<T> &other) : KernelBase(&me, 0), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, const Grid4d<T> &other) const
+  {
+    me[idx] = safeDivide(me[idx], other[idx]);
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline const Grid4d<T> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid4d<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dSafeDiv ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  const Grid4d<T> &other;
+};
+template<class T> struct Grid4dSetConst : public KernelBase {
+  Grid4dSetConst(Grid4d<T> &me, T value) : KernelBase(&me, 0), me(me), value(value)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid4d<T> &me, T value) const
+  {
+    me[idx] = value;
+  }
+  inline Grid4d<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid4d<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel Grid4dSetConst ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, value);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid4d<T> &me;
+  T value;
+};
+
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator+=(const Grid4d<S> &a)
+{
+  Grid4dAdd<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator+=(const S &a)
+{
+  Grid4dAddScalar<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator-=(const Grid4d<S> &a)
+{
+  Grid4dSub<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator-=(const S &a)
+{
+  Grid4dAddScalar<T, S>(*this, -a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator*=(const Grid4d<S> &a)
+{
+  Grid4dMult<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator*=(const S &a)
+{
+  Grid4dMultScalar<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator/=(const Grid4d<S> &a)
+{
+  Grid4dDiv<T, S>(*this, a);
+  return *this;
+}
+template<class T> template<class S> Grid4d<T> &Grid4d<T>::operator/=(const S &a)
+{
+  S rez((S)1.0 / a);
+  Grid4dMultScalar<T, S>(*this, rez);
+  return *this;
+}
+
+//******************************************************************************
+// Other helper functions
+
+inline Vec4 getGradient4d(const Grid4d<Real> &data, int i, int j, int k, int t)
+{
+  Vec4 v;
+  if (i > data.getSizeX() - 2)
+    i = data.getSizeX() - 2;
+  if (j > data.getSizeY() - 2)
+    j = data.getSizeY() - 2;
+  if (k > data.getSizeZ() - 2)
+    k = data.getSizeZ() - 2;
+  if (t > data.getSizeT() - 2)
+    t = data.getSizeT() - 2;
+  if (i < 1)
+    i = 1;
+  if (j < 1)
+    j = 1;
+  if (k < 1)
+    k = 1;
+  if (t < 1)
+    t = 1;
+  v = Vec4(data(i + 1, j, k, t) - data(i - 1, j, k, t),
+           data(i, j + 1, k, t) - data(i, j - 1, k, t),
+           data(i, j, k + 1, t) - data(i, j, k - 1, t),
+           data(i, j, k, t + 1) - data(i, j, k, t - 1));
+  return v;
+}
+
+template<class S> struct KnInterpolateGrid4dTempl : public KernelBase {
+  KnInterpolateGrid4dTempl(Grid4d<S> &target,
+                           Grid4d<S> &source,
+                           const Vec4 &sourceFactor,
+                           Vec4 offset)
+      : KernelBase(&target, 0),
+        target(target),
+        source(source),
+        sourceFactor(sourceFactor),
+        offset(offset)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 int t,
+                 Grid4d<S> &target,
+                 Grid4d<S> &source,
+                 const Vec4 &sourceFactor,
+                 Vec4 offset) const
+  {
+    Vec4 pos = Vec4(i, j, k, t) * sourceFactor + offset;
+    if (!source.is3D())
+      pos[2] = 0.;  // allow 2d -> 3d
+    if (!source.is4D())
+      pos[3] = 0.;  // allow 3d -> 4d
+    target(i, j, k, t) = source.getInterpolated(pos);
+  }
+  inline Grid4d<S> &getArg0()
+  {
+    return target;
+  }
+  typedef Grid4d<S> type0;
+  inline Grid4d<S> &getArg1()
+  {
+    return source;
+  }
+  typedef Grid4d<S> type1;
+  inline const Vec4 &getArg2()
+  {
+    return sourceFactor;
+  }
+  typedef Vec4 type2;
+  inline Vec4 &getArg3()
+  {
+    return offset;
+  }
+  typedef Vec4 type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnInterpolateGrid4dTempl ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ
+               << " "
+                  " t "
+               << minT << " - " << maxT,
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    if (maxT > 1) {
+      for (int t = __r.begin(); t != (int)__r.end(); t++)
+        for (int k = 0; k < maxZ; k++)
+          for (int j = 0; j < maxY; j++)
+            for (int i = 0; i < maxX; i++)
+              op(i, j, k, t, target, source, sourceFactor, offset);
+    }
+    else if (maxZ > 1) {
+      const int t = 0;
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < maxY; j++)
+          for (int i = 0; i < maxX; i++)
+            op(i, j, k, t, target, source, sourceFactor, offset);
+    }
+    else {
+      const int t = 0;
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < maxX; i++)
+          op(i, j, k, t, target, source, sourceFactor, offset);
+    }
+  }
+  void run()
+  {
+    if (maxT > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minT, maxT), *this);
+    }
+    else if (maxZ > 1) {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    }
+    else {
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+    }
+  }
+  Grid4d<S> &target;
+  Grid4d<S> &source;
+  const Vec4 &sourceFactor;
+  Vec4 offset;
+};
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/grid4d.h.reg.cpp b/extern/mantaflow/preprocessed/grid4d.h.reg.cpp
new file mode 100644
index 00000000000..7e490221ee6
--- /dev/null
+++ b/extern/mantaflow/preprocessed/grid4d.h.reg.cpp
@@ -0,0 +1,204 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "grid4d.h"
+namespace Manta {
+#ifdef _C_Grid4d
+static const Pb::Register _R_12("Grid4d<int>", "Grid4d<int>", "Grid4dBase");
+template<> const char *Namify<Grid4d<int>>::S = "Grid4d<int>";
+static const Pb::Register _R_13("Grid4d<int>", "Grid4d", Grid4d<int>::_W_8);
+static const Pb::Register _R_14("Grid4d<int>", "save", Grid4d<int>::_W_9);
+static const Pb::Register _R_15("Grid4d<int>", "load", Grid4d<int>::_W_10);
+static const Pb::Register _R_16("Grid4d<int>", "clear", Grid4d<int>::_W_11);
+static const Pb::Register _R_17("Grid4d<int>", "copyFrom", Grid4d<int>::_W_12);
+static const Pb::Register _R_18("Grid4d<int>", "add", Grid4d<int>::_W_13);
+static const Pb::Register _R_19("Grid4d<int>", "sub", Grid4d<int>::_W_14);
+static const Pb::Register _R_20("Grid4d<int>", "setConst", Grid4d<int>::_W_15);
+static const Pb::Register _R_21("Grid4d<int>", "addConst", Grid4d<int>::_W_16);
+static const Pb::Register _R_22("Grid4d<int>", "addScaled", Grid4d<int>::_W_17);
+static const Pb::Register _R_23("Grid4d<int>", "mult", Grid4d<int>::_W_18);
+static const Pb::Register _R_24("Grid4d<int>", "multConst", Grid4d<int>::_W_19);
+static const Pb::Register _R_25("Grid4d<int>", "clamp", Grid4d<int>::_W_20);
+static const Pb::Register _R_26("Grid4d<int>", "getMaxAbs", Grid4d<int>::_W_21);
+static const Pb::Register _R_27("Grid4d<int>", "getMax", Grid4d<int>::_W_22);
+static const Pb::Register _R_28("Grid4d<int>", "getMin", Grid4d<int>::_W_23);
+static const Pb::Register _R_29("Grid4d<int>", "setBound", Grid4d<int>::_W_24);
+static const Pb::Register _R_30("Grid4d<int>", "setBoundNeumann", Grid4d<int>::_W_25);
+static const Pb::Register _R_31("Grid4d<int>", "printGrid", Grid4d<int>::_W_26);
+static const Pb::Register _R_32("Grid4d<Real>", "Grid4d<Real>", "Grid4dBase");
+template<> const char *Namify<Grid4d<Real>>::S = "Grid4d<Real>";
+static const Pb::Register _R_33("Grid4d<Real>", "Grid4d", Grid4d<Real>::_W_8);
+static const Pb::Register _R_34("Grid4d<Real>", "save", Grid4d<Real>::_W_9);
+static const Pb::Register _R_35("Grid4d<Real>", "load", Grid4d<Real>::_W_10);
+static const Pb::Register _R_36("Grid4d<Real>", "clear", Grid4d<Real>::_W_11);
+static const Pb::Register _R_37("Grid4d<Real>", "copyFrom", Grid4d<Real>::_W_12);
+static const Pb::Register _R_38("Grid4d<Real>", "add", Grid4d<Real>::_W_13);
+static const Pb::Register _R_39("Grid4d<Real>", "sub", Grid4d<Real>::_W_14);
+static const Pb::Register _R_40("Grid4d<Real>", "setConst", Grid4d<Real>::_W_15);
+static const Pb::Register _R_41("Grid4d<Real>", "addConst", Grid4d<Real>::_W_16);
+static const Pb::Register _R_42("Grid4d<Real>", "addScaled", Grid4d<Real>::_W_17);
+static const Pb::Register _R_43("Grid4d<Real>", "mult", Grid4d<Real>::_W_18);
+static const Pb::Register _R_44("Grid4d<Real>", "multConst", Grid4d<Real>::_W_19);
+static const Pb::Register _R_45("Grid4d<Real>", "clamp", Grid4d<Real>::_W_20);
+static const Pb::Register _R_46("Grid4d<Real>", "getMaxAbs", Grid4d<Real>::_W_21);
+static const Pb::Register _R_47("Grid4d<Real>", "getMax", Grid4d<Real>::_W_22);
+static const Pb::Register _R_48("Grid4d<Real>", "getMin", Grid4d<Real>::_W_23);
+static const Pb::Register _R_49("Grid4d<Real>", "setBound", Grid4d<Real>::_W_24);
+static const Pb::Register _R_50("Grid4d<Real>", "setBoundNeumann", Grid4d<Real>::_W_25);
+static const Pb::Register _R_51("Grid4d<Real>", "printGrid", Grid4d<Real>::_W_26);
+static const Pb::Register _R_52("Grid4d<Vec3>", "Grid4d<Vec3>", "Grid4dBase");
+template<> const char *Namify<Grid4d<Vec3>>::S = "Grid4d<Vec3>";
+static const Pb::Register _R_53("Grid4d<Vec3>", "Grid4d", Grid4d<Vec3>::_W_8);
+static const Pb::Register _R_54("Grid4d<Vec3>", "save", Grid4d<Vec3>::_W_9);
+static const Pb::Register _R_55("Grid4d<Vec3>", "load", Grid4d<Vec3>::_W_10);
+static const Pb::Register _R_56("Grid4d<Vec3>", "clear", Grid4d<Vec3>::_W_11);
+static const Pb::Register _R_57("Grid4d<Vec3>", "copyFrom", Grid4d<Vec3>::_W_12);
+static const Pb::Register _R_58("Grid4d<Vec3>", "add", Grid4d<Vec3>::_W_13);
+static const Pb::Register _R_59("Grid4d<Vec3>", "sub", Grid4d<Vec3>::_W_14);
+static const Pb::Register _R_60("Grid4d<Vec3>", "setConst", Grid4d<Vec3>::_W_15);
+static const Pb::Register _R_61("Grid4d<Vec3>", "addConst", Grid4d<Vec3>::_W_16);
+static const Pb::Register _R_62("Grid4d<Vec3>", "addScaled", Grid4d<Vec3>::_W_17);
+static const Pb::Register _R_63("Grid4d<Vec3>", "mult", Grid4d<Vec3>::_W_18);
+static const Pb::Register _R_64("Grid4d<Vec3>", "multConst", Grid4d<Vec3>::_W_19);
+static const Pb::Register _R_65("Grid4d<Vec3>", "clamp", Grid4d<Vec3>::_W_20);
+static const Pb::Register _R_66("Grid4d<Vec3>", "getMaxAbs", Grid4d<Vec3>::_W_21);
+static const Pb::Register _R_67("Grid4d<Vec3>", "getMax", Grid4d<Vec3>::_W_22);
+static const Pb::Register _R_68("Grid4d<Vec3>", "getMin", Grid4d<Vec3>::_W_23);
+static const Pb::Register _R_69("Grid4d<Vec3>", "setBound", Grid4d<Vec3>::_W_24);
+static const Pb::Register _R_70("Grid4d<Vec3>", "setBoundNeumann", Grid4d<Vec3>::_W_25);
+static const Pb::Register _R_71("Grid4d<Vec3>", "printGrid", Grid4d<Vec3>::_W_26);
+static const Pb::Register _R_72("Grid4d<Vec4>", "Grid4d<Vec4>", "Grid4dBase");
+template<> const char *Namify<Grid4d<Vec4>>::S = "Grid4d<Vec4>";
+static const Pb::Register _R_73("Grid4d<Vec4>", "Grid4d", Grid4d<Vec4>::_W_8);
+static const Pb::Register _R_74("Grid4d<Vec4>", "save", Grid4d<Vec4>::_W_9);
+static const Pb::Register _R_75("Grid4d<Vec4>", "load", Grid4d<Vec4>::_W_10);
+static const Pb::Register _R_76("Grid4d<Vec4>", "clear", Grid4d<Vec4>::_W_11);
+static const Pb::Register _R_77("Grid4d<Vec4>", "copyFrom", Grid4d<Vec4>::_W_12);
+static const Pb::Register _R_78("Grid4d<Vec4>", "add", Grid4d<Vec4>::_W_13);
+static const Pb::Register _R_79("Grid4d<Vec4>", "sub", Grid4d<Vec4>::_W_14);
+static const Pb::Register _R_80("Grid4d<Vec4>", "setConst", Grid4d<Vec4>::_W_15);
+static const Pb::Register _R_81("Grid4d<Vec4>", "addConst", Grid4d<Vec4>::_W_16);
+static const Pb::Register _R_82("Grid4d<Vec4>", "addScaled", Grid4d<Vec4>::_W_17);
+static const Pb::Register _R_83("Grid4d<Vec4>", "mult", Grid4d<Vec4>::_W_18);
+static const Pb::Register _R_84("Grid4d<Vec4>", "multConst", Grid4d<Vec4>::_W_19);
+static const Pb::Register _R_85("Grid4d<Vec4>", "clamp", Grid4d<Vec4>::_W_20);
+static const Pb::Register _R_86("Grid4d<Vec4>", "getMaxAbs", Grid4d<Vec4>::_W_21);
+static const Pb::Register _R_87("Grid4d<Vec4>", "getMax", Grid4d<Vec4>::_W_22);
+static const Pb::Register _R_88("Grid4d<Vec4>", "getMin", Grid4d<Vec4>::_W_23);
+static const Pb::Register _R_89("Grid4d<Vec4>", "setBound", Grid4d<Vec4>::_W_24);
+static const Pb::Register _R_90("Grid4d<Vec4>", "setBoundNeumann", Grid4d<Vec4>::_W_25);
+static const Pb::Register _R_91("Grid4d<Vec4>", "printGrid", Grid4d<Vec4>::_W_26);
+#endif
+#ifdef _C_Grid4dBase
+static const Pb::Register _R_92("Grid4dBase", "Grid4dBase", "PbClass");
+template<> const char *Namify<Grid4dBase>::S = "Grid4dBase";
+static const Pb::Register _R_93("Grid4dBase", "Grid4dBase", Grid4dBase::_W_0);
+static const Pb::Register _R_94("Grid4dBase", "getSizeX", Grid4dBase::_W_1);
+static const Pb::Register _R_95("Grid4dBase", "getSizeY", Grid4dBase::_W_2);
+static const Pb::Register _R_96("Grid4dBase", "getSizeZ", Grid4dBase::_W_3);
+static const Pb::Register _R_97("Grid4dBase", "getSizeT", Grid4dBase::_W_4);
+static const Pb::Register _R_98("Grid4dBase", "getSize", Grid4dBase::_W_5);
+static const Pb::Register _R_99("Grid4dBase", "is3D", Grid4dBase::_W_6);
+static const Pb::Register _R_100("Grid4dBase", "is4D", Grid4dBase::_W_7);
+#endif
+static const Pb::Register _R_8("Grid4d<int>", "Grid4Int", "");
+static const Pb::Register _R_9("Grid4d<Real>", "Grid4Real", "");
+static const Pb::Register _R_10("Grid4d<Vec3>", "Grid4Vec3", "");
+static const Pb::Register _R_11("Grid4d<Vec4>", "Grid4Vec4", "");
+extern "C" {
+void PbRegister_file_8()
+{
+  KEEP_UNUSED(_R_12);
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+  KEEP_UNUSED(_R_23);
+  KEEP_UNUSED(_R_24);
+  KEEP_UNUSED(_R_25);
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+  KEEP_UNUSED(_R_33);
+  KEEP_UNUSED(_R_34);
+  KEEP_UNUSED(_R_35);
+  KEEP_UNUSED(_R_36);
+  KEEP_UNUSED(_R_37);
+  KEEP_UNUSED(_R_38);
+  KEEP_UNUSED(_R_39);
+  KEEP_UNUSED(_R_40);
+  KEEP_UNUSED(_R_41);
+  KEEP_UNUSED(_R_42);
+  KEEP_UNUSED(_R_43);
+  KEEP_UNUSED(_R_44);
+  KEEP_UNUSED(_R_45);
+  KEEP_UNUSED(_R_46);
+  KEEP_UNUSED(_R_47);
+  KEEP_UNUSED(_R_48);
+  KEEP_UNUSED(_R_49);
+  KEEP_UNUSED(_R_50);
+  KEEP_UNUSED(_R_51);
+  KEEP_UNUSED(_R_52);
+  KEEP_UNUSED(_R_53);
+  KEEP_UNUSED(_R_54);
+  KEEP_UNUSED(_R_55);
+  KEEP_UNUSED(_R_56);
+  KEEP_UNUSED(_R_57);
+  KEEP_UNUSED(_R_58);
+  KEEP_UNUSED(_R_59);
+  KEEP_UNUSED(_R_60);
+  KEEP_UNUSED(_R_61);
+  KEEP_UNUSED(_R_62);
+  KEEP_UNUSED(_R_63);
+  KEEP_UNUSED(_R_64);
+  KEEP_UNUSED(_R_65);
+  KEEP_UNUSED(_R_66);
+  KEEP_UNUSED(_R_67);
+  KEEP_UNUSED(_R_68);
+  KEEP_UNUSED(_R_69);
+  KEEP_UNUSED(_R_70);
+  KEEP_UNUSED(_R_71);
+  KEEP_UNUSED(_R_72);
+  KEEP_UNUSED(_R_73);
+  KEEP_UNUSED(_R_74);
+  KEEP_UNUSED(_R_75);
+  KEEP_UNUSED(_R_76);
+  KEEP_UNUSED(_R_77);
+  KEEP_UNUSED(_R_78);
+  KEEP_UNUSED(_R_79);
+  KEEP_UNUSED(_R_80);
+  KEEP_UNUSED(_R_81);
+  KEEP_UNUSED(_R_82);
+  KEEP_UNUSED(_R_83);
+  KEEP_UNUSED(_R_84);
+  KEEP_UNUSED(_R_85);
+  KEEP_UNUSED(_R_86);
+  KEEP_UNUSED(_R_87);
+  KEEP_UNUSED(_R_88);
+  KEEP_UNUSED(_R_89);
+  KEEP_UNUSED(_R_90);
+  KEEP_UNUSED(_R_91);
+  KEEP_UNUSED(_R_92);
+  KEEP_UNUSED(_R_93);
+  KEEP_UNUSED(_R_94);
+  KEEP_UNUSED(_R_95);
+  KEEP_UNUSED(_R_96);
+  KEEP_UNUSED(_R_97);
+  KEEP_UNUSED(_R_98);
+  KEEP_UNUSED(_R_99);
+  KEEP_UNUSED(_R_100);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/kernel.cpp b/extern/mantaflow/preprocessed/kernel.cpp
new file mode 100644
index 00000000000..72a5efff795
--- /dev/null
+++ b/extern/mantaflow/preprocessed/kernel.cpp
@@ -0,0 +1,61 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Function and macros for defining compution kernels over grids
+ *
+ ******************************************************************************/
+
+#include "kernel.h"
+#include "grid.h"
+#include "grid4d.h"
+#include "particle.h"
+
+namespace Manta {
+
+KernelBase::KernelBase(const GridBase *base, int bnd)
+    : maxX(base->getSizeX() - bnd),
+      maxY(base->getSizeY() - bnd),
+      maxZ(base->is3D() ? (base->getSizeZ() - bnd) : 1),
+      minZ(base->is3D() ? bnd : 0),
+      maxT(1),
+      minT(0),
+      X(base->getStrideX()),
+      Y(base->getStrideY()),
+      Z(base->getStrideZ()),
+      dimT(0),
+      size(base->getSizeX() * base->getSizeY() * (IndexInt)base->getSizeZ())
+{
+}
+
+KernelBase::KernelBase(IndexInt num)
+    : maxX(0), maxY(0), maxZ(0), minZ(0), maxT(0), X(0), Y(0), Z(0), dimT(0), size(num)
+{
+}
+
+KernelBase::KernelBase(const Grid4dBase *base, int bnd)
+    : maxX(base->getSizeX() - bnd),
+      maxY(base->getSizeY() - bnd),
+      maxZ(base->getSizeZ() - bnd),
+      minZ(bnd),
+      maxT(base->getSizeT() - bnd),
+      minT(bnd),
+      X(base->getStrideX()),
+      Y(base->getStrideY()),
+      Z(base->getStrideZ()),
+      dimT(base->getStrideT()),
+      size(base->getSizeX() * base->getSizeY() * base->getSizeZ() * (IndexInt)base->getSizeT())
+{
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/kernel.h b/extern/mantaflow/preprocessed/kernel.h
new file mode 100644
index 00000000000..90e30cd21e1
--- /dev/null
+++ b/extern/mantaflow/preprocessed/kernel.h
@@ -0,0 +1,99 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Function and macros for defining compution kernels over grids
+ *
+ ******************************************************************************/
+
+#ifndef _KERNEL_H
+#define _KERNEL_H
+
+#if TBB == 1
+#  include <tbb/blocked_range3d.h>
+#  include <tbb/blocked_range.h>
+#  include <tbb/parallel_for.h>
+#  include <tbb/parallel_reduce.h>
+#endif
+
+#if OPENMP == 1
+#  include <omp.h>
+#endif
+
+#include "general.h"
+
+namespace Manta {
+
+// fwd decl
+class GridBase;
+class Grid4dBase;
+class ParticleBase;
+
+// simple iteration
+#define FOR_IJK_BND(grid, bnd) \
+  for (int k = ((grid).is3D() ? bnd : 0), \
+           __kmax = ((grid).is3D() ? ((grid).getSizeZ() - bnd) : 1); \
+       k < __kmax; \
+       k++) \
+    for (int j = bnd; j < (grid).getSizeY() - bnd; j++) \
+      for (int i = bnd; i < (grid).getSizeX() - bnd; i++)
+
+#define FOR_IJK_REVERSE(grid) \
+  for (int k = (grid).getSizeZ() - 1; k >= 0; k--) \
+    for (int j = (grid).getSizeY() - 1; j >= 0; j--) \
+      for (int i = (grid).getSizeX() - 1; i >= 0; i--)
+
+#define FOR_IDX(grid) \
+  for (IndexInt idx = 0, total = (grid).getSizeX() * (grid).getSizeY() * (grid).getSizeZ(); \
+       idx < total; \
+       idx++)
+
+#define FOR_IJK(grid) FOR_IJK_BND(grid, 0)
+
+#define FOR_PARTS(parts) for (IndexInt idx = 0, total = (parts).size(); idx < total; idx++)
+
+// simple loop over 4d grids
+#define FOR_IJKT_BND(grid, bnd) \
+  for (int t = ((grid).is4D() ? bnd : 0); t < ((grid).is4D() ? ((grid).getSizeT() - bnd) : 1); \
+       ++t) \
+    for (int k = ((grid).is3D() ? bnd : 0); k < ((grid).is3D() ? ((grid).getSizeZ() - bnd) : 1); \
+         ++k) \
+      for (int j = bnd; j < (grid).getSizeY() - bnd; ++j) \
+        for (int i = bnd; i < (grid).getSizeX() - bnd; ++i)
+
+//! Basic data structure for kernel data, initialized based on kernel type (e.g. single, idx, etc).
+struct KernelBase {
+  int maxX, maxY, maxZ, minZ, maxT, minT;
+  int X, Y, Z, dimT;
+  IndexInt size;
+
+  KernelBase(IndexInt num);
+  KernelBase(const GridBase *base, int bnd);
+  KernelBase(const Grid4dBase *base, int bnd);
+
+  // specify in your derived classes:
+
+  // kernel operators
+  // ijk mode: void operator() (int i, int j, int k)
+  // idx mode: void operator() (IndexInt idx)
+
+  // reduce mode:
+  // void join(classname& other)
+  // void setup()
+};
+
+}  // namespace Manta
+
+// all kernels will automatically be added to the "Kernels" group in doxygen
+
+#endif
diff --git a/extern/mantaflow/preprocessed/kernel.h.reg.cpp b/extern/mantaflow/preprocessed/kernel.h.reg.cpp
new file mode 100644
index 00000000000..002396024ea
--- /dev/null
+++ b/extern/mantaflow/preprocessed/kernel.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "kernel.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_15()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/levelset.cpp b/extern/mantaflow/preprocessed/levelset.cpp
new file mode 100644
index 00000000000..dcc10718d71
--- /dev/null
+++ b/extern/mantaflow/preprocessed/levelset.cpp
@@ -0,0 +1,876 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Levelset
+ *
+ ******************************************************************************/
+
+#include "levelset.h"
+#include "fastmarch.h"
+#include "kernel.h"
+#include "mcubes.h"
+#include "mesh.h"
+#include <stack>
+
+using namespace std;
+namespace Manta {
+
+//************************************************************************
+// Helper functions and kernels for marching
+
+static const int FlagInited = FastMarch<FmHeapEntryOut, +1>::FlagInited;
+
+// neighbor lookup vectors
+static const Vec3i neighbors[6] = {Vec3i(-1, 0, 0),
+                                   Vec3i(1, 0, 0),
+                                   Vec3i(0, -1, 0),
+                                   Vec3i(0, 1, 0),
+                                   Vec3i(0, 0, -1),
+                                   Vec3i(0, 0, 1)};
+
+struct InitFmIn : public KernelBase {
+  InitFmIn(const FlagGrid &flags,
+           Grid<int> &fmFlags,
+           Grid<Real> &phi,
+           bool ignoreWalls,
+           int obstacleType)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        fmFlags(fmFlags),
+        phi(phi),
+        ignoreWalls(ignoreWalls),
+        obstacleType(obstacleType)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<int> &fmFlags,
+                 Grid<Real> &phi,
+                 bool ignoreWalls,
+                 int obstacleType) const
+  {
+    const IndexInt idx = flags.index(i, j, k);
+    const Real v = phi[idx];
+    if (ignoreWalls) {
+      if (v >= 0. && ((flags[idx] & obstacleType) == 0))
+        fmFlags[idx] = FlagInited;
+      else
+        fmFlags[idx] = 0;
+    }
+    else {
+      if (v >= 0)
+        fmFlags[idx] = FlagInited;
+      else
+        fmFlags[idx] = 0;
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<int> &getArg1()
+  {
+    return fmFlags;
+  }
+  typedef Grid<int> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type2;
+  inline bool &getArg3()
+  {
+    return ignoreWalls;
+  }
+  typedef bool type3;
+  inline int &getArg4()
+  {
+    return obstacleType;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel InitFmIn ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, fmFlags, phi, ignoreWalls, obstacleType);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, fmFlags, phi, ignoreWalls, obstacleType);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<int> &fmFlags;
+  Grid<Real> &phi;
+  bool ignoreWalls;
+  int obstacleType;
+};
+
+struct InitFmOut : public KernelBase {
+  InitFmOut(const FlagGrid &flags,
+            Grid<int> &fmFlags,
+            Grid<Real> &phi,
+            bool ignoreWalls,
+            int obstacleType)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        fmFlags(fmFlags),
+        phi(phi),
+        ignoreWalls(ignoreWalls),
+        obstacleType(obstacleType)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<int> &fmFlags,
+                 Grid<Real> &phi,
+                 bool ignoreWalls,
+                 int obstacleType) const
+  {
+    const IndexInt idx = flags.index(i, j, k);
+    const Real v = phi[idx];
+    if (ignoreWalls) {
+      fmFlags[idx] = (v < 0) ? FlagInited : 0;
+      if ((flags[idx] & obstacleType) != 0) {
+        fmFlags[idx] = 0;
+        phi[idx] = 0;
+      }
+    }
+    else {
+      fmFlags[idx] = (v < 0) ? FlagInited : 0;
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<int> &getArg1()
+  {
+    return fmFlags;
+  }
+  typedef Grid<int> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type2;
+  inline bool &getArg3()
+  {
+    return ignoreWalls;
+  }
+  typedef bool type3;
+  inline int &getArg4()
+  {
+    return obstacleType;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel InitFmOut ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, fmFlags, phi, ignoreWalls, obstacleType);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, fmFlags, phi, ignoreWalls, obstacleType);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<int> &fmFlags;
+  Grid<Real> &phi;
+  bool ignoreWalls;
+  int obstacleType;
+};
+
+struct SetUninitialized : public KernelBase {
+  SetUninitialized(const Grid<int> &flags,
+                   Grid<int> &fmFlags,
+                   Grid<Real> &phi,
+                   const Real val,
+                   int ignoreWalls,
+                   int obstacleType)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        fmFlags(fmFlags),
+        phi(phi),
+        val(val),
+        ignoreWalls(ignoreWalls),
+        obstacleType(obstacleType)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const Grid<int> &flags,
+                 Grid<int> &fmFlags,
+                 Grid<Real> &phi,
+                 const Real val,
+                 int ignoreWalls,
+                 int obstacleType) const
+  {
+    if (ignoreWalls) {
+      if ((fmFlags(i, j, k) != FlagInited) && ((flags(i, j, k) & obstacleType) == 0)) {
+        phi(i, j, k) = val;
+      }
+    }
+    else {
+      if ((fmFlags(i, j, k) != FlagInited))
+        phi(i, j, k) = val;
+    }
+  }
+  inline const Grid<int> &getArg0()
+  {
+    return flags;
+  }
+  typedef Grid<int> type0;
+  inline Grid<int> &getArg1()
+  {
+    return fmFlags;
+  }
+  typedef Grid<int> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type2;
+  inline const Real &getArg3()
+  {
+    return val;
+  }
+  typedef Real type3;
+  inline int &getArg4()
+  {
+    return ignoreWalls;
+  }
+  typedef int type4;
+  inline int &getArg5()
+  {
+    return obstacleType;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel SetUninitialized ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, fmFlags, phi, val, ignoreWalls, obstacleType);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, fmFlags, phi, val, ignoreWalls, obstacleType);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<int> &flags;
+  Grid<int> &fmFlags;
+  Grid<Real> &phi;
+  const Real val;
+  int ignoreWalls;
+  int obstacleType;
+};
+
+template<bool inward>
+inline bool isAtInterface(const Grid<int> &fmFlags, Grid<Real> &phi, const Vec3i &p)
+{
+  // check for interface
+  int max = phi.is3D() ? 6 : 4;
+  for (int nb = 0; nb < max; nb++) {
+    const Vec3i pn(p + neighbors[nb]);
+    if (!fmFlags.isInBounds(pn))
+      continue;
+
+    if (fmFlags(pn) != FlagInited)
+      continue;
+    if ((inward && phi(pn) >= 0.) || (!inward && phi(pn) < 0.))
+      return true;
+  }
+  return false;
+}
+
+//************************************************************************
+// Levelset class def
+
+LevelsetGrid::LevelsetGrid(FluidSolver *parent, bool show) : Grid<Real>(parent, show)
+{
+  mType = (GridType)(TypeLevelset | TypeReal);
+}
+
+LevelsetGrid::LevelsetGrid(FluidSolver *parent, Real *data, bool show)
+    : Grid<Real>(parent, data, show)
+{
+  mType = (GridType)(TypeLevelset | TypeReal);
+}
+
+Real LevelsetGrid::invalidTimeValue()
+{
+  return FastMarch<FmHeapEntryOut, 1>::InvalidTime();
+}
+
+//! Kernel: perform levelset union
+struct KnJoin : public KernelBase {
+  KnJoin(Grid<Real> &a, const Grid<Real> &b) : KernelBase(&a, 0), a(a), b(b)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Real> &a, const Grid<Real> &b) const
+  {
+    a[idx] = min(a[idx], b[idx]);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return a;
+  }
+  typedef Grid<Real> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return b;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnJoin ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, a, b);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &a;
+  const Grid<Real> &b;
+};
+void LevelsetGrid::join(const LevelsetGrid &o)
+{
+  KnJoin(*this, o);
+}
+
+//! subtract b, note does not preserve SDF!
+struct KnSubtract : public KernelBase {
+  KnSubtract(Grid<Real> &a, const Grid<Real> &b, const FlagGrid *flags, int subtractType)
+      : KernelBase(&a, 0), a(a), b(b), flags(flags), subtractType(subtractType)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 Grid<Real> &a,
+                 const Grid<Real> &b,
+                 const FlagGrid *flags,
+                 int subtractType) const
+  {
+    if (flags && ((*flags)(idx)&subtractType) == 0)
+      return;
+    if (b[idx] < 0.)
+      a[idx] = b[idx] * -1.;
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return a;
+  }
+  typedef Grid<Real> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return b;
+  }
+  typedef Grid<Real> type1;
+  inline const FlagGrid *getArg2()
+  {
+    return flags;
+  }
+  typedef FlagGrid type2;
+  inline int &getArg3()
+  {
+    return subtractType;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnSubtract ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, a, b, flags, subtractType);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &a;
+  const Grid<Real> &b;
+  const FlagGrid *flags;
+  int subtractType;
+};
+void LevelsetGrid::subtract(const LevelsetGrid &o, const FlagGrid *flags, const int subtractType)
+{
+  KnSubtract(*this, o, flags, subtractType);
+}
+
+//! re-init levelset and extrapolate velocities (in & out)
+//  note - uses flags to identify border (could also be done based on ls values)
+static void doReinitMarch(Grid<Real> &phi,
+                          const FlagGrid &flags,
+                          Real maxTime,
+                          MACGrid *velTransport,
+                          bool ignoreWalls,
+                          bool correctOuterLayer,
+                          int obstacleType)
+{
+  const int dim = (phi.is3D() ? 3 : 2);
+  Grid<int> fmFlags(phi.getParent());
+
+  FastMarch<FmHeapEntryIn, -1> marchIn(flags, fmFlags, phi, maxTime, NULL);
+
+  // march inside
+  InitFmIn(flags, fmFlags, phi, ignoreWalls, obstacleType);
+
+  FOR_IJK_BND(flags, 1)
+  {
+    if (fmFlags(i, j, k) == FlagInited)
+      continue;
+    if (ignoreWalls && ((flags(i, j, k) & obstacleType) != 0))
+      continue;
+    const Vec3i p(i, j, k);
+
+    if (isAtInterface<true>(fmFlags, phi, p)) {
+      // set value
+      fmFlags(p) = FlagInited;
+
+      // add neighbors that are not at the interface
+      for (int nb = 0; nb < 2 * dim; nb++) {
+        const Vec3i pn(p + neighbors[nb]);  // index always valid due to bnd=1
+        if (ignoreWalls && ((flags.get(pn) & obstacleType) != 0))
+          continue;
+
+        // check neighbors of neighbor
+        if (phi(pn) < 0. && !isAtInterface<true>(fmFlags, phi, pn)) {
+          marchIn.addToList(pn, p);
+        }
+      }
+    }
+  }
+  marchIn.performMarching();
+  // done with inwards marching
+
+  // now march out...
+
+  // set un initialized regions
+  SetUninitialized(flags, fmFlags, phi, -maxTime - 1., ignoreWalls, obstacleType);
+
+  InitFmOut(flags, fmFlags, phi, ignoreWalls, obstacleType);
+
+  FastMarch<FmHeapEntryOut, +1> marchOut(flags, fmFlags, phi, maxTime, velTransport);
+
+  // by default, correctOuterLayer is on
+  if (correctOuterLayer) {
+    // normal version, inwards march is done, now add all outside values (0..2] to list
+    // note, this might move the interface a bit! but keeps a nice signed distance field...
+    FOR_IJK_BND(flags, 1)
+    {
+      if (ignoreWalls && ((flags(i, j, k) & obstacleType) != 0))
+        continue;
+      const Vec3i p(i, j, k);
+
+      // check nbs
+      for (int nb = 0; nb < 2 * dim; nb++) {
+        const Vec3i pn(p + neighbors[nb]);  // index always valid due to bnd=1
+
+        if (fmFlags(pn) != FlagInited)
+          continue;
+        if (ignoreWalls && ((flags.get(pn) & obstacleType)) != 0)
+          continue;
+
+        const Real nbPhi = phi(pn);
+
+        // only add nodes near interface, not e.g. outer boundary vs. invalid region
+        if (nbPhi < 0 && nbPhi >= -2)
+          marchOut.addToList(p, pn);
+      }
+    }
+  }
+  else {
+    // alternative version, keep interface, do not distort outer cells
+    // add all ouside values, but not those at the IF layer
+    FOR_IJK_BND(flags, 1)
+    {
+      if (ignoreWalls && ((flags(i, j, k) & obstacleType) != 0))
+        continue;
+
+      // only look at ouside values
+      const Vec3i p(i, j, k);
+      if (phi(p) < 0)
+        continue;
+
+      if (isAtInterface<false>(fmFlags, phi, p)) {
+        // now add all non, interface neighbors
+        fmFlags(p) = FlagInited;
+
+        // add neighbors that are not at the interface
+        for (int nb = 0; nb < 2 * dim; nb++) {
+          const Vec3i pn(p + neighbors[nb]);  // index always valid due to bnd=1
+          if (ignoreWalls && ((flags.get(pn) & obstacleType) != 0))
+            continue;
+
+          // check neighbors of neighbor
+          if (phi(pn) > 0. && !isAtInterface<false>(fmFlags, phi, pn)) {
+            marchOut.addToList(pn, p);
+          }
+        }
+      }
+    }
+  }
+  marchOut.performMarching();
+
+  // set un initialized regions
+  SetUninitialized(flags, fmFlags, phi, +maxTime + 1., ignoreWalls, obstacleType);
+}
+
+//! call for levelset grids & external real grids
+
+void LevelsetGrid::reinitMarching(const FlagGrid &flags,
+                                  Real maxTime,
+                                  MACGrid *velTransport,
+                                  bool ignoreWalls,
+                                  bool correctOuterLayer,
+                                  int obstacleType)
+{
+  doReinitMarch(*this, flags, maxTime, velTransport, ignoreWalls, correctOuterLayer, obstacleType);
+}
+
+void LevelsetGrid::initFromFlags(const FlagGrid &flags, bool ignoreWalls)
+{
+  FOR_IDX(*this)
+  {
+    if (flags.isFluid(idx) || (ignoreWalls && flags.isObstacle(idx)))
+      mData[idx] = -0.5;
+    else
+      mData[idx] = 0.5;
+  }
+}
+
+void LevelsetGrid::fillHoles(int maxDepth, int boundaryWidth)
+{
+  Real curVal, i1, i2, j1, j2, k1, k2;
+  Vec3i c, cTmp;
+  std::stack<Vec3i> undoPos;
+  std::stack<Real> undoVal;
+  std::stack<Vec3i> todoPos;
+
+  FOR_IJK_BND(*this, boundaryWidth)
+  {
+
+    curVal = mData[index(i, j, k)];
+    i1 = mData[index(i - 1, j, k)];
+    i2 = mData[index(i + 1, j, k)];
+    j1 = mData[index(i, j - 1, k)];
+    j2 = mData[index(i, j + 1, k)];
+    k1 = mData[index(i, j, k - 1)];
+    k2 = mData[index(i, j, k + 1)];
+
+    /* Skip cells inside and cells outside with no inside neighbours early */
+    if (curVal < 0.)
+      continue;
+    if (curVal > 0. && i1 > 0. && i2 > 0. && j1 > 0. && j2 > 0. && k1 > 0. && k2 > 0.)
+      continue;
+
+    /* Cell at c is positive (outside) and has at least one negative (inside) neighbour cell */
+    c = Vec3i(i, j, k);
+
+    /* Current cell is outside and has inside neighbour(s) */
+    undoPos.push(c);
+    undoVal.push(curVal);
+    todoPos.push(c);
+
+    /* Enforce negative cell - if search depth gets exceeded this will be reverted to the original
+     * value */
+    mData[index(c.x, c.y, c.z)] = -0.5;
+
+    while (!todoPos.empty()) {
+      todoPos.pop();
+
+      /* Add neighbouring positive (inside) cells to stacks and set negavtive cell value */
+      if (c.x > 0 && mData[index(c.x - 1, c.y, c.z)] > 0.) {
+        cTmp = Vec3i(c.x - 1, c.y, c.z);
+        undoPos.push(cTmp);
+        undoVal.push(mData[index(cTmp)]);
+        todoPos.push(cTmp);
+        mData[index(cTmp)] = -0.5;
+      }
+      if (c.y > 0 && mData[index(c.x, c.y - 1, c.z)] > 0.) {
+        cTmp = Vec3i(c.x, c.y - 1, c.z);
+        undoPos.push(cTmp);
+        undoVal.push(mData[index(cTmp)]);
+        todoPos.push(cTmp);
+        mData[index(cTmp)] = -0.5;
+      }
+      if (c.z > 0 && mData[index(c.x, c.y, c.z - 1)] > 0.) {
+        cTmp = Vec3i(c.x, c.y, c.z - 1);
+        undoPos.push(cTmp);
+        undoVal.push(mData[index(cTmp)]);
+        todoPos.push(cTmp);
+        mData[index(cTmp)] = -0.5;
+      }
+      if (c.x < (*this).getSizeX() - 1 && mData[index(c.x + 1, c.y, c.z)] > 0.) {
+        cTmp = Vec3i(c.x + 1, c.y, c.z);
+        undoPos.push(cTmp);
+        undoVal.push(mData[index(cTmp)]);
+        todoPos.push(cTmp);
+        mData[index(cTmp)] = -0.5;
+      }
+      if (c.y < (*this).getSizeY() - 1 && mData[index(c.x, c.y + 1, c.z)] > 0.) {
+        cTmp = Vec3i(c.x, c.y + 1, c.z);
+        undoPos.push(cTmp);
+        undoVal.push(mData[index(cTmp)]);
+        todoPos.push(cTmp);
+        mData[index(cTmp)] = -0.5;
+      }
+      if (c.z < (*this).getSizeZ() - 1 && mData[index(c.x, c.y, c.z + 1)] > 0.) {
+        cTmp = Vec3i(c.x, c.y, c.z + 1);
+        undoPos.push(cTmp);
+        undoVal.push(mData[index(cTmp)]);
+        todoPos.push(cTmp);
+        mData[index(cTmp)] = -0.5;
+      }
+
+      /* Restore original value in cells if undo needed ie once cell undo count exceeds given limit
+       */
+      if (undoPos.size() > maxDepth) {
+        /* Clear todo stack */
+        while (!todoPos.empty()) {
+          todoPos.pop();
+        }
+        /* Clear undo stack and revert value */
+        while (!undoPos.empty()) {
+          c = undoPos.top();
+          curVal = undoVal.top();
+          undoPos.pop();
+          undoVal.pop();
+          mData[index(c.x, c.y, c.z)] = curVal;
+        }
+        break;
+      }
+
+      /* Ensure that undo stack is cleared at the end if no more items in todo stack left */
+      if (todoPos.empty()) {
+        while (!undoPos.empty()) {
+          undoPos.pop();
+        }
+        while (!undoVal.empty()) {
+          undoVal.pop();
+        }
+      }
+      /* Pop value for next while iteration */
+      else {
+        c = todoPos.top();
+      }
+    }
+  }
+}
+
+//! run marching cubes to create a mesh for the 0-levelset
+void LevelsetGrid::createMesh(Mesh &mesh)
+{
+  assertMsg(is3D(), "Only 3D grids supported so far");
+
+  mesh.clear();
+
+  const Real invalidTime = invalidTimeValue();
+  const Real isoValue = 1e-4;
+
+  // create some temp grids
+  Grid<int> edgeVX(mParent);
+  Grid<int> edgeVY(mParent);
+  Grid<int> edgeVZ(mParent);
+
+  for (int i = 0; i < mSize.x - 1; i++)
+    for (int j = 0; j < mSize.y - 1; j++)
+      for (int k = 0; k < mSize.z - 1; k++) {
+        Real value[8] = {get(i, j, k),
+                         get(i + 1, j, k),
+                         get(i + 1, j + 1, k),
+                         get(i, j + 1, k),
+                         get(i, j, k + 1),
+                         get(i + 1, j, k + 1),
+                         get(i + 1, j + 1, k + 1),
+                         get(i, j + 1, k + 1)};
+
+        // build lookup index, check for invalid times
+        bool skip = false;
+        int cubeIdx = 0;
+        for (int l = 0; l < 8; l++) {
+          value[l] *= -1;
+          if (-value[l] <= invalidTime)
+            skip = true;
+          if (value[l] < isoValue)
+            cubeIdx |= 1 << l;
+        }
+        if (skip || (mcEdgeTable[cubeIdx] == 0))
+          continue;
+
+        // where to look up if this point already exists
+        int triIndices[12];
+        int *eVert[12] = {&edgeVX(i, j, k),
+                          &edgeVY(i + 1, j, k),
+                          &edgeVX(i, j + 1, k),
+                          &edgeVY(i, j, k),
+                          &edgeVX(i, j, k + 1),
+                          &edgeVY(i + 1, j, k + 1),
+                          &edgeVX(i, j + 1, k + 1),
+                          &edgeVY(i, j, k + 1),
+                          &edgeVZ(i, j, k),
+                          &edgeVZ(i + 1, j, k),
+                          &edgeVZ(i + 1, j + 1, k),
+                          &edgeVZ(i, j + 1, k)};
+
+        const Vec3 pos[9] = {Vec3(i, j, k),
+                             Vec3(i + 1, j, k),
+                             Vec3(i + 1, j + 1, k),
+                             Vec3(i, j + 1, k),
+                             Vec3(i, j, k + 1),
+                             Vec3(i + 1, j, k + 1),
+                             Vec3(i + 1, j + 1, k + 1),
+                             Vec3(i, j + 1, k + 1)};
+
+        for (int e = 0; e < 12; e++) {
+          if (mcEdgeTable[cubeIdx] & (1 << e)) {
+            // vertex already calculated ?
+            if (*eVert[e] == 0) {
+              // interpolate edge
+              const int e1 = mcEdges[e * 2];
+              const int e2 = mcEdges[e * 2 + 1];
+              const Vec3 p1 = pos[e1];        // scalar field pos 1
+              const Vec3 p2 = pos[e2];        // scalar field pos 2
+              const float valp1 = value[e1];  // scalar field val 1
+              const float valp2 = value[e2];  // scalar field val 2
+              const float mu = (isoValue - valp1) / (valp2 - valp1);
+
+              // init isolevel vertex
+              Node vertex;
+              vertex.pos = p1 + (p2 - p1) * mu + Vec3(Real(0.5));
+              vertex.normal = getNormalized(
+                  getGradient(
+                      *this, i + cubieOffsetX[e1], j + cubieOffsetY[e1], k + cubieOffsetZ[e1]) *
+                      (1.0 - mu) +
+                  getGradient(
+                      *this, i + cubieOffsetX[e2], j + cubieOffsetY[e2], k + cubieOffsetZ[e2]) *
+                      (mu));
+
+              triIndices[e] = mesh.addNode(vertex) + 1;
+
+              // store vertex
+              *eVert[e] = triIndices[e];
+            }
+            else {
+              // retrieve  from vert array
+              triIndices[e] = *eVert[e];
+            }
+          }
+        }
+
+        // Create the triangles...
+        for (int e = 0; mcTriTable[cubeIdx][e] != -1; e += 3) {
+          mesh.addTri(Triangle(triIndices[mcTriTable[cubeIdx][e + 0]] - 1,
+                               triIndices[mcTriTable[cubeIdx][e + 1]] - 1,
+                               triIndices[mcTriTable[cubeIdx][e + 2]] - 1));
+        }
+      }
+
+  // mesh.rebuildCorners();
+  // mesh.rebuildLookup();
+
+  // Update mdata fields
+  mesh.updateDataFields();
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/levelset.h b/extern/mantaflow/preprocessed/levelset.h
new file mode 100644
index 00000000000..ab36ac24903
--- /dev/null
+++ b/extern/mantaflow/preprocessed/levelset.h
@@ -0,0 +1,245 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Levelset
+ *
+ ******************************************************************************/
+
+#ifndef _LEVELSET_H_
+#define _LEVELSET_H_
+
+#include "grid.h"
+
+namespace Manta {
+class Mesh;
+
+//! Special function for levelsets
+class LevelsetGrid : public Grid<Real> {
+ public:
+  LevelsetGrid(FluidSolver *parent, bool show = true);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "LevelsetGrid::LevelsetGrid", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        bool show = _args.getOpt<bool>("show", 1, true, &_lock);
+        obj = new LevelsetGrid(parent, show);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "LevelsetGrid::LevelsetGrid", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::LevelsetGrid", e.what());
+      return -1;
+    }
+  }
+
+  LevelsetGrid(FluidSolver *parent, Real *data, bool show = true);
+
+  //! reconstruct the levelset using fast marching
+
+  void reinitMarching(const FlagGrid &flags,
+                      Real maxTime = 4.0,
+                      MACGrid *velTransport = NULL,
+                      bool ignoreWalls = false,
+                      bool correctOuterLayer = true,
+                      int obstacleType = FlagGrid::TypeObstacle);
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "LevelsetGrid::reinitMarching", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        Real maxTime = _args.getOpt<Real>("maxTime", 1, 4.0, &_lock);
+        MACGrid *velTransport = _args.getPtrOpt<MACGrid>("velTransport", 2, NULL, &_lock);
+        bool ignoreWalls = _args.getOpt<bool>("ignoreWalls", 3, false, &_lock);
+        bool correctOuterLayer = _args.getOpt<bool>("correctOuterLayer", 4, true, &_lock);
+        int obstacleType = _args.getOpt<int>("obstacleType", 5, FlagGrid::TypeObstacle, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->reinitMarching(
+            flags, maxTime, velTransport, ignoreWalls, correctOuterLayer, obstacleType);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "LevelsetGrid::reinitMarching", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::reinitMarching", e.what());
+      return 0;
+    }
+  }
+
+  //! create a triangle mesh from the levelset isosurface
+  void createMesh(Mesh &mesh);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "LevelsetGrid::createMesh", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->createMesh(mesh);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "LevelsetGrid::createMesh", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::createMesh", e.what());
+      return 0;
+    }
+  }
+
+  //! union with another levelset
+  void join(const LevelsetGrid &o);
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "LevelsetGrid::join", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const LevelsetGrid &o = *_args.getPtr<LevelsetGrid>("o", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->join(o);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "LevelsetGrid::join", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::join", e.what());
+      return 0;
+    }
+  }
+
+  void subtract(const LevelsetGrid &o, const FlagGrid *flags = NULL, const int subtractType = 0);
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "LevelsetGrid::subtract", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const LevelsetGrid &o = *_args.getPtr<LevelsetGrid>("o", 0, &_lock);
+        const FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, NULL, &_lock);
+        const int subtractType = _args.getOpt<int>("subtractType", 2, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->subtract(o, flags, subtractType);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "LevelsetGrid::subtract", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::subtract", e.what());
+      return 0;
+    }
+  }
+
+  //! initialize levelset from flags (+/- 0.5 heaviside)
+  void initFromFlags(const FlagGrid &flags, bool ignoreWalls = false);
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "LevelsetGrid::initFromFlags", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        bool ignoreWalls = _args.getOpt<bool>("ignoreWalls", 1, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->initFromFlags(flags, ignoreWalls);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "LevelsetGrid::initFromFlags", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::initFromFlags", e.what());
+      return 0;
+    }
+  }
+
+  //! fill holes (pos cells enclosed by neg ones) up to given size with -0.5 (ie not preserving
+  //! sdf)
+  void fillHoles(int maxDepth = 10, int boundaryWidth = 1);
+  static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "LevelsetGrid::fillHoles", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int maxDepth = _args.getOpt<int>("maxDepth", 0, 10, &_lock);
+        int boundaryWidth = _args.getOpt<int>("boundaryWidth", 1, 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->fillHoles(maxDepth, boundaryWidth);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "LevelsetGrid::fillHoles", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("LevelsetGrid::fillHoles", e.what());
+      return 0;
+    }
+  }
+
+  static Real invalidTimeValue();
+ public:
+  PbArgs _args;
+}
+#define _C_LevelsetGrid
+;
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/levelset.h.reg.cpp b/extern/mantaflow/preprocessed/levelset.h.reg.cpp
new file mode 100644
index 00000000000..dc6669b5da3
--- /dev/null
+++ b/extern/mantaflow/preprocessed/levelset.h.reg.cpp
@@ -0,0 +1,32 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "levelset.h"
+namespace Manta {
+#ifdef _C_LevelsetGrid
+static const Pb::Register _R_11("LevelsetGrid", "LevelsetGrid", "Grid<Real>");
+template<> const char *Namify<LevelsetGrid>::S = "LevelsetGrid";
+static const Pb::Register _R_12("LevelsetGrid", "LevelsetGrid", LevelsetGrid::_W_0);
+static const Pb::Register _R_13("LevelsetGrid", "reinitMarching", LevelsetGrid::_W_1);
+static const Pb::Register _R_14("LevelsetGrid", "createMesh", LevelsetGrid::_W_2);
+static const Pb::Register _R_15("LevelsetGrid", "join", LevelsetGrid::_W_3);
+static const Pb::Register _R_16("LevelsetGrid", "subtract", LevelsetGrid::_W_4);
+static const Pb::Register _R_17("LevelsetGrid", "initFromFlags", LevelsetGrid::_W_5);
+static const Pb::Register _R_18("LevelsetGrid", "fillHoles", LevelsetGrid::_W_6);
+#endif
+extern "C" {
+void PbRegister_file_11()
+{
+  KEEP_UNUSED(_R_11);
+  KEEP_UNUSED(_R_12);
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/mesh.cpp b/extern/mantaflow/preprocessed/mesh.cpp
new file mode 100644
index 00000000000..d93c2ac04c0
--- /dev/null
+++ b/extern/mantaflow/preprocessed/mesh.cpp
@@ -0,0 +1,2733 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Meshes
+ *
+ * note: this is only a temporary solution, details are bound to change
+ *        long term goal is integration with Split&Merge code by Wojtan et al.
+ *
+ ******************************************************************************/
+
+#include "mesh.h"
+#include "integrator.h"
+#include "mantaio.h"
+#include "kernel.h"
+#include "shapes.h"
+#include "noisefield.h"
+//#include "grid.h"
+#include <stack>
+#include <cstring>
+
+using namespace std;
+namespace Manta {
+
+Mesh::Mesh(FluidSolver *parent) : PbClass(parent)
+{
+}
+
+Mesh::~Mesh()
+{
+  for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i)
+    mMeshData[i]->setMesh(NULL);
+
+  if (mFreeMdata) {
+    for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i)
+      delete mMeshData[i];
+  }
+}
+
+Mesh *Mesh::clone()
+{
+  Mesh *nm = new Mesh(mParent);
+  *nm = *this;
+  nm->setName(getName());
+  return nm;
+}
+
+void Mesh::deregister(MeshDataBase *mdata)
+{
+  bool done = false;
+  // remove pointer from mesh data list
+  for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i) {
+    if (mMeshData[i] == mdata) {
+      if (i < (IndexInt)mMeshData.size() - 1)
+        mMeshData[i] = mMeshData[mMeshData.size() - 1];
+      mMeshData.pop_back();
+      done = true;
+    }
+  }
+  if (!done)
+    errMsg("Invalid pointer given, not registered!");
+}
+
+// create and attach a new mdata field to this mesh
+PbClass *Mesh::create(PbType t, PbTypeVec T, const string &name)
+{
+#if NOPYTHON != 1
+  _args.add("nocheck", true);
+  if (t.str() == "")
+    errMsg("Specify mesh data type to create");
+  // debMsg( "Mdata creating '"<< t.str <<" with size "<< this->getSizeSlow(), 5 );
+
+  PbClass *pyObj = PbClass::createPyObject(t.str() + T.str(), name, _args, this->getParent());
+
+  MeshDataBase *mdata = dynamic_cast<MeshDataBase *>(pyObj);
+  if (!mdata) {
+    errMsg(
+        "Unable to get mesh data pointer from newly created object. Only create MeshData type "
+        "with a Mesh.creat() call, eg, MdataReal, MdataVec3 etc.");
+    delete pyObj;
+    return NULL;
+  }
+  else {
+    this->registerMdata(mdata);
+  }
+
+  // directly init size of new mdata field:
+  mdata->resize(this->getSizeSlow());
+#else
+  PbClass *pyObj = NULL;
+#endif
+  return pyObj;
+}
+
+void Mesh::registerMdata(MeshDataBase *mdata)
+{
+  mdata->setMesh(this);
+  mMeshData.push_back(mdata);
+
+  if (mdata->getType() == MeshDataBase::TypeReal) {
+    MeshDataImpl<Real> *pd = dynamic_cast<MeshDataImpl<Real> *>(mdata);
+    if (!pd)
+      errMsg("Invalid mdata object posing as real!");
+    this->registerMdataReal(pd);
+  }
+  else if (mdata->getType() == MeshDataBase::TypeInt) {
+    MeshDataImpl<int> *pd = dynamic_cast<MeshDataImpl<int> *>(mdata);
+    if (!pd)
+      errMsg("Invalid mdata object posing as int!");
+    this->registerMdataInt(pd);
+  }
+  else if (mdata->getType() == MeshDataBase::TypeVec3) {
+    MeshDataImpl<Vec3> *pd = dynamic_cast<MeshDataImpl<Vec3> *>(mdata);
+    if (!pd)
+      errMsg("Invalid mdata object posing as vec3!");
+    this->registerMdataVec3(pd);
+  }
+}
+void Mesh::registerMdataReal(MeshDataImpl<Real> *pd)
+{
+  mMdataReal.push_back(pd);
+}
+void Mesh::registerMdataVec3(MeshDataImpl<Vec3> *pd)
+{
+  mMdataVec3.push_back(pd);
+}
+void Mesh::registerMdataInt(MeshDataImpl<int> *pd)
+{
+  mMdataInt.push_back(pd);
+}
+
+void Mesh::addAllMdata()
+{
+  for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i) {
+    mMeshData[i]->addEntry();
+  }
+}
+
+Real Mesh::computeCenterOfMass(Vec3 &cm) const
+{
+
+  // use double precision for summation, otherwise too much error accumulation
+  double vol = 0;
+  Vector3D<double> cmd(0.0);
+  for (size_t tri = 0; tri < mTris.size(); tri++) {
+    Vector3D<double> p1(toVec3d(getNode(tri, 0)));
+    Vector3D<double> p2(toVec3d(getNode(tri, 1)));
+    Vector3D<double> p3(toVec3d(getNode(tri, 2)));
+
+    double cvol = dot(cross(p1, p2), p3) / 6.0;
+    cmd += (p1 + p2 + p3) * (cvol / 4.0);
+    vol += cvol;
+  }
+  if (vol != 0.0)
+    cmd /= vol;
+
+  cm = toVec3(cmd);
+  return (Real)vol;
+}
+
+void Mesh::clear()
+{
+  mNodes.clear();
+  mTris.clear();
+  mCorners.clear();
+  m1RingLookup.clear();
+  for (size_t i = 0; i < mNodeChannels.size(); i++)
+    mNodeChannels[i]->resize(0);
+  for (size_t i = 0; i < mTriChannels.size(); i++)
+    mTriChannels[i]->resize(0);
+
+  // clear mdata fields as well
+  for (size_t i = 0; i < mMdataReal.size(); i++)
+    mMdataReal[i]->resize(0);
+  for (size_t i = 0; i < mMdataVec3.size(); i++)
+    mMdataVec3[i]->resize(0);
+  for (size_t i = 0; i < mMdataInt.size(); i++)
+    mMdataInt[i]->resize(0);
+}
+
+Mesh &Mesh::operator=(const Mesh &o)
+{
+  // wipe current data
+  clear();
+  if (mNodeChannels.size() != o.mNodeChannels.size() ||
+      mTriChannels.size() != o.mTriChannels.size())
+    errMsg("can't copy mesh, channels not identical");
+  mNodeChannels.clear();
+  mTriChannels.clear();
+
+  // copy corner, nodes, tris
+  mCorners = o.mCorners;
+  mNodes = o.mNodes;
+  mTris = o.mTris;
+  m1RingLookup = o.m1RingLookup;
+
+  // copy channels
+  for (size_t i = 0; i < mNodeChannels.size(); i++)
+    mNodeChannels[i] = o.mNodeChannels[i];
+  for (size_t i = 0; i < o.mTriChannels.size(); i++)
+    mTriChannels[i] = o.mTriChannels[i];
+
+  return *this;
+}
+
+void Mesh::load(string name, bool append)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".gz")  // assume bobj gz
+    readBobjFile(name, this, append);
+  else if (ext == ".obj")
+    readObjFile(name, this, append);
+  else
+    errMsg("file '" + name + "' filetype not supported");
+
+  // dont always rebuild...
+  // rebuildCorners();
+  // rebuildLookup();
+}
+
+void Mesh::save(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".obj")
+    writeObjFile(name, this);
+  else if (ext == ".gz")
+    writeBobjFile(name, this);
+  else
+    errMsg("file '" + name + "' filetype not supported");
+}
+
+void Mesh::fromShape(Shape &shape, bool append)
+{
+  if (!append)
+    clear();
+  shape.generateMesh(this);
+}
+
+void Mesh::resizeTris(int numTris)
+{
+  mTris.resize(numTris);
+  rebuildChannels();
+}
+void Mesh::resizeNodes(int numNodes)
+{
+  mNodes.resize(numNodes);
+  rebuildChannels();
+}
+
+//! do a quick check whether a rebuild is necessary, and if yes do rebuild
+void Mesh::rebuildQuickCheck()
+{
+  if (mCorners.size() != 3 * mTris.size())
+    rebuildCorners();
+  if (m1RingLookup.size() != mNodes.size())
+    rebuildLookup();
+}
+
+void Mesh::rebuildCorners(int from, int to)
+{
+  mCorners.resize(3 * mTris.size());
+  if (to < 0)
+    to = mTris.size();
+
+  // fill in basic info
+  for (int tri = from; tri < to; tri++) {
+    for (int c = 0; c < 3; c++) {
+      const int idx = tri * 3 + c;
+      mCorners[idx].tri = tri;
+      mCorners[idx].node = mTris[tri].c[c];
+      mCorners[idx].next = 3 * tri + ((c + 1) % 3);
+      mCorners[idx].prev = 3 * tri + ((c + 2) % 3);
+      mCorners[idx].opposite = -1;
+    }
+  }
+
+  // set opposite info
+  int maxc = to * 3;
+  for (int c = from * 3; c < maxc; c++) {
+    int next = mCorners[mCorners[c].next].node;
+    int prev = mCorners[mCorners[c].prev].node;
+
+    // find corner with same next/prev nodes
+    for (int c2 = c + 1; c2 < maxc; c2++) {
+      int next2 = mCorners[mCorners[c2].next].node;
+      if (next2 != next && next2 != prev)
+        continue;
+      int prev2 = mCorners[mCorners[c2].prev].node;
+      if (prev2 != next && prev2 != prev)
+        continue;
+
+      // found
+      mCorners[c].opposite = c2;
+      mCorners[c2].opposite = c;
+      break;
+    }
+    if (mCorners[c].opposite < 0) {
+      // didn't find opposite
+      errMsg("can't rebuild corners, index without an opposite");
+    }
+  }
+
+  rebuildChannels();
+}
+
+void Mesh::rebuildLookup(int from, int to)
+{
+  if (from == 0 && to < 0)
+    m1RingLookup.clear();
+  m1RingLookup.resize(mNodes.size());
+  if (to < 0)
+    to = mTris.size();
+  from *= 3;
+  to *= 3;
+  for (int i = from; i < to; i++) {
+    const int node = mCorners[i].node;
+    m1RingLookup[node].nodes.insert(mCorners[mCorners[i].next].node);
+    m1RingLookup[node].nodes.insert(mCorners[mCorners[i].prev].node);
+    m1RingLookup[node].tris.insert(mCorners[i].tri);
+  }
+}
+
+void Mesh::rebuildChannels()
+{
+  for (size_t i = 0; i < mTriChannels.size(); i++)
+    mTriChannels[i]->resize(mTris.size());
+  for (size_t i = 0; i < mNodeChannels.size(); i++)
+    mNodeChannels[i]->resize(mNodes.size());
+}
+
+struct _KnAdvectMeshInGrid : public KernelBase {
+  _KnAdvectMeshInGrid(const KernelBase &base,
+                      vector<Node> &nodes,
+                      const FlagGrid &flags,
+                      const MACGrid &vel,
+                      const Real dt,
+                      vector<Vec3> &u)
+      : KernelBase(base), nodes(nodes), flags(flags), vel(vel), dt(dt), u(u)
+  {
+  }
+  inline void op(IndexInt idx,
+                 vector<Node> &nodes,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 const Real dt,
+                 vector<Vec3> &u) const
+  {
+    if (nodes[idx].flags & Mesh::NfFixed)
+      u[idx] = 0.0;
+    else if (!flags.isInBounds(nodes[idx].pos, 1))
+      u[idx] = 0.0;
+    else
+      u[idx] = vel.getInterpolated(nodes[idx].pos) * dt;
+  }
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, nodes, flags, vel, dt, u);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  vector<Node> &nodes;
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  const Real dt;
+  vector<Vec3> &u;
+};
+struct KnAdvectMeshInGrid : public KernelBase {
+  KnAdvectMeshInGrid(vector<Node> &nodes, const FlagGrid &flags, const MACGrid &vel, const Real dt)
+      : KernelBase(nodes.size()),
+        _inner(KernelBase(nodes.size()), nodes, flags, vel, dt, u),
+        nodes(nodes),
+        flags(flags),
+        vel(vel),
+        dt(dt),
+        u((size))
+  {
+    runMessage();
+    run();
+  }
+  void run()
+  {
+    _inner.run();
+  }
+  inline operator vector<Vec3>()
+  {
+    return u;
+  }
+  inline vector<Vec3> &getRet()
+  {
+    return u;
+  }
+  inline vector<Node> &getArg0()
+  {
+    return nodes;
+  }
+  typedef vector<Node> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  inline const Real &getArg3()
+  {
+    return dt;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAdvectMeshInGrid ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  _KnAdvectMeshInGrid _inner;
+  vector<Node> &nodes;
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  const Real dt;
+  vector<Vec3> u;
+};
+
+// advection plugin
+void Mesh::advectInGrid(FlagGrid &flags, MACGrid &vel, int integrationMode)
+{
+  KnAdvectMeshInGrid kernel(mNodes, flags, vel, getParent()->getDt());
+  integratePointSet(kernel, integrationMode);
+}
+
+void Mesh::scale(Vec3 s)
+{
+  for (size_t i = 0; i < mNodes.size(); i++)
+    mNodes[i].pos *= s;
+}
+
+void Mesh::offset(Vec3 o)
+{
+  for (size_t i = 0; i < mNodes.size(); i++)
+    mNodes[i].pos += o;
+}
+
+void Mesh::rotate(Vec3 thetas)
+{
+  // rotation thetas are in radians (e.g. pi is equal to 180 degrees)
+  auto rotate = [&](Real theta, unsigned int first_axis, unsigned int second_axis) {
+    if (theta == 0.0f)
+      return;
+
+    Real sin_t = sin(theta);
+    Real cos_t = cos(theta);
+
+    Real sin_sign = first_axis == 0u && second_axis == 2u ? -1.0f : 1.0f;
+    sin_t *= sin_sign;
+
+    size_t length = mNodes.size();
+    for (size_t n = 0; n < length; ++n) {
+      Vec3 &node = mNodes[n].pos;
+      Real first_axis_val = node[first_axis];
+      Real second_axis_val = node[second_axis];
+      node[first_axis] = first_axis_val * cos_t - second_axis_val * sin_t;
+      node[second_axis] = second_axis_val * cos_t + first_axis_val * sin_t;
+    }
+  };
+
+  // rotate x
+  rotate(thetas[0], 1u, 2u);
+  // rotate y
+  rotate(thetas[1], 0u, 2u);
+  // rotate z
+  rotate(thetas[2], 0u, 1u);
+}
+
+void Mesh::computeVelocity(Mesh &oldMesh, MACGrid &vel)
+{
+  // Early return if sizes do not match
+  if (oldMesh.mNodes.size() != mNodes.size())
+    return;
+
+  // temp grid
+  Grid<Vec3> veloMeanCounter(getParent());
+  veloMeanCounter.setConst(0.0f);
+
+  bool bIs2D = getParent()->is2D();
+
+  // calculate velocities from previous to current frame (per vertex)
+  for (size_t i = 0; i < mNodes.size(); ++i) {
+    // skip vertices that are not needed for 2D
+    if (bIs2D && (mNodes[i].pos.z < -0.5f || mNodes[i].pos.z > 0.5f))
+      continue;
+
+    Vec3 velo = mNodes[i].pos - oldMesh.mNodes[i].pos;
+    vel.setInterpolated(mNodes[i].pos, velo, &(veloMeanCounter[0]));
+  }
+
+  // discretize the vertex velocities by averaging them on the grid
+  vel.safeDivide(veloMeanCounter);
+}
+
+void Mesh::removeTri(int tri)
+{
+  // delete triangles by overwriting them with elements from the end of the array.
+  if (tri != (int)mTris.size() - 1) {
+    // if this is the last element, and it is marked for deletion,
+    // don't waste cycles transfering data to itself,
+    // and DEFINITELY don't transfer .opposite data to other, untainted triangles.
+
+    // old corners hold indices on the end of the corners array
+    // new corners holds indices in the new spot in the middle of the array
+    Corner *oldcorners[3];
+    Corner *newcorners[3];
+    int oldtri = mTris.size() - 1;
+    for (int c = 0; c < 3; c++) {
+      oldcorners[c] = &corners(oldtri, c);
+      newcorners[c] = &corners(tri, c);
+    }
+
+    // move the position of the triangle
+    mTris[tri] = mTris[oldtri];
+
+    // 1) update c.node, c.opposite (c.next and c.prev should be fine as they are)
+    for (int c = 0; c < 3; c++) {
+      newcorners[c]->node = mTris[tri].c[c];
+      newcorners[c]->opposite = oldcorners[c]->opposite;
+    }
+
+    //  2) c.opposite.opposite = c
+    for (int c = 0; c < 3; c++) {
+      if (newcorners[c]->opposite >= 0)
+        mCorners[newcorners[c]->opposite].opposite = 3 * tri + c;
+    }
+
+    // update tri lookup
+    for (int c = 0; c < 3; c++) {
+      int node = mTris[tri].c[c];
+      m1RingLookup[node].tris.erase(oldtri);
+      m1RingLookup[node].tris.insert(tri);
+    }
+  }
+
+  // transfer tri props
+  for (size_t p = 0; p < mTriChannels.size(); p++)
+    mTriChannels[p]->remove(tri);
+
+  // pop the triangle and corners out of the vector
+  mTris.pop_back();
+  mCorners.resize(mTris.size() * 3);
+}
+
+void Mesh::removeNodes(const vector<int> &deletedNodes)
+{
+  // After we delete the nodes that are marked for removal,
+  // the size of mNodes will be the current size - the size of the deleted array.
+  // We are going to move the elements at the end of the array
+  // (everything with an index >= newsize)
+  // to the deleted spots.
+  // We have to map all references to the last few nodes to their new locations.
+  int newsize = (int)(mNodes.size() - deletedNodes.size());
+
+  vector<int> new_index(deletedNodes.size());
+  int di, ni;
+  for (ni = 0; ni < (int)new_index.size(); ni++)
+    new_index[ni] = 0;
+  for (di = 0; di < (int)deletedNodes.size(); di++) {
+    if (deletedNodes[di] >= newsize)
+      new_index[deletedNodes[di] - newsize] = -1;  // tag this node as invalid
+  }
+  for (di = 0, ni = 0; ni < (int)new_index.size(); ni++, di++) {
+    // we need to find a valid node to move
+    // we marked invalid nodes in the earlier loop with a (-1),
+    // so pick anything but those
+    while (ni < (int)new_index.size() && new_index[ni] == -1)
+      ni++;
+
+    if (ni >= (int)new_index.size())
+      break;
+
+    // next we need to find a valid spot to move the node to.
+    // we iterate through deleted[] until we find a valid spot
+    while (di < (int)new_index.size() && deletedNodes[di] >= newsize)
+      di++;
+
+    // now we assign the valid node to the valid spot
+    new_index[ni] = deletedNodes[di];
+  }
+
+  // Now we have a map of valid indices.
+  // we move node[newsize+i] to location new_index[i].
+  // We ignore the nodes with a -1 index, because they should not be moved.
+  for (int i = 0; i < (int)new_index.size(); i++) {
+    if (new_index[i] != -1)
+      mNodes[new_index[i]] = mNodes[newsize + i];
+  }
+  mNodes.resize(newsize);
+
+  // handle vertex properties
+  for (size_t i = 0; i < mNodeChannels.size(); i++)
+    mNodeChannels[i]->renumber(new_index, newsize);
+
+  // finally, we reconnect everything that used to point to this vertex.
+  for (size_t tri = 0, n = 0; tri < mTris.size(); tri++) {
+    for (int c = 0; c < 3; c++, n++) {
+      if (mCorners[n].node >= newsize) {
+        int newindex = new_index[mCorners[n].node - newsize];
+        mCorners[n].node = newindex;
+        mTris[mCorners[n].tri].c[c] = newindex;
+      }
+    }
+  }
+
+  // renumber 1-ring
+  for (int i = 0; i < (int)new_index.size(); i++) {
+    if (new_index[i] != -1) {
+      m1RingLookup[new_index[i]].nodes.swap(m1RingLookup[newsize + i].nodes);
+      m1RingLookup[new_index[i]].tris.swap(m1RingLookup[newsize + i].tris);
+    }
+  }
+  m1RingLookup.resize(newsize);
+  vector<int> reStack(new_index.size());
+  for (int i = 0; i < newsize; i++) {
+    set<int> &cs = m1RingLookup[i].nodes;
+    int reNum = 0;
+    // find all nodes > newsize
+    set<int>::reverse_iterator itend = cs.rend();
+    for (set<int>::reverse_iterator it = cs.rbegin(); it != itend; ++it) {
+      if (*it < newsize)
+        break;
+      reStack[reNum++] = *it;
+    }
+    // kill them and insert shifted values
+    if (reNum > 0) {
+      cs.erase(cs.find(reStack[reNum - 1]), cs.end());
+      for (int j = 0; j < reNum; j++) {
+        cs.insert(new_index[reStack[j] - newsize]);
+#ifdef DEBUG
+        if (new_index[reStack[j] - newsize] == -1)
+          errMsg("invalid node present in 1-ring set");
+#endif
+      }
+    }
+  }
+}
+
+void Mesh::mergeNode(int node, int delnode)
+{
+  set<int> &ring = m1RingLookup[delnode].nodes;
+  for (set<int>::iterator it = ring.begin(); it != ring.end(); ++it) {
+    m1RingLookup[*it].nodes.erase(delnode);
+    if (*it != node) {
+      m1RingLookup[*it].nodes.insert(node);
+      m1RingLookup[node].nodes.insert(*it);
+    }
+  }
+  set<int> &ringt = m1RingLookup[delnode].tris;
+  for (set<int>::iterator it = ringt.begin(); it != ringt.end(); ++it) {
+    const int t = *it;
+    for (int c = 0; c < 3; c++) {
+      if (mCorners[3 * t + c].node == delnode) {
+        mCorners[3 * t + c].node = node;
+        mTris[t].c[c] = node;
+      }
+    }
+    m1RingLookup[node].tris.insert(t);
+  }
+  for (size_t i = 0; i < mNodeChannels.size(); i++) {
+    // weight is fixed to 1/2 for now
+    mNodeChannels[i]->mergeWith(node, delnode, 0.5);
+  }
+}
+
+void Mesh::removeTriFromLookup(int tri)
+{
+  for (int c = 0; c < 3; c++) {
+    int node = mTris[tri].c[c];
+    m1RingLookup[node].tris.erase(tri);
+  }
+}
+
+void Mesh::addCorner(Corner a)
+{
+  mCorners.push_back(a);
+}
+
+int Mesh::addTri(Triangle a)
+{
+  mTris.push_back(a);
+  for (int c = 0; c < 3; c++) {
+    int node = a.c[c];
+    int nextnode = a.c[(c + 1) % 3];
+    if ((int)m1RingLookup.size() <= node)
+      m1RingLookup.resize(node + 1);
+    if ((int)m1RingLookup.size() <= nextnode)
+      m1RingLookup.resize(nextnode + 1);
+    m1RingLookup[node].nodes.insert(nextnode);
+    m1RingLookup[nextnode].nodes.insert(node);
+    m1RingLookup[node].tris.insert(mTris.size() - 1);
+  }
+  return mTris.size() - 1;
+}
+
+int Mesh::addNode(Node a)
+{
+  mNodes.push_back(a);
+  if (m1RingLookup.size() < mNodes.size())
+    m1RingLookup.resize(mNodes.size());
+
+  // if mdata exists, add zero init for every node
+  addAllMdata();
+
+  return mNodes.size() - 1;
+}
+
+void Mesh::computeVertexNormals()
+{
+  for (size_t i = 0; i < mNodes.size(); i++) {
+    mNodes[i].normal = 0.0;
+  }
+  for (size_t t = 0; t < mTris.size(); t++) {
+    Vec3 p0 = getNode(t, 0), p1 = getNode(t, 1), p2 = getNode(t, 2);
+    Vec3 n0 = p0 - p1, n1 = p1 - p2, n2 = p2 - p0;
+    Real l0 = normSquare(n0), l1 = normSquare(n1), l2 = normSquare(n2);
+
+    Vec3 nm = cross(n0, n1);
+
+    mNodes[mTris[t].c[0]].normal += nm * (1.0 / (l0 * l2));
+    mNodes[mTris[t].c[1]].normal += nm * (1.0 / (l0 * l1));
+    mNodes[mTris[t].c[2]].normal += nm * (1.0 / (l1 * l2));
+  }
+  for (size_t i = 0; i < mNodes.size(); i++) {
+    normalize(mNodes[i].normal);
+  }
+}
+
+void Mesh::fastNodeLookupRebuild(int corner)
+{
+  int node = mCorners[corner].node;
+  m1RingLookup[node].nodes.clear();
+  m1RingLookup[node].tris.clear();
+  int start = mCorners[corner].prev;
+  int current = start;
+  do {
+    m1RingLookup[node].nodes.insert(mCorners[current].node);
+    m1RingLookup[node].tris.insert(mCorners[current].tri);
+    current = mCorners[mCorners[current].opposite].next;
+    if (current < 0)
+      errMsg("Can't use fastNodeLookupRebuild on incomplete surfaces");
+  } while (current != start);
+}
+
+void Mesh::sanityCheck(bool strict, vector<int> *deletedNodes, map<int, bool> *taintedTris)
+{
+  const int nodes = numNodes(), tris = numTris(), corners = 3 * tris;
+  for (size_t i = 0; i < mNodeChannels.size(); i++) {
+    if (mNodeChannels[i]->size() != nodes)
+      errMsg("Node channel size mismatch");
+  }
+  for (size_t i = 0; i < mTriChannels.size(); i++) {
+    if (mTriChannels[i]->size() != tris)
+      errMsg("Tri channel size mismatch");
+  }
+  if ((int)m1RingLookup.size() != nodes)
+    errMsg("1Ring size wrong");
+  for (size_t t = 0; t < mTris.size(); t++) {
+    if (taintedTris && taintedTris->find(t) != taintedTris->end())
+      continue;
+    for (int c = 0; c < 3; c++) {
+      int corner = t * 3 + c;
+      int node = mTris[t].c[c];
+      int next = mTris[t].c[(c + 1) % 3];
+      int prev = mTris[t].c[(c + 2) % 3];
+      int rnext = mCorners[corner].next;
+      int rprev = mCorners[corner].prev;
+      int ro = mCorners[corner].opposite;
+      if (node < 0 || node >= nodes || next < 0 || next >= nodes || prev < 0 || prev >= nodes)
+        errMsg("invalid node entry");
+      if (mCorners[corner].node != node || mCorners[corner].tri != (int)t)
+        errMsg("invalid basic corner entry");
+      if (rnext < 0 || rnext >= corners || rprev < 0 || rprev >= corners || ro >= corners)
+        errMsg("invalid corner links");
+      if (mCorners[rnext].node != next || mCorners[rprev].node != prev)
+        errMsg("invalid corner next/prev");
+      if (strict && ro < 0)
+        errMsg("opposite missing");
+      if (mCorners[ro].opposite != corner)
+        errMsg("invalid opposite ref");
+      set<int> &rnodes = m1RingLookup[node].nodes;
+      set<int> &rtris = m1RingLookup[node].tris;
+      if (rnodes.find(next) == rnodes.end() || rnodes.find(prev) == rnodes.end()) {
+        debMsg("Tri " << t << " " << node << " " << next << " " << prev, 1);
+        for (set<int>::iterator it = rnodes.begin(); it != rnodes.end(); ++it)
+          debMsg(*it, 1);
+        errMsg("node missing in 1ring");
+      }
+      if (rtris.find(t) == rtris.end()) {
+        debMsg("Tri " << t << " " << node, 1);
+        errMsg("tri missing in 1ring");
+      }
+    }
+  }
+  for (int n = 0; n < nodes; n++) {
+    bool docheck = true;
+    if (deletedNodes)
+      for (size_t e = 0; e < deletedNodes->size(); e++)
+        if ((*deletedNodes)[e] == n)
+          docheck = false;
+    ;
+
+    if (docheck) {
+      set<int> &sn = m1RingLookup[n].nodes;
+      set<int> &st = m1RingLookup[n].tris;
+      set<int> sn2;
+
+      for (set<int>::iterator it = st.begin(); it != st.end(); ++it) {
+        bool found = false;
+        for (int c = 0; c < 3; c++) {
+          if (mTris[*it].c[c] == n)
+            found = true;
+          else
+            sn2.insert(mTris[*it].c[c]);
+        }
+        if (!found) {
+          cout << *it << " " << n << endl;
+          for (int c = 0; c < 3; c++)
+            cout << mTris[*it].c[c] << endl;
+          errMsg("invalid triangle in 1ring");
+        }
+        if (taintedTris && taintedTris->find(*it) != taintedTris->end()) {
+          cout << *it << endl;
+          errMsg("tainted tri still is use");
+        }
+      }
+      if (sn.size() != sn2.size())
+        errMsg("invalid nodes in 1ring");
+      for (set<int>::iterator it = sn.begin(), it2 = sn2.begin(); it != sn.end(); ++it, ++it2) {
+        if (*it != *it2) {
+          cout << "Node " << n << ": " << *it << " vs " << *it2 << endl;
+          errMsg("node ring mismatch");
+        }
+      }
+    }
+  }
+}
+
+//*****************************************************************************
+// rasterization
+
+void meshSDF(Mesh &mesh, LevelsetGrid &levelset, Real sigma, Real cutoff = 0.);
+
+//! helper vec3 array container
+struct CVec3Ptr {
+  Real *x, *y, *z;
+  inline Vec3 get(int i) const
+  {
+    return Vec3(x[i], y[i], z[i]);
+  };
+  inline void set(int i, const Vec3 &v)
+  {
+    x[i] = v.x;
+    y[i] = v.y;
+    z[i] = v.z;
+  };
+};
+//! helper vec3 array, for CUDA compatibility, remove at some point
+struct CVec3Array {
+  CVec3Array(int sz)
+  {
+    x.resize(sz);
+    y.resize(sz);
+    z.resize(sz);
+  }
+  CVec3Array(const std::vector<Vec3> &v)
+  {
+    x.resize(v.size());
+    y.resize(v.size());
+    z.resize(v.size());
+    for (size_t i = 0; i < v.size(); i++) {
+      x[i] = v[i].x;
+      y[i] = v[i].y;
+      z[i] = v[i].z;
+    }
+  }
+  CVec3Ptr data()
+  {
+    CVec3Ptr a = {x.data(), y.data(), z.data()};
+    return a;
+  }
+  inline const Vec3 operator[](int idx) const
+  {
+    return Vec3((Real)x[idx], (Real)y[idx], (Real)z[idx]);
+  }
+  inline void set(int idx, const Vec3 &v)
+  {
+    x[idx] = v.x;
+    y[idx] = v.y;
+    z[idx] = v.z;
+  }
+  inline int size()
+  {
+    return x.size();
+  }
+  std::vector<Real> x, y, z;
+};
+
+// void SDFKernel(const int* partStart, const int* partLen, CVec3Ptr pos, CVec3Ptr normal, Real*
+// sdf, Vec3i gridRes, int intRadius, Real safeRadius2, Real cutoff2, Real isigma2);
+//! helper for rasterization
+static void SDFKernel(Grid<int> &partStart,
+                      Grid<int> &partLen,
+                      CVec3Ptr pos,
+                      CVec3Ptr normal,
+                      LevelsetGrid &sdf,
+                      Vec3i gridRes,
+                      int intRadius,
+                      Real safeRadius2,
+                      Real cutoff2,
+                      Real isigma2)
+{
+  for (int cnt_x(0); cnt_x < gridRes[0]; ++cnt_x) {
+    for (int cnt_y(0); cnt_y < gridRes[1]; ++cnt_y) {
+      for (int cnt_z(0); cnt_z < gridRes[2]; ++cnt_z) {
+        // cell index, center
+        Vec3i cell = Vec3i(cnt_x, cnt_y, cnt_z);
+        if (cell.x >= gridRes.x || cell.y >= gridRes.y || cell.z >= gridRes.z)
+          return;
+        Vec3 cpos = Vec3(cell.x + 0.5f, cell.y + 0.5f, cell.z + 0.5f);
+        Real sum = 0.0f;
+        Real dist = 0.0f;
+
+        // query cells within block radius
+        Vec3i minBlock = Vec3i(
+            max(cell.x - intRadius, 0), max(cell.y - intRadius, 0), max(cell.z - intRadius, 0));
+        Vec3i maxBlock = Vec3i(min(cell.x + intRadius, gridRes.x - 1),
+                               min(cell.y + intRadius, gridRes.y - 1),
+                               min(cell.z + intRadius, gridRes.z - 1));
+        for (int i = minBlock.x; i <= maxBlock.x; i++)
+          for (int j = minBlock.y; j <= maxBlock.y; j++)
+            for (int k = minBlock.z; k <= maxBlock.z; k++) {
+              // test if block is within radius
+              Vec3 d = Vec3(cell.x - i, cell.y - j, cell.z - k);
+              Real normSqr = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
+              if (normSqr > safeRadius2)
+                continue;
+
+              // find source cell, and divide it into thread blocks
+              int block = i + gridRes.x * (j + gridRes.y * k);
+              int slen = partLen[block];
+              if (slen == 0)
+                continue;
+              int start = partStart[block];
+
+              // process sources
+              for (int s = 0; s < slen; s++) {
+
+                // actual sdf kernel
+                Vec3 r = cpos - pos.get(start + s);
+                Real normSqr = r[0] * r[0] + r[1] * r[1] + r[2] * r[2];
+                Real r2 = normSqr;
+                if (r2 < cutoff2) {
+                  Real w = expf(-r2 * isigma2);
+                  sum += w;
+                  dist += dot(normal.get(start + s), r) * w;
+                }
+              }
+            }
+        // writeback
+        if (sum > 0.0f) {
+          // sdf[cell.x + gridRes.x * (cell.y + gridRes.y * cell.z)] = dist / sum;
+          sdf(cell.x, cell.y, cell.z) = dist / sum;
+        }
+      }
+    }
+  }
+}
+
+static inline IndexInt _cIndex(const Vec3 &pos, const Vec3i &s)
+{
+  Vec3i p = toVec3i(pos);
+  if (p.x < 0 || p.y < 0 || p.z < 0 || p.x >= s.x || p.y >= s.y || p.z >= s.z)
+    return -1;
+  return p.x + s.x * (p.y + s.y * p.z);
+}
+
+//! Kernel: Apply a shape to a grid, setting value inside
+
+template<class T> struct ApplyMeshToGrid : public KernelBase {
+  ApplyMeshToGrid(Grid<T> *grid, Grid<Real> &sdf, T value, FlagGrid *respectFlags)
+      : KernelBase(grid, 0), grid(grid), sdf(sdf), value(value), respectFlags(respectFlags)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, Grid<T> *grid, Grid<Real> &sdf, T value, FlagGrid *respectFlags) const
+  {
+    if (respectFlags && respectFlags->isObstacle(i, j, k))
+      return;
+    if (sdf(i, j, k) < 0) {
+      (*grid)(i, j, k) = value;
+    }
+  }
+  inline Grid<T> *getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<T> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return sdf;
+  }
+  typedef Grid<Real> type1;
+  inline T &getArg2()
+  {
+    return value;
+  }
+  typedef T type2;
+  inline FlagGrid *getArg3()
+  {
+    return respectFlags;
+  }
+  typedef FlagGrid type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyMeshToGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, sdf, value, respectFlags);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, sdf, value, respectFlags);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> *grid;
+  Grid<Real> &sdf;
+  T value;
+  FlagGrid *respectFlags;
+};
+
+void Mesh::applyMeshToGrid(GridBase *grid, FlagGrid *respectFlags, Real cutoff, Real meshSigma)
+{
+  FluidSolver dummy(grid->getSize());
+  LevelsetGrid mesh_sdf(&dummy, false);
+  meshSDF(*this, mesh_sdf, meshSigma, cutoff);  // meshSigma=2 fixed here
+
+#if NOPYTHON != 1
+  if (grid->getType() & GridBase::TypeInt)
+    ApplyMeshToGrid<int>((Grid<int> *)grid, mesh_sdf, _args.get<int>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeReal)
+    ApplyMeshToGrid<Real>((Grid<Real> *)grid, mesh_sdf, _args.get<Real>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeVec3)
+    ApplyMeshToGrid<Vec3>((Grid<Vec3> *)grid, mesh_sdf, _args.get<Vec3>("value"), respectFlags);
+  else
+    errMsg("Shape::applyToGrid(): unknown grid type");
+#else
+  errMsg("Not yet supported...");
+#endif
+}
+
+void Mesh::computeLevelset(LevelsetGrid &levelset, Real sigma, Real cutoff)
+{
+  meshSDF(*this, levelset, sigma, cutoff);
+}
+
+LevelsetGrid Mesh::getLevelset(Real sigma, Real cutoff)
+{
+  LevelsetGrid phi(getParent());
+  meshSDF(*this, phi, sigma, cutoff);
+  return phi;
+}
+
+void meshSDF(Mesh &mesh, LevelsetGrid &levelset, Real sigma, Real cutoff)
+{
+  if (cutoff < 0)
+    cutoff = 2 * sigma;
+  Real maxEdgeLength = 0.75;
+  Real numSamplesPerCell = 0.75;
+
+  Vec3i gridRes = levelset.getSize();
+  Vec3 mult = toVec3(gridRes) / toVec3(mesh.getParent()->getGridSize());
+
+  // prepare center values
+  std::vector<Vec3> center;
+  std::vector<Vec3> normals;
+  short bigEdges(0);
+  std::vector<Vec3> samplePoints;
+  for (int i = 0; i < mesh.numTris(); i++) {
+    center.push_back(Vec3(mesh.getFaceCenter(i) * mult));
+    normals.push_back(mesh.getFaceNormal(i));
+    // count big, stretched edges
+    bigEdges = 0;
+    for (short edge(0); edge < 3; ++edge) {
+      if (norm(mesh.getEdge(i, edge)) > maxEdgeLength) {
+        bigEdges += 1 << edge;
+      }
+    }
+    if (bigEdges > 0) {
+      samplePoints.clear();
+      short iterA, pointA, iterB, pointB;
+      int numSamples0 = norm(mesh.getEdge(i, 1)) * numSamplesPerCell;
+      int numSamples1 = norm(mesh.getEdge(i, 2)) * numSamplesPerCell;
+      int numSamples2 = norm(mesh.getEdge(i, 0)) * numSamplesPerCell;
+      if (!(bigEdges & (1 << 0))) {
+        // loop through 0,1
+        iterA = numSamples1;
+        pointA = 0;
+        iterB = numSamples2;
+        pointB = 1;
+      }
+      else if (!(bigEdges & (1 << 1))) {
+        // loop through 1,2
+        iterA = numSamples2;
+        pointA = 1;
+        iterB = numSamples0;
+        pointB = 2;
+      }
+      else {
+        // loop through 2,0
+        iterA = numSamples0;
+        pointA = 2;
+        iterB = numSamples1;
+        pointB = 0;
+      }
+
+      Real u(0.), v(0.), w(0.);  // barycentric uvw coords
+      Vec3 samplePoint, normal;
+      for (int sample0(0); sample0 < iterA; ++sample0) {
+        u = Real(1. * sample0 / iterA);
+        for (int sample1(0); sample1 < iterB; ++sample1) {
+          v = Real(1. * sample1 / iterB);
+          w = 1 - u - v;
+          if (w < 0.)
+            continue;
+          samplePoint = mesh.getNode(i, pointA) * mult * u + mesh.getNode(i, pointB) * mult * v +
+                        mesh.getNode(i, (3 - pointA - pointB)) * mult * w;
+          samplePoints.push_back(samplePoint);
+          normal = mesh.getFaceNormal(i);
+          normals.push_back(normal);
+        }
+      }
+      center.insert(center.end(), samplePoints.begin(), samplePoints.end());
+    }
+  }
+
+  // prepare grid
+  levelset.setConst(-cutoff);
+
+  // 1. count sources per cell
+  Grid<int> srcPerCell(levelset.getParent());
+  for (size_t i = 0; i < center.size(); i++) {
+    IndexInt idx = _cIndex(center[i], gridRes);
+    if (idx >= 0)
+      srcPerCell[idx]++;
+  }
+
+  // 2. create start index lookup
+  Grid<int> srcCellStart(levelset.getParent());
+  int cnt = 0;
+  FOR_IJK(srcCellStart)
+  {
+    IndexInt idx = srcCellStart.index(i, j, k);
+    srcCellStart[idx] = cnt;
+    cnt += srcPerCell[idx];
+  }
+
+  // 3. reorder nodes
+  CVec3Array reorderPos(center.size());
+  CVec3Array reorderNormal(center.size());
+  {
+    Grid<int> curSrcCell(levelset.getParent());
+    for (int i = 0; i < (int)center.size(); i++) {
+      IndexInt idx = _cIndex(center[i], gridRes);
+      if (idx < 0)
+        continue;
+      IndexInt idx2 = srcCellStart[idx] + curSrcCell[idx];
+      reorderPos.set(idx2, center[i]);
+      reorderNormal.set(idx2, normals[i]);
+      curSrcCell[idx]++;
+    }
+  }
+
+  // construct parameters
+  Real safeRadius = cutoff + sqrt(3.0) * 0.5;
+  Real safeRadius2 = safeRadius * safeRadius;
+  Real cutoff2 = cutoff * cutoff;
+  Real isigma2 = 1.0 / (sigma * sigma);
+  int intRadius = (int)(cutoff + 0.5);
+
+  SDFKernel(srcCellStart,
+            srcPerCell,
+            reorderPos.data(),
+            reorderNormal.data(),
+            levelset,
+            gridRes,
+            intRadius,
+            safeRadius2,
+            cutoff2,
+            isigma2);
+
+  // floodfill outside
+  std::stack<Vec3i> outside;
+  FOR_IJK(levelset)
+  {
+    if (levelset(i, j, k) >= cutoff - 1.0f)
+      outside.push(Vec3i(i, j, k));
+  }
+  while (!outside.empty()) {
+    Vec3i c = outside.top();
+    outside.pop();
+    levelset(c) = cutoff;
+    if (c.x > 0 && levelset(c.x - 1, c.y, c.z) < 0)
+      outside.push(Vec3i(c.x - 1, c.y, c.z));
+    if (c.y > 0 && levelset(c.x, c.y - 1, c.z) < 0)
+      outside.push(Vec3i(c.x, c.y - 1, c.z));
+    if (c.z > 0 && levelset(c.x, c.y, c.z - 1) < 0)
+      outside.push(Vec3i(c.x, c.y, c.z - 1));
+    if (c.x < levelset.getSizeX() - 1 && levelset(c.x + 1, c.y, c.z) < 0)
+      outside.push(Vec3i(c.x + 1, c.y, c.z));
+    if (c.y < levelset.getSizeY() - 1 && levelset(c.x, c.y + 1, c.z) < 0)
+      outside.push(Vec3i(c.x, c.y + 1, c.z));
+    if (c.z < levelset.getSizeZ() - 1 && levelset(c.x, c.y, c.z + 1) < 0)
+      outside.push(Vec3i(c.x, c.y, c.z + 1));
+  };
+}
+
+// Blender data pointer accessors
+std::string Mesh::getNodesDataPointer()
+{
+  std::ostringstream out;
+  out << &mNodes;
+  return out.str();
+}
+std::string Mesh::getTrisDataPointer()
+{
+  std::ostringstream out;
+  out << &mTris;
+  return out.str();
+}
+
+// mesh data
+
+MeshDataBase::MeshDataBase(FluidSolver *parent) : PbClass(parent), mMesh(NULL)
+{
+}
+
+MeshDataBase::~MeshDataBase()
+{
+  // notify parent of deletion
+  if (mMesh)
+    mMesh->deregister(this);
+}
+
+// actual data implementation
+
+template<class T>
+MeshDataImpl<T>::MeshDataImpl(FluidSolver *parent)
+    : MeshDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+{
+}
+
+template<class T>
+MeshDataImpl<T>::MeshDataImpl(FluidSolver *parent, MeshDataImpl<T> *other)
+    : MeshDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+{
+  this->mData = other->mData;
+  setName(other->getName());
+}
+
+template<class T> MeshDataImpl<T>::~MeshDataImpl()
+{
+}
+
+template<class T> IndexInt MeshDataImpl<T>::getSizeSlow() const
+{
+  return mData.size();
+}
+template<class T> void MeshDataImpl<T>::addEntry()
+{
+  // add zero'ed entry
+  T tmp = T(0.);
+  // for debugging, force init:
+  // tmp = T(0.02 * mData.size()); // increasing
+  // tmp = T(1.); // constant 1
+  return mData.push_back(tmp);
+}
+template<class T> void MeshDataImpl<T>::resize(IndexInt s)
+{
+  mData.resize(s);
+}
+template<class T> void MeshDataImpl<T>::copyValueSlow(IndexInt from, IndexInt to)
+{
+  this->copyValue(from, to);
+}
+template<class T> MeshDataBase *MeshDataImpl<T>::clone()
+{
+  MeshDataImpl<T> *npd = new MeshDataImpl<T>(getParent(), this);
+  return npd;
+}
+
+template<class T> void MeshDataImpl<T>::setSource(Grid<T> *grid, bool isMAC)
+{
+  mpGridSource = grid;
+  mGridSourceMAC = isMAC;
+  if (isMAC)
+    assertMsg(dynamic_cast<MACGrid *>(grid) != NULL, "Given grid is not a valid MAC grid");
+}
+
+template<class T> void MeshDataImpl<T>::initNewValue(IndexInt idx, Vec3 pos)
+{
+  if (!mpGridSource)
+    mData[idx] = 0;
+  else {
+    mData[idx] = mpGridSource->getInterpolated(pos);
+  }
+}
+
+// special handling needed for velocities
+template<> void MeshDataImpl<Vec3>::initNewValue(IndexInt idx, Vec3 pos)
+{
+  if (!mpGridSource)
+    mData[idx] = 0;
+  else {
+    if (!mGridSourceMAC)
+      mData[idx] = mpGridSource->getInterpolated(pos);
+    else
+      mData[idx] = ((MACGrid *)mpGridSource)->getInterpolated(pos);
+  }
+}
+
+//! update additional mesh data
+void Mesh::updateDataFields()
+{
+  for (size_t i = 0; i < mNodes.size(); ++i) {
+    Vec3 pos = mNodes[i].pos;
+    for (IndexInt md = 0; md < (IndexInt)mMdataReal.size(); ++md)
+      mMdataReal[md]->initNewValue(i, mNodes[i].pos);
+    for (IndexInt md = 0; md < (IndexInt)mMdataVec3.size(); ++md)
+      mMdataVec3[md]->initNewValue(i, mNodes[i].pos);
+    for (IndexInt md = 0; md < (IndexInt)mMdataInt.size(); ++md)
+      mMdataInt[md]->initNewValue(i, mNodes[i].pos);
+  }
+}
+
+template<typename T> void MeshDataImpl<T>::load(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    readMdataUni<T>(name, this);
+  else if (ext == ".raw")  // raw = uni for now
+    readMdataUni<T>(name, this);
+  else
+    errMsg("mesh data '" + name + "' filetype not supported for loading");
+}
+
+template<typename T> void MeshDataImpl<T>::save(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    writeMdataUni<T>(name, this);
+  else if (ext == ".raw")  // raw = uni for now
+    writeMdataUni<T>(name, this);
+  else
+    errMsg("mesh data '" + name + "' filetype not supported for saving");
+}
+
+// specializations
+
+template<> MeshDataBase::MdataType MeshDataImpl<Real>::getType() const
+{
+  return MeshDataBase::TypeReal;
+}
+template<> MeshDataBase::MdataType MeshDataImpl<int>::getType() const
+{
+  return MeshDataBase::TypeInt;
+}
+template<> MeshDataBase::MdataType MeshDataImpl<Vec3>::getType() const
+{
+  return MeshDataBase::TypeVec3;
+}
+
+template<class T> struct knSetMdataConst : public KernelBase {
+  knSetMdataConst(MeshDataImpl<T> &mdata, T value)
+      : KernelBase(mdata.size()), mdata(mdata), value(value)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &mdata, T value) const
+  {
+    mdata[idx] = value;
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return mdata;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetMdataConst ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, mdata, value);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &mdata;
+  T value;
+};
+
+template<class T, class S> struct knMdataSet : public KernelBase {
+  knMdataSet(MeshDataImpl<T> &me, const MeshDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const MeshDataImpl<S> &other) const
+  {
+    me[idx] += other[idx];
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataSet ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<S> &other;
+};
+template<class T, class S> struct knMdataAdd : public KernelBase {
+  knMdataAdd(MeshDataImpl<T> &me, const MeshDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const MeshDataImpl<S> &other) const
+  {
+    me[idx] += other[idx];
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataAdd ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<S> &other;
+};
+template<class T, class S> struct knMdataSub : public KernelBase {
+  knMdataSub(MeshDataImpl<T> &me, const MeshDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const MeshDataImpl<S> &other) const
+  {
+    me[idx] -= other[idx];
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataSub ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<S> &other;
+};
+template<class T, class S> struct knMdataMult : public KernelBase {
+  knMdataMult(MeshDataImpl<T> &me, const MeshDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const MeshDataImpl<S> &other) const
+  {
+    me[idx] *= other[idx];
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataMult ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<S> &other;
+};
+template<class T, class S> struct knMdataDiv : public KernelBase {
+  knMdataDiv(MeshDataImpl<T> &me, const MeshDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const MeshDataImpl<S> &other) const
+  {
+    me[idx] /= other[idx];
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataDiv ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<S> &other;
+};
+
+template<class T, class S> struct knMdataSetScalar : public KernelBase {
+  knMdataSetScalar(MeshDataImpl<T> &me, const S &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const S &other) const
+  {
+    me[idx] = other;
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataSetScalar ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const S &other;
+};
+template<class T, class S> struct knMdataAddScalar : public KernelBase {
+  knMdataAddScalar(MeshDataImpl<T> &me, const S &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const S &other) const
+  {
+    me[idx] += other;
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataAddScalar ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const S &other;
+};
+template<class T, class S> struct knMdataMultScalar : public KernelBase {
+  knMdataMultScalar(MeshDataImpl<T> &me, const S &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const S &other) const
+  {
+    me[idx] *= other;
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataMultScalar ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const S &other;
+};
+template<class T, class S> struct knMdataScaledAdd : public KernelBase {
+  knMdataScaledAdd(MeshDataImpl<T> &me, const MeshDataImpl<T> &other, const S &factor)
+      : KernelBase(me.size()), me(me), other(other), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 MeshDataImpl<T> &me,
+                 const MeshDataImpl<T> &other,
+                 const S &factor) const
+  {
+    me[idx] += factor * other[idx];
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<T> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<T> type1;
+  inline const S &getArg2()
+  {
+    return factor;
+  }
+  typedef S type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataScaledAdd ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, factor);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<T> &other;
+  const S &factor;
+};
+
+template<class T> struct knMdataSafeDiv : public KernelBase {
+  knMdataSafeDiv(MeshDataImpl<T> &me, const MeshDataImpl<T> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const MeshDataImpl<T> &other) const
+  {
+    me[idx] = safeDivide(me[idx], other[idx]);
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<T> &getArg1()
+  {
+    return other;
+  }
+  typedef MeshDataImpl<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataSafeDiv ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const MeshDataImpl<T> &other;
+};
+template<class T> struct knMdataSetConst : public KernelBase {
+  knMdataSetConst(MeshDataImpl<T> &mdata, T value)
+      : KernelBase(mdata.size()), mdata(mdata), value(value)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &mdata, T value) const
+  {
+    mdata[idx] = value;
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return mdata;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataSetConst ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, mdata, value);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &mdata;
+  T value;
+};
+
+template<class T> struct knMdataClamp : public KernelBase {
+  knMdataClamp(MeshDataImpl<T> &me, T min, T max)
+      : KernelBase(me.size()), me(me), min(min), max(max)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, T min, T max) const
+  {
+    me[idx] = clamp(me[idx], min, max);
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline T &getArg1()
+  {
+    return min;
+  }
+  typedef T type1;
+  inline T &getArg2()
+  {
+    return max;
+  }
+  typedef T type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataClamp ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, min, max);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  T min;
+  T max;
+};
+template<class T> struct knMdataClampMin : public KernelBase {
+  knMdataClampMin(MeshDataImpl<T> &me, const T vmin) : KernelBase(me.size()), me(me), vmin(vmin)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const T vmin) const
+  {
+    me[idx] = std::max(vmin, me[idx]);
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const T &getArg1()
+  {
+    return vmin;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataClampMin ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmin);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const T vmin;
+};
+template<class T> struct knMdataClampMax : public KernelBase {
+  knMdataClampMax(MeshDataImpl<T> &me, const T vmax) : KernelBase(me.size()), me(me), vmax(vmax)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<T> &me, const T vmax) const
+  {
+    me[idx] = std::min(vmax, me[idx]);
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const T &getArg1()
+  {
+    return vmax;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataClampMax ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmax);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const T vmax;
+};
+struct knMdataClampMinVec3 : public KernelBase {
+  knMdataClampMinVec3(MeshDataImpl<Vec3> &me, const Real vmin)
+      : KernelBase(me.size()), me(me), vmin(vmin)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<Vec3> &me, const Real vmin) const
+  {
+    me[idx].x = std::max(vmin, me[idx].x);
+    me[idx].y = std::max(vmin, me[idx].y);
+    me[idx].z = std::max(vmin, me[idx].z);
+  }
+  inline MeshDataImpl<Vec3> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<Vec3> type0;
+  inline const Real &getArg1()
+  {
+    return vmin;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataClampMinVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmin);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<Vec3> &me;
+  const Real vmin;
+};
+struct knMdataClampMaxVec3 : public KernelBase {
+  knMdataClampMaxVec3(MeshDataImpl<Vec3> &me, const Real vmax)
+      : KernelBase(me.size()), me(me), vmax(vmax)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, MeshDataImpl<Vec3> &me, const Real vmax) const
+  {
+    me[idx].x = std::min(vmax, me[idx].x);
+    me[idx].y = std::min(vmax, me[idx].y);
+    me[idx].z = std::min(vmax, me[idx].z);
+  }
+  inline MeshDataImpl<Vec3> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<Vec3> type0;
+  inline const Real &getArg1()
+  {
+    return vmax;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataClampMaxVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmax);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<Vec3> &me;
+  const Real vmax;
+};
+
+// python operators
+
+template<typename T> MeshDataImpl<T> &MeshDataImpl<T>::copyFrom(const MeshDataImpl<T> &a)
+{
+  assertMsg(a.mData.size() == mData.size(),
+            "different mdata size " << a.mData.size() << " vs " << this->mData.size());
+  memcpy(&mData[0], &a.mData[0], sizeof(T) * mData.size());
+  return *this;
+}
+
+template<typename T> void MeshDataImpl<T>::setConst(T s)
+{
+  knMdataSetScalar<T, T> op(*this, s);
+}
+
+template<typename T> void MeshDataImpl<T>::setConstRange(T s, const int begin, const int end)
+{
+  for (int i = begin; i < end; ++i)
+    (*this)[i] = s;
+}
+
+// special set by flag
+template<class T, class S> struct knMdataSetScalarIntFlag : public KernelBase {
+  knMdataSetScalarIntFlag(MeshDataImpl<T> &me,
+                          const S &other,
+                          const MeshDataImpl<int> &t,
+                          const int itype)
+      : KernelBase(me.size()), me(me), other(other), t(t), itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 MeshDataImpl<T> &me,
+                 const S &other,
+                 const MeshDataImpl<int> &t,
+                 const int itype) const
+  {
+    if (t[idx] & itype)
+      me[idx] = other;
+  }
+  inline MeshDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  inline const MeshDataImpl<int> &getArg2()
+  {
+    return t;
+  }
+  typedef MeshDataImpl<int> type2;
+  inline const int &getArg3()
+  {
+    return itype;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMdataSetScalarIntFlag ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, t, itype);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MeshDataImpl<T> &me;
+  const S &other;
+  const MeshDataImpl<int> &t;
+  const int itype;
+};
+template<typename T>
+void MeshDataImpl<T>::setConstIntFlag(T s, const MeshDataImpl<int> &t, const int itype)
+{
+  knMdataSetScalarIntFlag<T, T> op(*this, s, t, itype);
+}
+
+template<typename T> void MeshDataImpl<T>::add(const MeshDataImpl<T> &a)
+{
+  knMdataAdd<T, T> op(*this, a);
+}
+template<typename T> void MeshDataImpl<T>::sub(const MeshDataImpl<T> &a)
+{
+  knMdataSub<T, T> op(*this, a);
+}
+
+template<typename T> void MeshDataImpl<T>::addConst(T s)
+{
+  knMdataAddScalar<T, T> op(*this, s);
+}
+
+template<typename T> void MeshDataImpl<T>::addScaled(const MeshDataImpl<T> &a, const T &factor)
+{
+  knMdataScaledAdd<T, T> op(*this, a, factor);
+}
+
+template<typename T> void MeshDataImpl<T>::mult(const MeshDataImpl<T> &a)
+{
+  knMdataMult<T, T> op(*this, a);
+}
+
+template<typename T> void MeshDataImpl<T>::safeDiv(const MeshDataImpl<T> &a)
+{
+  knMdataSafeDiv<T> op(*this, a);
+}
+
+template<typename T> void MeshDataImpl<T>::multConst(T s)
+{
+  knMdataMultScalar<T, T> op(*this, s);
+}
+
+template<typename T> void MeshDataImpl<T>::clamp(Real vmin, Real vmax)
+{
+  knMdataClamp<T> op(*this, vmin, vmax);
+}
+
+template<typename T> void MeshDataImpl<T>::clampMin(Real vmin)
+{
+  knMdataClampMin<T> op(*this, vmin);
+}
+template<typename T> void MeshDataImpl<T>::clampMax(Real vmax)
+{
+  knMdataClampMax<T> op(*this, vmax);
+}
+
+template<> void MeshDataImpl<Vec3>::clampMin(Real vmin)
+{
+  knMdataClampMinVec3 op(*this, vmin);
+}
+template<> void MeshDataImpl<Vec3>::clampMax(Real vmax)
+{
+  knMdataClampMaxVec3 op(*this, vmax);
+}
+
+template<typename T> struct KnPtsSum : public KernelBase {
+  KnPtsSum(const MeshDataImpl<T> &val, const MeshDataImpl<int> *t, const int itype)
+      : KernelBase(val.size()), val(val), t(t), itype(itype), result(T(0.))
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const MeshDataImpl<T> &val,
+                 const MeshDataImpl<int> *t,
+                 const int itype,
+                 T &result)
+  {
+    if (t && !((*t)[idx] & itype))
+      return;
+    result += val[idx];
+  }
+  inline operator T()
+  {
+    return result;
+  }
+  inline T &getRet()
+  {
+    return result;
+  }
+  inline const MeshDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<T> type0;
+  inline const MeshDataImpl<int> *getArg1()
+  {
+    return t;
+  }
+  typedef MeshDataImpl<int> type1;
+  inline const int &getArg2()
+  {
+    return itype;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnPtsSum ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, t, itype, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  KnPtsSum(KnPtsSum &o, tbb::split)
+      : KernelBase(o), val(o.val), t(o.t), itype(o.itype), result(T(0.))
+  {
+  }
+  void join(const KnPtsSum &o)
+  {
+    result += o.result;
+  }
+  const MeshDataImpl<T> &val;
+  const MeshDataImpl<int> *t;
+  const int itype;
+  T result;
+};
+template<typename T> struct KnPtsSumSquare : public KernelBase {
+  KnPtsSumSquare(const MeshDataImpl<T> &val) : KernelBase(val.size()), val(val), result(0.)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const MeshDataImpl<T> &val, Real &result)
+  {
+    result += normSquare(val[idx]);
+  }
+  inline operator Real()
+  {
+    return result;
+  }
+  inline Real &getRet()
+  {
+    return result;
+  }
+  inline const MeshDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnPtsSumSquare ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  KnPtsSumSquare(KnPtsSumSquare &o, tbb::split) : KernelBase(o), val(o.val), result(0.)
+  {
+  }
+  void join(const KnPtsSumSquare &o)
+  {
+    result += o.result;
+  }
+  const MeshDataImpl<T> &val;
+  Real result;
+};
+template<typename T> struct KnPtsSumMagnitude : public KernelBase {
+  KnPtsSumMagnitude(const MeshDataImpl<T> &val) : KernelBase(val.size()), val(val), result(0.)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const MeshDataImpl<T> &val, Real &result)
+  {
+    result += norm(val[idx]);
+  }
+  inline operator Real()
+  {
+    return result;
+  }
+  inline Real &getRet()
+  {
+    return result;
+  }
+  inline const MeshDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnPtsSumMagnitude ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  KnPtsSumMagnitude(KnPtsSumMagnitude &o, tbb::split) : KernelBase(o), val(o.val), result(0.)
+  {
+  }
+  void join(const KnPtsSumMagnitude &o)
+  {
+    result += o.result;
+  }
+  const MeshDataImpl<T> &val;
+  Real result;
+};
+
+template<typename T> T MeshDataImpl<T>::sum(const MeshDataImpl<int> *t, const int itype) const
+{
+  return KnPtsSum<T>(*this, t, itype);
+}
+template<typename T> Real MeshDataImpl<T>::sumSquare() const
+{
+  return KnPtsSumSquare<T>(*this);
+}
+template<typename T> Real MeshDataImpl<T>::sumMagnitude() const
+{
+  return KnPtsSumMagnitude<T>(*this);
+}
+
+template<typename T>
+
+struct CompMdata_Min : public KernelBase {
+  CompMdata_Min(const MeshDataImpl<T> &val)
+      : KernelBase(val.size()), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const MeshDataImpl<T> &val, Real &minVal)
+  {
+    if (val[idx] < minVal)
+      minVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline const MeshDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMdata_Min ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMdata_Min(CompMdata_Min &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMdata_Min &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const MeshDataImpl<T> &val;
+  Real minVal;
+};
+
+template<typename T>
+
+struct CompMdata_Max : public KernelBase {
+  CompMdata_Max(const MeshDataImpl<T> &val)
+      : KernelBase(val.size()), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const MeshDataImpl<T> &val, Real &maxVal)
+  {
+    if (val[idx] > maxVal)
+      maxVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline const MeshDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMdata_Max ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMdata_Max(CompMdata_Max &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMdata_Max &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const MeshDataImpl<T> &val;
+  Real maxVal;
+};
+
+template<typename T> Real MeshDataImpl<T>::getMin()
+{
+  return CompMdata_Min<T>(*this);
+}
+
+template<typename T> Real MeshDataImpl<T>::getMaxAbs()
+{
+  Real amin = CompMdata_Min<T>(*this);
+  Real amax = CompMdata_Max<T>(*this);
+  return max(fabs(amin), fabs(amax));
+}
+
+template<typename T> Real MeshDataImpl<T>::getMax()
+{
+  return CompMdata_Max<T>(*this);
+}
+
+template<typename T>
+void MeshDataImpl<T>::printMdata(IndexInt start, IndexInt stop, bool printIndex)
+{
+  std::ostringstream sstr;
+  IndexInt s = (start > 0 ? start : 0);
+  IndexInt e = (stop > 0 ? stop : (IndexInt)mData.size());
+  s = Manta::clamp(s, (IndexInt)0, (IndexInt)mData.size());
+  e = Manta::clamp(e, (IndexInt)0, (IndexInt)mData.size());
+
+  for (IndexInt i = s; i < e; ++i) {
+    if (printIndex)
+      sstr << i << ": ";
+    sstr << mData[i] << " "
+         << "\n";
+  }
+  debMsg(sstr.str(), 1);
+}
+template<class T> std::string MeshDataImpl<T>::getDataPointer()
+{
+  std::ostringstream out;
+  out << &mData;
+  return out.str();
+}
+
+// specials for vec3
+// work on length values, ie, always positive (in contrast to scalar versions above)
+
+struct CompMdata_MinVec3 : public KernelBase {
+  CompMdata_MinVec3(const MeshDataImpl<Vec3> &val)
+      : KernelBase(val.size()), val(val), minVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const MeshDataImpl<Vec3> &val, Real &minVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s < minVal)
+      minVal = s;
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline const MeshDataImpl<Vec3> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<Vec3> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMdata_MinVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMdata_MinVec3(CompMdata_MinVec3 &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompMdata_MinVec3 &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const MeshDataImpl<Vec3> &val;
+  Real minVal;
+};
+
+struct CompMdata_MaxVec3 : public KernelBase {
+  CompMdata_MaxVec3(const MeshDataImpl<Vec3> &val)
+      : KernelBase(val.size()), val(val), maxVal(-std::numeric_limits<Real>::min())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const MeshDataImpl<Vec3> &val, Real &maxVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s > maxVal)
+      maxVal = s;
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline const MeshDataImpl<Vec3> &getArg0()
+  {
+    return val;
+  }
+  typedef MeshDataImpl<Vec3> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompMdata_MaxVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompMdata_MaxVec3(CompMdata_MaxVec3 &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::min())
+  {
+  }
+  void join(const CompMdata_MaxVec3 &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const MeshDataImpl<Vec3> &val;
+  Real maxVal;
+};
+
+template<> Real MeshDataImpl<Vec3>::getMin()
+{
+  return sqrt(CompMdata_MinVec3(*this));
+}
+
+template<> Real MeshDataImpl<Vec3>::getMaxAbs()
+{
+  return sqrt(CompMdata_MaxVec3(*this));  // no minimum necessary here
+}
+
+template<> Real MeshDataImpl<Vec3>::getMax()
+{
+  return sqrt(CompMdata_MaxVec3(*this));
+}
+
+// explicit instantiation
+template class MeshDataImpl<int>;
+template class MeshDataImpl<Real>;
+template class MeshDataImpl<Vec3>;
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/mesh.h b/extern/mantaflow/preprocessed/mesh.h
new file mode 100644
index 00000000000..f49619515ce
--- /dev/null
+++ b/extern/mantaflow/preprocessed/mesh.h
@@ -0,0 +1,1690 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Meshes
+ *
+ *  note: this is only a temporary solution, details are bound to change
+ *        long term goal is integration with Split&Merge code by Wojtan et al.
+ *
+ ******************************************************************************/
+
+#ifndef _MESH_H
+#define _MESH_H
+
+#include <vector>
+#include "manta.h"
+#include "vectorbase.h"
+#include <set>
+#include "levelset.h"
+
+namespace Manta {
+
+// fwd decl
+class GridBase;
+// class LevelsetGrid;
+class FlagGrid;
+class MACGrid;
+class Shape;
+class MeshDataBase;
+template<class T> class MeshDataImpl;
+
+//! Node position and flags
+struct Node {
+  Node() : flags(0), pos(Vec3::Zero), normal(Vec3::Zero)
+  {
+  }
+  Node(const Vec3 &p) : flags(0), pos(p)
+  {
+  }
+  int flags;
+  Vec3 pos, normal;
+};
+
+//! Carries indices of its nodes
+struct Triangle {
+  Triangle() : flags(0)
+  {
+    c[0] = c[1] = c[2] = 0;
+  }
+  Triangle(int n0, int n1, int n2) : flags(0)
+  {
+    c[0] = n0;
+    c[1] = n1;
+    c[2] = n2;
+  }
+
+  int c[3];
+  int flags;
+};
+
+//! For fast access to nodes and neighboring triangles
+struct Corner {
+  Corner() : tri(-1), node(-1), opposite(-1), next(-1), prev(-1){};
+  Corner(int t, int n) : tri(t), node(n), opposite(-1), next(-1), prev(-1)
+  {
+  }
+
+  int tri;
+  int node;
+  int opposite;
+  int next;
+  int prev;
+};
+
+//! Base class for mesh data channels (texture coords, vorticity, ...)
+struct NodeChannel {
+  virtual ~NodeChannel(){};
+  virtual void resize(int num) = 0;
+  virtual int size() = 0;
+  virtual NodeChannel *clone() = 0;
+
+  virtual void addInterpol(int a, int b, Real alpha) = 0;
+  virtual void mergeWith(int node, int delnode, Real alpha) = 0;
+  virtual void renumber(const std::vector<int> &newIndex, int newsize) = 0;
+};
+
+//! Node channel using only a vector
+template<class T> struct SimpleNodeChannel : public NodeChannel {
+  SimpleNodeChannel(){};
+  SimpleNodeChannel(const SimpleNodeChannel<T> &a) : data(a.data)
+  {
+  }
+  void resize(int num)
+  {
+    data.resize(num);
+  }
+  virtual int size()
+  {
+    return data.size();
+  }
+  virtual void renumber(const std::vector<int> &newIndex, int newsize);
+
+  // virtual void addSplit(int from, Real alpha) { data.push_back(data[from]); }
+
+  std::vector<T> data;
+};
+
+//! Base class for mesh data channels (texture coords, vorticity, ...)
+struct TriChannel {
+  virtual ~TriChannel(){};
+  virtual void resize(int num) = 0;
+  virtual TriChannel *clone() = 0;
+  virtual int size() = 0;
+
+  virtual void addNew() = 0;
+  virtual void addSplit(int from, Real alpha) = 0;
+  virtual void remove(int tri) = 0;
+};
+
+//! Tri channel using only a vector
+template<class T> struct SimpleTriChannel : public TriChannel {
+  SimpleTriChannel(){};
+  SimpleTriChannel(const SimpleTriChannel<T> &a) : data(a.data)
+  {
+  }
+  void resize(int num)
+  {
+    data.resize(num);
+  }
+  void remove(int tri)
+  {
+    if (tri != (int)data.size() - 1)
+      data[tri] = *data.rbegin();
+    data.pop_back();
+  }
+  virtual int size()
+  {
+    return data.size();
+  }
+
+  virtual void addSplit(int from, Real alpha)
+  {
+    data.push_back(data[from]);
+  }
+  virtual void addNew()
+  {
+    data.push_back(T());
+  }
+
+  std::vector<T> data;
+};
+
+struct OneRing {
+  OneRing()
+  {
+  }
+  std::set<int> nodes;
+  std::set<int> tris;
+};
+
+//! Triangle mesh class
+/*! note: this is only a temporary solution, details are bound to change
+          long term goal is integration with Split&Merge code by Wojtan et al.*/
+class Mesh : public PbClass {
+ public:
+  Mesh(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Mesh::Mesh", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new Mesh(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Mesh::Mesh", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::Mesh", e.what());
+      return -1;
+    }
+  }
+
+  virtual ~Mesh();
+  virtual Mesh *clone();
+
+  enum NodeFlags { NfNone = 0, NfFixed = 1, NfMarked = 2, NfKillme = 4, NfCollide = 8 };
+  enum FaceFlags { FfNone = 0, FfDoubled = 1, FfMarked = 2 };
+  enum MeshType { TypeNormal = 0, TypeVortexSheet };
+
+  virtual MeshType getType()
+  {
+    return TypeNormal;
+  }
+
+  Real computeCenterOfMass(Vec3 &cm) const;
+  void computeVertexNormals();
+
+  // plugins
+  void clear();
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::clear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clear();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::clear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::clear", e.what());
+      return 0;
+    }
+  }
+
+  void load(std::string name, bool append = false);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::load", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string name = _args.get<std::string>("name", 0, &_lock);
+        bool append = _args.getOpt<bool>("append", 1, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->load(name, append);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::load", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::load", e.what());
+      return 0;
+    }
+  }
+
+  void fromShape(Shape &shape, bool append = false);
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::fromShape", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock);
+        bool append = _args.getOpt<bool>("append", 1, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->fromShape(shape, append);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::fromShape", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::fromShape", e.what());
+      return 0;
+    }
+  }
+
+  void save(std::string name);
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::save", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->save(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::save", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::save", e.what());
+      return 0;
+    }
+  }
+
+  void advectInGrid(FlagGrid &flags, MACGrid &vel, int integrationMode);
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::advectInGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+        int integrationMode = _args.get<int>("integrationMode", 2, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->advectInGrid(flags, vel, integrationMode);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::advectInGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::advectInGrid", e.what());
+      return 0;
+    }
+  }
+
+  void scale(Vec3 s);
+  static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::scale", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Vec3 s = _args.get<Vec3>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->scale(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::scale", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::scale", e.what());
+      return 0;
+    }
+  }
+
+  void offset(Vec3 o);
+  static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::offset", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Vec3 o = _args.get<Vec3>("o", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->offset(o);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::offset", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::offset", e.what());
+      return 0;
+    }
+  }
+
+  void rotate(Vec3 thetas);
+  static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::rotate", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Vec3 thetas = _args.get<Vec3>("thetas", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->rotate(thetas);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::rotate", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::rotate", e.what());
+      return 0;
+    }
+  }
+
+  void computeVelocity(Mesh &oldMesh, MACGrid &vel);
+  static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::computeVelocity", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Mesh &oldMesh = *_args.getPtr<Mesh>("oldMesh", 0, &_lock);
+        MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->computeVelocity(oldMesh, vel);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::computeVelocity", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::computeVelocity", e.what());
+      return 0;
+    }
+  }
+
+  void computeLevelset(LevelsetGrid &levelset, Real sigma, Real cutoff = -1.);
+  static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::computeLevelset", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock);
+        Real sigma = _args.get<Real>("sigma", 1, &_lock);
+        Real cutoff = _args.getOpt<Real>("cutoff", 2, -1., &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->computeLevelset(levelset, sigma, cutoff);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::computeLevelset", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::computeLevelset", e.what());
+      return 0;
+    }
+  }
+
+  LevelsetGrid getLevelset(Real sigma, Real cutoff = -1.);
+  static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::getLevelset", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real sigma = _args.get<Real>("sigma", 0, &_lock);
+        Real cutoff = _args.getOpt<Real>("cutoff", 1, -1., &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getLevelset(sigma, cutoff));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::getLevelset", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::getLevelset", e.what());
+      return 0;
+    }
+  }
+
+  //! map mesh to grid with sdf
+  void applyMeshToGrid(GridBase *grid,
+                       FlagGrid *respectFlags = 0,
+                       Real cutoff = -1.,
+                       Real meshSigma = 2.);
+  static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::applyMeshToGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
+        FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 1, 0, &_lock);
+        Real cutoff = _args.getOpt<Real>("cutoff", 2, -1., &_lock);
+        Real meshSigma = _args.getOpt<Real>("meshSigma", 3, 2., &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->applyMeshToGrid(grid, respectFlags, cutoff, meshSigma);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::applyMeshToGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::applyMeshToGrid", e.what());
+      return 0;
+    }
+  }
+
+  //! get data pointer of nodes
+  std::string getNodesDataPointer();
+  static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::getNodesDataPointer", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getNodesDataPointer());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::getNodesDataPointer", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::getNodesDataPointer", e.what());
+      return 0;
+    }
+  }
+
+  //! get data pointer of tris
+  std::string getTrisDataPointer();
+  static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::getTrisDataPointer", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getTrisDataPointer());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::getTrisDataPointer", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::getTrisDataPointer", e.what());
+      return 0;
+    }
+  }
+
+  // ops
+  Mesh &operator=(const Mesh &o);
+
+  // accessors
+  inline int numTris() const
+  {
+    return mTris.size();
+  }
+  inline int numNodes() const
+  {
+    return mNodes.size();
+  }
+  inline int numTriChannels() const
+  {
+    return mTriChannels.size();
+  }
+  inline int numNodeChannels() const
+  {
+    return mNodeChannels.size();
+  }
+
+  //! return size of container
+  //! note , python binding disabled for now! cannot yet deal with long-long types
+  inline IndexInt size() const
+  {
+    return mNodes.size();
+  }
+  //! slow virtual function of base class, also returns size
+  virtual IndexInt getSizeSlow() const
+  {
+    return size();
+  }
+
+  inline Triangle &tris(int i)
+  {
+    return mTris[i];
+  }
+  inline Node &nodes(int i)
+  {
+    return mNodes[i];
+  }
+  inline Corner &corners(int tri, int c)
+  {
+    return mCorners[tri * 3 + c];
+  }
+  inline Corner &corners(int c)
+  {
+    return mCorners[c];
+  }
+  inline NodeChannel *nodeChannel(int i)
+  {
+    return mNodeChannels[i];
+  }
+  inline TriChannel *triChannel(int i)
+  {
+    return mTriChannels[i];
+  }
+
+  // allocate memory (eg upon load)
+  void resizeTris(int numTris);
+  void resizeNodes(int numNodes);
+
+  inline bool isNodeFixed(int n)
+  {
+    return mNodes[n].flags & NfFixed;
+  }
+  inline bool isTriangleFixed(int t)
+  {
+    return (mNodes[mTris[t].c[0]].flags & NfFixed) || (mNodes[mTris[t].c[1]].flags & NfFixed) ||
+           (mNodes[mTris[t].c[2]].flags & NfFixed);
+  }
+
+  inline const Vec3 getNode(int tri, int c) const
+  {
+    return mNodes[mTris[tri].c[c]].pos;
+  }
+  inline Vec3 &getNode(int tri, int c)
+  {
+    return mNodes[mTris[tri].c[c]].pos;
+  }
+  inline const Vec3 getEdge(int tri, int e) const
+  {
+    return getNode(tri, (e + 1) % 3) - getNode(tri, e);
+  }
+  inline OneRing &get1Ring(int node)
+  {
+    return m1RingLookup[node];
+  }
+  inline Real getFaceArea(int t) const
+  {
+    Vec3 c0 = mNodes[mTris[t].c[0]].pos;
+    return 0.5 * norm(cross(mNodes[mTris[t].c[1]].pos - c0, mNodes[mTris[t].c[2]].pos - c0));
+  }
+  inline Vec3 getFaceNormal(int t)
+  {
+    Vec3 c0 = mNodes[mTris[t].c[0]].pos;
+    return getNormalized(cross(mNodes[mTris[t].c[1]].pos - c0, mNodes[mTris[t].c[2]].pos - c0));
+  }
+  inline Vec3 getFaceCenter(int t) const
+  {
+    return (mNodes[mTris[t].c[0]].pos + mNodes[mTris[t].c[1]].pos + mNodes[mTris[t].c[2]].pos) /
+           3.0;
+  }
+  inline std::vector<Node> &getNodeData()
+  {
+    return mNodes;
+  }
+
+  void mergeNode(int node, int delnode);
+  int addNode(Node a);
+  int addTri(Triangle a);
+  void addCorner(Corner a);
+  void removeTri(int tri);
+  void removeTriFromLookup(int tri);
+  void removeNodes(const std::vector<int> &deletedNodes);
+  void rebuildCorners(int from = 0, int to = -1);
+  void rebuildLookup(int from = 0, int to = -1);
+  void rebuildQuickCheck();
+  void fastNodeLookupRebuild(int corner);
+  void sanityCheck(bool strict = true,
+                   std::vector<int> *deletedNodes = 0,
+                   std::map<int, bool> *taintedTris = 0);
+
+  void addTriChannel(TriChannel *c)
+  {
+    mTriChannels.push_back(c);
+    rebuildChannels();
+  }
+  void addNodeChannel(NodeChannel *c)
+  {
+    mNodeChannels.push_back(c);
+    rebuildChannels();
+  }
+
+  //! mesh data functions
+
+  //! create a mesh data object
+  PbClass *create(PbType type, PbTypeVec T = PbTypeVec(), const std::string &name = "");
+  static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Mesh::create", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        PbType type = _args.get<PbType>("type", 0, &_lock);
+        PbTypeVec T = _args.getOpt<PbTypeVec>("T", 1, PbTypeVec(), &_lock);
+        const std::string &name = _args.getOpt<std::string>("name", 2, "", &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->create(type, T, name));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Mesh::create", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Mesh::create", e.what());
+      return 0;
+    }
+  }
+
+  //! add a mesh data field, set its parent mesh pointer
+  void registerMdata(MeshDataBase *mdata);
+  void registerMdataReal(MeshDataImpl<Real> *mdata);
+  void registerMdataVec3(MeshDataImpl<Vec3> *mdata);
+  void registerMdataInt(MeshDataImpl<int> *mdata);
+  //! remove a mesh data entry
+  void deregister(MeshDataBase *mdata);
+  //! add one zero entry to all data fields
+  void addAllMdata();
+  // note - deletion of mdata is handled in compress function
+
+  //! how many are there?
+  IndexInt getNumMdata() const
+  {
+    return mMeshData.size();
+  }
+  //! access one of the fields
+  MeshDataBase *getMdata(int i)
+  {
+    return mMeshData[i];
+  }
+
+  //! update data fields
+  void updateDataFields();
+
+ protected:
+  void rebuildChannels();
+
+  std::vector<Node> mNodes;
+  std::vector<Triangle> mTris;
+  std::vector<Corner> mCorners;
+  std::vector<NodeChannel *> mNodeChannels;
+  std::vector<TriChannel *> mTriChannels;
+  std::vector<OneRing> m1RingLookup;
+
+  //! store mesh data , each pointer has its own storage vector of a certain type (int, real, vec3)
+  std::vector<MeshDataBase *> mMeshData;
+  //! lists of different types, for fast operations w/o virtual function calls
+  std::vector<MeshDataImpl<Real> *> mMdataReal;
+  std::vector<MeshDataImpl<Vec3> *> mMdataVec3;
+  std::vector<MeshDataImpl<int> *>
+      mMdataInt;  //! indicate that mdata of this mesh is copied, and needs to be freed
+  bool mFreeMdata;
+ public:
+  PbArgs _args;
+}
+#define _C_Mesh
+;
+
+//******************************************************************************
+
+//! abstract interface for mesh data
+class MeshDataBase : public PbClass {
+ public:
+  MeshDataBase(FluidSolver *parent);
+  static int _W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "MeshDataBase::MeshDataBase", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new MeshDataBase(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "MeshDataBase::MeshDataBase", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataBase::MeshDataBase", e.what());
+      return -1;
+    }
+  }
+
+  virtual ~MeshDataBase();
+
+  //! data type IDs, in line with those for grids
+  enum MdataType { TypeNone = 0, TypeReal = 1, TypeInt = 2, TypeVec3 = 4 };
+
+  //! interface functions, using assert instead of pure virtual for python compatibility
+  virtual IndexInt getSizeSlow() const
+  {
+    assertMsg(false, "Dont use, override...");
+    return 0;
+  }
+  virtual void addEntry()
+  {
+    assertMsg(false, "Dont use, override...");
+    return;
+  }
+  virtual MeshDataBase *clone()
+  {
+    assertMsg(false, "Dont use, override...");
+    return NULL;
+  }
+  virtual MdataType getType() const
+  {
+    assertMsg(false, "Dont use, override...");
+    return TypeNone;
+  }
+  virtual void resize(IndexInt size)
+  {
+    assertMsg(false, "Dont use, override...");
+    return;
+  }
+  virtual void copyValueSlow(IndexInt from, IndexInt to)
+  {
+    assertMsg(false, "Dont use, override...");
+    return;
+  }
+
+  //! set base pointer
+  void setMesh(Mesh *set)
+  {
+    mMesh = set;
+  }
+
+  //! debugging
+  inline void checkNodeIndex(IndexInt idx) const;
+
+ protected:
+  Mesh *mMesh;
+ public:
+  PbArgs _args;
+}
+#define _C_MeshDataBase
+;
+
+//! abstract interface for mesh data
+
+template<class T> class MeshDataImpl : public MeshDataBase {
+ public:
+  MeshDataImpl(FluidSolver *parent);
+  static int _W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "MeshDataImpl::MeshDataImpl", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new MeshDataImpl(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "MeshDataImpl::MeshDataImpl", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::MeshDataImpl", e.what());
+      return -1;
+    }
+  }
+
+  MeshDataImpl(FluidSolver *parent, MeshDataImpl<T> *other);
+  virtual ~MeshDataImpl();
+
+  //! access data
+  inline T &get(IndexInt idx)
+  {
+    DEBUG_ONLY(checkNodeIndex(idx));
+    return mData[idx];
+  }
+  inline const T &get(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkNodeIndex(idx));
+    return mData[idx];
+  }
+  inline T &operator[](IndexInt idx)
+  {
+    DEBUG_ONLY(checkNodeIndex(idx));
+    return mData[idx];
+  }
+  inline const T &operator[](IndexInt idx) const
+  {
+    DEBUG_ONLY(checkNodeIndex(idx));
+    return mData[idx];
+  }
+
+  //! set all values to 0, note - different from meshSystem::clear! doesnt modify size of array
+  //! (has to stay in sync with parent system)
+  void clear();
+  static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clear();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::clear", e.what());
+      return 0;
+    }
+  }
+
+  //! set grid from which to get data...
+  void setSource(Grid<T> *grid, bool isMAC = false);
+  static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setSource", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock);
+        bool isMAC = _args.getOpt<bool>("isMAC", 1, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setSource(grid, isMAC);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setSource", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::setSource", e.what());
+      return 0;
+    }
+  }
+
+  //! mesh data base interface
+  virtual IndexInt getSizeSlow() const;
+  virtual void addEntry();
+  virtual MeshDataBase *clone();
+  virtual MdataType getType() const;
+  virtual void resize(IndexInt s);
+  virtual void copyValueSlow(IndexInt from, IndexInt to);
+
+  IndexInt size() const
+  {
+    return mData.size();
+  }
+
+  //! fast inlined functions for per mesh operations
+  inline void copyValue(IndexInt from, IndexInt to)
+  {
+    get(to) = get(from);
+  }
+  void initNewValue(IndexInt idx, Vec3 pos);
+
+  //! python interface (similar to grid data)
+  void setConst(T s);
+  static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::setConst", e.what());
+      return 0;
+    }
+  }
+
+  void setConstRange(T s, const int begin, const int end);
+  static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstRange", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        const int begin = _args.get<int>("begin", 1, &_lock);
+        const int end = _args.get<int>("end", 2, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConstRange(s, begin, end);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setConstRange", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::setConstRange", e.what());
+      return 0;
+    }
+  }
+
+  MeshDataImpl<T> &copyFrom(const MeshDataImpl<T> &a);
+  static PyObject *_W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::copyFrom", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->copyFrom(a));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::copyFrom", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::copyFrom", e.what());
+      return 0;
+    }
+  }
+
+  void add(const MeshDataImpl<T> &a);
+  static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::add", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->add(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::add", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::add", e.what());
+      return 0;
+    }
+  }
+
+  void sub(const MeshDataImpl<T> &a);
+  static PyObject *_W_24(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sub", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->sub(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sub", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::sub", e.what());
+      return 0;
+    }
+  }
+
+  void addConst(T s);
+  static PyObject *_W_25(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::addConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::addConst", e.what());
+      return 0;
+    }
+  }
+
+  void addScaled(const MeshDataImpl<T> &a, const T &factor);
+  static PyObject *_W_26(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addScaled", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
+        const T &factor = *_args.getPtr<T>("factor", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addScaled(a, factor);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::addScaled", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::addScaled", e.what());
+      return 0;
+    }
+  }
+
+  void mult(const MeshDataImpl<T> &a);
+  static PyObject *_W_27(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::mult", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->mult(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::mult", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::mult", e.what());
+      return 0;
+    }
+  }
+
+  void multConst(T s);
+  static PyObject *_W_28(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::multConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->multConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::multConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::multConst", e.what());
+      return 0;
+    }
+  }
+
+  void safeDiv(const MeshDataImpl<T> &a);
+  static PyObject *_W_29(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::safeDiv", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->safeDiv(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::safeDiv", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::safeDiv", e.what());
+      return 0;
+    }
+  }
+
+  void clamp(Real min, Real max);
+  static PyObject *_W_30(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clamp", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real min = _args.get<Real>("min", 0, &_lock);
+        Real max = _args.get<Real>("max", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clamp(min, max);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clamp", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::clamp", e.what());
+      return 0;
+    }
+  }
+
+  void clampMin(Real vmin);
+  static PyObject *_W_31(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMin", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real vmin = _args.get<Real>("vmin", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clampMin(vmin);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clampMin", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::clampMin", e.what());
+      return 0;
+    }
+  }
+
+  void clampMax(Real vmax);
+  static PyObject *_W_32(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMax", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real vmax = _args.get<Real>("vmax", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clampMax(vmax);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clampMax", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::clampMax", e.what());
+      return 0;
+    }
+  }
+
+  Real getMaxAbs();
+  static PyObject *_W_33(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMaxAbs", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMaxAbs());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getMaxAbs", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::getMaxAbs", e.what());
+      return 0;
+    }
+  }
+
+  Real getMax();
+  static PyObject *_W_34(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMax", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMax());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getMax", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::getMax", e.what());
+      return 0;
+    }
+  }
+
+  Real getMin();
+  static PyObject *_W_35(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMin", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMin());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getMin", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::getMin", e.what());
+      return 0;
+    }
+  }
+
+  T sum(const MeshDataImpl<int> *t = NULL, const int itype = 0) const;
+  static PyObject *_W_36(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sum", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const MeshDataImpl<int> *t = _args.getPtrOpt<MeshDataImpl<int>>("t", 0, NULL, &_lock);
+        const int itype = _args.getOpt<int>("itype", 1, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->sum(t, itype));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sum", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::sum", e.what());
+      return 0;
+    }
+  }
+
+  Real sumSquare() const;
+  static PyObject *_W_37(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumSquare", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->sumSquare());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sumSquare", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::sumSquare", e.what());
+      return 0;
+    }
+  }
+
+  Real sumMagnitude() const;
+  static PyObject *_W_38(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumMagnitude", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->sumMagnitude());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sumMagnitude", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::sumMagnitude", e.what());
+      return 0;
+    }
+  }
+
+  //! special, set if int flag in t has "flag"
+  void setConstIntFlag(T s, const MeshDataImpl<int> &t, const int flag);
+  static PyObject *_W_39(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstIntFlag", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        T s = _args.get<T>("s", 0, &_lock);
+        const MeshDataImpl<int> &t = *_args.getPtr<MeshDataImpl<int>>("t", 1, &_lock);
+        const int flag = _args.get<int>("flag", 2, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConstIntFlag(s, t, flag);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setConstIntFlag", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::setConstIntFlag", e.what());
+      return 0;
+    }
+  }
+
+  void printMdata(IndexInt start = -1, IndexInt stop = -1, bool printIndex = false);
+  static PyObject *_W_40(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::printMdata", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
+        IndexInt stop = _args.getOpt<IndexInt>("stop", 1, -1, &_lock);
+        bool printIndex = _args.getOpt<bool>("printIndex", 2, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->printMdata(start, stop, printIndex);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::printMdata", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::printMdata", e.what());
+      return 0;
+    }
+  }
+
+  //! file io
+  void save(const std::string name);
+  static PyObject *_W_41(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::save", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->save(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::save", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::save", e.what());
+      return 0;
+    }
+  }
+
+  void load(const std::string name);
+  static PyObject *_W_42(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::load", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->load(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::load", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::load", e.what());
+      return 0;
+    }
+  }
+
+  //! get data pointer of mesh data
+  std::string getDataPointer();
+  static PyObject *_W_43(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getDataPointer", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getDataPointer());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getDataPointer", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MeshDataImpl::getDataPointer", e.what());
+      return 0;
+    }
+  }
+
+ protected:
+  //! data storage
+  std::vector<T> mData;
+
+  //! optionally , we might have an associated grid from which to grab new data
+  Grid<T> *mpGridSource;  //! unfortunately , we need to distinguish mac vs regular vec3
+  bool mGridSourceMAC;
+ public:
+  PbArgs _args;
+}
+#define _C_MeshDataImpl
+;
+
+// ***************************************************************************************************************
+// Implementation
+
+template<class T>
+void SimpleNodeChannel<T>::renumber(const std::vector<int> &newIndex, int newsize)
+{
+  for (size_t i = 0; i < newIndex.size(); i++) {
+    if (newIndex[i] != -1)
+      data[newIndex[i]] = data[newsize + i];
+  }
+  data.resize(newsize);
+}
+
+inline void MeshDataBase::checkNodeIndex(IndexInt idx) const
+{
+  IndexInt mySize = this->getSizeSlow();
+  if (idx < 0 || idx > mySize) {
+    errMsg("MeshData "
+           << " size " << mySize << " : index " << idx << " out of bound ");
+  }
+  if (mMesh && mMesh->getSizeSlow() != mySize) {
+    errMsg("MeshData "
+           << " size " << mySize << " does not match parent! (" << mMesh->getSizeSlow() << ") ");
+  }
+}
+
+template<class T> void MeshDataImpl<T>::clear()
+{
+  for (IndexInt i = 0; i < (IndexInt)mData.size(); ++i)
+    mData[i] = 0.;
+}
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/mesh.h.reg.cpp b/extern/mantaflow/preprocessed/mesh.h.reg.cpp
new file mode 100644
index 00000000000..b2ba3e22032
--- /dev/null
+++ b/extern/mantaflow/preprocessed/mesh.h.reg.cpp
@@ -0,0 +1,239 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "mesh.h"
+namespace Manta {
+#ifdef _C_Mesh
+static const Pb::Register _R_12("Mesh", "Mesh", "PbClass");
+template<> const char *Namify<Mesh>::S = "Mesh";
+static const Pb::Register _R_13("Mesh", "Mesh", Mesh::_W_0);
+static const Pb::Register _R_14("Mesh", "clear", Mesh::_W_1);
+static const Pb::Register _R_15("Mesh", "load", Mesh::_W_2);
+static const Pb::Register _R_16("Mesh", "fromShape", Mesh::_W_3);
+static const Pb::Register _R_17("Mesh", "save", Mesh::_W_4);
+static const Pb::Register _R_18("Mesh", "advectInGrid", Mesh::_W_5);
+static const Pb::Register _R_19("Mesh", "scale", Mesh::_W_6);
+static const Pb::Register _R_20("Mesh", "offset", Mesh::_W_7);
+static const Pb::Register _R_21("Mesh", "rotate", Mesh::_W_8);
+static const Pb::Register _R_22("Mesh", "computeVelocity", Mesh::_W_9);
+static const Pb::Register _R_23("Mesh", "computeLevelset", Mesh::_W_10);
+static const Pb::Register _R_24("Mesh", "getLevelset", Mesh::_W_11);
+static const Pb::Register _R_25("Mesh", "applyMeshToGrid", Mesh::_W_12);
+static const Pb::Register _R_26("Mesh", "getNodesDataPointer", Mesh::_W_13);
+static const Pb::Register _R_27("Mesh", "getTrisDataPointer", Mesh::_W_14);
+static const Pb::Register _R_28("Mesh", "create", Mesh::_W_15);
+#endif
+#ifdef _C_MeshDataBase
+static const Pb::Register _R_29("MeshDataBase", "MeshDataBase", "PbClass");
+template<> const char *Namify<MeshDataBase>::S = "MeshDataBase";
+static const Pb::Register _R_30("MeshDataBase", "MeshDataBase", MeshDataBase::_W_16);
+#endif
+#ifdef _C_MeshDataImpl
+static const Pb::Register _R_31("MeshDataImpl<int>", "MeshDataImpl<int>", "MeshDataBase");
+template<> const char *Namify<MeshDataImpl<int>>::S = "MeshDataImpl<int>";
+static const Pb::Register _R_32("MeshDataImpl<int>", "MeshDataImpl", MeshDataImpl<int>::_W_17);
+static const Pb::Register _R_33("MeshDataImpl<int>", "clear", MeshDataImpl<int>::_W_18);
+static const Pb::Register _R_34("MeshDataImpl<int>", "setSource", MeshDataImpl<int>::_W_19);
+static const Pb::Register _R_35("MeshDataImpl<int>", "setConst", MeshDataImpl<int>::_W_20);
+static const Pb::Register _R_36("MeshDataImpl<int>", "setConstRange", MeshDataImpl<int>::_W_21);
+static const Pb::Register _R_37("MeshDataImpl<int>", "copyFrom", MeshDataImpl<int>::_W_22);
+static const Pb::Register _R_38("MeshDataImpl<int>", "add", MeshDataImpl<int>::_W_23);
+static const Pb::Register _R_39("MeshDataImpl<int>", "sub", MeshDataImpl<int>::_W_24);
+static const Pb::Register _R_40("MeshDataImpl<int>", "addConst", MeshDataImpl<int>::_W_25);
+static const Pb::Register _R_41("MeshDataImpl<int>", "addScaled", MeshDataImpl<int>::_W_26);
+static const Pb::Register _R_42("MeshDataImpl<int>", "mult", MeshDataImpl<int>::_W_27);
+static const Pb::Register _R_43("MeshDataImpl<int>", "multConst", MeshDataImpl<int>::_W_28);
+static const Pb::Register _R_44("MeshDataImpl<int>", "safeDiv", MeshDataImpl<int>::_W_29);
+static const Pb::Register _R_45("MeshDataImpl<int>", "clamp", MeshDataImpl<int>::_W_30);
+static const Pb::Register _R_46("MeshDataImpl<int>", "clampMin", MeshDataImpl<int>::_W_31);
+static const Pb::Register _R_47("MeshDataImpl<int>", "clampMax", MeshDataImpl<int>::_W_32);
+static const Pb::Register _R_48("MeshDataImpl<int>", "getMaxAbs", MeshDataImpl<int>::_W_33);
+static const Pb::Register _R_49("MeshDataImpl<int>", "getMax", MeshDataImpl<int>::_W_34);
+static const Pb::Register _R_50("MeshDataImpl<int>", "getMin", MeshDataImpl<int>::_W_35);
+static const Pb::Register _R_51("MeshDataImpl<int>", "sum", MeshDataImpl<int>::_W_36);
+static const Pb::Register _R_52("MeshDataImpl<int>", "sumSquare", MeshDataImpl<int>::_W_37);
+static const Pb::Register _R_53("MeshDataImpl<int>", "sumMagnitude", MeshDataImpl<int>::_W_38);
+static const Pb::Register _R_54("MeshDataImpl<int>", "setConstIntFlag", MeshDataImpl<int>::_W_39);
+static const Pb::Register _R_55("MeshDataImpl<int>", "printMdata", MeshDataImpl<int>::_W_40);
+static const Pb::Register _R_56("MeshDataImpl<int>", "save", MeshDataImpl<int>::_W_41);
+static const Pb::Register _R_57("MeshDataImpl<int>", "load", MeshDataImpl<int>::_W_42);
+static const Pb::Register _R_58("MeshDataImpl<int>", "getDataPointer", MeshDataImpl<int>::_W_43);
+static const Pb::Register _R_59("MeshDataImpl<Real>", "MeshDataImpl<Real>", "MeshDataBase");
+template<> const char *Namify<MeshDataImpl<Real>>::S = "MeshDataImpl<Real>";
+static const Pb::Register _R_60("MeshDataImpl<Real>", "MeshDataImpl", MeshDataImpl<Real>::_W_17);
+static const Pb::Register _R_61("MeshDataImpl<Real>", "clear", MeshDataImpl<Real>::_W_18);
+static const Pb::Register _R_62("MeshDataImpl<Real>", "setSource", MeshDataImpl<Real>::_W_19);
+static const Pb::Register _R_63("MeshDataImpl<Real>", "setConst", MeshDataImpl<Real>::_W_20);
+static const Pb::Register _R_64("MeshDataImpl<Real>", "setConstRange", MeshDataImpl<Real>::_W_21);
+static const Pb::Register _R_65("MeshDataImpl<Real>", "copyFrom", MeshDataImpl<Real>::_W_22);
+static const Pb::Register _R_66("MeshDataImpl<Real>", "add", MeshDataImpl<Real>::_W_23);
+static const Pb::Register _R_67("MeshDataImpl<Real>", "sub", MeshDataImpl<Real>::_W_24);
+static const Pb::Register _R_68("MeshDataImpl<Real>", "addConst", MeshDataImpl<Real>::_W_25);
+static const Pb::Register _R_69("MeshDataImpl<Real>", "addScaled", MeshDataImpl<Real>::_W_26);
+static const Pb::Register _R_70("MeshDataImpl<Real>", "mult", MeshDataImpl<Real>::_W_27);
+static const Pb::Register _R_71("MeshDataImpl<Real>", "multConst", MeshDataImpl<Real>::_W_28);
+static const Pb::Register _R_72("MeshDataImpl<Real>", "safeDiv", MeshDataImpl<Real>::_W_29);
+static const Pb::Register _R_73("MeshDataImpl<Real>", "clamp", MeshDataImpl<Real>::_W_30);
+static const Pb::Register _R_74("MeshDataImpl<Real>", "clampMin", MeshDataImpl<Real>::_W_31);
+static const Pb::Register _R_75("MeshDataImpl<Real>", "clampMax", MeshDataImpl<Real>::_W_32);
+static const Pb::Register _R_76("MeshDataImpl<Real>", "getMaxAbs", MeshDataImpl<Real>::_W_33);
+static const Pb::Register _R_77("MeshDataImpl<Real>", "getMax", MeshDataImpl<Real>::_W_34);
+static const Pb::Register _R_78("MeshDataImpl<Real>", "getMin", MeshDataImpl<Real>::_W_35);
+static const Pb::Register _R_79("MeshDataImpl<Real>", "sum", MeshDataImpl<Real>::_W_36);
+static const Pb::Register _R_80("MeshDataImpl<Real>", "sumSquare", MeshDataImpl<Real>::_W_37);
+static const Pb::Register _R_81("MeshDataImpl<Real>", "sumMagnitude", MeshDataImpl<Real>::_W_38);
+static const Pb::Register _R_82("MeshDataImpl<Real>",
+                                "setConstIntFlag",
+                                MeshDataImpl<Real>::_W_39);
+static const Pb::Register _R_83("MeshDataImpl<Real>", "printMdata", MeshDataImpl<Real>::_W_40);
+static const Pb::Register _R_84("MeshDataImpl<Real>", "save", MeshDataImpl<Real>::_W_41);
+static const Pb::Register _R_85("MeshDataImpl<Real>", "load", MeshDataImpl<Real>::_W_42);
+static const Pb::Register _R_86("MeshDataImpl<Real>", "getDataPointer", MeshDataImpl<Real>::_W_43);
+static const Pb::Register _R_87("MeshDataImpl<Vec3>", "MeshDataImpl<Vec3>", "MeshDataBase");
+template<> const char *Namify<MeshDataImpl<Vec3>>::S = "MeshDataImpl<Vec3>";
+static const Pb::Register _R_88("MeshDataImpl<Vec3>", "MeshDataImpl", MeshDataImpl<Vec3>::_W_17);
+static const Pb::Register _R_89("MeshDataImpl<Vec3>", "clear", MeshDataImpl<Vec3>::_W_18);
+static const Pb::Register _R_90("MeshDataImpl<Vec3>", "setSource", MeshDataImpl<Vec3>::_W_19);
+static const Pb::Register _R_91("MeshDataImpl<Vec3>", "setConst", MeshDataImpl<Vec3>::_W_20);
+static const Pb::Register _R_92("MeshDataImpl<Vec3>", "setConstRange", MeshDataImpl<Vec3>::_W_21);
+static const Pb::Register _R_93("MeshDataImpl<Vec3>", "copyFrom", MeshDataImpl<Vec3>::_W_22);
+static const Pb::Register _R_94("MeshDataImpl<Vec3>", "add", MeshDataImpl<Vec3>::_W_23);
+static const Pb::Register _R_95("MeshDataImpl<Vec3>", "sub", MeshDataImpl<Vec3>::_W_24);
+static const Pb::Register _R_96("MeshDataImpl<Vec3>", "addConst", MeshDataImpl<Vec3>::_W_25);
+static const Pb::Register _R_97("MeshDataImpl<Vec3>", "addScaled", MeshDataImpl<Vec3>::_W_26);
+static const Pb::Register _R_98("MeshDataImpl<Vec3>", "mult", MeshDataImpl<Vec3>::_W_27);
+static const Pb::Register _R_99("MeshDataImpl<Vec3>", "multConst", MeshDataImpl<Vec3>::_W_28);
+static const Pb::Register _R_100("MeshDataImpl<Vec3>", "safeDiv", MeshDataImpl<Vec3>::_W_29);
+static const Pb::Register _R_101("MeshDataImpl<Vec3>", "clamp", MeshDataImpl<Vec3>::_W_30);
+static const Pb::Register _R_102("MeshDataImpl<Vec3>", "clampMin", MeshDataImpl<Vec3>::_W_31);
+static const Pb::Register _R_103("MeshDataImpl<Vec3>", "clampMax", MeshDataImpl<Vec3>::_W_32);
+static const Pb::Register _R_104("MeshDataImpl<Vec3>", "getMaxAbs", MeshDataImpl<Vec3>::_W_33);
+static const Pb::Register _R_105("MeshDataImpl<Vec3>", "getMax", MeshDataImpl<Vec3>::_W_34);
+static const Pb::Register _R_106("MeshDataImpl<Vec3>", "getMin", MeshDataImpl<Vec3>::_W_35);
+static const Pb::Register _R_107("MeshDataImpl<Vec3>", "sum", MeshDataImpl<Vec3>::_W_36);
+static const Pb::Register _R_108("MeshDataImpl<Vec3>", "sumSquare", MeshDataImpl<Vec3>::_W_37);
+static const Pb::Register _R_109("MeshDataImpl<Vec3>", "sumMagnitude", MeshDataImpl<Vec3>::_W_38);
+static const Pb::Register _R_110("MeshDataImpl<Vec3>",
+                                 "setConstIntFlag",
+                                 MeshDataImpl<Vec3>::_W_39);
+static const Pb::Register _R_111("MeshDataImpl<Vec3>", "printMdata", MeshDataImpl<Vec3>::_W_40);
+static const Pb::Register _R_112("MeshDataImpl<Vec3>", "save", MeshDataImpl<Vec3>::_W_41);
+static const Pb::Register _R_113("MeshDataImpl<Vec3>", "load", MeshDataImpl<Vec3>::_W_42);
+static const Pb::Register _R_114("MeshDataImpl<Vec3>",
+                                 "getDataPointer",
+                                 MeshDataImpl<Vec3>::_W_43);
+#endif
+static const Pb::Register _R_9("MeshDataImpl<int>", "MdataInt", "");
+static const Pb::Register _R_10("MeshDataImpl<Real>", "MdataReal", "");
+static const Pb::Register _R_11("MeshDataImpl<Vec3>", "MdataVec3", "");
+extern "C" {
+void PbRegister_file_9()
+{
+  KEEP_UNUSED(_R_12);
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+  KEEP_UNUSED(_R_23);
+  KEEP_UNUSED(_R_24);
+  KEEP_UNUSED(_R_25);
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+  KEEP_UNUSED(_R_33);
+  KEEP_UNUSED(_R_34);
+  KEEP_UNUSED(_R_35);
+  KEEP_UNUSED(_R_36);
+  KEEP_UNUSED(_R_37);
+  KEEP_UNUSED(_R_38);
+  KEEP_UNUSED(_R_39);
+  KEEP_UNUSED(_R_40);
+  KEEP_UNUSED(_R_41);
+  KEEP_UNUSED(_R_42);
+  KEEP_UNUSED(_R_43);
+  KEEP_UNUSED(_R_44);
+  KEEP_UNUSED(_R_45);
+  KEEP_UNUSED(_R_46);
+  KEEP_UNUSED(_R_47);
+  KEEP_UNUSED(_R_48);
+  KEEP_UNUSED(_R_49);
+  KEEP_UNUSED(_R_50);
+  KEEP_UNUSED(_R_51);
+  KEEP_UNUSED(_R_52);
+  KEEP_UNUSED(_R_53);
+  KEEP_UNUSED(_R_54);
+  KEEP_UNUSED(_R_55);
+  KEEP_UNUSED(_R_56);
+  KEEP_UNUSED(_R_57);
+  KEEP_UNUSED(_R_58);
+  KEEP_UNUSED(_R_59);
+  KEEP_UNUSED(_R_60);
+  KEEP_UNUSED(_R_61);
+  KEEP_UNUSED(_R_62);
+  KEEP_UNUSED(_R_63);
+  KEEP_UNUSED(_R_64);
+  KEEP_UNUSED(_R_65);
+  KEEP_UNUSED(_R_66);
+  KEEP_UNUSED(_R_67);
+  KEEP_UNUSED(_R_68);
+  KEEP_UNUSED(_R_69);
+  KEEP_UNUSED(_R_70);
+  KEEP_UNUSED(_R_71);
+  KEEP_UNUSED(_R_72);
+  KEEP_UNUSED(_R_73);
+  KEEP_UNUSED(_R_74);
+  KEEP_UNUSED(_R_75);
+  KEEP_UNUSED(_R_76);
+  KEEP_UNUSED(_R_77);
+  KEEP_UNUSED(_R_78);
+  KEEP_UNUSED(_R_79);
+  KEEP_UNUSED(_R_80);
+  KEEP_UNUSED(_R_81);
+  KEEP_UNUSED(_R_82);
+  KEEP_UNUSED(_R_83);
+  KEEP_UNUSED(_R_84);
+  KEEP_UNUSED(_R_85);
+  KEEP_UNUSED(_R_86);
+  KEEP_UNUSED(_R_87);
+  KEEP_UNUSED(_R_88);
+  KEEP_UNUSED(_R_89);
+  KEEP_UNUSED(_R_90);
+  KEEP_UNUSED(_R_91);
+  KEEP_UNUSED(_R_92);
+  KEEP_UNUSED(_R_93);
+  KEEP_UNUSED(_R_94);
+  KEEP_UNUSED(_R_95);
+  KEEP_UNUSED(_R_96);
+  KEEP_UNUSED(_R_97);
+  KEEP_UNUSED(_R_98);
+  KEEP_UNUSED(_R_99);
+  KEEP_UNUSED(_R_100);
+  KEEP_UNUSED(_R_101);
+  KEEP_UNUSED(_R_102);
+  KEEP_UNUSED(_R_103);
+  KEEP_UNUSED(_R_104);
+  KEEP_UNUSED(_R_105);
+  KEEP_UNUSED(_R_106);
+  KEEP_UNUSED(_R_107);
+  KEEP_UNUSED(_R_108);
+  KEEP_UNUSED(_R_109);
+  KEEP_UNUSED(_R_110);
+  KEEP_UNUSED(_R_111);
+  KEEP_UNUSED(_R_112);
+  KEEP_UNUSED(_R_113);
+  KEEP_UNUSED(_R_114);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/movingobs.cpp b/extern/mantaflow/preprocessed/movingobs.cpp
new file mode 100644
index 00000000000..a6ff01fd1e0
--- /dev/null
+++ b/extern/mantaflow/preprocessed/movingobs.cpp
@@ -0,0 +1,112 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Moving obstacles
+ *
+ ******************************************************************************/
+
+#include "movingobs.h"
+#include "commonkernels.h"
+#include "randomstream.h"
+
+using namespace std;
+namespace Manta {
+
+//******************************************************************************
+// MovingObs class members
+
+int MovingObstacle::sIDcnt = 10;
+
+MovingObstacle::MovingObstacle(FluidSolver *parent, int emptyType)
+    : PbClass(parent), mEmptyType(emptyType)
+{
+  mID = 1 << sIDcnt;
+  sIDcnt++;
+  if (sIDcnt > 15)
+    errMsg(
+        "currently only 5 separate moving obstacles supported (are you generating them in a "
+        "loop?)");
+}
+
+void MovingObstacle::add(Shape *shape)
+{
+  mShapes.push_back(shape);
+}
+
+void MovingObstacle::projectOutside(FlagGrid &flags, BasicParticleSystem &parts)
+{
+  LevelsetGrid levelset(mParent, false);
+  Grid<Vec3> gradient(mParent);
+
+  // rebuild obstacle levelset
+  FOR_IDX(levelset)
+  {
+    levelset[idx] = flags.isObstacle(idx) ? -0.5 : 0.5;
+  }
+  levelset.reinitMarching(flags, 6.0, 0, true, false, FlagGrid::TypeReserved);
+
+  // build levelset gradient
+  GradientOp(gradient, levelset);
+
+  parts.projectOutside(gradient);
+}
+
+void MovingObstacle::moveLinear(
+    Real t, Real t0, Real t1, Vec3 p0, Vec3 p1, FlagGrid &flags, MACGrid &vel, bool smooth)
+{
+  Real alpha = (t - t0) / (t1 - t0);
+  if (alpha >= 0 && alpha <= 1) {
+    Vec3 v = (p1 - p0) / ((t1 - t0) * getParent()->getDt());
+
+    // ease in and out
+    if (smooth) {
+      v *= 6.0f * (alpha - square(alpha));
+      alpha = square(alpha) * (3.0f - 2.0f * alpha);
+    }
+
+    Vec3 pos = alpha * p1 + (1.0f - alpha) * p0;
+    for (size_t i = 0; i < mShapes.size(); i++)
+      mShapes[i]->setCenter(pos);
+
+    // reset flags
+    FOR_IDX(flags)
+    {
+      if ((flags[idx] & mID) != 0)
+        flags[idx] = mEmptyType;
+    }
+    // apply new flags
+    for (size_t i = 0; i < mShapes.size(); i++) {
+#if NOPYTHON != 1
+      mShapes[i]->_args.clear();
+      mShapes[i]->_args.add("value", FlagGrid::TypeObstacle | mID);
+      mShapes[i]->applyToGrid(&flags, 0);
+#else
+      errMsg("Not yet supported...");
+#endif
+    }
+    // apply velocities
+    FOR_IJK_BND(flags, 1)
+    {
+      bool cur = (flags(i, j, k) & mID) != 0;
+      if (cur || (flags(i - 1, j, k) & mID) != 0)
+        vel(i, j, k).x = v.x;
+      if (cur || (flags(i, j - 1, k) & mID) != 0)
+        vel(i, j, k).y = v.y;
+      if (cur || (flags(i, j, k - 1) & mID) != 0)
+        vel(i, j, k).z = v.z;
+    }
+  }
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/movingobs.h b/extern/mantaflow/preprocessed/movingobs.h
new file mode 100644
index 00000000000..71cc441f1d0
--- /dev/null
+++ b/extern/mantaflow/preprocessed/movingobs.h
@@ -0,0 +1,164 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * moving obstacles
+ *
+ ******************************************************************************/
+
+#ifndef _MOVINGOBS_H
+#define _MOVINGOBS_H
+
+#include "shapes.h"
+#include "particle.h"
+
+namespace Manta {
+
+//! Moving obstacle composed of basic shapes
+class MovingObstacle : public PbClass {
+ public:
+  MovingObstacle(FluidSolver *parent, int emptyType = FlagGrid::TypeEmpty);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "MovingObstacle::MovingObstacle", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        int emptyType = _args.getOpt<int>("emptyType", 1, FlagGrid::TypeEmpty, &_lock);
+        obj = new MovingObstacle(parent, emptyType);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "MovingObstacle::MovingObstacle", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("MovingObstacle::MovingObstacle", e.what());
+      return -1;
+    }
+  }
+
+  void add(Shape *shape);
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MovingObstacle::add", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Shape *shape = _args.getPtr<Shape>("shape", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->add(shape);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MovingObstacle::add", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MovingObstacle::add", e.what());
+      return 0;
+    }
+  }
+
+  //! If t in [t0,t1], apply linear motion path from p0 to p1
+  void moveLinear(Real t,
+                  Real t0,
+                  Real t1,
+                  Vec3 p0,
+                  Vec3 p1,
+                  FlagGrid &flags,
+                  MACGrid &vel,
+                  bool smooth = true);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MovingObstacle::moveLinear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real t = _args.get<Real>("t", 0, &_lock);
+        Real t0 = _args.get<Real>("t0", 1, &_lock);
+        Real t1 = _args.get<Real>("t1", 2, &_lock);
+        Vec3 p0 = _args.get<Vec3>("p0", 3, &_lock);
+        Vec3 p1 = _args.get<Vec3>("p1", 4, &_lock);
+        FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 5, &_lock);
+        MACGrid &vel = *_args.getPtr<MACGrid>("vel", 6, &_lock);
+        bool smooth = _args.getOpt<bool>("smooth", 7, true, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->moveLinear(t, t0, t1, p0, p1, flags, vel, smooth);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MovingObstacle::moveLinear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MovingObstacle::moveLinear", e.what());
+      return 0;
+    }
+  }
+
+  //! Compute levelset, and project FLIP particles outside obstacles
+  void projectOutside(FlagGrid &flags, BasicParticleSystem &flip);
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "MovingObstacle::projectOutside", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        BasicParticleSystem &flip = *_args.getPtr<BasicParticleSystem>("flip", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->projectOutside(flags, flip);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "MovingObstacle::projectOutside", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("MovingObstacle::projectOutside", e.what());
+      return 0;
+    }
+  }
+
+ protected:
+  std::vector<Shape *> mShapes;
+  int mEmptyType;
+  int mID;
+  static int sIDcnt;
+ public:
+  PbArgs _args;
+}
+#define _C_MovingObstacle
+;
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/movingobs.h.reg.cpp b/extern/mantaflow/preprocessed/movingobs.h.reg.cpp
new file mode 100644
index 00000000000..b5a01a83c3b
--- /dev/null
+++ b/extern/mantaflow/preprocessed/movingobs.h.reg.cpp
@@ -0,0 +1,26 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "movingobs.h"
+namespace Manta {
+#ifdef _C_MovingObstacle
+static const Pb::Register _R_17("MovingObstacle", "MovingObstacle", "PbClass");
+template<> const char *Namify<MovingObstacle>::S = "MovingObstacle";
+static const Pb::Register _R_18("MovingObstacle", "MovingObstacle", MovingObstacle::_W_0);
+static const Pb::Register _R_19("MovingObstacle", "add", MovingObstacle::_W_1);
+static const Pb::Register _R_20("MovingObstacle", "moveLinear", MovingObstacle::_W_2);
+static const Pb::Register _R_21("MovingObstacle", "projectOutside", MovingObstacle::_W_3);
+#endif
+extern "C" {
+void PbRegister_file_17()
+{
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/multigrid.cpp b/extern/mantaflow/preprocessed/multigrid.cpp
new file mode 100644
index 00000000000..9e35c6f9368
--- /dev/null
+++ b/extern/mantaflow/preprocessed/multigrid.cpp
@@ -0,0 +1,1857 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Multigrid solver
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Copyright 2016, by Florian Ferstl (florian.ferstl.ff@gmail.com)
+ *
+ * This is an implementation of the solver developed by Dick et al. [1]
+ * without topology awareness (= vertex duplication on coarser levels). This
+ * simplification allows us to use regular grids for all levels of the multigrid
+ * hierarchy and works well for moderately complex domains.
+ *
+ * [1] Solving the Fluid Pressure Poisson Equation Using Multigrid-Evaluation
+ *     and Improvements, C. Dick, M. Rogowsky, R. Westermann, IEEE TVCG 2015
+ *
+ ******************************************************************************/
+
+#include "multigrid.h"
+
+#define FOR_LVL(IDX, LVL) for (int IDX = 0; IDX < mb[LVL].size(); IDX++)
+
+#define FOR_VEC_MINMAX(VEC, MIN, MAX) \
+  Vec3i VEC; \
+  const Vec3i VEC##__min = (MIN), VEC##__max = (MAX); \
+  for (VEC.z = VEC##__min.z; VEC.z <= VEC##__max.z; VEC.z++) \
+    for (VEC.y = VEC##__min.y; VEC.y <= VEC##__max.y; VEC.y++) \
+      for (VEC.x = VEC##__min.x; VEC.x <= VEC##__max.x; VEC.x++)
+
+#define FOR_VECLIN_MINMAX(VEC, LIN, MIN, MAX) \
+  Vec3i VEC; \
+  int LIN = 0; \
+  const Vec3i VEC##__min = (MIN), VEC##__max = (MAX); \
+  for (VEC.z = VEC##__min.z; VEC.z <= VEC##__max.z; VEC.z++) \
+    for (VEC.y = VEC##__min.y; VEC.y <= VEC##__max.y; VEC.y++) \
+      for (VEC.x = VEC##__min.x; VEC.x <= VEC##__max.x; VEC.x++, LIN++)
+
+#define MG_TIMINGS(X)
+//#define MG_TIMINGS(X) X
+
+using namespace std;
+namespace Manta {
+
+// Helper class for calling mantaflow kernels with a specific number of threads
+class ThreadSize {
+  IndexInt s;
+
+ public:
+  ThreadSize(IndexInt _s)
+  {
+    s = _s;
+  }
+  IndexInt size()
+  {
+    return s;
+  }
+};
+
+// ----------------------------------------------------------------------------
+// Efficient min heap for <ID, key> pairs with 0<=ID<N and 0<=key<K
+// (elements are stored in K buckets, where each bucket is a doubly linked list).
+// - if K<<N, all ops are O(1) on avg (worst case O(K)).
+// - memory usage O(K+N): (K+N) * 3 * sizeof(int).
+class NKMinHeap {
+ private:
+  struct Entry {
+    int key, prev, next;
+    Entry() : key(-1), prev(-1), next(-1)
+    {
+    }
+  };
+
+  int mN, mK, mSize, mMinKey;
+
+  // Double linked lists of IDs, one for each bucket/key.
+  // The first K entries are the buckets' head pointers,
+  // and the last N entries correspond to the IDs.
+  std::vector<Entry> mEntries;
+
+ public:
+  NKMinHeap(int N, int K) : mN(N), mK(K), mSize(0), mMinKey(-1), mEntries(N + K)
+  {
+  }
+
+  int size()
+  {
+    return mSize;
+  }
+  int getKey(int ID)
+  {
+    return mEntries[mK + ID].key;
+  }
+
+  // Insert, decrease or increase key (or delete by setting key to -1)
+  void setKey(int ID, int key);
+
+  // peek min key (returns ID/key pair)
+  std::pair<int, int> peekMin();
+
+  // pop min key (returns ID/key pair)
+  std::pair<int, int> popMin();
+
+  void print();  // for debugging
+};
+
+void NKMinHeap::setKey(int ID, int key)
+{
+  assertMsg(0 <= ID && ID < mN, "NKMinHeap::setKey: ID out of range");
+  assertMsg(-1 <= key && key < mK, "NKMinHeap::setKey: key out of range");
+
+  const int kid = mK + ID;
+
+  if (mEntries[kid].key == key)
+    return;  // nothing changes
+
+  // remove from old key-list if ID existed previously
+  if (mEntries[kid].key != -1) {
+    int pred = mEntries[kid].prev;
+    int succ = mEntries[kid].next;  // can be -1
+
+    mEntries[pred].next = succ;
+    if (succ != -1)
+      mEntries[succ].prev = pred;
+
+    // if removed key was minimum key, mMinKey may need to be updated
+    int removedKey = mEntries[kid].key;
+    if (removedKey == mMinKey) {
+      if (mSize == 1) {
+        mMinKey = -1;
+      }
+      else {
+        for (; mMinKey < mK; mMinKey++) {
+          if (mEntries[mMinKey].next != -1)
+            break;
+        }
+      }
+    }
+
+    mSize--;
+  }
+
+  // set new key of ID
+  mEntries[kid].key = key;
+
+  if (key == -1) {
+    // finished if key was set to -1
+    mEntries[kid].next = mEntries[kid].prev = -1;
+    return;
+  }
+
+  // add key
+  mSize++;
+  if (mMinKey == -1)
+    mMinKey = key;
+  else
+    mMinKey = std::min(mMinKey, key);
+
+  // insert into new key-list (headed by mEntries[key])
+  int tmp = mEntries[key].next;
+
+  mEntries[key].next = kid;
+  mEntries[kid].prev = key;
+
+  mEntries[kid].next = tmp;
+  if (tmp != -1)
+    mEntries[tmp].prev = kid;
+}
+
+std::pair<int, int> NKMinHeap::peekMin()
+{
+  if (mSize == 0)
+    return std::pair<int, int>(-1, -1);  // error
+
+  const int ID = mEntries[mMinKey].next - mK;
+  return std::pair<int, int>(ID, mMinKey);
+}
+
+std::pair<int, int> NKMinHeap::popMin()
+{
+  if (mSize == 0)
+    return std::pair<int, int>(-1, -1);  // error
+
+  const int kid = mEntries[mMinKey].next;
+  const int ID = kid - mK;
+  const int key = mMinKey;
+
+  // remove from key-list
+  int pred = mEntries[kid].prev;
+  int succ = mEntries[kid].next;  // can be -1
+
+  mEntries[pred].next = succ;
+  if (succ != -1)
+    mEntries[succ].prev = pred;
+
+  // remove entry
+  mEntries[kid] = Entry();
+  mSize--;
+
+  // update mMinKey
+  if (mSize == 0) {
+    mMinKey = -1;
+  }
+  else {
+    for (; mMinKey < mK; mMinKey++) {
+      if (mEntries[mMinKey].next != -1)
+        break;
+    }
+  }
+
+  // return result
+  return std::pair<int, int>(ID, key);
+}
+
+void NKMinHeap::print()
+{
+  std::cout << "Size: " << mSize << ", MinKey: " << mMinKey << std::endl;
+  for (int key = 0; key < mK; key++) {
+    if (mEntries[key].next != -1) {
+      std::cout << "Key " << key << ": ";
+      int kid = mEntries[key].next;
+      while (kid != -1) {
+        std::cout << kid - mK << " ";
+        kid = mEntries[kid].next;
+      }
+      std::cout << std::endl;
+    }
+  }
+  std::cout << std::endl;
+}
+
+// ----------------------------------------------------------------------------
+// GridMg methods
+//
+// Illustration of 27-point stencil indices
+// y     | z = -1    z = 0      z = 1
+// ^     | 6  7  8,  15 16 17,  24 25 26
+// |     | 3  4  5,  12 13 14,  21 22 23
+// o-> x | 0  1  2,   9 10 11,  18 19 20
+//
+// Symmetric storage with only 14 entries per vertex
+// y     | z = -1    z = 0      z = 1
+// ^     | -  -  -,   2  3  4,  11 12 13
+// |     | -  -  -,   -  0  1,   8  9 10
+// o-> x | -  -  -,   -  -  -,   5  6  7
+
+GridMg::GridMg(const Vec3i &gridSize)
+    : mNumPreSmooth(1),
+      mNumPostSmooth(1),
+      mCoarsestLevelAccuracy(Real(1E-8)),
+      mTrivialEquationScale(Real(1E-6)),
+      mIsASet(false),
+      mIsRhsSet(false)
+{
+  MG_TIMINGS(MuTime time;)
+
+  // 2D or 3D mode
+  mIs3D = (gridSize.z > 1);
+  mDim = mIs3D ? 3 : 2;
+  mStencilSize = mIs3D ? 14 : 5;  // A has a full 27-point stencil on levels > 0
+  mStencilSize0 = mIs3D ? 4 : 3;  // A has a 7-point stencil on level 0
+  mStencilMin = Vec3i(-1, -1, mIs3D ? -1 : 0);
+  mStencilMax = Vec3i(1, 1, mIs3D ? 1 : 0);
+
+  // Create level 0 (=original grid)
+  mSize.push_back(gridSize);
+  mPitch.push_back(Vec3i(1, mSize.back().x, mSize.back().x * mSize.back().y));
+  int n = mSize.back().x * mSize.back().y * mSize.back().z;
+
+  mA.push_back(std::vector<Real>(n * mStencilSize0));
+  mx.push_back(std::vector<Real>(n));
+  mb.push_back(std::vector<Real>(n));
+  mr.push_back(std::vector<Real>(n));
+  mType.push_back(std::vector<VertexType>(n));
+  mCGtmp1.push_back(std::vector<double>());
+  mCGtmp2.push_back(std::vector<double>());
+  mCGtmp3.push_back(std::vector<double>());
+  mCGtmp4.push_back(std::vector<double>());
+
+  debMsg("GridMg::GridMg level 0: " << mSize[0].x << " x " << mSize[0].y << " x " << mSize[0].z
+                                    << " x ",
+         2);
+
+  // Create coarse levels >0
+  for (int l = 1; l <= 100; l++) {
+    if (mSize[l - 1].x <= 5 && mSize[l - 1].y <= 5 && mSize[l - 1].z <= 5)
+      break;
+    if (n <= 1000)
+      break;
+
+    mSize.push_back((mSize[l - 1] + 2) / 2);
+    mPitch.push_back(Vec3i(1, mSize.back().x, mSize.back().x * mSize.back().y));
+    n = mSize.back().x * mSize.back().y * mSize.back().z;
+
+    mA.push_back(std::vector<Real>(n * mStencilSize));
+    mx.push_back(std::vector<Real>(n));
+    mb.push_back(std::vector<Real>(n));
+    mr.push_back(std::vector<Real>(n));
+    mType.push_back(std::vector<VertexType>(n));
+    mCGtmp1.push_back(std::vector<double>());
+    mCGtmp2.push_back(std::vector<double>());
+    mCGtmp3.push_back(std::vector<double>());
+    mCGtmp4.push_back(std::vector<double>());
+
+    debMsg("GridMg::GridMg level " << l << ": " << mSize[l].x << " x " << mSize[l].y << " x "
+                                   << mSize[l].z << " x ",
+           2);
+  }
+
+  // Additional memory for CG on coarsest level
+  mCGtmp1.back() = std::vector<double>(n);
+  mCGtmp2.back() = std::vector<double>(n);
+  mCGtmp3.back() = std::vector<double>(n);
+  mCGtmp4.back() = std::vector<double>(n);
+
+  MG_TIMINGS(debMsg("GridMg: Allocation done in " << time.update(), 1);)
+
+  // Precalculate coarsening paths:
+  // (V) <--restriction-- (U) <--A_{l-1}-- (W) <--interpolation-- (N)
+  Vec3i p7stencil[7] = {Vec3i(0, 0, 0),
+                        Vec3i(-1, 0, 0),
+                        Vec3i(1, 0, 0),
+                        Vec3i(0, -1, 0),
+                        Vec3i(0, 1, 0),
+                        Vec3i(0, 0, -1),
+                        Vec3i(0, 0, 1)};
+  Vec3i V(1, 1, 1);  // reference coarse grid vertex at (1,1,1)
+  FOR_VEC_MINMAX(U, V * 2 + mStencilMin, V * 2 + mStencilMax)
+  {
+    for (int i = 0; i < 1 + 2 * mDim; i++) {
+      Vec3i W = U + p7stencil[i];
+      FOR_VEC_MINMAX(N, W / 2, (W + 1) / 2)
+      {
+        int s = dot(N, Vec3i(1, 3, 9));
+
+        if (s >= 13) {
+          CoarseningPath path;
+          path.N = N - 1;                  // offset of N on coarse grid
+          path.U = U - V * 2;              // offset of U on fine grid
+          path.W = W - V * 2;              // offset of W on fine grid
+          path.sc = s - 13;                // stencil index corresponding to V<-N on coarse grid
+          path.sf = (i + 1) / 2;           // stencil index corresponding to U<-W on coarse grid
+          path.inUStencil = (i % 2 == 0);  // fine grid stencil entry stored at U or W?
+          path.rw = Real(1) /
+                    Real(1 << ((U.x % 2) + (U.y % 2) + (U.z % 2)));  // restriction weight V<-U
+          path.iw = Real(1) /
+                    Real(1 << ((W.x % 2) + (W.y % 2) + (W.z % 2)));  // interpolation weight W<-N
+          mCoarseningPaths0.push_back(path);
+        }
+      }
+    }
+  }
+
+  auto pathLess = [](const GridMg::CoarseningPath &p1, const GridMg::CoarseningPath &p2) {
+    if (p1.sc == p2.sc)
+      return dot(p1.U + 1, Vec3i(1, 3, 9)) < dot(p2.U + 1, Vec3i(1, 3, 9));
+    return p1.sc < p2.sc;
+  };
+  std::sort(mCoarseningPaths0.begin(), mCoarseningPaths0.end(), pathLess);
+}
+
+void GridMg::analyzeStencil(int v,
+                            bool is3D,
+                            bool &isStencilSumNonZero,
+                            bool &isEquationTrivial) const
+{
+  Vec3i V = vecIdx(v, 0);
+
+  // collect stencil entries
+  Real A[7];
+  A[0] = mA[0][v * mStencilSize0 + 0];
+  A[1] = mA[0][v * mStencilSize0 + 1];
+  A[2] = mA[0][v * mStencilSize0 + 2];
+  A[3] = is3D ? mA[0][v * mStencilSize0 + 3] : Real(0);
+  A[4] = V.x != 0 ? mA[0][(v - mPitch[0].x) * mStencilSize0 + 1] : Real(0);
+  A[5] = V.y != 0 ? mA[0][(v - mPitch[0].y) * mStencilSize0 + 2] : Real(0);
+  A[6] = V.z != 0 && is3D ? mA[0][(v - mPitch[0].z) * mStencilSize0 + 3] : Real(0);
+
+  // compute sum of stencil entries
+  Real stencilMax = Real(0), stencilSum = Real(0);
+  for (int i = 0; i < 7; i++) {
+    stencilSum += A[i];
+    stencilMax = max(stencilMax, std::abs(A[i]));
+  }
+
+  // check if sum is numerically zero
+  isStencilSumNonZero = std::abs(stencilSum / stencilMax) > Real(1E-6);
+
+  // check for trivial equation (exact comparisons)
+  isEquationTrivial = A[0] == Real(1) && A[1] == Real(0) && A[2] == Real(0) && A[3] == Real(0) &&
+                      A[4] == Real(0) && A[5] == Real(0) && A[6] == Real(0);
+}
+
+struct knCopyA : public KernelBase {
+  knCopyA(std::vector<Real> &sizeRef,
+          std::vector<Real> &A0,
+          int stencilSize0,
+          bool is3D,
+          const Grid<Real> *pA0,
+          const Grid<Real> *pAi,
+          const Grid<Real> *pAj,
+          const Grid<Real> *pAk)
+      : KernelBase(sizeRef.size()),
+        sizeRef(sizeRef),
+        A0(A0),
+        stencilSize0(stencilSize0),
+        is3D(is3D),
+        pA0(pA0),
+        pAi(pAi),
+        pAj(pAj),
+        pAk(pAk)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 std::vector<Real> &sizeRef,
+                 std::vector<Real> &A0,
+                 int stencilSize0,
+                 bool is3D,
+                 const Grid<Real> *pA0,
+                 const Grid<Real> *pAi,
+                 const Grid<Real> *pAj,
+                 const Grid<Real> *pAk) const
+  {
+    A0[idx * stencilSize0 + 0] = (*pA0)[idx];
+    A0[idx * stencilSize0 + 1] = (*pAi)[idx];
+    A0[idx * stencilSize0 + 2] = (*pAj)[idx];
+    if (is3D)
+      A0[idx * stencilSize0 + 3] = (*pAk)[idx];
+  }
+  inline std::vector<Real> &getArg0()
+  {
+    return sizeRef;
+  }
+  typedef std::vector<Real> type0;
+  inline std::vector<Real> &getArg1()
+  {
+    return A0;
+  }
+  typedef std::vector<Real> type1;
+  inline int &getArg2()
+  {
+    return stencilSize0;
+  }
+  typedef int type2;
+  inline bool &getArg3()
+  {
+    return is3D;
+  }
+  typedef bool type3;
+  inline const Grid<Real> *getArg4()
+  {
+    return pA0;
+  }
+  typedef Grid<Real> type4;
+  inline const Grid<Real> *getArg5()
+  {
+    return pAi;
+  }
+  typedef Grid<Real> type5;
+  inline const Grid<Real> *getArg6()
+  {
+    return pAj;
+  }
+  typedef Grid<Real> type6;
+  inline const Grid<Real> *getArg7()
+  {
+    return pAk;
+  }
+  typedef Grid<Real> type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCopyA ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, sizeRef, A0, stencilSize0, is3D, pA0, pAi, pAj, pAk);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<Real> &sizeRef;
+  std::vector<Real> &A0;
+  int stencilSize0;
+  bool is3D;
+  const Grid<Real> *pA0;
+  const Grid<Real> *pAi;
+  const Grid<Real> *pAj;
+  const Grid<Real> *pAk;
+};
+
+struct knActivateVertices : public KernelBase {
+  knActivateVertices(std::vector<GridMg::VertexType> &type_0,
+                     std::vector<Real> &A0,
+                     bool &nonZeroStencilSumFound,
+                     bool &trivialEquationsFound,
+                     const GridMg &mg)
+      : KernelBase(type_0.size()),
+        type_0(type_0),
+        A0(A0),
+        nonZeroStencilSumFound(nonZeroStencilSumFound),
+        trivialEquationsFound(trivialEquationsFound),
+        mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 std::vector<GridMg::VertexType> &type_0,
+                 std::vector<Real> &A0,
+                 bool &nonZeroStencilSumFound,
+                 bool &trivialEquationsFound,
+                 const GridMg &mg) const
+  {
+    // active vertices on level 0 are vertices with non-zero diagonal entry in A
+    type_0[idx] = GridMg::vtInactive;
+
+    if (mg.mA[0][idx * mg.mStencilSize0 + 0] != Real(0)) {
+      type_0[idx] = GridMg::vtActive;
+
+      bool isStencilSumNonZero = false, isEquationTrivial = false;
+      mg.analyzeStencil(int(idx), mg.mIs3D, isStencilSumNonZero, isEquationTrivial);
+
+      // Note: nonZeroStencilSumFound and trivialEquationsFound are only
+      // changed from false to true, and hence there are no race conditions.
+      if (isStencilSumNonZero)
+        nonZeroStencilSumFound = true;
+
+      // scale down trivial equations
+      if (isEquationTrivial) {
+        type_0[idx] = GridMg::vtActiveTrivial;
+        A0[idx * mg.mStencilSize0 + 0] *= mg.mTrivialEquationScale;
+        trivialEquationsFound = true;
+      };
+    }
+  }
+  inline std::vector<GridMg::VertexType> &getArg0()
+  {
+    return type_0;
+  }
+  typedef std::vector<GridMg::VertexType> type0;
+  inline std::vector<Real> &getArg1()
+  {
+    return A0;
+  }
+  typedef std::vector<Real> type1;
+  inline bool &getArg2()
+  {
+    return nonZeroStencilSumFound;
+  }
+  typedef bool type2;
+  inline bool &getArg3()
+  {
+    return trivialEquationsFound;
+  }
+  typedef bool type3;
+  inline const GridMg &getArg4()
+  {
+    return mg;
+  }
+  typedef GridMg type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knActivateVertices ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, type_0, A0, nonZeroStencilSumFound, trivialEquationsFound, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<GridMg::VertexType> &type_0;
+  std::vector<Real> &A0;
+  bool &nonZeroStencilSumFound;
+  bool &trivialEquationsFound;
+  const GridMg &mg;
+};
+
+void GridMg::setA(const Grid<Real> *pA0,
+                  const Grid<Real> *pAi,
+                  const Grid<Real> *pAj,
+                  const Grid<Real> *pAk)
+{
+  MG_TIMINGS(MuTime time;)
+
+  // Copy level 0
+  knCopyA(mx[0], mA[0], mStencilSize0, mIs3D, pA0, pAi, pAj, pAk);
+
+  // Determine active vertices and scale trivial equations
+  bool nonZeroStencilSumFound = false;
+  bool trivialEquationsFound = false;
+
+  knActivateVertices(mType[0], mA[0], nonZeroStencilSumFound, trivialEquationsFound, *this);
+
+  if (trivialEquationsFound)
+    debMsg("GridMg::setA: Found at least one trivial equation", 2);
+
+  // Sanity check: if all rows of A sum up to 0 --> A doesn't have full rank (opposite direction
+  // isn't necessarily true)
+  if (!nonZeroStencilSumFound)
+    debMsg(
+        "GridMg::setA: Found constant mode: A*1=0! A does not have full rank and multigrid may "
+        "not converge. (forgot to fix a pressure value?)",
+        1);
+
+  // Create coarse grids and operators on levels >0
+  for (int l = 1; l < mA.size(); l++) {
+    MG_TIMINGS(time.get();)
+    genCoarseGrid(l);
+    MG_TIMINGS(debMsg("GridMg: Generated level " << l << " in " << time.update(), 1);)
+    genCoraseGridOperator(l);
+    MG_TIMINGS(debMsg("GridMg: Generated operator " << l << " in " << time.update(), 1);)
+  }
+
+  mIsASet = true;
+  mIsRhsSet = false;  // invalidate rhs
+}
+
+struct knSetRhs : public KernelBase {
+  knSetRhs(std::vector<Real> &b, const Grid<Real> &rhs, const GridMg &mg)
+      : KernelBase(b.size()), b(b), rhs(rhs), mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<Real> &b, const Grid<Real> &rhs, const GridMg &mg) const
+  {
+    b[idx] = rhs[idx];
+
+    // scale down trivial equations
+    if (mg.mType[0][idx] == GridMg::vtActiveTrivial) {
+      b[idx] *= mg.mTrivialEquationScale;
+    };
+  }
+  inline std::vector<Real> &getArg0()
+  {
+    return b;
+  }
+  typedef std::vector<Real> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return rhs;
+  }
+  typedef Grid<Real> type1;
+  inline const GridMg &getArg2()
+  {
+    return mg;
+  }
+  typedef GridMg type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetRhs ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, b, rhs, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<Real> &b;
+  const Grid<Real> &rhs;
+  const GridMg &mg;
+};
+
+void GridMg::setRhs(const Grid<Real> &rhs)
+{
+  assertMsg(mIsASet, "GridMg::setRhs Error: A has not been set.");
+
+  knSetRhs(mb[0], rhs, *this);
+
+  mIsRhsSet = true;
+}
+
+template<class T> struct knSet : public KernelBase {
+  knSet(std::vector<T> &data, T value) : KernelBase(data.size()), data(data), value(value)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<T> &data, T value) const
+  {
+    data[idx] = value;
+  }
+  inline std::vector<T> &getArg0()
+  {
+    return data;
+  }
+  typedef std::vector<T> type0;
+  inline T &getArg1()
+  {
+    return value;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSet ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, data, value);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<T> &data;
+  T value;
+};
+
+template<class T> struct knCopyToVector : public KernelBase {
+  knCopyToVector(std::vector<T> &dst, const Grid<T> &src)
+      : KernelBase(dst.size()), dst(dst), src(src)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<T> &dst, const Grid<T> &src) const
+  {
+    dst[idx] = src[idx];
+  }
+  inline std::vector<T> &getArg0()
+  {
+    return dst;
+  }
+  typedef std::vector<T> type0;
+  inline const Grid<T> &getArg1()
+  {
+    return src;
+  }
+  typedef Grid<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCopyToVector ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, dst, src);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<T> &dst;
+  const Grid<T> &src;
+};
+
+template<class T> struct knCopyToGrid : public KernelBase {
+  knCopyToGrid(const std::vector<T> &src, Grid<T> &dst)
+      : KernelBase(src.size()), src(src), dst(dst)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const std::vector<T> &src, Grid<T> &dst) const
+  {
+    dst[idx] = src[idx];
+  }
+  inline const std::vector<T> &getArg0()
+  {
+    return src;
+  }
+  typedef std::vector<T> type0;
+  inline Grid<T> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCopyToGrid ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, src, dst);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const std::vector<T> &src;
+  Grid<T> &dst;
+};
+
+template<class T> struct knAddAssign : public KernelBase {
+  knAddAssign(std::vector<T> &dst, const std::vector<T> &src)
+      : KernelBase(dst.size()), dst(dst), src(src)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<T> &dst, const std::vector<T> &src) const
+  {
+    dst[idx] += src[idx];
+  }
+  inline std::vector<T> &getArg0()
+  {
+    return dst;
+  }
+  typedef std::vector<T> type0;
+  inline const std::vector<T> &getArg1()
+  {
+    return src;
+  }
+  typedef std::vector<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knAddAssign ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, dst, src);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<T> &dst;
+  const std::vector<T> &src;
+};
+
+Real GridMg::doVCycle(Grid<Real> &dst, const Grid<Real> *src)
+{
+  MG_TIMINGS(MuTime timeSmooth; MuTime timeCG; MuTime timeI; MuTime timeR; MuTime timeTotal;
+             MuTime time;)
+  MG_TIMINGS(timeSmooth.clear(); timeCG.clear(); timeI.clear(); timeR.clear();)
+
+  assertMsg(mIsASet && mIsRhsSet, "GridMg::doVCycle Error: A and/or rhs have not been set.");
+
+  const int maxLevel = int(mA.size()) - 1;
+
+  if (src) {
+    knCopyToVector<Real>(mx[0], *src);
+  }
+  else {
+    knSet<Real>(mx[0], Real(0));
+  }
+
+  for (int l = 0; l < maxLevel; l++) {
+    MG_TIMINGS(time.update();)
+    for (int i = 0; i < mNumPreSmooth; i++) {
+      smoothGS(l, false);
+    }
+
+    MG_TIMINGS(timeSmooth += time.update();)
+
+    calcResidual(l);
+    restrict(l + 1, mr[l], mb[l + 1]);
+
+    knSet<Real>(mx[l + 1], Real(0));
+
+    MG_TIMINGS(timeR += time.update();)
+  }
+
+  MG_TIMINGS(time.update();)
+  solveCG(maxLevel);
+  MG_TIMINGS(timeCG += time.update();)
+
+  for (int l = maxLevel - 1; l >= 0; l--) {
+    MG_TIMINGS(time.update();)
+    interpolate(l, mx[l + 1], mr[l]);
+
+    knAddAssign<Real>(mx[l], mr[l]);
+
+    MG_TIMINGS(timeI += time.update();)
+
+    for (int i = 0; i < mNumPostSmooth; i++) {
+      smoothGS(l, true);
+    }
+    MG_TIMINGS(timeSmooth += time.update();)
+  }
+
+  calcResidual(0);
+  Real res = calcResidualNorm(0);
+
+  knCopyToGrid<Real>(mx[0], dst);
+
+  MG_TIMINGS(debMsg("GridMg: Finished VCycle in "
+                        << timeTotal.update() << " (smoothing: " << timeSmooth
+                        << ", CG: " << timeCG << ", R: " << timeR << ", I: " << timeI << ")",
+                    1);)
+
+  return res;
+}
+
+struct knActivateCoarseVertices : public KernelBase {
+  knActivateCoarseVertices(std::vector<GridMg::VertexType> &type, int unused)
+      : KernelBase(type.size()), type(type), unused(unused)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<GridMg::VertexType> &type, int unused) const
+  {
+    // set all remaining 'free' vertices to 'removed',
+    if (type[idx] == GridMg::vtFree)
+      type[idx] = GridMg::vtRemoved;
+
+    // then convert 'zero' vertices to 'active' and 'removed' vertices to 'inactive'
+    if (type[idx] == GridMg::vtZero)
+      type[idx] = GridMg::vtActive;
+    if (type[idx] == GridMg::vtRemoved)
+      type[idx] = GridMg::vtInactive;
+  }
+  inline std::vector<GridMg::VertexType> &getArg0()
+  {
+    return type;
+  }
+  typedef std::vector<GridMg::VertexType> type0;
+  inline int &getArg1()
+  {
+    return unused;
+  }
+  typedef int type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knActivateCoarseVertices ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, type, unused);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<GridMg::VertexType> &type;
+  int unused;
+};
+
+// Determine active cells on coarse level l from active cells on fine level l-1
+// while ensuring a full-rank interpolation operator (see Section 3.3 in [1]).
+void GridMg::genCoarseGrid(int l)
+{
+  // AF_Free: unused/untouched vertices
+  // AF_Zero: vertices selected for coarser level
+  // AF_Removed: vertices removed from coarser level
+  enum activeFlags : char { AF_Removed = 0, AF_Zero = 1, AF_Free = 2 };
+
+  // initialize all coarse vertices with 'free'
+  knSet<VertexType>(mType[l], vtFree);
+
+  // initialize min heap of (ID: fine grid vertex, key: #free interpolation vertices) pairs
+  NKMinHeap heap(int(mb[l - 1].size()),
+                 mIs3D ? 9 : 5);  // max 8 (or 4 in 2D) free interpolation vertices
+
+  FOR_LVL(v, l - 1)
+  {
+    if (mType[l - 1][v] != vtInactive) {
+      Vec3i V = vecIdx(v, l - 1);
+      int fiv = 1 << ((V.x % 2) + (V.y % 2) + (V.z % 2));
+      heap.setKey(v, fiv);
+    }
+  }
+
+  // process fine vertices in heap consecutively, always choosing the vertex with
+  // the currently smallest number of free interpolation vertices
+  while (heap.size() > 0) {
+    int v = heap.popMin().first;
+    Vec3i V = vecIdx(v, l - 1);
+
+    // loop over associated interpolation vertices of V on coarse level l:
+    // the first encountered 'free' vertex is set to 'zero',
+    // all remaining 'free' vertices are set to 'removed'.
+    bool vdone = false;
+
+    FOR_VEC_MINMAX(I, V / 2, (V + 1) / 2)
+    {
+      int i = linIdx(I, l);
+
+      if (mType[l][i] == vtFree) {
+        if (vdone) {
+          mType[l][i] = vtRemoved;
+        }
+        else {
+          mType[l][i] = vtZero;
+          vdone = true;
+        }
+
+        // update #free interpolation vertices in heap:
+        // loop over all associated restriction vertices of I on fine level l-1
+        FOR_VEC_MINMAX(R, vmax(0, I * 2 - 1), vmin(mSize[l - 1] - 1, I * 2 + 1))
+        {
+          int r = linIdx(R, l - 1);
+          int key = heap.getKey(r);
+
+          if (key > 1) {
+            heap.setKey(r, key - 1);
+          }  // decrease key of r
+          else if (key > -1) {
+            heap.setKey(r, -1);
+          }  // removes r from heap
+        }
+      }
+    }
+  }
+
+  knActivateCoarseVertices(mType[l], 0);
+}
+
+struct knGenCoarseGridOperator : public KernelBase {
+  knGenCoarseGridOperator(std::vector<Real> &sizeRef,
+                          std::vector<Real> &A,
+                          int l,
+                          const GridMg &mg)
+      : KernelBase(sizeRef.size()), sizeRef(sizeRef), A(A), l(l), mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 std::vector<Real> &sizeRef,
+                 std::vector<Real> &A,
+                 int l,
+                 const GridMg &mg) const
+  {
+    if (mg.mType[l][idx] == GridMg::vtInactive)
+      return;
+
+    for (int i = 0; i < mg.mStencilSize; i++) {
+      A[idx * mg.mStencilSize + i] = Real(0);
+    }  // clear stencil
+
+    Vec3i V = mg.vecIdx(int(idx), l);
+
+    // Calculate the stencil of A_l at V by considering all vertex paths of the form:
+    // (V) <--restriction-- (U) <--A_{l-1}-- (W) <--interpolation-- (N)
+    // V and N are vertices on the coarse grid level l,
+    // U and W are vertices on the fine grid level l-1.
+
+    if (l == 1) {
+      // loop over precomputed paths
+      for (auto it = mg.mCoarseningPaths0.begin(); it != mg.mCoarseningPaths0.end(); it++) {
+        Vec3i N = V + it->N;
+        int n = mg.linIdx(N, l);
+        if (!mg.inGrid(N, l) || mg.mType[l][n] == GridMg::vtInactive)
+          continue;
+
+        Vec3i U = V * 2 + it->U;
+        int u = mg.linIdx(U, l - 1);
+        if (!mg.inGrid(U, l - 1) || mg.mType[l - 1][u] == GridMg::vtInactive)
+          continue;
+
+        Vec3i W = V * 2 + it->W;
+        int w = mg.linIdx(W, l - 1);
+        if (!mg.inGrid(W, l - 1) || mg.mType[l - 1][w] == GridMg::vtInactive)
+          continue;
+
+        if (it->inUStencil) {
+          A[idx * mg.mStencilSize + it->sc] += it->rw *
+                                               mg.mA[l - 1][u * mg.mStencilSize0 + it->sf] *
+                                               it->iw;
+        }
+        else {
+          A[idx * mg.mStencilSize + it->sc] += it->rw *
+                                               mg.mA[l - 1][w * mg.mStencilSize0 + it->sf] *
+                                               it->iw;
+        }
+      }
+    }
+    else {
+      // l > 1:
+      // loop over restriction vertices U on level l-1 associated with V
+      FOR_VEC_MINMAX(U, vmax(0, V * 2 - 1), vmin(mg.mSize[l - 1] - 1, V * 2 + 1))
+      {
+        int u = mg.linIdx(U, l - 1);
+        if (mg.mType[l - 1][u] == GridMg::vtInactive)
+          continue;
+
+        // restriction weight
+        Real rw = Real(1) / Real(1 << ((U.x % 2) + (U.y % 2) + (U.z % 2)));
+
+        // loop over all stencil neighbors N of V on level l that can be reached via restriction to
+        // U
+        FOR_VEC_MINMAX(N, (U - 1) / 2, vmin(mg.mSize[l] - 1, (U + 2) / 2))
+        {
+          int n = mg.linIdx(N, l);
+          if (mg.mType[l][n] == GridMg::vtInactive)
+            continue;
+
+          // stencil entry at V associated to N (coarse grid level l)
+          Vec3i SC = N - V + mg.mStencilMax;
+          int sc = SC.x + 3 * SC.y + 9 * SC.z;
+          if (sc < mg.mStencilSize - 1)
+            continue;
+
+          // loop over all vertices W which are in the stencil of A_{l-1} at U
+          // and which interpolate from N
+          FOR_VEC_MINMAX(W,
+                         vmax(0, vmax(U - 1, N * 2 - 1)),
+                         vmin(mg.mSize[l - 1] - 1, vmin(U + 1, N * 2 + 1)))
+          {
+            int w = mg.linIdx(W, l - 1);
+            if (mg.mType[l - 1][w] == GridMg::vtInactive)
+              continue;
+
+            // stencil entry at U associated to W (fine grid level l-1)
+            Vec3i SF = W - U + mg.mStencilMax;
+            int sf = SF.x + 3 * SF.y + 9 * SF.z;
+
+            Real iw = Real(1) /
+                      Real(1 << ((W.x % 2) + (W.y % 2) + (W.z % 2)));  // interpolation weight
+
+            if (sf < mg.mStencilSize) {
+              A[idx * mg.mStencilSize + sc - mg.mStencilSize + 1] +=
+                  rw * mg.mA[l - 1][w * mg.mStencilSize + mg.mStencilSize - 1 - sf] * iw;
+            }
+            else {
+              A[idx * mg.mStencilSize + sc - mg.mStencilSize + 1] +=
+                  rw * mg.mA[l - 1][u * mg.mStencilSize + sf - mg.mStencilSize + 1] * iw;
+            }
+          }
+        }
+      }
+    }
+  }
+  inline std::vector<Real> &getArg0()
+  {
+    return sizeRef;
+  }
+  typedef std::vector<Real> type0;
+  inline std::vector<Real> &getArg1()
+  {
+    return A;
+  }
+  typedef std::vector<Real> type1;
+  inline int &getArg2()
+  {
+    return l;
+  }
+  typedef int type2;
+  inline const GridMg &getArg3()
+  {
+    return mg;
+  }
+  typedef GridMg type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knGenCoarseGridOperator ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, sizeRef, A, l, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<Real> &sizeRef;
+  std::vector<Real> &A;
+  int l;
+  const GridMg &mg;
+};
+
+// Calculate A_l on coarse level l from A_{l-1} on fine level l-1 using
+// Galerkin-based coarsening, i.e., compute A_l = R * A_{l-1} * I.
+void GridMg::genCoraseGridOperator(int l)
+{
+  // for each coarse grid vertex V
+  knGenCoarseGridOperator(mx[l], mA[l], l, *this);
+}
+
+struct knSmoothColor : public KernelBase {
+  knSmoothColor(ThreadSize &numBlocks,
+                std::vector<Real> &x,
+                const Vec3i &blockSize,
+                const std::vector<Vec3i> &colorOffs,
+                int l,
+                const GridMg &mg)
+      : KernelBase(numBlocks.size()),
+        numBlocks(numBlocks),
+        x(x),
+        blockSize(blockSize),
+        colorOffs(colorOffs),
+        l(l),
+        mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ThreadSize &numBlocks,
+                 std::vector<Real> &x,
+                 const Vec3i &blockSize,
+                 const std::vector<Vec3i> &colorOffs,
+                 int l,
+                 const GridMg &mg) const
+  {
+    Vec3i blockOff(int(idx) % blockSize.x,
+                   (int(idx) % (blockSize.x * blockSize.y)) / blockSize.x,
+                   int(idx) / (blockSize.x * blockSize.y));
+
+    for (int off = 0; off < colorOffs.size(); off++) {
+
+      Vec3i V = blockOff * 2 + colorOffs[off];
+      if (!mg.inGrid(V, l))
+        continue;
+
+      const int v = mg.linIdx(V, l);
+      if (mg.mType[l][v] == GridMg::vtInactive)
+        continue;
+
+      Real sum = mg.mb[l][v];
+
+      if (l == 0) {
+        int n;
+        for (int d = 0; d < mg.mDim; d++) {
+          if (V[d] > 0) {
+            n = v - mg.mPitch[0][d];
+            sum -= mg.mA[0][n * mg.mStencilSize0 + d + 1] * mg.mx[0][n];
+          }
+          if (V[d] < mg.mSize[0][d] - 1) {
+            n = v + mg.mPitch[0][d];
+            sum -= mg.mA[0][v * mg.mStencilSize0 + d + 1] * mg.mx[0][n];
+          }
+        }
+
+        x[v] = sum / mg.mA[0][v * mg.mStencilSize0 + 0];
+      }
+      else {
+        FOR_VECLIN_MINMAX(S, s, mg.mStencilMin, mg.mStencilMax)
+        {
+          if (s == mg.mStencilSize - 1)
+            continue;
+
+          Vec3i N = V + S;
+          int n = mg.linIdx(N, l);
+
+          if (mg.inGrid(N, l) && mg.mType[l][n] != GridMg::vtInactive) {
+            if (s < mg.mStencilSize) {
+              sum -= mg.mA[l][n * mg.mStencilSize + mg.mStencilSize - 1 - s] * mg.mx[l][n];
+            }
+            else {
+              sum -= mg.mA[l][v * mg.mStencilSize + s - mg.mStencilSize + 1] * mg.mx[l][n];
+            }
+          }
+        }
+
+        x[v] = sum / mg.mA[l][v * mg.mStencilSize + 0];
+      }
+    }
+  }
+  inline ThreadSize &getArg0()
+  {
+    return numBlocks;
+  }
+  typedef ThreadSize type0;
+  inline std::vector<Real> &getArg1()
+  {
+    return x;
+  }
+  typedef std::vector<Real> type1;
+  inline const Vec3i &getArg2()
+  {
+    return blockSize;
+  }
+  typedef Vec3i type2;
+  inline const std::vector<Vec3i> &getArg3()
+  {
+    return colorOffs;
+  }
+  typedef std::vector<Vec3i> type3;
+  inline int &getArg4()
+  {
+    return l;
+  }
+  typedef int type4;
+  inline const GridMg &getArg5()
+  {
+    return mg;
+  }
+  typedef GridMg type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSmoothColor ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, numBlocks, x, blockSize, colorOffs, l, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ThreadSize &numBlocks;
+  std::vector<Real> &x;
+  const Vec3i &blockSize;
+  const std::vector<Vec3i> &colorOffs;
+  int l;
+  const GridMg &mg;
+};
+
+void GridMg::smoothGS(int l, bool reversedOrder)
+{
+  // Multicolor Gauss-Seidel with two colors for the 5/7-point stencil on level 0
+  // and with four/eight colors for the 9/27-point stencil on levels > 0
+  std::vector<std::vector<Vec3i>> colorOffs;
+  const Vec3i a[8] = {Vec3i(0, 0, 0),
+                      Vec3i(1, 0, 0),
+                      Vec3i(0, 1, 0),
+                      Vec3i(1, 1, 0),
+                      Vec3i(0, 0, 1),
+                      Vec3i(1, 0, 1),
+                      Vec3i(0, 1, 1),
+                      Vec3i(1, 1, 1)};
+  if (mIs3D) {
+    if (l == 0)
+      colorOffs = {{a[0], a[3], a[5], a[6]}, {a[1], a[2], a[4], a[7]}};
+    else
+      colorOffs = {{a[0]}, {a[1]}, {a[2]}, {a[3]}, {a[4]}, {a[5]}, {a[6]}, {a[7]}};
+  }
+  else {
+    if (l == 0)
+      colorOffs = {{a[0], a[3]}, {a[1], a[2]}};
+    else
+      colorOffs = {{a[0]}, {a[1]}, {a[2]}, {a[3]}};
+  }
+
+  // Divide grid into 2x2 blocks for parallelization
+  Vec3i blockSize = (mSize[l] + 1) / 2;
+  ThreadSize numBlocks(blockSize.x * blockSize.y * blockSize.z);
+
+  for (int c = 0; c < colorOffs.size(); c++) {
+    int color = reversedOrder ? int(colorOffs.size()) - 1 - c : c;
+
+    knSmoothColor(numBlocks, mx[l], blockSize, colorOffs[color], l, *this);
+  }
+}
+
+struct knCalcResidual : public KernelBase {
+  knCalcResidual(std::vector<Real> &r, int l, const GridMg &mg)
+      : KernelBase(r.size()), r(r), l(l), mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<Real> &r, int l, const GridMg &mg) const
+  {
+    if (mg.mType[l][idx] == GridMg::vtInactive)
+      return;
+
+    Vec3i V = mg.vecIdx(int(idx), l);
+
+    Real sum = mg.mb[l][idx];
+
+    if (l == 0) {
+      int n;
+      for (int d = 0; d < mg.mDim; d++) {
+        if (V[d] > 0) {
+          n = int(idx) - mg.mPitch[0][d];
+          sum -= mg.mA[0][n * mg.mStencilSize0 + d + 1] * mg.mx[0][n];
+        }
+        if (V[d] < mg.mSize[0][d] - 1) {
+          n = int(idx) + mg.mPitch[0][d];
+          sum -= mg.mA[0][idx * mg.mStencilSize0 + d + 1] * mg.mx[0][n];
+        }
+      }
+      sum -= mg.mA[0][idx * mg.mStencilSize0 + 0] * mg.mx[0][idx];
+    }
+    else {
+      FOR_VECLIN_MINMAX(S, s, mg.mStencilMin, mg.mStencilMax)
+      {
+        Vec3i N = V + S;
+        int n = mg.linIdx(N, l);
+
+        if (mg.inGrid(N, l) && mg.mType[l][n] != GridMg::vtInactive) {
+          if (s < mg.mStencilSize) {
+            sum -= mg.mA[l][n * mg.mStencilSize + mg.mStencilSize - 1 - s] * mg.mx[l][n];
+          }
+          else {
+            sum -= mg.mA[l][idx * mg.mStencilSize + s - mg.mStencilSize + 1] * mg.mx[l][n];
+          }
+        }
+      }
+    }
+
+    r[idx] = sum;
+  }
+  inline std::vector<Real> &getArg0()
+  {
+    return r;
+  }
+  typedef std::vector<Real> type0;
+  inline int &getArg1()
+  {
+    return l;
+  }
+  typedef int type1;
+  inline const GridMg &getArg2()
+  {
+    return mg;
+  }
+  typedef GridMg type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCalcResidual ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, r, l, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<Real> &r;
+  int l;
+  const GridMg &mg;
+};
+
+void GridMg::calcResidual(int l)
+{
+  knCalcResidual(mr[l], l, *this);
+}
+
+struct knResidualNormSumSqr : public KernelBase {
+  knResidualNormSumSqr(const vector<Real> &r, int l, const GridMg &mg)
+      : KernelBase(r.size()), r(r), l(l), mg(mg), result(Real(0))
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const vector<Real> &r, int l, const GridMg &mg, Real &result)
+  {
+    if (mg.mType[l][idx] == GridMg::vtInactive)
+      return;
+
+    result += r[idx] * r[idx];
+  }
+  inline operator Real()
+  {
+    return result;
+  }
+  inline Real &getRet()
+  {
+    return result;
+  }
+  inline const vector<Real> &getArg0()
+  {
+    return r;
+  }
+  typedef vector<Real> type0;
+  inline int &getArg1()
+  {
+    return l;
+  }
+  typedef int type1;
+  inline const GridMg &getArg2()
+  {
+    return mg;
+  }
+  typedef GridMg type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knResidualNormSumSqr ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, r, l, mg, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  knResidualNormSumSqr(knResidualNormSumSqr &o, tbb::split)
+      : KernelBase(o), r(o.r), l(o.l), mg(o.mg), result(Real(0))
+  {
+  }
+  void join(const knResidualNormSumSqr &o)
+  {
+    result += o.result;
+  }
+  const vector<Real> &r;
+  int l;
+  const GridMg &mg;
+  Real result;
+};
+;
+
+Real GridMg::calcResidualNorm(int l)
+{
+  Real res = knResidualNormSumSqr(mr[l], l, *this);
+
+  return std::sqrt(res);
+}
+
+// Standard conjugate gradients with Jacobi preconditioner
+// Notes: Always run at double precision. Not parallelized since
+//        coarsest level is assumed to be small.
+void GridMg::solveCG(int l)
+{
+  auto applyAStencil = [this](int v, int l, const std::vector<double> &vec) -> double {
+    Vec3i V = vecIdx(v, l);
+
+    double sum = 0;
+
+    if (l == 0) {
+      int n;
+      for (int d = 0; d < mDim; d++) {
+        if (V[d] > 0) {
+          n = v - mPitch[0][d];
+          sum += mA[0][n * mStencilSize0 + d + 1] * vec[n];
+        }
+        if (V[d] < mSize[0][d] - 1) {
+          n = v + mPitch[0][d];
+          sum += mA[0][v * mStencilSize0 + d + 1] * vec[n];
+        }
+      }
+      sum += mA[0][v * mStencilSize0 + 0] * vec[v];
+    }
+    else {
+      FOR_VECLIN_MINMAX(S, s, mStencilMin, mStencilMax)
+      {
+        Vec3i N = V + S;
+        int n = linIdx(N, l);
+
+        if (inGrid(N, l) && mType[l][n] != vtInactive) {
+          if (s < mStencilSize) {
+            sum += mA[l][n * mStencilSize + mStencilSize - 1 - s] * vec[n];
+          }
+          else {
+            sum += mA[l][v * mStencilSize + s - mStencilSize + 1] * vec[n];
+          }
+        }
+      }
+    }
+
+    return sum;
+  };
+
+  std::vector<double> &z = mCGtmp1[l];
+  std::vector<double> &p = mCGtmp2[l];
+  std::vector<double> &x = mCGtmp3[l];
+  std::vector<double> &r = mCGtmp4[l];
+
+  // Initialization:
+  double alphaTop = 0;
+  double initialResidual = 0;
+
+  FOR_LVL(v, l)
+  {
+    x[v] = mx[l][v];
+  }
+
+  FOR_LVL(v, l)
+  {
+    if (mType[l][v] == vtInactive)
+      continue;
+
+    r[v] = mb[l][v] - applyAStencil(v, l, x);
+    if (l == 0) {
+      z[v] = r[v] / mA[0][v * mStencilSize0 + 0];
+    }
+    else {
+      z[v] = r[v] / mA[l][v * mStencilSize + 0];
+    }
+
+    initialResidual += r[v] * r[v];
+    p[v] = z[v];
+    alphaTop += r[v] * z[v];
+  }
+
+  initialResidual = std::sqrt(initialResidual);
+
+  int iter = 0;
+  const int maxIter = 10000;
+  double residual = -1;
+
+  // CG iterations
+  for (; iter < maxIter && initialResidual > 1E-12; iter++) {
+    double alphaBot = 0;
+
+    FOR_LVL(v, l)
+    {
+      if (mType[l][v] == vtInactive)
+        continue;
+
+      z[v] = applyAStencil(v, l, p);
+      alphaBot += p[v] * z[v];
+    }
+
+    double alpha = alphaTop / alphaBot;
+
+    double alphaTopNew = 0;
+    residual = 0;
+
+    FOR_LVL(v, l)
+    {
+      if (mType[l][v] == vtInactive)
+        continue;
+
+      x[v] += alpha * p[v];
+      r[v] -= alpha * z[v];
+      residual += r[v] * r[v];
+      if (l == 0)
+        z[v] = r[v] / mA[0][v * mStencilSize0 + 0];
+      else
+        z[v] = r[v] / mA[l][v * mStencilSize + 0];
+      alphaTopNew += r[v] * z[v];
+    }
+
+    residual = std::sqrt(residual);
+
+    if (residual / initialResidual < mCoarsestLevelAccuracy)
+      break;
+
+    double beta = alphaTopNew / alphaTop;
+    alphaTop = alphaTopNew;
+
+    FOR_LVL(v, l)
+    {
+      p[v] = z[v] + beta * p[v];
+    }
+    debMsg("GridMg::solveCG i=" << iter << " rel-residual=" << (residual / initialResidual), 5);
+  }
+
+  FOR_LVL(v, l)
+  {
+    mx[l][v] = Real(x[v]);
+  }
+
+  if (iter == maxIter) {
+    debMsg("GridMg::solveCG Warning: Reached maximum number of CG iterations", 1);
+  }
+  else {
+    debMsg("GridMg::solveCG Info: Reached residual " << residual << " in " << iter
+                                                     << " iterations",
+           2);
+  }
+}
+
+struct knRestrict : public KernelBase {
+  knRestrict(std::vector<Real> &dst, const std::vector<Real> &src, int l_dst, const GridMg &mg)
+      : KernelBase(dst.size()), dst(dst), src(src), l_dst(l_dst), mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 std::vector<Real> &dst,
+                 const std::vector<Real> &src,
+                 int l_dst,
+                 const GridMg &mg) const
+  {
+    if (mg.mType[l_dst][idx] == GridMg::vtInactive)
+      return;
+
+    const int l_src = l_dst - 1;
+
+    // Coarse grid vertex
+    Vec3i V = mg.vecIdx(int(idx), l_dst);
+
+    Real sum = Real(0);
+
+    FOR_VEC_MINMAX(R, vmax(0, V * 2 - 1), vmin(mg.mSize[l_src] - 1, V * 2 + 1))
+    {
+      int r = mg.linIdx(R, l_src);
+      if (mg.mType[l_src][r] == GridMg::vtInactive)
+        continue;
+
+      // restriction weight
+      Real rw = Real(1) / Real(1 << ((R.x % 2) + (R.y % 2) + (R.z % 2)));
+
+      sum += rw * src[r];
+    }
+
+    dst[idx] = sum;
+  }
+  inline std::vector<Real> &getArg0()
+  {
+    return dst;
+  }
+  typedef std::vector<Real> type0;
+  inline const std::vector<Real> &getArg1()
+  {
+    return src;
+  }
+  typedef std::vector<Real> type1;
+  inline int &getArg2()
+  {
+    return l_dst;
+  }
+  typedef int type2;
+  inline const GridMg &getArg3()
+  {
+    return mg;
+  }
+  typedef GridMg type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knRestrict ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, dst, src, l_dst, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<Real> &dst;
+  const std::vector<Real> &src;
+  int l_dst;
+  const GridMg &mg;
+};
+
+void GridMg::restrict(int l_dst, const std::vector<Real> &src, std::vector<Real> &dst) const
+{
+  knRestrict(dst, src, l_dst, *this);
+}
+
+struct knInterpolate : public KernelBase {
+  knInterpolate(std::vector<Real> &dst, const std::vector<Real> &src, int l_dst, const GridMg &mg)
+      : KernelBase(dst.size()), dst(dst), src(src), l_dst(l_dst), mg(mg)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 std::vector<Real> &dst,
+                 const std::vector<Real> &src,
+                 int l_dst,
+                 const GridMg &mg) const
+  {
+    if (mg.mType[l_dst][idx] == GridMg::vtInactive)
+      return;
+
+    const int l_src = l_dst + 1;
+
+    Vec3i V = mg.vecIdx(int(idx), l_dst);
+
+    Real sum = Real(0);
+
+    FOR_VEC_MINMAX(I, V / 2, (V + 1) / 2)
+    {
+      int i = mg.linIdx(I, l_src);
+      if (mg.mType[l_src][i] != GridMg::vtInactive)
+        sum += src[i];
+    }
+
+    // interpolation weight
+    Real iw = Real(1) / Real(1 << ((V.x % 2) + (V.y % 2) + (V.z % 2)));
+
+    dst[idx] = iw * sum;
+  }
+  inline std::vector<Real> &getArg0()
+  {
+    return dst;
+  }
+  typedef std::vector<Real> type0;
+  inline const std::vector<Real> &getArg1()
+  {
+    return src;
+  }
+  typedef std::vector<Real> type1;
+  inline int &getArg2()
+  {
+    return l_dst;
+  }
+  typedef int type2;
+  inline const GridMg &getArg3()
+  {
+    return mg;
+  }
+  typedef GridMg type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knInterpolate ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, dst, src, l_dst, mg);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<Real> &dst;
+  const std::vector<Real> &src;
+  int l_dst;
+  const GridMg &mg;
+};
+
+void GridMg::interpolate(int l_dst, const std::vector<Real> &src, std::vector<Real> &dst) const
+{
+  knInterpolate(dst, src, l_dst, *this);
+}
+
+};  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/multigrid.h b/extern/mantaflow/preprocessed/multigrid.h
new file mode 100644
index 00000000000..12cc4d9abce
--- /dev/null
+++ b/extern/mantaflow/preprocessed/multigrid.h
@@ -0,0 +1,186 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Multigrid solver by Florian Ferstl (florian.ferstl.ff@gmail.com)
+ *
+ * This is an implementation of the solver developed by Dick et al. [1]
+ * without topology awareness (= vertex duplication on coarser levels). This
+ * simplification allows us to use regular grids for all levels of the multigrid
+ * hierarchy and works well for moderately complex domains.
+ *
+ * [1] Solving the Fluid Pressure Poisson Equation Using Multigrid-Evaluation
+ *     and Improvements, C. Dick, M. Rogowsky, R. Westermann, IEEE TVCG 2015
+ *
+ ******************************************************************************/
+
+#ifndef _MULTIGRID_H
+#define _MULTIGRID_H
+
+#include "vectorbase.h"
+#include "grid.h"
+
+namespace Manta {
+
+//! Multigrid solver
+class GridMg {
+ public:
+  //! constructor: preallocates most of required memory for multigrid hierarchy
+  GridMg(const Vec3i &gridSize);
+  ~GridMg(){};
+
+  //! update system matrix A from symmetric 7-point stencil
+  void setA(const Grid<Real> *pA0,
+            const Grid<Real> *pAi,
+            const Grid<Real> *pAj,
+            const Grid<Real> *pAk);
+
+  //! set right-hand side after setting A
+  void setRhs(const Grid<Real> &rhs);
+
+  bool isASet() const
+  {
+    return mIsASet;
+  }
+  bool isRhsSet() const
+  {
+    return mIsRhsSet;
+  }
+
+  //! perform VCycle iteration
+  // - if src is null, then a zero vector is used instead
+  // - returns norm of residual after VCylcle
+  Real doVCycle(Grid<Real> &dst, const Grid<Real> *src = nullptr);
+
+  // access
+  void setCoarsestLevelAccuracy(Real accuracy)
+  {
+    mCoarsestLevelAccuracy = accuracy;
+  }
+  Real getCoarsestLevelAccuracy() const
+  {
+    return mCoarsestLevelAccuracy;
+  }
+  void setSmoothing(int numPreSmooth, int numPostSmooth)
+  {
+    mNumPreSmooth = numPreSmooth;
+    mNumPostSmooth = numPostSmooth;
+  }
+  int getNumPreSmooth() const
+  {
+    return mNumPreSmooth;
+  }
+  int getNumPostSmooth() const
+  {
+    return mNumPostSmooth;
+  }
+
+  //! Set factor for automated downscaling of trivial equations:
+  // 1*x_i = b_i  --->  trivialEquationScale*x_i = trivialEquationScale*b_i
+  // Factor should be significantly smaller than the scale of the entries in A.
+  //     Info: Trivial equations of the form x_i = b_i can have a negative
+  //     effect on the coarse grid operators of the multigrid hierarchy (due
+  //     to scaling mismatches), which can lead to slow multigrid convergence.
+  //     To avoid this, the solver checks for such equations when updating A
+  //     (and rhs) and scales these equations by a fixed factor < 1.
+  void setTrivialEquationScale(Real scale)
+  {
+    mTrivialEquationScale = scale;
+  }
+
+ private:
+  Vec3i vecIdx(int v, int l) const
+  {
+    return Vec3i(v % mSize[l].x,
+                 (v % (mSize[l].x * mSize[l].y)) / mSize[l].x,
+                 v / (mSize[l].x * mSize[l].y));
+  }
+  int linIdx(Vec3i V, int l) const
+  {
+    return V.x + V.y * mPitch[l].y + V.z * mPitch[l].z;
+  }
+  bool inGrid(Vec3i V, int l) const
+  {
+    return V.x >= 0 && V.y >= 0 && V.z >= 0 && V.x < mSize[l].x && V.y < mSize[l].y &&
+           V.z < mSize[l].z;
+  }
+
+  void analyzeStencil(int v, bool is3D, bool &isStencilSumNonZero, bool &isEquationTrivial) const;
+
+  void genCoarseGrid(int l);
+  void genCoraseGridOperator(int l);
+
+  void smoothGS(int l, bool reversedOrder);
+  void calcResidual(int l);
+  Real calcResidualNorm(int l);
+  void solveCG(int l);
+
+  void restrict(int l_dst, const std::vector<Real> &src, std::vector<Real> &dst) const;
+  void interpolate(int l_dst, const std::vector<Real> &src, std::vector<Real> &dst) const;
+
+ private:
+  enum VertexType : char {
+    vtInactive = 0,
+    vtActive = 1,
+    vtActiveTrivial = 2,  // only on finest level 0
+    vtRemoved = 3,        //-+
+    vtZero = 4,           // +-- only during coarse grid generation
+    vtFree = 5            //-+
+  };
+
+  struct CoarseningPath {
+    Vec3i U, W, N;
+    int sc, sf;
+    Real rw, iw;
+    bool inUStencil;
+  };
+
+  int mNumPreSmooth;
+  int mNumPostSmooth;
+  Real mCoarsestLevelAccuracy;
+  Real mTrivialEquationScale;
+
+  std::vector<std::vector<Real>> mA;
+  std::vector<std::vector<Real>> mx;
+  std::vector<std::vector<Real>> mb;
+  std::vector<std::vector<Real>> mr;
+  std::vector<std::vector<VertexType>> mType;
+  std::vector<std::vector<double>> mCGtmp1, mCGtmp2, mCGtmp3, mCGtmp4;
+  std::vector<Vec3i> mSize, mPitch;
+  std::vector<CoarseningPath> mCoarseningPaths0;
+
+  bool mIs3D;
+  int mDim;
+  int mStencilSize;
+  int mStencilSize0;
+  Vec3i mStencilMin;
+  Vec3i mStencilMax;
+
+  bool mIsASet;
+  bool mIsRhsSet;
+
+  // provide kernels with access
+  friend struct knActivateVertices;
+  friend struct knActivateCoarseVertices;
+  friend struct knSetRhs;
+  friend struct knGenCoarseGridOperator;
+  friend struct knSmoothColor;
+  friend struct knCalcResidual;
+  friend struct knResidualNormSumSqr;
+  friend struct knRestrict;
+  friend struct knInterpolate;
+};  // GridMg
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/multigrid.h.reg.cpp b/extern/mantaflow/preprocessed/multigrid.h.reg.cpp
new file mode 100644
index 00000000000..8f91e6ecf2e
--- /dev/null
+++ b/extern/mantaflow/preprocessed/multigrid.h.reg.cpp
@@ -0,0 +1,13 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "multigrid.h"
+namespace Manta {
+extern "C" {
+void PbRegister_file_4()
+{
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/noisefield.cpp b/extern/mantaflow/preprocessed/noisefield.cpp
new file mode 100644
index 00000000000..98a92309b05
--- /dev/null
+++ b/extern/mantaflow/preprocessed/noisefield.cpp
@@ -0,0 +1,325 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Noise field
+ *
+ ******************************************************************************/
+
+#include "noisefield.h"
+#include "randomstream.h"
+#include "grid.h"
+
+using namespace std;
+
+//*****************************************************************************
+// Wavelet noise
+
+#if FLOATINGPOINT_PRECISION == 1
+#  define TILENAME "waveletNoiseTile.bin"
+#else
+#  define TILENAME "waveletNoiseTileD.bin"
+#endif
+
+namespace Manta {
+
+int WaveletNoiseField::randomSeed = 13322223;
+Real *WaveletNoiseField::mNoiseTile = NULL;
+std::atomic<int> WaveletNoiseField::mNoiseReferenceCount(0);
+
+static Real _aCoeffs[32] = {
+    0.000334,  -0.001528, 0.000410,  0.003545,  -0.000938, -0.008233, 0.002172,  0.019120,
+    -0.005040, -0.044412, 0.011655,  0.103311,  -0.025936, -0.243780, 0.033979,  0.655340,
+    0.655340,  0.033979,  -0.243780, -0.025936, 0.103311,  0.011655,  -0.044412, -0.005040,
+    0.019120,  0.002172,  -0.008233, -0.000938, 0.003546,  0.000410,  -0.001528, 0.000334};
+
+void WaveletNoiseField::downsample(Real *from, Real *to, int n, int stride)
+{
+  const Real *a = &_aCoeffs[16];
+  for (int i = 0; i < n / 2; i++) {
+    to[i * stride] = 0;
+    for (int k = 2 * i - 16; k < 2 * i + 16; k++) {
+      to[i * stride] += a[k - 2 * i] * from[modFast128(k) * stride];
+    }
+  }
+}
+
+static Real _pCoeffs[4] = {0.25, 0.75, 0.75, 0.25};
+
+void WaveletNoiseField::upsample(Real *from, Real *to, int n, int stride)
+{
+  const Real *pp = &_pCoeffs[1];
+
+  for (int i = 0; i < n; i++) {
+    to[i * stride] = 0;
+    for (int k = i / 2 - 1; k < i / 2 + 3; k++) {
+      to[i * stride] += 0.5 * pp[k - i / 2] * from[modSlow(k, n / 2) * stride];
+    }  // new */
+  }
+}
+
+WaveletNoiseField::WaveletNoiseField(FluidSolver *parent, int fixedSeed, int loadFromFile)
+    : PbClass(parent),
+      mPosOffset(0.),
+      mPosScale(1.),
+      mValOffset(0.),
+      mValScale(1.),
+      mClamp(false),
+      mClampNeg(0),
+      mClampPos(1),
+      mTimeAnim(0),
+      mGsInvX(0),
+      mGsInvY(0),
+      mGsInvZ(0)
+{
+  Real scale = 1.0 / parent->getGridSize().max();
+  mGsInvX = scale;
+  mGsInvY = scale;
+  mGsInvZ = parent->is3D() ? scale : 1;
+
+  // use global random seed with offset if none is given
+  if (fixedSeed == -1) {
+    fixedSeed = randomSeed + 123;
+  }
+  RandomStream randStreamPos(fixedSeed);
+  mSeedOffset = Vec3(randStreamPos.getVec3Norm());
+
+  generateTile(loadFromFile);
+};
+
+string WaveletNoiseField::toString()
+{
+  std::ostringstream out;
+  out << "NoiseField: name '" << mName << "' "
+      << "  pos off=" << mPosOffset << " scale=" << mPosScale << "  val off=" << mValOffset
+      << " scale=" << mValScale << "  clamp =" << mClamp << " val=" << mClampNeg << " to "
+      << mClampPos << "  timeAni =" << mTimeAnim
+      << "  gridInv =" << Vec3(mGsInvX, mGsInvY, mGsInvZ);
+  return out.str();
+}
+
+void WaveletNoiseField::generateTile(int loadFromFile)
+{
+  // generate tile
+  const int n = NOISE_TILE_SIZE;
+  const int n3 = n * n * n, n3d = n3 * 3;
+
+  if (mNoiseTile) {
+    mNoiseReferenceCount++;
+    return;
+  }
+  Real *noise3 = new Real[n3d];
+  if (loadFromFile) {
+    FILE *fp = fopen(TILENAME, "rb");
+    if (fp) {
+      assertMsg(fread(noise3, sizeof(Real), n3d, fp) == n3d,
+                "Failed to read wavelet noise tile, file invalid/corrupt? (" << TILENAME << ") ");
+      fclose(fp);
+      debMsg("Noise tile loaded from file " TILENAME, 1);
+      mNoiseTile = noise3;
+      mNoiseReferenceCount++;
+      return;
+    }
+  }
+
+  debMsg("Generating 3x " << n << "^3 noise tile ", 1);
+  Real *temp13 = new Real[n3d];
+  Real *temp23 = new Real[n3d];
+
+  // initialize
+  for (int i = 0; i < n3d; i++) {
+    temp13[i] = temp23[i] = noise3[i] = 0.;
+  }
+
+  // Step 1. Fill the tile with random numbers in the range -1 to 1.
+  RandomStream randStreamTile(randomSeed);
+  for (int i = 0; i < n3d; i++) {
+    // noise3[i] = (randStream.getReal() + randStream2.getReal()) -1.; // produces repeated
+    // values??
+    noise3[i] = randStreamTile.getRandNorm(0, 1);
+  }
+
+  // Steps 2 and 3. Downsample and upsample the tile
+  for (int tile = 0; tile < 3; tile++) {
+    for (int iy = 0; iy < n; iy++)
+      for (int iz = 0; iz < n; iz++) {
+        const int i = iy * n + iz * n * n + tile * n3;
+        downsample(&noise3[i], &temp13[i], n, 1);
+        upsample(&temp13[i], &temp23[i], n, 1);
+      }
+    for (int ix = 0; ix < n; ix++)
+      for (int iz = 0; iz < n; iz++) {
+        const int i = ix + iz * n * n + tile * n3;
+        downsample(&temp23[i], &temp13[i], n, n);
+        upsample(&temp13[i], &temp23[i], n, n);
+      }
+    for (int ix = 0; ix < n; ix++)
+      for (int iy = 0; iy < n; iy++) {
+        const int i = ix + iy * n + tile * n3;
+        downsample(&temp23[i], &temp13[i], n, n * n);
+        upsample(&temp13[i], &temp23[i], n, n * n);
+      }
+  }
+
+  // Step 4. Subtract out the coarse-scale contribution
+  for (int i = 0; i < n3d; i++) {
+    noise3[i] -= temp23[i];
+  }
+
+  // Avoid even/odd variance difference by adding odd-offset version of noise to itself.
+  int offset = n / 2;
+  if (offset % 2 == 0)
+    offset++;
+
+  if (n != 128)
+    errMsg("WaveletNoise::Fast 128 mod used, change for non-128 resolution");
+
+  int icnt = 0;
+  for (int tile = 0; tile < 3; tile++)
+    for (int ix = 0; ix < n; ix++)
+      for (int iy = 0; iy < n; iy++)
+        for (int iz = 0; iz < n; iz++) {
+          temp13[icnt] = noise3[modFast128(ix + offset) + modFast128(iy + offset) * n +
+                                modFast128(iz + offset) * n * n + tile * n3];
+          icnt++;
+        }
+
+  for (int i = 0; i < n3d; i++) {
+    noise3[i] += temp13[i];
+  }
+
+  mNoiseTile = noise3;
+  mNoiseReferenceCount++;
+  delete[] temp13;
+  delete[] temp23;
+
+  if (loadFromFile) {
+    FILE *fp = fopen(TILENAME, "wb");
+    if (fp) {
+      fwrite(noise3, sizeof(Real), n3d, fp);
+      fclose(fp);
+      debMsg("Noise field saved to file ", 1);
+    }
+  }
+}
+
+void WaveletNoiseField::downsampleNeumann(const Real *from, Real *to, int n, int stride)
+{
+  // if these values are not local incorrect results are generated
+  static const Real *const aCoCenter = &_aCoeffs[16];
+  for (int i = 0; i < n / 2; i++) {
+    to[i * stride] = 0;
+    for (int k = 2 * i - 16; k < 2 * i + 16; k++) {
+      // handle boundary
+      Real fromval;
+      if (k < 0) {
+        fromval = from[0];
+      }
+      else if (k > n - 1) {
+        fromval = from[(n - 1) * stride];
+      }
+      else {
+        fromval = from[k * stride];
+      }
+      to[i * stride] += aCoCenter[k - 2 * i] * fromval;
+    }
+  }
+}
+
+void WaveletNoiseField::upsampleNeumann(const Real *from, Real *to, int n, int stride)
+{
+  static const Real *const pp = &_pCoeffs[1];
+  for (int i = 0; i < n; i++) {
+    to[i * stride] = 0;
+    for (int k = i / 2 - 1; k < i / 2 + 3; k++) {
+      Real fromval;
+      if (k > n / 2 - 1) {
+        fromval = from[(n / 2 - 1) * stride];
+      }
+      else if (k < 0) {
+        fromval = from[0];
+      }
+      else {
+        fromval = from[k * stride];
+      }
+      to[i * stride] += 0.5 * pp[k - i / 2] * fromval;
+    }
+  }
+}
+
+void WaveletNoiseField::computeCoefficients(Grid<Real> &input,
+                                            Grid<Real> &tempIn1,
+                                            Grid<Real> &tempIn2)
+{
+  // generate tile
+  const int sx = input.getSizeX();
+  const int sy = input.getSizeY();
+  const int sz = input.getSizeZ();
+  const int n3 = sx * sy * sz;
+  // just for compatibility with wavelet turb code
+  Real *temp13 = &tempIn1(0, 0, 0);
+  Real *temp23 = &tempIn2(0, 0, 0);
+  Real *noise3 = &input(0, 0, 0);
+
+  // clear grids
+  for (int i = 0; i < n3; i++) {
+    temp13[i] = temp23[i] = 0.f;
+  }
+
+  // Steps 2 and 3. Downsample and upsample the tile
+  for (int iz = 0; iz < sz; iz++)
+    for (int iy = 0; iy < sy; iy++) {
+      const int i = iz * sx * sy + iy * sx;
+      downsampleNeumann(&noise3[i], &temp13[i], sx, 1);
+      upsampleNeumann(&temp13[i], &temp23[i], sx, 1);
+    }
+
+  for (int iz = 0; iz < sz; iz++)
+    for (int ix = 0; ix < sx; ix++) {
+      const int i = iz * sx * sy + ix;
+      downsampleNeumann(&temp23[i], &temp13[i], sy, sx);
+      upsampleNeumann(&temp13[i], &temp23[i], sy, sx);
+    }
+
+  if (input.is3D()) {
+    for (int iy = 0; iy < sy; iy++)
+      for (int ix = 0; ix < sx; ix++) {
+        const int i = iy * sx + ix;
+        downsampleNeumann(&temp23[i], &temp13[i], sz, sy * sx);
+        upsampleNeumann(&temp13[i], &temp23[i], sz, sy * sx);
+      }
+  }
+
+  // Step 4. Subtract out the coarse-scale contribution
+  for (int i = 0; i < n3; i++) {
+    Real residual = noise3[i] - temp23[i];
+    temp13[i] = sqrtf(fabs(residual));
+  }
+
+  // copy back, and compute actual weight for wavelet turbulence...
+  Real smoothingFactor = 1. / 6.;
+  if (!input.is3D())
+    smoothingFactor = 1. / 4.;
+  FOR_IJK_BND(input, 1)
+  {
+    // apply some brute force smoothing
+    Real res = temp13[k * sx * sy + j * sx + i - 1] + temp13[k * sx * sy + j * sx + i + 1];
+    res += temp13[k * sx * sy + j * sx + i - sx] + temp13[k * sx * sy + j * sx + i + sx];
+    if (input.is3D())
+      res += temp13[k * sx * sy + j * sx + i - sx * sy] +
+             temp13[k * sx * sy + j * sx + i + sx * sy];
+    input(i, j, k) = res * smoothingFactor;
+  }
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/noisefield.h b/extern/mantaflow/preprocessed/noisefield.h
new file mode 100644
index 00000000000..ddf47573dd9
--- /dev/null
+++ b/extern/mantaflow/preprocessed/noisefield.h
@@ -0,0 +1,635 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Wavelet noise field
+ *
+ ******************************************************************************/
+
+#ifndef _NOISEFIELD_H_
+#define _NOISEFIELD_H_
+
+#include "vectorbase.h"
+#include "manta.h"
+#include "grid.h"
+#include <atomic>
+
+namespace Manta {
+
+#define NOISE_TILE_SIZE 128
+
+// wrapper for a parametrized field of wavelet noise
+
+class WaveletNoiseField : public PbClass {
+ public:
+  WaveletNoiseField(FluidSolver *parent, int fixedSeed = -1, int loadFromFile = false);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "WaveletNoiseField::WaveletNoiseField", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        int fixedSeed = _args.getOpt<int>("fixedSeed", 1, -1, &_lock);
+        int loadFromFile = _args.getOpt<int>("loadFromFile", 2, false, &_lock);
+        obj = new WaveletNoiseField(parent, fixedSeed, loadFromFile);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "WaveletNoiseField::WaveletNoiseField", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("WaveletNoiseField::WaveletNoiseField", e.what());
+      return -1;
+    }
+  }
+
+  ~WaveletNoiseField()
+  {
+    if (mNoiseTile && !mNoiseReferenceCount) {
+      delete mNoiseTile;
+      mNoiseTile = NULL;
+    }
+  };
+
+  //! evaluate noise
+  inline Real evaluate(Vec3 pos, int tile = 0) const;
+  //! evaluate noise as a vector
+  inline Vec3 evaluateVec(Vec3 pos, int tile = 0) const;
+  //! evaluate curl noise
+  inline Vec3 evaluateCurl(Vec3 pos) const;
+
+  //! direct data access
+  Real *data()
+  {
+    return mNoiseTile;
+  }
+
+  //! compute wavelet decomposition of an input grid (stores residual coefficients)
+  static void computeCoefficients(Grid<Real> &input, Grid<Real> &tempIn1, Grid<Real> &tempIn2);
+
+  // helper
+  std::string toString();
+
+  // texcoord position and scale
+  Vec3 mPosOffset;
+  static PyObject *_GET_mPosOffset(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mPosOffset);
+  }
+  static int _SET_mPosOffset(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mPosOffset = fromPy<Vec3>(val);
+    return 0;
+  }
+
+  Vec3 mPosScale;
+  static PyObject *_GET_mPosScale(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mPosScale);
+  }
+  static int _SET_mPosScale(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mPosScale = fromPy<Vec3>(val);
+    return 0;
+  }
+
+  // value offset & scale
+  Real mValOffset;
+  static PyObject *_GET_mValOffset(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mValOffset);
+  }
+  static int _SET_mValOffset(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mValOffset = fromPy<Real>(val);
+    return 0;
+  }
+
+  Real mValScale;
+  static PyObject *_GET_mValScale(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mValScale);
+  }
+  static int _SET_mValScale(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mValScale = fromPy<Real>(val);
+    return 0;
+  }
+
+  // clamp? (default 0-1)
+  bool mClamp;
+  static PyObject *_GET_mClamp(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mClamp);
+  }
+  static int _SET_mClamp(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mClamp = fromPy<bool>(val);
+    return 0;
+  }
+
+  Real mClampNeg;
+  static PyObject *_GET_mClampNeg(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mClampNeg);
+  }
+  static int _SET_mClampNeg(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mClampNeg = fromPy<Real>(val);
+    return 0;
+  }
+
+  Real mClampPos;
+  static PyObject *_GET_mClampPos(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mClampPos);
+  }
+  static int _SET_mClampPos(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mClampPos = fromPy<Real>(val);
+    return 0;
+  }
+
+  // animated over time
+  Real mTimeAnim;
+  static PyObject *_GET_mTimeAnim(PyObject *self, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    return toPy(pbo->mTimeAnim);
+  }
+  static int _SET_mTimeAnim(PyObject *self, PyObject *val, void *cl)
+  {
+    WaveletNoiseField *pbo = dynamic_cast<WaveletNoiseField *>(Pb::objFromPy(self));
+    pbo->mTimeAnim = fromPy<Real>(val);
+    return 0;
+  }
+
+ protected:
+  // noise evaluation functions
+  static inline Real WNoiseDx(const Vec3 &p, Real *data);
+  static inline Vec3 WNoiseVec(const Vec3 &p, Real *data);
+  static inline Real WNoise(const Vec3 &p, Real *data);
+
+  // helpers for tile generation , for periodic 128 grids only
+  static void downsample(Real *from, Real *to, int n, int stride);
+  static void upsample(Real *from, Real *to, int n, int stride);
+
+  // for grids with arbitrary sizes, and neumann boundary conditions
+  static void downsampleNeumann(const Real *from, Real *to, int n, int stride);
+  static void upsampleNeumann(const Real *from, Real *to, int n, int stride);
+
+  static inline int modSlow(int x, int n)
+  {
+    int m = x % n;
+    return (m < 0) ? m + n : m;
+  }
+// warning - noiseTileSize has to be 128^3!
+#define modFast128(x) ((x)&127)
+
+  inline Real getTime() const
+  {
+    return mParent->getTime() * mParent->getDx() * mTimeAnim;
+  }
+
+  // pre-compute tile data for wavelet noise
+  void generateTile(int loadFromFile);
+
+  // animation over time
+  // grid size normalization (inverse size)
+  Real mGsInvX, mGsInvY, mGsInvZ;
+  // random offset into tile to simulate different random seeds
+  Vec3 mSeedOffset;
+
+  static Real *mNoiseTile;
+  // global random seed storage
+  static int randomSeed;
+  // global reference count for noise tile
+  static std::atomic<int> mNoiseReferenceCount;
+ public:
+  PbArgs _args;
+}
+#define _C_WaveletNoiseField
+;
+
+// **************************************************************************
+// Implementation
+
+#define ADD_WEIGHTED(x, y, z) \
+  weight = 1.0f; \
+  xC = modFast128(midX + (x)); \
+  weight *= w[0][(x) + 1]; \
+  yC = modFast128(midY + (y)); \
+  weight *= w[1][(y) + 1]; \
+  zC = modFast128(midZ + (z)); \
+  weight *= w[2][(z) + 1]; \
+  result += weight * data[(zC * NOISE_TILE_SIZE + yC) * NOISE_TILE_SIZE + xC];
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// derivatives of 3D noise - unrolled for performance
+//////////////////////////////////////////////////////////////////////////////////////////
+inline Real WaveletNoiseField::WNoiseDx(const Vec3 &p, Real *data)
+{
+  Real w[3][3], t, result = 0;
+
+  // Evaluate quadratic B-spline basis functions
+  int midX = (int)ceil(p[0] - 0.5f);
+  t = midX - (p[0] - 0.5f);
+  w[0][0] = -t;
+  w[0][2] = (1.f - t);
+  w[0][1] = 2.0f * t - 1.0f;
+
+  int midY = (int)ceil(p[1] - 0.5f);
+  t = midY - (p[1] - 0.5f);
+  w[1][0] = t * t * 0.5f;
+  w[1][2] = (1.f - t) * (1.f - t) * 0.5f;
+  w[1][1] = 1.f - w[1][0] - w[1][2];
+
+  int midZ = (int)ceil(p[2] - 0.5f);
+  t = midZ - (p[2] - 0.5f);
+  w[2][0] = t * t * 0.5f;
+  w[2][2] = (1.f - t) * (1.f - t) * 0.5f;
+  w[2][1] = 1.f - w[2][0] - w[2][2];
+
+  // Evaluate noise by weighting noise coefficients by basis function values
+  int xC, yC, zC;
+  Real weight = 1;
+
+  ADD_WEIGHTED(-1, -1, -1);
+  ADD_WEIGHTED(0, -1, -1);
+  ADD_WEIGHTED(1, -1, -1);
+  ADD_WEIGHTED(-1, 0, -1);
+  ADD_WEIGHTED(0, 0, -1);
+  ADD_WEIGHTED(1, 0, -1);
+  ADD_WEIGHTED(-1, 1, -1);
+  ADD_WEIGHTED(0, 1, -1);
+  ADD_WEIGHTED(1, 1, -1);
+
+  ADD_WEIGHTED(-1, -1, 0);
+  ADD_WEIGHTED(0, -1, 0);
+  ADD_WEIGHTED(1, -1, 0);
+  ADD_WEIGHTED(-1, 0, 0);
+  ADD_WEIGHTED(0, 0, 0);
+  ADD_WEIGHTED(1, 0, 0);
+  ADD_WEIGHTED(-1, 1, 0);
+  ADD_WEIGHTED(0, 1, 0);
+  ADD_WEIGHTED(1, 1, 0);
+
+  ADD_WEIGHTED(-1, -1, 1);
+  ADD_WEIGHTED(0, -1, 1);
+  ADD_WEIGHTED(1, -1, 1);
+  ADD_WEIGHTED(-1, 0, 1);
+  ADD_WEIGHTED(0, 0, 1);
+  ADD_WEIGHTED(1, 0, 1);
+  ADD_WEIGHTED(-1, 1, 1);
+  ADD_WEIGHTED(0, 1, 1);
+  ADD_WEIGHTED(1, 1, 1);
+
+  return result;
+}
+
+inline Real WaveletNoiseField::WNoise(const Vec3 &p, Real *data)
+{
+  Real w[3][3], t, result = 0;
+
+  // Evaluate quadratic B-spline basis functions
+  int midX = (int)ceilf(p[0] - 0.5f);
+  t = midX - (p[0] - 0.5f);
+  w[0][0] = t * t * 0.5f;
+  w[0][2] = (1.f - t) * (1.f - t) * 0.5f;
+  w[0][1] = 1.f - w[0][0] - w[0][2];
+
+  int midY = (int)ceilf(p[1] - 0.5f);
+  t = midY - (p[1] - 0.5f);
+  w[1][0] = t * t * 0.5f;
+  w[1][2] = (1.f - t) * (1.f - t) * 0.5f;
+  w[1][1] = 1.f - w[1][0] - w[1][2];
+
+  int midZ = (int)ceilf(p[2] - 0.5f);
+  t = midZ - (p[2] - 0.5f);
+  w[2][0] = t * t * 0.5f;
+  w[2][2] = (1.f - t) * (1.f - t) * 0.5f;
+  w[2][1] = 1.f - w[2][0] - w[2][2];
+
+  // Evaluate noise by weighting noise coefficients by basis function values
+  int xC, yC, zC;
+  Real weight = 1;
+
+  ADD_WEIGHTED(-1, -1, -1);
+  ADD_WEIGHTED(0, -1, -1);
+  ADD_WEIGHTED(1, -1, -1);
+  ADD_WEIGHTED(-1, 0, -1);
+  ADD_WEIGHTED(0, 0, -1);
+  ADD_WEIGHTED(1, 0, -1);
+  ADD_WEIGHTED(-1, 1, -1);
+  ADD_WEIGHTED(0, 1, -1);
+  ADD_WEIGHTED(1, 1, -1);
+
+  ADD_WEIGHTED(-1, -1, 0);
+  ADD_WEIGHTED(0, -1, 0);
+  ADD_WEIGHTED(1, -1, 0);
+  ADD_WEIGHTED(-1, 0, 0);
+  ADD_WEIGHTED(0, 0, 0);
+  ADD_WEIGHTED(1, 0, 0);
+  ADD_WEIGHTED(-1, 1, 0);
+  ADD_WEIGHTED(0, 1, 0);
+  ADD_WEIGHTED(1, 1, 0);
+
+  ADD_WEIGHTED(-1, -1, 1);
+  ADD_WEIGHTED(0, -1, 1);
+  ADD_WEIGHTED(1, -1, 1);
+  ADD_WEIGHTED(-1, 0, 1);
+  ADD_WEIGHTED(0, 0, 1);
+  ADD_WEIGHTED(1, 0, 1);
+  ADD_WEIGHTED(-1, 1, 1);
+  ADD_WEIGHTED(0, 1, 1);
+  ADD_WEIGHTED(1, 1, 1);
+
+  return result;
+}
+
+#define ADD_WEIGHTEDX(x, y, z) \
+  weight = dw[0][(x) + 1] * w[1][(y) + 1] * w[2][(z) + 1]; \
+  result += weight * neighbors[x + 1][y + 1][z + 1];
+
+#define ADD_WEIGHTEDY(x, y, z) \
+  weight = w[0][(x) + 1] * dw[1][(y) + 1] * w[2][(z) + 1]; \
+  result += weight * neighbors[x + 1][y + 1][z + 1];
+
+#define ADD_WEIGHTEDZ(x, y, z) \
+  weight = w[0][(x) + 1] * w[1][(y) + 1] * dw[2][(z) + 1]; \
+  result += weight * neighbors[x + 1][y + 1][z + 1];
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// compute all derivatives in at once
+//////////////////////////////////////////////////////////////////////////////////////////
+inline Vec3 WaveletNoiseField::WNoiseVec(const Vec3 &p, Real *data)
+{
+  Vec3 final(0.);
+  Real w[3][3];
+  Real dw[3][3];
+  Real result = 0;
+  int xC, yC, zC;
+  Real weight;
+
+  int midX = (int)ceil(p[0] - 0.5f);
+  int midY = (int)ceil(p[1] - 0.5f);
+  int midZ = (int)ceil(p[2] - 0.5f);
+
+  Real t0 = midX - (p[0] - 0.5f);
+  Real t1 = midY - (p[1] - 0.5f);
+  Real t2 = midZ - (p[2] - 0.5f);
+
+  // precache all the neighbors for fast access
+  Real neighbors[3][3][3];
+  for (int z = -1; z <= 1; z++)
+    for (int y = -1; y <= 1; y++)
+      for (int x = -1; x <= 1; x++) {
+        xC = modFast128(midX + (x));
+        yC = modFast128(midY + (y));
+        zC = modFast128(midZ + (z));
+        neighbors[x + 1][y + 1][z + 1] =
+            data[zC * NOISE_TILE_SIZE * NOISE_TILE_SIZE + yC * NOISE_TILE_SIZE + xC];
+      }
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // evaluate splines
+  ///////////////////////////////////////////////////////////////////////////////////////
+  dw[0][0] = -t0;
+  dw[0][2] = (1.f - t0);
+  dw[0][1] = 2.0f * t0 - 1.0f;
+
+  dw[1][0] = -t1;
+  dw[1][2] = (1.0f - t1);
+  dw[1][1] = 2.0f * t1 - 1.0f;
+
+  dw[2][0] = -t2;
+  dw[2][2] = (1.0f - t2);
+  dw[2][1] = 2.0f * t2 - 1.0f;
+
+  w[0][0] = t0 * t0 * 0.5f;
+  w[0][2] = (1.f - t0) * (1.f - t0) * 0.5f;
+  w[0][1] = 1.f - w[0][0] - w[0][2];
+
+  w[1][0] = t1 * t1 * 0.5f;
+  w[1][2] = (1.f - t1) * (1.f - t1) * 0.5f;
+  w[1][1] = 1.f - w[1][0] - w[1][2];
+
+  w[2][0] = t2 * t2 * 0.5f;
+  w[2][2] = (1.f - t2) * (1.f - t2) * 0.5f;
+  w[2][1] = 1.f - w[2][0] - w[2][2];
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // x derivative
+  ///////////////////////////////////////////////////////////////////////////////////////
+  result = 0.0f;
+  ADD_WEIGHTEDX(-1, -1, -1);
+  ADD_WEIGHTEDX(0, -1, -1);
+  ADD_WEIGHTEDX(1, -1, -1);
+  ADD_WEIGHTEDX(-1, 0, -1);
+  ADD_WEIGHTEDX(0, 0, -1);
+  ADD_WEIGHTEDX(1, 0, -1);
+  ADD_WEIGHTEDX(-1, 1, -1);
+  ADD_WEIGHTEDX(0, 1, -1);
+  ADD_WEIGHTEDX(1, 1, -1);
+
+  ADD_WEIGHTEDX(-1, -1, 0);
+  ADD_WEIGHTEDX(0, -1, 0);
+  ADD_WEIGHTEDX(1, -1, 0);
+  ADD_WEIGHTEDX(-1, 0, 0);
+  ADD_WEIGHTEDX(0, 0, 0);
+  ADD_WEIGHTEDX(1, 0, 0);
+  ADD_WEIGHTEDX(-1, 1, 0);
+  ADD_WEIGHTEDX(0, 1, 0);
+  ADD_WEIGHTEDX(1, 1, 0);
+
+  ADD_WEIGHTEDX(-1, -1, 1);
+  ADD_WEIGHTEDX(0, -1, 1);
+  ADD_WEIGHTEDX(1, -1, 1);
+  ADD_WEIGHTEDX(-1, 0, 1);
+  ADD_WEIGHTEDX(0, 0, 1);
+  ADD_WEIGHTEDX(1, 0, 1);
+  ADD_WEIGHTEDX(-1, 1, 1);
+  ADD_WEIGHTEDX(0, 1, 1);
+  ADD_WEIGHTEDX(1, 1, 1);
+  final[0] = result;
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // y derivative
+  ///////////////////////////////////////////////////////////////////////////////////////
+  result = 0.0f;
+  ADD_WEIGHTEDY(-1, -1, -1);
+  ADD_WEIGHTEDY(0, -1, -1);
+  ADD_WEIGHTEDY(1, -1, -1);
+  ADD_WEIGHTEDY(-1, 0, -1);
+  ADD_WEIGHTEDY(0, 0, -1);
+  ADD_WEIGHTEDY(1, 0, -1);
+  ADD_WEIGHTEDY(-1, 1, -1);
+  ADD_WEIGHTEDY(0, 1, -1);
+  ADD_WEIGHTEDY(1, 1, -1);
+
+  ADD_WEIGHTEDY(-1, -1, 0);
+  ADD_WEIGHTEDY(0, -1, 0);
+  ADD_WEIGHTEDY(1, -1, 0);
+  ADD_WEIGHTEDY(-1, 0, 0);
+  ADD_WEIGHTEDY(0, 0, 0);
+  ADD_WEIGHTEDY(1, 0, 0);
+  ADD_WEIGHTEDY(-1, 1, 0);
+  ADD_WEIGHTEDY(0, 1, 0);
+  ADD_WEIGHTEDY(1, 1, 0);
+
+  ADD_WEIGHTEDY(-1, -1, 1);
+  ADD_WEIGHTEDY(0, -1, 1);
+  ADD_WEIGHTEDY(1, -1, 1);
+  ADD_WEIGHTEDY(-1, 0, 1);
+  ADD_WEIGHTEDY(0, 0, 1);
+  ADD_WEIGHTEDY(1, 0, 1);
+  ADD_WEIGHTEDY(-1, 1, 1);
+  ADD_WEIGHTEDY(0, 1, 1);
+  ADD_WEIGHTEDY(1, 1, 1);
+  final[1] = result;
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // z derivative
+  ///////////////////////////////////////////////////////////////////////////////////////
+  result = 0.0f;
+  ADD_WEIGHTEDZ(-1, -1, -1);
+  ADD_WEIGHTEDZ(0, -1, -1);
+  ADD_WEIGHTEDZ(1, -1, -1);
+  ADD_WEIGHTEDZ(-1, 0, -1);
+  ADD_WEIGHTEDZ(0, 0, -1);
+  ADD_WEIGHTEDZ(1, 0, -1);
+  ADD_WEIGHTEDZ(-1, 1, -1);
+  ADD_WEIGHTEDZ(0, 1, -1);
+  ADD_WEIGHTEDZ(1, 1, -1);
+
+  ADD_WEIGHTEDZ(-1, -1, 0);
+  ADD_WEIGHTEDZ(0, -1, 0);
+  ADD_WEIGHTEDZ(1, -1, 0);
+  ADD_WEIGHTEDZ(-1, 0, 0);
+  ADD_WEIGHTEDZ(0, 0, 0);
+  ADD_WEIGHTEDZ(1, 0, 0);
+  ADD_WEIGHTEDZ(-1, 1, 0);
+  ADD_WEIGHTEDZ(0, 1, 0);
+  ADD_WEIGHTEDZ(1, 1, 0);
+
+  ADD_WEIGHTEDZ(-1, -1, 1);
+  ADD_WEIGHTEDZ(0, -1, 1);
+  ADD_WEIGHTEDZ(1, -1, 1);
+  ADD_WEIGHTEDZ(-1, 0, 1);
+  ADD_WEIGHTEDZ(0, 0, 1);
+  ADD_WEIGHTEDZ(1, 0, 1);
+  ADD_WEIGHTEDZ(-1, 1, 1);
+  ADD_WEIGHTEDZ(0, 1, 1);
+  ADD_WEIGHTEDZ(1, 1, 1);
+  final[2] = result;
+
+  // debMsg("FINAL","at "<<p<<" = "<<final); // DEBUG
+  return final;
+}
+#undef ADD_WEIGHTEDX
+#undef ADD_WEIGHTEDY
+#undef ADD_WEIGHTEDZ
+
+inline Real WaveletNoiseField::evaluate(Vec3 pos, int tile) const
+{
+  pos[0] *= mGsInvX;
+  pos[1] *= mGsInvY;
+  pos[2] *= mGsInvZ;
+  pos += mSeedOffset;
+
+  // time anim
+  pos += Vec3(getTime());
+
+  pos[0] *= mPosScale[0];
+  pos[1] *= mPosScale[1];
+  pos[2] *= mPosScale[2];
+  pos += mPosOffset;
+
+  const int n3 = square(NOISE_TILE_SIZE) * NOISE_TILE_SIZE;
+  Real v = WNoise(pos, &mNoiseTile[tile * n3]);
+
+  v += mValOffset;
+  v *= mValScale;
+  if (mClamp) {
+    if (v < mClampNeg)
+      v = mClampNeg;
+    if (v > mClampPos)
+      v = mClampPos;
+  }
+  return v;
+}
+
+inline Vec3 WaveletNoiseField::evaluateVec(Vec3 pos, int tile) const
+{
+  pos[0] *= mGsInvX;
+  pos[1] *= mGsInvY;
+  pos[2] *= mGsInvZ;
+  pos += mSeedOffset;
+
+  // time anim
+  pos += Vec3(getTime());
+
+  pos[0] *= mPosScale[0];
+  pos[1] *= mPosScale[1];
+  pos[2] *= mPosScale[2];
+  pos += mPosOffset;
+
+  const int n3 = square(NOISE_TILE_SIZE) * NOISE_TILE_SIZE;
+  Vec3 v = WNoiseVec(pos, &mNoiseTile[tile * n3]);
+
+  v += Vec3(mValOffset);
+  v *= mValScale;
+
+  if (mClamp) {
+    for (int i = 0; i < 3; i++) {
+      if (v[i] < mClampNeg)
+        v[i] = mClampNeg;
+      if (v[i] > mClampPos)
+        v[i] = mClampPos;
+    }
+  }
+  return v;
+}
+
+inline Vec3 WaveletNoiseField::evaluateCurl(Vec3 pos) const
+{
+  // gradients of w0-w2
+  Vec3 d0 = evaluateVec(pos, 0), d1 = evaluateVec(pos, 1), d2 = evaluateVec(pos, 2);
+
+  return Vec3(d0.y - d1.z, d2.z - d0.x, d1.x - d2.y);
+}
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/noisefield.h.reg.cpp b/extern/mantaflow/preprocessed/noisefield.h.reg.cpp
new file mode 100644
index 00000000000..f4967abcb43
--- /dev/null
+++ b/extern/mantaflow/preprocessed/noisefield.h.reg.cpp
@@ -0,0 +1,60 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "noisefield.h"
+namespace Manta {
+#ifdef _C_WaveletNoiseField
+static const Pb::Register _R_13("WaveletNoiseField", "NoiseField", "PbClass");
+template<> const char *Namify<WaveletNoiseField>::S = "WaveletNoiseField";
+static const Pb::Register _R_14("WaveletNoiseField", "WaveletNoiseField", WaveletNoiseField::_W_0);
+static const Pb::Register _R_15("WaveletNoiseField",
+                                "posOffset",
+                                WaveletNoiseField::_GET_mPosOffset,
+                                WaveletNoiseField::_SET_mPosOffset);
+static const Pb::Register _R_16("WaveletNoiseField",
+                                "posScale",
+                                WaveletNoiseField::_GET_mPosScale,
+                                WaveletNoiseField::_SET_mPosScale);
+static const Pb::Register _R_17("WaveletNoiseField",
+                                "valOffset",
+                                WaveletNoiseField::_GET_mValOffset,
+                                WaveletNoiseField::_SET_mValOffset);
+static const Pb::Register _R_18("WaveletNoiseField",
+                                "valScale",
+                                WaveletNoiseField::_GET_mValScale,
+                                WaveletNoiseField::_SET_mValScale);
+static const Pb::Register _R_19("WaveletNoiseField",
+                                "clamp",
+                                WaveletNoiseField::_GET_mClamp,
+                                WaveletNoiseField::_SET_mClamp);
+static const Pb::Register _R_20("WaveletNoiseField",
+                                "clampNeg",
+                                WaveletNoiseField::_GET_mClampNeg,
+                                WaveletNoiseField::_SET_mClampNeg);
+static const Pb::Register _R_21("WaveletNoiseField",
+                                "clampPos",
+                                WaveletNoiseField::_GET_mClampPos,
+                                WaveletNoiseField::_SET_mClampPos);
+static const Pb::Register _R_22("WaveletNoiseField",
+                                "timeAnim",
+                                WaveletNoiseField::_GET_mTimeAnim,
+                                WaveletNoiseField::_SET_mTimeAnim);
+#endif
+extern "C" {
+void PbRegister_file_13()
+{
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/particle.cpp b/extern/mantaflow/preprocessed/particle.cpp
new file mode 100644
index 00000000000..478f1417109
--- /dev/null
+++ b/extern/mantaflow/preprocessed/particle.cpp
@@ -0,0 +1,1620 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2013 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Particle data functionality
+ *
+ ******************************************************************************/
+
+#include <fstream>
+#include <cstring>
+#if NO_ZLIB != 1
+#  include <zlib.h>
+#endif
+#include "particle.h"
+#include "levelset.h"
+#include "mantaio.h"
+
+using namespace std;
+namespace Manta {
+
+ParticleBase::ParticleBase(FluidSolver *parent)
+    : PbClass(parent), mAllowCompress(true), mFreePdata(false)
+{
+}
+
+ParticleBase::~ParticleBase()
+{
+  // make sure data fields now parent system is deleted
+  for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
+    mPartData[i]->setParticleSys(NULL);
+
+  if (mFreePdata) {
+    for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
+      delete mPartData[i];
+  }
+}
+
+std::string ParticleBase::infoString() const
+{
+  return "ParticleSystem " + mName + " <no info>";
+}
+
+void ParticleBase::cloneParticleData(ParticleBase *nm)
+{
+  // clone additional data , and make sure the copied particle system deletes it
+  nm->mFreePdata = true;
+  for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i) {
+    ParticleDataBase *pdata = mPartData[i]->clone();
+    nm->registerPdata(pdata);
+  }
+}
+
+void ParticleBase::deregister(ParticleDataBase *pdata)
+{
+  bool done = false;
+  // remove pointer from particle data list
+  for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i) {
+    if (mPartData[i] == pdata) {
+      if (i < (IndexInt)mPartData.size() - 1)
+        mPartData[i] = mPartData[mPartData.size() - 1];
+      mPartData.pop_back();
+      done = true;
+    }
+  }
+  if (!done)
+    errMsg("Invalid pointer given, not registered!");
+}
+
+// create and attach a new pdata field to this particle system
+PbClass *ParticleBase::create(PbType t, PbTypeVec T, const string &name)
+{
+#if NOPYTHON != 1
+  _args.add("nocheck", true);
+  if (t.str() == "")
+    errMsg("Specify particle data type to create");
+  // debMsg( "Pdata creating '"<< t.str <<" with size "<< this->getSizeSlow(), 5 );
+
+  PbClass *pyObj = PbClass::createPyObject(t.str() + T.str(), name, _args, this->getParent());
+
+  ParticleDataBase *pdata = dynamic_cast<ParticleDataBase *>(pyObj);
+  if (!pdata) {
+    errMsg(
+        "Unable to get particle data pointer from newly created object. Only create ParticleData "
+        "type with a ParticleSys.creat() call, eg, PdataReal, PdataVec3 etc.");
+    delete pyObj;
+    return NULL;
+  }
+  else {
+    this->registerPdata(pdata);
+  }
+
+  // directly init size of new pdata field:
+  pdata->resize(this->getSizeSlow());
+#else
+  PbClass *pyObj = NULL;
+#endif
+  return pyObj;
+}
+
+void ParticleBase::registerPdata(ParticleDataBase *pdata)
+{
+  pdata->setParticleSys(this);
+  mPartData.push_back(pdata);
+
+  if (pdata->getType() == ParticleDataBase::TypeReal) {
+    ParticleDataImpl<Real> *pd = dynamic_cast<ParticleDataImpl<Real> *>(pdata);
+    if (!pd)
+      errMsg("Invalid pdata object posing as real!");
+    this->registerPdataReal(pd);
+  }
+  else if (pdata->getType() == ParticleDataBase::TypeInt) {
+    ParticleDataImpl<int> *pd = dynamic_cast<ParticleDataImpl<int> *>(pdata);
+    if (!pd)
+      errMsg("Invalid pdata object posing as int!");
+    this->registerPdataInt(pd);
+  }
+  else if (pdata->getType() == ParticleDataBase::TypeVec3) {
+    ParticleDataImpl<Vec3> *pd = dynamic_cast<ParticleDataImpl<Vec3> *>(pdata);
+    if (!pd)
+      errMsg("Invalid pdata object posing as vec3!");
+    this->registerPdataVec3(pd);
+  }
+}
+void ParticleBase::registerPdataReal(ParticleDataImpl<Real> *pd)
+{
+  mPdataReal.push_back(pd);
+}
+void ParticleBase::registerPdataVec3(ParticleDataImpl<Vec3> *pd)
+{
+  mPdataVec3.push_back(pd);
+}
+void ParticleBase::registerPdataInt(ParticleDataImpl<int> *pd)
+{
+  mPdataInt.push_back(pd);
+}
+
+void ParticleBase::addAllPdata()
+{
+  for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i) {
+    mPartData[i]->addEntry();
+  }
+}
+
+BasicParticleSystem::BasicParticleSystem(FluidSolver *parent)
+    : ParticleSystem<BasicParticleData>(parent)
+{
+  this->mAllowCompress = false;
+}
+
+// file io
+
+void BasicParticleSystem::writeParticlesText(const string name) const
+{
+  ofstream ofs(name.c_str());
+  if (!ofs.good())
+    errMsg("can't open file!");
+  ofs << this->size() << ", pdata: " << mPartData.size() << " (" << mPdataInt.size() << ","
+      << mPdataReal.size() << "," << mPdataVec3.size() << ") \n";
+  for (IndexInt i = 0; i < this->size(); ++i) {
+    ofs << i << ": " << this->getPos(i) << " , " << this->getStatus(i) << ". ";
+    for (IndexInt pd = 0; pd < (IndexInt)mPdataInt.size(); ++pd)
+      ofs << mPdataInt[pd]->get(i) << " ";
+    for (IndexInt pd = 0; pd < (IndexInt)mPdataReal.size(); ++pd)
+      ofs << mPdataReal[pd]->get(i) << " ";
+    for (IndexInt pd = 0; pd < (IndexInt)mPdataVec3.size(); ++pd)
+      ofs << mPdataVec3[pd]->get(i) << " ";
+    ofs << "\n";
+  }
+  ofs.close();
+}
+
+void BasicParticleSystem::writeParticlesRawPositionsGz(const string name) const
+{
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "wb1");
+  if (!gzf)
+    errMsg("can't open file " << name);
+  for (IndexInt i = 0; i < this->size(); ++i) {
+    Vector3D<float> p = toVec3f(this->getPos(i));
+    gzwrite(gzf, &p, sizeof(float) * 3);
+  }
+  gzclose(gzf);
+#else
+  cout << "file format not supported without zlib" << endl;
+#endif
+}
+
+void BasicParticleSystem::writeParticlesRawVelocityGz(const string name) const
+{
+#if NO_ZLIB != 1
+  gzFile gzf = gzopen(name.c_str(), "wb1");
+  if (!gzf)
+    errMsg("can't open file " << name);
+  if (mPdataVec3.size() < 1)
+    errMsg("no vec3 particle data channel found!");
+  // note , assuming particle data vec3 0 is velocity! make optional...
+  for (IndexInt i = 0; i < this->size(); ++i) {
+    Vector3D<float> p = toVec3f(mPdataVec3[0]->get(i));
+    gzwrite(gzf, &p, sizeof(float) * 3);
+  }
+  gzclose(gzf);
+#else
+  cout << "file format not supported without zlib" << endl;
+#endif
+}
+
+void BasicParticleSystem::load(const string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    readParticlesUni(name, this);
+  else if (ext == ".raw")  // raw = uni for now
+    readParticlesUni(name, this);
+  else
+    errMsg("particle '" + name + "' filetype not supported for loading");
+}
+
+void BasicParticleSystem::save(const string name) const
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".txt")
+    this->writeParticlesText(name);
+  else if (ext == ".uni")
+    writeParticlesUni(name, this);
+  else if (ext == ".raw")  // raw = uni for now
+    writeParticlesUni(name, this);
+  // raw data formats, very basic for simple data transfer to other programs
+  else if (ext == ".posgz")
+    this->writeParticlesRawPositionsGz(name);
+  else if (ext == ".velgz")
+    this->writeParticlesRawVelocityGz(name);
+  else
+    errMsg("particle '" + name + "' filetype not supported for saving");
+}
+
+void BasicParticleSystem::printParts(IndexInt start, IndexInt stop, bool printIndex)
+{
+  std::ostringstream sstr;
+  IndexInt s = (start > 0 ? start : 0);
+  IndexInt e = (stop > 0 ? stop : (IndexInt)mData.size());
+  s = Manta::clamp(s, (IndexInt)0, (IndexInt)mData.size());
+  e = Manta::clamp(e, (IndexInt)0, (IndexInt)mData.size());
+
+  for (IndexInt i = s; i < e; ++i) {
+    if (printIndex)
+      sstr << i << ": ";
+    sstr << mData[i].pos << " " << mData[i].flag << "\n";
+  }
+  debMsg(sstr.str(), 1);
+}
+
+std::string BasicParticleSystem::getDataPointer()
+{
+  std::ostringstream out;
+  out << &mData;
+  return out.str();
+}
+
+void BasicParticleSystem::readParticles(BasicParticleSystem *from)
+{
+  // re-allocate all data
+  this->resizeAll(from->size());
+  assertMsg(from->size() == this->size(), "particle size doesn't match");
+
+  for (int i = 0; i < this->size(); ++i) {
+    (*this)[i].pos = (*from)[i].pos;
+    (*this)[i].flag = (*from)[i].flag;
+  }
+  this->transformPositions(from->getParent()->getGridSize(), this->getParent()->getGridSize());
+}
+
+// particle data
+
+ParticleDataBase::ParticleDataBase(FluidSolver *parent) : PbClass(parent), mpParticleSys(NULL)
+{
+}
+
+ParticleDataBase::~ParticleDataBase()
+{
+  // notify parent of deletion
+  if (mpParticleSys)
+    mpParticleSys->deregister(this);
+}
+
+// actual data implementation
+
+template<class T>
+ParticleDataImpl<T>::ParticleDataImpl(FluidSolver *parent)
+    : ParticleDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+{
+}
+
+template<class T>
+ParticleDataImpl<T>::ParticleDataImpl(FluidSolver *parent, ParticleDataImpl<T> *other)
+    : ParticleDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
+{
+  this->mData = other->mData;
+  setName(other->getName());
+}
+
+template<class T> ParticleDataImpl<T>::~ParticleDataImpl()
+{
+}
+
+template<class T> IndexInt ParticleDataImpl<T>::getSizeSlow() const
+{
+  return mData.size();
+}
+template<class T> void ParticleDataImpl<T>::addEntry()
+{
+  // add zero'ed entry
+  T tmp = T(0.);
+  // for debugging, force init:
+  // tmp = T(0.02 * mData.size()); // increasing
+  // tmp = T(1.); // constant 1
+  return mData.push_back(tmp);
+}
+template<class T> void ParticleDataImpl<T>::resize(IndexInt s)
+{
+  mData.resize(s);
+}
+template<class T> void ParticleDataImpl<T>::copyValueSlow(IndexInt from, IndexInt to)
+{
+  this->copyValue(from, to);
+}
+template<class T> ParticleDataBase *ParticleDataImpl<T>::clone()
+{
+  ParticleDataImpl<T> *npd = new ParticleDataImpl<T>(getParent(), this);
+  return npd;
+}
+
+template<class T> void ParticleDataImpl<T>::setSource(Grid<T> *grid, bool isMAC)
+{
+  mpGridSource = grid;
+  mGridSourceMAC = isMAC;
+  if (isMAC)
+    assertMsg(dynamic_cast<MACGrid *>(grid) != NULL, "Given grid is not a valid MAC grid");
+}
+
+template<class T> void ParticleDataImpl<T>::initNewValue(IndexInt idx, Vec3 pos)
+{
+  if (!mpGridSource)
+    mData[idx] = 0;
+  else {
+    mData[idx] = mpGridSource->getInterpolated(pos);
+  }
+}
+// special handling needed for velocities
+template<> void ParticleDataImpl<Vec3>::initNewValue(IndexInt idx, Vec3 pos)
+{
+  if (!mpGridSource)
+    mData[idx] = 0;
+  else {
+    if (!mGridSourceMAC)
+      mData[idx] = mpGridSource->getInterpolated(pos);
+    else
+      mData[idx] = ((MACGrid *)mpGridSource)->getInterpolated(pos);
+  }
+}
+
+template<typename T> void ParticleDataImpl<T>::load(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    readPdataUni<T>(name, this);
+  else if (ext == ".raw")  // raw = uni for now
+    readPdataUni<T>(name, this);
+  else
+    errMsg("particle data '" + name + "' filetype not supported for loading");
+}
+
+template<typename T> void ParticleDataImpl<T>::save(string name)
+{
+  if (name.find_last_of('.') == string::npos)
+    errMsg("file '" + name + "' does not have an extension");
+  string ext = name.substr(name.find_last_of('.'));
+  if (ext == ".uni")
+    writePdataUni<T>(name, this);
+  else if (ext == ".raw")  // raw = uni for now
+    writePdataUni<T>(name, this);
+  else
+    errMsg("particle data '" + name + "' filetype not supported for saving");
+}
+
+// specializations
+
+template<> ParticleDataBase::PdataType ParticleDataImpl<Real>::getType() const
+{
+  return ParticleDataBase::TypeReal;
+}
+template<> ParticleDataBase::PdataType ParticleDataImpl<int>::getType() const
+{
+  return ParticleDataBase::TypeInt;
+}
+template<> ParticleDataBase::PdataType ParticleDataImpl<Vec3>::getType() const
+{
+  return ParticleDataBase::TypeVec3;
+}
+
+// note, we need a flag value for functions such as advection
+// ideally, this value should never be modified
+int ParticleIndexData::flag = 0;
+Vec3 ParticleIndexData::pos = Vec3(0., 0., 0.);
+
+template<class T, class S> struct knPdataAdd : public KernelBase {
+  knPdataAdd(ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other) const
+  {
+    me[idx] += other[idx];
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef ParticleDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataAdd ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const ParticleDataImpl<S> &other;
+};
+template<class T, class S> struct knPdataSub : public KernelBase {
+  knPdataSub(ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other) const
+  {
+    me[idx] -= other[idx];
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef ParticleDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataSub ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const ParticleDataImpl<S> &other;
+};
+template<class T, class S> struct knPdataMult : public KernelBase {
+  knPdataMult(ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other) const
+  {
+    me[idx] *= other[idx];
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef ParticleDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataMult ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const ParticleDataImpl<S> &other;
+};
+template<class T, class S> struct knPdataDiv : public KernelBase {
+  knPdataDiv(ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const ParticleDataImpl<S> &other) const
+  {
+    me[idx] /= other[idx];
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<S> &getArg1()
+  {
+    return other;
+  }
+  typedef ParticleDataImpl<S> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataDiv ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const ParticleDataImpl<S> &other;
+};
+template<class T> struct knPdataSafeDiv : public KernelBase {
+  knPdataSafeDiv(ParticleDataImpl<T> &me, const ParticleDataImpl<T> &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const ParticleDataImpl<T> &other) const
+  {
+    me[idx] = safeDivide(me[idx], other[idx]);
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<T> &getArg1()
+  {
+    return other;
+  }
+  typedef ParticleDataImpl<T> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataSafeDiv ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const ParticleDataImpl<T> &other;
+};
+
+template<class T, class S> struct knPdataSetScalar : public KernelBase {
+  knPdataSetScalar(ParticleDataImpl<T> &me, const S &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const S &other) const
+  {
+    me[idx] = other;
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataSetScalar ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const S &other;
+};
+template<class T, class S> struct knPdataAddScalar : public KernelBase {
+  knPdataAddScalar(ParticleDataImpl<T> &me, const S &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const S &other) const
+  {
+    me[idx] += other;
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataAddScalar ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const S &other;
+};
+template<class T, class S> struct knPdataMultScalar : public KernelBase {
+  knPdataMultScalar(ParticleDataImpl<T> &me, const S &other)
+      : KernelBase(me.size()), me(me), other(other)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const S &other) const
+  {
+    me[idx] *= other;
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataMultScalar ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const S &other;
+};
+template<class T, class S> struct knPdataScaledAdd : public KernelBase {
+  knPdataScaledAdd(ParticleDataImpl<T> &me, const ParticleDataImpl<T> &other, const S &factor)
+      : KernelBase(me.size()), me(me), other(other), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ParticleDataImpl<T> &me,
+                 const ParticleDataImpl<T> &other,
+                 const S &factor) const
+  {
+    me[idx] += factor * other[idx];
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<T> &getArg1()
+  {
+    return other;
+  }
+  typedef ParticleDataImpl<T> type1;
+  inline const S &getArg2()
+  {
+    return factor;
+  }
+  typedef S type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataScaledAdd ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, factor);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const ParticleDataImpl<T> &other;
+  const S &factor;
+};
+
+template<class T> struct knPdataClamp : public KernelBase {
+  knPdataClamp(ParticleDataImpl<T> &me, const T vmin, const T vmax)
+      : KernelBase(me.size()), me(me), vmin(vmin), vmax(vmax)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const T vmin, const T vmax) const
+  {
+    me[idx] = clamp(me[idx], vmin, vmax);
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const T &getArg1()
+  {
+    return vmin;
+  }
+  typedef T type1;
+  inline const T &getArg2()
+  {
+    return vmax;
+  }
+  typedef T type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataClamp ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmin, vmax);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const T vmin;
+  const T vmax;
+};
+template<class T> struct knPdataClampMin : public KernelBase {
+  knPdataClampMin(ParticleDataImpl<T> &me, const T vmin)
+      : KernelBase(me.size()), me(me), vmin(vmin)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const T vmin) const
+  {
+    me[idx] = std::max(vmin, me[idx]);
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const T &getArg1()
+  {
+    return vmin;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataClampMin ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmin);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const T vmin;
+};
+template<class T> struct knPdataClampMax : public KernelBase {
+  knPdataClampMax(ParticleDataImpl<T> &me, const T vmax)
+      : KernelBase(me.size()), me(me), vmax(vmax)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<T> &me, const T vmax) const
+  {
+    me[idx] = std::min(vmax, me[idx]);
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const T &getArg1()
+  {
+    return vmax;
+  }
+  typedef T type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataClampMax ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmax);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const T vmax;
+};
+
+struct knPdataClampMinVec3 : public KernelBase {
+  knPdataClampMinVec3(ParticleDataImpl<Vec3> &me, const Real vmin)
+      : KernelBase(me.size()), me(me), vmin(vmin)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<Vec3> &me, const Real vmin) const
+  {
+    me[idx].x = std::max(vmin, me[idx].x);
+    me[idx].y = std::max(vmin, me[idx].y);
+    me[idx].z = std::max(vmin, me[idx].z);
+  }
+  inline ParticleDataImpl<Vec3> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<Vec3> type0;
+  inline const Real &getArg1()
+  {
+    return vmin;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataClampMinVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmin);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<Vec3> &me;
+  const Real vmin;
+};
+
+struct knPdataClampMaxVec3 : public KernelBase {
+  knPdataClampMaxVec3(ParticleDataImpl<Vec3> &me, const Real vmax)
+      : KernelBase(me.size()), me(me), vmax(vmax)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleDataImpl<Vec3> &me, const Real vmax) const
+  {
+    me[idx].x = std::min(vmax, me[idx].x);
+    me[idx].y = std::min(vmax, me[idx].y);
+    me[idx].z = std::min(vmax, me[idx].z);
+  }
+  inline ParticleDataImpl<Vec3> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<Vec3> type0;
+  inline const Real &getArg1()
+  {
+    return vmax;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataClampMaxVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, vmax);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<Vec3> &me;
+  const Real vmax;
+};
+
+// python operators
+
+template<typename T>
+ParticleDataImpl<T> &ParticleDataImpl<T>::copyFrom(const ParticleDataImpl<T> &a)
+{
+  assertMsg(a.mData.size() == mData.size(),
+            "different pdata size " << a.mData.size() << " vs " << this->mData.size());
+  mData = a.mData;
+  return *this;
+}
+
+template<typename T> void ParticleDataImpl<T>::setConst(const T &s)
+{
+  knPdataSetScalar<T, T> op(*this, s);
+}
+
+template<typename T>
+void ParticleDataImpl<T>::setConstRange(const T &s, const int begin, const int end)
+{
+  for (int i = begin; i < end; ++i)
+    (*this)[i] = s;
+}
+
+// special set by flag
+
+template<class T, class S> struct knPdataSetScalarIntFlag : public KernelBase {
+  knPdataSetScalarIntFlag(ParticleDataImpl<T> &me,
+                          const S &other,
+                          const ParticleDataImpl<int> &t,
+                          const int itype)
+      : KernelBase(me.size()), me(me), other(other), t(t), itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ParticleDataImpl<T> &me,
+                 const S &other,
+                 const ParticleDataImpl<int> &t,
+                 const int itype) const
+  {
+    if (t[idx] & itype)
+      me[idx] = other;
+  }
+  inline ParticleDataImpl<T> &getArg0()
+  {
+    return me;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const S &getArg1()
+  {
+    return other;
+  }
+  typedef S type1;
+  inline const ParticleDataImpl<int> &getArg2()
+  {
+    return t;
+  }
+  typedef ParticleDataImpl<int> type2;
+  inline const int &getArg3()
+  {
+    return itype;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPdataSetScalarIntFlag ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, t, itype);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<T> &me;
+  const S &other;
+  const ParticleDataImpl<int> &t;
+  const int itype;
+};
+template<typename T>
+void ParticleDataImpl<T>::setConstIntFlag(const T &s,
+                                          const ParticleDataImpl<int> &t,
+                                          const int itype)
+{
+  knPdataSetScalarIntFlag<T, T> op(*this, s, t, itype);
+}
+
+template<typename T> void ParticleDataImpl<T>::add(const ParticleDataImpl<T> &a)
+{
+  knPdataAdd<T, T> op(*this, a);
+}
+template<typename T> void ParticleDataImpl<T>::sub(const ParticleDataImpl<T> &a)
+{
+  knPdataSub<T, T> op(*this, a);
+}
+
+template<typename T> void ParticleDataImpl<T>::addConst(const T &s)
+{
+  knPdataAddScalar<T, T> op(*this, s);
+}
+
+template<typename T>
+void ParticleDataImpl<T>::addScaled(const ParticleDataImpl<T> &a, const T &factor)
+{
+  knPdataScaledAdd<T, T> op(*this, a, factor);
+}
+
+template<typename T> void ParticleDataImpl<T>::mult(const ParticleDataImpl<T> &a)
+{
+  knPdataMult<T, T> op(*this, a);
+}
+
+template<typename T> void ParticleDataImpl<T>::safeDiv(const ParticleDataImpl<T> &a)
+{
+  knPdataSafeDiv<T> op(*this, a);
+}
+
+template<typename T> void ParticleDataImpl<T>::multConst(const T &s)
+{
+  knPdataMultScalar<T, T> op(*this, s);
+}
+
+template<typename T> void ParticleDataImpl<T>::clamp(const Real vmin, const Real vmax)
+{
+  knPdataClamp<T> op(*this, vmin, vmax);
+}
+
+template<typename T> void ParticleDataImpl<T>::clampMin(const Real vmin)
+{
+  knPdataClampMin<T> op(*this, vmin);
+}
+template<typename T> void ParticleDataImpl<T>::clampMax(const Real vmax)
+{
+  knPdataClampMax<T> op(*this, vmax);
+}
+
+template<> void ParticleDataImpl<Vec3>::clampMin(const Real vmin)
+{
+  knPdataClampMinVec3 op(*this, vmin);
+}
+template<> void ParticleDataImpl<Vec3>::clampMax(const Real vmax)
+{
+  knPdataClampMaxVec3 op(*this, vmax);
+}
+
+template<typename T> struct KnPtsSum : public KernelBase {
+  KnPtsSum(const ParticleDataImpl<T> &val, const ParticleDataImpl<int> *t, const int itype)
+      : KernelBase(val.size()), val(val), t(t), itype(itype), result(T(0.))
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const ParticleDataImpl<T> &val,
+                 const ParticleDataImpl<int> *t,
+                 const int itype,
+                 T &result)
+  {
+    if (t && !((*t)[idx] & itype))
+      return;
+    result += val[idx];
+  }
+  inline operator T()
+  {
+    return result;
+  }
+  inline T &getRet()
+  {
+    return result;
+  }
+  inline const ParticleDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<T> type0;
+  inline const ParticleDataImpl<int> *getArg1()
+  {
+    return t;
+  }
+  typedef ParticleDataImpl<int> type1;
+  inline const int &getArg2()
+  {
+    return itype;
+  }
+  typedef int type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnPtsSum ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, t, itype, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  KnPtsSum(KnPtsSum &o, tbb::split)
+      : KernelBase(o), val(o.val), t(o.t), itype(o.itype), result(T(0.))
+  {
+  }
+  void join(const KnPtsSum &o)
+  {
+    result += o.result;
+  }
+  const ParticleDataImpl<T> &val;
+  const ParticleDataImpl<int> *t;
+  const int itype;
+  T result;
+};
+template<typename T> struct KnPtsSumSquare : public KernelBase {
+  KnPtsSumSquare(const ParticleDataImpl<T> &val) : KernelBase(val.size()), val(val), result(0.)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const ParticleDataImpl<T> &val, Real &result)
+  {
+    result += normSquare(val[idx]);
+  }
+  inline operator Real()
+  {
+    return result;
+  }
+  inline Real &getRet()
+  {
+    return result;
+  }
+  inline const ParticleDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnPtsSumSquare ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  KnPtsSumSquare(KnPtsSumSquare &o, tbb::split) : KernelBase(o), val(o.val), result(0.)
+  {
+  }
+  void join(const KnPtsSumSquare &o)
+  {
+    result += o.result;
+  }
+  const ParticleDataImpl<T> &val;
+  Real result;
+};
+template<typename T> struct KnPtsSumMagnitude : public KernelBase {
+  KnPtsSumMagnitude(const ParticleDataImpl<T> &val) : KernelBase(val.size()), val(val), result(0.)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const ParticleDataImpl<T> &val, Real &result)
+  {
+    result += norm(val[idx]);
+  }
+  inline operator Real()
+  {
+    return result;
+  }
+  inline Real &getRet()
+  {
+    return result;
+  }
+  inline const ParticleDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnPtsSumMagnitude ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, result);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  KnPtsSumMagnitude(KnPtsSumMagnitude &o, tbb::split) : KernelBase(o), val(o.val), result(0.)
+  {
+  }
+  void join(const KnPtsSumMagnitude &o)
+  {
+    result += o.result;
+  }
+  const ParticleDataImpl<T> &val;
+  Real result;
+};
+
+template<typename T>
+T ParticleDataImpl<T>::sum(const ParticleDataImpl<int> *t, const int itype) const
+{
+  return KnPtsSum<T>(*this, t, itype);
+}
+template<typename T> Real ParticleDataImpl<T>::sumSquare() const
+{
+  return KnPtsSumSquare<T>(*this);
+}
+template<typename T> Real ParticleDataImpl<T>::sumMagnitude() const
+{
+  return KnPtsSumMagnitude<T>(*this);
+}
+
+template<typename T>
+
+struct CompPdata_Min : public KernelBase {
+  CompPdata_Min(const ParticleDataImpl<T> &val)
+      : KernelBase(val.size()), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const ParticleDataImpl<T> &val, Real &minVal)
+  {
+    if (val[idx] < minVal)
+      minVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline const ParticleDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompPdata_Min ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompPdata_Min(CompPdata_Min &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompPdata_Min &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const ParticleDataImpl<T> &val;
+  Real minVal;
+};
+
+template<typename T>
+
+struct CompPdata_Max : public KernelBase {
+  CompPdata_Max(const ParticleDataImpl<T> &val)
+      : KernelBase(val.size()), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const ParticleDataImpl<T> &val, Real &maxVal)
+  {
+    if (val[idx] > maxVal)
+      maxVal = val[idx];
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline const ParticleDataImpl<T> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<T> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompPdata_Max ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompPdata_Max(CompPdata_Max &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompPdata_Max &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const ParticleDataImpl<T> &val;
+  Real maxVal;
+};
+
+template<typename T> Real ParticleDataImpl<T>::getMin() const
+{
+  return CompPdata_Min<T>(*this);
+}
+
+template<typename T> Real ParticleDataImpl<T>::getMaxAbs() const
+{
+  Real amin = CompPdata_Min<T>(*this);
+  Real amax = CompPdata_Max<T>(*this);
+  return max(fabs(amin), fabs(amax));
+}
+
+template<typename T> Real ParticleDataImpl<T>::getMax() const
+{
+  return CompPdata_Max<T>(*this);
+}
+
+template<typename T>
+void ParticleDataImpl<T>::printPdata(IndexInt start, IndexInt stop, bool printIndex)
+{
+  std::ostringstream sstr;
+  IndexInt s = (start > 0 ? start : 0);
+  IndexInt e = (stop > 0 ? stop : (IndexInt)mData.size());
+  s = Manta::clamp(s, (IndexInt)0, (IndexInt)mData.size());
+  e = Manta::clamp(e, (IndexInt)0, (IndexInt)mData.size());
+
+  for (IndexInt i = s; i < e; ++i) {
+    if (printIndex)
+      sstr << i << ": ";
+    sstr << mData[i] << " "
+         << "\n";
+  }
+  debMsg(sstr.str(), 1);
+}
+template<class T> std::string ParticleDataImpl<T>::getDataPointer()
+{
+  std::ostringstream out;
+  out << &mData;
+  return out.str();
+}
+
+// specials for vec3
+// work on length values, ie, always positive (in contrast to scalar versions above)
+
+struct CompPdata_MinVec3 : public KernelBase {
+  CompPdata_MinVec3(const ParticleDataImpl<Vec3> &val)
+      : KernelBase(val.size()), val(val), minVal(std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const ParticleDataImpl<Vec3> &val, Real &minVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s < minVal)
+      minVal = s;
+  }
+  inline operator Real()
+  {
+    return minVal;
+  }
+  inline Real &getRet()
+  {
+    return minVal;
+  }
+  inline const ParticleDataImpl<Vec3> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<Vec3> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompPdata_MinVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, minVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompPdata_MinVec3(CompPdata_MinVec3 &o, tbb::split)
+      : KernelBase(o), val(o.val), minVal(std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompPdata_MinVec3 &o)
+  {
+    minVal = min(minVal, o.minVal);
+  }
+  const ParticleDataImpl<Vec3> &val;
+  Real minVal;
+};
+
+struct CompPdata_MaxVec3 : public KernelBase {
+  CompPdata_MaxVec3(const ParticleDataImpl<Vec3> &val)
+      : KernelBase(val.size()), val(val), maxVal(-std::numeric_limits<Real>::max())
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const ParticleDataImpl<Vec3> &val, Real &maxVal)
+  {
+    const Real s = normSquare(val[idx]);
+    if (s > maxVal)
+      maxVal = s;
+  }
+  inline operator Real()
+  {
+    return maxVal;
+  }
+  inline Real &getRet()
+  {
+    return maxVal;
+  }
+  inline const ParticleDataImpl<Vec3> &getArg0()
+  {
+    return val;
+  }
+  typedef ParticleDataImpl<Vec3> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CompPdata_MaxVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, val, maxVal);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CompPdata_MaxVec3(CompPdata_MaxVec3 &o, tbb::split)
+      : KernelBase(o), val(o.val), maxVal(-std::numeric_limits<Real>::max())
+  {
+  }
+  void join(const CompPdata_MaxVec3 &o)
+  {
+    maxVal = max(maxVal, o.maxVal);
+  }
+  const ParticleDataImpl<Vec3> &val;
+  Real maxVal;
+};
+
+template<> Real ParticleDataImpl<Vec3>::getMin() const
+{
+  return sqrt(CompPdata_MinVec3(*this));
+}
+
+template<> Real ParticleDataImpl<Vec3>::getMaxAbs() const
+{
+  return sqrt(CompPdata_MaxVec3(*this));  // no minimum necessary here
+}
+
+template<> Real ParticleDataImpl<Vec3>::getMax() const
+{
+  return sqrt(CompPdata_MaxVec3(*this));
+}
+
+// explicit instantiation
+template class ParticleDataImpl<int>;
+template class ParticleDataImpl<Real>;
+template class ParticleDataImpl<Vec3>;
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/particle.h b/extern/mantaflow/preprocessed/particle.h
new file mode 100644
index 00000000000..2d41397a961
--- /dev/null
+++ b/extern/mantaflow/preprocessed/particle.h
@@ -0,0 +1,2582 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Base class for particle systems
+ *
+ ******************************************************************************/
+
+#ifndef _PARTICLE_H
+#define _PARTICLE_H
+
+#include <vector>
+#include "grid.h"
+#include "vectorbase.h"
+#include "integrator.h"
+#include "randomstream.h"
+namespace Manta {
+
+// fwd decl
+template<class T> class Grid;
+class ParticleDataBase;
+template<class T> class ParticleDataImpl;
+
+//! Baseclass for particle systems. Does not implement any data
+class ParticleBase : public PbClass {
+ public:
+  enum SystemType { BASE = 0, PARTICLE, VORTEX, FILAMENT, FLIP, TURBULENCE, INDEX };
+
+  enum ParticleStatus {
+    PNONE = 0,
+    PNEW = (1 << 0),    // particles newly created in this step
+    PSPRAY = (1 << 1),  // secondary particle types
+    PBUBBLE = (1 << 2),
+    PFOAM = (1 << 3),
+    PTRACER = (1 << 4),
+    PDELETE = (1 << 10),   // mark as deleted, will be deleted in next compress() step
+    PINVALID = (1 << 30),  // unused
+  };
+
+  ParticleBase(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "ParticleBase::ParticleBase", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new ParticleBase(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "ParticleBase::ParticleBase", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleBase::ParticleBase", e.what());
+      return -1;
+    }
+  }
+
+  virtual ~ParticleBase();
+
+  //! copy all the particle data thats registered with the other particle system to this one
+  virtual void cloneParticleData(ParticleBase *nm);
+
+  virtual SystemType getType() const
+  {
+    return BASE;
+  }
+  virtual std::string infoString() const;
+  virtual ParticleBase *clone()
+  {
+    assertMsg(false, "Dont use, override...");
+    return NULL;
+  }
+
+  //! slow virtual function to query size, do not use in kernels! use size() instead
+  virtual IndexInt getSizeSlow() const
+  {
+    assertMsg(false, "Dont use, override...");
+    return 0;
+  }
+
+  //! add a position as potential candidate for new particle (todo, make usable from parallel
+  //! threads)
+  inline void addBuffered(const Vec3 &pos, int flag = 0);
+
+  //! particle data functions
+
+  //! create a particle data object
+  PbClass *create(PbType type, PbTypeVec T = PbTypeVec(), const std::string &name = "");
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleBase *pbo = dynamic_cast<ParticleBase *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleBase::create", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        PbType type = _args.get<PbType>("type", 0, &_lock);
+        PbTypeVec T = _args.getOpt<PbTypeVec>("T", 1, PbTypeVec(), &_lock);
+        const std::string &name = _args.getOpt<std::string>("name", 2, "", &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->create(type, T, name));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleBase::create", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleBase::create", e.what());
+      return 0;
+    }
+  }
+
+  //! add a particle data field, set its parent particle-system pointer
+  void registerPdata(ParticleDataBase *pdata);
+  void registerPdataReal(ParticleDataImpl<Real> *pdata);
+  void registerPdataVec3(ParticleDataImpl<Vec3> *pdata);
+  void registerPdataInt(ParticleDataImpl<int> *pdata);
+  //! remove a particle data entry
+  void deregister(ParticleDataBase *pdata);
+  //! add one zero entry to all data fields
+  void addAllPdata();
+  // note - deletion of pdata is handled in compress function
+
+  //! how many are there?
+  IndexInt getNumPdata() const
+  {
+    return mPartData.size();
+  }
+  //! access one of the fields
+  ParticleDataBase *getPdata(int i)
+  {
+    return mPartData[i];
+  }
+
+ protected:
+  //! new particle candidates
+  std::vector<Vec3> mNewBufferPos;
+  std::vector<int> mNewBufferFlag;
+
+  //! allow automatic compression / resize? disallowed for, eg, flip particle systems
+  bool mAllowCompress;
+
+  //! store particle data , each pointer has its own storage vector of a certain type (int, real,
+  //! vec3)
+  std::vector<ParticleDataBase *> mPartData;
+  //! lists of different types, for fast operations w/o virtual function calls (all calls necessary
+  //! per particle)
+  std::vector<ParticleDataImpl<Real> *> mPdataReal;
+  std::vector<ParticleDataImpl<Vec3> *> mPdataVec3;
+  std::vector<ParticleDataImpl<int> *>
+      mPdataInt;  //! indicate that pdata of this particle system is copied, and needs to be freed
+  bool mFreePdata;
+ public:
+  PbArgs _args;
+}
+#define _C_ParticleBase
+;
+
+//! Main class for particle systems
+/*! Basetype S must at least contain flag, pos fields */
+template<class S> class ParticleSystem : public ParticleBase {
+ public:
+  ParticleSystem(FluidSolver *parent) : ParticleBase(parent), mDeletes(0), mDeleteChunk(0)
+  {
+  }
+  static int _W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "ParticleSystem::ParticleSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new ParticleSystem(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "ParticleSystem::ParticleSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::ParticleSystem", e.what());
+      return -1;
+    }
+  }
+
+  virtual ~ParticleSystem(){};
+
+  virtual SystemType getType() const
+  {
+    return S::getType();
+  };
+
+  //! accessors
+  inline S &operator[](IndexInt idx)
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx];
+  }
+  inline const S &operator[](IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx];
+  }
+  //! return size of container
+  //! note , python binding disabled for now! cannot yet deal with long-long types
+  inline IndexInt size() const
+  {
+    return mData.size();
+  }
+  //! slow virtual function of base class, also returns size
+  virtual IndexInt getSizeSlow() const
+  {
+    return size();
+  }
+  //! note , special call for python, note - doesnt support more than 2b parts!
+  int pySize() const
+  {
+    return (int)mData.size();
+  }
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::pySize", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->pySize());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::pySize", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::pySize", e.what());
+      return 0;
+    }
+  }
+
+  //! query status
+  inline int getStatus(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx].flag;
+  }
+  inline bool isActive(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return (mData[idx].flag & PDELETE) == 0;
+  }
+  inline bool isSpray(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return (mData[idx].flag & PSPRAY);
+  }
+  inline bool isBubble(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return (mData[idx].flag & PBUBBLE);
+  }
+  inline bool isFoam(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return (mData[idx].flag & PFOAM);
+  }
+  inline bool isTracer(IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return (mData[idx].flag & PTRACER);
+  }
+
+  //! update status
+  inline void setStatus(IndexInt idx, const int status)
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    mData[idx].flag = status;
+  }
+
+  //! safe accessor for python
+  void setPos(const IndexInt idx, const Vec3 &pos)
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    mData[idx].pos = pos;
+  }
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::setPos", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const IndexInt idx = _args.get<IndexInt>("idx", 0, &_lock);
+        const Vec3 &pos = _args.get<Vec3>("pos", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setPos(idx, pos);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::setPos", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::setPos", e.what());
+      return 0;
+    }
+  }
+
+  const Vec3 &getPos(const IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx].pos;
+  }
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::getPos", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const IndexInt idx = _args.get<IndexInt>("idx", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getPos(idx));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::getPos", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::getPos", e.what());
+      return 0;
+    }
+  }
+
+  //! copy all positions into pdata vec3 field
+  void getPosPdata(ParticleDataImpl<Vec3> &target) const;
+  static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::getPosPdata", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        ParticleDataImpl<Vec3> &target = *_args.getPtr<ParticleDataImpl<Vec3>>(
+            "target", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->getPosPdata(target);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::getPosPdata", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::getPosPdata", e.what());
+      return 0;
+    }
+  }
+
+  void setPosPdata(const ParticleDataImpl<Vec3> &source);
+  static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::setPosPdata", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<Vec3> &source = *_args.getPtr<ParticleDataImpl<Vec3>>(
+            "source", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setPosPdata(source);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::setPosPdata", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::setPosPdata", e.what());
+      return 0;
+    }
+  }
+
+  //! transform coordinate system from one grid size to another (usually upon load)
+  void transformPositions(Vec3i dimOld, Vec3i dimNew);
+
+  //! explicitly trigger compression from outside
+  void doCompress()
+  {
+    if (mDeletes > mDeleteChunk)
+      compress();
+  }
+  //! insert buffered positions as new particles, update additional particle data
+  void insertBufferedParticles();
+  //! resize data vector, and all pdata fields
+  void resizeAll(IndexInt newsize);
+
+  //! adding and deleting
+  inline void kill(IndexInt idx);
+  IndexInt add(const S &data);
+  //! remove all particles, init 0 length arrays (also pdata)
+  void clear();
+  static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::clear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clear();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::clear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::clear", e.what());
+      return 0;
+    }
+  }
+
+  //! Advect particle in grid velocity field
+  void advectInGrid(const FlagGrid &flags,
+                    const MACGrid &vel,
+                    const int integrationMode,
+                    const bool deleteInObstacle = true,
+                    const bool stopInObstacle = true,
+                    const ParticleDataImpl<int> *ptype = NULL,
+                    const int exclude = 0);
+  static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::advectInGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+        const int integrationMode = _args.get<int>("integrationMode", 2, &_lock);
+        const bool deleteInObstacle = _args.getOpt<bool>("deleteInObstacle", 3, true, &_lock);
+        const bool stopInObstacle = _args.getOpt<bool>("stopInObstacle", 4, true, &_lock);
+        const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+            "ptype", 5, NULL, &_lock);
+        const int exclude = _args.getOpt<int>("exclude", 6, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->advectInGrid(
+            flags, vel, integrationMode, deleteInObstacle, stopInObstacle, ptype, exclude);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::advectInGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::advectInGrid", e.what());
+      return 0;
+    }
+  }
+
+  //! Project particles outside obstacles
+  void projectOutside(Grid<Vec3> &gradient);
+  static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::projectOutside", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Grid<Vec3> &gradient = *_args.getPtr<Grid<Vec3>>("gradient", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->projectOutside(gradient);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::projectOutside", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::projectOutside", e.what());
+      return 0;
+    }
+  }
+
+  void projectOutOfBnd(const FlagGrid &flags,
+                       const Real bnd,
+                       const std::string &plane = "xXyYzZ",
+                       const ParticleDataImpl<int> *ptype = NULL,
+                       const int exclude = 0);
+  static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleSystem::projectOutOfBnd", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        const Real bnd = _args.get<Real>("bnd", 1, &_lock);
+        const std::string &plane = _args.getOpt<std::string>("plane", 2, "xXyYzZ", &_lock);
+        const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+            "ptype", 3, NULL, &_lock);
+        const int exclude = _args.getOpt<int>("exclude", 4, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->projectOutOfBnd(flags, bnd, plane, ptype, exclude);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleSystem::projectOutOfBnd", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleSystem::projectOutOfBnd", e.what());
+      return 0;
+    }
+  }
+
+  virtual ParticleBase *clone();
+  virtual std::string infoString() const;
+
+  //! debugging
+  inline void checkPartIndex(IndexInt idx) const;
+
+ protected:
+  //! deletion count , and interval for re-compressing
+  IndexInt mDeletes, mDeleteChunk;
+  //! the particle data
+  std::vector<S> mData;
+  //! reduce storage , called by doCompress
+  virtual void compress();
+ public:
+  PbArgs _args;
+}
+#define _C_ParticleSystem
+;
+
+//******************************************************************************
+
+//! Simplest data class for particle systems
+//! contains a position and an int flag; note that these are deprectated, and will at
+//! some point be replaced by the more flexible pdata fields. For now manually copy with
+//! getPosPdata / setPosPdata.
+struct BasicParticleData {
+ public:
+  BasicParticleData() : pos(0.), flag(0)
+  {
+  }
+  BasicParticleData(const Vec3 &p) : pos(p), flag(0)
+  {
+  }
+  static ParticleBase::SystemType getType()
+  {
+    return ParticleBase::PARTICLE;
+  }
+
+  //! data (note, this size is currently hard coded for uni i/o)
+  Vec3 pos;
+  int flag;
+};
+
+class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
+ public:
+  BasicParticleSystem(FluidSolver *parent);
+  static int _W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "BasicParticleSystem::BasicParticleSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new BasicParticleSystem(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "BasicParticleSystem::BasicParticleSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::BasicParticleSystem", e.what());
+      return -1;
+    }
+  }
+
+  //! file io
+  void save(const std::string name) const;
+  static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::save", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->save(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "BasicParticleSystem::save", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::save", e.what());
+      return 0;
+    }
+  }
+
+  void load(const std::string name);
+  static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::load", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->load(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "BasicParticleSystem::load", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::load", e.what());
+      return 0;
+    }
+  }
+
+  //! save to text file
+  void writeParticlesText(const std::string name) const;
+  //! other output formats
+  void writeParticlesRawPositionsGz(const std::string name) const;
+  void writeParticlesRawVelocityGz(const std::string name) const;
+
+  //! read from other particle system (with resize)
+  void readParticles(BasicParticleSystem *from);
+  static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::readParticles", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        BasicParticleSystem *from = _args.getPtr<BasicParticleSystem>("from", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->readParticles(from);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "BasicParticleSystem::readParticles", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::readParticles", e.what());
+      return 0;
+    }
+  }
+
+  //! add particles in python
+  void addParticle(Vec3 pos)
+  {
+    add(BasicParticleData(pos));
+  }
+  static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::addParticle", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Vec3 pos = _args.get<Vec3>("pos", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addParticle(pos);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "BasicParticleSystem::addParticle", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::addParticle", e.what());
+      return 0;
+    }
+  }
+
+  //! dangerous, get low level access - avoid usage, only used in vortex filament advection for now
+  std::vector<BasicParticleData> &getData()
+  {
+    return mData;
+  }
+
+  void printParts(IndexInt start = -1, IndexInt stop = -1, bool printIndex = false);
+  static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::printParts", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
+        IndexInt stop = _args.getOpt<IndexInt>("stop", 1, -1, &_lock);
+        bool printIndex = _args.getOpt<bool>("printIndex", 2, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->printParts(start, stop, printIndex);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "BasicParticleSystem::printParts", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::printParts", e.what());
+      return 0;
+    }
+  }
+
+  //! get data pointer of particle data
+  std::string getDataPointer();
+  static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::getDataPointer", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getDataPointer());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "BasicParticleSystem::getDataPointer", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("BasicParticleSystem::getDataPointer", e.what());
+      return 0;
+    }
+  }
+
+ public:
+  PbArgs _args;
+}
+#define _C_BasicParticleSystem
+;
+
+//******************************************************************************
+
+//! Index into other particle system
+//  used for grid based neighborhood searches on generic particle systems (stores
+//  only active particles, and reduces copied data)
+//  note - pos & flag are disabled here, do not use!
+struct ParticleIndexData {
+ public:
+  ParticleIndexData() : sourceIndex(0)
+  {
+  }
+  static ParticleBase::SystemType getType()
+  {
+    return ParticleBase::INDEX;
+  }
+
+  IndexInt sourceIndex;  // index of this particle in the original particle system
+  //! note - the following two are needed for template instantiation, but not used
+  //! for the particle index system (use values from original one!)
+  static Vec3 pos;  // do not use...
+  static int flag;  // not needed usally
+                    // Vec3 pos; // enable for debugging
+};
+
+class ParticleIndexSystem : public ParticleSystem<ParticleIndexData> {
+ public:
+  ParticleIndexSystem(FluidSolver *parent) : ParticleSystem<ParticleIndexData>(parent)
+  {
+  }
+  static int _W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "ParticleIndexSystem::ParticleIndexSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new ParticleIndexSystem(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "ParticleIndexSystem::ParticleIndexSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleIndexSystem::ParticleIndexSystem", e.what());
+      return -1;
+    }
+  };
+  //! we only need a resize function...
+  void resize(IndexInt size)
+  {
+    mData.resize(size);
+  }
+ public:
+  PbArgs _args;
+}
+#define _C_ParticleIndexSystem
+;
+
+//******************************************************************************
+
+//! Particle set with connectivity
+
+template<class DATA, class CON> class ConnectedParticleSystem : public ParticleSystem<DATA> {
+ public:
+  ConnectedParticleSystem(FluidSolver *parent) : ParticleSystem<DATA>(parent)
+  {
+  }
+  static int _W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "ConnectedParticleSystem::ConnectedParticleSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new ConnectedParticleSystem(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(
+          obj->getParent(), "ConnectedParticleSystem::ConnectedParticleSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("ConnectedParticleSystem::ConnectedParticleSystem", e.what());
+      return -1;
+    }
+  }
+
+  //! accessors
+  inline bool isSegActive(int i)
+  {
+    return (mSegments[i].flag & ParticleBase::PDELETE) == 0;
+  }
+  inline int segSize() const
+  {
+    return mSegments.size();
+  }
+  inline CON &seg(int i)
+  {
+    return mSegments[i];
+  }
+  inline const CON &seg(int i) const
+  {
+    return mSegments[i];
+  }
+
+  virtual ParticleBase *clone();
+
+ protected:
+  std::vector<CON> mSegments;
+  virtual void compress();
+ public:
+  PbArgs _args;
+}
+#define _C_ConnectedParticleSystem
+;
+
+//******************************************************************************
+
+//! abstract interface for particle data
+class ParticleDataBase : public PbClass {
+ public:
+  ParticleDataBase(FluidSolver *parent);
+  static int _W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "ParticleDataBase::ParticleDataBase", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new ParticleDataBase(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "ParticleDataBase::ParticleDataBase", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataBase::ParticleDataBase", e.what());
+      return -1;
+    }
+  }
+
+  virtual ~ParticleDataBase();
+
+  //! data type IDs, in line with those for grids
+  enum PdataType { TypeNone = 0, TypeReal = 1, TypeInt = 2, TypeVec3 = 4 };
+
+  //! interface functions, using assert instead of pure virtual for python compatibility
+  virtual IndexInt getSizeSlow() const
+  {
+    assertMsg(false, "Dont use, override...");
+    return 0;
+  }
+  virtual void addEntry()
+  {
+    assertMsg(false, "Dont use, override...");
+    return;
+  }
+  virtual ParticleDataBase *clone()
+  {
+    assertMsg(false, "Dont use, override...");
+    return NULL;
+  }
+  virtual PdataType getType() const
+  {
+    assertMsg(false, "Dont use, override...");
+    return TypeNone;
+  }
+  virtual void resize(IndexInt size)
+  {
+    assertMsg(false, "Dont use, override...");
+    return;
+  }
+  virtual void copyValueSlow(IndexInt from, IndexInt to)
+  {
+    assertMsg(false, "Dont use, override...");
+    return;
+  }
+
+  //! set base pointer
+  void setParticleSys(ParticleBase *set)
+  {
+    mpParticleSys = set;
+  }
+
+  //! debugging
+  inline void checkPartIndex(IndexInt idx) const;
+
+ protected:
+  ParticleBase *mpParticleSys;
+ public:
+  PbArgs _args;
+}
+#define _C_ParticleDataBase
+;
+
+//! abstract interface for particle data
+
+template<class T> class ParticleDataImpl : public ParticleDataBase {
+ public:
+  ParticleDataImpl(FluidSolver *parent);
+  static int _W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "ParticleDataImpl::ParticleDataImpl", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new ParticleDataImpl(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "ParticleDataImpl::ParticleDataImpl", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::ParticleDataImpl", e.what());
+      return -1;
+    }
+  }
+
+  ParticleDataImpl(FluidSolver *parent, ParticleDataImpl<T> *other);
+  virtual ~ParticleDataImpl();
+
+  //! access data
+  inline T &get(const IndexInt idx)
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx];
+  }
+  inline const T &get(const IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx];
+  }
+  inline T &operator[](const IndexInt idx)
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx];
+  }
+  inline const T &operator[](const IndexInt idx) const
+  {
+    DEBUG_ONLY(checkPartIndex(idx));
+    return mData[idx];
+  }
+
+  //! set all values to 0, note - different from particleSystem::clear! doesnt modify size of array
+  //! (has to stay in sync with parent system)
+  void clear();
+  static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clear", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clear();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::clear", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::clear", e.what());
+      return 0;
+    }
+  }
+
+  //! set grid from which to get data...
+  void setSource(Grid<T> *grid, bool isMAC = false);
+  static PyObject *_W_24(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setSource", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock);
+        bool isMAC = _args.getOpt<bool>("isMAC", 1, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setSource(grid, isMAC);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::setSource", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::setSource", e.what());
+      return 0;
+    }
+  }
+
+  //! particle data base interface
+  virtual IndexInt getSizeSlow() const;
+  virtual void addEntry();
+  virtual ParticleDataBase *clone();
+  virtual PdataType getType() const;
+  virtual void resize(IndexInt s);
+  virtual void copyValueSlow(IndexInt from, IndexInt to);
+
+  IndexInt size() const
+  {
+    return mData.size();
+  }
+
+  //! fast inlined functions for per particle operations
+  inline void copyValue(IndexInt from, IndexInt to)
+  {
+    get(to) = get(from);
+  }
+  void initNewValue(IndexInt idx, Vec3 pos);
+
+  //! python interface (similar to grid data)
+  ParticleDataImpl<T> &copyFrom(const ParticleDataImpl<T> &a);
+  static PyObject *_W_25(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::copyFrom", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->copyFrom(a));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::copyFrom", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::copyFrom", e.what());
+      return 0;
+    }
+  }
+
+  void setConst(const T &s);
+  static PyObject *_W_26(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const T &s = *_args.getPtr<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::setConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::setConst", e.what());
+      return 0;
+    }
+  }
+
+  void setConstRange(const T &s, const int begin, const int end);
+  static PyObject *_W_27(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConstRange", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const T &s = *_args.getPtr<T>("s", 0, &_lock);
+        const int begin = _args.get<int>("begin", 1, &_lock);
+        const int end = _args.get<int>("end", 2, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConstRange(s, begin, end);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::setConstRange", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::setConstRange", e.what());
+      return 0;
+    }
+  }
+
+  void add(const ParticleDataImpl<T> &a);
+  static PyObject *_W_28(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::add", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->add(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::add", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::add", e.what());
+      return 0;
+    }
+  }
+
+  void sub(const ParticleDataImpl<T> &a);
+  static PyObject *_W_29(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sub", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->sub(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::sub", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::sub", e.what());
+      return 0;
+    }
+  }
+
+  void addConst(const T &s);
+  static PyObject *_W_30(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::addConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const T &s = *_args.getPtr<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::addConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::addConst", e.what());
+      return 0;
+    }
+  }
+
+  void addScaled(const ParticleDataImpl<T> &a, const T &factor);
+  static PyObject *_W_31(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::addScaled", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
+        const T &factor = *_args.getPtr<T>("factor", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->addScaled(a, factor);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::addScaled", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::addScaled", e.what());
+      return 0;
+    }
+  }
+
+  void mult(const ParticleDataImpl<T> &a);
+  static PyObject *_W_32(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::mult", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->mult(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::mult", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::mult", e.what());
+      return 0;
+    }
+  }
+
+  void multConst(const T &s);
+  static PyObject *_W_33(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::multConst", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const T &s = *_args.getPtr<T>("s", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->multConst(s);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::multConst", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::multConst", e.what());
+      return 0;
+    }
+  }
+
+  void safeDiv(const ParticleDataImpl<T> &a);
+  static PyObject *_W_34(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::safeDiv", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->safeDiv(a);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::safeDiv", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::safeDiv", e.what());
+      return 0;
+    }
+  }
+
+  void clamp(const Real vmin, const Real vmax);
+  static PyObject *_W_35(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clamp", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Real vmin = _args.get<Real>("vmin", 0, &_lock);
+        const Real vmax = _args.get<Real>("vmax", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clamp(vmin, vmax);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::clamp", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::clamp", e.what());
+      return 0;
+    }
+  }
+
+  void clampMin(const Real vmin);
+  static PyObject *_W_36(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clampMin", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Real vmin = _args.get<Real>("vmin", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clampMin(vmin);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::clampMin", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::clampMin", e.what());
+      return 0;
+    }
+  }
+
+  void clampMax(const Real vmax);
+  static PyObject *_W_37(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clampMax", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Real vmax = _args.get<Real>("vmax", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->clampMax(vmax);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::clampMax", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::clampMax", e.what());
+      return 0;
+    }
+  }
+
+  Real getMaxAbs() const;
+  static PyObject *_W_38(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMaxAbs", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMaxAbs());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::getMaxAbs", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::getMaxAbs", e.what());
+      return 0;
+    }
+  }
+
+  Real getMax() const;
+  static PyObject *_W_39(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMax", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMax());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::getMax", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::getMax", e.what());
+      return 0;
+    }
+  }
+
+  Real getMin() const;
+  static PyObject *_W_40(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMin", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getMin());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::getMin", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::getMin", e.what());
+      return 0;
+    }
+  }
+
+  T sum(const ParticleDataImpl<int> *t = NULL, const int itype = 0) const;
+  static PyObject *_W_41(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sum", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const ParticleDataImpl<int> *t = _args.getPtrOpt<ParticleDataImpl<int>>(
+            "t", 0, NULL, &_lock);
+        const int itype = _args.getOpt<int>("itype", 1, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->sum(t, itype));
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::sum", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::sum", e.what());
+      return 0;
+    }
+  }
+
+  Real sumSquare() const;
+  static PyObject *_W_42(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sumSquare", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->sumSquare());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::sumSquare", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::sumSquare", e.what());
+      return 0;
+    }
+  }
+
+  Real sumMagnitude() const;
+  static PyObject *_W_43(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sumMagnitude", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->sumMagnitude());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::sumMagnitude", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::sumMagnitude", e.what());
+      return 0;
+    }
+  }
+
+  //! special, set if int flag in t has "flag"
+  void setConstIntFlag(const T &s, const ParticleDataImpl<int> &t, const int flag);
+  static PyObject *_W_44(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConstIntFlag", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const T &s = *_args.getPtr<T>("s", 0, &_lock);
+        const ParticleDataImpl<int> &t = *_args.getPtr<ParticleDataImpl<int>>("t", 1, &_lock);
+        const int flag = _args.get<int>("flag", 2, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setConstIntFlag(s, t, flag);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::setConstIntFlag", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::setConstIntFlag", e.what());
+      return 0;
+    }
+  }
+
+  void printPdata(IndexInt start = -1, IndexInt stop = -1, bool printIndex = false);
+  static PyObject *_W_45(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::printPdata", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
+        IndexInt stop = _args.getOpt<IndexInt>("stop", 1, -1, &_lock);
+        bool printIndex = _args.getOpt<bool>("printIndex", 2, false, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->printPdata(start, stop, printIndex);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::printPdata", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::printPdata", e.what());
+      return 0;
+    }
+  }
+
+  //! file io
+  void save(const std::string name);
+  static PyObject *_W_46(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::save", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->save(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::save", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::save", e.what());
+      return 0;
+    }
+  }
+
+  void load(const std::string name);
+  static PyObject *_W_47(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::load", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const std::string name = _args.get<std::string>("name", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->load(name);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::load", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::load", e.what());
+      return 0;
+    }
+  }
+
+  //! get data pointer of particle data
+  std::string getDataPointer();
+  static PyObject *_W_48(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getDataPointer", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getDataPointer());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "ParticleDataImpl::getDataPointer", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("ParticleDataImpl::getDataPointer", e.what());
+      return 0;
+    }
+  }
+
+ protected:
+  //! data storage
+  std::vector<T> mData;
+
+  //! optionally , we might have an associated grid from which to grab new data
+  Grid<T> *mpGridSource;  //! unfortunately , we need to distinguish mac vs regular vec3
+  bool mGridSourceMAC;
+ public:
+  PbArgs _args;
+}
+#define _C_ParticleDataImpl
+;
+
+//******************************************************************************
+// Implementation
+//******************************************************************************
+
+const int DELETE_PART = 20;  // chunk size for compression
+
+void ParticleBase::addBuffered(const Vec3 &pos, int flag)
+{
+  mNewBufferPos.push_back(pos);
+  mNewBufferFlag.push_back(flag);
+}
+
+template<class S> void ParticleSystem<S>::clear()
+{
+  mDeleteChunk = mDeletes = 0;
+  this->resizeAll(0);  // instead of mData.clear
+}
+
+template<class S> IndexInt ParticleSystem<S>::add(const S &data)
+{
+  mData.push_back(data);
+  mDeleteChunk = mData.size() / DELETE_PART;
+  this->addAllPdata();
+  return mData.size() - 1;
+}
+
+template<class S> inline void ParticleSystem<S>::kill(IndexInt idx)
+{
+  assertMsg(idx >= 0 && idx < size(), "Index out of bounds");
+  mData[idx].flag |= PDELETE;
+  if ((++mDeletes > mDeleteChunk) && (mAllowCompress))
+    compress();
+}
+
+template<class S> void ParticleSystem<S>::getPosPdata(ParticleDataImpl<Vec3> &target) const
+{
+  for (IndexInt i = 0; i < (IndexInt)this->size(); ++i) {
+    target[i] = this->getPos(i);
+  }
+}
+template<class S> void ParticleSystem<S>::setPosPdata(const ParticleDataImpl<Vec3> &source)
+{
+  for (IndexInt i = 0; i < (IndexInt)this->size(); ++i) {
+    this->setPos(i, source[i]);
+  }
+}
+
+template<class S> void ParticleSystem<S>::transformPositions(Vec3i dimOld, Vec3i dimNew)
+{
+  const Vec3 factor = calcGridSizeFactor(dimNew, dimOld);
+  for (IndexInt i = 0; i < (IndexInt)this->size(); ++i) {
+    this->setPos(i, this->getPos(i) * factor);
+  }
+}
+
+// check for deletion/invalid position, otherwise return velocity
+
+template<class S> struct _GridAdvectKernel : public KernelBase {
+  _GridAdvectKernel(const KernelBase &base,
+                    std::vector<S> &p,
+                    const MACGrid &vel,
+                    const FlagGrid &flags,
+                    const Real dt,
+                    const bool deleteInObstacle,
+                    const bool stopInObstacle,
+                    const ParticleDataImpl<int> *ptype,
+                    const int exclude,
+                    std::vector<Vec3> &u)
+      : KernelBase(base),
+        p(p),
+        vel(vel),
+        flags(flags),
+        dt(dt),
+        deleteInObstacle(deleteInObstacle),
+        stopInObstacle(stopInObstacle),
+        ptype(ptype),
+        exclude(exclude),
+        u(u)
+  {
+  }
+  inline void op(IndexInt idx,
+                 std::vector<S> &p,
+                 const MACGrid &vel,
+                 const FlagGrid &flags,
+                 const Real dt,
+                 const bool deleteInObstacle,
+                 const bool stopInObstacle,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude,
+                 std::vector<Vec3> &u) const
+  {
+    if ((p[idx].flag & ParticleBase::PDELETE) || (ptype && ((*ptype)[idx] & exclude))) {
+      u[idx] = 0.;
+      return;
+    }
+    // special handling
+    if (deleteInObstacle || stopInObstacle) {
+      if (!flags.isInBounds(p[idx].pos, 1) || flags.isObstacle(p[idx].pos)) {
+        if (stopInObstacle)
+          u[idx] = 0.;
+        // for simple tracer particles, its convenient to delete particles right away
+        // for other sim types, eg flip, we can try to fix positions later on
+        if (deleteInObstacle)
+          p[idx].flag |= ParticleBase::PDELETE;
+        return;
+      }
+    }
+    u[idx] = vel.getInterpolated(p[idx].pos) * dt;
+  }
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, vel, flags, dt, deleteInObstacle, stopInObstacle, ptype, exclude, u);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<S> &p;
+  const MACGrid &vel;
+  const FlagGrid &flags;
+  const Real dt;
+  const bool deleteInObstacle;
+  const bool stopInObstacle;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+  std::vector<Vec3> &u;
+};
+template<class S> struct GridAdvectKernel : public KernelBase {
+  GridAdvectKernel(std::vector<S> &p,
+                   const MACGrid &vel,
+                   const FlagGrid &flags,
+                   const Real dt,
+                   const bool deleteInObstacle,
+                   const bool stopInObstacle,
+                   const ParticleDataImpl<int> *ptype,
+                   const int exclude)
+      : KernelBase(p.size()),
+        _inner(KernelBase(p.size()),
+               p,
+               vel,
+               flags,
+               dt,
+               deleteInObstacle,
+               stopInObstacle,
+               ptype,
+               exclude,
+               u),
+        p(p),
+        vel(vel),
+        flags(flags),
+        dt(dt),
+        deleteInObstacle(deleteInObstacle),
+        stopInObstacle(stopInObstacle),
+        ptype(ptype),
+        exclude(exclude),
+        u((size))
+  {
+    runMessage();
+    run();
+  }
+  void run()
+  {
+    _inner.run();
+  }
+  inline operator std::vector<Vec3>()
+  {
+    return u;
+  }
+  inline std::vector<Vec3> &getRet()
+  {
+    return u;
+  }
+  inline std::vector<S> &getArg0()
+  {
+    return p;
+  }
+  typedef std::vector<S> type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const FlagGrid &getArg2()
+  {
+    return flags;
+  }
+  typedef FlagGrid type2;
+  inline const Real &getArg3()
+  {
+    return dt;
+  }
+  typedef Real type3;
+  inline const bool &getArg4()
+  {
+    return deleteInObstacle;
+  }
+  typedef bool type4;
+  inline const bool &getArg5()
+  {
+    return stopInObstacle;
+  }
+  typedef bool type5;
+  inline const ParticleDataImpl<int> *getArg6()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type6;
+  inline const int &getArg7()
+  {
+    return exclude;
+  }
+  typedef int type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel GridAdvectKernel ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  _GridAdvectKernel<S> _inner;
+  std::vector<S> &p;
+  const MACGrid &vel;
+  const FlagGrid &flags;
+  const Real dt;
+  const bool deleteInObstacle;
+  const bool stopInObstacle;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+  std::vector<Vec3> u;
+};
+;
+
+// final check after advection to make sure particles haven't escaped
+// (similar to particle advection kernel)
+
+template<class S> struct KnDeleteInObstacle : public KernelBase {
+  KnDeleteInObstacle(std::vector<S> &p, const FlagGrid &flags)
+      : KernelBase(p.size()), p(p), flags(flags)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, std::vector<S> &p, const FlagGrid &flags) const
+  {
+    if (p[idx].flag & ParticleBase::PDELETE)
+      return;
+    if (!flags.isInBounds(p[idx].pos, 1) || flags.isObstacle(p[idx].pos)) {
+      p[idx].flag |= ParticleBase::PDELETE;
+    }
+  }
+  inline std::vector<S> &getArg0()
+  {
+    return p;
+  }
+  typedef std::vector<S> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnDeleteInObstacle ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, flags);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<S> &p;
+  const FlagGrid &flags;
+};
+
+// try to get closer to actual obstacle boundary
+static inline Vec3 bisectBacktracePos(const FlagGrid &flags, const Vec3 &oldp, const Vec3 &newp)
+{
+  Real s = 0.;
+  for (int i = 1; i < 5; ++i) {
+    Real ds = 1. / (Real)(1 << i);
+    if (!flags.isObstacle(oldp * (1. - (s + ds)) + newp * (s + ds))) {
+      s += ds;
+    }
+  }
+  return (oldp * (1. - (s)) + newp * (s));
+}
+
+// at least make sure all particles are inside domain
+
+template<class S> struct KnClampPositions : public KernelBase {
+  KnClampPositions(std::vector<S> &p,
+                   const FlagGrid &flags,
+                   ParticleDataImpl<Vec3> *posOld = NULL,
+                   bool stopInObstacle = true,
+                   const ParticleDataImpl<int> *ptype = NULL,
+                   const int exclude = 0)
+      : KernelBase(p.size()),
+        p(p),
+        flags(flags),
+        posOld(posOld),
+        stopInObstacle(stopInObstacle),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 std::vector<S> &p,
+                 const FlagGrid &flags,
+                 ParticleDataImpl<Vec3> *posOld = NULL,
+                 bool stopInObstacle = true,
+                 const ParticleDataImpl<int> *ptype = NULL,
+                 const int exclude = 0) const
+  {
+    if (p[idx].flag & ParticleBase::PDELETE)
+      return;
+    if (ptype && ((*ptype)[idx] & exclude)) {
+      if (posOld)
+        p[idx].pos = (*posOld)[idx];
+      return;
+    }
+    if (!flags.isInBounds(p[idx].pos, 0)) {
+      p[idx].pos = clamp(p[idx].pos, Vec3(0.), toVec3(flags.getSize()) - Vec3(1.));
+    }
+    if (stopInObstacle && (flags.isObstacle(p[idx].pos))) {
+      p[idx].pos = bisectBacktracePos(flags, (*posOld)[idx], p[idx].pos);
+    }
+  }
+  inline std::vector<S> &getArg0()
+  {
+    return p;
+  }
+  typedef std::vector<S> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline ParticleDataImpl<Vec3> *getArg2()
+  {
+    return posOld;
+  }
+  typedef ParticleDataImpl<Vec3> type2;
+  inline bool &getArg3()
+  {
+    return stopInObstacle;
+  }
+  typedef bool type3;
+  inline const ParticleDataImpl<int> *getArg4()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type4;
+  inline const int &getArg5()
+  {
+    return exclude;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnClampPositions ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, flags, posOld, stopInObstacle, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  std::vector<S> &p;
+  const FlagGrid &flags;
+  ParticleDataImpl<Vec3> *posOld;
+  bool stopInObstacle;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+// advection plugin
+template<class S>
+void ParticleSystem<S>::advectInGrid(const FlagGrid &flags,
+                                     const MACGrid &vel,
+                                     const int integrationMode,
+                                     const bool deleteInObstacle,
+                                     const bool stopInObstacle,
+                                     const ParticleDataImpl<int> *ptype,
+                                     const int exclude)
+{
+  // position clamp requires old positions, backup
+  ParticleDataImpl<Vec3> *posOld = NULL;
+  if (!deleteInObstacle) {
+    posOld = new ParticleDataImpl<Vec3>(this->getParent());
+    posOld->resize(mData.size());
+    for (IndexInt i = 0; i < (IndexInt)mData.size(); ++i)
+      (*posOld)[i] = mData[i].pos;
+  }
+
+  // update positions
+  GridAdvectKernel<S> kernel(
+      mData, vel, flags, getParent()->getDt(), deleteInObstacle, stopInObstacle, ptype, exclude);
+  integratePointSet(kernel, integrationMode);
+
+  if (!deleteInObstacle) {
+    KnClampPositions<S>(mData, flags, posOld, stopInObstacle, ptype, exclude);
+    delete posOld;
+  }
+  else {
+    KnDeleteInObstacle<S>(mData, flags);
+  }
+}
+
+template<class S> struct KnProjectParticles : public KernelBase {
+  KnProjectParticles(ParticleSystem<S> &part, Grid<Vec3> &gradient)
+      : KernelBase(part.size()), part(part), gradient(gradient)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, ParticleSystem<S> &part, Grid<Vec3> &gradient)
+  {
+    static RandomStream rand(3123984);
+    const double jlen = 0.1;
+
+    if (part.isActive(idx)) {
+      // project along levelset gradient
+      Vec3 p = part[idx].pos;
+      if (gradient.isInBounds(p)) {
+        Vec3 n = gradient.getInterpolated(p);
+        Real dist = normalize(n);
+        Vec3 dx = n * (-dist + jlen * (1 + rand.getReal()));
+        p += dx;
+      }
+      // clamp to outer boundaries (+jitter)
+      const double jlen = 0.1;
+      Vec3 jitter = jlen * rand.getVec3();
+      part[idx].pos = clamp(p, Vec3(1, 1, 1) + jitter, toVec3(gradient.getSize() - 1) - jitter);
+    }
+  }
+  inline ParticleSystem<S> &getArg0()
+  {
+    return part;
+  }
+  typedef ParticleSystem<S> type0;
+  inline Grid<Vec3> &getArg1()
+  {
+    return gradient;
+  }
+  typedef Grid<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnProjectParticles ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void run()
+  {
+    const IndexInt _sz = size;
+    for (IndexInt i = 0; i < _sz; i++)
+      op(i, part, gradient);
+  }
+  ParticleSystem<S> &part;
+  Grid<Vec3> &gradient;
+};
+
+template<class S> void ParticleSystem<S>::projectOutside(Grid<Vec3> &gradient)
+{
+  KnProjectParticles<S>(*this, gradient);
+}
+
+template<class S> struct KnProjectOutOfBnd : public KernelBase {
+  KnProjectOutOfBnd(ParticleSystem<S> &part,
+                    const FlagGrid &flags,
+                    const Real bnd,
+                    const bool *axis,
+                    const ParticleDataImpl<int> *ptype,
+                    const int exclude)
+      : KernelBase(part.size()),
+        part(part),
+        flags(flags),
+        bnd(bnd),
+        axis(axis),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ParticleSystem<S> &part,
+                 const FlagGrid &flags,
+                 const Real bnd,
+                 const bool *axis,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (!part.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+    if (axis[0])
+      part[idx].pos.x = std::max(part[idx].pos.x, bnd);
+    if (axis[1])
+      part[idx].pos.x = std::min(part[idx].pos.x, static_cast<Real>(flags.getSizeX()) - bnd);
+    if (axis[2])
+      part[idx].pos.y = std::max(part[idx].pos.y, bnd);
+    if (axis[3])
+      part[idx].pos.y = std::min(part[idx].pos.y, static_cast<Real>(flags.getSizeY()) - bnd);
+    if (flags.is3D()) {
+      if (axis[4])
+        part[idx].pos.z = std::max(part[idx].pos.z, bnd);
+      if (axis[5])
+        part[idx].pos.z = std::min(part[idx].pos.z, static_cast<Real>(flags.getSizeZ()) - bnd);
+    }
+  }
+  inline ParticleSystem<S> &getArg0()
+  {
+    return part;
+  }
+  typedef ParticleSystem<S> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Real &getArg2()
+  {
+    return bnd;
+  }
+  typedef Real type2;
+  inline const bool *getArg3()
+  {
+    return axis;
+  }
+  typedef bool type3;
+  inline const ParticleDataImpl<int> *getArg4()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type4;
+  inline const int &getArg5()
+  {
+    return exclude;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnProjectOutOfBnd ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, part, flags, bnd, axis, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleSystem<S> &part;
+  const FlagGrid &flags;
+  const Real bnd;
+  const bool *axis;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+template<class S>
+void ParticleSystem<S>::projectOutOfBnd(const FlagGrid &flags,
+                                        const Real bnd,
+                                        const std::string &plane,
+                                        const ParticleDataImpl<int> *ptype,
+                                        const int exclude)
+{
+  bool axis[6] = {false};
+  for (std::string::const_iterator it = plane.begin(); it != plane.end(); ++it) {
+    if (*it == 'x')
+      axis[0] = true;
+    if (*it == 'X')
+      axis[1] = true;
+    if (*it == 'y')
+      axis[2] = true;
+    if (*it == 'Y')
+      axis[3] = true;
+    if (*it == 'z')
+      axis[4] = true;
+    if (*it == 'Z')
+      axis[5] = true;
+  }
+  KnProjectOutOfBnd<S>(*this, flags, bnd, axis, ptype, exclude);
+}
+
+template<class S> void ParticleSystem<S>::resizeAll(IndexInt size)
+{
+  // resize all buffers to target size in 1 go
+  mData.resize(size);
+  for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
+    mPartData[i]->resize(size);
+}
+
+template<class S> void ParticleSystem<S>::compress()
+{
+  IndexInt nextRead = mData.size();
+  for (IndexInt i = 0; i < (IndexInt)mData.size(); i++) {
+    while ((mData[i].flag & PDELETE) != 0) {
+      nextRead--;
+      mData[i] = mData[nextRead];
+      // ugly, but prevent virtual function calls here:
+      for (IndexInt pd = 0; pd < (IndexInt)mPdataReal.size(); ++pd)
+        mPdataReal[pd]->copyValue(nextRead, i);
+      for (IndexInt pd = 0; pd < (IndexInt)mPdataVec3.size(); ++pd)
+        mPdataVec3[pd]->copyValue(nextRead, i);
+      for (IndexInt pd = 0; pd < (IndexInt)mPdataInt.size(); ++pd)
+        mPdataInt[pd]->copyValue(nextRead, i);
+      mData[nextRead].flag = PINVALID;
+    }
+  }
+  if (nextRead < (IndexInt)mData.size())
+    debMsg("Deleted " << ((IndexInt)mData.size() - nextRead) << " particles", 1);  // debug info
+
+  resizeAll(nextRead);
+  mDeletes = 0;
+  mDeleteChunk = mData.size() / DELETE_PART;
+}
+
+//! insert buffered positions as new particles, update additional particle data
+template<class S> void ParticleSystem<S>::insertBufferedParticles()
+{
+  if (mNewBufferPos.size() == 0)
+    return;
+  IndexInt newCnt = mData.size();
+  resizeAll(newCnt + mNewBufferPos.size());
+
+  // clear new flag everywhere
+  for (IndexInt i = 0; i < (IndexInt)mData.size(); ++i)
+    mData[i].flag &= ~PNEW;
+
+  for (IndexInt i = 0; i < (IndexInt)mNewBufferPos.size(); ++i) {
+    int flag = (mNewBufferFlag.size() > 0) ? mNewBufferFlag[i] : 0;
+    // note, other fields are not initialized here...
+    mData[newCnt].pos = mNewBufferPos[i];
+    mData[newCnt].flag = PNEW | flag;
+    // now init pdata fields from associated grids...
+    for (IndexInt pd = 0; pd < (IndexInt)mPdataReal.size(); ++pd)
+      mPdataReal[pd]->initNewValue(newCnt, mNewBufferPos[i]);
+    for (IndexInt pd = 0; pd < (IndexInt)mPdataVec3.size(); ++pd)
+      mPdataVec3[pd]->initNewValue(newCnt, mNewBufferPos[i]);
+    for (IndexInt pd = 0; pd < (IndexInt)mPdataInt.size(); ++pd)
+      mPdataInt[pd]->initNewValue(newCnt, mNewBufferPos[i]);
+    newCnt++;
+  }
+  if (mNewBufferPos.size() > 0)
+    debMsg("Added & initialized " << (IndexInt)mNewBufferPos.size() << " particles",
+           2);  // debug info
+  mNewBufferPos.clear();
+  mNewBufferFlag.clear();
+}
+
+template<class DATA, class CON> void ConnectedParticleSystem<DATA, CON>::compress()
+{
+  const IndexInt sz = ParticleSystem<DATA>::size();
+  IndexInt *renumber_back = new IndexInt[sz];
+  IndexInt *renumber = new IndexInt[sz];
+  for (IndexInt i = 0; i < sz; i++)
+    renumber[i] = renumber_back[i] = -1;
+
+  // reorder elements
+  std::vector<DATA> &data = ParticleSystem<DATA>::mData;
+  IndexInt nextRead = sz;
+  for (IndexInt i = 0; i < nextRead; i++) {
+    if ((data[i].flag & ParticleBase::PDELETE) != 0) {
+      nextRead--;
+      data[i] = data[nextRead];
+      data[nextRead].flag = 0;
+      renumber_back[i] = nextRead;
+    }
+    else
+      renumber_back[i] = i;
+  }
+
+  // acceleration structure
+  for (IndexInt i = 0; i < nextRead; i++)
+    renumber[renumber_back[i]] = i;
+
+  // rename indices in filaments
+  for (IndexInt i = 0; i < (IndexInt)mSegments.size(); i++)
+    mSegments[i].renumber(renumber);
+
+  ParticleSystem<DATA>::mData.resize(nextRead);
+  ParticleSystem<DATA>::mDeletes = 0;
+  ParticleSystem<DATA>::mDeleteChunk = ParticleSystem<DATA>::size() / DELETE_PART;
+
+  delete[] renumber;
+  delete[] renumber_back;
+}
+
+template<class S> ParticleBase *ParticleSystem<S>::clone()
+{
+  ParticleSystem<S> *nm = new ParticleSystem<S>(getParent());
+  if (this->mAllowCompress)
+    compress();
+
+  nm->mData = mData;
+  nm->setName(getName());
+  this->cloneParticleData(nm);
+  return nm;
+}
+
+template<class DATA, class CON> ParticleBase *ConnectedParticleSystem<DATA, CON>::clone()
+{
+  ConnectedParticleSystem<DATA, CON> *nm = new ConnectedParticleSystem<DATA, CON>(
+      this->getParent());
+  if (this->mAllowCompress)
+    compress();
+
+  nm->mData = this->mData;
+  nm->mSegments = mSegments;
+  nm->setName(this->getName());
+  this->cloneParticleData(nm);
+  return nm;
+}
+
+template<class S> std::string ParticleSystem<S>::infoString() const
+{
+  std::stringstream s;
+  s << "ParticleSys '" << getName() << "'\n-> ";
+  if (this->getNumPdata() > 0)
+    s << "pdata: " << this->getNumPdata();
+  s << "parts: " << size();
+  // for(IndexInt i=0; i<(IndexInt)mPartData.size(); ++i) { sstr << i<<":" << mPartData[i]->size()
+  // <<" "; }
+  return s.str();
+}
+
+template<class S> inline void ParticleSystem<S>::checkPartIndex(IndexInt idx) const
+{
+  IndexInt mySize = this->size();
+  if (idx < 0 || idx > mySize) {
+    errMsg("ParticleBase "
+           << " size " << mySize << " : index " << idx << " out of bound ");
+  }
+}
+
+inline void ParticleDataBase::checkPartIndex(IndexInt idx) const
+{
+  IndexInt mySize = this->getSizeSlow();
+  if (idx < 0 || idx > mySize) {
+    errMsg("ParticleData "
+           << " size " << mySize << " : index " << idx << " out of bound ");
+  }
+  if (mpParticleSys && mpParticleSys->getSizeSlow() != mySize) {
+    errMsg("ParticleData "
+           << " size " << mySize << " does not match parent! (" << mpParticleSys->getSizeSlow()
+           << ") ");
+  }
+}
+
+// set contents to zero, as for a grid
+template<class T> void ParticleDataImpl<T>::clear()
+{
+  for (IndexInt i = 0; i < (IndexInt)mData.size(); ++i)
+    mData[i] = 0.;
+}
+
+//! count by type flag
+int countParticles(const ParticleDataImpl<int> &t, const int flag);
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/particle.h.reg.cpp b/extern/mantaflow/preprocessed/particle.h.reg.cpp
new file mode 100644
index 00000000000..6e0466d0203
--- /dev/null
+++ b/extern/mantaflow/preprocessed/particle.h.reg.cpp
@@ -0,0 +1,437 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "particle.h"
+namespace Manta {
+#ifdef _C_BasicParticleSystem
+static const Pb::Register _R_13("BasicParticleSystem",
+                                "BasicParticleSystem",
+                                "ParticleSystem<BasicParticleData>");
+template<> const char *Namify<BasicParticleSystem>::S = "BasicParticleSystem";
+static const Pb::Register _R_14("BasicParticleSystem",
+                                "BasicParticleSystem",
+                                BasicParticleSystem::_W_12);
+static const Pb::Register _R_15("BasicParticleSystem", "save", BasicParticleSystem::_W_13);
+static const Pb::Register _R_16("BasicParticleSystem", "load", BasicParticleSystem::_W_14);
+static const Pb::Register _R_17("BasicParticleSystem",
+                                "readParticles",
+                                BasicParticleSystem::_W_15);
+static const Pb::Register _R_18("BasicParticleSystem", "addParticle", BasicParticleSystem::_W_16);
+static const Pb::Register _R_19("BasicParticleSystem", "printParts", BasicParticleSystem::_W_17);
+static const Pb::Register _R_20("BasicParticleSystem",
+                                "getDataPointer",
+                                BasicParticleSystem::_W_18);
+#endif
+#ifdef _C_ParticleBase
+static const Pb::Register _R_21("ParticleBase", "ParticleBase", "PbClass");
+template<> const char *Namify<ParticleBase>::S = "ParticleBase";
+static const Pb::Register _R_22("ParticleBase", "ParticleBase", ParticleBase::_W_0);
+static const Pb::Register _R_23("ParticleBase", "create", ParticleBase::_W_1);
+#endif
+#ifdef _C_ParticleDataBase
+static const Pb::Register _R_24("ParticleDataBase", "ParticleDataBase", "PbClass");
+template<> const char *Namify<ParticleDataBase>::S = "ParticleDataBase";
+static const Pb::Register _R_25("ParticleDataBase", "ParticleDataBase", ParticleDataBase::_W_21);
+#endif
+#ifdef _C_ParticleDataImpl
+static const Pb::Register _R_26("ParticleDataImpl<int>",
+                                "ParticleDataImpl<int>",
+                                "ParticleDataBase");
+template<> const char *Namify<ParticleDataImpl<int>>::S = "ParticleDataImpl<int>";
+static const Pb::Register _R_27("ParticleDataImpl<int>",
+                                "ParticleDataImpl",
+                                ParticleDataImpl<int>::_W_22);
+static const Pb::Register _R_28("ParticleDataImpl<int>", "clear", ParticleDataImpl<int>::_W_23);
+static const Pb::Register _R_29("ParticleDataImpl<int>",
+                                "setSource",
+                                ParticleDataImpl<int>::_W_24);
+static const Pb::Register _R_30("ParticleDataImpl<int>", "copyFrom", ParticleDataImpl<int>::_W_25);
+static const Pb::Register _R_31("ParticleDataImpl<int>", "setConst", ParticleDataImpl<int>::_W_26);
+static const Pb::Register _R_32("ParticleDataImpl<int>",
+                                "setConstRange",
+                                ParticleDataImpl<int>::_W_27);
+static const Pb::Register _R_33("ParticleDataImpl<int>", "add", ParticleDataImpl<int>::_W_28);
+static const Pb::Register _R_34("ParticleDataImpl<int>", "sub", ParticleDataImpl<int>::_W_29);
+static const Pb::Register _R_35("ParticleDataImpl<int>", "addConst", ParticleDataImpl<int>::_W_30);
+static const Pb::Register _R_36("ParticleDataImpl<int>",
+                                "addScaled",
+                                ParticleDataImpl<int>::_W_31);
+static const Pb::Register _R_37("ParticleDataImpl<int>", "mult", ParticleDataImpl<int>::_W_32);
+static const Pb::Register _R_38("ParticleDataImpl<int>",
+                                "multConst",
+                                ParticleDataImpl<int>::_W_33);
+static const Pb::Register _R_39("ParticleDataImpl<int>", "safeDiv", ParticleDataImpl<int>::_W_34);
+static const Pb::Register _R_40("ParticleDataImpl<int>", "clamp", ParticleDataImpl<int>::_W_35);
+static const Pb::Register _R_41("ParticleDataImpl<int>", "clampMin", ParticleDataImpl<int>::_W_36);
+static const Pb::Register _R_42("ParticleDataImpl<int>", "clampMax", ParticleDataImpl<int>::_W_37);
+static const Pb::Register _R_43("ParticleDataImpl<int>",
+                                "getMaxAbs",
+                                ParticleDataImpl<int>::_W_38);
+static const Pb::Register _R_44("ParticleDataImpl<int>", "getMax", ParticleDataImpl<int>::_W_39);
+static const Pb::Register _R_45("ParticleDataImpl<int>", "getMin", ParticleDataImpl<int>::_W_40);
+static const Pb::Register _R_46("ParticleDataImpl<int>", "sum", ParticleDataImpl<int>::_W_41);
+static const Pb::Register _R_47("ParticleDataImpl<int>",
+                                "sumSquare",
+                                ParticleDataImpl<int>::_W_42);
+static const Pb::Register _R_48("ParticleDataImpl<int>",
+                                "sumMagnitude",
+                                ParticleDataImpl<int>::_W_43);
+static const Pb::Register _R_49("ParticleDataImpl<int>",
+                                "setConstIntFlag",
+                                ParticleDataImpl<int>::_W_44);
+static const Pb::Register _R_50("ParticleDataImpl<int>",
+                                "printPdata",
+                                ParticleDataImpl<int>::_W_45);
+static const Pb::Register _R_51("ParticleDataImpl<int>", "save", ParticleDataImpl<int>::_W_46);
+static const Pb::Register _R_52("ParticleDataImpl<int>", "load", ParticleDataImpl<int>::_W_47);
+static const Pb::Register _R_53("ParticleDataImpl<int>",
+                                "getDataPointer",
+                                ParticleDataImpl<int>::_W_48);
+static const Pb::Register _R_54("ParticleDataImpl<Real>",
+                                "ParticleDataImpl<Real>",
+                                "ParticleDataBase");
+template<> const char *Namify<ParticleDataImpl<Real>>::S = "ParticleDataImpl<Real>";
+static const Pb::Register _R_55("ParticleDataImpl<Real>",
+                                "ParticleDataImpl",
+                                ParticleDataImpl<Real>::_W_22);
+static const Pb::Register _R_56("ParticleDataImpl<Real>", "clear", ParticleDataImpl<Real>::_W_23);
+static const Pb::Register _R_57("ParticleDataImpl<Real>",
+                                "setSource",
+                                ParticleDataImpl<Real>::_W_24);
+static const Pb::Register _R_58("ParticleDataImpl<Real>",
+                                "copyFrom",
+                                ParticleDataImpl<Real>::_W_25);
+static const Pb::Register _R_59("ParticleDataImpl<Real>",
+                                "setConst",
+                                ParticleDataImpl<Real>::_W_26);
+static const Pb::Register _R_60("ParticleDataImpl<Real>",
+                                "setConstRange",
+                                ParticleDataImpl<Real>::_W_27);
+static const Pb::Register _R_61("ParticleDataImpl<Real>", "add", ParticleDataImpl<Real>::_W_28);
+static const Pb::Register _R_62("ParticleDataImpl<Real>", "sub", ParticleDataImpl<Real>::_W_29);
+static const Pb::Register _R_63("ParticleDataImpl<Real>",
+                                "addConst",
+                                ParticleDataImpl<Real>::_W_30);
+static const Pb::Register _R_64("ParticleDataImpl<Real>",
+                                "addScaled",
+                                ParticleDataImpl<Real>::_W_31);
+static const Pb::Register _R_65("ParticleDataImpl<Real>", "mult", ParticleDataImpl<Real>::_W_32);
+static const Pb::Register _R_66("ParticleDataImpl<Real>",
+                                "multConst",
+                                ParticleDataImpl<Real>::_W_33);
+static const Pb::Register _R_67("ParticleDataImpl<Real>",
+                                "safeDiv",
+                                ParticleDataImpl<Real>::_W_34);
+static const Pb::Register _R_68("ParticleDataImpl<Real>", "clamp", ParticleDataImpl<Real>::_W_35);
+static const Pb::Register _R_69("ParticleDataImpl<Real>",
+                                "clampMin",
+                                ParticleDataImpl<Real>::_W_36);
+static const Pb::Register _R_70("ParticleDataImpl<Real>",
+                                "clampMax",
+                                ParticleDataImpl<Real>::_W_37);
+static const Pb::Register _R_71("ParticleDataImpl<Real>",
+                                "getMaxAbs",
+                                ParticleDataImpl<Real>::_W_38);
+static const Pb::Register _R_72("ParticleDataImpl<Real>", "getMax", ParticleDataImpl<Real>::_W_39);
+static const Pb::Register _R_73("ParticleDataImpl<Real>", "getMin", ParticleDataImpl<Real>::_W_40);
+static const Pb::Register _R_74("ParticleDataImpl<Real>", "sum", ParticleDataImpl<Real>::_W_41);
+static const Pb::Register _R_75("ParticleDataImpl<Real>",
+                                "sumSquare",
+                                ParticleDataImpl<Real>::_W_42);
+static const Pb::Register _R_76("ParticleDataImpl<Real>",
+                                "sumMagnitude",
+                                ParticleDataImpl<Real>::_W_43);
+static const Pb::Register _R_77("ParticleDataImpl<Real>",
+                                "setConstIntFlag",
+                                ParticleDataImpl<Real>::_W_44);
+static const Pb::Register _R_78("ParticleDataImpl<Real>",
+                                "printPdata",
+                                ParticleDataImpl<Real>::_W_45);
+static const Pb::Register _R_79("ParticleDataImpl<Real>", "save", ParticleDataImpl<Real>::_W_46);
+static const Pb::Register _R_80("ParticleDataImpl<Real>", "load", ParticleDataImpl<Real>::_W_47);
+static const Pb::Register _R_81("ParticleDataImpl<Real>",
+                                "getDataPointer",
+                                ParticleDataImpl<Real>::_W_48);
+static const Pb::Register _R_82("ParticleDataImpl<Vec3>",
+                                "ParticleDataImpl<Vec3>",
+                                "ParticleDataBase");
+template<> const char *Namify<ParticleDataImpl<Vec3>>::S = "ParticleDataImpl<Vec3>";
+static const Pb::Register _R_83("ParticleDataImpl<Vec3>",
+                                "ParticleDataImpl",
+                                ParticleDataImpl<Vec3>::_W_22);
+static const Pb::Register _R_84("ParticleDataImpl<Vec3>", "clear", ParticleDataImpl<Vec3>::_W_23);
+static const Pb::Register _R_85("ParticleDataImpl<Vec3>",
+                                "setSource",
+                                ParticleDataImpl<Vec3>::_W_24);
+static const Pb::Register _R_86("ParticleDataImpl<Vec3>",
+                                "copyFrom",
+                                ParticleDataImpl<Vec3>::_W_25);
+static const Pb::Register _R_87("ParticleDataImpl<Vec3>",
+                                "setConst",
+                                ParticleDataImpl<Vec3>::_W_26);
+static const Pb::Register _R_88("ParticleDataImpl<Vec3>",
+                                "setConstRange",
+                                ParticleDataImpl<Vec3>::_W_27);
+static const Pb::Register _R_89("ParticleDataImpl<Vec3>", "add", ParticleDataImpl<Vec3>::_W_28);
+static const Pb::Register _R_90("ParticleDataImpl<Vec3>", "sub", ParticleDataImpl<Vec3>::_W_29);
+static const Pb::Register _R_91("ParticleDataImpl<Vec3>",
+                                "addConst",
+                                ParticleDataImpl<Vec3>::_W_30);
+static const Pb::Register _R_92("ParticleDataImpl<Vec3>",
+                                "addScaled",
+                                ParticleDataImpl<Vec3>::_W_31);
+static const Pb::Register _R_93("ParticleDataImpl<Vec3>", "mult", ParticleDataImpl<Vec3>::_W_32);
+static const Pb::Register _R_94("ParticleDataImpl<Vec3>",
+                                "multConst",
+                                ParticleDataImpl<Vec3>::_W_33);
+static const Pb::Register _R_95("ParticleDataImpl<Vec3>",
+                                "safeDiv",
+                                ParticleDataImpl<Vec3>::_W_34);
+static const Pb::Register _R_96("ParticleDataImpl<Vec3>", "clamp", ParticleDataImpl<Vec3>::_W_35);
+static const Pb::Register _R_97("ParticleDataImpl<Vec3>",
+                                "clampMin",
+                                ParticleDataImpl<Vec3>::_W_36);
+static const Pb::Register _R_98("ParticleDataImpl<Vec3>",
+                                "clampMax",
+                                ParticleDataImpl<Vec3>::_W_37);
+static const Pb::Register _R_99("ParticleDataImpl<Vec3>",
+                                "getMaxAbs",
+                                ParticleDataImpl<Vec3>::_W_38);
+static const Pb::Register _R_100("ParticleDataImpl<Vec3>",
+                                 "getMax",
+                                 ParticleDataImpl<Vec3>::_W_39);
+static const Pb::Register _R_101("ParticleDataImpl<Vec3>",
+                                 "getMin",
+                                 ParticleDataImpl<Vec3>::_W_40);
+static const Pb::Register _R_102("ParticleDataImpl<Vec3>", "sum", ParticleDataImpl<Vec3>::_W_41);
+static const Pb::Register _R_103("ParticleDataImpl<Vec3>",
+                                 "sumSquare",
+                                 ParticleDataImpl<Vec3>::_W_42);
+static const Pb::Register _R_104("ParticleDataImpl<Vec3>",
+                                 "sumMagnitude",
+                                 ParticleDataImpl<Vec3>::_W_43);
+static const Pb::Register _R_105("ParticleDataImpl<Vec3>",
+                                 "setConstIntFlag",
+                                 ParticleDataImpl<Vec3>::_W_44);
+static const Pb::Register _R_106("ParticleDataImpl<Vec3>",
+                                 "printPdata",
+                                 ParticleDataImpl<Vec3>::_W_45);
+static const Pb::Register _R_107("ParticleDataImpl<Vec3>", "save", ParticleDataImpl<Vec3>::_W_46);
+static const Pb::Register _R_108("ParticleDataImpl<Vec3>", "load", ParticleDataImpl<Vec3>::_W_47);
+static const Pb::Register _R_109("ParticleDataImpl<Vec3>",
+                                 "getDataPointer",
+                                 ParticleDataImpl<Vec3>::_W_48);
+#endif
+#ifdef _C_ParticleIndexSystem
+static const Pb::Register _R_110("ParticleIndexSystem",
+                                 "ParticleIndexSystem",
+                                 "ParticleSystem<ParticleIndexData>");
+template<> const char *Namify<ParticleIndexSystem>::S = "ParticleIndexSystem";
+static const Pb::Register _R_111("ParticleIndexSystem",
+                                 "ParticleIndexSystem",
+                                 ParticleIndexSystem::_W_19);
+#endif
+#ifdef _C_ParticleSystem
+static const Pb::Register _R_112("ParticleSystem<BasicParticleData>",
+                                 "ParticleSystem<BasicParticleData>",
+                                 "ParticleBase");
+template<>
+const char *Namify<ParticleSystem<BasicParticleData>>::S = "ParticleSystem<BasicParticleData>";
+static const Pb::Register _R_113("ParticleSystem<BasicParticleData>",
+                                 "ParticleSystem",
+                                 ParticleSystem<BasicParticleData>::_W_2);
+static const Pb::Register _R_114("ParticleSystem<BasicParticleData>",
+                                 "pySize",
+                                 ParticleSystem<BasicParticleData>::_W_3);
+static const Pb::Register _R_115("ParticleSystem<BasicParticleData>",
+                                 "setPos",
+                                 ParticleSystem<BasicParticleData>::_W_4);
+static const Pb::Register _R_116("ParticleSystem<BasicParticleData>",
+                                 "getPos",
+                                 ParticleSystem<BasicParticleData>::_W_5);
+static const Pb::Register _R_117("ParticleSystem<BasicParticleData>",
+                                 "getPosPdata",
+                                 ParticleSystem<BasicParticleData>::_W_6);
+static const Pb::Register _R_118("ParticleSystem<BasicParticleData>",
+                                 "setPosPdata",
+                                 ParticleSystem<BasicParticleData>::_W_7);
+static const Pb::Register _R_119("ParticleSystem<BasicParticleData>",
+                                 "clear",
+                                 ParticleSystem<BasicParticleData>::_W_8);
+static const Pb::Register _R_120("ParticleSystem<BasicParticleData>",
+                                 "advectInGrid",
+                                 ParticleSystem<BasicParticleData>::_W_9);
+static const Pb::Register _R_121("ParticleSystem<BasicParticleData>",
+                                 "projectOutside",
+                                 ParticleSystem<BasicParticleData>::_W_10);
+static const Pb::Register _R_122("ParticleSystem<BasicParticleData>",
+                                 "projectOutOfBnd",
+                                 ParticleSystem<BasicParticleData>::_W_11);
+static const Pb::Register _R_123("ParticleSystem<ParticleIndexData>",
+                                 "ParticleSystem<ParticleIndexData>",
+                                 "ParticleBase");
+template<>
+const char *Namify<ParticleSystem<ParticleIndexData>>::S = "ParticleSystem<ParticleIndexData>";
+static const Pb::Register _R_124("ParticleSystem<ParticleIndexData>",
+                                 "ParticleSystem",
+                                 ParticleSystem<ParticleIndexData>::_W_2);
+static const Pb::Register _R_125("ParticleSystem<ParticleIndexData>",
+                                 "pySize",
+                                 ParticleSystem<ParticleIndexData>::_W_3);
+static const Pb::Register _R_126("ParticleSystem<ParticleIndexData>",
+                                 "setPos",
+                                 ParticleSystem<ParticleIndexData>::_W_4);
+static const Pb::Register _R_127("ParticleSystem<ParticleIndexData>",
+                                 "getPos",
+                                 ParticleSystem<ParticleIndexData>::_W_5);
+static const Pb::Register _R_128("ParticleSystem<ParticleIndexData>",
+                                 "getPosPdata",
+                                 ParticleSystem<ParticleIndexData>::_W_6);
+static const Pb::Register _R_129("ParticleSystem<ParticleIndexData>",
+                                 "setPosPdata",
+                                 ParticleSystem<ParticleIndexData>::_W_7);
+static const Pb::Register _R_130("ParticleSystem<ParticleIndexData>",
+                                 "clear",
+                                 ParticleSystem<ParticleIndexData>::_W_8);
+static const Pb::Register _R_131("ParticleSystem<ParticleIndexData>",
+                                 "advectInGrid",
+                                 ParticleSystem<ParticleIndexData>::_W_9);
+static const Pb::Register _R_132("ParticleSystem<ParticleIndexData>",
+                                 "projectOutside",
+                                 ParticleSystem<ParticleIndexData>::_W_10);
+static const Pb::Register _R_133("ParticleSystem<ParticleIndexData>",
+                                 "projectOutOfBnd",
+                                 ParticleSystem<ParticleIndexData>::_W_11);
+#endif
+static const Pb::Register _R_10("ParticleDataImpl<int>", "PdataInt", "");
+static const Pb::Register _R_11("ParticleDataImpl<Real>", "PdataReal", "");
+static const Pb::Register _R_12("ParticleDataImpl<Vec3>", "PdataVec3", "");
+extern "C" {
+void PbRegister_file_10()
+{
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+  KEEP_UNUSED(_R_23);
+  KEEP_UNUSED(_R_24);
+  KEEP_UNUSED(_R_25);
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+  KEEP_UNUSED(_R_33);
+  KEEP_UNUSED(_R_34);
+  KEEP_UNUSED(_R_35);
+  KEEP_UNUSED(_R_36);
+  KEEP_UNUSED(_R_37);
+  KEEP_UNUSED(_R_38);
+  KEEP_UNUSED(_R_39);
+  KEEP_UNUSED(_R_40);
+  KEEP_UNUSED(_R_41);
+  KEEP_UNUSED(_R_42);
+  KEEP_UNUSED(_R_43);
+  KEEP_UNUSED(_R_44);
+  KEEP_UNUSED(_R_45);
+  KEEP_UNUSED(_R_46);
+  KEEP_UNUSED(_R_47);
+  KEEP_UNUSED(_R_48);
+  KEEP_UNUSED(_R_49);
+  KEEP_UNUSED(_R_50);
+  KEEP_UNUSED(_R_51);
+  KEEP_UNUSED(_R_52);
+  KEEP_UNUSED(_R_53);
+  KEEP_UNUSED(_R_54);
+  KEEP_UNUSED(_R_55);
+  KEEP_UNUSED(_R_56);
+  KEEP_UNUSED(_R_57);
+  KEEP_UNUSED(_R_58);
+  KEEP_UNUSED(_R_59);
+  KEEP_UNUSED(_R_60);
+  KEEP_UNUSED(_R_61);
+  KEEP_UNUSED(_R_62);
+  KEEP_UNUSED(_R_63);
+  KEEP_UNUSED(_R_64);
+  KEEP_UNUSED(_R_65);
+  KEEP_UNUSED(_R_66);
+  KEEP_UNUSED(_R_67);
+  KEEP_UNUSED(_R_68);
+  KEEP_UNUSED(_R_69);
+  KEEP_UNUSED(_R_70);
+  KEEP_UNUSED(_R_71);
+  KEEP_UNUSED(_R_72);
+  KEEP_UNUSED(_R_73);
+  KEEP_UNUSED(_R_74);
+  KEEP_UNUSED(_R_75);
+  KEEP_UNUSED(_R_76);
+  KEEP_UNUSED(_R_77);
+  KEEP_UNUSED(_R_78);
+  KEEP_UNUSED(_R_79);
+  KEEP_UNUSED(_R_80);
+  KEEP_UNUSED(_R_81);
+  KEEP_UNUSED(_R_82);
+  KEEP_UNUSED(_R_83);
+  KEEP_UNUSED(_R_84);
+  KEEP_UNUSED(_R_85);
+  KEEP_UNUSED(_R_86);
+  KEEP_UNUSED(_R_87);
+  KEEP_UNUSED(_R_88);
+  KEEP_UNUSED(_R_89);
+  KEEP_UNUSED(_R_90);
+  KEEP_UNUSED(_R_91);
+  KEEP_UNUSED(_R_92);
+  KEEP_UNUSED(_R_93);
+  KEEP_UNUSED(_R_94);
+  KEEP_UNUSED(_R_95);
+  KEEP_UNUSED(_R_96);
+  KEEP_UNUSED(_R_97);
+  KEEP_UNUSED(_R_98);
+  KEEP_UNUSED(_R_99);
+  KEEP_UNUSED(_R_100);
+  KEEP_UNUSED(_R_101);
+  KEEP_UNUSED(_R_102);
+  KEEP_UNUSED(_R_103);
+  KEEP_UNUSED(_R_104);
+  KEEP_UNUSED(_R_105);
+  KEEP_UNUSED(_R_106);
+  KEEP_UNUSED(_R_107);
+  KEEP_UNUSED(_R_108);
+  KEEP_UNUSED(_R_109);
+  KEEP_UNUSED(_R_110);
+  KEEP_UNUSED(_R_111);
+  KEEP_UNUSED(_R_112);
+  KEEP_UNUSED(_R_113);
+  KEEP_UNUSED(_R_114);
+  KEEP_UNUSED(_R_115);
+  KEEP_UNUSED(_R_116);
+  KEEP_UNUSED(_R_117);
+  KEEP_UNUSED(_R_118);
+  KEEP_UNUSED(_R_119);
+  KEEP_UNUSED(_R_120);
+  KEEP_UNUSED(_R_121);
+  KEEP_UNUSED(_R_122);
+  KEEP_UNUSED(_R_123);
+  KEEP_UNUSED(_R_124);
+  KEEP_UNUSED(_R_125);
+  KEEP_UNUSED(_R_126);
+  KEEP_UNUSED(_R_127);
+  KEEP_UNUSED(_R_128);
+  KEEP_UNUSED(_R_129);
+  KEEP_UNUSED(_R_130);
+  KEEP_UNUSED(_R_131);
+  KEEP_UNUSED(_R_132);
+  KEEP_UNUSED(_R_133);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/plugin/advection.cpp b/extern/mantaflow/preprocessed/plugin/advection.cpp
new file mode 100644
index 00000000000..13f53140348
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/advection.cpp
@@ -0,0 +1,1521 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011-2015 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Plugins for advection
+ *
+ ******************************************************************************/
+
+#include "vectorbase.h"
+#include "grid.h"
+#include "kernel.h"
+#include <limits>
+
+using namespace std;
+
+namespace Manta {
+
+//! Semi-Lagrange interpolation kernel
+
+template<class T> struct SemiLagrange : public KernelBase {
+  SemiLagrange(const FlagGrid &flags,
+               const MACGrid &vel,
+               Grid<T> &dst,
+               const Grid<T> &src,
+               Real dt,
+               bool isLevelset,
+               int orderSpace,
+               int orderTrace)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        vel(vel),
+        dst(dst),
+        src(src),
+        dt(dt),
+        isLevelset(isLevelset),
+        orderSpace(orderSpace),
+        orderTrace(orderTrace)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 Grid<T> &dst,
+                 const Grid<T> &src,
+                 Real dt,
+                 bool isLevelset,
+                 int orderSpace,
+                 int orderTrace) const
+  {
+    if (orderTrace == 1) {
+      // traceback position
+      Vec3 pos = Vec3(i + 0.5f, j + 0.5f, k + 0.5f) - vel.getCentered(i, j, k) * dt;
+      dst(i, j, k) = src.getInterpolatedHi(pos, orderSpace);
+    }
+    else if (orderTrace == 2) {
+      // backtracing using explicit midpoint
+      Vec3 p0 = Vec3(i + 0.5f, j + 0.5f, k + 0.5f);
+      Vec3 p1 = p0 - vel.getCentered(i, j, k) * dt * 0.5;
+      Vec3 p2 = p0 - vel.getInterpolated(p1) * dt;
+      dst(i, j, k) = src.getInterpolatedHi(p2, orderSpace);
+    }
+    else {
+      assertMsg(false, "Unknown backtracing order " << orderTrace);
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline Grid<T> &getArg2()
+  {
+    return dst;
+  }
+  typedef Grid<T> type2;
+  inline const Grid<T> &getArg3()
+  {
+    return src;
+  }
+  typedef Grid<T> type3;
+  inline Real &getArg4()
+  {
+    return dt;
+  }
+  typedef Real type4;
+  inline bool &getArg5()
+  {
+    return isLevelset;
+  }
+  typedef bool type5;
+  inline int &getArg6()
+  {
+    return orderSpace;
+  }
+  typedef int type6;
+  inline int &getArg7()
+  {
+    return orderTrace;
+  }
+  typedef int type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel SemiLagrange ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, dst, src, dt, isLevelset, orderSpace, orderTrace);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, dst, src, dt, isLevelset, orderSpace, orderTrace);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  Grid<T> &dst;
+  const Grid<T> &src;
+  Real dt;
+  bool isLevelset;
+  int orderSpace;
+  int orderTrace;
+};
+
+//! Semi-Lagrange interpolation kernel for MAC grids
+
+struct SemiLagrangeMAC : public KernelBase {
+  SemiLagrangeMAC(const FlagGrid &flags,
+                  const MACGrid &vel,
+                  MACGrid &dst,
+                  const MACGrid &src,
+                  Real dt,
+                  int orderSpace,
+                  int orderTrace)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        vel(vel),
+        dst(dst),
+        src(src),
+        dt(dt),
+        orderSpace(orderSpace),
+        orderTrace(orderTrace)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 MACGrid &dst,
+                 const MACGrid &src,
+                 Real dt,
+                 int orderSpace,
+                 int orderTrace) const
+  {
+    if (orderTrace == 1) {
+      // get currect velocity at MAC position
+      // no need to shift xpos etc. as lookup field is also shifted
+      Vec3 xpos = Vec3(i + 0.5f, j + 0.5f, k + 0.5f) - vel.getAtMACX(i, j, k) * dt;
+      Real vx = src.getInterpolatedComponentHi<0>(xpos, orderSpace);
+      Vec3 ypos = Vec3(i + 0.5f, j + 0.5f, k + 0.5f) - vel.getAtMACY(i, j, k) * dt;
+      Real vy = src.getInterpolatedComponentHi<1>(ypos, orderSpace);
+      Vec3 zpos = Vec3(i + 0.5f, j + 0.5f, k + 0.5f) - vel.getAtMACZ(i, j, k) * dt;
+      Real vz = src.getInterpolatedComponentHi<2>(zpos, orderSpace);
+
+      dst(i, j, k) = Vec3(vx, vy, vz);
+    }
+    else if (orderTrace == 2) {
+      Vec3 p0 = Vec3(i + 0.5, j + 0.5, k + 0.5);
+      Vec3 xp0 = Vec3(i, j + 0.5f, k + 0.5f);
+      Vec3 xp1 = xp0 - src.getAtMACX(i, j, k) * dt * 0.5;
+      Vec3 xp2 = p0 - src.getInterpolated(xp1) * dt;
+      Real vx = src.getInterpolatedComponentHi<0>(xp2, orderSpace);
+      Vec3 yp0 = Vec3(i + 0.5f, j, k + 0.5f);
+      Vec3 yp1 = yp0 - src.getAtMACY(i, j, k) * dt * 0.5;
+      Vec3 yp2 = p0 - src.getInterpolated(yp1) * dt;
+      Real vy = src.getInterpolatedComponentHi<1>(yp2, orderSpace);
+      Vec3 zp0 = Vec3(i + 0.5f, j + 0.5f, k);
+      Vec3 zp1 = zp0 - src.getAtMACZ(i, j, k) * dt * 0.5;
+      Vec3 zp2 = p0 - src.getInterpolated(zp1) * dt;
+      Real vz = src.getInterpolatedComponentHi<2>(zp2, orderSpace);
+
+      dst(i, j, k) = Vec3(vx, vy, vz);
+    }
+    else {
+      assertMsg(false, "Unknown backtracing order " << orderTrace);
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline MACGrid &getArg2()
+  {
+    return dst;
+  }
+  typedef MACGrid type2;
+  inline const MACGrid &getArg3()
+  {
+    return src;
+  }
+  typedef MACGrid type3;
+  inline Real &getArg4()
+  {
+    return dt;
+  }
+  typedef Real type4;
+  inline int &getArg5()
+  {
+    return orderSpace;
+  }
+  typedef int type5;
+  inline int &getArg6()
+  {
+    return orderTrace;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel SemiLagrangeMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, dst, src, dt, orderSpace, orderTrace);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, dst, src, dt, orderSpace, orderTrace);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  MACGrid &dst;
+  const MACGrid &src;
+  Real dt;
+  int orderSpace;
+  int orderTrace;
+};
+
+//! Kernel: Correct based on forward and backward SL steps (for both centered & mac grids)
+
+template<class T> struct MacCormackCorrect : public KernelBase {
+  MacCormackCorrect(const FlagGrid &flags,
+                    Grid<T> &dst,
+                    const Grid<T> &old,
+                    const Grid<T> &fwd,
+                    const Grid<T> &bwd,
+                    Real strength,
+                    bool isLevelSet,
+                    bool isMAC = false)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        dst(dst),
+        old(old),
+        fwd(fwd),
+        bwd(bwd),
+        strength(strength),
+        isLevelSet(isLevelSet),
+        isMAC(isMAC)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const FlagGrid &flags,
+                 Grid<T> &dst,
+                 const Grid<T> &old,
+                 const Grid<T> &fwd,
+                 const Grid<T> &bwd,
+                 Real strength,
+                 bool isLevelSet,
+                 bool isMAC = false) const
+  {
+    dst[idx] = fwd[idx];
+
+    if (flags.isFluid(idx)) {
+      // only correct inside fluid region; note, strenth of correction can be modified here
+      dst[idx] += strength * 0.5 * (old[idx] - bwd[idx]);
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<T> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<T> type1;
+  inline const Grid<T> &getArg2()
+  {
+    return old;
+  }
+  typedef Grid<T> type2;
+  inline const Grid<T> &getArg3()
+  {
+    return fwd;
+  }
+  typedef Grid<T> type3;
+  inline const Grid<T> &getArg4()
+  {
+    return bwd;
+  }
+  typedef Grid<T> type4;
+  inline Real &getArg5()
+  {
+    return strength;
+  }
+  typedef Real type5;
+  inline bool &getArg6()
+  {
+    return isLevelSet;
+  }
+  typedef bool type6;
+  inline bool &getArg7()
+  {
+    return isMAC;
+  }
+  typedef bool type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel MacCormackCorrect ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, dst, old, fwd, bwd, strength, isLevelSet, isMAC);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const FlagGrid &flags;
+  Grid<T> &dst;
+  const Grid<T> &old;
+  const Grid<T> &fwd;
+  const Grid<T> &bwd;
+  Real strength;
+  bool isLevelSet;
+  bool isMAC;
+};
+
+//! Kernel: Correct based on forward and backward SL steps (for both centered & mac grids)
+
+template<class T> struct MacCormackCorrectMAC : public KernelBase {
+  MacCormackCorrectMAC(const FlagGrid &flags,
+                       Grid<T> &dst,
+                       const Grid<T> &old,
+                       const Grid<T> &fwd,
+                       const Grid<T> &bwd,
+                       Real strength,
+                       bool isLevelSet,
+                       bool isMAC = false)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        dst(dst),
+        old(old),
+        fwd(fwd),
+        bwd(bwd),
+        strength(strength),
+        isLevelSet(isLevelSet),
+        isMAC(isMAC)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<T> &dst,
+                 const Grid<T> &old,
+                 const Grid<T> &fwd,
+                 const Grid<T> &bwd,
+                 Real strength,
+                 bool isLevelSet,
+                 bool isMAC = false) const
+  {
+    bool skip[3] = {false, false, false};
+
+    if (!flags.isFluid(i, j, k))
+      skip[0] = skip[1] = skip[2] = true;
+    if (isMAC) {
+      if ((i > 0) && (!flags.isFluid(i - 1, j, k)))
+        skip[0] = true;
+      if ((j > 0) && (!flags.isFluid(i, j - 1, k)))
+        skip[1] = true;
+      if ((k > 0) && (!flags.isFluid(i, j, k - 1)))
+        skip[2] = true;
+    }
+
+    for (int c = 0; c < 3; ++c) {
+      if (skip[c]) {
+        dst(i, j, k)[c] = fwd(i, j, k)[c];
+      }
+      else {
+        // perform actual correction with given strength
+        dst(i, j, k)[c] = fwd(i, j, k)[c] + strength * 0.5 * (old(i, j, k)[c] - bwd(i, j, k)[c]);
+      }
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<T> &getArg1()
+  {
+    return dst;
+  }
+  typedef Grid<T> type1;
+  inline const Grid<T> &getArg2()
+  {
+    return old;
+  }
+  typedef Grid<T> type2;
+  inline const Grid<T> &getArg3()
+  {
+    return fwd;
+  }
+  typedef Grid<T> type3;
+  inline const Grid<T> &getArg4()
+  {
+    return bwd;
+  }
+  typedef Grid<T> type4;
+  inline Real &getArg5()
+  {
+    return strength;
+  }
+  typedef Real type5;
+  inline bool &getArg6()
+  {
+    return isLevelSet;
+  }
+  typedef bool type6;
+  inline bool &getArg7()
+  {
+    return isMAC;
+  }
+  typedef bool type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel MacCormackCorrectMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, dst, old, fwd, bwd, strength, isLevelSet, isMAC);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, dst, old, fwd, bwd, strength, isLevelSet, isMAC);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<T> &dst;
+  const Grid<T> &old;
+  const Grid<T> &fwd;
+  const Grid<T> &bwd;
+  Real strength;
+  bool isLevelSet;
+  bool isMAC;
+};
+
+// Helper to collect min/max in a template
+template<class T> inline void getMinMax(T &minv, T &maxv, const T &val)
+{
+  if (val < minv)
+    minv = val;
+  if (val > maxv)
+    maxv = val;
+}
+template<> inline void getMinMax<Vec3>(Vec3 &minv, Vec3 &maxv, const Vec3 &val)
+{
+  getMinMax(minv.x, maxv.x, val.x);
+  getMinMax(minv.y, maxv.y, val.y);
+  getMinMax(minv.z, maxv.z, val.z);
+}
+
+//! detect out of bounds value
+template<class T> inline bool cmpMinMax(T &minv, T &maxv, const T &val)
+{
+  if (val < minv)
+    return true;
+  if (val > maxv)
+    return true;
+  return false;
+}
+template<> inline bool cmpMinMax<Vec3>(Vec3 &minv, Vec3 &maxv, const Vec3 &val)
+{
+  return (cmpMinMax(minv.x, maxv.x, val.x) | cmpMinMax(minv.y, maxv.y, val.y) |
+          cmpMinMax(minv.z, maxv.z, val.z));
+}
+
+#define checkFlag(x, y, z) (flags((x), (y), (z)) & (FlagGrid::TypeFluid | FlagGrid::TypeEmpty))
+
+//! Helper function for clamping non-mac grids (those have specialized per component version below)
+//  Note - 2 clamp modes, a sharper one (default, clampMode 1, also uses backward step),
+//         and a softer version (clampMode 2) that is recommended in Andy's paper
+template<class T>
+inline T doClampComponent(const Vec3i &gridSize,
+                          const FlagGrid &flags,
+                          T dst,
+                          const Grid<T> &orig,
+                          const T fwd,
+                          const Vec3 &pos,
+                          const Vec3 &vel,
+                          const int clampMode)
+{
+  T minv(std::numeric_limits<Real>::max()), maxv(-std::numeric_limits<Real>::max());
+  bool haveFl = false;
+
+  // forward (and optionally) backward
+  Vec3i positions[2];
+  int numPos = 1;
+  positions[0] = toVec3i(pos - vel);
+  if (clampMode == 1) {
+    numPos = 2;
+    positions[1] = toVec3i(pos + vel);
+  }
+
+  for (int l = 0; l < numPos; ++l) {
+    Vec3i &currPos = positions[l];
+
+    // clamp lookup to grid
+    const int i0 = clamp(currPos.x, 0, gridSize.x - 1);  // note! gridsize already has -1 from call
+    const int j0 = clamp(currPos.y, 0, gridSize.y - 1);
+    const int k0 = clamp(currPos.z, 0, (orig.is3D() ? (gridSize.z - 1) : 1));
+    const int i1 = i0 + 1, j1 = j0 + 1, k1 = (orig.is3D() ? (k0 + 1) : k0);
+
+    // find min/max around source pos
+    if (checkFlag(i0, j0, k0)) {
+      getMinMax(minv, maxv, orig(i0, j0, k0));
+      haveFl = true;
+    }
+    if (checkFlag(i1, j0, k0)) {
+      getMinMax(minv, maxv, orig(i1, j0, k0));
+      haveFl = true;
+    }
+    if (checkFlag(i0, j1, k0)) {
+      getMinMax(minv, maxv, orig(i0, j1, k0));
+      haveFl = true;
+    }
+    if (checkFlag(i1, j1, k0)) {
+      getMinMax(minv, maxv, orig(i1, j1, k0));
+      haveFl = true;
+    }
+
+    if (orig.is3D()) {
+      if (checkFlag(i0, j0, k1)) {
+        getMinMax(minv, maxv, orig(i0, j0, k1));
+        haveFl = true;
+      }
+      if (checkFlag(i1, j0, k1)) {
+        getMinMax(minv, maxv, orig(i1, j0, k1));
+        haveFl = true;
+      }
+      if (checkFlag(i0, j1, k1)) {
+        getMinMax(minv, maxv, orig(i0, j1, k1));
+        haveFl = true;
+      }
+      if (checkFlag(i1, j1, k1)) {
+        getMinMax(minv, maxv, orig(i1, j1, k1));
+        haveFl = true;
+      }
+    }
+  }
+
+  if (!haveFl)
+    return fwd;
+  if (clampMode == 1) {
+    dst = clamp(dst, minv, maxv);  // hard clamp
+  }
+  else {
+    if (cmpMinMax(minv, maxv, dst))
+      dst = fwd;  // recommended in paper, "softer"
+  }
+  return dst;
+}
+
+//! Helper function for clamping MAC grids, slight differences in flag checks
+//  similar to scalar version, just uses single component c of vec3 values
+//  for symmetry, reverts to first order near boundaries for clampMode 2
+template<int c>
+inline Real doClampComponentMAC(const FlagGrid &flags,
+                                const Vec3i &gridSize,
+                                Real dst,
+                                const MACGrid &orig,
+                                Real fwd,
+                                const Vec3 &pos,
+                                const Vec3 &vel,
+                                const int clampMode)
+{
+  Real minv = std::numeric_limits<Real>::max(), maxv = -std::numeric_limits<Real>::max();
+  // bool haveFl = false;
+
+  // forward (and optionally) backward
+  Vec3i positions[2];
+  int numPos = 1;
+  positions[0] = toVec3i(pos - vel);
+  if (clampMode == 1) {
+    numPos = 2;
+    positions[1] = toVec3i(pos + vel);
+  }
+
+  Vec3i oPos = toVec3i(pos);
+  Vec3i nbPos = oPos;
+  nbPos[c] -= 1;
+  if (clampMode == 2 &&
+      (!(checkFlag(oPos.x, oPos.y, oPos.z) && checkFlag(nbPos.x, nbPos.y, nbPos.z))))
+    return fwd;  // replaces haveFl check
+
+  for (int l = 0; l < numPos; ++l) {
+    Vec3i &currPos = positions[l];
+
+    const int i0 = clamp(currPos.x, 0, gridSize.x - 1);  // note! gridsize already has -1 from call
+    const int j0 = clamp(
+        currPos.y, 0, gridSize.y - 1);  // but we need a clamp to -2 for the +1 offset below
+    const int k0 = clamp(currPos.z, 0, (orig.is3D() ? (gridSize.z - 1) : 0));
+    const int i1 = i0 + 1, j1 = j0 + 1, k1 = (orig.is3D() ? (k0 + 1) : k0);
+
+    // find min/max around source pos
+    getMinMax(minv, maxv, orig(i0, j0, k0)[c]);
+    getMinMax(minv, maxv, orig(i1, j0, k0)[c]);
+    getMinMax(minv, maxv, orig(i0, j1, k0)[c]);
+    getMinMax(minv, maxv, orig(i1, j1, k0)[c]);
+
+    if (orig.is3D()) {
+      getMinMax(minv, maxv, orig(i0, j0, k1)[c]);
+      getMinMax(minv, maxv, orig(i1, j0, k1)[c]);
+      getMinMax(minv, maxv, orig(i0, j1, k1)[c]);
+      getMinMax(minv, maxv, orig(i1, j1, k1)[c]);
+    }
+  }
+
+  if (clampMode == 1) {
+    dst = clamp(dst, minv, maxv);  // hard clamp
+  }
+  else {
+    if (cmpMinMax(minv, maxv, dst))
+      dst = fwd;  // recommended in paper, "softer"
+  }
+  return dst;
+}
+
+#undef checkFlag
+
+//! Kernel: Clamp obtained value to min/max in source area, and reset values that point out of grid
+//! or into boundaries
+//          (note - MAC grids are handled below)
+
+template<class T> struct MacCormackClamp : public KernelBase {
+  MacCormackClamp(const FlagGrid &flags,
+                  const MACGrid &vel,
+                  Grid<T> &dst,
+                  const Grid<T> &orig,
+                  const Grid<T> &fwd,
+                  Real dt,
+                  const int clampMode)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        vel(vel),
+        dst(dst),
+        orig(orig),
+        fwd(fwd),
+        dt(dt),
+        clampMode(clampMode)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 Grid<T> &dst,
+                 const Grid<T> &orig,
+                 const Grid<T> &fwd,
+                 Real dt,
+                 const int clampMode) const
+  {
+    T dval = dst(i, j, k);
+    Vec3i gridUpper = flags.getSize() - 1;
+
+    dval = doClampComponent<T>(gridUpper,
+                               flags,
+                               dval,
+                               orig,
+                               fwd(i, j, k),
+                               Vec3(i, j, k),
+                               vel.getCentered(i, j, k) * dt,
+                               clampMode);
+
+    if (1 && clampMode == 1) {
+      // lookup forward/backward , round to closest NB
+      Vec3i posFwd = toVec3i(Vec3(i, j, k) + Vec3(0.5, 0.5, 0.5) - vel.getCentered(i, j, k) * dt);
+      Vec3i posBwd = toVec3i(Vec3(i, j, k) + Vec3(0.5, 0.5, 0.5) + vel.getCentered(i, j, k) * dt);
+
+      // test if lookups point out of grid or into obstacle (note doClampComponent already checks
+      // sides, below is needed for valid flags access)
+      if (posFwd.x < 0 || posFwd.y < 0 || posFwd.z < 0 || posBwd.x < 0 || posBwd.y < 0 ||
+          posBwd.z < 0 || posFwd.x > gridUpper.x || posFwd.y > gridUpper.y ||
+          ((posFwd.z > gridUpper.z) && flags.is3D()) || posBwd.x > gridUpper.x ||
+          posBwd.y > gridUpper.y || ((posBwd.z > gridUpper.z) && flags.is3D()) ||
+          flags.isObstacle(posFwd) || flags.isObstacle(posBwd)) {
+        dval = fwd(i, j, k);
+      }
+    }
+    // clampMode 2 handles flags in doClampComponent call
+
+    dst(i, j, k) = dval;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline Grid<T> &getArg2()
+  {
+    return dst;
+  }
+  typedef Grid<T> type2;
+  inline const Grid<T> &getArg3()
+  {
+    return orig;
+  }
+  typedef Grid<T> type3;
+  inline const Grid<T> &getArg4()
+  {
+    return fwd;
+  }
+  typedef Grid<T> type4;
+  inline Real &getArg5()
+  {
+    return dt;
+  }
+  typedef Real type5;
+  inline const int &getArg6()
+  {
+    return clampMode;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel MacCormackClamp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, dst, orig, fwd, dt, clampMode);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, dst, orig, fwd, dt, clampMode);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  Grid<T> &dst;
+  const Grid<T> &orig;
+  const Grid<T> &fwd;
+  Real dt;
+  const int clampMode;
+};
+
+//! Kernel: same as MacCormackClamp above, but specialized version for MAC grids
+
+struct MacCormackClampMAC : public KernelBase {
+  MacCormackClampMAC(const FlagGrid &flags,
+                     const MACGrid &vel,
+                     MACGrid &dst,
+                     const MACGrid &orig,
+                     const MACGrid &fwd,
+                     Real dt,
+                     const int clampMode)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        vel(vel),
+        dst(dst),
+        orig(orig),
+        fwd(fwd),
+        dt(dt),
+        clampMode(clampMode)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 MACGrid &dst,
+                 const MACGrid &orig,
+                 const MACGrid &fwd,
+                 Real dt,
+                 const int clampMode) const
+  {
+    Vec3 pos(i, j, k);
+    Vec3 dval = dst(i, j, k);
+    Vec3 dfwd = fwd(i, j, k);
+    Vec3i gridUpper = flags.getSize() - 1;
+
+    dval.x = doClampComponentMAC<0>(
+        flags, gridUpper, dval.x, orig, dfwd.x, pos, vel.getAtMACX(i, j, k) * dt, clampMode);
+    dval.y = doClampComponentMAC<1>(
+        flags, gridUpper, dval.y, orig, dfwd.y, pos, vel.getAtMACY(i, j, k) * dt, clampMode);
+    if (flags.is3D())
+      dval.z = doClampComponentMAC<2>(
+          flags, gridUpper, dval.z, orig, dfwd.z, pos, vel.getAtMACZ(i, j, k) * dt, clampMode);
+
+    // note - the MAC version currently does not check whether source points were inside an
+    // obstacle! (unlike centered version) this would need to be done for each face separately to
+    // stay symmetric...
+
+    dst(i, j, k) = dval;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline MACGrid &getArg2()
+  {
+    return dst;
+  }
+  typedef MACGrid type2;
+  inline const MACGrid &getArg3()
+  {
+    return orig;
+  }
+  typedef MACGrid type3;
+  inline const MACGrid &getArg4()
+  {
+    return fwd;
+  }
+  typedef MACGrid type4;
+  inline Real &getArg5()
+  {
+    return dt;
+  }
+  typedef Real type5;
+  inline const int &getArg6()
+  {
+    return clampMode;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel MacCormackClampMAC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, dst, orig, fwd, dt, clampMode);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, dst, orig, fwd, dt, clampMode);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  MACGrid &dst;
+  const MACGrid &orig;
+  const MACGrid &fwd;
+  Real dt;
+  const int clampMode;
+};
+
+//! template function for performing SL advection
+//! (Note boundary width only needed for specialization for MAC grids below)
+template<class GridType>
+void fnAdvectSemiLagrange(FluidSolver *parent,
+                          const FlagGrid &flags,
+                          const MACGrid &vel,
+                          GridType &orig,
+                          int order,
+                          Real strength,
+                          int orderSpace,
+                          int clampMode,
+                          int orderTrace)
+{
+  typedef typename GridType::BASETYPE T;
+
+  Real dt = parent->getDt();
+  bool levelset = orig.getType() & GridBase::TypeLevelset;
+
+  // forward step
+  GridType fwd(parent);
+  SemiLagrange<T>(flags, vel, fwd, orig, dt, levelset, orderSpace, orderTrace);
+
+  if (order == 1) {
+    orig.swap(fwd);
+  }
+  else if (order == 2) {  // MacCormack
+    GridType bwd(parent);
+    GridType newGrid(parent);
+
+    // bwd <- backwards step
+    SemiLagrange<T>(flags, vel, bwd, fwd, -dt, levelset, orderSpace, orderTrace);
+
+    // newGrid <- compute correction
+    MacCormackCorrect<T>(flags, newGrid, orig, fwd, bwd, strength, levelset);
+
+    // clamp values
+    MacCormackClamp<T>(flags, vel, newGrid, orig, fwd, dt, clampMode);
+
+    orig.swap(newGrid);
+  }
+}
+
+// outflow functions
+
+//! calculate local propagation velocity for cell (i,j,k)
+Vec3 getBulkVel(const FlagGrid &flags, const MACGrid &vel, int i, int j, int k)
+{
+  Vec3 avg = Vec3(0.);
+  int count = 0;
+  int size = 1;  // stencil size
+  int nmax = (flags.is3D() ? size : 0);
+  // average the neighboring fluid / outflow cell's velocity
+  for (int n = -nmax; n <= nmax; n++) {
+    for (int m = -size; m <= size; m++) {
+      for (int l = -size; l <= size; l++) {
+        if (flags.isInBounds(Vec3i(i + l, j + m, k + n)) &&
+            (flags.isFluid(i + l, j + m, k + n) || flags.isOutflow(i + l, j + m, k + n))) {
+          avg += vel(i + l, j + m, k + n);
+          count++;
+        }
+      }
+    }
+  }
+  return count > 0 ? avg / count : avg;
+}
+
+//! extrapolate normal velocity components into outflow cell
+struct extrapolateVelConvectiveBC : public KernelBase {
+  extrapolateVelConvectiveBC(const FlagGrid &flags,
+                             const MACGrid &vel,
+                             MACGrid &velDst,
+                             const MACGrid &velPrev,
+                             Real timeStep)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        vel(vel),
+        velDst(velDst),
+        velPrev(velPrev),
+        timeStep(timeStep)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 MACGrid &velDst,
+                 const MACGrid &velPrev,
+                 Real timeStep) const
+  {
+    if (flags.isOutflow(i, j, k)) {
+      Vec3 bulkVel = getBulkVel(flags, vel, i, j, k);
+      int dim = flags.is3D() ? 3 : 2;
+      const Vec3i cur = Vec3i(i, j, k);
+      Vec3i low, up, flLow, flUp;
+      int cnt = 0;
+      // iterate over each velocity component x, y, z
+      for (int c = 0; c < dim; c++) {
+        low = up = flLow = flUp = cur;
+        Real factor = timeStep *
+                      max((Real)1.0, bulkVel[c]);  // prevent the extrapolated velocity from
+                                                   // exploding when bulk velocity below 1
+        low[c] = flLow[c] = cur[c] - 1;
+        up[c] = flUp[c] = cur[c] + 1;
+        // iterate over bWidth to allow for extrapolation into more distant outflow cells;
+        // hard-coded extrapolation distance of two cells
+        for (int d = 0; d < 2; d++) {
+          bool extrapolateFromLower = flags.isInBounds(flLow) && flags.isFluid(flLow);
+          bool extrapolateFromUpper = flags.isInBounds(flUp) && flags.isFluid(flUp);
+          if (extrapolateFromLower || extrapolateFromUpper) {
+            if (extrapolateFromLower) {
+              velDst(i, j, k) += ((vel(i, j, k) - velPrev(i, j, k)) / factor) + vel(low);
+              cnt++;
+            }
+            if (extrapolateFromUpper) {
+              // check for cells equally far away from two fluid cells -> average value between
+              // both sides
+              velDst(i, j, k) += ((vel(i, j, k) - velPrev(i, j, k)) / factor) + vel(up);
+              cnt++;
+            }
+            break;
+          }
+          flLow[c]--;
+          flUp[c]++;
+        }
+      }
+      if (cnt > 0)
+        velDst(i, j, k) /= cnt;
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline MACGrid &getArg2()
+  {
+    return velDst;
+  }
+  typedef MACGrid type2;
+  inline const MACGrid &getArg3()
+  {
+    return velPrev;
+  }
+  typedef MACGrid type3;
+  inline Real &getArg4()
+  {
+    return timeStep;
+  }
+  typedef Real type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel extrapolateVelConvectiveBC ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, vel, velDst, velPrev, timeStep);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, vel, velDst, velPrev, timeStep);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  MACGrid &velDst;
+  const MACGrid &velPrev;
+  Real timeStep;
+};
+
+//! copy extrapolated velocity components
+struct copyChangedVels : public KernelBase {
+  copyChangedVels(const FlagGrid &flags, const MACGrid &velDst, MACGrid &vel)
+      : KernelBase(&flags, 0), flags(flags), velDst(velDst), vel(vel)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const FlagGrid &flags, const MACGrid &velDst, MACGrid &vel) const
+  {
+    if (flags.isOutflow(i, j, k))
+      vel(i, j, k) = velDst(i, j, k);
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return velDst;
+  }
+  typedef MACGrid type1;
+  inline MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel copyChangedVels ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, velDst, vel);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, velDst, vel);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &velDst;
+  MACGrid &vel;
+};
+
+//! extrapolate normal velocity components into open boundary cells (marked as outflow cells)
+void applyOutflowBC(const FlagGrid &flags, MACGrid &vel, const MACGrid &velPrev, double timeStep)
+{
+  MACGrid velDst(vel.getParent());  // do not overwrite vel while it is read
+  extrapolateVelConvectiveBC(flags, vel, velDst, velPrev, max(1.0, timeStep * 4));
+  copyChangedVels(flags, velDst, vel);
+}
+
+// advection helpers
+
+//! prevent parts of the surface getting "stuck" in obstacle regions
+struct knResetPhiInObs : public KernelBase {
+  knResetPhiInObs(const FlagGrid &flags, Grid<Real> &sdf)
+      : KernelBase(&flags, 0), flags(flags), sdf(sdf)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const FlagGrid &flags, Grid<Real> &sdf) const
+  {
+    if (flags.isObstacle(i, j, k) && (sdf(i, j, k) < 0.)) {
+      sdf(i, j, k) = 0.1;
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return sdf;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knResetPhiInObs ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, sdf);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, sdf);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &sdf;
+};
+void resetPhiInObs(const FlagGrid &flags, Grid<Real> &sdf)
+{
+  knResetPhiInObs(flags, sdf);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "resetPhiInObs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &sdf = *_args.getPtr<Grid<Real>>("sdf", 1, &_lock);
+      _retval = getPyNone();
+      resetPhiInObs(flags, sdf);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "resetPhiInObs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("resetPhiInObs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_resetPhiInObs("", "resetPhiInObs", _W_0);
+extern "C" {
+void PbRegister_resetPhiInObs()
+{
+  KEEP_UNUSED(_RP_resetPhiInObs);
+}
+}
+
+// advection main calls
+
+//! template function for performing SL advection: specialized version for MAC grids
+template<>
+void fnAdvectSemiLagrange<MACGrid>(FluidSolver *parent,
+                                   const FlagGrid &flags,
+                                   const MACGrid &vel,
+                                   MACGrid &orig,
+                                   int order,
+                                   Real strength,
+                                   int orderSpace,
+                                   int clampMode,
+                                   int orderTrace)
+{
+  Real dt = parent->getDt();
+
+  // forward step
+  MACGrid fwd(parent);
+  SemiLagrangeMAC(flags, vel, fwd, orig, dt, orderSpace, orderTrace);
+
+  if (orderSpace != 1) {
+    debMsg("Warning higher order for MAC grids not yet implemented...", 1);
+  }
+
+  if (order == 1) {
+    applyOutflowBC(flags, fwd, orig, dt);
+    orig.swap(fwd);
+  }
+  else if (order == 2) {  // MacCormack
+    MACGrid bwd(parent);
+    MACGrid newGrid(parent);
+
+    // bwd <- backwards step
+    SemiLagrangeMAC(flags, vel, bwd, fwd, -dt, orderSpace, orderTrace);
+
+    // newGrid <- compute correction
+    MacCormackCorrectMAC<Vec3>(flags, newGrid, orig, fwd, bwd, strength, false, true);
+
+    // clamp values
+    MacCormackClampMAC(flags, vel, newGrid, orig, fwd, dt, clampMode);
+
+    applyOutflowBC(flags, newGrid, orig, dt);
+    orig.swap(newGrid);
+  }
+}
+
+//! Perform semi-lagrangian advection of target Real- or Vec3 grid
+//! Open boundary handling needs information about width of border
+//! Clamping modes: 1 regular clamp leading to more overshoot and sharper results, 2 revert to 1st
+//! order slightly smoother less overshoot (enable when 1 gives artifacts)
+
+void advectSemiLagrange(const FlagGrid *flags,
+                        const MACGrid *vel,
+                        GridBase *grid,
+                        int order = 1,
+                        Real strength = 1.0,
+                        int orderSpace = 1,
+                        bool openBounds = false,
+                        int boundaryWidth = -1,
+                        int clampMode = 2,
+                        int orderTrace = 1)
+{
+  assertMsg(order == 1 || order == 2,
+            "AdvectSemiLagrange: Only order 1 (regular SL) and 2 (MacCormack) supported");
+  if ((boundaryWidth != -1) || (openBounds)) {
+    debMsg(
+        "Warning: boundaryWidth and openBounds parameters in AdvectSemiLagrange plugin are "
+        "deprecated (and have no more effect), please remove.",
+        0);
+  }
+
+  // determine type of grid
+  if (grid->getType() & GridBase::TypeReal) {
+    fnAdvectSemiLagrange<Grid<Real>>(flags->getParent(),
+                                     *flags,
+                                     *vel,
+                                     *((Grid<Real> *)grid),
+                                     order,
+                                     strength,
+                                     orderSpace,
+                                     clampMode,
+                                     orderTrace);
+  }
+  else if (grid->getType() & GridBase::TypeMAC) {
+    fnAdvectSemiLagrange<MACGrid>(flags->getParent(),
+                                  *flags,
+                                  *vel,
+                                  *((MACGrid *)grid),
+                                  order,
+                                  strength,
+                                  orderSpace,
+                                  clampMode,
+                                  orderTrace);
+  }
+  else if (grid->getType() & GridBase::TypeVec3) {
+    fnAdvectSemiLagrange<Grid<Vec3>>(flags->getParent(),
+                                     *flags,
+                                     *vel,
+                                     *((Grid<Vec3> *)grid),
+                                     order,
+                                     strength,
+                                     orderSpace,
+                                     clampMode,
+                                     orderTrace);
+  }
+  else
+    errMsg("AdvectSemiLagrange: Grid Type is not supported (only Real, Vec3, MAC, Levelset)");
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "advectSemiLagrange", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid *flags = _args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const MACGrid *vel = _args.getPtr<MACGrid>("vel", 1, &_lock);
+      GridBase *grid = _args.getPtr<GridBase>("grid", 2, &_lock);
+      int order = _args.getOpt<int>("order", 3, 1, &_lock);
+      Real strength = _args.getOpt<Real>("strength", 4, 1.0, &_lock);
+      int orderSpace = _args.getOpt<int>("orderSpace", 5, 1, &_lock);
+      bool openBounds = _args.getOpt<bool>("openBounds", 6, false, &_lock);
+      int boundaryWidth = _args.getOpt<int>("boundaryWidth", 7, -1, &_lock);
+      int clampMode = _args.getOpt<int>("clampMode", 8, 2, &_lock);
+      int orderTrace = _args.getOpt<int>("orderTrace", 9, 1, &_lock);
+      _retval = getPyNone();
+      advectSemiLagrange(flags,
+                         vel,
+                         grid,
+                         order,
+                         strength,
+                         orderSpace,
+                         openBounds,
+                         boundaryWidth,
+                         clampMode,
+                         orderTrace);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "advectSemiLagrange", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("advectSemiLagrange", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_advectSemiLagrange("", "advectSemiLagrange", _W_1);
+extern "C" {
+void PbRegister_advectSemiLagrange()
+{
+  KEEP_UNUSED(_RP_advectSemiLagrange);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/apic.cpp b/extern/mantaflow/preprocessed/plugin/apic.cpp
new file mode 100644
index 00000000000..6ff893014c9
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/apic.cpp
@@ -0,0 +1,496 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+// ----------------------------------------------------------------------------
+//
+// MantaFlow fluid solver framework
+// Copyright 2016-2017 Kiwon Um, Nils Thuerey
+//
+// This program is free software, distributed under the terms of the
+// Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Affine Particle-In-Cell
+//
+// ----------------------------------------------------------------------------
+
+#include "particle.h"
+#include "grid.h"
+
+namespace Manta {
+
+struct knApicMapLinearVec3ToMACGrid : public KernelBase {
+  knApicMapLinearVec3ToMACGrid(const BasicParticleSystem &p,
+                               MACGrid &mg,
+                               MACGrid &vg,
+                               const ParticleDataImpl<Vec3> &vp,
+                               const ParticleDataImpl<Vec3> &cpx,
+                               const ParticleDataImpl<Vec3> &cpy,
+                               const ParticleDataImpl<Vec3> &cpz,
+                               const ParticleDataImpl<int> *ptype,
+                               const int exclude)
+      : KernelBase(p.size()),
+        p(p),
+        mg(mg),
+        vg(vg),
+        vp(vp),
+        cpx(cpx),
+        cpy(cpy),
+        cpz(cpz),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 MACGrid &mg,
+                 MACGrid &vg,
+                 const ParticleDataImpl<Vec3> &vp,
+                 const ParticleDataImpl<Vec3> &cpx,
+                 const ParticleDataImpl<Vec3> &cpy,
+                 const ParticleDataImpl<Vec3> &cpz,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude)
+  {
+    if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+    const IndexInt dX[2] = {0, vg.getStrideX()};
+    const IndexInt dY[2] = {0, vg.getStrideY()};
+    const IndexInt dZ[2] = {0, vg.getStrideZ()};
+
+    const Vec3 &pos = p[idx].pos, &vel = vp[idx];
+    const IndexInt fi = static_cast<IndexInt>(pos.x), fj = static_cast<IndexInt>(pos.y),
+                   fk = static_cast<IndexInt>(pos.z);
+    const IndexInt ci = static_cast<IndexInt>(pos.x - 0.5),
+                   cj = static_cast<IndexInt>(pos.y - 0.5),
+                   ck = static_cast<IndexInt>(pos.z - 0.5);
+    const Real wfi = clamp(pos.x - fi, Real(0), Real(1)),
+               wfj = clamp(pos.y - fj, Real(0), Real(1)),
+               wfk = clamp(pos.z - fk, Real(0), Real(1));
+    const Real wci = clamp(Real(pos.x - ci - 0.5), Real(0), Real(1)),
+               wcj = clamp(Real(pos.y - cj - 0.5), Real(0), Real(1)),
+               wck = clamp(Real(pos.z - ck - 0.5), Real(0), Real(1));
+    // TODO: check index for safety
+    {  // u-face
+      const IndexInt gidx = fi * dX[1] + cj * dY[1] + ck * dZ[1];
+      const Vec3 gpos(fi, cj + 0.5, ck + 0.5);
+      const Real wi[2] = {Real(1) - wfi, wfi};
+      const Real wj[2] = {Real(1) - wcj, wcj};
+      const Real wk[2] = {Real(1) - wck, wck};
+      for (int i = 0; i < 2; ++i)
+        for (int j = 0; j < 2; ++j)
+          for (int k = 0; k < 2; ++k) {
+            const Real w = wi[i] * wj[j] * wk[k];
+            mg[gidx + dX[i] + dY[j] + dZ[k]].x += w;
+            vg[gidx + dX[i] + dY[j] + dZ[k]].x += w * vel.x;
+            vg[gidx + dX[i] + dY[j] + dZ[k]].x += w * dot(cpx[idx], gpos + Vec3(i, j, k) - pos);
+          }
+    }
+    {  // v-face
+      const IndexInt gidx = ci * dX[1] + fj * dY[1] + ck * dZ[1];
+      const Vec3 gpos(ci + 0.5, fj, ck + 0.5);
+      const Real wi[2] = {Real(1) - wci, wci};
+      const Real wj[2] = {Real(1) - wfj, wfj};
+      const Real wk[2] = {Real(1) - wck, wck};
+      for (int i = 0; i < 2; ++i)
+        for (int j = 0; j < 2; ++j)
+          for (int k = 0; k < 2; ++k) {
+            const Real w = wi[i] * wj[j] * wk[k];
+            mg[gidx + dX[i] + dY[j] + dZ[k]].y += w;
+            vg[gidx + dX[i] + dY[j] + dZ[k]].y += w * vel.y;
+            vg[gidx + dX[i] + dY[j] + dZ[k]].y += w * dot(cpy[idx], gpos + Vec3(i, j, k) - pos);
+          }
+    }
+    if (!vg.is3D())
+      return;
+    {  // w-face
+      const IndexInt gidx = ci * dX[1] + cj * dY[1] + fk * dZ[1];
+      const Vec3 gpos(ci + 0.5, cj + 0.5, fk);
+      const Real wi[2] = {Real(1) - wci, wci};
+      const Real wj[2] = {Real(1) - wcj, wcj};
+      const Real wk[2] = {Real(1) - wfk, wfk};
+      for (int i = 0; i < 2; ++i)
+        for (int j = 0; j < 2; ++j)
+          for (int k = 0; k < 2; ++k) {
+            const Real w = wi[i] * wj[j] * wk[k];
+            mg[gidx + dX[i] + dY[j] + dZ[k]].z += w;
+            vg[gidx + dX[i] + dY[j] + dZ[k]].z += w * vel.z;
+            vg[gidx + dX[i] + dY[j] + dZ[k]].z += w * dot(cpz[idx], gpos + Vec3(i, j, k) - pos);
+          }
+    }
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline MACGrid &getArg1()
+  {
+    return mg;
+  }
+  typedef MACGrid type1;
+  inline MACGrid &getArg2()
+  {
+    return vg;
+  }
+  typedef MACGrid type2;
+  inline const ParticleDataImpl<Vec3> &getArg3()
+  {
+    return vp;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline const ParticleDataImpl<Vec3> &getArg4()
+  {
+    return cpx;
+  }
+  typedef ParticleDataImpl<Vec3> type4;
+  inline const ParticleDataImpl<Vec3> &getArg5()
+  {
+    return cpy;
+  }
+  typedef ParticleDataImpl<Vec3> type5;
+  inline const ParticleDataImpl<Vec3> &getArg6()
+  {
+    return cpz;
+  }
+  typedef ParticleDataImpl<Vec3> type6;
+  inline const ParticleDataImpl<int> *getArg7()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type7;
+  inline const int &getArg8()
+  {
+    return exclude;
+  }
+  typedef int type8;
+  void runMessage()
+  {
+    debMsg("Executing kernel knApicMapLinearVec3ToMACGrid ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void run()
+  {
+    const IndexInt _sz = size;
+    for (IndexInt i = 0; i < _sz; i++)
+      op(i, p, mg, vg, vp, cpx, cpy, cpz, ptype, exclude);
+  }
+  const BasicParticleSystem &p;
+  MACGrid &mg;
+  MACGrid &vg;
+  const ParticleDataImpl<Vec3> &vp;
+  const ParticleDataImpl<Vec3> &cpx;
+  const ParticleDataImpl<Vec3> &cpy;
+  const ParticleDataImpl<Vec3> &cpz;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+void apicMapPartsToMAC(const FlagGrid &flags,
+                       MACGrid &vel,
+                       const BasicParticleSystem &parts,
+                       const ParticleDataImpl<Vec3> &partVel,
+                       const ParticleDataImpl<Vec3> &cpx,
+                       const ParticleDataImpl<Vec3> &cpy,
+                       const ParticleDataImpl<Vec3> &cpz,
+                       MACGrid *mass = NULL,
+                       const ParticleDataImpl<int> *ptype = NULL,
+                       const int exclude = 0)
+{
+  // affine map
+  // let's assume that the particle mass is constant, 1.0
+  const bool freeMass = !mass;
+  if (!mass)
+    mass = new MACGrid(flags.getParent());
+  else
+    mass->clear();
+
+  vel.clear();
+  knApicMapLinearVec3ToMACGrid(parts, *mass, vel, partVel, cpx, cpy, cpz, ptype, exclude);
+  mass->stomp(VECTOR_EPSILON);
+  vel.safeDivide(*mass);
+
+  if (freeMass)
+    delete mass;
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "apicMapPartsToMAC", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 2, &_lock);
+      const ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "partVel", 3, &_lock);
+      const ParticleDataImpl<Vec3> &cpx = *_args.getPtr<ParticleDataImpl<Vec3>>("cpx", 4, &_lock);
+      const ParticleDataImpl<Vec3> &cpy = *_args.getPtr<ParticleDataImpl<Vec3>>("cpy", 5, &_lock);
+      const ParticleDataImpl<Vec3> &cpz = *_args.getPtr<ParticleDataImpl<Vec3>>("cpz", 6, &_lock);
+      MACGrid *mass = _args.getPtrOpt<MACGrid>("mass", 7, NULL, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 8, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 9, 0, &_lock);
+      _retval = getPyNone();
+      apicMapPartsToMAC(flags, vel, parts, partVel, cpx, cpy, cpz, mass, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "apicMapPartsToMAC", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("apicMapPartsToMAC", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_apicMapPartsToMAC("", "apicMapPartsToMAC", _W_0);
+extern "C" {
+void PbRegister_apicMapPartsToMAC()
+{
+  KEEP_UNUSED(_RP_apicMapPartsToMAC);
+}
+}
+
+struct knApicMapLinearMACGridToVec3 : public KernelBase {
+  knApicMapLinearMACGridToVec3(ParticleDataImpl<Vec3> &vp,
+                               ParticleDataImpl<Vec3> &cpx,
+                               ParticleDataImpl<Vec3> &cpy,
+                               ParticleDataImpl<Vec3> &cpz,
+                               const BasicParticleSystem &p,
+                               const MACGrid &vg,
+                               const FlagGrid &flags,
+                               const ParticleDataImpl<int> *ptype,
+                               const int exclude)
+      : KernelBase(vp.size()),
+        vp(vp),
+        cpx(cpx),
+        cpy(cpy),
+        cpz(cpz),
+        p(p),
+        vg(vg),
+        flags(flags),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ParticleDataImpl<Vec3> &vp,
+                 ParticleDataImpl<Vec3> &cpx,
+                 ParticleDataImpl<Vec3> &cpy,
+                 ParticleDataImpl<Vec3> &cpz,
+                 const BasicParticleSystem &p,
+                 const MACGrid &vg,
+                 const FlagGrid &flags,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+
+    vp[idx] = cpx[idx] = cpy[idx] = cpz[idx] = Vec3(Real(0));
+    const IndexInt dX[2] = {0, vg.getStrideX()}, dY[2] = {0, vg.getStrideY()},
+                   dZ[2] = {0, vg.getStrideZ()};
+    const Real gw[2] = {-Real(1), Real(1)};
+
+    const Vec3 &pos = p[idx].pos;
+    const IndexInt fi = static_cast<IndexInt>(pos.x), fj = static_cast<IndexInt>(pos.y),
+                   fk = static_cast<IndexInt>(pos.z);
+    const IndexInt ci = static_cast<IndexInt>(pos.x - 0.5),
+                   cj = static_cast<IndexInt>(pos.y - 0.5),
+                   ck = static_cast<IndexInt>(pos.z - 0.5);
+    const Real wfi = clamp(pos.x - fi, Real(0), Real(1)),
+               wfj = clamp(pos.y - fj, Real(0), Real(1)),
+               wfk = clamp(pos.z - fk, Real(0), Real(1));
+    const Real wci = clamp(Real(pos.x - ci - 0.5), Real(0), Real(1)),
+               wcj = clamp(Real(pos.y - cj - 0.5), Real(0), Real(1)),
+               wck = clamp(Real(pos.z - ck - 0.5), Real(0), Real(1));
+    // TODO: check index for safety
+    {  // u
+      const IndexInt gidx = fi * dX[1] + cj * dY[1] + ck * dZ[1];
+      const Real wx[2] = {Real(1) - wfi, wfi};
+      const Real wy[2] = {Real(1) - wcj, wcj};
+      const Real wz[2] = {Real(1) - wck, wck};
+      for (int i = 0; i < 2; ++i)
+        for (int j = 0; j < 2; ++j)
+          for (int k = 0; k < 2; ++k) {
+            const IndexInt vidx = gidx + dX[i] + dY[j] + dZ[k];
+            Real vgx = vg[vidx].x;
+            vp[idx].x += wx[i] * wy[j] * wz[k] * vgx;
+            cpx[idx].x += gw[i] * wy[j] * wz[k] * vgx;
+            cpx[idx].y += wx[i] * gw[j] * wz[k] * vgx;
+            cpx[idx].z += wx[i] * wy[j] * gw[k] * vgx;
+          }
+    }
+    {  // v
+      const IndexInt gidx = ci * dX[1] + fj * dY[1] + ck * dZ[1];
+      const Real wx[2] = {Real(1) - wci, wci};
+      const Real wy[2] = {Real(1) - wfj, wfj};
+      const Real wz[2] = {Real(1) - wck, wck};
+      for (int i = 0; i < 2; ++i)
+        for (int j = 0; j < 2; ++j)
+          for (int k = 0; k < 2; ++k) {
+            const IndexInt vidx = gidx + dX[i] + dY[j] + dZ[k];
+            Real vgy = vg[vidx].y;
+            vp[idx].y += wx[i] * wy[j] * wz[k] * vgy;
+            cpy[idx].x += gw[i] * wy[j] * wz[k] * vgy;
+            cpy[idx].y += wx[i] * gw[j] * wz[k] * vgy;
+            cpy[idx].z += wx[i] * wy[j] * gw[k] * vgy;
+          }
+    }
+    if (!vg.is3D())
+      return;
+    {  // w
+      const IndexInt gidx = ci * dX[1] + cj * dY[1] + fk * dZ[1];
+      const Real wx[2] = {Real(1) - wci, wci};
+      const Real wy[2] = {Real(1) - wcj, wcj};
+      const Real wz[2] = {Real(1) - wfk, wfk};
+      for (int i = 0; i < 2; ++i)
+        for (int j = 0; j < 2; ++j)
+          for (int k = 0; k < 2; ++k) {
+            const IndexInt vidx = gidx + dX[i] + dY[j] + dZ[k];
+            Real vgz = vg[vidx].z;
+            vp[idx].z += wx[i] * wy[j] * wz[k] * vgz;
+            cpz[idx].x += gw[i] * wy[j] * wz[k] * vgz;
+            cpz[idx].y += wx[i] * gw[j] * wz[k] * vgz;
+            cpz[idx].z += wx[i] * wy[j] * gw[k] * vgz;
+          }
+    }
+  }
+  inline ParticleDataImpl<Vec3> &getArg0()
+  {
+    return vp;
+  }
+  typedef ParticleDataImpl<Vec3> type0;
+  inline ParticleDataImpl<Vec3> &getArg1()
+  {
+    return cpx;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline ParticleDataImpl<Vec3> &getArg2()
+  {
+    return cpy;
+  }
+  typedef ParticleDataImpl<Vec3> type2;
+  inline ParticleDataImpl<Vec3> &getArg3()
+  {
+    return cpz;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline const BasicParticleSystem &getArg4()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type4;
+  inline const MACGrid &getArg5()
+  {
+    return vg;
+  }
+  typedef MACGrid type5;
+  inline const FlagGrid &getArg6()
+  {
+    return flags;
+  }
+  typedef FlagGrid type6;
+  inline const ParticleDataImpl<int> *getArg7()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type7;
+  inline const int &getArg8()
+  {
+    return exclude;
+  }
+  typedef int type8;
+  void runMessage()
+  {
+    debMsg("Executing kernel knApicMapLinearMACGridToVec3 ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, vp, cpx, cpy, cpz, p, vg, flags, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<Vec3> &vp;
+  ParticleDataImpl<Vec3> &cpx;
+  ParticleDataImpl<Vec3> &cpy;
+  ParticleDataImpl<Vec3> &cpz;
+  const BasicParticleSystem &p;
+  const MACGrid &vg;
+  const FlagGrid &flags;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+void apicMapMACGridToParts(ParticleDataImpl<Vec3> &partVel,
+                           ParticleDataImpl<Vec3> &cpx,
+                           ParticleDataImpl<Vec3> &cpy,
+                           ParticleDataImpl<Vec3> &cpz,
+                           const BasicParticleSystem &parts,
+                           const MACGrid &vel,
+                           const FlagGrid &flags,
+                           const ParticleDataImpl<int> *ptype = NULL,
+                           const int exclude = 0)
+{
+  knApicMapLinearMACGridToVec3(partVel, cpx, cpy, cpz, parts, vel, flags, ptype, exclude);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "apicMapMACGridToParts", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "partVel", 0, &_lock);
+      ParticleDataImpl<Vec3> &cpx = *_args.getPtr<ParticleDataImpl<Vec3>>("cpx", 1, &_lock);
+      ParticleDataImpl<Vec3> &cpy = *_args.getPtr<ParticleDataImpl<Vec3>>("cpy", 2, &_lock);
+      ParticleDataImpl<Vec3> &cpz = *_args.getPtr<ParticleDataImpl<Vec3>>("cpz", 3, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 4, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 5, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 6, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 7, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 8, 0, &_lock);
+      _retval = getPyNone();
+      apicMapMACGridToParts(partVel, cpx, cpy, cpz, parts, vel, flags, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "apicMapMACGridToParts", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("apicMapMACGridToParts", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_apicMapMACGridToParts("", "apicMapMACGridToParts", _W_1);
+extern "C" {
+void PbRegister_apicMapMACGridToParts()
+{
+  KEEP_UNUSED(_RP_apicMapMACGridToParts);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/extforces.cpp b/extern/mantaflow/preprocessed/plugin/extforces.cpp
new file mode 100644
index 00000000000..3e1e5733257
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/extforces.cpp
@@ -0,0 +1,1559 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * GNU General Public License (GPL)
+ * http://www.gnu.org/licenses
+ *
+ * Set boundary conditions, gravity
+ *
+ ******************************************************************************/
+
+#include "vectorbase.h"
+#include "grid.h"
+#include "commonkernels.h"
+#include "particle.h"
+
+using namespace std;
+
+namespace Manta {
+
+//! add constant force between fl/fl and fl/em cells
+struct KnApplyForceField : public KernelBase {
+  KnApplyForceField(const FlagGrid &flags,
+                    MACGrid &vel,
+                    const Grid<Vec3> &force,
+                    const Grid<Real> *include,
+                    bool additive,
+                    bool isMAC)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        vel(vel),
+        force(force),
+        include(include),
+        additive(additive),
+        isMAC(isMAC)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 MACGrid &vel,
+                 const Grid<Vec3> &force,
+                 const Grid<Real> *include,
+                 bool additive,
+                 bool isMAC) const
+  {
+    bool curFluid = flags.isFluid(i, j, k);
+    bool curEmpty = flags.isEmpty(i, j, k);
+    if (!curFluid && !curEmpty)
+      return;
+    if (include && ((*include)(i, j, k) > 0.))
+      return;
+
+    Real forceX = (isMAC) ? force(i, j, k).x : 0.5 * (force(i - 1, j, k).x + force(i, j, k).x);
+    Real forceY = (isMAC) ? force(i, j, k).y : 0.5 * (force(i, j - 1, k).y + force(i, j, k).y);
+
+    Real forceZ = 0.;
+    if (vel.is3D())
+      forceZ = (isMAC) ? force(i, j, k).z : 0.5 * (force(i, j, k - 1).z + force(i, j, k).z);
+
+    if (flags.isFluid(i - 1, j, k) || (curFluid && flags.isEmpty(i - 1, j, k)))
+      vel(i, j, k).x = (additive) ? vel(i, j, k).x + forceX : forceX;
+    if (flags.isFluid(i, j - 1, k) || (curFluid && flags.isEmpty(i, j - 1, k)))
+      vel(i, j, k).y = (additive) ? vel(i, j, k).y + forceY : forceY;
+    if (vel.is3D() && (flags.isFluid(i, j, k - 1) || (curFluid && flags.isEmpty(i, j, k - 1))))
+      vel(i, j, k).z = (additive) ? vel(i, j, k).z + forceZ : forceZ;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const Grid<Vec3> &getArg2()
+  {
+    return force;
+  }
+  typedef Grid<Vec3> type2;
+  inline const Grid<Real> *getArg3()
+  {
+    return include;
+  }
+  typedef Grid<Real> type3;
+  inline bool &getArg4()
+  {
+    return additive;
+  }
+  typedef bool type4;
+  inline bool &getArg5()
+  {
+    return isMAC;
+  }
+  typedef bool type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnApplyForceField ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, force, include, additive, isMAC);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, force, include, additive, isMAC);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  MACGrid &vel;
+  const Grid<Vec3> &force;
+  const Grid<Real> *include;
+  bool additive;
+  bool isMAC;
+};
+
+//! add constant force between fl/fl and fl/em cells
+struct KnApplyForce : public KernelBase {
+  KnApplyForce(
+      const FlagGrid &flags, MACGrid &vel, Vec3 force, const Grid<Real> *exclude, bool additive)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        vel(vel),
+        force(force),
+        exclude(exclude),
+        additive(additive)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 MACGrid &vel,
+                 Vec3 force,
+                 const Grid<Real> *exclude,
+                 bool additive) const
+  {
+    bool curFluid = flags.isFluid(i, j, k);
+    bool curEmpty = flags.isEmpty(i, j, k);
+    if (!curFluid && !curEmpty)
+      return;
+    if (exclude && ((*exclude)(i, j, k) < 0.))
+      return;
+
+    if (flags.isFluid(i - 1, j, k) || (curFluid && flags.isEmpty(i - 1, j, k)))
+      vel(i, j, k).x = (additive) ? vel(i, j, k).x + force.x : force.x;
+    if (flags.isFluid(i, j - 1, k) || (curFluid && flags.isEmpty(i, j - 1, k)))
+      vel(i, j, k).y = (additive) ? vel(i, j, k).y + force.y : force.y;
+    if (vel.is3D() && (flags.isFluid(i, j, k - 1) || (curFluid && flags.isEmpty(i, j, k - 1))))
+      vel(i, j, k).z = (additive) ? vel(i, j, k).z + force.z : force.z;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline Vec3 &getArg2()
+  {
+    return force;
+  }
+  typedef Vec3 type2;
+  inline const Grid<Real> *getArg3()
+  {
+    return exclude;
+  }
+  typedef Grid<Real> type3;
+  inline bool &getArg4()
+  {
+    return additive;
+  }
+  typedef bool type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnApplyForce ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, force, exclude, additive);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, force, exclude, additive);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  MACGrid &vel;
+  Vec3 force;
+  const Grid<Real> *exclude;
+  bool additive;
+};
+
+//! add gravity forces to all fluid cells, automatically adapts to different grid sizes
+void addGravity(const FlagGrid &flags,
+                MACGrid &vel,
+                Vec3 gravity,
+                const Grid<Real> *exclude = NULL)
+{
+  Vec3 f = gravity * flags.getParent()->getDt() / flags.getDx();
+  KnApplyForce(flags, vel, f, exclude, true);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addGravity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      Vec3 gravity = _args.get<Vec3>("gravity", 2, &_lock);
+      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, NULL, &_lock);
+      _retval = getPyNone();
+      addGravity(flags, vel, gravity, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addGravity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addGravity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addGravity("", "addGravity", _W_0);
+extern "C" {
+void PbRegister_addGravity()
+{
+  KEEP_UNUSED(_RP_addGravity);
+}
+}
+
+//! add gravity forces to all fluid cells , but dont account for changing cell size
+void addGravityNoScale(const FlagGrid &flags,
+                       MACGrid &vel,
+                       const Vec3 &gravity,
+                       const Grid<Real> *exclude = NULL)
+{
+  const Vec3 f = gravity * flags.getParent()->getDt();
+  KnApplyForce(flags, vel, f, exclude, true);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addGravityNoScale", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const Vec3 &gravity = _args.get<Vec3>("gravity", 2, &_lock);
+      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, NULL, &_lock);
+      _retval = getPyNone();
+      addGravityNoScale(flags, vel, gravity, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addGravityNoScale", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addGravityNoScale", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addGravityNoScale("", "addGravityNoScale", _W_1);
+extern "C" {
+void PbRegister_addGravityNoScale()
+{
+  KEEP_UNUSED(_RP_addGravityNoScale);
+}
+}
+
+//! kernel to add Buoyancy force
+struct KnAddBuoyancy : public KernelBase {
+  KnAddBuoyancy(const FlagGrid &flags, const Grid<Real> &factor, MACGrid &vel, Vec3 strength)
+      : KernelBase(&flags, 1), flags(flags), factor(factor), vel(vel), strength(strength)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const Grid<Real> &factor,
+                 MACGrid &vel,
+                 Vec3 strength) const
+  {
+    if (!flags.isFluid(i, j, k))
+      return;
+    if (flags.isFluid(i - 1, j, k))
+      vel(i, j, k).x += (0.5 * strength.x) * (factor(i, j, k) + factor(i - 1, j, k));
+    if (flags.isFluid(i, j - 1, k))
+      vel(i, j, k).y += (0.5 * strength.y) * (factor(i, j, k) + factor(i, j - 1, k));
+    if (vel.is3D() && flags.isFluid(i, j, k - 1))
+      vel(i, j, k).z += (0.5 * strength.z) * (factor(i, j, k) + factor(i, j, k - 1));
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return factor;
+  }
+  typedef Grid<Real> type1;
+  inline MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  inline Vec3 &getArg3()
+  {
+    return strength;
+  }
+  typedef Vec3 type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAddBuoyancy ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, factor, vel, strength);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, factor, vel, strength);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const Grid<Real> &factor;
+  MACGrid &vel;
+  Vec3 strength;
+};
+
+//! add Buoyancy force based on fctor (e.g. smoke density)
+void addBuoyancy(const FlagGrid &flags,
+                 const Grid<Real> &density,
+                 MACGrid &vel,
+                 Vec3 gravity,
+                 Real coefficient = 1.)
+{
+  Vec3 f = -gravity * flags.getParent()->getDt() / flags.getParent()->getDx() * coefficient;
+  KnAddBuoyancy(flags, density, vel, f);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addBuoyancy", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 2, &_lock);
+      Vec3 gravity = _args.get<Vec3>("gravity", 3, &_lock);
+      Real coefficient = _args.getOpt<Real>("coefficient", 4, 1., &_lock);
+      _retval = getPyNone();
+      addBuoyancy(flags, density, vel, gravity, coefficient);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addBuoyancy", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addBuoyancy", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addBuoyancy("", "addBuoyancy", _W_2);
+extern "C" {
+void PbRegister_addBuoyancy()
+{
+  KEEP_UNUSED(_RP_addBuoyancy);
+}
+}
+
+// inflow / outflow boundaries
+
+//! helper to parse openbounds string [xXyYzZ] , convert to vec3
+inline void convertDescToVec(const string &desc, Vector3D<bool> &lo, Vector3D<bool> &up)
+{
+  for (size_t i = 0; i < desc.size(); i++) {
+    if (desc[i] == 'x')
+      lo.x = true;
+    else if (desc[i] == 'y')
+      lo.y = true;
+    else if (desc[i] == 'z')
+      lo.z = true;
+    else if (desc[i] == 'X')
+      up.x = true;
+    else if (desc[i] == 'Y')
+      up.y = true;
+    else if (desc[i] == 'Z')
+      up.z = true;
+    else
+      errMsg("invalid character in boundary description string. Only [xyzXYZ] allowed.");
+  }
+}
+
+//! add empty and outflow flag to cells of open boundaries
+void setOpenBound(FlagGrid &flags,
+                  int bWidth,
+                  string openBound = "",
+                  int type = FlagGrid::TypeOutflow | FlagGrid::TypeEmpty)
+{
+  if (openBound == "")
+    return;
+  Vector3D<bool> lo, up;
+  convertDescToVec(openBound, lo, up);
+
+  FOR_IJK(flags)
+  {
+    bool loX = lo.x && i <= bWidth;  // a cell which belongs to the lower x open bound
+    bool loY = lo.y && j <= bWidth;
+    bool upX = up.x && i >= flags.getSizeX() - bWidth -
+                                1;  // a cell which belongs to the upper x open bound
+    bool upY = up.y && j >= flags.getSizeY() - bWidth - 1;
+    bool innerI = i > bWidth &&
+                  i < flags.getSizeX() - bWidth -
+                          1;  // a cell which does not belong to the lower or upper x bound
+    bool innerJ = j > bWidth && j < flags.getSizeY() - bWidth - 1;
+
+    // when setting boundaries to open: don't set shared part of wall to empty if neighboring wall
+    // is not open
+    if ((!flags.is3D()) && (loX || upX || loY || upY)) {
+      if ((loX || upX || innerI) && (loY || upY || innerJ) && flags.isObstacle(i, j, k))
+        flags(i, j, k) = type;
+    }
+    else {
+      bool loZ = lo.z && k <= bWidth;  // a cell which belongs to the lower z open bound
+      bool upZ = up.z && k >= flags.getSizeZ() - bWidth -
+                                  1;  // a cell which belongs to the upper z open bound
+      bool innerK = k > bWidth &&
+                    k < flags.getSizeZ() - bWidth -
+                            1;  // a cell which does not belong to the lower or upper z bound
+      if (loX || upX || loY || upY || loZ || upZ) {
+        if ((loX || upX || innerI) && (loY || upY || innerJ) && (loZ || upZ || innerK) &&
+            flags.isObstacle(i, j, k))
+          flags(i, j, k) = type;
+      }
+    }
+  }
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setOpenBound", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      int bWidth = _args.get<int>("bWidth", 1, &_lock);
+      string openBound = _args.getOpt<string>("openBound", 2, "", &_lock);
+      int type = _args.getOpt<int>("type", 3, FlagGrid::TypeOutflow | FlagGrid::TypeEmpty, &_lock);
+      _retval = getPyNone();
+      setOpenBound(flags, bWidth, openBound, type);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setOpenBound", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setOpenBound", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setOpenBound("", "setOpenBound", _W_3);
+extern "C" {
+void PbRegister_setOpenBound()
+{
+  KEEP_UNUSED(_RP_setOpenBound);
+}
+}
+
+//! delete fluid and ensure empty flag in outflow cells, delete particles and density and set phi
+//! to 0.5
+void resetOutflow(FlagGrid &flags,
+                  Grid<Real> *phi = 0,
+                  BasicParticleSystem *parts = 0,
+                  Grid<Real> *real = 0,
+                  Grid<int> *index = 0,
+                  ParticleIndexSystem *indexSys = 0)
+{
+  // check if phi and parts -> pindex and gpi already created -> access particles from cell index,
+  // avoid extra looping over particles
+  if (parts && (!index || !indexSys)) {
+    if (phi)
+      debMsg(
+          "resetOpenBound for phi and particles, but missing index and indexSys for enhanced "
+          "particle access!",
+          1);
+    for (int idx = 0; idx < (int)parts->size(); idx++)
+      if (parts->isActive(idx) && flags.isInBounds(parts->getPos(idx)) &&
+          flags.isOutflow(parts->getPos(idx)))
+        parts->kill(idx);
+  }
+  FOR_IJK(flags)
+  {
+    if (flags.isOutflow(i, j, k)) {
+      flags(i, j, k) = (flags(i, j, k) | FlagGrid::TypeEmpty) &
+                       ~FlagGrid::TypeFluid;  // make sure there is not fluid flag set and to reset
+                                              // the empty flag
+      // the particles in a cell i,j,k are particles[index(i,j,k)] to particles[index(i+1,j,k)-1]
+      if (parts && index && indexSys) {
+        int isysIdxS = index->index(i, j, k);
+        int pStart = (*index)(isysIdxS), pEnd = 0;
+        if (flags.isInBounds(isysIdxS + 1))
+          pEnd = (*index)(isysIdxS + 1);
+        else
+          pEnd = indexSys->size();
+        // now loop over particles in cell
+        for (int p = pStart; p < pEnd; ++p) {
+          int psrc = (*indexSys)[p].sourceIndex;
+          if (parts->isActive(psrc) && flags.isInBounds(parts->getPos(psrc)))
+            parts->kill(psrc);
+        }
+      }
+      if (phi)
+        (*phi)(i, j, k) = 0.5;
+      if (real)
+        (*real)(i, j, k) = 0;
+    }
+  }
+  if (parts)
+    parts->doCompress();
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "resetOutflow", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 1, 0, &_lock);
+      BasicParticleSystem *parts = _args.getPtrOpt<BasicParticleSystem>("parts", 2, 0, &_lock);
+      Grid<Real> *real = _args.getPtrOpt<Grid<Real>>("real", 3, 0, &_lock);
+      Grid<int> *index = _args.getPtrOpt<Grid<int>>("index", 4, 0, &_lock);
+      ParticleIndexSystem *indexSys = _args.getPtrOpt<ParticleIndexSystem>(
+          "indexSys", 5, 0, &_lock);
+      _retval = getPyNone();
+      resetOutflow(flags, phi, parts, real, index, indexSys);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "resetOutflow", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("resetOutflow", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_resetOutflow("", "resetOutflow", _W_4);
+extern "C" {
+void PbRegister_resetOutflow()
+{
+  KEEP_UNUSED(_RP_resetOutflow);
+}
+}
+
+//! enforce a constant inflow/outflow at the grid boundaries
+struct KnSetInflow : public KernelBase {
+  KnSetInflow(MACGrid &vel, int dim, int p0, const Vec3 &val)
+      : KernelBase(&vel, 0), vel(vel), dim(dim), p0(p0), val(val)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, MACGrid &vel, int dim, int p0, const Vec3 &val) const
+  {
+    Vec3i p(i, j, k);
+    if (p[dim] == p0 || p[dim] == p0 + 1)
+      vel(i, j, k) = val;
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline int &getArg1()
+  {
+    return dim;
+  }
+  typedef int type1;
+  inline int &getArg2()
+  {
+    return p0;
+  }
+  typedef int type2;
+  inline const Vec3 &getArg3()
+  {
+    return val;
+  }
+  typedef Vec3 type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnSetInflow ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, vel, dim, p0, val);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, vel, dim, p0, val);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  MACGrid &vel;
+  int dim;
+  int p0;
+  const Vec3 &val;
+};
+
+//! enforce a constant inflow/outflow at the grid boundaries
+void setInflowBcs(MACGrid &vel, string dir, Vec3 value)
+{
+  for (size_t i = 0; i < dir.size(); i++) {
+    if (dir[i] >= 'x' && dir[i] <= 'z') {
+      int dim = dir[i] - 'x';
+      KnSetInflow(vel, dim, 0, value);
+    }
+    else if (dir[i] >= 'X' && dir[i] <= 'Z') {
+      int dim = dir[i] - 'X';
+      KnSetInflow(vel, dim, vel.getSize()[dim] - 1, value);
+    }
+    else
+      errMsg("invalid character in direction string. Only [xyzXYZ] allowed.");
+  }
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setInflowBcs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      string dir = _args.get<string>("dir", 1, &_lock);
+      Vec3 value = _args.get<Vec3>("value", 2, &_lock);
+      _retval = getPyNone();
+      setInflowBcs(vel, dir, value);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setInflowBcs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setInflowBcs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setInflowBcs("", "setInflowBcs", _W_5);
+extern "C" {
+void PbRegister_setInflowBcs()
+{
+  KEEP_UNUSED(_RP_setInflowBcs);
+}
+}
+
+// set obstacle boundary conditions
+
+//! set no-stick wall boundary condition between ob/fl and ob/ob cells
+struct KnSetWallBcs : public KernelBase {
+  KnSetWallBcs(const FlagGrid &flags, MACGrid &vel, const MACGrid *obvel)
+      : KernelBase(&flags, 0), flags(flags), vel(vel), obvel(obvel)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const FlagGrid &flags, MACGrid &vel, const MACGrid *obvel) const
+  {
+
+    bool curFluid = flags.isFluid(i, j, k);
+    bool curObs = flags.isObstacle(i, j, k);
+    Vec3 bcsVel(0., 0., 0.);
+    if (!curFluid && !curObs)
+      return;
+
+    if (obvel) {
+      bcsVel.x = (*obvel)(i, j, k).x;
+      bcsVel.y = (*obvel)(i, j, k).y;
+      if ((*obvel).is3D())
+        bcsVel.z = (*obvel)(i, j, k).z;
+    }
+
+    // we use i>0 instead of bnd=1 to check outer wall
+    if (i > 0 && flags.isObstacle(i - 1, j, k))
+      vel(i, j, k).x = bcsVel.x;
+    if (i > 0 && curObs && flags.isFluid(i - 1, j, k))
+      vel(i, j, k).x = bcsVel.x;
+    if (j > 0 && flags.isObstacle(i, j - 1, k))
+      vel(i, j, k).y = bcsVel.y;
+    if (j > 0 && curObs && flags.isFluid(i, j - 1, k))
+      vel(i, j, k).y = bcsVel.y;
+
+    if (!vel.is3D()) {
+      vel(i, j, k).z = 0;
+    }
+    else {
+      if (k > 0 && flags.isObstacle(i, j, k - 1))
+        vel(i, j, k).z = bcsVel.z;
+      if (k > 0 && curObs && flags.isFluid(i, j, k - 1))
+        vel(i, j, k).z = bcsVel.z;
+    }
+
+    if (curFluid) {
+      if ((i > 0 && flags.isStick(i - 1, j, k)) ||
+          (i < flags.getSizeX() - 1 && flags.isStick(i + 1, j, k)))
+        vel(i, j, k).y = vel(i, j, k).z = 0;
+      if ((j > 0 && flags.isStick(i, j - 1, k)) ||
+          (j < flags.getSizeY() - 1 && flags.isStick(i, j + 1, k)))
+        vel(i, j, k).x = vel(i, j, k).z = 0;
+      if (vel.is3D() && ((k > 0 && flags.isStick(i, j, k - 1)) ||
+                         (k < flags.getSizeZ() - 1 && flags.isStick(i, j, k + 1))))
+        vel(i, j, k).x = vel(i, j, k).y = 0;
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const MACGrid *getArg2()
+  {
+    return obvel;
+  }
+  typedef MACGrid type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnSetWallBcs ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, vel, obvel);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, vel, obvel);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  MACGrid &vel;
+  const MACGrid *obvel;
+};
+
+//! set wall BCs for fill fraction mode, note - only needs obstacle SDF
+
+struct KnSetWallBcsFrac : public KernelBase {
+  KnSetWallBcsFrac(const FlagGrid &flags,
+                   const MACGrid &vel,
+                   MACGrid &velTarget,
+                   const MACGrid *obvel,
+                   const Grid<Real> *phiObs,
+                   const int &boundaryWidth = 0)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        vel(vel),
+        velTarget(velTarget),
+        obvel(obvel),
+        phiObs(phiObs),
+        boundaryWidth(boundaryWidth)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 MACGrid &velTarget,
+                 const MACGrid *obvel,
+                 const Grid<Real> *phiObs,
+                 const int &boundaryWidth = 0) const
+  {
+    bool curFluid = flags.isFluid(i, j, k);
+    bool curObs = flags.isObstacle(i, j, k);
+    velTarget(i, j, k) = vel(i, j, k);
+    if (!curFluid && !curObs)
+      return;
+
+    // zero normal component in all obstacle regions
+    if (flags.isInBounds(Vec3i(i, j, k), 1)) {
+
+      if (curObs | flags.isObstacle(i - 1, j, k)) {
+        Vec3 dphi(0., 0., 0.);
+        const Real tmp1 = (phiObs->get(i, j, k) + phiObs->get(i - 1, j, k)) * .5;
+        Real tmp2 = (phiObs->get(i, j + 1, k) + phiObs->get(i - 1, j + 1, k)) * .5;
+        Real phi1 = (tmp1 + tmp2) * .5;
+        tmp2 = (phiObs->get(i, j - 1, k) + phiObs->get(i - 1, j - 1, k)) * .5;
+        Real phi2 = (tmp1 + tmp2) * .5;
+
+        dphi.x = phiObs->get(i, j, k) - phiObs->get(i - 1, j, k);
+        dphi.y = phi1 - phi2;
+
+        if (phiObs->is3D()) {
+          tmp2 = (phiObs->get(i, j, k + 1) + phiObs->get(i - 1, j, k + 1)) * .5;
+          phi1 = (tmp1 + tmp2) * .5;
+          tmp2 = (phiObs->get(i, j, k - 1) + phiObs->get(i - 1, j, k - 1)) * .5;
+          phi2 = (tmp1 + tmp2) * .5;
+          dphi.z = phi1 - phi2;
+        }
+
+        normalize(dphi);
+        Vec3 velMAC = vel.getAtMACX(i, j, k);
+        velTarget(i, j, k).x = velMAC.x - dot(dphi, velMAC) * dphi.x;
+      }
+
+      if (curObs | flags.isObstacle(i, j - 1, k)) {
+        Vec3 dphi(0., 0., 0.);
+        const Real tmp1 = (phiObs->get(i, j, k) + phiObs->get(i, j - 1, k)) * .5;
+        Real tmp2 = (phiObs->get(i + 1, j, k) + phiObs->get(i + 1, j - 1, k)) * .5;
+        Real phi1 = (tmp1 + tmp2) * .5;
+        tmp2 = (phiObs->get(i - 1, j, k) + phiObs->get(i - 1, j - 1, k)) * .5;
+        Real phi2 = (tmp1 + tmp2) * .5;
+
+        dphi.x = phi1 - phi2;
+        dphi.y = phiObs->get(i, j, k) - phiObs->get(i, j - 1, k);
+        if (phiObs->is3D()) {
+          tmp2 = (phiObs->get(i, j, k + 1) + phiObs->get(i, j - 1, k + 1)) * .5;
+          phi1 = (tmp1 + tmp2) * .5;
+          tmp2 = (phiObs->get(i, j, k - 1) + phiObs->get(i, j - 1, k - 1)) * .5;
+          phi2 = (tmp1 + tmp2) * .5;
+          dphi.z = phi1 - phi2;
+        }
+
+        normalize(dphi);
+        Vec3 velMAC = vel.getAtMACY(i, j, k);
+        velTarget(i, j, k).y = velMAC.y - dot(dphi, velMAC) * dphi.y;
+      }
+
+      if (phiObs->is3D() && (curObs | flags.isObstacle(i, j, k - 1))) {
+        Vec3 dphi(0., 0., 0.);
+        const Real tmp1 = (phiObs->get(i, j, k) + phiObs->get(i, j, k - 1)) * .5;
+
+        Real tmp2;
+        tmp2 = (phiObs->get(i + 1, j, k) + phiObs->get(i + 1, j, k - 1)) * .5;
+        Real phi1 = (tmp1 + tmp2) * .5;
+        tmp2 = (phiObs->get(i - 1, j, k) + phiObs->get(i - 1, j, k - 1)) * .5;
+        Real phi2 = (tmp1 + tmp2) * .5;
+        dphi.x = phi1 - phi2;
+
+        tmp2 = (phiObs->get(i, j + 1, k) + phiObs->get(i, j + 1, k - 1)) * .5;
+        phi1 = (tmp1 + tmp2) * .5;
+        tmp2 = (phiObs->get(i, j - 1, k) + phiObs->get(i, j - 1, k - 1)) * .5;
+        phi2 = (tmp1 + tmp2) * .5;
+        dphi.y = phi1 - phi2;
+
+        dphi.z = phiObs->get(i, j, k) - phiObs->get(i, j, k - 1);
+
+        normalize(dphi);
+        Vec3 velMAC = vel.getAtMACZ(i, j, k);
+        velTarget(i, j, k).z = velMAC.z - dot(dphi, velMAC) * dphi.z;
+      }
+    }  // not at boundary
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline MACGrid &getArg2()
+  {
+    return velTarget;
+  }
+  typedef MACGrid type2;
+  inline const MACGrid *getArg3()
+  {
+    return obvel;
+  }
+  typedef MACGrid type3;
+  inline const Grid<Real> *getArg4()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type4;
+  inline const int &getArg5()
+  {
+    return boundaryWidth;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnSetWallBcsFrac ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, vel, velTarget, obvel, phiObs, boundaryWidth);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, vel, velTarget, obvel, phiObs, boundaryWidth);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  MACGrid &velTarget;
+  const MACGrid *obvel;
+  const Grid<Real> *phiObs;
+  const int &boundaryWidth;
+};
+
+//! set zero normal velocity boundary condition on walls
+// (optionally with second order accuracy using the obstacle SDF , fractions grid currentlyl not
+// needed)
+void setWallBcs(const FlagGrid &flags,
+                MACGrid &vel,
+                const MACGrid *obvel = 0,
+                const MACGrid *fractions = 0,
+                const Grid<Real> *phiObs = 0,
+                int boundaryWidth = 0)
+{
+  if (!phiObs || !fractions) {
+    KnSetWallBcs(flags, vel, obvel);
+  }
+  else {
+    MACGrid tmpvel(vel.getParent());
+    KnSetWallBcsFrac(flags, vel, tmpvel, obvel, phiObs, boundaryWidth);
+    vel.swap(tmpvel);
+  }
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setWallBcs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 2, 0, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 3, 0, &_lock);
+      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 4, 0, &_lock);
+      int boundaryWidth = _args.getOpt<int>("boundaryWidth", 5, 0, &_lock);
+      _retval = getPyNone();
+      setWallBcs(flags, vel, obvel, fractions, phiObs, boundaryWidth);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setWallBcs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setWallBcs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setWallBcs("", "setWallBcs", _W_6);
+extern "C" {
+void PbRegister_setWallBcs()
+{
+  KEEP_UNUSED(_RP_setWallBcs);
+}
+}
+
+//! add Forces between fl/fl and fl/em cells (interpolate cell centered forces to MAC grid)
+struct KnAddForceIfLower : public KernelBase {
+  KnAddForceIfLower(const FlagGrid &flags, MACGrid &vel, const Grid<Vec3> &force)
+      : KernelBase(&flags, 1), flags(flags), vel(vel), force(force)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const FlagGrid &flags, MACGrid &vel, const Grid<Vec3> &force) const
+  {
+    bool curFluid = flags.isFluid(i, j, k);
+    bool curEmpty = flags.isEmpty(i, j, k);
+    if (!curFluid && !curEmpty)
+      return;
+
+    if (flags.isFluid(i - 1, j, k) || (curFluid && flags.isEmpty(i - 1, j, k))) {
+      Real forceMACX = 0.5 * (force(i - 1, j, k).x + force(i, j, k).x);
+      Real min = std::min(vel(i, j, k).x, forceMACX);
+      Real max = std::max(vel(i, j, k).x, forceMACX);
+      Real sum = vel(i, j, k).x + forceMACX;
+      vel(i, j, k).x = (forceMACX > 0) ? std::min(sum, max) : std::max(sum, min);
+    }
+    if (flags.isFluid(i, j - 1, k) || (curFluid && flags.isEmpty(i, j - 1, k))) {
+      Real forceMACY = 0.5 * (force(i, j - 1, k).y + force(i, j, k).y);
+      Real min = std::min(vel(i, j, k).y, forceMACY);
+      Real max = std::max(vel(i, j, k).y, forceMACY);
+      Real sum = vel(i, j, k).y + forceMACY;
+      vel(i, j, k).y = (forceMACY > 0) ? std::min(sum, max) : std::max(sum, min);
+    }
+    if (vel.is3D() && (flags.isFluid(i, j, k - 1) || (curFluid && flags.isEmpty(i, j, k - 1)))) {
+      Real forceMACZ = 0.5 * (force(i, j, k - 1).z + force(i, j, k).z);
+      Real min = std::min(vel(i, j, k).z, forceMACZ);
+      Real max = std::max(vel(i, j, k).z, forceMACZ);
+      Real sum = vel(i, j, k).z + forceMACZ;
+      vel(i, j, k).z = (forceMACZ > 0) ? std::min(sum, max) : std::max(sum, min);
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const Grid<Vec3> &getArg2()
+  {
+    return force;
+  }
+  typedef Grid<Vec3> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAddForceIfLower ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, force);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, force);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  MACGrid &vel;
+  const Grid<Vec3> &force;
+};
+
+// Initial velocity for smoke
+void setInitialVelocity(const FlagGrid &flags, MACGrid &vel, const Grid<Vec3> &invel)
+{
+  KnAddForceIfLower(flags, vel, invel);
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setInitialVelocity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const Grid<Vec3> &invel = *_args.getPtr<Grid<Vec3>>("invel", 2, &_lock);
+      _retval = getPyNone();
+      setInitialVelocity(flags, vel, invel);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setInitialVelocity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setInitialVelocity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setInitialVelocity("", "setInitialVelocity", _W_7);
+extern "C" {
+void PbRegister_setInitialVelocity()
+{
+  KEEP_UNUSED(_RP_setInitialVelocity);
+}
+}
+
+//! Kernel: gradient norm operator
+struct KnConfForce : public KernelBase {
+  KnConfForce(Grid<Vec3> &force,
+              const Grid<Real> &grid,
+              const Grid<Vec3> &curl,
+              Real str,
+              const Grid<Real> *strGrid)
+      : KernelBase(&force, 1), force(force), grid(grid), curl(curl), str(str), strGrid(strGrid)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Vec3> &force,
+                 const Grid<Real> &grid,
+                 const Grid<Vec3> &curl,
+                 Real str,
+                 const Grid<Real> *strGrid) const
+  {
+    Vec3 grad = 0.5 * Vec3(grid(i + 1, j, k) - grid(i - 1, j, k),
+                           grid(i, j + 1, k) - grid(i, j - 1, k),
+                           0.);
+    if (grid.is3D())
+      grad[2] = 0.5 * (grid(i, j, k + 1) - grid(i, j, k - 1));
+    normalize(grad);
+    if (strGrid)
+      str += (*strGrid)(i, j, k);
+    force(i, j, k) = str * cross(grad, curl(i, j, k));
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return force;
+  }
+  typedef Grid<Vec3> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return grid;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Vec3> &getArg2()
+  {
+    return curl;
+  }
+  typedef Grid<Vec3> type2;
+  inline Real &getArg3()
+  {
+    return str;
+  }
+  typedef Real type3;
+  inline const Grid<Real> *getArg4()
+  {
+    return strGrid;
+  }
+  typedef Grid<Real> type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnConfForce ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, force, grid, curl, str, strGrid);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, force, grid, curl, str, strGrid);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Vec3> &force;
+  const Grid<Real> &grid;
+  const Grid<Vec3> &curl;
+  Real str;
+  const Grid<Real> *strGrid;
+};
+
+void vorticityConfinement(MACGrid &vel,
+                          const FlagGrid &flags,
+                          Real strengthGlobal = 0,
+                          const Grid<Real> *strengthCell = NULL)
+{
+  Grid<Vec3> velCenter(flags.getParent()), curl(flags.getParent()), force(flags.getParent());
+  Grid<Real> norm(flags.getParent());
+
+  GetCentered(velCenter, vel);
+  CurlOp(velCenter, curl);
+  GridNorm(norm, curl);
+  KnConfForce(force, norm, curl, strengthGlobal, strengthCell);
+  KnApplyForceField(flags, vel, force, NULL, true, false);
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "vorticityConfinement", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      Real strengthGlobal = _args.getOpt<Real>("strengthGlobal", 2, 0, &_lock);
+      const Grid<Real> *strengthCell = _args.getPtrOpt<Grid<Real>>(
+          "strengthCell", 3, NULL, &_lock);
+      _retval = getPyNone();
+      vorticityConfinement(vel, flags, strengthGlobal, strengthCell);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "vorticityConfinement", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("vorticityConfinement", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_vorticityConfinement("", "vorticityConfinement", _W_8);
+extern "C" {
+void PbRegister_vorticityConfinement()
+{
+  KEEP_UNUSED(_RP_vorticityConfinement);
+}
+}
+
+void addForceField(const FlagGrid &flags,
+                   MACGrid &vel,
+                   const Grid<Vec3> &force,
+                   const Grid<Real> *region = NULL,
+                   bool isMAC = false)
+{
+  KnApplyForceField(flags, vel, force, region, true, isMAC);
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addForceField", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>("force", 2, &_lock);
+      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, NULL, &_lock);
+      bool isMAC = _args.getOpt<bool>("isMAC", 4, false, &_lock);
+      _retval = getPyNone();
+      addForceField(flags, vel, force, region, isMAC);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addForceField", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addForceField", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addForceField("", "addForceField", _W_9);
+extern "C" {
+void PbRegister_addForceField()
+{
+  KEEP_UNUSED(_RP_addForceField);
+}
+}
+
+void setForceField(const FlagGrid &flags,
+                   MACGrid &vel,
+                   const Grid<Vec3> &force,
+                   const Grid<Real> *region = NULL,
+                   bool isMAC = false)
+{
+  KnApplyForceField(flags, vel, force, region, false, isMAC);
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setForceField", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>("force", 2, &_lock);
+      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, NULL, &_lock);
+      bool isMAC = _args.getOpt<bool>("isMAC", 4, false, &_lock);
+      _retval = getPyNone();
+      setForceField(flags, vel, force, region, isMAC);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setForceField", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setForceField", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setForceField("", "setForceField", _W_10);
+extern "C" {
+void PbRegister_setForceField()
+{
+  KEEP_UNUSED(_RP_setForceField);
+}
+}
+
+void dissolveSmoke(const FlagGrid &flags,
+                   Grid<Real> &density,
+                   Grid<Real> *heat = NULL,
+                   Grid<Real> *red = NULL,
+                   Grid<Real> *green = NULL,
+                   Grid<Real> *blue = NULL,
+                   int speed = 5,
+                   bool logFalloff = true)
+{
+  float dydx = 1.0f / (float)speed;  // max density/speed = dydx
+  float fac = 1.0f - dydx;
+
+  FOR_IJK_BND(density, 0)
+  {
+    bool curFluid = flags.isFluid(i, j, k);
+    if (!curFluid)
+      continue;
+
+    if (logFalloff) {
+      density(i, j, k) *= fac;
+      if (heat) {
+        (*heat)(i, j, k) *= fac;
+      }
+      if (red) {
+        (*red)(i, j, k) *= fac;
+        (*green)(i, j, k) *= fac;
+        (*blue)(i, j, k) *= fac;
+      }
+    }
+    else {  // linear falloff
+      float d = density(i, j, k);
+      density(i, j, k) -= dydx;
+      if (density(i, j, k) < 0.0f)
+        density(i, j, k) = 0.0f;
+      if (heat) {
+        if (fabs((*heat)(i, j, k)) < dydx)
+          (*heat)(i, j, k) = 0.0f;
+        else if ((*heat)(i, j, k) > 0.0f)
+          (*heat)(i, j, k) -= dydx;
+        else if ((*heat)(i, j, k) < 0.0f)
+          (*heat)(i, j, k) += dydx;
+      }
+      if (red && notZero(d)) {
+        (*red)(i, j, k) *= (density(i, j, k) / d);
+        (*green)(i, j, k) *= (density(i, j, k) / d);
+        (*blue)(i, j, k) *= (density(i, j, k) / d);
+      }
+    }
+  }
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "dissolveSmoke", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 2, NULL, &_lock);
+      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, NULL, &_lock);
+      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, NULL, &_lock);
+      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, NULL, &_lock);
+      int speed = _args.getOpt<int>("speed", 6, 5, &_lock);
+      bool logFalloff = _args.getOpt<bool>("logFalloff", 7, true, &_lock);
+      _retval = getPyNone();
+      dissolveSmoke(flags, density, heat, red, green, blue, speed, logFalloff);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "dissolveSmoke", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("dissolveSmoke", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_dissolveSmoke("", "dissolveSmoke", _W_11);
+extern "C" {
+void PbRegister_dissolveSmoke()
+{
+  KEEP_UNUSED(_RP_dissolveSmoke);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/fire.cpp b/extern/mantaflow/preprocessed/plugin/fire.cpp
new file mode 100644
index 00000000000..9047d4bf8a1
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/fire.cpp
@@ -0,0 +1,435 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2016 Sebastian Barschkis, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Fire modeling plugin
+ *
+ ******************************************************************************/
+
+#include "general.h"
+#include "grid.h"
+#include "vectorbase.h"
+
+using namespace std;
+
+namespace Manta {
+
+struct KnProcessBurn : public KernelBase {
+  KnProcessBurn(Grid<Real> &fuel,
+                Grid<Real> &density,
+                Grid<Real> &react,
+                Grid<Real> *red,
+                Grid<Real> *green,
+                Grid<Real> *blue,
+                Grid<Real> *heat,
+                Real burningRate,
+                Real flameSmoke,
+                Real ignitionTemp,
+                Real maxTemp,
+                Real dt,
+                Vec3 flameSmokeColor)
+      : KernelBase(&fuel, 1),
+        fuel(fuel),
+        density(density),
+        react(react),
+        red(red),
+        green(green),
+        blue(blue),
+        heat(heat),
+        burningRate(burningRate),
+        flameSmoke(flameSmoke),
+        ignitionTemp(ignitionTemp),
+        maxTemp(maxTemp),
+        dt(dt),
+        flameSmokeColor(flameSmokeColor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Real> &fuel,
+                 Grid<Real> &density,
+                 Grid<Real> &react,
+                 Grid<Real> *red,
+                 Grid<Real> *green,
+                 Grid<Real> *blue,
+                 Grid<Real> *heat,
+                 Real burningRate,
+                 Real flameSmoke,
+                 Real ignitionTemp,
+                 Real maxTemp,
+                 Real dt,
+                 Vec3 flameSmokeColor) const
+  {
+    // Save initial values
+    Real origFuel = fuel(i, j, k);
+    Real origSmoke = density(i, j, k);
+    Real smokeEmit = 0.0f;
+    Real flame = 0.0f;
+
+    // Process fuel
+    fuel(i, j, k) -= burningRate * dt;
+    if (fuel(i, j, k) < 0.0f)
+      fuel(i, j, k) = 0.0f;
+
+    // Process reaction coordinate
+    if (origFuel > VECTOR_EPSILON) {
+      react(i, j, k) *= fuel(i, j, k) / origFuel;
+      flame = pow(react(i, j, k), 0.5f);
+    }
+    else {
+      react(i, j, k) = 0.0f;
+    }
+
+    // Set fluid temperature based on fuel burn rate and "flameSmoke" factor
+    smokeEmit = (origFuel < 1.0f) ? (1.0 - origFuel) * 0.5f : 0.0f;
+    smokeEmit = (smokeEmit + 0.5f) * (origFuel - fuel(i, j, k)) * 0.1f * flameSmoke;
+    density(i, j, k) += smokeEmit;
+    clamp(density(i, j, k), (Real)0.0f, (Real)1.0f);
+
+    // Set fluid temperature from the flame temperature profile
+    if (heat && flame)
+      (*heat)(i, j, k) = (1.0f - flame) * ignitionTemp + flame * maxTemp;
+
+    // Mix new color
+    if (smokeEmit > VECTOR_EPSILON) {
+      float smokeFactor = density(i, j, k) / (origSmoke + smokeEmit);
+      if (red)
+        (*red)(i, j, k) = ((*red)(i, j, k) + flameSmokeColor.x * smokeEmit) * smokeFactor;
+      if (green)
+        (*green)(i, j, k) = ((*green)(i, j, k) + flameSmokeColor.y * smokeEmit) * smokeFactor;
+      if (blue)
+        (*blue)(i, j, k) = ((*blue)(i, j, k) + flameSmokeColor.z * smokeEmit) * smokeFactor;
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return fuel;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return density;
+  }
+  typedef Grid<Real> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return react;
+  }
+  typedef Grid<Real> type2;
+  inline Grid<Real> *getArg3()
+  {
+    return red;
+  }
+  typedef Grid<Real> type3;
+  inline Grid<Real> *getArg4()
+  {
+    return green;
+  }
+  typedef Grid<Real> type4;
+  inline Grid<Real> *getArg5()
+  {
+    return blue;
+  }
+  typedef Grid<Real> type5;
+  inline Grid<Real> *getArg6()
+  {
+    return heat;
+  }
+  typedef Grid<Real> type6;
+  inline Real &getArg7()
+  {
+    return burningRate;
+  }
+  typedef Real type7;
+  inline Real &getArg8()
+  {
+    return flameSmoke;
+  }
+  typedef Real type8;
+  inline Real &getArg9()
+  {
+    return ignitionTemp;
+  }
+  typedef Real type9;
+  inline Real &getArg10()
+  {
+    return maxTemp;
+  }
+  typedef Real type10;
+  inline Real &getArg11()
+  {
+    return dt;
+  }
+  typedef Real type11;
+  inline Vec3 &getArg12()
+  {
+    return flameSmokeColor;
+  }
+  typedef Vec3 type12;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnProcessBurn ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i,
+               j,
+               k,
+               fuel,
+               density,
+               react,
+               red,
+               green,
+               blue,
+               heat,
+               burningRate,
+               flameSmoke,
+               ignitionTemp,
+               maxTemp,
+               dt,
+               flameSmokeColor);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i,
+             j,
+             k,
+             fuel,
+             density,
+             react,
+             red,
+             green,
+             blue,
+             heat,
+             burningRate,
+             flameSmoke,
+             ignitionTemp,
+             maxTemp,
+             dt,
+             flameSmokeColor);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &fuel;
+  Grid<Real> &density;
+  Grid<Real> &react;
+  Grid<Real> *red;
+  Grid<Real> *green;
+  Grid<Real> *blue;
+  Grid<Real> *heat;
+  Real burningRate;
+  Real flameSmoke;
+  Real ignitionTemp;
+  Real maxTemp;
+  Real dt;
+  Vec3 flameSmokeColor;
+};
+
+void processBurn(Grid<Real> &fuel,
+                 Grid<Real> &density,
+                 Grid<Real> &react,
+                 Grid<Real> *red = NULL,
+                 Grid<Real> *green = NULL,
+                 Grid<Real> *blue = NULL,
+                 Grid<Real> *heat = NULL,
+                 Real burningRate = 0.75f,
+                 Real flameSmoke = 1.0f,
+                 Real ignitionTemp = 1.25f,
+                 Real maxTemp = 1.75f,
+                 Vec3 flameSmokeColor = Vec3(0.7f, 0.7f, 0.7f))
+{
+  Real dt = fuel.getParent()->getDt();
+  KnProcessBurn(fuel,
+                density,
+                react,
+                red,
+                green,
+                blue,
+                heat,
+                burningRate,
+                flameSmoke,
+                ignitionTemp,
+                maxTemp,
+                dt,
+                flameSmokeColor);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "processBurn", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &fuel = *_args.getPtr<Grid<Real>>("fuel", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      Grid<Real> &react = *_args.getPtr<Grid<Real>>("react", 2, &_lock);
+      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, NULL, &_lock);
+      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, NULL, &_lock);
+      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, NULL, &_lock);
+      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 6, NULL, &_lock);
+      Real burningRate = _args.getOpt<Real>("burningRate", 7, 0.75f, &_lock);
+      Real flameSmoke = _args.getOpt<Real>("flameSmoke", 8, 1.0f, &_lock);
+      Real ignitionTemp = _args.getOpt<Real>("ignitionTemp", 9, 1.25f, &_lock);
+      Real maxTemp = _args.getOpt<Real>("maxTemp", 10, 1.75f, &_lock);
+      Vec3 flameSmokeColor = _args.getOpt<Vec3>(
+          "flameSmokeColor", 11, Vec3(0.7f, 0.7f, 0.7f), &_lock);
+      _retval = getPyNone();
+      processBurn(fuel,
+                  density,
+                  react,
+                  red,
+                  green,
+                  blue,
+                  heat,
+                  burningRate,
+                  flameSmoke,
+                  ignitionTemp,
+                  maxTemp,
+                  flameSmokeColor);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "processBurn", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("processBurn", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_processBurn("", "processBurn", _W_0);
+extern "C" {
+void PbRegister_processBurn()
+{
+  KEEP_UNUSED(_RP_processBurn);
+}
+}
+
+struct KnUpdateFlame : public KernelBase {
+  KnUpdateFlame(const Grid<Real> &react, Grid<Real> &flame)
+      : KernelBase(&react, 1), react(react), flame(flame)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<Real> &react, Grid<Real> &flame) const
+  {
+    if (react(i, j, k) > 0.0f)
+      flame(i, j, k) = pow(react(i, j, k), 0.5f);
+    else
+      flame(i, j, k) = 0.0f;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return react;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return flame;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnUpdateFlame ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, react, flame);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, react, flame);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<Real> &react;
+  Grid<Real> &flame;
+};
+
+void updateFlame(const Grid<Real> &react, Grid<Real> &flame)
+{
+  KnUpdateFlame(react, flame);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "updateFlame", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &react = *_args.getPtr<Grid<Real>>("react", 0, &_lock);
+      Grid<Real> &flame = *_args.getPtr<Grid<Real>>("flame", 1, &_lock);
+      _retval = getPyNone();
+      updateFlame(react, flame);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "updateFlame", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("updateFlame", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_updateFlame("", "updateFlame", _W_1);
+extern "C" {
+void PbRegister_updateFlame()
+{
+  KEEP_UNUSED(_RP_updateFlame);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/flip.cpp b/extern/mantaflow/preprocessed/plugin/flip.cpp
new file mode 100644
index 00000000000..f6d082900b5
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/flip.cpp
@@ -0,0 +1,2819 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * FLIP (fluid implicit particles)
+ * for use with particle data fields
+ *
+ ******************************************************************************/
+
+#include "particle.h"
+#include "grid.h"
+#include "commonkernels.h"
+#include "randomstream.h"
+#include "levelset.h"
+#include "shapes.h"
+#include "matrixbase.h"
+
+using namespace std;
+namespace Manta {
+
+// init
+
+//! note - this is a simplified version , sampleLevelsetWithParticles has more functionality
+
+void sampleFlagsWithParticles(const FlagGrid &flags,
+                              BasicParticleSystem &parts,
+                              const int discretization,
+                              const Real randomness)
+{
+  const bool is3D = flags.is3D();
+  const Real jlen = randomness / discretization;
+  const Vec3 disp(1.0 / discretization, 1.0 / discretization, 1.0 / discretization);
+  RandomStream mRand(9832);
+
+  FOR_IJK_BND(flags, 0)
+  {
+    if (flags.isObstacle(i, j, k))
+      continue;
+    if (flags.isFluid(i, j, k)) {
+      const Vec3 pos(i, j, k);
+      for (int dk = 0; dk < (is3D ? discretization : 1); dk++)
+        for (int dj = 0; dj < discretization; dj++)
+          for (int di = 0; di < discretization; di++) {
+            Vec3 subpos = pos + disp * Vec3(0.5 + di, 0.5 + dj, 0.5 + dk);
+            subpos += jlen * (Vec3(1, 1, 1) - 2.0 * mRand.getVec3());
+            if (!is3D)
+              subpos[2] = 0.5;
+            parts.addBuffered(subpos);
+          }
+    }
+  }
+  parts.insertBufferedParticles();
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "sampleFlagsWithParticles", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 1, &_lock);
+      const int discretization = _args.get<int>("discretization", 2, &_lock);
+      const Real randomness = _args.get<Real>("randomness", 3, &_lock);
+      _retval = getPyNone();
+      sampleFlagsWithParticles(flags, parts, discretization, randomness);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "sampleFlagsWithParticles", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("sampleFlagsWithParticles", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_sampleFlagsWithParticles("", "sampleFlagsWithParticles", _W_0);
+extern "C" {
+void PbRegister_sampleFlagsWithParticles()
+{
+  KEEP_UNUSED(_RP_sampleFlagsWithParticles);
+}
+}
+
+//! sample a level set with particles, use reset to clear the particle buffer,
+//! and skipEmpty for a continuous inflow (in the latter case, only empty cells will
+//! be re-filled once they empty when calling sampleLevelsetWithParticles during
+//! the main loop).
+
+void sampleLevelsetWithParticles(const LevelsetGrid &phi,
+                                 const FlagGrid &flags,
+                                 BasicParticleSystem &parts,
+                                 const int discretization,
+                                 const Real randomness,
+                                 const bool reset = false,
+                                 const bool refillEmpty = false,
+                                 const int particleFlag = -1)
+{
+  const bool is3D = phi.is3D();
+  const Real jlen = randomness / discretization;
+  const Vec3 disp(1.0 / discretization, 1.0 / discretization, 1.0 / discretization);
+  RandomStream mRand(9832);
+
+  if (reset) {
+    parts.clear();
+    parts.doCompress();
+  }
+
+  FOR_IJK_BND(phi, 0)
+  {
+    if (flags.isObstacle(i, j, k))
+      continue;
+    if (refillEmpty && flags.isFluid(i, j, k))
+      continue;
+    if (phi(i, j, k) < 1.733) {
+      const Vec3 pos(i, j, k);
+      for (int dk = 0; dk < (is3D ? discretization : 1); dk++)
+        for (int dj = 0; dj < discretization; dj++)
+          for (int di = 0; di < discretization; di++) {
+            Vec3 subpos = pos + disp * Vec3(0.5 + di, 0.5 + dj, 0.5 + dk);
+            subpos += jlen * (Vec3(1, 1, 1) - 2.0 * mRand.getVec3());
+            if (!is3D)
+              subpos[2] = 0.5;
+            if (phi.getInterpolated(subpos) > 0.)
+              continue;
+            if (particleFlag < 0) {
+              parts.addBuffered(subpos);
+            }
+            else {
+              parts.addBuffered(subpos, particleFlag);
+            }
+          }
+    }
+  }
+
+  parts.insertBufferedParticles();
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "sampleLevelsetWithParticles", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 2, &_lock);
+      const int discretization = _args.get<int>("discretization", 3, &_lock);
+      const Real randomness = _args.get<Real>("randomness", 4, &_lock);
+      const bool reset = _args.getOpt<bool>("reset", 5, false, &_lock);
+      const bool refillEmpty = _args.getOpt<bool>("refillEmpty", 6, false, &_lock);
+      const int particleFlag = _args.getOpt<int>("particleFlag", 7, -1, &_lock);
+      _retval = getPyNone();
+      sampleLevelsetWithParticles(
+          phi, flags, parts, discretization, randomness, reset, refillEmpty, particleFlag);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "sampleLevelsetWithParticles", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("sampleLevelsetWithParticles", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_sampleLevelsetWithParticles("", "sampleLevelsetWithParticles", _W_1);
+extern "C" {
+void PbRegister_sampleLevelsetWithParticles()
+{
+  KEEP_UNUSED(_RP_sampleLevelsetWithParticles);
+}
+}
+
+//! sample a shape with particles, use reset to clear the particle buffer,
+//! and skipEmpty for a continuous inflow (in the latter case, only empty cells will
+//! be re-filled once they empty when calling sampleShapeWithParticles during
+//! the main loop).
+
+void sampleShapeWithParticles(const Shape &shape,
+                              const FlagGrid &flags,
+                              BasicParticleSystem &parts,
+                              const int discretization,
+                              const Real randomness,
+                              const bool reset = false,
+                              const bool refillEmpty = false,
+                              const LevelsetGrid *exclude = NULL)
+{
+  const bool is3D = flags.is3D();
+  const Real jlen = randomness / discretization;
+  const Vec3 disp(1.0 / discretization, 1.0 / discretization, 1.0 / discretization);
+  RandomStream mRand(9832);
+
+  if (reset) {
+    parts.clear();
+    parts.doCompress();
+  }
+
+  FOR_IJK_BND(flags, 0)
+  {
+    if (flags.isObstacle(i, j, k))
+      continue;
+    if (refillEmpty && flags.isFluid(i, j, k))
+      continue;
+    const Vec3 pos(i, j, k);
+    for (int dk = 0; dk < (is3D ? discretization : 1); dk++)
+      for (int dj = 0; dj < discretization; dj++)
+        for (int di = 0; di < discretization; di++) {
+          Vec3 subpos = pos + disp * Vec3(0.5 + di, 0.5 + dj, 0.5 + dk);
+          subpos += jlen * (Vec3(1, 1, 1) - 2.0 * mRand.getVec3());
+          if (!is3D)
+            subpos[2] = 0.5;
+          if (exclude && exclude->getInterpolated(subpos) <= 0.)
+            continue;
+          if (!shape.isInside(subpos))
+            continue;
+          parts.addBuffered(subpos);
+        }
+  }
+
+  parts.insertBufferedParticles();
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "sampleShapeWithParticles", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 2, &_lock);
+      const int discretization = _args.get<int>("discretization", 3, &_lock);
+      const Real randomness = _args.get<Real>("randomness", 4, &_lock);
+      const bool reset = _args.getOpt<bool>("reset", 5, false, &_lock);
+      const bool refillEmpty = _args.getOpt<bool>("refillEmpty", 6, false, &_lock);
+      const LevelsetGrid *exclude = _args.getPtrOpt<LevelsetGrid>("exclude", 7, NULL, &_lock);
+      _retval = getPyNone();
+      sampleShapeWithParticles(
+          shape, flags, parts, discretization, randomness, reset, refillEmpty, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "sampleShapeWithParticles", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("sampleShapeWithParticles", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_sampleShapeWithParticles("", "sampleShapeWithParticles", _W_2);
+extern "C" {
+void PbRegister_sampleShapeWithParticles()
+{
+  KEEP_UNUSED(_RP_sampleShapeWithParticles);
+}
+}
+
+//! mark fluid cells and helpers
+struct knClearFluidFlags : public KernelBase {
+  knClearFluidFlags(FlagGrid &flags, int dummy = 0)
+      : KernelBase(&flags, 0), flags(flags), dummy(dummy)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, FlagGrid &flags, int dummy = 0) const
+  {
+    if (flags.isFluid(i, j, k)) {
+      flags(i, j, k) = (flags(i, j, k) | FlagGrid::TypeEmpty) & ~FlagGrid::TypeFluid;
+    }
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline int &getArg1()
+  {
+    return dummy;
+  }
+  typedef int type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knClearFluidFlags ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, dummy);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, dummy);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  FlagGrid &flags;
+  int dummy;
+};
+
+struct knSetNbObstacle : public KernelBase {
+  knSetNbObstacle(FlagGrid &nflags, const FlagGrid &flags, const Grid<Real> &phiObs)
+      : KernelBase(&nflags, 1), nflags(nflags), flags(flags), phiObs(phiObs)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, FlagGrid &nflags, const FlagGrid &flags, const Grid<Real> &phiObs) const
+  {
+    if (phiObs(i, j, k) > 0.)
+      return;
+    if (flags.isEmpty(i, j, k)) {
+      bool set = false;
+      if ((flags.isFluid(i - 1, j, k)) && (phiObs(i + 1, j, k) <= 0.))
+        set = true;
+      if ((flags.isFluid(i + 1, j, k)) && (phiObs(i - 1, j, k) <= 0.))
+        set = true;
+      if ((flags.isFluid(i, j - 1, k)) && (phiObs(i, j + 1, k) <= 0.))
+        set = true;
+      if ((flags.isFluid(i, j + 1, k)) && (phiObs(i, j - 1, k) <= 0.))
+        set = true;
+      if (flags.is3D()) {
+        if ((flags.isFluid(i, j, k - 1)) && (phiObs(i, j, k + 1) <= 0.))
+          set = true;
+        if ((flags.isFluid(i, j, k + 1)) && (phiObs(i, j, k - 1) <= 0.))
+          set = true;
+      }
+      if (set)
+        nflags(i, j, k) = (flags(i, j, k) | FlagGrid::TypeFluid) & ~FlagGrid::TypeEmpty;
+    }
+  }
+  inline FlagGrid &getArg0()
+  {
+    return nflags;
+  }
+  typedef FlagGrid type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetNbObstacle ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, nflags, flags, phiObs);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, nflags, flags, phiObs);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  FlagGrid &nflags;
+  const FlagGrid &flags;
+  const Grid<Real> &phiObs;
+};
+void markFluidCells(const BasicParticleSystem &parts,
+                    FlagGrid &flags,
+                    const Grid<Real> *phiObs = NULL,
+                    const ParticleDataImpl<int> *ptype = NULL,
+                    const int exclude = 0)
+{
+  // remove all fluid cells
+  knClearFluidFlags(flags, 0);
+
+  // mark all particles in flaggrid as fluid
+  for (IndexInt idx = 0; idx < parts.size(); idx++) {
+    if (!parts.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      continue;
+    Vec3i p = toVec3i(parts.getPos(idx));
+    if (flags.isInBounds(p) && flags.isEmpty(p))
+      flags(p) = (flags(p) | FlagGrid::TypeFluid) & ~FlagGrid::TypeEmpty;
+  }
+
+  // special for second order obstacle BCs, check empty cells in boundary region
+  if (phiObs) {
+    FlagGrid tmp(flags);
+    knSetNbObstacle(tmp, flags, *phiObs);
+    flags.swap(tmp);
+  }
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "markFluidCells", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 2, NULL, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 3, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 4, 0, &_lock);
+      _retval = getPyNone();
+      markFluidCells(parts, flags, phiObs, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "markFluidCells", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("markFluidCells", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_markFluidCells("", "markFluidCells", _W_3);
+extern "C" {
+void PbRegister_markFluidCells()
+{
+  KEEP_UNUSED(_RP_markFluidCells);
+}
+}
+
+// for testing purposes only...
+void testInitGridWithPos(Grid<Real> &grid)
+{
+  FOR_IJK(grid)
+  {
+    grid(i, j, k) = norm(Vec3(i, j, k));
+  }
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "testInitGridWithPos", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 0, &_lock);
+      _retval = getPyNone();
+      testInitGridWithPos(grid);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "testInitGridWithPos", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("testInitGridWithPos", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_testInitGridWithPos("", "testInitGridWithPos", _W_4);
+extern "C" {
+void PbRegister_testInitGridWithPos()
+{
+  KEEP_UNUSED(_RP_testInitGridWithPos);
+}
+}
+
+//! helper to calculate particle radius factor to cover the diagonal of a cell in 2d/3d
+inline Real calculateRadiusFactor(const Grid<Real> &grid, Real factor)
+{
+  return (grid.is3D() ? sqrt(3.) : sqrt(2.)) *
+         (factor + .01);  // note, a 1% safety factor is added here
+}
+
+//! re-sample particles based on an input levelset
+// optionally skip seeding new particles in "exclude" SDF
+
+void adjustNumber(BasicParticleSystem &parts,
+                  const MACGrid &vel,
+                  const FlagGrid &flags,
+                  int minParticles,
+                  int maxParticles,
+                  const LevelsetGrid &phi,
+                  Real radiusFactor = 1.,
+                  Real narrowBand = -1.,
+                  const Grid<Real> *exclude = NULL)
+{
+  // which levelset to use as threshold
+  const Real SURFACE_LS = -1.0 * calculateRadiusFactor(phi, radiusFactor);
+  Grid<int> tmp(vel.getParent());
+  std::ostringstream out;
+
+  // count particles in cells, and delete excess particles
+  for (IndexInt idx = 0; idx < (int)parts.size(); idx++) {
+    if (parts.isActive(idx)) {
+      Vec3i p = toVec3i(parts.getPos(idx));
+      if (!tmp.isInBounds(p)) {
+        parts.kill(idx);  // out of domain, remove
+        continue;
+      }
+
+      Real phiv = phi.getInterpolated(parts.getPos(idx));
+      if (phiv > 0) {
+        parts.kill(idx);
+        continue;
+      }
+      if (narrowBand > 0. && phiv < -narrowBand) {
+        parts.kill(idx);
+        continue;
+      }
+
+      bool atSurface = false;
+      if (phiv > SURFACE_LS)
+        atSurface = true;
+      int num = tmp(p);
+
+      // dont delete particles in non fluid cells here, the particles are "always right"
+      if (num > maxParticles && (!atSurface)) {
+        parts.kill(idx);
+      }
+      else {
+        tmp(p) = num + 1;
+      }
+    }
+  }
+
+  // seed new particles
+  RandomStream mRand(9832);
+  FOR_IJK(tmp)
+  {
+    int cnt = tmp(i, j, k);
+
+    // skip cells near surface
+    if (phi(i, j, k) > SURFACE_LS)
+      continue;
+    if (narrowBand > 0. && phi(i, j, k) < -narrowBand) {
+      continue;
+    }
+    if (exclude && ((*exclude)(i, j, k) < 0.)) {
+      continue;
+    }
+
+    if (flags.isFluid(i, j, k) && cnt < minParticles) {
+      for (int m = cnt; m < minParticles; m++) {
+        Vec3 pos = Vec3(i, j, k) + mRand.getVec3();
+        // Vec3 pos (i + 0.5, j + 0.5, k + 0.5); // cell center
+        parts.addBuffered(pos);
+      }
+    }
+  }
+
+  parts.doCompress();
+  parts.insertBufferedParticles();
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "adjustNumber", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      int minParticles = _args.get<int>("minParticles", 3, &_lock);
+      int maxParticles = _args.get<int>("maxParticles", 4, &_lock);
+      const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 5, &_lock);
+      Real radiusFactor = _args.getOpt<Real>("radiusFactor", 6, 1., &_lock);
+      Real narrowBand = _args.getOpt<Real>("narrowBand", 7, -1., &_lock);
+      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 8, NULL, &_lock);
+      _retval = getPyNone();
+      adjustNumber(
+          parts, vel, flags, minParticles, maxParticles, phi, radiusFactor, narrowBand, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "adjustNumber", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("adjustNumber", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_adjustNumber("", "adjustNumber", _W_5);
+extern "C" {
+void PbRegister_adjustNumber()
+{
+  KEEP_UNUSED(_RP_adjustNumber);
+}
+}
+
+// simple and slow helper conversion to show contents of int grids like a real grid in the ui
+// (use eg to quickly display contents of the particle-index grid)
+
+void debugIntToReal(const Grid<int> &source, Grid<Real> &dest, Real factor = 1.)
+{
+  FOR_IJK(source)
+  {
+    dest(i, j, k) = (Real)source(i, j, k) * factor;
+  }
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "debugIntToReal", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<int> &source = *_args.getPtr<Grid<int>>("source", 0, &_lock);
+      Grid<Real> &dest = *_args.getPtr<Grid<Real>>("dest", 1, &_lock);
+      Real factor = _args.getOpt<Real>("factor", 2, 1., &_lock);
+      _retval = getPyNone();
+      debugIntToReal(source, dest, factor);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "debugIntToReal", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("debugIntToReal", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_debugIntToReal("", "debugIntToReal", _W_6);
+extern "C" {
+void PbRegister_debugIntToReal()
+{
+  KEEP_UNUSED(_RP_debugIntToReal);
+}
+}
+
+// build a grid that contains indices for a particle system
+// the particles in a cell i,j,k are particles[index(i,j,k)] to particles[index(i+1,j,k)-1]
+// (ie,  particles[index(i+1,j,k)] already belongs to cell i+1,j,k)
+
+void gridParticleIndex(const BasicParticleSystem &parts,
+                       ParticleIndexSystem &indexSys,
+                       const FlagGrid &flags,
+                       Grid<int> &index,
+                       Grid<int> *counter = NULL)
+{
+  bool delCounter = false;
+  if (!counter) {
+    counter = new Grid<int>(flags.getParent());
+    delCounter = true;
+  }
+  else {
+    counter->clear();
+  }
+
+  // count particles in cells, and delete excess particles
+  index.clear();
+  int inactive = 0;
+  for (IndexInt idx = 0; idx < (IndexInt)parts.size(); idx++) {
+    if (parts.isActive(idx)) {
+      // check index for validity...
+      Vec3i p = toVec3i(parts.getPos(idx));
+      if (!index.isInBounds(p)) {
+        inactive++;
+        continue;
+      }
+
+      index(p)++;
+    }
+    else {
+      inactive++;
+    }
+  }
+
+  // note - this one might be smaller...
+  indexSys.resize(parts.size() - inactive);
+
+  // convert per cell number to continuous index
+  IndexInt idx = 0;
+  FOR_IJK(index)
+  {
+    int num = index(i, j, k);
+    index(i, j, k) = idx;
+    idx += num;
+  }
+
+  // add particles to indexed array, we still need a per cell particle counter
+  for (IndexInt idx = 0; idx < (IndexInt)parts.size(); idx++) {
+    if (!parts.isActive(idx))
+      continue;
+    Vec3i p = toVec3i(parts.getPos(idx));
+    if (!index.isInBounds(p)) {
+      continue;
+    }
+
+    // initialize position and index into original array
+    // indexSys[ index(p)+(*counter)(p) ].pos        = parts[idx].pos;
+    indexSys[index(p) + (*counter)(p)].sourceIndex = idx;
+    (*counter)(p)++;
+  }
+
+  if (delCounter)
+    delete counter;
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "gridParticleIndex", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      ParticleIndexSystem &indexSys = *_args.getPtr<ParticleIndexSystem>("indexSys", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      Grid<int> &index = *_args.getPtr<Grid<int>>("index", 3, &_lock);
+      Grid<int> *counter = _args.getPtrOpt<Grid<int>>("counter", 4, NULL, &_lock);
+      _retval = getPyNone();
+      gridParticleIndex(parts, indexSys, flags, index, counter);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "gridParticleIndex", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("gridParticleIndex", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_gridParticleIndex("", "gridParticleIndex", _W_7);
+extern "C" {
+void PbRegister_gridParticleIndex()
+{
+  KEEP_UNUSED(_RP_gridParticleIndex);
+}
+}
+
+struct ComputeUnionLevelsetPindex : public KernelBase {
+  ComputeUnionLevelsetPindex(const Grid<int> &index,
+                             const BasicParticleSystem &parts,
+                             const ParticleIndexSystem &indexSys,
+                             LevelsetGrid &phi,
+                             const Real radius,
+                             const ParticleDataImpl<int> *ptype,
+                             const int exclude)
+      : KernelBase(&index, 0),
+        index(index),
+        parts(parts),
+        indexSys(indexSys),
+        phi(phi),
+        radius(radius),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const Grid<int> &index,
+                 const BasicParticleSystem &parts,
+                 const ParticleIndexSystem &indexSys,
+                 LevelsetGrid &phi,
+                 const Real radius,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    const Vec3 gridPos = Vec3(i, j, k) + Vec3(0.5);  // shifted by half cell
+    Real phiv = radius * 1.0;                        // outside
+
+    int r = int(radius) + 1;
+    int rZ = phi.is3D() ? r : 0;
+    for (int zj = k - rZ; zj <= k + rZ; zj++)
+      for (int yj = j - r; yj <= j + r; yj++)
+        for (int xj = i - r; xj <= i + r; xj++) {
+          if (!phi.isInBounds(Vec3i(xj, yj, zj)))
+            continue;
+
+          // note, for the particle indices in indexSys the access is periodic (ie, dont skip for
+          // eg inBounds(sx,10,10)
+          IndexInt isysIdxS = index.index(xj, yj, zj);
+          IndexInt pStart = index(isysIdxS), pEnd = 0;
+          if (phi.isInBounds(isysIdxS + 1))
+            pEnd = index(isysIdxS + 1);
+          else
+            pEnd = indexSys.size();
+
+          // now loop over particles in cell
+          for (IndexInt p = pStart; p < pEnd; ++p) {
+            const int psrc = indexSys[p].sourceIndex;
+            if (ptype && ((*ptype)[psrc] & exclude))
+              continue;
+            const Vec3 pos = parts[psrc].pos;
+            phiv = std::min(phiv, fabs(norm(gridPos - pos)) - radius);
+          }
+        }
+    phi(i, j, k) = phiv;
+  }
+  inline const Grid<int> &getArg0()
+  {
+    return index;
+  }
+  typedef Grid<int> type0;
+  inline const BasicParticleSystem &getArg1()
+  {
+    return parts;
+  }
+  typedef BasicParticleSystem type1;
+  inline const ParticleIndexSystem &getArg2()
+  {
+    return indexSys;
+  }
+  typedef ParticleIndexSystem type2;
+  inline LevelsetGrid &getArg3()
+  {
+    return phi;
+  }
+  typedef LevelsetGrid type3;
+  inline const Real &getArg4()
+  {
+    return radius;
+  }
+  typedef Real type4;
+  inline const ParticleDataImpl<int> *getArg5()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type5;
+  inline const int &getArg6()
+  {
+    return exclude;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel ComputeUnionLevelsetPindex ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, index, parts, indexSys, phi, radius, ptype, exclude);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, index, parts, indexSys, phi, radius, ptype, exclude);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const Grid<int> &index;
+  const BasicParticleSystem &parts;
+  const ParticleIndexSystem &indexSys;
+  LevelsetGrid &phi;
+  const Real radius;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+void unionParticleLevelset(const BasicParticleSystem &parts,
+                           const ParticleIndexSystem &indexSys,
+                           const FlagGrid &flags,
+                           const Grid<int> &index,
+                           LevelsetGrid &phi,
+                           const Real radiusFactor = 1.,
+                           const ParticleDataImpl<int> *ptype = NULL,
+                           const int exclude = 0)
+{
+  // use half a cell diagonal as base radius
+  const Real radius = 0.5 * calculateRadiusFactor(phi, radiusFactor);
+  // no reset of phi necessary here
+  ComputeUnionLevelsetPindex(index, parts, indexSys, phi, radius, ptype, exclude);
+
+  phi.setBound(0.5, 0);
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "unionParticleLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const ParticleIndexSystem &indexSys = *_args.getPtr<ParticleIndexSystem>(
+          "indexSys", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      const Grid<int> &index = *_args.getPtr<Grid<int>>("index", 3, &_lock);
+      LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 4, &_lock);
+      const Real radiusFactor = _args.getOpt<Real>("radiusFactor", 5, 1., &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 6, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
+      _retval = getPyNone();
+      unionParticleLevelset(parts, indexSys, flags, index, phi, radiusFactor, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "unionParticleLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("unionParticleLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_unionParticleLevelset("", "unionParticleLevelset", _W_8);
+extern "C" {
+void PbRegister_unionParticleLevelset()
+{
+  KEEP_UNUSED(_RP_unionParticleLevelset);
+}
+}
+
+//! kernel for computing averaged particle level set weights
+
+struct ComputeAveragedLevelsetWeight : public KernelBase {
+  ComputeAveragedLevelsetWeight(const BasicParticleSystem &parts,
+                                const Grid<int> &index,
+                                const ParticleIndexSystem &indexSys,
+                                LevelsetGrid &phi,
+                                const Real radius,
+                                const ParticleDataImpl<int> *ptype,
+                                const int exclude,
+                                Grid<Vec3> *save_pAcc = NULL,
+                                Grid<Real> *save_rAcc = NULL)
+      : KernelBase(&index, 0),
+        parts(parts),
+        index(index),
+        indexSys(indexSys),
+        phi(phi),
+        radius(radius),
+        ptype(ptype),
+        exclude(exclude),
+        save_pAcc(save_pAcc),
+        save_rAcc(save_rAcc)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const BasicParticleSystem &parts,
+                 const Grid<int> &index,
+                 const ParticleIndexSystem &indexSys,
+                 LevelsetGrid &phi,
+                 const Real radius,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude,
+                 Grid<Vec3> *save_pAcc = NULL,
+                 Grid<Real> *save_rAcc = NULL) const
+  {
+    const Vec3 gridPos = Vec3(i, j, k) + Vec3(0.5);  // shifted by half cell
+    Real phiv = radius * 1.0;                        // outside
+
+    // loop over neighborhood, similar to ComputeUnionLevelsetPindex
+    const Real sradiusInv = 1. / (4. * radius * radius);
+    int r = int(1. * radius) + 1;
+    int rZ = phi.is3D() ? r : 0;
+    // accumulators
+    Real wacc = 0.;
+    Vec3 pacc = Vec3(0.);
+    Real racc = 0.;
+
+    for (int zj = k - rZ; zj <= k + rZ; zj++)
+      for (int yj = j - r; yj <= j + r; yj++)
+        for (int xj = i - r; xj <= i + r; xj++) {
+          if (!phi.isInBounds(Vec3i(xj, yj, zj)))
+            continue;
+
+          IndexInt isysIdxS = index.index(xj, yj, zj);
+          IndexInt pStart = index(isysIdxS), pEnd = 0;
+          if (phi.isInBounds(isysIdxS + 1))
+            pEnd = index(isysIdxS + 1);
+          else
+            pEnd = indexSys.size();
+          for (IndexInt p = pStart; p < pEnd; ++p) {
+            IndexInt psrc = indexSys[p].sourceIndex;
+            if (ptype && ((*ptype)[psrc] & exclude))
+              continue;
+
+            Vec3 pos = parts[psrc].pos;
+            Real s = normSquare(gridPos - pos) * sradiusInv;
+            // Real  w = std::max(0., cubed(1.-s) );
+            Real w = std::max(0., (1. - s));  // a bit smoother
+            wacc += w;
+            racc += radius * w;
+            pacc += pos * w;
+          }
+        }
+
+    if (wacc > VECTOR_EPSILON) {
+      racc /= wacc;
+      pacc /= wacc;
+      phiv = fabs(norm(gridPos - pacc)) - racc;
+
+      if (save_pAcc)
+        (*save_pAcc)(i, j, k) = pacc;
+      if (save_rAcc)
+        (*save_rAcc)(i, j, k) = racc;
+    }
+    phi(i, j, k) = phiv;
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return parts;
+  }
+  typedef BasicParticleSystem type0;
+  inline const Grid<int> &getArg1()
+  {
+    return index;
+  }
+  typedef Grid<int> type1;
+  inline const ParticleIndexSystem &getArg2()
+  {
+    return indexSys;
+  }
+  typedef ParticleIndexSystem type2;
+  inline LevelsetGrid &getArg3()
+  {
+    return phi;
+  }
+  typedef LevelsetGrid type3;
+  inline const Real &getArg4()
+  {
+    return radius;
+  }
+  typedef Real type4;
+  inline const ParticleDataImpl<int> *getArg5()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type5;
+  inline const int &getArg6()
+  {
+    return exclude;
+  }
+  typedef int type6;
+  inline Grid<Vec3> *getArg7()
+  {
+    return save_pAcc;
+  }
+  typedef Grid<Vec3> type7;
+  inline Grid<Real> *getArg8()
+  {
+    return save_rAcc;
+  }
+  typedef Grid<Real> type8;
+  void runMessage()
+  {
+    debMsg("Executing kernel ComputeAveragedLevelsetWeight ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, parts, index, indexSys, phi, radius, ptype, exclude, save_pAcc, save_rAcc);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, parts, index, indexSys, phi, radius, ptype, exclude, save_pAcc, save_rAcc);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const BasicParticleSystem &parts;
+  const Grid<int> &index;
+  const ParticleIndexSystem &indexSys;
+  LevelsetGrid &phi;
+  const Real radius;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+  Grid<Vec3> *save_pAcc;
+  Grid<Real> *save_rAcc;
+};
+
+template<class T> T smoothingValue(const Grid<T> val, int i, int j, int k, T center)
+{
+  return val(i, j, k);
+}
+
+// smoothing, and
+
+template<class T> struct knSmoothGrid : public KernelBase {
+  knSmoothGrid(const Grid<T> &me, Grid<T> &tmp, Real factor)
+      : KernelBase(&me, 1), me(me), tmp(tmp), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<T> &me, Grid<T> &tmp, Real factor) const
+  {
+    T val = me(i, j, k) + me(i + 1, j, k) + me(i - 1, j, k) + me(i, j + 1, k) + me(i, j - 1, k);
+    if (me.is3D()) {
+      val += me(i, j, k + 1) + me(i, j, k - 1);
+    }
+    tmp(i, j, k) = val * factor;
+  }
+  inline const Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline Grid<T> &getArg1()
+  {
+    return tmp;
+  }
+  typedef Grid<T> type1;
+  inline Real &getArg2()
+  {
+    return factor;
+  }
+  typedef Real type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSmoothGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, me, tmp, factor);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, me, tmp, factor);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<T> &me;
+  Grid<T> &tmp;
+  Real factor;
+};
+
+template<class T> struct knSmoothGridNeg : public KernelBase {
+  knSmoothGridNeg(const Grid<T> &me, Grid<T> &tmp, Real factor)
+      : KernelBase(&me, 1), me(me), tmp(tmp), factor(factor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<T> &me, Grid<T> &tmp, Real factor) const
+  {
+    T val = me(i, j, k) + me(i + 1, j, k) + me(i - 1, j, k) + me(i, j + 1, k) + me(i, j - 1, k);
+    if (me.is3D()) {
+      val += me(i, j, k + 1) + me(i, j, k - 1);
+    }
+    val *= factor;
+    if (val < tmp(i, j, k))
+      tmp(i, j, k) = val;
+    else
+      tmp(i, j, k) = me(i, j, k);
+  }
+  inline const Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline Grid<T> &getArg1()
+  {
+    return tmp;
+  }
+  typedef Grid<T> type1;
+  inline Real &getArg2()
+  {
+    return factor;
+  }
+  typedef Real type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSmoothGridNeg ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, me, tmp, factor);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, me, tmp, factor);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<T> &me;
+  Grid<T> &tmp;
+  Real factor;
+};
+
+//! Zhu & Bridson particle level set creation
+
+void averagedParticleLevelset(const BasicParticleSystem &parts,
+                              const ParticleIndexSystem &indexSys,
+                              const FlagGrid &flags,
+                              const Grid<int> &index,
+                              LevelsetGrid &phi,
+                              const Real radiusFactor = 1.,
+                              const int smoothen = 1,
+                              const int smoothenNeg = 1,
+                              const ParticleDataImpl<int> *ptype = NULL,
+                              const int exclude = 0)
+{
+  // use half a cell diagonal as base radius
+  const Real radius = 0.5 * calculateRadiusFactor(phi, radiusFactor);
+  ComputeAveragedLevelsetWeight(parts, index, indexSys, phi, radius, ptype, exclude);
+
+  // post-process level-set
+  for (int i = 0; i < std::max(smoothen, smoothenNeg); ++i) {
+    LevelsetGrid tmp(flags.getParent());
+    if (i < smoothen) {
+      knSmoothGrid<Real>(phi, tmp, 1. / (phi.is3D() ? 7. : 5.));
+      phi.swap(tmp);
+    }
+    if (i < smoothenNeg) {
+      knSmoothGridNeg<Real>(phi, tmp, 1. / (phi.is3D() ? 7. : 5.));
+      phi.swap(tmp);
+    }
+  }
+  phi.setBound(0.5, 0);
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "averagedParticleLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const ParticleIndexSystem &indexSys = *_args.getPtr<ParticleIndexSystem>(
+          "indexSys", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      const Grid<int> &index = *_args.getPtr<Grid<int>>("index", 3, &_lock);
+      LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 4, &_lock);
+      const Real radiusFactor = _args.getOpt<Real>("radiusFactor", 5, 1., &_lock);
+      const int smoothen = _args.getOpt<int>("smoothen", 6, 1, &_lock);
+      const int smoothenNeg = _args.getOpt<int>("smoothenNeg", 7, 1, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 8, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 9, 0, &_lock);
+      _retval = getPyNone();
+      averagedParticleLevelset(
+          parts, indexSys, flags, index, phi, radiusFactor, smoothen, smoothenNeg, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "averagedParticleLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("averagedParticleLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_averagedParticleLevelset("", "averagedParticleLevelset", _W_9);
+extern "C" {
+void PbRegister_averagedParticleLevelset()
+{
+  KEEP_UNUSED(_RP_averagedParticleLevelset);
+}
+}
+
+//! kernel for improvedParticleLevelset
+
+struct correctLevelset : public KernelBase {
+  correctLevelset(LevelsetGrid &phi,
+                  const Grid<Vec3> &pAcc,
+                  const Grid<Real> &rAcc,
+                  const Real radius,
+                  const Real t_low,
+                  const Real t_high)
+      : KernelBase(&phi, 1),
+        phi(phi),
+        pAcc(pAcc),
+        rAcc(rAcc),
+        radius(radius),
+        t_low(t_low),
+        t_high(t_high)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 LevelsetGrid &phi,
+                 const Grid<Vec3> &pAcc,
+                 const Grid<Real> &rAcc,
+                 const Real radius,
+                 const Real t_low,
+                 const Real t_high) const
+  {
+    if (rAcc(i, j, k) <= VECTOR_EPSILON)
+      return;  // outside nothing happens
+    Real x = pAcc(i, j, k).x;
+
+    // create jacobian of pAcc via central differences
+    Matrix3x3f jacobian = Matrix3x3f(0.5 * (pAcc(i + 1, j, k).x - pAcc(i - 1, j, k).x),
+                                     0.5 * (pAcc(i, j + 1, k).x - pAcc(i, j - 1, k).x),
+                                     0.5 * (pAcc(i, j, k + 1).x - pAcc(i, j, k - 1).x),
+                                     0.5 * (pAcc(i + 1, j, k).y - pAcc(i - 1, j, k).y),
+                                     0.5 * (pAcc(i, j + 1, k).y - pAcc(i, j - 1, k).y),
+                                     0.5 * (pAcc(i, j, k + 1).y - pAcc(i, j, k - 1).y),
+                                     0.5 * (pAcc(i + 1, j, k).z - pAcc(i - 1, j, k).z),
+                                     0.5 * (pAcc(i, j + 1, k).z - pAcc(i, j - 1, k).z),
+                                     0.5 * (pAcc(i, j, k + 1).z - pAcc(i, j, k - 1).z));
+
+    // compute largest eigenvalue of jacobian
+    Vec3 EV = jacobian.eigenvalues();
+    Real maxEV = std::max(std::max(EV.x, EV.y), EV.z);
+
+    // calculate correction factor
+    Real correction = 1;
+    if (maxEV >= t_low) {
+      Real t = (t_high - maxEV) / (t_high - t_low);
+      correction = t * t * t - 3 * t * t + 3 * t;
+    }
+    correction = (correction < 0) ?
+                     0 :
+                     correction;  // enforce correction factor to [0,1] (not explicitly in paper)
+
+    const Vec3 gridPos = Vec3(i, j, k) + Vec3(0.5);  // shifted by half cell
+    const Real correctedPhi = fabs(norm(gridPos - pAcc(i, j, k))) - rAcc(i, j, k) * correction;
+    phi(i, j, k) = (correctedPhi > radius) ?
+                       radius :
+                       correctedPhi;  // adjust too high outside values when too few particles are
+                                      // nearby to make smoothing possible (not in paper)
+  }
+  inline LevelsetGrid &getArg0()
+  {
+    return phi;
+  }
+  typedef LevelsetGrid type0;
+  inline const Grid<Vec3> &getArg1()
+  {
+    return pAcc;
+  }
+  typedef Grid<Vec3> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return rAcc;
+  }
+  typedef Grid<Real> type2;
+  inline const Real &getArg3()
+  {
+    return radius;
+  }
+  typedef Real type3;
+  inline const Real &getArg4()
+  {
+    return t_low;
+  }
+  typedef Real type4;
+  inline const Real &getArg5()
+  {
+    return t_high;
+  }
+  typedef Real type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel correctLevelset ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, phi, pAcc, rAcc, radius, t_low, t_high);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, phi, pAcc, rAcc, radius, t_low, t_high);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  LevelsetGrid &phi;
+  const Grid<Vec3> &pAcc;
+  const Grid<Real> &rAcc;
+  const Real radius;
+  const Real t_low;
+  const Real t_high;
+};
+
+//! Approach from "A unified particle model for fluid-solid interactions" by Solenthaler et al. in
+//! 2007
+
+void improvedParticleLevelset(const BasicParticleSystem &parts,
+                              const ParticleIndexSystem &indexSys,
+                              const FlagGrid &flags,
+                              const Grid<int> &index,
+                              LevelsetGrid &phi,
+                              const Real radiusFactor = 1.,
+                              const int smoothen = 1,
+                              const int smoothenNeg = 1,
+                              const Real t_low = 0.4,
+                              const Real t_high = 3.5,
+                              const ParticleDataImpl<int> *ptype = NULL,
+                              const int exclude = 0)
+{
+  // create temporary grids to store values from levelset weight computation
+  Grid<Vec3> save_pAcc(flags.getParent());
+  Grid<Real> save_rAcc(flags.getParent());
+
+  const Real radius = 0.5 * calculateRadiusFactor(
+                                phi, radiusFactor);  // use half a cell diagonal as base radius
+  ComputeAveragedLevelsetWeight(
+      parts, index, indexSys, phi, radius, ptype, exclude, &save_pAcc, &save_rAcc);
+  correctLevelset(phi, save_pAcc, save_rAcc, radius, t_low, t_high);
+
+  // post-process level-set
+  for (int i = 0; i < std::max(smoothen, smoothenNeg); ++i) {
+    LevelsetGrid tmp(flags.getParent());
+    if (i < smoothen) {
+      knSmoothGrid<Real>(phi, tmp, 1. / (phi.is3D() ? 7. : 5.));
+      phi.swap(tmp);
+    }
+    if (i < smoothenNeg) {
+      knSmoothGridNeg<Real>(phi, tmp, 1. / (phi.is3D() ? 7. : 5.));
+      phi.swap(tmp);
+    }
+  }
+  phi.setBound(0.5, 0);
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "improvedParticleLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const ParticleIndexSystem &indexSys = *_args.getPtr<ParticleIndexSystem>(
+          "indexSys", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      const Grid<int> &index = *_args.getPtr<Grid<int>>("index", 3, &_lock);
+      LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 4, &_lock);
+      const Real radiusFactor = _args.getOpt<Real>("radiusFactor", 5, 1., &_lock);
+      const int smoothen = _args.getOpt<int>("smoothen", 6, 1, &_lock);
+      const int smoothenNeg = _args.getOpt<int>("smoothenNeg", 7, 1, &_lock);
+      const Real t_low = _args.getOpt<Real>("t_low", 8, 0.4, &_lock);
+      const Real t_high = _args.getOpt<Real>("t_high", 9, 3.5, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 10, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 11, 0, &_lock);
+      _retval = getPyNone();
+      improvedParticleLevelset(parts,
+                               indexSys,
+                               flags,
+                               index,
+                               phi,
+                               radiusFactor,
+                               smoothen,
+                               smoothenNeg,
+                               t_low,
+                               t_high,
+                               ptype,
+                               exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "improvedParticleLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("improvedParticleLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_improvedParticleLevelset("", "improvedParticleLevelset", _W_10);
+extern "C" {
+void PbRegister_improvedParticleLevelset()
+{
+  KEEP_UNUSED(_RP_improvedParticleLevelset);
+}
+}
+
+struct knPushOutofObs : public KernelBase {
+  knPushOutofObs(BasicParticleSystem &parts,
+                 const FlagGrid &flags,
+                 const Grid<Real> &phiObs,
+                 const Real shift,
+                 const Real thresh,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude)
+      : KernelBase(parts.size()),
+        parts(parts),
+        flags(flags),
+        phiObs(phiObs),
+        shift(shift),
+        thresh(thresh),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 BasicParticleSystem &parts,
+                 const FlagGrid &flags,
+                 const Grid<Real> &phiObs,
+                 const Real shift,
+                 const Real thresh,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (!parts.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+    Vec3i p = toVec3i(parts.getPos(idx));
+
+    if (!flags.isInBounds(p))
+      return;
+    Real v = phiObs.getInterpolated(parts.getPos(idx));
+    if (v < thresh) {
+      Vec3 grad = getGradient(phiObs, p.x, p.y, p.z);
+      if (normalize(grad) < VECTOR_EPSILON)
+        return;
+      parts.setPos(idx, parts.getPos(idx) + grad * (thresh - v + shift));
+    }
+  }
+  inline BasicParticleSystem &getArg0()
+  {
+    return parts;
+  }
+  typedef BasicParticleSystem type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type2;
+  inline const Real &getArg3()
+  {
+    return shift;
+  }
+  typedef Real type3;
+  inline const Real &getArg4()
+  {
+    return thresh;
+  }
+  typedef Real type4;
+  inline const ParticleDataImpl<int> *getArg5()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type5;
+  inline const int &getArg6()
+  {
+    return exclude;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel knPushOutofObs ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, parts, flags, phiObs, shift, thresh, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystem &parts;
+  const FlagGrid &flags;
+  const Grid<Real> &phiObs;
+  const Real shift;
+  const Real thresh;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+//! push particles out of obstacle levelset
+
+void pushOutofObs(BasicParticleSystem &parts,
+                  const FlagGrid &flags,
+                  const Grid<Real> &phiObs,
+                  const Real shift = 0,
+                  const Real thresh = 0,
+                  const ParticleDataImpl<int> *ptype = NULL,
+                  const int exclude = 0)
+{
+  knPushOutofObs(parts, flags, phiObs, shift, thresh, ptype, exclude);
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "pushOutofObs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 2, &_lock);
+      const Real shift = _args.getOpt<Real>("shift", 3, 0, &_lock);
+      const Real thresh = _args.getOpt<Real>("thresh", 4, 0, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 5, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 6, 0, &_lock);
+      _retval = getPyNone();
+      pushOutofObs(parts, flags, phiObs, shift, thresh, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "pushOutofObs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("pushOutofObs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_pushOutofObs("", "pushOutofObs", _W_11);
+extern "C" {
+void PbRegister_pushOutofObs()
+{
+  KEEP_UNUSED(_RP_pushOutofObs);
+}
+}
+
+//******************************************************************************
+// grid interpolation functions
+
+template<class T> struct knSafeDivReal : public KernelBase {
+  knSafeDivReal(Grid<T> &me, const Grid<Real> &other, Real cutoff = VECTOR_EPSILON)
+      : KernelBase(&me, 0), me(me), other(other), cutoff(cutoff)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 Grid<T> &me,
+                 const Grid<Real> &other,
+                 Real cutoff = VECTOR_EPSILON) const
+  {
+    if (other[idx] < cutoff) {
+      me[idx] = 0.;
+    }
+    else {
+      T div(other[idx]);
+      me[idx] = safeDivide(me[idx], div);
+    }
+  }
+  inline Grid<T> &getArg0()
+  {
+    return me;
+  }
+  typedef Grid<T> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return other;
+  }
+  typedef Grid<Real> type1;
+  inline Real &getArg2()
+  {
+    return cutoff;
+  }
+  typedef Real type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSafeDivReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, me, other, cutoff);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<T> &me;
+  const Grid<Real> &other;
+  Real cutoff;
+};
+
+// Set velocities on the grid from the particle system
+
+struct knMapLinearVec3ToMACGrid : public KernelBase {
+  knMapLinearVec3ToMACGrid(const BasicParticleSystem &p,
+                           const FlagGrid &flags,
+                           const MACGrid &vel,
+                           Grid<Vec3> &tmp,
+                           const ParticleDataImpl<Vec3> &pvel,
+                           const ParticleDataImpl<int> *ptype,
+                           const int exclude)
+      : KernelBase(p.size()),
+        p(p),
+        flags(flags),
+        vel(vel),
+        tmp(tmp),
+        pvel(pvel),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 Grid<Vec3> &tmp,
+                 const ParticleDataImpl<Vec3> &pvel,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude)
+  {
+    unusedParameter(flags);
+    if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+    vel.setInterpolated(p[idx].pos, pvel[idx], &tmp[0]);
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  inline Grid<Vec3> &getArg3()
+  {
+    return tmp;
+  }
+  typedef Grid<Vec3> type3;
+  inline const ParticleDataImpl<Vec3> &getArg4()
+  {
+    return pvel;
+  }
+  typedef ParticleDataImpl<Vec3> type4;
+  inline const ParticleDataImpl<int> *getArg5()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type5;
+  inline const int &getArg6()
+  {
+    return exclude;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMapLinearVec3ToMACGrid ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void run()
+  {
+    const IndexInt _sz = size;
+    for (IndexInt i = 0; i < _sz; i++)
+      op(i, p, flags, vel, tmp, pvel, ptype, exclude);
+  }
+  const BasicParticleSystem &p;
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  Grid<Vec3> &tmp;
+  const ParticleDataImpl<Vec3> &pvel;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+// optionally , this function can use an existing vec3 grid to store the weights
+// this is useful in combination with the simple extrapolation function
+
+void mapPartsToMAC(const FlagGrid &flags,
+                   MACGrid &vel,
+                   MACGrid &velOld,
+                   const BasicParticleSystem &parts,
+                   const ParticleDataImpl<Vec3> &partVel,
+                   Grid<Vec3> *weight = NULL,
+                   const ParticleDataImpl<int> *ptype = NULL,
+                   const int exclude = 0)
+{
+  // interpol -> grid. tmpgrid for particle contribution weights
+  bool freeTmp = false;
+  if (!weight) {
+    weight = new Grid<Vec3>(flags.getParent());
+    freeTmp = true;
+  }
+  else {
+    weight->clear();  // make sure we start with a zero grid!
+  }
+  vel.clear();
+  knMapLinearVec3ToMACGrid(parts, flags, vel, *weight, partVel, ptype, exclude);
+
+  // stomp small values in weight to zero to prevent roundoff errors
+  weight->stomp(Vec3(VECTOR_EPSILON));
+  vel.safeDivide(*weight);
+
+  // store original state
+  velOld.copyFrom(vel);
+  if (freeTmp)
+    delete weight;
+}
+static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mapPartsToMAC", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      MACGrid &velOld = *_args.getPtr<MACGrid>("velOld", 2, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 3, &_lock);
+      const ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "partVel", 4, &_lock);
+      Grid<Vec3> *weight = _args.getPtrOpt<Grid<Vec3>>("weight", 5, NULL, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 6, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
+      _retval = getPyNone();
+      mapPartsToMAC(flags, vel, velOld, parts, partVel, weight, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mapPartsToMAC", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mapPartsToMAC", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mapPartsToMAC("", "mapPartsToMAC", _W_12);
+extern "C" {
+void PbRegister_mapPartsToMAC()
+{
+  KEEP_UNUSED(_RP_mapPartsToMAC);
+}
+}
+
+template<class T> struct knMapLinear : public KernelBase {
+  knMapLinear(const BasicParticleSystem &p,
+              const FlagGrid &flags,
+              const Grid<T> &target,
+              Grid<Real> &gtmp,
+              const ParticleDataImpl<T> &psource)
+      : KernelBase(p.size()), p(p), flags(flags), target(target), gtmp(gtmp), psource(psource)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 const FlagGrid &flags,
+                 const Grid<T> &target,
+                 Grid<Real> &gtmp,
+                 const ParticleDataImpl<T> &psource)
+  {
+    unusedParameter(flags);
+    if (!p.isActive(idx))
+      return;
+    target.setInterpolated(p[idx].pos, psource[idx], gtmp);
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Grid<T> &getArg2()
+  {
+    return target;
+  }
+  typedef Grid<T> type2;
+  inline Grid<Real> &getArg3()
+  {
+    return gtmp;
+  }
+  typedef Grid<Real> type3;
+  inline const ParticleDataImpl<T> &getArg4()
+  {
+    return psource;
+  }
+  typedef ParticleDataImpl<T> type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMapLinear ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void run()
+  {
+    const IndexInt _sz = size;
+    for (IndexInt i = 0; i < _sz; i++)
+      op(i, p, flags, target, gtmp, psource);
+  }
+  const BasicParticleSystem &p;
+  const FlagGrid &flags;
+  const Grid<T> &target;
+  Grid<Real> &gtmp;
+  const ParticleDataImpl<T> &psource;
+};
+
+template<class T>
+void mapLinearRealHelper(const FlagGrid &flags,
+                         Grid<T> &target,
+                         const BasicParticleSystem &parts,
+                         const ParticleDataImpl<T> &source)
+{
+  Grid<Real> tmp(flags.getParent());
+  target.clear();
+  knMapLinear<T>(parts, flags, target, tmp, source);
+  knSafeDivReal<T>(target, tmp);
+}
+
+void mapPartsToGrid(const FlagGrid &flags,
+                    Grid<Real> &target,
+                    const BasicParticleSystem &parts,
+                    const ParticleDataImpl<Real> &source)
+{
+  mapLinearRealHelper<Real>(flags, target, parts, source);
+}
+static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mapPartsToGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 2, &_lock);
+      const ParticleDataImpl<Real> &source = *_args.getPtr<ParticleDataImpl<Real>>(
+          "source", 3, &_lock);
+      _retval = getPyNone();
+      mapPartsToGrid(flags, target, parts, source);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mapPartsToGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mapPartsToGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mapPartsToGrid("", "mapPartsToGrid", _W_13);
+extern "C" {
+void PbRegister_mapPartsToGrid()
+{
+  KEEP_UNUSED(_RP_mapPartsToGrid);
+}
+}
+
+void mapPartsToGridVec3(const FlagGrid &flags,
+                        Grid<Vec3> &target,
+                        const BasicParticleSystem &parts,
+                        const ParticleDataImpl<Vec3> &source)
+{
+  mapLinearRealHelper<Vec3>(flags, target, parts, source);
+}
+static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mapPartsToGridVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 2, &_lock);
+      const ParticleDataImpl<Vec3> &source = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "source", 3, &_lock);
+      _retval = getPyNone();
+      mapPartsToGridVec3(flags, target, parts, source);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mapPartsToGridVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mapPartsToGridVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mapPartsToGridVec3("", "mapPartsToGridVec3", _W_14);
+extern "C" {
+void PbRegister_mapPartsToGridVec3()
+{
+  KEEP_UNUSED(_RP_mapPartsToGridVec3);
+}
+}
+
+// integers need "max" mode, not yet implemented
+// PYTHON() void mapPartsToGridInt ( FlagGrid& flags, Grid<int >& target , BasicParticleSystem&
+// parts , ParticleDataImpl<int >& source ) { 	mapLinearRealHelper<int >(flags,target,parts,source);
+//}
+
+template<class T> struct knMapFromGrid : public KernelBase {
+  knMapFromGrid(const BasicParticleSystem &p, const Grid<T> &gsrc, ParticleDataImpl<T> &target)
+      : KernelBase(p.size()), p(p), gsrc(gsrc), target(target)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 const Grid<T> &gsrc,
+                 ParticleDataImpl<T> &target) const
+  {
+    if (!p.isActive(idx))
+      return;
+    target[idx] = gsrc.getInterpolated(p[idx].pos);
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline const Grid<T> &getArg1()
+  {
+    return gsrc;
+  }
+  typedef Grid<T> type1;
+  inline ParticleDataImpl<T> &getArg2()
+  {
+    return target;
+  }
+  typedef ParticleDataImpl<T> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMapFromGrid ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, gsrc, target);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystem &p;
+  const Grid<T> &gsrc;
+  ParticleDataImpl<T> &target;
+};
+void mapGridToParts(const Grid<Real> &source,
+                    const BasicParticleSystem &parts,
+                    ParticleDataImpl<Real> &target)
+{
+  knMapFromGrid<Real>(parts, source, target);
+}
+static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mapGridToParts", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 1, &_lock);
+      ParticleDataImpl<Real> &target = *_args.getPtr<ParticleDataImpl<Real>>("target", 2, &_lock);
+      _retval = getPyNone();
+      mapGridToParts(source, parts, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mapGridToParts", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mapGridToParts", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mapGridToParts("", "mapGridToParts", _W_15);
+extern "C" {
+void PbRegister_mapGridToParts()
+{
+  KEEP_UNUSED(_RP_mapGridToParts);
+}
+}
+
+void mapGridToPartsVec3(const Grid<Vec3> &source,
+                        const BasicParticleSystem &parts,
+                        ParticleDataImpl<Vec3> &target)
+{
+  knMapFromGrid<Vec3>(parts, source, target);
+}
+static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mapGridToPartsVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 1, &_lock);
+      ParticleDataImpl<Vec3> &target = *_args.getPtr<ParticleDataImpl<Vec3>>("target", 2, &_lock);
+      _retval = getPyNone();
+      mapGridToPartsVec3(source, parts, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mapGridToPartsVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mapGridToPartsVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mapGridToPartsVec3("", "mapGridToPartsVec3", _W_16);
+extern "C" {
+void PbRegister_mapGridToPartsVec3()
+{
+  KEEP_UNUSED(_RP_mapGridToPartsVec3);
+}
+}
+
+// Get velocities from grid
+
+struct knMapLinearMACGridToVec3_PIC : public KernelBase {
+  knMapLinearMACGridToVec3_PIC(const BasicParticleSystem &p,
+                               const FlagGrid &flags,
+                               const MACGrid &vel,
+                               ParticleDataImpl<Vec3> &pvel,
+                               const ParticleDataImpl<int> *ptype,
+                               const int exclude)
+      : KernelBase(p.size()),
+        p(p),
+        flags(flags),
+        vel(vel),
+        pvel(pvel),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 ParticleDataImpl<Vec3> &pvel,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+    // pure PIC
+    pvel[idx] = vel.getInterpolated(p[idx].pos);
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  inline ParticleDataImpl<Vec3> &getArg3()
+  {
+    return pvel;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline const ParticleDataImpl<int> *getArg4()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type4;
+  inline const int &getArg5()
+  {
+    return exclude;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMapLinearMACGridToVec3_PIC ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, flags, vel, pvel, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystem &p;
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  ParticleDataImpl<Vec3> &pvel;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+void mapMACToParts(const FlagGrid &flags,
+                   const MACGrid &vel,
+                   const BasicParticleSystem &parts,
+                   ParticleDataImpl<Vec3> &partVel,
+                   const ParticleDataImpl<int> *ptype = NULL,
+                   const int exclude = 0)
+{
+  knMapLinearMACGridToVec3_PIC(parts, flags, vel, partVel, ptype, exclude);
+}
+static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "mapMACToParts", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 2, &_lock);
+      ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "partVel", 3, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 4, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 5, 0, &_lock);
+      _retval = getPyNone();
+      mapMACToParts(flags, vel, parts, partVel, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "mapMACToParts", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("mapMACToParts", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_mapMACToParts("", "mapMACToParts", _W_17);
+extern "C" {
+void PbRegister_mapMACToParts()
+{
+  KEEP_UNUSED(_RP_mapMACToParts);
+}
+}
+
+// with flip delta interpolation
+
+struct knMapLinearMACGridToVec3_FLIP : public KernelBase {
+  knMapLinearMACGridToVec3_FLIP(const BasicParticleSystem &p,
+                                const FlagGrid &flags,
+                                const MACGrid &vel,
+                                const MACGrid &oldVel,
+                                ParticleDataImpl<Vec3> &pvel,
+                                const Real flipRatio,
+                                const ParticleDataImpl<int> *ptype,
+                                const int exclude)
+      : KernelBase(p.size()),
+        p(p),
+        flags(flags),
+        vel(vel),
+        oldVel(oldVel),
+        pvel(pvel),
+        flipRatio(flipRatio),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 const FlagGrid &flags,
+                 const MACGrid &vel,
+                 const MACGrid &oldVel,
+                 ParticleDataImpl<Vec3> &pvel,
+                 const Real flipRatio,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (!p.isActive(idx) || (ptype && ((*ptype)[idx] & exclude)))
+      return;
+    Vec3 v = vel.getInterpolated(p[idx].pos);
+    Vec3 delta = v - oldVel.getInterpolated(p[idx].pos);
+    pvel[idx] = flipRatio * (pvel[idx] + delta) + (1.0 - flipRatio) * v;
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  inline const MACGrid &getArg3()
+  {
+    return oldVel;
+  }
+  typedef MACGrid type3;
+  inline ParticleDataImpl<Vec3> &getArg4()
+  {
+    return pvel;
+  }
+  typedef ParticleDataImpl<Vec3> type4;
+  inline const Real &getArg5()
+  {
+    return flipRatio;
+  }
+  typedef Real type5;
+  inline const ParticleDataImpl<int> *getArg6()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type6;
+  inline const int &getArg7()
+  {
+    return exclude;
+  }
+  typedef int type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel knMapLinearMACGridToVec3_FLIP ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, flags, vel, oldVel, pvel, flipRatio, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystem &p;
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  const MACGrid &oldVel;
+  ParticleDataImpl<Vec3> &pvel;
+  const Real flipRatio;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+
+void flipVelocityUpdate(const FlagGrid &flags,
+                        const MACGrid &vel,
+                        const MACGrid &velOld,
+                        const BasicParticleSystem &parts,
+                        ParticleDataImpl<Vec3> &partVel,
+                        const Real flipRatio,
+                        const ParticleDataImpl<int> *ptype = NULL,
+                        const int exclude = 0)
+{
+  knMapLinearMACGridToVec3_FLIP(parts, flags, vel, velOld, partVel, flipRatio, ptype, exclude);
+}
+static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipVelocityUpdate", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const MACGrid &velOld = *_args.getPtr<MACGrid>("velOld", 2, &_lock);
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 3, &_lock);
+      ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "partVel", 4, &_lock);
+      const Real flipRatio = _args.get<Real>("flipRatio", 5, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
+          "ptype", 6, NULL, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
+      _retval = getPyNone();
+      flipVelocityUpdate(flags, vel, velOld, parts, partVel, flipRatio, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipVelocityUpdate", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipVelocityUpdate", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipVelocityUpdate("", "flipVelocityUpdate", _W_18);
+extern "C" {
+void PbRegister_flipVelocityUpdate()
+{
+  KEEP_UNUSED(_RP_flipVelocityUpdate);
+}
+}
+
+//******************************************************************************
+// narrow band
+
+struct knCombineVels : public KernelBase {
+  knCombineVels(MACGrid &vel,
+                const Grid<Vec3> &w,
+                MACGrid &combineVel,
+                const LevelsetGrid *phi,
+                Real narrowBand,
+                Real thresh)
+      : KernelBase(&vel, 0),
+        vel(vel),
+        w(w),
+        combineVel(combineVel),
+        phi(phi),
+        narrowBand(narrowBand),
+        thresh(thresh)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &vel,
+                 const Grid<Vec3> &w,
+                 MACGrid &combineVel,
+                 const LevelsetGrid *phi,
+                 Real narrowBand,
+                 Real thresh) const
+  {
+    int idx = vel.index(i, j, k);
+
+    for (int c = 0; c < 3; ++c) {
+      // Correct narrow-band FLIP
+      if (phi) {
+        Vec3 pos(i, j, k);
+        pos[(c + 1) % 3] += Real(0.5);
+        pos[(c + 2) % 3] += Real(0.5);
+        Real p = phi->getInterpolated(pos);
+        if (p < -narrowBand) {
+          vel[idx][c] = 0;
+          continue;
+        }
+      }
+
+      if (w[idx][c] > thresh) {
+        combineVel[idx][c] = vel[idx][c];
+        vel[idx][c] = -1;
+      }
+      else {
+        vel[idx][c] = 0;
+      }
+    }
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline const Grid<Vec3> &getArg1()
+  {
+    return w;
+  }
+  typedef Grid<Vec3> type1;
+  inline MACGrid &getArg2()
+  {
+    return combineVel;
+  }
+  typedef MACGrid type2;
+  inline const LevelsetGrid *getArg3()
+  {
+    return phi;
+  }
+  typedef LevelsetGrid type3;
+  inline Real &getArg4()
+  {
+    return narrowBand;
+  }
+  typedef Real type4;
+  inline Real &getArg5()
+  {
+    return thresh;
+  }
+  typedef Real type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCombineVels ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, vel, w, combineVel, phi, narrowBand, thresh);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, vel, w, combineVel, phi, narrowBand, thresh);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  MACGrid &vel;
+  const Grid<Vec3> &w;
+  MACGrid &combineVel;
+  const LevelsetGrid *phi;
+  Real narrowBand;
+  Real thresh;
+};
+
+//! narrow band velocity combination
+
+void combineGridVel(MACGrid &vel,
+                    const Grid<Vec3> &weight,
+                    MACGrid &combineVel,
+                    const LevelsetGrid *phi = NULL,
+                    Real narrowBand = 0.0,
+                    Real thresh = 0.0)
+{
+  knCombineVels(vel, weight, combineVel, phi, narrowBand, thresh);
+}
+static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "combineGridVel", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      const Grid<Vec3> &weight = *_args.getPtr<Grid<Vec3>>("weight", 1, &_lock);
+      MACGrid &combineVel = *_args.getPtr<MACGrid>("combineVel", 2, &_lock);
+      const LevelsetGrid *phi = _args.getPtrOpt<LevelsetGrid>("phi", 3, NULL, &_lock);
+      Real narrowBand = _args.getOpt<Real>("narrowBand", 4, 0.0, &_lock);
+      Real thresh = _args.getOpt<Real>("thresh", 5, 0.0, &_lock);
+      _retval = getPyNone();
+      combineGridVel(vel, weight, combineVel, phi, narrowBand, thresh);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "combineGridVel", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("combineGridVel", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_combineGridVel("", "combineGridVel", _W_19);
+extern "C" {
+void PbRegister_combineGridVel()
+{
+  KEEP_UNUSED(_RP_combineGridVel);
+}
+}
+
+//! surface tension helper
+void getLaplacian(Grid<Real> &laplacian, const Grid<Real> &grid)
+{
+  LaplaceOp(laplacian, grid);
+}
+static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getLaplacian", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &laplacian = *_args.getPtr<Grid<Real>>("laplacian", 0, &_lock);
+      const Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 1, &_lock);
+      _retval = getPyNone();
+      getLaplacian(laplacian, grid);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getLaplacian", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getLaplacian", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getLaplacian("", "getLaplacian", _W_20);
+extern "C" {
+void PbRegister_getLaplacian()
+{
+  KEEP_UNUSED(_RP_getLaplacian);
+}
+}
+
+void getCurvature(Grid<Real> &curv, const Grid<Real> &grid, const Real h = 1.0)
+{
+  CurvatureOp(curv, grid, h);
+}
+static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getCurvature", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &curv = *_args.getPtr<Grid<Real>>("curv", 0, &_lock);
+      const Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 1, &_lock);
+      const Real h = _args.getOpt<Real>("h", 2, 1.0, &_lock);
+      _retval = getPyNone();
+      getCurvature(curv, grid, h);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getCurvature", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getCurvature", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getCurvature("", "getCurvature", _W_21);
+extern "C" {
+void PbRegister_getCurvature()
+{
+  KEEP_UNUSED(_RP_getCurvature);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/fluidguiding.cpp b/extern/mantaflow/preprocessed/plugin/fluidguiding.cpp
new file mode 100644
index 00000000000..13383581123
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/fluidguiding.cpp
@@ -0,0 +1,802 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Plugins for pressure correction: solve_pressure, and ghost fluid helpers
+ *
+ ******************************************************************************/
+#include "vectorbase.h"
+#include "grid.h"
+#include "kernel.h"
+#include "conjugategrad.h"
+#include "rcmatrix.h"
+
+using namespace std;
+namespace Manta {
+
+// only supports a single blur size for now, globals stored here
+bool gBlurPrecomputed = false;
+int gBlurKernelRadius = -1;
+Matrix gBlurKernel;
+
+// *****************************************************************************
+// Helper functions for fluid guiding
+
+//! creates a 1D (horizontal) Gaussian blur kernel of size n and standard deviation sigma
+Matrix get1DGaussianBlurKernel(const int n, const int sigma)
+{
+  Matrix x(n), y(n);
+  for (int j = 0; j < n; j++) {
+    x.add_to_element(0, j, -(n - 1) * 0.5);
+    y.add_to_element(0, j, j - (n - 1) * 0.5);
+  }
+  Matrix G(n);
+  Real sumG = 0;
+  for (int j = 0; j < n; j++) {
+    G.add_to_element(0,
+                     j,
+                     1 / (2 * M_PI * sigma * sigma) *
+                         exp(-(x(0, j) * x(0, j) + y(0, j) * y(0, j)) / (2 * sigma * sigma)));
+    sumG += G(0, j);
+  }
+  G = G * (1.0 / sumG);
+  return G;
+}
+
+//! convolves in with 1D kernel (centred at the kernel's midpoint) in the x-direction
+//! (out must be a grid of zeros)
+struct apply1DKernelDirX : public KernelBase {
+  apply1DKernelDirX(const MACGrid &in, MACGrid &out, const Matrix &kernel)
+      : KernelBase(&in, 0), in(in), out(out), kernel(kernel)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const MACGrid &in, MACGrid &out, const Matrix &kernel) const
+  {
+    int nx = in.getSizeX();
+    int kn = kernel.n;
+    int kCentre = kn / 2;
+    for (int m = 0, ind = kn - 1, ii = i - kCentre; m < kn; m++, ind--, ii++) {
+      if (ii < 0)
+        continue;
+      else if (ii >= nx)
+        break;
+      else
+        out(i, j, k) += in(ii, j, k) * kernel(0, ind);
+    }
+  }
+  inline const MACGrid &getArg0()
+  {
+    return in;
+  }
+  typedef MACGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return out;
+  }
+  typedef MACGrid type1;
+  inline const Matrix &getArg2()
+  {
+    return kernel;
+  }
+  typedef Matrix type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel apply1DKernelDirX ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, in, out, kernel);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, in, out, kernel);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const MACGrid &in;
+  MACGrid &out;
+  const Matrix &kernel;
+};
+
+//! convolves in with 1D kernel (centred at the kernel's midpoint) in the y-direction
+//! (out must be a grid of zeros)
+struct apply1DKernelDirY : public KernelBase {
+  apply1DKernelDirY(const MACGrid &in, MACGrid &out, const Matrix &kernel)
+      : KernelBase(&in, 0), in(in), out(out), kernel(kernel)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const MACGrid &in, MACGrid &out, const Matrix &kernel) const
+  {
+    int ny = in.getSizeY();
+    int kn = kernel.n;
+    int kCentre = kn / 2;
+    for (int m = 0, ind = kn - 1, jj = j - kCentre; m < kn; m++, ind--, jj++) {
+      if (jj < 0)
+        continue;
+      else if (jj >= ny)
+        break;
+      else
+        out(i, j, k) += in(i, jj, k) * kernel(0, ind);
+    }
+  }
+  inline const MACGrid &getArg0()
+  {
+    return in;
+  }
+  typedef MACGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return out;
+  }
+  typedef MACGrid type1;
+  inline const Matrix &getArg2()
+  {
+    return kernel;
+  }
+  typedef Matrix type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel apply1DKernelDirY ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, in, out, kernel);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, in, out, kernel);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const MACGrid &in;
+  MACGrid &out;
+  const Matrix &kernel;
+};
+
+//! convolves in with 1D kernel (centred at the kernel's midpoint) in the z-direction
+//! (out must be a grid of zeros)
+struct apply1DKernelDirZ : public KernelBase {
+  apply1DKernelDirZ(const MACGrid &in, MACGrid &out, const Matrix &kernel)
+      : KernelBase(&in, 0), in(in), out(out), kernel(kernel)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const MACGrid &in, MACGrid &out, const Matrix &kernel) const
+  {
+    int nz = in.getSizeZ();
+    int kn = kernel.n;
+    int kCentre = kn / 2;
+    for (int m = 0, ind = kn - 1, kk = k - kCentre; m < kn; m++, ind--, kk++) {
+      if (kk < 0)
+        continue;
+      else if (kk >= nz)
+        break;
+      else
+        out(i, j, k) += in(i, j, kk) * kernel(0, ind);
+    }
+  }
+  inline const MACGrid &getArg0()
+  {
+    return in;
+  }
+  typedef MACGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return out;
+  }
+  typedef MACGrid type1;
+  inline const Matrix &getArg2()
+  {
+    return kernel;
+  }
+  typedef Matrix type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel apply1DKernelDirZ ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, in, out, kernel);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, in, out, kernel);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const MACGrid &in;
+  MACGrid &out;
+  const Matrix &kernel;
+};
+
+//! Apply separable Gaussian blur in 2D
+void applySeparableKernel2D(MACGrid &grid, const FlagGrid &flags, const Matrix &kernel)
+{
+  // int nx = grid.getSizeX(), ny = grid.getSizeY();
+  // int kn = kernel.n;
+  // int kCentre = kn / 2;
+  FluidSolver *parent = grid.getParent();
+  MACGrid orig = MACGrid(parent);
+  orig.copyFrom(grid);
+  MACGrid gridX = MACGrid(parent);
+  apply1DKernelDirX(grid, gridX, kernel);
+  MACGrid gridXY = MACGrid(parent);
+  apply1DKernelDirY(gridX, gridXY, kernel);
+  grid.copyFrom(gridXY);
+  FOR_IJK(grid)
+  {
+    if ((i > 0 && flags.isObstacle(i - 1, j, k)) || (j > 0 && flags.isObstacle(i, j - 1, k)) ||
+        flags.isObstacle(i, j, k)) {
+      grid(i, j, k).x = orig(i, j, k).x;
+      grid(i, j, k).y = orig(i, j, k).y;
+      grid(i, j, k).z = orig(i, j, k).z;
+    }
+  }
+}
+
+//! Apply separable Gaussian blur in 3D
+void applySeparableKernel3D(MACGrid &grid, const FlagGrid &flags, const Matrix &kernel)
+{
+  // int nx = grid.getSizeX(), ny = grid.getSizeY(), nz = grid.getSizeZ();
+  // int kn = kernel.n;
+  // int kCentre = kn / 2;
+  FluidSolver *parent = grid.getParent();
+  MACGrid orig = MACGrid(parent);
+  orig.copyFrom(grid);
+  MACGrid gridX = MACGrid(parent);
+  apply1DKernelDirX(grid, gridX, kernel);
+  MACGrid gridXY = MACGrid(parent);
+  apply1DKernelDirY(gridX, gridXY, kernel);
+  MACGrid gridXYZ = MACGrid(parent);
+  apply1DKernelDirZ(gridXY, gridXYZ, kernel);
+  grid.copyFrom(gridXYZ);
+  FOR_IJK(grid)
+  {
+    if ((i > 0 && flags.isObstacle(i - 1, j, k)) || (j > 0 && flags.isObstacle(i, j - 1, k)) ||
+        (k > 0 && flags.isObstacle(i, j, k - 1)) || flags.isObstacle(i, j, k)) {
+      grid(i, j, k).x = orig(i, j, k).x;
+      grid(i, j, k).y = orig(i, j, k).y;
+      grid(i, j, k).z = orig(i, j, k).z;
+    }
+  }
+}
+
+//! Apply separable Gaussian blur in 2D or 3D depending on input dimensions
+void applySeparableKernel(MACGrid &grid, const FlagGrid &flags, const Matrix &kernel)
+{
+  if (!grid.is3D())
+    applySeparableKernel2D(grid, flags, kernel);
+  else
+    applySeparableKernel3D(grid, flags, kernel);
+}
+
+//! Compute r-norm for the stopping criterion
+Real getRNorm(const MACGrid &x, const MACGrid &z)
+{
+  MACGrid r = MACGrid(x.getParent());
+  r.copyFrom(x);
+  r.sub(z);
+  return r.getMaxAbs();
+}
+
+//! Compute s-norm for the stopping criterion
+Real getSNorm(const Real rho, const MACGrid &z, const MACGrid &z_prev)
+{
+  MACGrid s = MACGrid(z_prev.getParent());
+  s.copyFrom(z_prev);
+  s.sub(z);
+  s.multConst(rho);
+  return s.getMaxAbs();
+}
+
+//! Compute primal eps for the stopping criterion
+Real getEpsPri(const Real eps_abs, const Real eps_rel, const MACGrid &x, const MACGrid &z)
+{
+  Real max_norm = max(x.getMaxAbs(), z.getMaxAbs());
+  Real eps_pri = sqrt(x.is3D() ? 3.0 : 2.0) * eps_abs + eps_rel * max_norm;
+  return eps_pri;
+}
+
+//! Compute dual eps for the stopping criterion
+Real getEpsDual(const Real eps_abs, const Real eps_rel, const MACGrid &y)
+{
+  Real eps_dual = sqrt(y.is3D() ? 3.0 : 2.0) * eps_abs + eps_rel * y.getMaxAbs();
+  return eps_dual;
+}
+
+//! Create a spiral velocity field in 2D as a test scene (optionally in 3D)
+void getSpiralVelocity(const FlagGrid &flags,
+                       MACGrid &vel,
+                       Real strength = 1.0,
+                       bool with3D = false)
+{
+  int nx = flags.getSizeX(), ny = flags.getSizeY(), nz = 1;
+  if (with3D)
+    nz = flags.getSizeZ();
+  Real midX = 0.5 * (Real)(nx - 1);
+  Real midY = 0.5 * (Real)(ny - 1);
+  Real midZ = 0.5 * (Real)(nz - 1);
+  for (int i = 0; i < nx; i++) {
+    for (int j = 0; j < ny; j++) {
+      for (int k = 0; k < nz; k++) {
+        int idx = flags.index(i, j, k);
+        Real diffX = midX - i;
+        Real diffY = midY - j;
+        Real hypotenuse = sqrt(diffX * diffX + diffY * diffY);
+        if (hypotenuse > 0) {
+          vel[idx].x = diffY / hypotenuse;
+          vel[idx].y = -diffX / hypotenuse;
+        }
+      }
+    }
+  }
+  vel.multConst(strength);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getSpiralVelocity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      Real strength = _args.getOpt<Real>("strength", 2, 1.0, &_lock);
+      bool with3D = _args.getOpt<bool>("with3D", 3, false, &_lock);
+      _retval = getPyNone();
+      getSpiralVelocity(flags, vel, strength, with3D);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getSpiralVelocity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getSpiralVelocity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getSpiralVelocity("", "getSpiralVelocity", _W_0);
+extern "C" {
+void PbRegister_getSpiralVelocity()
+{
+  KEEP_UNUSED(_RP_getSpiralVelocity);
+}
+}
+
+//! Set the guiding weight W as a gradient in the y-direction
+void setGradientYWeight(
+    Grid<Real> &W, const int minY, const int maxY, const Real valAtMin, const Real valAtMax)
+{
+  FOR_IJK(W)
+  {
+    if (minY <= j && j <= maxY) {
+      Real val = valAtMin;
+      if (valAtMax != valAtMin) {
+        Real ratio = (Real)(j - minY) / (Real)(maxY - minY);
+        val = ratio * valAtMax + (1.0 - ratio) * valAtMin;
+      }
+      W(i, j, k) = val;
+    }
+  }
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setGradientYWeight", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &W = *_args.getPtr<Grid<Real>>("W", 0, &_lock);
+      const int minY = _args.get<int>("minY", 1, &_lock);
+      const int maxY = _args.get<int>("maxY", 2, &_lock);
+      const Real valAtMin = _args.get<Real>("valAtMin", 3, &_lock);
+      const Real valAtMax = _args.get<Real>("valAtMax", 4, &_lock);
+      _retval = getPyNone();
+      setGradientYWeight(W, minY, maxY, valAtMin, valAtMax);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setGradientYWeight", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setGradientYWeight", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setGradientYWeight("", "setGradientYWeight", _W_1);
+extern "C" {
+void PbRegister_setGradientYWeight()
+{
+  KEEP_UNUSED(_RP_setGradientYWeight);
+}
+}
+
+// *****************************************************************************
+// More helper functions for fluid guiding
+
+//! Apply Gaussian blur (either 2D or 3D) in a separable way
+void applySeparableGaussianBlur(MACGrid &grid, const FlagGrid &flags, const Matrix &kernel1D)
+{
+  assertMsg(gBlurPrecomputed, "Error - blue kernel not precomputed");
+  applySeparableKernel(grid, flags, kernel1D);
+}
+
+//! Precomputation performed before the first PD iteration
+void ADMM_precompute_Separable(int blurRadius)
+{
+  if (gBlurPrecomputed) {
+    assertMsg(gBlurKernelRadius == blurRadius,
+              "More than a single blur radius not supported at the moment.");
+    return;
+  }
+  int kernelSize = 2 * blurRadius + 1;
+  gBlurKernel = get1DGaussianBlurKernel(kernelSize, kernelSize);
+  gBlurPrecomputed = true;
+  gBlurKernelRadius = blurRadius;
+}
+
+//! Apply approximate multiplication of inverse(M)
+void applyApproxInvM(MACGrid &v, const FlagGrid &flags, const MACGrid &invA)
+{
+  MACGrid v_new = MACGrid(v.getParent());
+  v_new.copyFrom(v);
+  v_new.mult(invA);
+  applySeparableGaussianBlur(v_new, flags, gBlurKernel);
+  applySeparableGaussianBlur(v_new, flags, gBlurKernel);
+  v_new.multConst(2.0);
+  v_new.mult(invA);
+  v.mult(invA);
+  v.sub(v_new);
+}
+
+//! Precompute Q, a reused quantity in the PD iterations
+//! Q = 2*G*G*(velT-velC)-sigma*velC
+void precomputeQ(MACGrid &Q,
+                 const FlagGrid &flags,
+                 const MACGrid &velT_region,
+                 const MACGrid &velC,
+                 const Matrix &gBlurKernel,
+                 const Real sigma)
+{
+  Q.copyFrom(velT_region);
+  Q.sub(velC);
+  applySeparableGaussianBlur(Q, flags, gBlurKernel);
+  applySeparableGaussianBlur(Q, flags, gBlurKernel);
+  Q.multConst(2.0);
+  Q.addScaled(velC, -sigma);
+}
+
+//! Precompute inverse(A), a reused quantity in the PD iterations
+//! A = 2*S^2 + p*I, invA = elementwise 1/A
+void precomputeInvA(MACGrid &invA, const Grid<Real> &weight, const Real sigma)
+{
+  FOR_IJK(invA)
+  {
+    Real val = 2 * weight(i, j, k) * weight(i, j, k) + sigma;
+    if (val < 0.01)
+      val = 0.01;
+    Real invVal = 1.0 / val;
+    invA(i, j, k).x = invVal;
+    invA(i, j, k).y = invVal;
+    invA(i, j, k).z = invVal;
+  }
+}
+
+//! proximal operator of f , guiding
+void prox_f(MACGrid &v,
+            const FlagGrid &flags,
+            const MACGrid &Q,
+            const MACGrid &velC,
+            const Real sigma,
+            const MACGrid &invA)
+{
+  v.multConst(sigma);
+  v.add(Q);
+  applyApproxInvM(v, flags, invA);
+  v.add(velC);
+}
+
+// *****************************************************************************
+
+// re-uses main pressure solve from pressure.cpp
+void solvePressure(MACGrid &vel,
+                   Grid<Real> &pressure,
+                   const FlagGrid &flags,
+                   Real cgAccuracy = 1e-3,
+                   const Grid<Real> *phi = 0,
+                   const Grid<Real> *perCellCorr = 0,
+                   const MACGrid *fractions = 0,
+                   const MACGrid *obvel = 0,
+                   Real gfClamp = 1e-04,
+                   Real cgMaxIterFac = 1.5,
+                   bool precondition = true,
+                   int preconditioner = 1,
+                   bool enforceCompatibility = false,
+                   bool useL2Norm = false,
+                   bool zeroPressureFixing = false,
+                   const Grid<Real> *curv = NULL,
+                   const Real surfTens = 0.0,
+                   Grid<Real> *retRhs = NULL);
+
+//! Main function for fluid guiding , includes "regular" pressure solve
+
+void PD_fluid_guiding(MACGrid &vel,
+                      MACGrid &velT,
+                      Grid<Real> &pressure,
+                      FlagGrid &flags,
+                      Grid<Real> &weight,
+                      int blurRadius = 5,
+                      Real theta = 1.0,
+                      Real tau = 1.0,
+                      Real sigma = 1.0,
+                      Real epsRel = 1e-3,
+                      Real epsAbs = 1e-3,
+                      int maxIters = 200,
+                      Grid<Real> *phi = 0,
+                      Grid<Real> *perCellCorr = 0,
+                      MACGrid *fractions = 0,
+                      MACGrid *obvel = 0,
+                      Real gfClamp = 1e-04,
+                      Real cgMaxIterFac = 1.5,
+                      Real cgAccuracy = 1e-3,
+                      int preconditioner = 1,
+                      bool zeroPressureFixing = false,
+                      const Grid<Real> *curv = NULL,
+                      const Real surfTens = 0.)
+{
+  FluidSolver *parent = vel.getParent();
+
+  // initialize dual/slack variables
+  MACGrid velC = MACGrid(parent);
+  velC.copyFrom(vel);
+  MACGrid x = MACGrid(parent);
+  MACGrid y = MACGrid(parent);
+  MACGrid z = MACGrid(parent);
+  MACGrid x0 = MACGrid(parent);
+  MACGrid z0 = MACGrid(parent);
+
+  // precomputation
+  ADMM_precompute_Separable(blurRadius);
+  MACGrid Q = MACGrid(parent);
+  precomputeQ(Q, flags, velT, velC, gBlurKernel, sigma);
+  MACGrid invA = MACGrid(parent);
+  precomputeInvA(invA, weight, sigma);
+
+  // loop
+  int iter = 0;
+  for (iter = 0; iter < maxIters; iter++) {
+    // x-update
+    x0.copyFrom(x);
+    x.multConst(1.0 / sigma);
+    x.add(y);
+    prox_f(x, flags, Q, velC, sigma, invA);
+    x.multConst(-sigma);
+    x.addScaled(y, sigma);
+    x.add(x0);
+
+    // z-update
+    z0.copyFrom(z);
+    z.addScaled(x, -tau);
+    Real cgAccuracyAdaptive = cgAccuracy;
+
+    solvePressure(z,
+                  pressure,
+                  flags,
+                  cgAccuracyAdaptive,
+                  phi,
+                  perCellCorr,
+                  fractions,
+                  obvel,
+                  gfClamp,
+                  cgMaxIterFac,
+                  true,
+                  preconditioner,
+                  false,
+                  false,
+                  zeroPressureFixing,
+                  curv,
+                  surfTens);
+
+    // y-update
+    y.copyFrom(z);
+    y.sub(z0);
+    y.multConst(theta);
+    y.add(z);
+
+    // stopping criterion
+    bool stop = (iter > 0 && getRNorm(z, z0) < getEpsDual(epsAbs, epsRel, z));
+
+    if (stop || (iter == maxIters - 1))
+      break;
+  }
+
+  // vel_new = z
+  vel.copyFrom(z);
+
+  debMsg("PD_fluid_guiding iterations:" << iter, 1);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "PD_fluid_guiding", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      MACGrid &velT = *_args.getPtr<MACGrid>("velT", 1, &_lock);
+      Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
+      Grid<Real> &weight = *_args.getPtr<Grid<Real>>("weight", 4, &_lock);
+      int blurRadius = _args.getOpt<int>("blurRadius", 5, 5, &_lock);
+      Real theta = _args.getOpt<Real>("theta", 6, 1.0, &_lock);
+      Real tau = _args.getOpt<Real>("tau", 7, 1.0, &_lock);
+      Real sigma = _args.getOpt<Real>("sigma", 8, 1.0, &_lock);
+      Real epsRel = _args.getOpt<Real>("epsRel", 9, 1e-3, &_lock);
+      Real epsAbs = _args.getOpt<Real>("epsAbs", 10, 1e-3, &_lock);
+      int maxIters = _args.getOpt<int>("maxIters", 11, 200, &_lock);
+      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 12, 0, &_lock);
+      Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 13, 0, &_lock);
+      MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 14, 0, &_lock);
+      MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 15, 0, &_lock);
+      Real gfClamp = _args.getOpt<Real>("gfClamp", 16, 1e-04, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 17, 1.5, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 18, 1e-3, &_lock);
+      int preconditioner = _args.getOpt<int>("preconditioner", 19, 1, &_lock);
+      bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 20, false, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 21, NULL, &_lock);
+      const Real surfTens = _args.getOpt<Real>("surfTens", 22, 0., &_lock);
+      _retval = getPyNone();
+      PD_fluid_guiding(vel,
+                       velT,
+                       pressure,
+                       flags,
+                       weight,
+                       blurRadius,
+                       theta,
+                       tau,
+                       sigma,
+                       epsRel,
+                       epsAbs,
+                       maxIters,
+                       phi,
+                       perCellCorr,
+                       fractions,
+                       obvel,
+                       gfClamp,
+                       cgMaxIterFac,
+                       cgAccuracy,
+                       preconditioner,
+                       zeroPressureFixing,
+                       curv,
+                       surfTens);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "PD_fluid_guiding", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("PD_fluid_guiding", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_PD_fluid_guiding("", "PD_fluid_guiding", _W_2);
+extern "C" {
+void PbRegister_PD_fluid_guiding()
+{
+  KEEP_UNUSED(_RP_PD_fluid_guiding);
+}
+}
+
+//! reset precomputation
+void releaseBlurPrecomp()
+{
+  gBlurPrecomputed = false;
+  gBlurKernelRadius = -1;
+  gBlurKernel = 0.f;
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "releaseBlurPrecomp", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      _retval = getPyNone();
+      releaseBlurPrecomp();
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "releaseBlurPrecomp", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("releaseBlurPrecomp", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_releaseBlurPrecomp("", "releaseBlurPrecomp", _W_3);
+extern "C" {
+void PbRegister_releaseBlurPrecomp()
+{
+  KEEP_UNUSED(_RP_releaseBlurPrecomp);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/initplugins.cpp b/extern/mantaflow/preprocessed/plugin/initplugins.cpp
new file mode 100644
index 00000000000..3e28c947424
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/initplugins.cpp
@@ -0,0 +1,2317 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Tools to setup fields and inflows
+ *
+ ******************************************************************************/
+
+#include "vectorbase.h"
+#include "shapes.h"
+#include "commonkernels.h"
+#include "particle.h"
+#include "noisefield.h"
+#include "simpleimage.h"
+#include "mesh.h"
+
+using namespace std;
+
+namespace Manta {
+
+//! Apply noise to grid
+
+struct KnApplyNoiseInfl : public KernelBase {
+  KnApplyNoiseInfl(const FlagGrid &flags,
+                   Grid<Real> &density,
+                   const WaveletNoiseField &noise,
+                   const Grid<Real> &sdf,
+                   Real scale,
+                   Real sigma)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        density(density),
+        noise(noise),
+        sdf(sdf),
+        scale(scale),
+        sigma(sigma)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &density,
+                 const WaveletNoiseField &noise,
+                 const Grid<Real> &sdf,
+                 Real scale,
+                 Real sigma) const
+  {
+    if (!flags.isFluid(i, j, k) || sdf(i, j, k) > sigma)
+      return;
+    Real factor = clamp(1.0 - 0.5 / sigma * (sdf(i, j, k) + sigma), 0.0, 1.0);
+
+    Real target = noise.evaluate(Vec3(i, j, k)) * scale * factor;
+    if (density(i, j, k) < target)
+      density(i, j, k) = target;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return density;
+  }
+  typedef Grid<Real> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline const Grid<Real> &getArg3()
+  {
+    return sdf;
+  }
+  typedef Grid<Real> type3;
+  inline Real &getArg4()
+  {
+    return scale;
+  }
+  typedef Real type4;
+  inline Real &getArg5()
+  {
+    return sigma;
+  }
+  typedef Real type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnApplyNoiseInfl ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, density, noise, sdf, scale, sigma);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, density, noise, sdf, scale, sigma);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &density;
+  const WaveletNoiseField &noise;
+  const Grid<Real> &sdf;
+  Real scale;
+  Real sigma;
+};
+
+//! Init noise-modulated density inside shape
+
+void densityInflow(const FlagGrid &flags,
+                   Grid<Real> &density,
+                   const WaveletNoiseField &noise,
+                   Shape *shape,
+                   Real scale = 1.0,
+                   Real sigma = 0)
+{
+  Grid<Real> sdf = shape->computeLevelset();
+  KnApplyNoiseInfl(flags, density, noise, sdf, scale, sigma);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "densityInflow", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Shape *shape = _args.getPtr<Shape>("shape", 3, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 4, 1.0, &_lock);
+      Real sigma = _args.getOpt<Real>("sigma", 5, 0, &_lock);
+      _retval = getPyNone();
+      densityInflow(flags, density, noise, shape, scale, sigma);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "densityInflow", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("densityInflow", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_densityInflow("", "densityInflow", _W_0);
+extern "C" {
+void PbRegister_densityInflow()
+{
+  KEEP_UNUSED(_RP_densityInflow);
+}
+}
+
+//! Apply noise to real grid based on an SDF
+struct KnAddNoise : public KernelBase {
+  KnAddNoise(const FlagGrid &flags,
+             Grid<Real> &density,
+             const WaveletNoiseField &noise,
+             const Grid<Real> *sdf,
+             Real scale)
+      : KernelBase(&flags, 0), flags(flags), density(density), noise(noise), sdf(sdf), scale(scale)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &density,
+                 const WaveletNoiseField &noise,
+                 const Grid<Real> *sdf,
+                 Real scale) const
+  {
+    if (!flags.isFluid(i, j, k) || (sdf && (*sdf)(i, j, k) > 0.))
+      return;
+    density(i, j, k) += noise.evaluate(Vec3(i, j, k)) * scale;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return density;
+  }
+  typedef Grid<Real> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline const Grid<Real> *getArg3()
+  {
+    return sdf;
+  }
+  typedef Grid<Real> type3;
+  inline Real &getArg4()
+  {
+    return scale;
+  }
+  typedef Real type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAddNoise ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, density, noise, sdf, scale);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, density, noise, sdf, scale);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &density;
+  const WaveletNoiseField &noise;
+  const Grid<Real> *sdf;
+  Real scale;
+};
+void addNoise(const FlagGrid &flags,
+              Grid<Real> &density,
+              const WaveletNoiseField &noise,
+              const Grid<Real> *sdf = NULL,
+              Real scale = 1.0)
+{
+  KnAddNoise(flags, density, noise, sdf, scale);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addNoise", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      const Grid<Real> *sdf = _args.getPtrOpt<Grid<Real>>("sdf", 3, NULL, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 4, 1.0, &_lock);
+      _retval = getPyNone();
+      addNoise(flags, density, noise, sdf, scale);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addNoise", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addNoise", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addNoise("", "addNoise", _W_1);
+extern "C" {
+void PbRegister_addNoise()
+{
+  KEEP_UNUSED(_RP_addNoise);
+}
+}
+
+//! sample noise field and set pdata with its values (for convenience, scale the noise values)
+
+template<class T> struct knSetPdataNoise : public KernelBase {
+  knSetPdataNoise(const BasicParticleSystem &parts,
+                  ParticleDataImpl<T> &pdata,
+                  const WaveletNoiseField &noise,
+                  Real scale)
+      : KernelBase(parts.size()), parts(parts), pdata(pdata), noise(noise), scale(scale)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &parts,
+                 ParticleDataImpl<T> &pdata,
+                 const WaveletNoiseField &noise,
+                 Real scale) const
+  {
+    pdata[idx] = noise.evaluate(parts.getPos(idx)) * scale;
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return parts;
+  }
+  typedef BasicParticleSystem type0;
+  inline ParticleDataImpl<T> &getArg1()
+  {
+    return pdata;
+  }
+  typedef ParticleDataImpl<T> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline Real &getArg3()
+  {
+    return scale;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetPdataNoise ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, parts, pdata, noise, scale);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystem &parts;
+  ParticleDataImpl<T> &pdata;
+  const WaveletNoiseField &noise;
+  Real scale;
+};
+
+template<class T> struct knSetPdataNoiseVec : public KernelBase {
+  knSetPdataNoiseVec(const BasicParticleSystem &parts,
+                     ParticleDataImpl<T> &pdata,
+                     const WaveletNoiseField &noise,
+                     Real scale)
+      : KernelBase(parts.size()), parts(parts), pdata(pdata), noise(noise), scale(scale)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &parts,
+                 ParticleDataImpl<T> &pdata,
+                 const WaveletNoiseField &noise,
+                 Real scale) const
+  {
+    pdata[idx] = noise.evaluateVec(parts.getPos(idx)) * scale;
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return parts;
+  }
+  typedef BasicParticleSystem type0;
+  inline ParticleDataImpl<T> &getArg1()
+  {
+    return pdata;
+  }
+  typedef ParticleDataImpl<T> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline Real &getArg3()
+  {
+    return scale;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetPdataNoiseVec ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, parts, pdata, noise, scale);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystem &parts;
+  ParticleDataImpl<T> &pdata;
+  const WaveletNoiseField &noise;
+  Real scale;
+};
+void setNoisePdata(const BasicParticleSystem &parts,
+                   ParticleDataImpl<Real> &pd,
+                   const WaveletNoiseField &noise,
+                   Real scale = 1.)
+{
+  knSetPdataNoise<Real>(parts, pd, noise, scale);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setNoisePdata", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      ParticleDataImpl<Real> &pd = *_args.getPtr<ParticleDataImpl<Real>>("pd", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1., &_lock);
+      _retval = getPyNone();
+      setNoisePdata(parts, pd, noise, scale);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setNoisePdata", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setNoisePdata", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setNoisePdata("", "setNoisePdata", _W_2);
+extern "C" {
+void PbRegister_setNoisePdata()
+{
+  KEEP_UNUSED(_RP_setNoisePdata);
+}
+}
+
+void setNoisePdataVec3(const BasicParticleSystem &parts,
+                       ParticleDataImpl<Vec3> &pd,
+                       const WaveletNoiseField &noise,
+                       Real scale = 1.)
+{
+  knSetPdataNoiseVec<Vec3>(parts, pd, noise, scale);
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setNoisePdataVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      ParticleDataImpl<Vec3> &pd = *_args.getPtr<ParticleDataImpl<Vec3>>("pd", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1., &_lock);
+      _retval = getPyNone();
+      setNoisePdataVec3(parts, pd, noise, scale);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setNoisePdataVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setNoisePdataVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setNoisePdataVec3("", "setNoisePdataVec3", _W_3);
+extern "C" {
+void PbRegister_setNoisePdataVec3()
+{
+  KEEP_UNUSED(_RP_setNoisePdataVec3);
+}
+}
+
+void setNoisePdataInt(const BasicParticleSystem &parts,
+                      ParticleDataImpl<int> &pd,
+                      const WaveletNoiseField &noise,
+                      Real scale = 1.)
+{
+  knSetPdataNoise<int>(parts, pd, noise, scale);
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setNoisePdataInt", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      ParticleDataImpl<int> &pd = *_args.getPtr<ParticleDataImpl<int>>("pd", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1., &_lock);
+      _retval = getPyNone();
+      setNoisePdataInt(parts, pd, noise, scale);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setNoisePdataInt", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setNoisePdataInt", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setNoisePdataInt("", "setNoisePdataInt", _W_4);
+extern "C" {
+void PbRegister_setNoisePdataInt()
+{
+  KEEP_UNUSED(_RP_setNoisePdataInt);
+}
+}
+
+//! SDF gradient from obstacle flags, for turbulence.py
+//  FIXME, slow, without kernel...
+Grid<Vec3> obstacleGradient(const FlagGrid &flags)
+{
+  LevelsetGrid levelset(flags.getParent(), false);
+  Grid<Vec3> gradient(flags.getParent());
+
+  // rebuild obstacle levelset
+  FOR_IDX(levelset)
+  {
+    levelset[idx] = flags.isObstacle(idx) ? -0.5 : 0.5;
+  }
+  levelset.reinitMarching(flags, 6.0, 0, true, false, FlagGrid::TypeReserved);
+
+  // build levelset gradient
+  GradientOp(gradient, levelset);
+
+  FOR_IDX(levelset)
+  {
+    Vec3 grad = gradient[idx];
+    Real s = normalize(grad);
+    if (s <= 0.1 || levelset[idx] >= 0)
+      grad = Vec3(0.);
+    gradient[idx] = grad * levelset[idx];
+  }
+
+  return gradient;
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "obstacleGradient", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      _retval = toPy(obstacleGradient(flags));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "obstacleGradient", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("obstacleGradient", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_obstacleGradient("", "obstacleGradient", _W_5);
+extern "C" {
+void PbRegister_obstacleGradient()
+{
+  KEEP_UNUSED(_RP_obstacleGradient);
+}
+}
+
+//! SDF from obstacle flags, for turbulence.py
+LevelsetGrid obstacleLevelset(const FlagGrid &flags)
+{
+  LevelsetGrid levelset(flags.getParent(), false);
+
+  // rebuild obstacle levelset
+  FOR_IDX(levelset)
+  {
+    levelset[idx] = flags.isObstacle(idx) ? -0.5 : 0.5;
+  }
+  levelset.reinitMarching(flags, 6.0, 0, true, false, FlagGrid::TypeReserved);
+
+  return levelset;
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "obstacleLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      _retval = toPy(obstacleLevelset(flags));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "obstacleLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("obstacleLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_obstacleLevelset("", "obstacleLevelset", _W_6);
+extern "C" {
+void PbRegister_obstacleLevelset()
+{
+  KEEP_UNUSED(_RP_obstacleLevelset);
+}
+}
+
+//*****************************************************************************
+// blender init functions
+
+struct KnApplyEmission : public KernelBase {
+  KnApplyEmission(const FlagGrid &flags,
+                  Grid<Real> &target,
+                  const Grid<Real> &source,
+                  const Grid<Real> *emissionTexture,
+                  bool isAbsolute,
+                  int type)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        target(target),
+        source(source),
+        emissionTexture(emissionTexture),
+        isAbsolute(isAbsolute),
+        type(type)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &target,
+                 const Grid<Real> &source,
+                 const Grid<Real> *emissionTexture,
+                 bool isAbsolute,
+                 int type) const
+  {
+    // if type is given, only apply emission when celltype matches type from flaggrid
+    // and if emission texture is given, only apply emission when some emission is present at cell
+    // (important for emit from particles)
+    bool isInflow = (type & FlagGrid::TypeInflow && flags.isInflow(i, j, k));
+    bool isOutflow = (type & FlagGrid::TypeOutflow && flags.isOutflow(i, j, k));
+    if ((type && !isInflow && !isOutflow) && (emissionTexture && !(*emissionTexture)(i, j, k)))
+      return;
+
+    if (isAbsolute)
+      target(i, j, k) = source(i, j, k);
+    else
+      target(i, j, k) += source(i, j, k);
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return source;
+  }
+  typedef Grid<Real> type2;
+  inline const Grid<Real> *getArg3()
+  {
+    return emissionTexture;
+  }
+  typedef Grid<Real> type3;
+  inline bool &getArg4()
+  {
+    return isAbsolute;
+  }
+  typedef bool type4;
+  inline int &getArg5()
+  {
+    return type;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnApplyEmission ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, target, source, emissionTexture, isAbsolute, type);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, target, source, emissionTexture, isAbsolute, type);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &target;
+  const Grid<Real> &source;
+  const Grid<Real> *emissionTexture;
+  bool isAbsolute;
+  int type;
+};
+
+//! Add emission values
+// isAbsolute: whether to add emission values to existing, or replace
+void applyEmission(FlagGrid &flags,
+                   Grid<Real> &target,
+                   Grid<Real> &source,
+                   Grid<Real> *emissionTexture = NULL,
+                   bool isAbsolute = true,
+                   int type = 0)
+{
+  KnApplyEmission(flags, target, source, emissionTexture, isAbsolute, type);
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "applyEmission", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
+      Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 2, &_lock);
+      Grid<Real> *emissionTexture = _args.getPtrOpt<Grid<Real>>(
+          "emissionTexture", 3, NULL, &_lock);
+      bool isAbsolute = _args.getOpt<bool>("isAbsolute", 4, true, &_lock);
+      int type = _args.getOpt<int>("type", 5, 0, &_lock);
+      _retval = getPyNone();
+      applyEmission(flags, target, source, emissionTexture, isAbsolute, type);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "applyEmission", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("applyEmission", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_applyEmission("", "applyEmission", _W_7);
+extern "C" {
+void PbRegister_applyEmission()
+{
+  KEEP_UNUSED(_RP_applyEmission);
+}
+}
+
+// blender init functions for meshes
+
+struct KnApplyDensity : public KernelBase {
+  KnApplyDensity(
+      const FlagGrid &flags, Grid<Real> &density, const Grid<Real> &sdf, Real value, Real sigma)
+      : KernelBase(&flags, 0), flags(flags), density(density), sdf(sdf), value(value), sigma(sigma)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &density,
+                 const Grid<Real> &sdf,
+                 Real value,
+                 Real sigma) const
+  {
+    if (!flags.isFluid(i, j, k) || sdf(i, j, k) > sigma)
+      return;
+    density(i, j, k) = value;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return density;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return sdf;
+  }
+  typedef Grid<Real> type2;
+  inline Real &getArg3()
+  {
+    return value;
+  }
+  typedef Real type3;
+  inline Real &getArg4()
+  {
+    return sigma;
+  }
+  typedef Real type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnApplyDensity ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, density, sdf, value, sigma);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, density, sdf, value, sigma);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &density;
+  const Grid<Real> &sdf;
+  Real value;
+  Real sigma;
+};
+//! Init noise-modulated density inside mesh
+
+void densityInflowMeshNoise(const FlagGrid &flags,
+                            Grid<Real> &density,
+                            const WaveletNoiseField &noise,
+                            Mesh *mesh,
+                            Real scale = 1.0,
+                            Real sigma = 0)
+{
+  LevelsetGrid sdf(density.getParent(), false);
+  mesh->computeLevelset(sdf, 1.);
+  KnApplyNoiseInfl(flags, density, noise, sdf, scale, sigma);
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "densityInflowMeshNoise", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Mesh *mesh = _args.getPtr<Mesh>("mesh", 3, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 4, 1.0, &_lock);
+      Real sigma = _args.getOpt<Real>("sigma", 5, 0, &_lock);
+      _retval = getPyNone();
+      densityInflowMeshNoise(flags, density, noise, mesh, scale, sigma);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "densityInflowMeshNoise", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("densityInflowMeshNoise", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_densityInflowMeshNoise("", "densityInflowMeshNoise", _W_8);
+extern "C" {
+void PbRegister_densityInflowMeshNoise()
+{
+  KEEP_UNUSED(_RP_densityInflowMeshNoise);
+}
+}
+
+//! Init constant density inside mesh
+
+void densityInflowMesh(const FlagGrid &flags,
+                       Grid<Real> &density,
+                       Mesh *mesh,
+                       Real value = 1.,
+                       Real cutoff = 7,
+                       Real sigma = 0)
+{
+  LevelsetGrid sdf(density.getParent(), false);
+  mesh->computeLevelset(sdf, 2., cutoff);
+  KnApplyDensity(flags, density, sdf, value, sigma);
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "densityInflowMesh", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      Mesh *mesh = _args.getPtr<Mesh>("mesh", 2, &_lock);
+      Real value = _args.getOpt<Real>("value", 3, 1., &_lock);
+      Real cutoff = _args.getOpt<Real>("cutoff", 4, 7, &_lock);
+      Real sigma = _args.getOpt<Real>("sigma", 5, 0, &_lock);
+      _retval = getPyNone();
+      densityInflowMesh(flags, density, mesh, value, cutoff, sigma);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "densityInflowMesh", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("densityInflowMesh", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_densityInflowMesh("", "densityInflowMesh", _W_9);
+extern "C" {
+void PbRegister_densityInflowMesh()
+{
+  KEEP_UNUSED(_RP_densityInflowMesh);
+}
+}
+
+//*****************************************************************************
+
+//! check for symmetry , optionally enfore by copying
+
+void checkSymmetry(
+    Grid<Real> &a, Grid<Real> *err = NULL, bool symmetrize = false, int axis = 0, int bound = 0)
+{
+  const int c = axis;
+  const int s = a.getSize()[c];
+  FOR_IJK(a)
+  {
+    Vec3i idx(i, j, k), mdx(i, j, k);
+    mdx[c] = s - 1 - idx[c];
+    if (bound > 0 && ((!a.isInBounds(idx, bound)) || (!a.isInBounds(mdx, bound))))
+      continue;
+
+    if (err)
+      (*err)(idx) = fabs((double)(a(idx) - a(mdx)));
+    if (symmetrize && (idx[c] < s / 2)) {
+      a(idx) = a(mdx);
+    }
+  }
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "checkSymmetry", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &a = *_args.getPtr<Grid<Real>>("a", 0, &_lock);
+      Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, NULL, &_lock);
+      bool symmetrize = _args.getOpt<bool>("symmetrize", 2, false, &_lock);
+      int axis = _args.getOpt<int>("axis", 3, 0, &_lock);
+      int bound = _args.getOpt<int>("bound", 4, 0, &_lock);
+      _retval = getPyNone();
+      checkSymmetry(a, err, symmetrize, axis, bound);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "checkSymmetry", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("checkSymmetry", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_checkSymmetry("", "checkSymmetry", _W_10);
+extern "C" {
+void PbRegister_checkSymmetry()
+{
+  KEEP_UNUSED(_RP_checkSymmetry);
+}
+}
+
+//! check for symmetry , mac grid version
+
+void checkSymmetryVec3(Grid<Vec3> &a,
+                       Grid<Real> *err = NULL,
+                       bool symmetrize = false,
+                       int axis = 0,
+                       int bound = 0,
+                       int disable = 0)
+{
+  if (err)
+    err->setConst(0.);
+
+  // each dimension is measured separately for flexibility (could be combined)
+  const int c = axis;
+  const int o1 = (c + 1) % 3;
+  const int o2 = (c + 2) % 3;
+
+  // x
+  if (!(disable & 1)) {
+    const int s = a.getSize()[c] + 1;
+    FOR_IJK(a)
+    {
+      Vec3i idx(i, j, k), mdx(i, j, k);
+      mdx[c] = s - 1 - idx[c];
+      if (mdx[c] >= a.getSize()[c])
+        continue;
+      if (bound > 0 && ((!a.isInBounds(idx, bound)) || (!a.isInBounds(mdx, bound))))
+        continue;
+
+      // special case: center "line" of values , should be zero!
+      if (mdx[c] == idx[c]) {
+        if (err)
+          (*err)(idx) += fabs((double)(a(idx)[c]));
+        if (symmetrize)
+          a(idx)[c] = 0.;
+        continue;
+      }
+
+      // note - the a(mdx) component needs to be inverted here!
+      if (err)
+        (*err)(idx) += fabs((double)(a(idx)[c] - (a(mdx)[c] * -1.)));
+      if (symmetrize && (idx[c] < s / 2)) {
+        a(idx)[c] = a(mdx)[c] * -1.;
+      }
+    }
+  }
+
+  // y
+  if (!(disable & 2)) {
+    const int s = a.getSize()[c];
+    FOR_IJK(a)
+    {
+      Vec3i idx(i, j, k), mdx(i, j, k);
+      mdx[c] = s - 1 - idx[c];
+      if (bound > 0 && ((!a.isInBounds(idx, bound)) || (!a.isInBounds(mdx, bound))))
+        continue;
+
+      if (err)
+        (*err)(idx) += fabs((double)(a(idx)[o1] - a(mdx)[o1]));
+      if (symmetrize && (idx[c] < s / 2)) {
+        a(idx)[o1] = a(mdx)[o1];
+      }
+    }
+  }
+
+  // z
+  if (!(disable & 4)) {
+    const int s = a.getSize()[c];
+    FOR_IJK(a)
+    {
+      Vec3i idx(i, j, k), mdx(i, j, k);
+      mdx[c] = s - 1 - idx[c];
+      if (bound > 0 && ((!a.isInBounds(idx, bound)) || (!a.isInBounds(mdx, bound))))
+        continue;
+
+      if (err)
+        (*err)(idx) += fabs((double)(a(idx)[o2] - a(mdx)[o2]));
+      if (symmetrize && (idx[c] < s / 2)) {
+        a(idx)[o2] = a(mdx)[o2];
+      }
+    }
+  }
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "checkSymmetryVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &a = *_args.getPtr<Grid<Vec3>>("a", 0, &_lock);
+      Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, NULL, &_lock);
+      bool symmetrize = _args.getOpt<bool>("symmetrize", 2, false, &_lock);
+      int axis = _args.getOpt<int>("axis", 3, 0, &_lock);
+      int bound = _args.getOpt<int>("bound", 4, 0, &_lock);
+      int disable = _args.getOpt<int>("disable", 5, 0, &_lock);
+      _retval = getPyNone();
+      checkSymmetryVec3(a, err, symmetrize, axis, bound, disable);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "checkSymmetryVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("checkSymmetryVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_checkSymmetryVec3("", "checkSymmetryVec3", _W_11);
+extern "C" {
+void PbRegister_checkSymmetryVec3()
+{
+  KEEP_UNUSED(_RP_checkSymmetryVec3);
+}
+}
+
+// from simpleimage.cpp
+void projectImg(SimpleImage &img, const Grid<Real> &val, int shadeMode = 0, Real scale = 1.);
+
+//! output shaded (all 3 axes at once for 3D)
+//! shading modes: 0 smoke, 1 surfaces
+
+void projectPpmFull(const Grid<Real> &val, string name, int shadeMode = 0, Real scale = 1.)
+{
+  SimpleImage img;
+  projectImg(img, val, shadeMode, scale);
+  img.writePpm(name);
+}
+static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "projectPpmFull", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &val = *_args.getPtr<Grid<Real>>("val", 0, &_lock);
+      string name = _args.get<string>("name", 1, &_lock);
+      int shadeMode = _args.getOpt<int>("shadeMode", 2, 0, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1., &_lock);
+      _retval = getPyNone();
+      projectPpmFull(val, name, shadeMode, scale);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "projectPpmFull", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("projectPpmFull", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_projectPpmFull("", "projectPpmFull", _W_12);
+extern "C" {
+void PbRegister_projectPpmFull()
+{
+  KEEP_UNUSED(_RP_projectPpmFull);
+}
+}
+
+// helper functions for pdata operator tests
+
+//! init some test particles at the origin
+
+void addTestParts(BasicParticleSystem &parts, int num)
+{
+  for (int i = 0; i < num; ++i)
+    parts.addBuffered(Vec3(0, 0, 0));
+
+  parts.doCompress();
+  parts.insertBufferedParticles();
+}
+static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addTestParts", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      int num = _args.get<int>("num", 1, &_lock);
+      _retval = getPyNone();
+      addTestParts(parts, num);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addTestParts", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addTestParts", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addTestParts("", "addTestParts", _W_13);
+extern "C" {
+void PbRegister_addTestParts()
+{
+  KEEP_UNUSED(_RP_addTestParts);
+}
+}
+
+//! calculate the difference between two pdata fields (note - slow!, not parallelized)
+
+Real pdataMaxDiff(const ParticleDataBase *a, const ParticleDataBase *b)
+{
+  double maxVal = 0.;
+  // debMsg(" PD "<< a->getType()<<"  as"<<a->getSizeSlow()<<"  bs"<<b->getSizeSlow() , 1);
+  assertMsg(a->getType() == b->getType(), "pdataMaxDiff problem - different pdata types!");
+  assertMsg(a->getSizeSlow() == b->getSizeSlow(), "pdataMaxDiff problem - different pdata sizes!");
+
+  if (a->getType() & ParticleDataBase::TypeReal) {
+    const ParticleDataImpl<Real> &av = *dynamic_cast<const ParticleDataImpl<Real> *>(a);
+    const ParticleDataImpl<Real> &bv = *dynamic_cast<const ParticleDataImpl<Real> *>(b);
+    FOR_PARTS(av)
+    {
+      maxVal = std::max(maxVal, (double)fabs(av[idx] - bv[idx]));
+    }
+  }
+  else if (a->getType() & ParticleDataBase::TypeInt) {
+    const ParticleDataImpl<int> &av = *dynamic_cast<const ParticleDataImpl<int> *>(a);
+    const ParticleDataImpl<int> &bv = *dynamic_cast<const ParticleDataImpl<int> *>(b);
+    FOR_PARTS(av)
+    {
+      maxVal = std::max(maxVal, (double)fabs((double)av[idx] - bv[idx]));
+    }
+  }
+  else if (a->getType() & ParticleDataBase::TypeVec3) {
+    const ParticleDataImpl<Vec3> &av = *dynamic_cast<const ParticleDataImpl<Vec3> *>(a);
+    const ParticleDataImpl<Vec3> &bv = *dynamic_cast<const ParticleDataImpl<Vec3> *>(b);
+    FOR_PARTS(av)
+    {
+      double d = 0.;
+      for (int c = 0; c < 3; ++c) {
+        d += fabs((double)av[idx][c] - (double)bv[idx][c]);
+      }
+      maxVal = std::max(maxVal, d);
+    }
+  }
+  else {
+    errMsg("pdataMaxDiff: Grid Type is not supported (only Real, Vec3, int)");
+  }
+
+  return maxVal;
+}
+static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "pdataMaxDiff", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const ParticleDataBase *a = _args.getPtr<ParticleDataBase>("a", 0, &_lock);
+      const ParticleDataBase *b = _args.getPtr<ParticleDataBase>("b", 1, &_lock);
+      _retval = toPy(pdataMaxDiff(a, b));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "pdataMaxDiff", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("pdataMaxDiff", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_pdataMaxDiff("", "pdataMaxDiff", _W_14);
+extern "C" {
+void PbRegister_pdataMaxDiff()
+{
+  KEEP_UNUSED(_RP_pdataMaxDiff);
+}
+}
+
+//! calculate center of mass given density grid, for re-centering
+
+Vec3 calcCenterOfMass(const Grid<Real> &density)
+{
+  Vec3 p(0.0f);
+  Real w = 0.0f;
+  FOR_IJK(density)
+  {
+    p += density(i, j, k) * Vec3(i + 0.5f, j + 0.5f, k + 0.5f);
+    w += density(i, j, k);
+  }
+  if (w > 1e-6f)
+    p /= w;
+  return p;
+}
+static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "calcCenterOfMass", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 0, &_lock);
+      _retval = toPy(calcCenterOfMass(density));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "calcCenterOfMass", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("calcCenterOfMass", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_calcCenterOfMass("", "calcCenterOfMass", _W_15);
+extern "C" {
+void PbRegister_calcCenterOfMass()
+{
+  KEEP_UNUSED(_RP_calcCenterOfMass);
+}
+}
+
+//*****************************************************************************
+// helper functions for volume fractions (which are needed for second order obstacle boundaries)
+
+inline static Real calcFraction(Real phi1, Real phi2, Real fracThreshold)
+{
+  if (phi1 > 0. && phi2 > 0.)
+    return 1.;
+  if (phi1 < 0. && phi2 < 0.)
+    return 0.;
+
+  // make sure phi1 < phi2
+  if (phi2 < phi1) {
+    Real t = phi1;
+    phi1 = phi2;
+    phi2 = t;
+  }
+  Real denom = phi1 - phi2;
+  if (denom > -1e-04)
+    return 0.5;
+
+  Real frac = 1. - phi1 / denom;
+  if (frac < fracThreshold)
+    frac = 0.;  // stomp small values , dont mark as fluid
+  return std::min(Real(1), frac);
+}
+
+struct KnUpdateFractions : public KernelBase {
+  KnUpdateFractions(const FlagGrid &flags,
+                    const Grid<Real> &phiObs,
+                    MACGrid &fractions,
+                    const int &boundaryWidth,
+                    const Real fracThreshold)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        phiObs(phiObs),
+        fractions(fractions),
+        boundaryWidth(boundaryWidth),
+        fracThreshold(fracThreshold)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const Grid<Real> &phiObs,
+                 MACGrid &fractions,
+                 const int &boundaryWidth,
+                 const Real fracThreshold) const
+  {
+
+    // walls at domain bounds and inner objects
+    fractions(i, j, k).x = calcFraction(phiObs(i, j, k), phiObs(i - 1, j, k), fracThreshold);
+    fractions(i, j, k).y = calcFraction(phiObs(i, j, k), phiObs(i, j - 1, k), fracThreshold);
+    if (phiObs.is3D()) {
+      fractions(i, j, k).z = calcFraction(phiObs(i, j, k), phiObs(i, j, k - 1), fracThreshold);
+    }
+
+    // remaining BCs at the domain boundaries
+    const int w = boundaryWidth;
+    // only set if not in obstacle
+    if (phiObs(i, j, k) < 0.)
+      return;
+
+    // x-direction boundaries
+    if (i <= w + 1) {  // min x
+      if ((flags.isInflow(i - 1, j, k)) || (flags.isOutflow(i - 1, j, k)) ||
+          (flags.isOpen(i - 1, j, k))) {
+        fractions(i, j, k).x = fractions(i, j, k).y = 1.;
+        if (flags.is3D())
+          fractions(i, j, k).z = 1.;
+      }
+    }
+    if (i >= flags.getSizeX() - w - 2) {  // max x
+      if ((flags.isInflow(i + 1, j, k)) || (flags.isOutflow(i + 1, j, k)) ||
+          (flags.isOpen(i + 1, j, k))) {
+        fractions(i + 1, j, k).x = fractions(i + 1, j, k).y = 1.;
+        if (flags.is3D())
+          fractions(i + 1, j, k).z = 1.;
+      }
+    }
+    // y-direction boundaries
+    if (j <= w + 1) {  // min y
+      if ((flags.isInflow(i, j - 1, k)) || (flags.isOutflow(i, j - 1, k)) ||
+          (flags.isOpen(i, j - 1, k))) {
+        fractions(i, j, k).x = fractions(i, j, k).y = 1.;
+        if (flags.is3D())
+          fractions(i, j, k).z = 1.;
+      }
+    }
+    if (j >= flags.getSizeY() - w - 2) {  // max y
+      if ((flags.isInflow(i, j + 1, k)) || (flags.isOutflow(i, j + 1, k)) ||
+          (flags.isOpen(i, j + 1, k))) {
+        fractions(i, j + 1, k).x = fractions(i, j + 1, k).y = 1.;
+        if (flags.is3D())
+          fractions(i, j + 1, k).z = 1.;
+      }
+    }
+    // z-direction boundaries
+    if (flags.is3D()) {
+      if (k <= w + 1) {  // min z
+        if ((flags.isInflow(i, j, k - 1)) || (flags.isOutflow(i, j, k - 1)) ||
+            (flags.isOpen(i, j, k - 1))) {
+          fractions(i, j, k).x = fractions(i, j, k).y = 1.;
+          if (flags.is3D())
+            fractions(i, j, k).z = 1.;
+        }
+      }
+      if (j >= flags.getSizeZ() - w - 2) {  // max z
+        if ((flags.isInflow(i, j, k + 1)) || (flags.isOutflow(i, j, k + 1)) ||
+            (flags.isOpen(i, j, k + 1))) {
+          fractions(i, j, k + 1).x = fractions(i, j, k + 1).y = 1.;
+          if (flags.is3D())
+            fractions(i, j, k + 1).z = 1.;
+        }
+      }
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type1;
+  inline MACGrid &getArg2()
+  {
+    return fractions;
+  }
+  typedef MACGrid type2;
+  inline const int &getArg3()
+  {
+    return boundaryWidth;
+  }
+  typedef int type3;
+  inline const Real &getArg4()
+  {
+    return fracThreshold;
+  }
+  typedef Real type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnUpdateFractions ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, phiObs, fractions, boundaryWidth, fracThreshold);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, phiObs, fractions, boundaryWidth, fracThreshold);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const Grid<Real> &phiObs;
+  MACGrid &fractions;
+  const int &boundaryWidth;
+  const Real fracThreshold;
+};
+
+//! update fill fraction values
+void updateFractions(const FlagGrid &flags,
+                     const Grid<Real> &phiObs,
+                     MACGrid &fractions,
+                     const int &boundaryWidth = 0,
+                     const Real fracThreshold = 0.01)
+{
+  fractions.setConst(Vec3(0.));
+  KnUpdateFractions(flags, phiObs, fractions, boundaryWidth, fracThreshold);
+}
+static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "updateFractions", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 1, &_lock);
+      MACGrid &fractions = *_args.getPtr<MACGrid>("fractions", 2, &_lock);
+      const int &boundaryWidth = _args.getOpt<int>("boundaryWidth", 3, 0, &_lock);
+      const Real fracThreshold = _args.getOpt<Real>("fracThreshold", 4, 0.01, &_lock);
+      _retval = getPyNone();
+      updateFractions(flags, phiObs, fractions, boundaryWidth, fracThreshold);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "updateFractions", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("updateFractions", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_updateFractions("", "updateFractions", _W_16);
+extern "C" {
+void PbRegister_updateFractions()
+{
+  KEEP_UNUSED(_RP_updateFractions);
+}
+}
+
+struct KnUpdateFlagsObs : public KernelBase {
+  KnUpdateFlagsObs(FlagGrid &flags,
+                   const MACGrid *fractions,
+                   const Grid<Real> &phiObs,
+                   const Grid<Real> *phiOut,
+                   const Grid<Real> *phiIn)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        fractions(fractions),
+        phiObs(phiObs),
+        phiOut(phiOut),
+        phiIn(phiIn)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 FlagGrid &flags,
+                 const MACGrid *fractions,
+                 const Grid<Real> &phiObs,
+                 const Grid<Real> *phiOut,
+                 const Grid<Real> *phiIn) const
+  {
+
+    bool isObs = false;
+    if (fractions) {
+      Real f = 0.;
+      f += fractions->get(i, j, k).x;
+      f += fractions->get(i + 1, j, k).x;
+      f += fractions->get(i, j, k).y;
+      f += fractions->get(i, j + 1, k).y;
+      if (flags.is3D()) {
+        f += fractions->get(i, j, k).z;
+        f += fractions->get(i, j, k + 1).z;
+      }
+      if (f == 0.)
+        isObs = true;
+    }
+    else {
+      if (phiObs(i, j, k) < 0.)
+        isObs = true;
+    }
+
+    bool isOutflow = false;
+    bool isInflow = false;
+    if (phiOut && (*phiOut)(i, j, k) < 0.)
+      isOutflow = true;
+    if (phiIn && (*phiIn)(i, j, k) < 0.)
+      isInflow = true;
+
+    if (isObs)
+      flags(i, j, k) = FlagGrid::TypeObstacle;
+    else if (isInflow)
+      flags(i, j, k) = (FlagGrid::TypeFluid | FlagGrid::TypeInflow);
+    else if (isOutflow)
+      flags(i, j, k) = (FlagGrid::TypeEmpty | FlagGrid::TypeOutflow);
+    else
+      flags(i, j, k) = FlagGrid::TypeEmpty;
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid *getArg1()
+  {
+    return fractions;
+  }
+  typedef MACGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type2;
+  inline const Grid<Real> *getArg3()
+  {
+    return phiOut;
+  }
+  typedef Grid<Real> type3;
+  inline const Grid<Real> *getArg4()
+  {
+    return phiIn;
+  }
+  typedef Grid<Real> type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnUpdateFlagsObs ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, fractions, phiObs, phiOut, phiIn);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, fractions, phiObs, phiOut, phiIn);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  FlagGrid &flags;
+  const MACGrid *fractions;
+  const Grid<Real> &phiObs;
+  const Grid<Real> *phiOut;
+  const Grid<Real> *phiIn;
+};
+
+//! update obstacle and outflow flags from levelsets
+//! optionally uses fill fractions for obstacle
+void setObstacleFlags(FlagGrid &flags,
+                      const Grid<Real> &phiObs,
+                      const MACGrid *fractions = NULL,
+                      const Grid<Real> *phiOut = NULL,
+                      const Grid<Real> *phiIn = NULL)
+{
+  KnUpdateFlagsObs(flags, fractions, phiObs, phiOut, phiIn);
+}
+static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setObstacleFlags", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 1, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 2, NULL, &_lock);
+      const Grid<Real> *phiOut = _args.getPtrOpt<Grid<Real>>("phiOut", 3, NULL, &_lock);
+      const Grid<Real> *phiIn = _args.getPtrOpt<Grid<Real>>("phiIn", 4, NULL, &_lock);
+      _retval = getPyNone();
+      setObstacleFlags(flags, phiObs, fractions, phiOut, phiIn);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setObstacleFlags", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setObstacleFlags", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setObstacleFlags("", "setObstacleFlags", _W_17);
+extern "C" {
+void PbRegister_setObstacleFlags()
+{
+  KEEP_UNUSED(_RP_setObstacleFlags);
+}
+}
+
+//! small helper for test case test_1040_secOrderBnd.py
+struct kninitVortexVelocity : public KernelBase {
+  kninitVortexVelocity(const Grid<Real> &phiObs,
+                       MACGrid &vel,
+                       const Vec3 &center,
+                       const Real &radius)
+      : KernelBase(&phiObs, 0), phiObs(phiObs), vel(vel), center(center), radius(radius)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const Grid<Real> &phiObs,
+                 MACGrid &vel,
+                 const Vec3 &center,
+                 const Real &radius) const
+  {
+
+    if (phiObs(i, j, k) >= -1.) {
+
+      Real dx = i - center.x;
+      if (dx >= 0)
+        dx -= .5;
+      else
+        dx += .5;
+      Real dy = j - center.y;
+      Real r = std::sqrt(dx * dx + dy * dy);
+      Real alpha = atan2(dy, dx);
+
+      vel(i, j, k).x = -std::sin(alpha) * (r / radius);
+
+      dx = i - center.x;
+      dy = j - center.y;
+      if (dy >= 0)
+        dy -= .5;
+      else
+        dy += .5;
+      r = std::sqrt(dx * dx + dy * dy);
+      alpha = atan2(dy, dx);
+
+      vel(i, j, k).y = std::cos(alpha) * (r / radius);
+    }
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const Vec3 &getArg2()
+  {
+    return center;
+  }
+  typedef Vec3 type2;
+  inline const Real &getArg3()
+  {
+    return radius;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel kninitVortexVelocity ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, phiObs, vel, center, radius);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, phiObs, vel, center, radius);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const Grid<Real> &phiObs;
+  MACGrid &vel;
+  const Vec3 &center;
+  const Real &radius;
+};
+
+void initVortexVelocity(const Grid<Real> &phiObs,
+                        MACGrid &vel,
+                        const Vec3 &center,
+                        const Real &radius)
+{
+  kninitVortexVelocity(phiObs, vel, center, radius);
+}
+static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "initVortexVelocity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const Vec3 &center = _args.get<Vec3>("center", 2, &_lock);
+      const Real &radius = _args.get<Real>("radius", 3, &_lock);
+      _retval = getPyNone();
+      initVortexVelocity(phiObs, vel, center, radius);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "initVortexVelocity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("initVortexVelocity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_initVortexVelocity("", "initVortexVelocity", _W_18);
+extern "C" {
+void PbRegister_initVortexVelocity()
+{
+  KEEP_UNUSED(_RP_initVortexVelocity);
+}
+}
+
+//*****************************************************************************
+// helper functions for blurring
+
+//! class for Gaussian Blur
+struct GaussianKernelCreator {
+ public:
+  float mSigma;
+  int mDim;
+  float *mMat1D;
+
+  GaussianKernelCreator() : mSigma(0.0f), mDim(0), mMat1D(NULL)
+  {
+  }
+  GaussianKernelCreator(float sigma, int dim = 0) : mSigma(0.0f), mDim(0), mMat1D(NULL)
+  {
+    setGaussianSigma(sigma, dim);
+  }
+
+  Real getWeiAtDis(float disx, float disy)
+  {
+    float m = 1.0 / (sqrt(2.0 * M_PI) * mSigma);
+    float v = m * exp(-(1.0 * disx * disx + 1.0 * disy * disy) / (2.0 * mSigma * mSigma));
+    return v;
+  }
+
+  Real getWeiAtDis(float disx, float disy, float disz)
+  {
+    float m = 1.0 / (sqrt(2.0 * M_PI) * mSigma);
+    float v = m * exp(-(1.0 * disx * disx + 1.0 * disy * disy + 1.0 * disz * disz) /
+                      (2.0 * mSigma * mSigma));
+    return v;
+  }
+
+  void setGaussianSigma(float sigma, int dim = 0)
+  {
+    mSigma = sigma;
+    if (dim < 3)
+      mDim = (int)(2.0 * 3.0 * sigma + 1.0f);
+    else
+      mDim = dim;
+    if (mDim < 3)
+      mDim = 3;
+
+    if (mDim % 2 == 0)
+      ++mDim;  // make dim odd
+
+    float s2 = mSigma * mSigma;
+    int c = mDim / 2;
+    float m = 1.0 / (sqrt(2.0 * M_PI) * mSigma);
+
+    // create 1D matrix
+    if (mMat1D)
+      delete[] mMat1D;
+    mMat1D = new float[mDim];
+    for (int i = 0; i < (mDim + 1) / 2; i++) {
+      float v = m * exp(-(1.0 * i * i) / (2.0 * s2));
+      mMat1D[c + i] = v;
+      mMat1D[c - i] = v;
+    }
+  }
+
+  ~GaussianKernelCreator()
+  {
+    if (mMat1D)
+      delete[] mMat1D;
+  }
+
+  float get1DKernelValue(int off)
+  {
+    assertMsg(off >= 0 && off < mDim, "off exceeded boundary in Gaussian Kernel 1D!");
+    return mMat1D[off];
+  }
+};
+
+template<class T>
+T convolveGrid(Grid<T> &originGrid, GaussianKernelCreator &gkSigma, Vec3 pos, int cdir)
+{
+  // pos should be the centre pos, e.g., 1.5, 4.5, 0.5 for grid pos 1,4,0
+  Vec3 step(1.0, 0.0, 0.0);
+  if (cdir == 1)  // todo, z
+    step = Vec3(0.0, 1.0, 0.0);
+  else if (cdir == 2)
+    step = Vec3(0.0, 0.0, 1.0);
+  T pxResult(0);
+  for (int i = 0; i < gkSigma.mDim; ++i) {
+    Vec3i curpos = toVec3i(pos - step * (i - gkSigma.mDim / 2));
+    if (originGrid.isInBounds(curpos))
+      pxResult += gkSigma.get1DKernelValue(i) * originGrid.get(curpos);
+    else {  // TODO , improve...
+      Vec3i curfitpos = curpos;
+      if (curfitpos.x < 0)
+        curfitpos.x = 0;
+      else if (curfitpos.x >= originGrid.getSizeX())
+        curfitpos.x = originGrid.getSizeX() - 1;
+      if (curfitpos.y < 0)
+        curfitpos.y = 0;
+      else if (curfitpos.y >= originGrid.getSizeY())
+        curfitpos.y = originGrid.getSizeY() - 1;
+      if (curfitpos.z < 0)
+        curfitpos.z = 0;
+      else if (curfitpos.z >= originGrid.getSizeZ())
+        curfitpos.z = originGrid.getSizeZ() - 1;
+      pxResult += gkSigma.get1DKernelValue(i) * originGrid.get(curfitpos);
+    }
+  }
+  return pxResult;
+}
+
+template<class T> struct knBlurGrid : public KernelBase {
+  knBlurGrid(Grid<T> &originGrid, Grid<T> &targetGrid, GaussianKernelCreator &gkSigma, int cdir)
+      : KernelBase(&originGrid, 0),
+        originGrid(originGrid),
+        targetGrid(targetGrid),
+        gkSigma(gkSigma),
+        cdir(cdir)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<T> &originGrid,
+                 Grid<T> &targetGrid,
+                 GaussianKernelCreator &gkSigma,
+                 int cdir) const
+  {
+    targetGrid(i, j, k) = convolveGrid<T>(originGrid, gkSigma, Vec3(i, j, k), cdir);
+  }
+  inline Grid<T> &getArg0()
+  {
+    return originGrid;
+  }
+  typedef Grid<T> type0;
+  inline Grid<T> &getArg1()
+  {
+    return targetGrid;
+  }
+  typedef Grid<T> type1;
+  inline GaussianKernelCreator &getArg2()
+  {
+    return gkSigma;
+  }
+  typedef GaussianKernelCreator type2;
+  inline int &getArg3()
+  {
+    return cdir;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knBlurGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, originGrid, targetGrid, gkSigma, cdir);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, originGrid, targetGrid, gkSigma, cdir);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> &originGrid;
+  Grid<T> &targetGrid;
+  GaussianKernelCreator &gkSigma;
+  int cdir;
+};
+
+template<class T> int blurGrid(Grid<T> &originGrid, Grid<T> &targetGrid, float sigma)
+{
+  GaussianKernelCreator tmGK(sigma);
+  Grid<T> tmpGrid(originGrid);
+  knBlurGrid<T>(originGrid, tmpGrid, tmGK, 0);  // blur x
+  knBlurGrid<T>(tmpGrid, targetGrid, tmGK, 1);  // blur y
+  if (targetGrid.is3D()) {
+    tmpGrid.copyFrom(targetGrid);
+    knBlurGrid<T>(tmpGrid, targetGrid, tmGK, 2);
+  }
+  return tmGK.mDim;
+}
+
+struct KnBlurMACGridGauss : public KernelBase {
+  KnBlurMACGridGauss(MACGrid &originGrid,
+                     MACGrid &target,
+                     GaussianKernelCreator &gkSigma,
+                     int cdir)
+      : KernelBase(&originGrid, 0),
+        originGrid(originGrid),
+        target(target),
+        gkSigma(gkSigma),
+        cdir(cdir)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &originGrid,
+                 MACGrid &target,
+                 GaussianKernelCreator &gkSigma,
+                 int cdir) const
+  {
+    Vec3 pos(i, j, k);
+    Vec3 step(1.0, 0.0, 0.0);
+    if (cdir == 1)
+      step = Vec3(0.0, 1.0, 0.0);
+    else if (cdir == 2)
+      step = Vec3(0.0, 0.0, 1.0);
+
+    Vec3 pxResult(0.0f);
+    for (int di = 0; di < gkSigma.mDim; ++di) {
+      Vec3i curpos = toVec3i(pos - step * (di - gkSigma.mDim / 2));
+      if (!originGrid.isInBounds(curpos)) {
+        if (curpos.x < 0)
+          curpos.x = 0;
+        else if (curpos.x >= originGrid.getSizeX())
+          curpos.x = originGrid.getSizeX() - 1;
+        if (curpos.y < 0)
+          curpos.y = 0;
+        else if (curpos.y >= originGrid.getSizeY())
+          curpos.y = originGrid.getSizeY() - 1;
+        if (curpos.z < 0)
+          curpos.z = 0;
+        else if (curpos.z >= originGrid.getSizeZ())
+          curpos.z = originGrid.getSizeZ() - 1;
+      }
+      pxResult += gkSigma.get1DKernelValue(di) * originGrid.get(curpos);
+    }
+    target(i, j, k) = pxResult;
+  }
+  inline MACGrid &getArg0()
+  {
+    return originGrid;
+  }
+  typedef MACGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return target;
+  }
+  typedef MACGrid type1;
+  inline GaussianKernelCreator &getArg2()
+  {
+    return gkSigma;
+  }
+  typedef GaussianKernelCreator type2;
+  inline int &getArg3()
+  {
+    return cdir;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnBlurMACGridGauss ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, originGrid, target, gkSigma, cdir);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, originGrid, target, gkSigma, cdir);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  MACGrid &originGrid;
+  MACGrid &target;
+  GaussianKernelCreator &gkSigma;
+  int cdir;
+};
+
+int blurMacGrid(MACGrid &oG, MACGrid &tG, float si)
+{
+  GaussianKernelCreator tmGK(si);
+  MACGrid tmpGrid(oG);
+  KnBlurMACGridGauss(oG, tmpGrid, tmGK, 0);  // blur x
+  KnBlurMACGridGauss(tmpGrid, tG, tmGK, 1);  // blur y
+  if (tG.is3D()) {
+    tmpGrid.copyFrom(tG);
+    KnBlurMACGridGauss(tmpGrid, tG, tmGK, 2);
+  }
+  return tmGK.mDim;
+}
+static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "blurMacGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &oG = *_args.getPtr<MACGrid>("oG", 0, &_lock);
+      MACGrid &tG = *_args.getPtr<MACGrid>("tG", 1, &_lock);
+      float si = _args.get<float>("si", 2, &_lock);
+      _retval = toPy(blurMacGrid(oG, tG, si));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "blurMacGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("blurMacGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_blurMacGrid("", "blurMacGrid", _W_19);
+extern "C" {
+void PbRegister_blurMacGrid()
+{
+  KEEP_UNUSED(_RP_blurMacGrid);
+}
+}
+
+int blurRealGrid(Grid<Real> &oG, Grid<Real> &tG, float si)
+{
+  return blurGrid<Real>(oG, tG, si);
+}
+static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "blurRealGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &oG = *_args.getPtr<Grid<Real>>("oG", 0, &_lock);
+      Grid<Real> &tG = *_args.getPtr<Grid<Real>>("tG", 1, &_lock);
+      float si = _args.get<float>("si", 2, &_lock);
+      _retval = toPy(blurRealGrid(oG, tG, si));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "blurRealGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("blurRealGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_blurRealGrid("", "blurRealGrid", _W_20);
+extern "C" {
+void PbRegister_blurRealGrid()
+{
+  KEEP_UNUSED(_RP_blurRealGrid);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/kepsilon.cpp b/extern/mantaflow/preprocessed/plugin/kepsilon.cpp
new file mode 100644
index 00000000000..306db9e20cc
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/kepsilon.cpp
@@ -0,0 +1,578 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Turbulence modeling plugins
+ *
+ ******************************************************************************/
+
+#include "grid.h"
+#include "commonkernels.h"
+#include "vortexsheet.h"
+#include "conjugategrad.h"
+
+using namespace std;
+
+namespace Manta {
+
+// k-epsilon model constants
+const Real keCmu = 0.09;
+const Real keC1 = 1.44;
+const Real keC2 = 1.92;
+const Real keS1 = 1.0;
+const Real keS2 = 1.3;
+
+// k-epsilon limiters
+const Real keU0 = 1.0;
+const Real keImin = 2e-3;
+const Real keImax = 1.0;
+const Real keNuMin = 1e-3;
+const Real keNuMax = 5.0;
+
+//! clamp k and epsilon to limits
+
+struct KnTurbulenceClamp : public KernelBase {
+  KnTurbulenceClamp(
+      Grid<Real> &kgrid, Grid<Real> &egrid, Real minK, Real maxK, Real minNu, Real maxNu)
+      : KernelBase(&kgrid, 0),
+        kgrid(kgrid),
+        egrid(egrid),
+        minK(minK),
+        maxK(maxK),
+        minNu(minNu),
+        maxNu(maxNu)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 Grid<Real> &kgrid,
+                 Grid<Real> &egrid,
+                 Real minK,
+                 Real maxK,
+                 Real minNu,
+                 Real maxNu) const
+  {
+    Real eps = egrid[idx];
+    Real ke = clamp(kgrid[idx], minK, maxK);
+    Real nu = keCmu * square(ke) / eps;
+    if (nu > maxNu)
+      eps = keCmu * square(ke) / maxNu;
+    if (nu < minNu)
+      eps = keCmu * square(ke) / minNu;
+
+    kgrid[idx] = ke;
+    egrid[idx] = eps;
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return kgrid;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return egrid;
+  }
+  typedef Grid<Real> type1;
+  inline Real &getArg2()
+  {
+    return minK;
+  }
+  typedef Real type2;
+  inline Real &getArg3()
+  {
+    return maxK;
+  }
+  typedef Real type3;
+  inline Real &getArg4()
+  {
+    return minNu;
+  }
+  typedef Real type4;
+  inline Real &getArg5()
+  {
+    return maxNu;
+  }
+  typedef Real type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnTurbulenceClamp ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, kgrid, egrid, minK, maxK, minNu, maxNu);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &kgrid;
+  Grid<Real> &egrid;
+  Real minK;
+  Real maxK;
+  Real minNu;
+  Real maxNu;
+};
+
+//! Compute k-epsilon production term P = 2*nu_T*sum_ij(Sij^2) and the turbulent viscosity
+//! nu_T=C_mu*k^2/eps
+
+struct KnComputeProduction : public KernelBase {
+  KnComputeProduction(const MACGrid &vel,
+                      const Grid<Vec3> &velCenter,
+                      const Grid<Real> &ke,
+                      const Grid<Real> &eps,
+                      Grid<Real> &prod,
+                      Grid<Real> &nuT,
+                      Grid<Real> *strain,
+                      Real pscale = 1.0f)
+      : KernelBase(&vel, 1),
+        vel(vel),
+        velCenter(velCenter),
+        ke(ke),
+        eps(eps),
+        prod(prod),
+        nuT(nuT),
+        strain(strain),
+        pscale(pscale)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const MACGrid &vel,
+                 const Grid<Vec3> &velCenter,
+                 const Grid<Real> &ke,
+                 const Grid<Real> &eps,
+                 Grid<Real> &prod,
+                 Grid<Real> &nuT,
+                 Grid<Real> *strain,
+                 Real pscale = 1.0f) const
+  {
+    Real curEps = eps(i, j, k);
+    if (curEps > 0) {
+      // turbulent viscosity: nu_T = C_mu * k^2/eps
+      Real curNu = keCmu * square(ke(i, j, k)) / curEps;
+
+      // compute Sij = 1/2 * (dU_i/dx_j + dU_j/dx_i)
+      Vec3 diag = Vec3(vel(i + 1, j, k).x, vel(i, j + 1, k).y, vel(i, j, k + 1).z) - vel(i, j, k);
+      Vec3 ux = 0.5 * (velCenter(i + 1, j, k) - velCenter(i - 1, j, k));
+      Vec3 uy = 0.5 * (velCenter(i, j + 1, k) - velCenter(i, j - 1, k));
+      Vec3 uz = 0.5 * (velCenter(i, j, k + 1) - velCenter(i, j, k - 1));
+      Real S12 = 0.5 * (ux.y + uy.x);
+      Real S13 = 0.5 * (ux.z + uz.x);
+      Real S23 = 0.5 * (uy.z + uz.y);
+      Real S2 = square(diag.x) + square(diag.y) + square(diag.z) + 2.0 * square(S12) +
+                2.0 * square(S13) + 2.0 * square(S23);
+
+      // P = 2*nu_T*sum_ij(Sij^2)
+      prod(i, j, k) = 2.0 * curNu * S2 * pscale;
+      nuT(i, j, k) = curNu;
+      if (strain)
+        (*strain)(i, j, k) = sqrt(S2);
+    }
+    else {
+      prod(i, j, k) = 0;
+      nuT(i, j, k) = 0;
+      if (strain)
+        (*strain)(i, j, k) = 0;
+    }
+  }
+  inline const MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline const Grid<Vec3> &getArg1()
+  {
+    return velCenter;
+  }
+  typedef Grid<Vec3> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return ke;
+  }
+  typedef Grid<Real> type2;
+  inline const Grid<Real> &getArg3()
+  {
+    return eps;
+  }
+  typedef Grid<Real> type3;
+  inline Grid<Real> &getArg4()
+  {
+    return prod;
+  }
+  typedef Grid<Real> type4;
+  inline Grid<Real> &getArg5()
+  {
+    return nuT;
+  }
+  typedef Grid<Real> type5;
+  inline Grid<Real> *getArg6()
+  {
+    return strain;
+  }
+  typedef Grid<Real> type6;
+  inline Real &getArg7()
+  {
+    return pscale;
+  }
+  typedef Real type7;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnComputeProduction ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, velCenter, ke, eps, prod, nuT, strain, pscale);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, velCenter, ke, eps, prod, nuT, strain, pscale);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const MACGrid &vel;
+  const Grid<Vec3> &velCenter;
+  const Grid<Real> &ke;
+  const Grid<Real> &eps;
+  Grid<Real> &prod;
+  Grid<Real> &nuT;
+  Grid<Real> *strain;
+  Real pscale;
+};
+
+//! Compute k-epsilon production term P = 2*nu_T*sum_ij(Sij^2) and the turbulent viscosity
+//! nu_T=C_mu*k^2/eps
+
+void KEpsilonComputeProduction(const MACGrid &vel,
+                               Grid<Real> &k,
+                               Grid<Real> &eps,
+                               Grid<Real> &prod,
+                               Grid<Real> &nuT,
+                               Grid<Real> *strain = 0,
+                               Real pscale = 1.0f)
+{
+  // get centered velocity grid
+  Grid<Vec3> vcenter(k.getParent());
+  GetCentered(vcenter, vel);
+  FillInBoundary(vcenter, 1);
+
+  // compute limits
+  const Real minK = 1.5 * square(keU0) * square(keImin);
+  const Real maxK = 1.5 * square(keU0) * square(keImax);
+  KnTurbulenceClamp(k, eps, minK, maxK, keNuMin, keNuMax);
+
+  KnComputeProduction(vel, vcenter, k, eps, prod, nuT, strain, pscale);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "KEpsilonComputeProduction", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 1, &_lock);
+      Grid<Real> &eps = *_args.getPtr<Grid<Real>>("eps", 2, &_lock);
+      Grid<Real> &prod = *_args.getPtr<Grid<Real>>("prod", 3, &_lock);
+      Grid<Real> &nuT = *_args.getPtr<Grid<Real>>("nuT", 4, &_lock);
+      Grid<Real> *strain = _args.getPtrOpt<Grid<Real>>("strain", 5, 0, &_lock);
+      Real pscale = _args.getOpt<Real>("pscale", 6, 1.0f, &_lock);
+      _retval = getPyNone();
+      KEpsilonComputeProduction(vel, k, eps, prod, nuT, strain, pscale);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "KEpsilonComputeProduction", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("KEpsilonComputeProduction", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_KEpsilonComputeProduction("", "KEpsilonComputeProduction", _W_0);
+extern "C" {
+void PbRegister_KEpsilonComputeProduction()
+{
+  KEEP_UNUSED(_RP_KEpsilonComputeProduction);
+}
+}
+
+//! Integrate source terms of k-epsilon equation
+
+struct KnAddTurbulenceSource : public KernelBase {
+  KnAddTurbulenceSource(Grid<Real> &kgrid, Grid<Real> &egrid, const Grid<Real> &pgrid, Real dt)
+      : KernelBase(&kgrid, 0), kgrid(kgrid), egrid(egrid), pgrid(pgrid), dt(dt)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      IndexInt idx, Grid<Real> &kgrid, Grid<Real> &egrid, const Grid<Real> &pgrid, Real dt) const
+  {
+    Real eps = egrid[idx], prod = pgrid[idx], ke = kgrid[idx];
+    if (ke <= 0)
+      ke = 1e-3;  // pre-clamp to avoid nan
+
+    Real newK = ke + dt * (prod - eps);
+    Real newEps = eps + dt * (prod * keC1 - eps * keC2) * (eps / ke);
+    if (newEps <= 0)
+      newEps = 1e-4;  // pre-clamp to avoid nan
+
+    kgrid[idx] = newK;
+    egrid[idx] = newEps;
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return kgrid;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return egrid;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return pgrid;
+  }
+  typedef Grid<Real> type2;
+  inline Real &getArg3()
+  {
+    return dt;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAddTurbulenceSource ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, kgrid, egrid, pgrid, dt);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Real> &kgrid;
+  Grid<Real> &egrid;
+  const Grid<Real> &pgrid;
+  Real dt;
+};
+
+//! Integrate source terms of k-epsilon equation
+void KEpsilonSources(Grid<Real> &k, Grid<Real> &eps, Grid<Real> &prod)
+{
+  Real dt = k.getParent()->getDt();
+
+  KnAddTurbulenceSource(k, eps, prod, dt);
+
+  // compute limits
+  const Real minK = 1.5 * square(keU0) * square(keImin);
+  const Real maxK = 1.5 * square(keU0) * square(keImax);
+  KnTurbulenceClamp(k, eps, minK, maxK, keNuMin, keNuMax);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "KEpsilonSources", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 0, &_lock);
+      Grid<Real> &eps = *_args.getPtr<Grid<Real>>("eps", 1, &_lock);
+      Grid<Real> &prod = *_args.getPtr<Grid<Real>>("prod", 2, &_lock);
+      _retval = getPyNone();
+      KEpsilonSources(k, eps, prod);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "KEpsilonSources", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("KEpsilonSources", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_KEpsilonSources("", "KEpsilonSources", _W_1);
+extern "C" {
+void PbRegister_KEpsilonSources()
+{
+  KEEP_UNUSED(_RP_KEpsilonSources);
+}
+}
+
+//! Initialize the domain or boundary conditions
+void KEpsilonBcs(
+    const FlagGrid &flags, Grid<Real> &k, Grid<Real> &eps, Real intensity, Real nu, bool fillArea)
+{
+  // compute limits
+  const Real vk = 1.5 * square(keU0) * square(intensity);
+  const Real ve = keCmu * square(vk) / nu;
+
+  FOR_IDX(k)
+  {
+    if (fillArea || flags.isObstacle(idx)) {
+      k[idx] = vk;
+      eps[idx] = ve;
+    }
+  }
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "KEpsilonBcs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 1, &_lock);
+      Grid<Real> &eps = *_args.getPtr<Grid<Real>>("eps", 2, &_lock);
+      Real intensity = _args.get<Real>("intensity", 3, &_lock);
+      Real nu = _args.get<Real>("nu", 4, &_lock);
+      bool fillArea = _args.get<bool>("fillArea", 5, &_lock);
+      _retval = getPyNone();
+      KEpsilonBcs(flags, k, eps, intensity, nu, fillArea);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "KEpsilonBcs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("KEpsilonBcs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_KEpsilonBcs("", "KEpsilonBcs", _W_2);
+extern "C" {
+void PbRegister_KEpsilonBcs()
+{
+  KEEP_UNUSED(_RP_KEpsilonBcs);
+}
+}
+
+//! Gradient diffusion smoothing. Not unconditionally stable -- should probably do substepping etc.
+void ApplyGradDiff(
+    const Grid<Real> &grid, Grid<Real> &res, const Grid<Real> &nu, Real dt, Real sigma)
+{
+  // should do this (but requires better boundary handling)
+  /*MACGrid grad(grid.getParent());
+  GradientOpMAC(grad, grid);
+  grad *= nu;
+  DivergenceOpMAC(res, grad);
+  res *= dt/sigma;  */
+
+  LaplaceOp(res, grid);
+  res *= nu;
+  res *= dt / sigma;
+}
+
+//! Compute k-epsilon turbulent viscosity
+void KEpsilonGradientDiffusion(
+    Grid<Real> &k, Grid<Real> &eps, Grid<Real> &nuT, Real sigmaU = 4.0, MACGrid *vel = 0)
+{
+  Real dt = k.getParent()->getDt();
+  Grid<Real> res(k.getParent());
+
+  // gradient diffusion of k
+  ApplyGradDiff(k, res, nuT, dt, keS1);
+  k += res;
+
+  // gradient diffusion of epsilon
+  ApplyGradDiff(eps, res, nuT, dt, keS2);
+  eps += res;
+
+  // gradient diffusion of velocity
+  if (vel) {
+    Grid<Real> vc(k.getParent());
+    for (int c = 0; c < 3; c++) {
+      GetComponent(*vel, vc, c);
+      ApplyGradDiff(vc, res, nuT, dt, sigmaU);
+      vc += res;
+      SetComponent(*vel, vc, c);
+    }
+  }
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "KEpsilonGradientDiffusion", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 0, &_lock);
+      Grid<Real> &eps = *_args.getPtr<Grid<Real>>("eps", 1, &_lock);
+      Grid<Real> &nuT = *_args.getPtr<Grid<Real>>("nuT", 2, &_lock);
+      Real sigmaU = _args.getOpt<Real>("sigmaU", 3, 4.0, &_lock);
+      MACGrid *vel = _args.getPtrOpt<MACGrid>("vel", 4, 0, &_lock);
+      _retval = getPyNone();
+      KEpsilonGradientDiffusion(k, eps, nuT, sigmaU, vel);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "KEpsilonGradientDiffusion", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("KEpsilonGradientDiffusion", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_KEpsilonGradientDiffusion("", "KEpsilonGradientDiffusion", _W_3);
+extern "C" {
+void PbRegister_KEpsilonGradientDiffusion()
+{
+  KEEP_UNUSED(_RP_KEpsilonGradientDiffusion);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/meshplugins.cpp b/extern/mantaflow/preprocessed/plugin/meshplugins.cpp
new file mode 100644
index 00000000000..415bca153d0
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/meshplugins.cpp
@@ -0,0 +1,780 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Smoothing etc. for meshes
+ *
+ ******************************************************************************/
+
+/******************************************************************************/
+// Copyright note:
+//
+// These functions (C) Chris Wojtan
+// Long-term goal is to unify with his split&merge codebase
+//
+/******************************************************************************/
+
+#include <queue>
+#include <algorithm>
+#include "mesh.h"
+#include "kernel.h"
+#include "edgecollapse.h"
+#include <mesh.h>
+#include <stack>
+
+using namespace std;
+
+namespace Manta {
+
+//! Mesh smoothing
+/*! see Desbrun 99 "Implicit fairing of of irregular meshes using diffusion and curvature flow"*/
+void smoothMesh(Mesh &mesh, Real strength, int steps = 1, Real minLength = 1e-5)
+{
+  const Real dt = mesh.getParent()->getDt();
+  const Real str = min(dt * strength, (Real)1);
+  mesh.rebuildQuickCheck();
+
+  // calculate original mesh volume
+  Vec3 origCM;
+  Real origVolume = mesh.computeCenterOfMass(origCM);
+
+  // temp vertices
+  const int numCorners = mesh.numTris() * 3;
+  const int numNodes = mesh.numNodes();
+  vector<Vec3> temp(numNodes);
+  vector<bool> visited(numNodes);
+
+  for (int s = 0; s < steps; s++) {
+    // reset markers
+    for (size_t i = 0; i < visited.size(); i++)
+      visited[i] = false;
+
+    for (int c = 0; c < numCorners; c++) {
+      const int node = mesh.corners(c).node;
+      if (visited[node])
+        continue;
+
+      const Vec3 pos = mesh.nodes(node).pos;
+      Vec3 dx(0.0);
+      Real totalLen = 0;
+
+      // rotate around vertex
+      set<int> &ring = mesh.get1Ring(node).nodes;
+      for (set<int>::iterator it = ring.begin(); it != ring.end(); it++) {
+        Vec3 edge = mesh.nodes(*it).pos - pos;
+        Real len = norm(edge);
+
+        if (len > minLength) {
+          dx += edge * (1.0 / len);
+          totalLen += len;
+        }
+        else {
+          totalLen = 0.0;
+          break;
+        }
+      }
+      visited[node] = true;
+      temp[node] = pos;
+      if (totalLen != 0)
+        temp[node] += dx * (str / totalLen);
+    }
+
+    // copy back
+    for (int n = 0; n < numNodes; n++)
+      if (!mesh.isNodeFixed(n))
+        mesh.nodes(n).pos = temp[n];
+  }
+
+  // calculate new mesh volume
+  Vec3 newCM;
+  Real newVolume = mesh.computeCenterOfMass(newCM);
+
+  // preserve volume : scale relative to CM
+  Real beta;
+#if defined(WIN32) || defined(_WIN32)
+  beta = pow((Real)std::abs(origVolume / newVolume), (Real)(1. / 3.));
+#else
+  beta = cbrt(origVolume / newVolume);
+#endif
+
+  for (int n = 0; n < numNodes; n++)
+    if (!mesh.isNodeFixed(n))
+      mesh.nodes(n).pos = origCM + (mesh.nodes(n).pos - newCM) * beta;
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "smoothMesh", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+      Real strength = _args.get<Real>("strength", 1, &_lock);
+      int steps = _args.getOpt<int>("steps", 2, 1, &_lock);
+      Real minLength = _args.getOpt<Real>("minLength", 3, 1e-5, &_lock);
+      _retval = getPyNone();
+      smoothMesh(mesh, strength, steps, minLength);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "smoothMesh", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("smoothMesh", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_smoothMesh("", "smoothMesh", _W_0);
+extern "C" {
+void PbRegister_smoothMesh()
+{
+  KEEP_UNUSED(_RP_smoothMesh);
+}
+}
+
+//! Subdivide and edgecollapse to guarantee mesh with edgelengths between
+//! min/maxLength and an angle below minAngle
+void subdivideMesh(
+    Mesh &mesh, Real minAngle, Real minLength, Real maxLength, bool cutTubes = false)
+{
+  // gather some statistics
+  int edgeSubdivs = 0, edgeCollsAngle = 0, edgeCollsLen = 0, edgeKill = 0;
+  mesh.rebuildQuickCheck();
+
+  vector<int> deletedNodes;
+  map<int, bool> taintedTris;
+  priority_queue<pair<Real, int>> pq;
+
+  //////////////////////////////////////////
+  // EDGE COLLAPSE                        //
+  //    - particles marked for deletation //
+  //////////////////////////////////////////
+
+  for (int t = 0; t < mesh.numTris(); t++) {
+    if (taintedTris.find(t) != taintedTris.end())
+      continue;
+
+    // check if at least 2 nodes are marked for delete
+    bool k[3];
+    int numKill = 0;
+    for (int i = 0; i < 3; i++) {
+      k[i] = mesh.nodes(mesh.tris(t).c[i]).flags & Mesh::NfKillme;
+      if (k[i])
+        numKill++;
+    }
+    if (numKill < 2)
+      continue;
+
+    if (k[0] && k[1])
+      CollapseEdge(mesh,
+                   t,
+                   2,
+                   mesh.getEdge(t, 0),
+                   mesh.getNode(t, 0),
+                   deletedNodes,
+                   taintedTris,
+                   edgeKill,
+                   cutTubes);
+    else if (k[1] && k[2])
+      CollapseEdge(mesh,
+                   t,
+                   0,
+                   mesh.getEdge(t, 1),
+                   mesh.getNode(t, 1),
+                   deletedNodes,
+                   taintedTris,
+                   edgeKill,
+                   cutTubes);
+    else if (k[2] && k[0])
+      CollapseEdge(mesh,
+                   t,
+                   1,
+                   mesh.getEdge(t, 2),
+                   mesh.getNode(t, 2),
+                   deletedNodes,
+                   taintedTris,
+                   edgeKill,
+                   cutTubes);
+  }
+
+  //////////////////////////////////////////
+  // EDGE COLLAPSING                      //
+  //      - based on small triangle angle //
+  //////////////////////////////////////////
+
+  if (minAngle > 0) {
+    for (int t = 0; t < mesh.numTris(); t++) {
+      // we only want to run through the edge list ONCE.
+      // we achieve this in a method very similar to the above subdivision method.
+
+      // if this triangle has already been deleted, ignore it
+      if (taintedTris.find(t) != taintedTris.end())
+        continue;
+
+      // first we find the angles of this triangle
+      Vec3 e0 = mesh.getEdge(t, 0), e1 = mesh.getEdge(t, 1), e2 = mesh.getEdge(t, 2);
+      Vec3 ne0 = e0;
+      Vec3 ne1 = e1;
+      Vec3 ne2 = e2;
+      normalize(ne0);
+      normalize(ne1);
+      normalize(ne2);
+
+      // Real thisArea = sqrMag(cross(-e2,e0));
+      // small angle approximation says sin(x) = arcsin(x) = x,
+      // arccos(x) = pi/2 - arcsin(x),
+      // cos(x) = dot(A,B),
+      // so angle is approximately 1 - dot(A,B).
+      Real angle[3];
+      angle[0] = 1.0 - dot(ne0, -ne2);
+      angle[1] = 1.0 - dot(ne1, -ne0);
+      angle[2] = 1.0 - dot(ne2, -ne1);
+      Real worstAngle = angle[0];
+      int which = 0;
+      if (angle[1] < worstAngle) {
+        worstAngle = angle[1];
+        which = 1;
+      }
+      if (angle[2] < worstAngle) {
+        worstAngle = angle[2];
+        which = 2;
+      }
+
+      // then we see if the angle is too small
+      if (worstAngle < minAngle) {
+        Vec3 edgevect;
+        Vec3 endpoint;
+        switch (which) {
+          case 0:
+            endpoint = mesh.getNode(t, 1);
+            edgevect = e1;
+            break;
+          case 1:
+            endpoint = mesh.getNode(t, 2);
+            edgevect = e2;
+            break;
+          case 2:
+            endpoint = mesh.getNode(t, 0);
+            edgevect = e0;
+            break;
+          default:
+            break;
+        }
+
+        CollapseEdge(mesh,
+                     t,
+                     which,
+                     edgevect,
+                     endpoint,
+                     deletedNodes,
+                     taintedTris,
+                     edgeCollsAngle,
+                     cutTubes);
+      }
+    }
+  }
+
+  //////////////////////
+  // EDGE SUBDIVISION //
+  //////////////////////
+
+  Real maxLength2 = maxLength * maxLength;
+  for (int t = 0; t < mesh.numTris(); t++) {
+    // first we find the maximum length edge in this triangle
+    Vec3 e0 = mesh.getEdge(t, 0), e1 = mesh.getEdge(t, 1), e2 = mesh.getEdge(t, 2);
+    Real d0 = normSquare(e0);
+    Real d1 = normSquare(e1);
+    Real d2 = normSquare(e2);
+
+    Real longest = max(d0, max(d1, d2));
+    if (longest > maxLength2) {
+      pq.push(pair<Real, int>(longest, t));
+    }
+  }
+  if (maxLength > 0) {
+
+    while (!pq.empty() && pq.top().first > maxLength2) {
+      // we only want to run through the edge list ONCE
+      // and we want to subdivide the original edges before we subdivide any newer, shorter edges,
+      // so whenever we subdivide, we add the 2 new triangles on the end of the SurfaceTri vector
+      // and mark the original subdivided triangles for deletion.
+      //  when we are done subdividing, we delete the obsolete triangles
+
+      int triA = pq.top().second;
+      pq.pop();
+
+      if (taintedTris.find(triA) != taintedTris.end())
+        continue;
+
+      // first we find the maximum length edge in this triangle
+      Vec3 e0 = mesh.getEdge(triA, 0), e1 = mesh.getEdge(triA, 1), e2 = mesh.getEdge(triA, 2);
+      Real d0 = normSquare(e0);
+      Real d1 = normSquare(e1);
+      Real d2 = normSquare(e2);
+
+      Vec3 edgevect;
+      Vec3 endpoint;
+      int which;
+      if (d0 > d1) {
+        if (d0 > d2) {
+          edgevect = e0;
+          endpoint = mesh.getNode(triA, 0);
+          ;
+          which = 2;  // 2 opposite of edge 0-1
+        }
+        else {
+          edgevect = e2;
+          endpoint = mesh.getNode(triA, 2);
+          which = 1;  // 1 opposite of edge 2-0
+        }
+      }
+      else {
+        if (d1 > d2) {
+          edgevect = e1;
+          endpoint = mesh.getNode(triA, 1);
+          which = 0;  // 0 opposite of edge 1-2
+        }
+        else {
+          edgevect = e2;
+          endpoint = mesh.getNode(triA, 2);
+          which = 1;  // 1 opposite of edge 2-0
+        }
+      }
+      // This edge is too long, so we split it in the middle
+
+      //         *
+      //        / \.
+      //       /C0 \.
+      //      /     \.
+      //     /       \.
+      //    /    B    \.
+      //   /           \.
+      //  /C1        C2 \.
+      // *---------------*
+      //  \C2        C1 /
+      //   \           /
+      //    \    A    /
+      //     \       /
+      //      \     /
+      //       \C0 /
+      //        \ /
+      //         *
+      //
+      //      BECOMES
+      //
+      //         *
+      //        /|\.
+      //       / | \.
+      //      /C0|C0\.
+      //     /   |   \.
+      //    / B1 | B2 \.
+      //   /     |     \.
+      //  /C1  C2|C1 C2 \.
+      // *-------*-------*
+      //  \C2  C1|C2  C1/
+      //   \     |     /
+      //    \ A2 | A1 /
+      //     \   |   /
+      //      \C0|C0/
+      //       \ | /
+      //        \|/
+      //         *
+
+      int triB = -1;
+      bool haveB = false;
+      Corner ca_old[3], cb_old[3];
+      ca_old[0] = mesh.corners(triA, which);
+      ca_old[1] = mesh.corners(ca_old[0].next);
+      ca_old[2] = mesh.corners(ca_old[0].prev);
+      if (ca_old[0].opposite >= 0) {
+        cb_old[0] = mesh.corners(ca_old[0].opposite);
+        cb_old[1] = mesh.corners(cb_old[0].next);
+        cb_old[2] = mesh.corners(cb_old[0].prev);
+        triB = cb_old[0].tri;
+        haveB = true;
+      }
+      // else throw Error("nonmanifold");
+
+      // subdivide in the middle of the edge and create new triangles
+      Node newNode;
+      newNode.flags = 0;
+
+      newNode.pos = endpoint + 0.5 * edgevect;  // fallback: linear average
+      // default: use butterfly
+      if (haveB)
+        newNode.pos = ModifiedButterflySubdivision(mesh, ca_old[0], cb_old[0], newNode.pos);
+
+      // find indices of two points of 'which'-edge
+      // merge flags
+      int P0 = ca_old[1].node;
+      int P1 = ca_old[2].node;
+      newNode.flags = mesh.nodes(P0).flags | mesh.nodes(P1).flags;
+
+      Real len0 = norm(mesh.nodes(P0).pos - newNode.pos);
+      Real len1 = norm(mesh.nodes(P1).pos - newNode.pos);
+
+      // remove P0/P1 1-ring connection
+      mesh.get1Ring(P0).nodes.erase(P1);
+      mesh.get1Ring(P1).nodes.erase(P0);
+      mesh.get1Ring(P0).tris.erase(triA);
+      mesh.get1Ring(P1).tris.erase(triA);
+      mesh.get1Ring(ca_old[0].node).tris.erase(triA);
+      if (haveB) {
+        mesh.get1Ring(P0).tris.erase(triB);
+        mesh.get1Ring(P1).tris.erase(triB);
+        mesh.get1Ring(cb_old[0].node).tris.erase(triB);
+      }
+
+      // init channel properties for new node
+      for (int i = 0; i < mesh.numNodeChannels(); i++) {
+        mesh.nodeChannel(i)->addInterpol(P0, P1, len0 / (len0 + len1));
+      }
+
+      // write to array
+      mesh.addTri(Triangle(ca_old[0].node, ca_old[1].node, mesh.numNodes()));
+      mesh.addTri(Triangle(ca_old[0].node, mesh.numNodes(), ca_old[2].node));
+      if (haveB) {
+        mesh.addTri(Triangle(cb_old[0].node, cb_old[1].node, mesh.numNodes()));
+        mesh.addTri(Triangle(cb_old[0].node, mesh.numNodes(), cb_old[2].node));
+      }
+      mesh.addNode(newNode);
+
+      const int nt = haveB ? 4 : 2;
+      int triA1 = mesh.numTris() - nt;
+      int triA2 = mesh.numTris() - nt + 1;
+      int triB1 = 0, triB2 = 0;
+      if (haveB) {
+        triB1 = mesh.numTris() - nt + 2;
+        triB2 = mesh.numTris() - nt + 3;
+      }
+      mesh.tris(triA1).flags = mesh.tris(triA).flags;
+      mesh.tris(triA2).flags = mesh.tris(triA).flags;
+      mesh.tris(triB1).flags = mesh.tris(triB).flags;
+      mesh.tris(triB2).flags = mesh.tris(triB).flags;
+
+      // connect new triangles to outside triangles,
+      // and connect outside triangles to these new ones
+      for (int c = 0; c < 3; c++)
+        mesh.addCorner(Corner(triA1, mesh.tris(triA1).c[c]));
+      for (int c = 0; c < 3; c++)
+        mesh.addCorner(Corner(triA2, mesh.tris(triA2).c[c]));
+      if (haveB) {
+        for (int c = 0; c < 3; c++)
+          mesh.addCorner(Corner(triB1, mesh.tris(triB1).c[c]));
+        for (int c = 0; c < 3; c++)
+          mesh.addCorner(Corner(triB2, mesh.tris(triB2).c[c]));
+      }
+
+      int baseIdx = 3 * (mesh.numTris() - nt);
+      Corner *cBase = &mesh.corners(baseIdx);
+
+      // set next/prev
+      for (int t = 0; t < nt; t++)
+        for (int c = 0; c < 3; c++) {
+          cBase[t * 3 + c].next = baseIdx + t * 3 + ((c + 1) % 3);
+          cBase[t * 3 + c].prev = baseIdx + t * 3 + ((c + 2) % 3);
+        }
+
+      // set opposites
+      // A1
+      cBase[0].opposite = haveB ? (baseIdx + 9) : -1;
+      cBase[1].opposite = baseIdx + 5;
+      cBase[2].opposite = -1;
+      if (ca_old[2].opposite >= 0) {
+        cBase[2].opposite = ca_old[2].opposite;
+        mesh.corners(cBase[2].opposite).opposite = baseIdx + 2;
+      }
+      // A2
+      cBase[3].opposite = haveB ? (baseIdx + 6) : -1;
+      cBase[4].opposite = -1;
+      if (ca_old[1].opposite >= 0) {
+        cBase[4].opposite = ca_old[1].opposite;
+        mesh.corners(cBase[4].opposite).opposite = baseIdx + 4;
+      }
+      cBase[5].opposite = baseIdx + 1;
+      if (haveB) {
+        // B1
+        cBase[6].opposite = baseIdx + 3;
+        cBase[7].opposite = baseIdx + 11;
+        cBase[8].opposite = -1;
+        if (cb_old[2].opposite >= 0) {
+          cBase[8].opposite = cb_old[2].opposite;
+          mesh.corners(cBase[8].opposite).opposite = baseIdx + 8;
+        }
+        // B2
+        cBase[9].opposite = baseIdx + 0;
+        cBase[10].opposite = -1;
+        if (cb_old[1].opposite >= 0) {
+          cBase[10].opposite = cb_old[1].opposite;
+          mesh.corners(cBase[10].opposite).opposite = baseIdx + 10;
+        }
+        cBase[11].opposite = baseIdx + 7;
+      }
+
+      ////////////////////
+      // mark the two original triangles for deletion
+      taintedTris[triA] = true;
+      mesh.removeTriFromLookup(triA);
+      if (haveB) {
+        taintedTris[triB] = true;
+        mesh.removeTriFromLookup(triB);
+      }
+
+      Real areaA1 = mesh.getFaceArea(triA1), areaA2 = mesh.getFaceArea(triA2);
+      Real areaB1 = 0, areaB2 = 0;
+      if (haveB) {
+        areaB1 = mesh.getFaceArea(triB1);
+        areaB2 = mesh.getFaceArea(triB2);
+      }
+
+      // add channel props for new triangles
+      for (int i = 0; i < mesh.numTriChannels(); i++) {
+        mesh.triChannel(i)->addSplit(triA, areaA1 / (areaA1 + areaA2));
+        mesh.triChannel(i)->addSplit(triA, areaA2 / (areaA1 + areaA2));
+        if (haveB) {
+          mesh.triChannel(i)->addSplit(triB, areaB1 / (areaB1 + areaB2));
+          mesh.triChannel(i)->addSplit(triB, areaB2 / (areaB1 + areaB2));
+        }
+      }
+
+      // add the four new triangles to the prority queue
+      for (int i = mesh.numTris() - nt; i < mesh.numTris(); i++) {
+        // find the maximum length edge in this triangle
+        Vec3 ne0 = mesh.getEdge(i, 0), ne1 = mesh.getEdge(i, 1), ne2 = mesh.getEdge(i, 2);
+        Real nd0 = normSquare(ne0);
+        Real nd1 = normSquare(ne1);
+        Real nd2 = normSquare(ne2);
+        Real longest = max(nd0, max(nd1, nd2));
+        // longest = (int)(longest * 1e2) / 1e2; // HACK: truncate
+        pq.push(pair<Real, int>(longest, i));
+      }
+      edgeSubdivs++;
+    }
+  }
+
+  //////////////////////////////////////////
+  // EDGE COLLAPSING                      //
+  //      - based on short edge length    //
+  //////////////////////////////////////////
+  if (minLength > 0) {
+    const Real minLength2 = minLength * minLength;
+    for (int t = 0; t < mesh.numTris(); t++) {
+      // we only want to run through the edge list ONCE.
+      // we achieve this in a method very similar to the above subdivision method.
+
+      // NOTE:
+      // priority queue does not work so great in the edge collapse case,
+      // because collapsing one triangle affects the edge lengths
+      // of many neighbor triangles,
+      // and we do not update their maximum edge length in the queue.
+
+      // if this triangle has already been deleted, ignore it
+      // if(taintedTris[t])
+      //  continue;
+
+      if (taintedTris.find(t) != taintedTris.end())
+        continue;
+
+      // first we find the minimum length edge in this triangle
+      Vec3 e0 = mesh.getEdge(t, 0), e1 = mesh.getEdge(t, 1), e2 = mesh.getEdge(t, 2);
+      Real d0 = normSquare(e0);
+      Real d1 = normSquare(e1);
+      Real d2 = normSquare(e2);
+
+      Vec3 edgevect;
+      Vec3 endpoint;
+      Real dist2;
+      int which;
+      if (d0 < d1) {
+        if (d0 < d2) {
+          dist2 = d0;
+          edgevect = e0;
+          endpoint = mesh.getNode(t, 0);
+          which = 2;  // 2 opposite of edge 0-1
+        }
+        else {
+          dist2 = d2;
+          edgevect = e2;
+          endpoint = mesh.getNode(t, 2);
+          which = 1;  // 1 opposite of edge 2-0
+        }
+      }
+      else {
+        if (d1 < d2) {
+          dist2 = d1;
+          edgevect = e1;
+          endpoint = mesh.getNode(t, 1);
+          which = 0;  // 0 opposite of edge 1-2
+        }
+        else {
+          dist2 = d2;
+          edgevect = e2;
+          endpoint = mesh.getNode(t, 2);
+          which = 1;  // 1 opposite of edge 2-0
+        }
+      }
+      // then we see if the min length edge is too short
+      if (dist2 < minLength2) {
+        CollapseEdge(
+            mesh, t, which, edgevect, endpoint, deletedNodes, taintedTris, edgeCollsLen, cutTubes);
+      }
+    }
+  }
+  // cleanup nodes and triangles marked for deletion
+
+  //  we run backwards through the deleted array,
+  //  replacing triangles with ones from the back
+  //          (this avoids the potential problem of overwriting a triangle
+  //              with a to-be-deleted triangle)
+  std::map<int, bool>::reverse_iterator tti = taintedTris.rbegin();
+  for (; tti != taintedTris.rend(); tti++)
+    mesh.removeTri(tti->first);
+
+  mesh.removeNodes(deletedNodes);
+  cout << "Surface subdivision finished with " << mesh.numNodes() << " surface nodes and "
+       << mesh.numTris();
+  cout << " surface triangles, edgeSubdivs:" << edgeSubdivs << ", edgeCollapses: " << edgeCollsLen;
+  cout << " + " << edgeCollsAngle << " + " << edgeKill << endl;
+  // mesh.sanityCheck();
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "subdivideMesh", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+      Real minAngle = _args.get<Real>("minAngle", 1, &_lock);
+      Real minLength = _args.get<Real>("minLength", 2, &_lock);
+      Real maxLength = _args.get<Real>("maxLength", 3, &_lock);
+      bool cutTubes = _args.getOpt<bool>("cutTubes", 4, false, &_lock);
+      _retval = getPyNone();
+      subdivideMesh(mesh, minAngle, minLength, maxLength, cutTubes);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "subdivideMesh", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("subdivideMesh", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_subdivideMesh("", "subdivideMesh", _W_1);
+extern "C" {
+void PbRegister_subdivideMesh()
+{
+  KEEP_UNUSED(_RP_subdivideMesh);
+}
+}
+
+void killSmallComponents(Mesh &mesh, int elements = 10)
+{
+  const int num = mesh.numTris();
+  vector<int> comp(num);
+  vector<int> numEl;
+  vector<int> deletedNodes;
+  vector<bool> isNodeDel(mesh.numNodes());
+  map<int, bool> taintedTris;
+  // enumerate components
+  int cur = 0;
+  for (int i = 0; i < num; i++) {
+    if (comp[i] == 0) {
+      cur++;
+      comp[i] = cur;
+
+      stack<int> stack;
+      stack.push(i);
+      int cnt = 1;
+      while (!stack.empty()) {
+        int tri = stack.top();
+        stack.pop();
+        for (int c = 0; c < 3; c++) {
+          int op = mesh.corners(tri, c).opposite;
+          if (op < 0)
+            continue;
+          int ntri = mesh.corners(op).tri;
+          if (comp[ntri] == 0) {
+            comp[ntri] = cur;
+            stack.push(ntri);
+            cnt++;
+          }
+        }
+      }
+      numEl.push_back(cnt);
+    }
+  }
+  // kill small components
+  for (int j = 0; j < num; j++) {
+    if (numEl[comp[j] - 1] < elements) {
+      taintedTris[j] = true;
+      for (int c = 0; c < 3; c++) {
+        int n = mesh.tris(j).c[c];
+        if (!isNodeDel[n]) {
+          isNodeDel[n] = true;
+          deletedNodes.push_back(n);
+        }
+      }
+    }
+  }
+
+  std::map<int, bool>::reverse_iterator tti = taintedTris.rbegin();
+  for (; tti != taintedTris.rend(); tti++)
+    mesh.removeTri(tti->first);
+
+  mesh.removeNodes(deletedNodes);
+
+  if (!taintedTris.empty())
+    cout << "Killed small components : " << deletedNodes.size() << " nodes, " << taintedTris.size()
+         << " tris deleted." << endl;
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "killSmallComponents", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+      int elements = _args.getOpt<int>("elements", 1, 10, &_lock);
+      _retval = getPyNone();
+      killSmallComponents(mesh, elements);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "killSmallComponents", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("killSmallComponents", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_killSmallComponents("", "killSmallComponents", _W_2);
+extern "C" {
+void PbRegister_killSmallComponents()
+{
+  KEEP_UNUSED(_RP_killSmallComponents);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/pressure.cpp b/extern/mantaflow/preprocessed/plugin/pressure.cpp
new file mode 100644
index 00000000000..7def2669e36
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/pressure.cpp
@@ -0,0 +1,1511 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Plugins for pressure correction: solve_pressure, and ghost fluid helpers
+ *
+ ******************************************************************************/
+#include "vectorbase.h"
+#include "kernel.h"
+#include "conjugategrad.h"
+#include "multigrid.h"
+
+using namespace std;
+namespace Manta {
+
+//! Preconditioner for CG solver
+// - None: Use standard CG
+// - MIC: Modified incomplete Cholesky preconditioner
+// - MGDynamic: Multigrid preconditioner, rebuilt for each solve
+// - MGStatic: Multigrid preconditioner, built only once (faster than
+//       MGDynamic, but works only if Poisson equation does not change)
+enum Preconditioner { PcNone = 0, PcMIC = 1, PcMGDynamic = 2, PcMGStatic = 3 };
+
+inline static Real surfTensHelper(const IndexInt idx,
+                                  const int offset,
+                                  const Grid<Real> &phi,
+                                  const Grid<Real> &curv,
+                                  const Real surfTens,
+                                  const Real gfClamp);
+
+//! Kernel: Construct the right-hand side of the poisson equation
+
+struct MakeRhs : public KernelBase {
+  MakeRhs(const FlagGrid &flags,
+          Grid<Real> &rhs,
+          const MACGrid &vel,
+          const Grid<Real> *perCellCorr,
+          const MACGrid *fractions,
+          const MACGrid *obvel,
+          const Grid<Real> *phi,
+          const Grid<Real> *curv,
+          const Real surfTens,
+          const Real gfClamp)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        rhs(rhs),
+        vel(vel),
+        perCellCorr(perCellCorr),
+        fractions(fractions),
+        obvel(obvel),
+        phi(phi),
+        curv(curv),
+        surfTens(surfTens),
+        gfClamp(gfClamp),
+        cnt(0),
+        sum(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &rhs,
+                 const MACGrid &vel,
+                 const Grid<Real> *perCellCorr,
+                 const MACGrid *fractions,
+                 const MACGrid *obvel,
+                 const Grid<Real> *phi,
+                 const Grid<Real> *curv,
+                 const Real surfTens,
+                 const Real gfClamp,
+                 int &cnt,
+                 double &sum)
+  {
+    if (!flags.isFluid(i, j, k)) {
+      rhs(i, j, k) = 0;
+      return;
+    }
+
+    // compute negative divergence
+    // no flag checks: assumes vel at obstacle interfaces is set to zero
+    Real set(0);
+    if (!fractions) {
+      set = vel(i, j, k).x - vel(i + 1, j, k).x + vel(i, j, k).y - vel(i, j + 1, k).y;
+      if (vel.is3D())
+        set += vel(i, j, k).z - vel(i, j, k + 1).z;
+    }
+    else {
+      set = (*fractions)(i, j, k).x * vel(i, j, k).x -
+            (*fractions)(i + 1, j, k).x * vel(i + 1, j, k).x +
+            (*fractions)(i, j, k).y * vel(i, j, k).y -
+            (*fractions)(i, j + 1, k).y * vel(i, j + 1, k).y;
+      if (vel.is3D())
+        set += (*fractions)(i, j, k).z * vel(i, j, k).z -
+               (*fractions)(i, j, k + 1).z * vel(i, j, k + 1).z;
+
+      // compute divergence from obstacle by using obstacle velocity (optional)
+      if (obvel) {
+        set += (1 - (*fractions)(i, j, k).x) * (*obvel)(i, j, k).x -
+               (1 - (*fractions)(i + 1, j, k).x) * (*obvel)(i + 1, j, k).x +
+               (1 - (*fractions)(i, j, k).y) * (*obvel)(i, j, k).y -
+               (1 - (*fractions)(i, j + 1, k).y) * (*obvel)(i, j + 1, k).y;
+        if (obvel->is3D())
+          set += (1 - (*fractions)(i, j, k).z) * (*obvel)(i, j, k).z -
+                 (1 - (*fractions)(i, j, k + 1).z) * (*obvel)(i, j, k + 1).z;
+      }
+    }
+
+    // compute surface tension effect (optional)
+    if (phi && curv) {
+      const IndexInt idx = flags.index(i, j, k);
+      const int X = flags.getStrideX(), Y = flags.getStrideY(), Z = flags.getStrideZ();
+      if (flags.isEmpty(i - 1, j, k))
+        set += surfTensHelper(idx, -X, *phi, *curv, surfTens, gfClamp);
+      if (flags.isEmpty(i + 1, j, k))
+        set += surfTensHelper(idx, +X, *phi, *curv, surfTens, gfClamp);
+      if (flags.isEmpty(i, j - 1, k))
+        set += surfTensHelper(idx, -Y, *phi, *curv, surfTens, gfClamp);
+      if (flags.isEmpty(i, j + 1, k))
+        set += surfTensHelper(idx, +Y, *phi, *curv, surfTens, gfClamp);
+      if (vel.is3D()) {
+        if (flags.isEmpty(i, j, k - 1))
+          set += surfTensHelper(idx, -Z, *phi, *curv, surfTens, gfClamp);
+        if (flags.isEmpty(i, j, k + 1))
+          set += surfTensHelper(idx, +Z, *phi, *curv, surfTens, gfClamp);
+      }
+    }
+
+    // per cell divergence correction (optional)
+    if (perCellCorr)
+      set += perCellCorr->get(i, j, k);
+
+    // obtain sum, cell count
+    sum += set;
+    cnt++;
+
+    rhs(i, j, k) = set;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return rhs;
+  }
+  typedef Grid<Real> type1;
+  inline const MACGrid &getArg2()
+  {
+    return vel;
+  }
+  typedef MACGrid type2;
+  inline const Grid<Real> *getArg3()
+  {
+    return perCellCorr;
+  }
+  typedef Grid<Real> type3;
+  inline const MACGrid *getArg4()
+  {
+    return fractions;
+  }
+  typedef MACGrid type4;
+  inline const MACGrid *getArg5()
+  {
+    return obvel;
+  }
+  typedef MACGrid type5;
+  inline const Grid<Real> *getArg6()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type6;
+  inline const Grid<Real> *getArg7()
+  {
+    return curv;
+  }
+  typedef Grid<Real> type7;
+  inline const Real &getArg8()
+  {
+    return surfTens;
+  }
+  typedef Real type8;
+  inline const Real &getArg9()
+  {
+    return gfClamp;
+  }
+  typedef Real type9;
+  void runMessage()
+  {
+    debMsg("Executing kernel MakeRhs ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i,
+               j,
+               k,
+               flags,
+               rhs,
+               vel,
+               perCellCorr,
+               fractions,
+               obvel,
+               phi,
+               curv,
+               surfTens,
+               gfClamp,
+               cnt,
+               sum);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i,
+             j,
+             k,
+             flags,
+             rhs,
+             vel,
+             perCellCorr,
+             fractions,
+             obvel,
+             phi,
+             curv,
+             surfTens,
+             gfClamp,
+             cnt,
+             sum);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_reduce(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_reduce(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MakeRhs(MakeRhs &o, tbb::split)
+      : KernelBase(o),
+        flags(o.flags),
+        rhs(o.rhs),
+        vel(o.vel),
+        perCellCorr(o.perCellCorr),
+        fractions(o.fractions),
+        obvel(o.obvel),
+        phi(o.phi),
+        curv(o.curv),
+        surfTens(o.surfTens),
+        gfClamp(o.gfClamp),
+        cnt(0),
+        sum(0)
+  {
+  }
+  void join(const MakeRhs &o)
+  {
+    cnt += o.cnt;
+    sum += o.sum;
+  }
+  const FlagGrid &flags;
+  Grid<Real> &rhs;
+  const MACGrid &vel;
+  const Grid<Real> *perCellCorr;
+  const MACGrid *fractions;
+  const MACGrid *obvel;
+  const Grid<Real> *phi;
+  const Grid<Real> *curv;
+  const Real surfTens;
+  const Real gfClamp;
+  int cnt;
+  double sum;
+};
+
+//! Kernel: make velocity divergence free by subtracting pressure gradient
+
+struct knCorrectVelocity : public KernelBase {
+  knCorrectVelocity(const FlagGrid &flags, MACGrid &vel, const Grid<Real> &pressure)
+      : KernelBase(&flags, 1), flags(flags), vel(vel), pressure(pressure)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const FlagGrid &flags, MACGrid &vel, const Grid<Real> &pressure) const
+  {
+    const IndexInt idx = flags.index(i, j, k);
+    if (flags.isFluid(idx)) {
+      if (flags.isFluid(i - 1, j, k))
+        vel[idx].x -= (pressure[idx] - pressure(i - 1, j, k));
+      if (flags.isFluid(i, j - 1, k))
+        vel[idx].y -= (pressure[idx] - pressure(i, j - 1, k));
+      if (flags.is3D() && flags.isFluid(i, j, k - 1))
+        vel[idx].z -= (pressure[idx] - pressure(i, j, k - 1));
+
+      if (flags.isEmpty(i - 1, j, k))
+        vel[idx].x -= pressure[idx];
+      if (flags.isEmpty(i, j - 1, k))
+        vel[idx].y -= pressure[idx];
+      if (flags.is3D() && flags.isEmpty(i, j, k - 1))
+        vel[idx].z -= pressure[idx];
+    }
+    else if (flags.isEmpty(idx) &&
+             !flags.isOutflow(idx)) {  // don't change velocities in outflow cells
+      if (flags.isFluid(i - 1, j, k))
+        vel[idx].x += pressure(i - 1, j, k);
+      else
+        vel[idx].x = 0.f;
+      if (flags.isFluid(i, j - 1, k))
+        vel[idx].y += pressure(i, j - 1, k);
+      else
+        vel[idx].y = 0.f;
+      if (flags.is3D()) {
+        if (flags.isFluid(i, j, k - 1))
+          vel[idx].z += pressure(i, j, k - 1);
+        else
+          vel[idx].z = 0.f;
+      }
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return pressure;
+  }
+  typedef Grid<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCorrectVelocity ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, vel, pressure);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, vel, pressure);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  MACGrid &vel;
+  const Grid<Real> &pressure;
+};
+
+// *****************************************************************************
+// Ghost fluid helpers
+
+// calculate fraction filled with liquid (note, assumes inside value is < outside!)
+inline static Real thetaHelper(const Real inside, const Real outside)
+{
+  const Real denom = inside - outside;
+  if (denom > -1e-04)
+    return 0.5;  // should always be neg, and large enough...
+  return std::max(Real(0), std::min(Real(1), inside / denom));
+}
+
+// calculate ghost fluid factor, cell at idx should be a fluid cell
+inline static Real ghostFluidHelper(const IndexInt idx,
+                                    const int offset,
+                                    const Grid<Real> &phi,
+                                    const Real gfClamp)
+{
+  Real alpha = thetaHelper(phi[idx], phi[idx + offset]);
+  if (alpha < gfClamp)
+    return alpha = gfClamp;
+  return (1. - (1. / alpha));
+}
+
+inline static Real surfTensHelper(const IndexInt idx,
+                                  const int offset,
+                                  const Grid<Real> &phi,
+                                  const Grid<Real> &curv,
+                                  const Real surfTens,
+                                  const Real gfClamp)
+{
+  return surfTens * (curv[idx + offset] - ghostFluidHelper(idx, offset, phi, gfClamp) * curv[idx]);
+}
+
+//! Kernel: Adapt A0 for ghost fluid
+
+struct ApplyGhostFluidDiagonal : public KernelBase {
+  ApplyGhostFluidDiagonal(Grid<Real> &A0,
+                          const FlagGrid &flags,
+                          const Grid<Real> &phi,
+                          const Real gfClamp)
+      : KernelBase(&A0, 1), A0(A0), flags(flags), phi(phi), gfClamp(gfClamp)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Real> &A0,
+                 const FlagGrid &flags,
+                 const Grid<Real> &phi,
+                 const Real gfClamp) const
+  {
+    const int X = flags.getStrideX(), Y = flags.getStrideY(), Z = flags.getStrideZ();
+    const IndexInt idx = flags.index(i, j, k);
+    if (!flags.isFluid(idx))
+      return;
+
+    if (flags.isEmpty(i - 1, j, k))
+      A0[idx] -= ghostFluidHelper(idx, -X, phi, gfClamp);
+    if (flags.isEmpty(i + 1, j, k))
+      A0[idx] -= ghostFluidHelper(idx, +X, phi, gfClamp);
+    if (flags.isEmpty(i, j - 1, k))
+      A0[idx] -= ghostFluidHelper(idx, -Y, phi, gfClamp);
+    if (flags.isEmpty(i, j + 1, k))
+      A0[idx] -= ghostFluidHelper(idx, +Y, phi, gfClamp);
+    if (flags.is3D()) {
+      if (flags.isEmpty(i, j, k - 1))
+        A0[idx] -= ghostFluidHelper(idx, -Z, phi, gfClamp);
+      if (flags.isEmpty(i, j, k + 1))
+        A0[idx] -= ghostFluidHelper(idx, +Z, phi, gfClamp);
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return A0;
+  }
+  typedef Grid<Real> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type2;
+  inline const Real &getArg3()
+  {
+    return gfClamp;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyGhostFluidDiagonal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, A0, flags, phi, gfClamp);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, A0, flags, phi, gfClamp);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &A0;
+  const FlagGrid &flags;
+  const Grid<Real> &phi;
+  const Real gfClamp;
+};
+
+//! Kernel: Apply velocity update: ghost fluid contribution
+
+struct knCorrectVelocityGhostFluid : public KernelBase {
+  knCorrectVelocityGhostFluid(MACGrid &vel,
+                              const FlagGrid &flags,
+                              const Grid<Real> &pressure,
+                              const Grid<Real> &phi,
+                              Real gfClamp,
+                              const Grid<Real> *curv,
+                              const Real surfTens)
+      : KernelBase(&vel, 1),
+        vel(vel),
+        flags(flags),
+        pressure(pressure),
+        phi(phi),
+        gfClamp(gfClamp),
+        curv(curv),
+        surfTens(surfTens)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &vel,
+                 const FlagGrid &flags,
+                 const Grid<Real> &pressure,
+                 const Grid<Real> &phi,
+                 Real gfClamp,
+                 const Grid<Real> *curv,
+                 const Real surfTens) const
+  {
+    const IndexInt X = flags.getStrideX(), Y = flags.getStrideY(), Z = flags.getStrideZ();
+    const IndexInt idx = flags.index(i, j, k);
+    if (flags.isFluid(idx)) {
+      if (flags.isEmpty(i - 1, j, k))
+        vel[idx][0] += pressure[idx] * ghostFluidHelper(idx, -X, phi, gfClamp);
+      if (flags.isEmpty(i, j - 1, k))
+        vel[idx][1] += pressure[idx] * ghostFluidHelper(idx, -Y, phi, gfClamp);
+      if (flags.is3D() && flags.isEmpty(i, j, k - 1))
+        vel[idx][2] += pressure[idx] * ghostFluidHelper(idx, -Z, phi, gfClamp);
+    }
+    else if (flags.isEmpty(idx) &&
+             !flags.isOutflow(idx)) {  // do not change velocities in outflow cells
+      if (flags.isFluid(i - 1, j, k))
+        vel[idx][0] -= pressure(i - 1, j, k) * ghostFluidHelper(idx - X, +X, phi, gfClamp);
+      else
+        vel[idx].x = 0.f;
+      if (flags.isFluid(i, j - 1, k))
+        vel[idx][1] -= pressure(i, j - 1, k) * ghostFluidHelper(idx - Y, +Y, phi, gfClamp);
+      else
+        vel[idx].y = 0.f;
+      if (flags.is3D()) {
+        if (flags.isFluid(i, j, k - 1))
+          vel[idx][2] -= pressure(i, j, k - 1) * ghostFluidHelper(idx - Z, +Z, phi, gfClamp);
+        else
+          vel[idx].z = 0.f;
+      }
+    }
+
+    if (curv) {
+      if (flags.isFluid(idx)) {
+        if (flags.isEmpty(i - 1, j, k))
+          vel[idx].x += surfTensHelper(idx, -X, phi, *curv, surfTens, gfClamp);
+        if (flags.isEmpty(i, j - 1, k))
+          vel[idx].y += surfTensHelper(idx, -Y, phi, *curv, surfTens, gfClamp);
+        if (flags.is3D() && flags.isEmpty(i, j, k - 1))
+          vel[idx].z += surfTensHelper(idx, -Z, phi, *curv, surfTens, gfClamp);
+      }
+      else if (flags.isEmpty(idx) &&
+               !flags.isOutflow(idx)) {  // do not change velocities in outflow cells
+        vel[idx].x -= (flags.isFluid(i - 1, j, k)) ?
+                          surfTensHelper(idx - X, +X, phi, *curv, surfTens, gfClamp) :
+                          0.f;
+        vel[idx].y -= (flags.isFluid(i, j - 1, k)) ?
+                          surfTensHelper(idx - Y, +Y, phi, *curv, surfTens, gfClamp) :
+                          0.f;
+        if (flags.is3D())
+          vel[idx].z -= (flags.isFluid(i, j, k - 1)) ?
+                            surfTensHelper(idx - Z, +Z, phi, *curv, surfTens, gfClamp) :
+                            0.f;
+      }
+    }
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return pressure;
+  }
+  typedef Grid<Real> type2;
+  inline const Grid<Real> &getArg3()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type3;
+  inline Real &getArg4()
+  {
+    return gfClamp;
+  }
+  typedef Real type4;
+  inline const Grid<Real> *getArg5()
+  {
+    return curv;
+  }
+  typedef Grid<Real> type5;
+  inline const Real &getArg6()
+  {
+    return surfTens;
+  }
+  typedef Real type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCorrectVelocityGhostFluid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, flags, pressure, phi, gfClamp, curv, surfTens);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, flags, pressure, phi, gfClamp, curv, surfTens);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MACGrid &vel;
+  const FlagGrid &flags;
+  const Grid<Real> &pressure;
+  const Grid<Real> &phi;
+  Real gfClamp;
+  const Grid<Real> *curv;
+  const Real surfTens;
+};
+
+// improve behavior of clamping for large time steps:
+inline static Real ghostFluidWasClamped(const IndexInt idx,
+                                        const int offset,
+                                        const Grid<Real> &phi,
+                                        const Real gfClamp)
+{
+  const Real alpha = thetaHelper(phi[idx], phi[idx + offset]);
+  if (alpha < gfClamp)
+    return true;
+  return false;
+}
+
+struct knReplaceClampedGhostFluidVels : public KernelBase {
+  knReplaceClampedGhostFluidVels(MACGrid &vel,
+                                 const FlagGrid &flags,
+                                 const Grid<Real> &pressure,
+                                 const Grid<Real> &phi,
+                                 Real gfClamp)
+      : KernelBase(&vel, 1), vel(vel), flags(flags), pressure(pressure), phi(phi), gfClamp(gfClamp)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &vel,
+                 const FlagGrid &flags,
+                 const Grid<Real> &pressure,
+                 const Grid<Real> &phi,
+                 Real gfClamp) const
+  {
+    const IndexInt idx = flags.index(i, j, k);
+    const IndexInt X = flags.getStrideX(), Y = flags.getStrideY(), Z = flags.getStrideZ();
+    if (!flags.isEmpty(idx))
+      return;
+
+    if (flags.isFluid(i - 1, j, k) && ghostFluidWasClamped(idx - X, +X, phi, gfClamp))
+      vel[idx][0] = vel[idx - X][0];
+    if (flags.isFluid(i, j - 1, k) && ghostFluidWasClamped(idx - Y, +Y, phi, gfClamp))
+      vel[idx][1] = vel[idx - Y][1];
+    if (flags.is3D() && flags.isFluid(i, j, k - 1) &&
+        ghostFluidWasClamped(idx - Z, +Z, phi, gfClamp))
+      vel[idx][2] = vel[idx - Z][2];
+
+    if (flags.isFluid(i + 1, j, k) && ghostFluidWasClamped(idx + X, -X, phi, gfClamp))
+      vel[idx][0] = vel[idx + X][0];
+    if (flags.isFluid(i, j + 1, k) && ghostFluidWasClamped(idx + Y, -Y, phi, gfClamp))
+      vel[idx][1] = vel[idx + Y][1];
+    if (flags.is3D() && flags.isFluid(i, j, k + 1) &&
+        ghostFluidWasClamped(idx + Z, -Z, phi, gfClamp))
+      vel[idx][2] = vel[idx + Z][2];
+  }
+  inline MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return pressure;
+  }
+  typedef Grid<Real> type2;
+  inline const Grid<Real> &getArg3()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type3;
+  inline Real &getArg4()
+  {
+    return gfClamp;
+  }
+  typedef Real type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knReplaceClampedGhostFluidVels ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, flags, pressure, phi, gfClamp);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, flags, pressure, phi, gfClamp);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  MACGrid &vel;
+  const FlagGrid &flags;
+  const Grid<Real> &pressure;
+  const Grid<Real> &phi;
+  Real gfClamp;
+};
+
+//! Kernel: Compute min value of Real grid
+
+struct CountEmptyCells : public KernelBase {
+  CountEmptyCells(const FlagGrid &flags) : KernelBase(&flags, 0), flags(flags), numEmpty(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const FlagGrid &flags, int &numEmpty)
+  {
+    if (flags.isEmpty(idx))
+      numEmpty++;
+  }
+  inline operator int()
+  {
+    return numEmpty;
+  }
+  inline int &getRet()
+  {
+    return numEmpty;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel CountEmptyCells ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, numEmpty);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  CountEmptyCells(CountEmptyCells &o, tbb::split) : KernelBase(o), flags(o.flags), numEmpty(0)
+  {
+  }
+  void join(const CountEmptyCells &o)
+  {
+    numEmpty += o.numEmpty;
+  }
+  const FlagGrid &flags;
+  int numEmpty;
+};
+
+// *****************************************************************************
+// Misc helpers
+
+//! Change 'A' and 'rhs' such that pressure at 'fixPidx' is fixed to 'value'
+void fixPressure(int fixPidx,
+                 Real value,
+                 Grid<Real> &rhs,
+                 Grid<Real> &A0,
+                 Grid<Real> &Ai,
+                 Grid<Real> &Aj,
+                 Grid<Real> &Ak)
+{
+  // Bring to rhs at neighbors
+  rhs[fixPidx + Ai.getStrideX()] -= Ai[fixPidx] * value;
+  rhs[fixPidx + Aj.getStrideY()] -= Aj[fixPidx] * value;
+  rhs[fixPidx - Ai.getStrideX()] -= Ai[fixPidx - Ai.getStrideX()] * value;
+  rhs[fixPidx - Aj.getStrideY()] -= Aj[fixPidx - Aj.getStrideY()] * value;
+  if (rhs.is3D()) {
+    rhs[fixPidx + Ak.getStrideZ()] -= Ak[fixPidx] * value;
+    rhs[fixPidx - Ak.getStrideZ()] -= Ak[fixPidx - Ak.getStrideZ()] * value;
+  }
+
+  // Trivialize equation at 'fixPidx' to: pressure[fixPidx] = value
+  rhs[fixPidx] = value;
+  A0[fixPidx] = Real(1);
+  Ai[fixPidx] = Aj[fixPidx] = Ak[fixPidx] = Real(0);
+  Ai[fixPidx - Ai.getStrideX()] = Real(0);
+  Aj[fixPidx - Aj.getStrideY()] = Real(0);
+  if (rhs.is3D()) {
+    Ak[fixPidx - Ak.getStrideZ()] = Real(0);
+  }
+}
+
+// for "static" MG mode, keep one MG data structure per fluid solver
+// leave cleanup to OS/user if nonzero at program termination (PcMGStatic mode)
+// alternatively, manually release in scene file with releaseMG
+static std::map<FluidSolver *, GridMg *> gMapMG;
+
+void releaseMG(FluidSolver *solver = nullptr)
+{
+  // release all?
+  if (!solver) {
+    for (std::map<FluidSolver *, GridMg *>::iterator it = gMapMG.begin(); it != gMapMG.end();
+         it++) {
+      if (it->first != nullptr)
+        releaseMG(it->first);
+    }
+    return;
+  }
+
+  GridMg *mg = gMapMG[solver];
+  if (mg) {
+    delete mg;
+    gMapMG[solver] = nullptr;
+  }
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "releaseMG", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FluidSolver *solver = _args.getPtrOpt<FluidSolver>("solver", 0, nullptr, &_lock);
+      _retval = getPyNone();
+      releaseMG(solver);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "releaseMG", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("releaseMG", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_releaseMG("", "releaseMG", _W_0);
+extern "C" {
+void PbRegister_releaseMG()
+{
+  KEEP_UNUSED(_RP_releaseMG);
+}
+}
+
+// *****************************************************************************
+// Main pressure solve
+
+// Note , all three pressure solve helper functions take
+// identical parameters, apart from the RHS grid (and different const values)
+
+//! Compute rhs for pressure solve
+
+void computePressureRhs(Grid<Real> &rhs,
+                        const MACGrid &vel,
+                        const Grid<Real> &pressure,
+                        const FlagGrid &flags,
+                        Real cgAccuracy = 1e-3,
+                        const Grid<Real> *phi = 0,
+                        const Grid<Real> *perCellCorr = 0,
+                        const MACGrid *fractions = 0,
+                        const MACGrid *obvel = 0,
+                        Real gfClamp = 1e-04,
+                        Real cgMaxIterFac = 1.5,
+                        bool precondition = true,
+                        int preconditioner = PcMIC,
+                        bool enforceCompatibility = false,
+                        bool useL2Norm = false,
+                        bool zeroPressureFixing = false,
+                        const Grid<Real> *curv = NULL,
+                        const Real surfTens = 0.)
+{
+  // compute divergence and init right hand side
+  MakeRhs kernMakeRhs(
+      flags, rhs, vel, perCellCorr, fractions, obvel, phi, curv, surfTens, gfClamp);
+
+  if (enforceCompatibility)
+    rhs += (Real)(-kernMakeRhs.sum / (Real)kernMakeRhs.cnt);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "computePressureRhs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &rhs = *_args.getPtr<Grid<Real>>("rhs", 0, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      const Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-3, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, 0, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 6, 0, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, 0, &_lock);
+      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 8, 0, &_lock);
+      Real gfClamp = _args.getOpt<Real>("gfClamp", 9, 1e-04, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 10, 1.5, &_lock);
+      bool precondition = _args.getOpt<bool>("precondition", 11, true, &_lock);
+      int preconditioner = _args.getOpt<int>("preconditioner", 12, PcMIC, &_lock);
+      bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 13, false, &_lock);
+      bool useL2Norm = _args.getOpt<bool>("useL2Norm", 14, false, &_lock);
+      bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 15, false, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 16, NULL, &_lock);
+      const Real surfTens = _args.getOpt<Real>("surfTens", 17, 0., &_lock);
+      _retval = getPyNone();
+      computePressureRhs(rhs,
+                         vel,
+                         pressure,
+                         flags,
+                         cgAccuracy,
+                         phi,
+                         perCellCorr,
+                         fractions,
+                         obvel,
+                         gfClamp,
+                         cgMaxIterFac,
+                         precondition,
+                         preconditioner,
+                         enforceCompatibility,
+                         useL2Norm,
+                         zeroPressureFixing,
+                         curv,
+                         surfTens);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "computePressureRhs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("computePressureRhs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_computePressureRhs("", "computePressureRhs", _W_1);
+extern "C" {
+void PbRegister_computePressureRhs()
+{
+  KEEP_UNUSED(_RP_computePressureRhs);
+}
+}
+
+//! Build and solve pressure system of equations
+//! perCellCorr: a divergence correction for each cell, optional
+//! fractions: for 2nd order obstacle boundaries, optional
+//! gfClamp: clamping threshold for ghost fluid method
+//! cgMaxIterFac: heuristic to determine maximal number of CG iteations, increase for more accurate
+//! solutions preconditioner: MIC, or MG (see Preconditioner enum) useL2Norm: use max norm by
+//! default, can be turned to L2 here zeroPressureFixing: remove null space by fixing a single
+//! pressure value, needed for MG curv: curvature for surface tension effects surfTens: surface
+//! tension coefficient retRhs: return RHS divergence, e.g., for debugging; optional
+
+void solvePressureSystem(Grid<Real> &rhs,
+                         MACGrid &vel,
+                         Grid<Real> &pressure,
+                         const FlagGrid &flags,
+                         Real cgAccuracy = 1e-3,
+                         const Grid<Real> *phi = 0,
+                         const Grid<Real> *perCellCorr = 0,
+                         const MACGrid *fractions = 0,
+                         Real gfClamp = 1e-04,
+                         Real cgMaxIterFac = 1.5,
+                         bool precondition = true,
+                         int preconditioner = PcMIC,
+                         const bool enforceCompatibility = false,
+                         const bool useL2Norm = false,
+                         const bool zeroPressureFixing = false,
+                         const Grid<Real> *curv = NULL,
+                         const Real surfTens = 0.)
+{
+  if (precondition == false)
+    preconditioner = PcNone;  // for backwards compatibility
+
+  // reserve temp grids
+  FluidSolver *parent = flags.getParent();
+  Grid<Real> residual(parent);
+  Grid<Real> search(parent);
+  Grid<Real> A0(parent);
+  Grid<Real> Ai(parent);
+  Grid<Real> Aj(parent);
+  Grid<Real> Ak(parent);
+  Grid<Real> tmp(parent);
+
+  // setup matrix and boundaries
+  MakeLaplaceMatrix(flags, A0, Ai, Aj, Ak, fractions);
+
+  if (phi) {
+    ApplyGhostFluidDiagonal(A0, flags, *phi, gfClamp);
+  }
+
+  // check whether we need to fix some pressure value...
+  // (manually enable, or automatically for high accuracy, can cause asymmetries otherwise)
+  if (zeroPressureFixing || cgAccuracy < 1e-07) {
+    if (FLOATINGPOINT_PRECISION == 1)
+      debMsg(
+          "Warning - high CG accuracy with single-precision floating point accuracy might not "
+          "converge...",
+          2);
+
+    int numEmpty = CountEmptyCells(flags);
+    IndexInt fixPidx = -1;
+    if (numEmpty == 0) {
+      // Determine appropriate fluid cell for pressure fixing
+      // 1) First check some preferred positions for approx. symmetric zeroPressureFixing
+      Vec3i topCenter(
+          flags.getSizeX() / 2, flags.getSizeY() - 1, flags.is3D() ? flags.getSizeZ() / 2 : 0);
+      Vec3i preferredPos[] = {topCenter, topCenter - Vec3i(0, 1, 0), topCenter - Vec3i(0, 2, 0)};
+
+      for (Vec3i pos : preferredPos) {
+        if (flags.isFluid(pos)) {
+          fixPidx = flags.index(pos);
+          break;
+        }
+      }
+
+      // 2) Then search whole domain
+      if (fixPidx == -1) {
+        FOR_IJK_BND(flags, 1)
+        {
+          if (flags.isFluid(i, j, k)) {
+            fixPidx = flags.index(i, j, k);
+            // break FOR_IJK_BND loop
+            i = flags.getSizeX() - 1;
+            j = flags.getSizeY() - 1;
+            k = __kmax;
+          }
+        }
+      }
+      // debMsg("No empty cells! Fixing pressure of cell "<<fixPidx<<" to zero",1);
+    }
+    if (fixPidx >= 0) {
+      fixPressure(fixPidx, Real(0), rhs, A0, Ai, Aj, Ak);
+      static bool msgOnce = false;
+      if (!msgOnce) {
+        debMsg("Pinning pressure of cell " << fixPidx << " to zero", 2);
+        msgOnce = true;
+      }
+    }
+  }
+
+  // CG setup
+  // note: the last factor increases the max iterations for 2d, which right now can't use a
+  // preconditioner
+  GridCgInterface *gcg;
+  if (vel.is3D())
+    gcg = new GridCg<ApplyMatrix>(pressure, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+  else
+    gcg = new GridCg<ApplyMatrix2D>(
+        pressure, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+
+  gcg->setAccuracy(cgAccuracy);
+  gcg->setUseL2Norm(useL2Norm);
+
+  int maxIter = 0;
+
+  Grid<Real> *pca0 = nullptr, *pca1 = nullptr, *pca2 = nullptr, *pca3 = nullptr;
+  GridMg *pmg = nullptr;
+
+  // optional preconditioning
+  if (preconditioner == PcNone || preconditioner == PcMIC) {
+    maxIter = (int)(cgMaxIterFac * flags.getSize().max()) * (flags.is3D() ? 1 : 4);
+
+    pca0 = new Grid<Real>(parent);
+    pca1 = new Grid<Real>(parent);
+    pca2 = new Grid<Real>(parent);
+    pca3 = new Grid<Real>(parent);
+
+    gcg->setICPreconditioner(preconditioner == PcMIC ? GridCgInterface::PC_mICP :
+                                                       GridCgInterface::PC_None,
+                             pca0,
+                             pca1,
+                             pca2,
+                             pca3);
+  }
+  else if (preconditioner == PcMGDynamic || preconditioner == PcMGStatic) {
+    maxIter = 100;
+
+    pmg = gMapMG[parent];
+    if (!pmg) {
+      pmg = new GridMg(pressure.getSize());
+      gMapMG[parent] = pmg;
+    }
+
+    gcg->setMGPreconditioner(GridCgInterface::PC_MGP, pmg);
+  }
+
+  // CG solve
+  for (int iter = 0; iter < maxIter; iter++) {
+    if (!gcg->iterate())
+      iter = maxIter;
+    if (iter < maxIter)
+      debMsg("FluidSolver::solvePressure iteration " << iter
+                                                     << ", residual: " << gcg->getResNorm(),
+             9);
+  }
+  debMsg("FluidSolver::solvePressure done. Iterations:" << gcg->getIterations()
+                                                        << ", residual:" << gcg->getResNorm(),
+         2);
+
+  // Cleanup
+  if (gcg)
+    delete gcg;
+  if (pca0)
+    delete pca0;
+  if (pca1)
+    delete pca1;
+  if (pca2)
+    delete pca2;
+  if (pca3)
+    delete pca3;
+
+  // PcMGDynamic: always delete multigrid solver after use
+  // PcMGStatic: keep multigrid solver for next solve
+  if (pmg && preconditioner == PcMGDynamic)
+    releaseMG(parent);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "solvePressureSystem", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &rhs = *_args.getPtr<Grid<Real>>("rhs", 0, &_lock);
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-3, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, 0, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 6, 0, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, 0, &_lock);
+      Real gfClamp = _args.getOpt<Real>("gfClamp", 8, 1e-04, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 9, 1.5, &_lock);
+      bool precondition = _args.getOpt<bool>("precondition", 10, true, &_lock);
+      int preconditioner = _args.getOpt<int>("preconditioner", 11, PcMIC, &_lock);
+      const bool enforceCompatibility = _args.getOpt<bool>(
+          "enforceCompatibility", 12, false, &_lock);
+      const bool useL2Norm = _args.getOpt<bool>("useL2Norm", 13, false, &_lock);
+      const bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 14, false, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, NULL, &_lock);
+      const Real surfTens = _args.getOpt<Real>("surfTens", 16, 0., &_lock);
+      _retval = getPyNone();
+      solvePressureSystem(rhs,
+                          vel,
+                          pressure,
+                          flags,
+                          cgAccuracy,
+                          phi,
+                          perCellCorr,
+                          fractions,
+                          gfClamp,
+                          cgMaxIterFac,
+                          precondition,
+                          preconditioner,
+                          enforceCompatibility,
+                          useL2Norm,
+                          zeroPressureFixing,
+                          curv,
+                          surfTens);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "solvePressureSystem", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("solvePressureSystem", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_solvePressureSystem("", "solvePressureSystem", _W_2);
+extern "C" {
+void PbRegister_solvePressureSystem()
+{
+  KEEP_UNUSED(_RP_solvePressureSystem);
+}
+}
+
+//! Apply pressure gradient to make velocity field divergence free
+
+void correctVelocity(MACGrid &vel,
+                     Grid<Real> &pressure,
+                     const FlagGrid &flags,
+                     Real cgAccuracy = 1e-3,
+                     const Grid<Real> *phi = 0,
+                     const Grid<Real> *perCellCorr = 0,
+                     const MACGrid *fractions = 0,
+                     Real gfClamp = 1e-04,
+                     Real cgMaxIterFac = 1.5,
+                     bool precondition = true,
+                     int preconditioner = PcMIC,
+                     bool enforceCompatibility = false,
+                     bool useL2Norm = false,
+                     bool zeroPressureFixing = false,
+                     const Grid<Real> *curv = NULL,
+                     const Real surfTens = 0.)
+{
+  knCorrectVelocity(flags, vel, pressure);
+  if (phi) {
+    knCorrectVelocityGhostFluid(vel, flags, pressure, *phi, gfClamp, curv, surfTens);
+    // improve behavior of clamping for large time steps:
+    knReplaceClampedGhostFluidVels(vel, flags, pressure, *phi, gfClamp);
+  }
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "correctVelocity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 3, 1e-3, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, 0, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 5, 0, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, 0, &_lock);
+      Real gfClamp = _args.getOpt<Real>("gfClamp", 7, 1e-04, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 8, 1.5, &_lock);
+      bool precondition = _args.getOpt<bool>("precondition", 9, true, &_lock);
+      int preconditioner = _args.getOpt<int>("preconditioner", 10, PcMIC, &_lock);
+      bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 11, false, &_lock);
+      bool useL2Norm = _args.getOpt<bool>("useL2Norm", 12, false, &_lock);
+      bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 13, false, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 14, NULL, &_lock);
+      const Real surfTens = _args.getOpt<Real>("surfTens", 15, 0., &_lock);
+      _retval = getPyNone();
+      correctVelocity(vel,
+                      pressure,
+                      flags,
+                      cgAccuracy,
+                      phi,
+                      perCellCorr,
+                      fractions,
+                      gfClamp,
+                      cgMaxIterFac,
+                      precondition,
+                      preconditioner,
+                      enforceCompatibility,
+                      useL2Norm,
+                      zeroPressureFixing,
+                      curv,
+                      surfTens);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "correctVelocity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("correctVelocity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_correctVelocity("", "correctVelocity", _W_3);
+extern "C" {
+void PbRegister_correctVelocity()
+{
+  KEEP_UNUSED(_RP_correctVelocity);
+}
+}
+
+//! Perform pressure projection of the velocity grid, calls
+//! all three pressure helper functions in a row.
+
+void solvePressure(MACGrid &vel,
+                   Grid<Real> &pressure,
+                   const FlagGrid &flags,
+                   Real cgAccuracy = 1e-3,
+                   const Grid<Real> *phi = 0,
+                   const Grid<Real> *perCellCorr = 0,
+                   const MACGrid *fractions = 0,
+                   const MACGrid *obvel = 0,
+                   Real gfClamp = 1e-04,
+                   Real cgMaxIterFac = 1.5,
+                   bool precondition = true,
+                   int preconditioner = PcMIC,
+                   bool enforceCompatibility = false,
+                   bool useL2Norm = false,
+                   bool zeroPressureFixing = false,
+                   const Grid<Real> *curv = NULL,
+                   const Real surfTens = 0.,
+                   Grid<Real> *retRhs = NULL)
+{
+  Grid<Real> rhs(vel.getParent());
+
+  computePressureRhs(rhs,
+                     vel,
+                     pressure,
+                     flags,
+                     cgAccuracy,
+                     phi,
+                     perCellCorr,
+                     fractions,
+                     obvel,
+                     gfClamp,
+                     cgMaxIterFac,
+                     precondition,
+                     preconditioner,
+                     enforceCompatibility,
+                     useL2Norm,
+                     zeroPressureFixing,
+                     curv,
+                     surfTens);
+
+  solvePressureSystem(rhs,
+                      vel,
+                      pressure,
+                      flags,
+                      cgAccuracy,
+                      phi,
+                      perCellCorr,
+                      fractions,
+                      gfClamp,
+                      cgMaxIterFac,
+                      precondition,
+                      preconditioner,
+                      enforceCompatibility,
+                      useL2Norm,
+                      zeroPressureFixing,
+                      curv,
+                      surfTens);
+
+  correctVelocity(vel,
+                  pressure,
+                  flags,
+                  cgAccuracy,
+                  phi,
+                  perCellCorr,
+                  fractions,
+                  gfClamp,
+                  cgMaxIterFac,
+                  precondition,
+                  preconditioner,
+                  enforceCompatibility,
+                  useL2Norm,
+                  zeroPressureFixing,
+                  curv,
+                  surfTens);
+
+  // optionally , return RHS
+  if (retRhs) {
+    retRhs->copyFrom(rhs);
+  }
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "solvePressure", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 1, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 3, 1e-3, &_lock);
+      const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, 0, &_lock);
+      const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 5, 0, &_lock);
+      const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, 0, &_lock);
+      const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 7, 0, &_lock);
+      Real gfClamp = _args.getOpt<Real>("gfClamp", 8, 1e-04, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 9, 1.5, &_lock);
+      bool precondition = _args.getOpt<bool>("precondition", 10, true, &_lock);
+      int preconditioner = _args.getOpt<int>("preconditioner", 11, PcMIC, &_lock);
+      bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 12, false, &_lock);
+      bool useL2Norm = _args.getOpt<bool>("useL2Norm", 13, false, &_lock);
+      bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 14, false, &_lock);
+      const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, NULL, &_lock);
+      const Real surfTens = _args.getOpt<Real>("surfTens", 16, 0., &_lock);
+      Grid<Real> *retRhs = _args.getPtrOpt<Grid<Real>>("retRhs", 17, NULL, &_lock);
+      _retval = getPyNone();
+      solvePressure(vel,
+                    pressure,
+                    flags,
+                    cgAccuracy,
+                    phi,
+                    perCellCorr,
+                    fractions,
+                    obvel,
+                    gfClamp,
+                    cgMaxIterFac,
+                    precondition,
+                    preconditioner,
+                    enforceCompatibility,
+                    useL2Norm,
+                    zeroPressureFixing,
+                    curv,
+                    surfTens,
+                    retRhs);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "solvePressure", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("solvePressure", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_solvePressure("", "solvePressure", _W_4);
+extern "C" {
+void PbRegister_solvePressure()
+{
+  KEEP_UNUSED(_RP_solvePressure);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp b/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp
new file mode 100644
index 00000000000..a6bbccc5966
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp
@@ -0,0 +1,502 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+// ----------------------------------------------------------------------------
+//
+// MantaFlow fluid solver framework
+// Copyright 2018 Kiwon Um, Nils Thuerey
+//
+// This program is free software, distributed under the terms of the
+// GNU General Public License (GPL)
+// http://www.gnu.org/licenses
+//
+// Particle system helper
+//
+// ----------------------------------------------------------------------------
+
+#include "particle.h"
+
+namespace Manta {
+
+struct KnAddForcePvel : public KernelBase {
+  KnAddForcePvel(ParticleDataImpl<Vec3> &v,
+                 const Vec3 &da,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude)
+      : KernelBase(v.size()), v(v), da(da), ptype(ptype), exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ParticleDataImpl<Vec3> &v,
+                 const Vec3 &da,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (ptype && ((*ptype)[idx] & exclude))
+      return;
+    v[idx] += da;
+  }
+  inline ParticleDataImpl<Vec3> &getArg0()
+  {
+    return v;
+  }
+  typedef ParticleDataImpl<Vec3> type0;
+  inline const Vec3 &getArg1()
+  {
+    return da;
+  }
+  typedef Vec3 type1;
+  inline const ParticleDataImpl<int> *getArg2()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type2;
+  inline const int &getArg3()
+  {
+    return exclude;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAddForcePvel ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, v, da, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<Vec3> &v;
+  const Vec3 &da;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+//! add force to vec3 particle data; a: acceleration
+
+void addForcePvel(ParticleDataImpl<Vec3> &vel,
+                  const Vec3 &a,
+                  const Real dt,
+                  const ParticleDataImpl<int> *ptype,
+                  const int exclude)
+{
+  KnAddForcePvel(vel, a * dt, ptype, exclude);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "addForcePvel", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 0, &_lock);
+      const Vec3 &a = _args.get<Vec3>("a", 1, &_lock);
+      const Real dt = _args.get<Real>("dt", 2, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtr<ParticleDataImpl<int>>("ptype", 3, &_lock);
+      const int exclude = _args.get<int>("exclude", 4, &_lock);
+      _retval = getPyNone();
+      addForcePvel(vel, a, dt, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "addForcePvel", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("addForcePvel", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_addForcePvel("", "addForcePvel", _W_0);
+extern "C" {
+void PbRegister_addForcePvel()
+{
+  KEEP_UNUSED(_RP_addForcePvel);
+}
+}
+
+struct KnUpdateVelocityFromDeltaPos : public KernelBase {
+  KnUpdateVelocityFromDeltaPos(const BasicParticleSystem &p,
+                               ParticleDataImpl<Vec3> &v,
+                               const ParticleDataImpl<Vec3> &x_prev,
+                               const Real over_dt,
+                               const ParticleDataImpl<int> *ptype,
+                               const int exclude)
+      : KernelBase(p.size()),
+        p(p),
+        v(v),
+        x_prev(x_prev),
+        over_dt(over_dt),
+        ptype(ptype),
+        exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystem &p,
+                 ParticleDataImpl<Vec3> &v,
+                 const ParticleDataImpl<Vec3> &x_prev,
+                 const Real over_dt,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (ptype && ((*ptype)[idx] & exclude))
+      return;
+    v[idx] = (p[idx].pos - x_prev[idx]) * over_dt;
+  }
+  inline const BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline ParticleDataImpl<Vec3> &getArg1()
+  {
+    return v;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline const ParticleDataImpl<Vec3> &getArg2()
+  {
+    return x_prev;
+  }
+  typedef ParticleDataImpl<Vec3> type2;
+  inline const Real &getArg3()
+  {
+    return over_dt;
+  }
+  typedef Real type3;
+  inline const ParticleDataImpl<int> *getArg4()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type4;
+  inline const int &getArg5()
+  {
+    return exclude;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnUpdateVelocityFromDeltaPos ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, v, x_prev, over_dt, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystem &p;
+  ParticleDataImpl<Vec3> &v;
+  const ParticleDataImpl<Vec3> &x_prev;
+  const Real over_dt;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+//! retrieve velocity from position change
+
+void updateVelocityFromDeltaPos(const BasicParticleSystem &parts,
+                                ParticleDataImpl<Vec3> &vel,
+                                const ParticleDataImpl<Vec3> &x_prev,
+                                const Real dt,
+                                const ParticleDataImpl<int> *ptype,
+                                const int exclude)
+{
+  KnUpdateVelocityFromDeltaPos(parts, vel, x_prev, 1.0 / dt, ptype, exclude);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "updateVelocityFromDeltaPos", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 1, &_lock);
+      const ParticleDataImpl<Vec3> &x_prev = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "x_prev", 2, &_lock);
+      const Real dt = _args.get<Real>("dt", 3, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtr<ParticleDataImpl<int>>("ptype", 4, &_lock);
+      const int exclude = _args.get<int>("exclude", 5, &_lock);
+      _retval = getPyNone();
+      updateVelocityFromDeltaPos(parts, vel, x_prev, dt, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "updateVelocityFromDeltaPos", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("updateVelocityFromDeltaPos", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_updateVelocityFromDeltaPos("", "updateVelocityFromDeltaPos", _W_1);
+extern "C" {
+void PbRegister_updateVelocityFromDeltaPos()
+{
+  KEEP_UNUSED(_RP_updateVelocityFromDeltaPos);
+}
+}
+
+struct KnStepEuler : public KernelBase {
+  KnStepEuler(BasicParticleSystem &p,
+              const ParticleDataImpl<Vec3> &v,
+              const Real dt,
+              const ParticleDataImpl<int> *ptype,
+              const int exclude)
+      : KernelBase(p.size()), p(p), v(v), dt(dt), ptype(ptype), exclude(exclude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 BasicParticleSystem &p,
+                 const ParticleDataImpl<Vec3> &v,
+                 const Real dt,
+                 const ParticleDataImpl<int> *ptype,
+                 const int exclude) const
+  {
+    if (ptype && ((*ptype)[idx] & exclude))
+      return;
+    p[idx].pos += v[idx] * dt;
+  }
+  inline BasicParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef BasicParticleSystem type0;
+  inline const ParticleDataImpl<Vec3> &getArg1()
+  {
+    return v;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline const Real &getArg2()
+  {
+    return dt;
+  }
+  typedef Real type2;
+  inline const ParticleDataImpl<int> *getArg3()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type3;
+  inline const int &getArg4()
+  {
+    return exclude;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnStepEuler ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, v, dt, ptype, exclude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystem &p;
+  const ParticleDataImpl<Vec3> &v;
+  const Real dt;
+  const ParticleDataImpl<int> *ptype;
+  const int exclude;
+};
+//! simple foward Euler integration for particle system
+
+void eulerStep(BasicParticleSystem &parts,
+               const ParticleDataImpl<Vec3> &vel,
+               const ParticleDataImpl<int> *ptype,
+               const int exclude)
+{
+  KnStepEuler(parts, vel, parts.getParent()->getDt(), ptype, exclude);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "eulerStep", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 1, &_lock);
+      const ParticleDataImpl<int> *ptype = _args.getPtr<ParticleDataImpl<int>>("ptype", 2, &_lock);
+      const int exclude = _args.get<int>("exclude", 3, &_lock);
+      _retval = getPyNone();
+      eulerStep(parts, vel, ptype, exclude);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "eulerStep", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("eulerStep", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_eulerStep("", "eulerStep", _W_2);
+extern "C" {
+void PbRegister_eulerStep()
+{
+  KEEP_UNUSED(_RP_eulerStep);
+}
+}
+
+struct KnSetPartType : public KernelBase {
+  KnSetPartType(ParticleDataImpl<int> &ptype,
+                const BasicParticleSystem &part,
+                const int mark,
+                const int stype,
+                const FlagGrid &flags,
+                const int cflag)
+      : KernelBase(ptype.size()),
+        ptype(ptype),
+        part(part),
+        mark(mark),
+        stype(stype),
+        flags(flags),
+        cflag(cflag)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 ParticleDataImpl<int> &ptype,
+                 const BasicParticleSystem &part,
+                 const int mark,
+                 const int stype,
+                 const FlagGrid &flags,
+                 const int cflag) const
+  {
+    if (flags.isInBounds(part.getPos(idx), 0) && (flags.getAt(part.getPos(idx)) & cflag) &&
+        (ptype[idx] & stype))
+      ptype[idx] = mark;
+  }
+  inline ParticleDataImpl<int> &getArg0()
+  {
+    return ptype;
+  }
+  typedef ParticleDataImpl<int> type0;
+  inline const BasicParticleSystem &getArg1()
+  {
+    return part;
+  }
+  typedef BasicParticleSystem type1;
+  inline const int &getArg2()
+  {
+    return mark;
+  }
+  typedef int type2;
+  inline const int &getArg3()
+  {
+    return stype;
+  }
+  typedef int type3;
+  inline const FlagGrid &getArg4()
+  {
+    return flags;
+  }
+  typedef FlagGrid type4;
+  inline const int &getArg5()
+  {
+    return cflag;
+  }
+  typedef int type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnSetPartType ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, ptype, part, mark, stype, flags, cflag);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  ParticleDataImpl<int> &ptype;
+  const BasicParticleSystem &part;
+  const int mark;
+  const int stype;
+  const FlagGrid &flags;
+  const int cflag;
+};
+//! if particle is stype and in cflag cell, set ptype as mark
+
+void setPartType(const BasicParticleSystem &parts,
+                 ParticleDataImpl<int> &ptype,
+                 const int mark,
+                 const int stype,
+                 const FlagGrid &flags,
+                 const int cflag)
+{
+  KnSetPartType(ptype, parts, mark, stype, flags, cflag);
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setPartType", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      ParticleDataImpl<int> &ptype = *_args.getPtr<ParticleDataImpl<int>>("ptype", 1, &_lock);
+      const int mark = _args.get<int>("mark", 2, &_lock);
+      const int stype = _args.get<int>("stype", 3, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 4, &_lock);
+      const int cflag = _args.get<int>("cflag", 5, &_lock);
+      _retval = getPyNone();
+      setPartType(parts, ptype, mark, stype, flags, cflag);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setPartType", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setPartType", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setPartType("", "setPartType", _W_3);
+extern "C" {
+void PbRegister_setPartType()
+{
+  KEEP_UNUSED(_RP_setPartType);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/secondaryparticles.cpp b/extern/mantaflow/preprocessed/plugin/secondaryparticles.cpp
new file mode 100644
index 00000000000..281e12ef04b
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/secondaryparticles.cpp
@@ -0,0 +1,3065 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2017 Georg Kohl, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * GNU General Public License (GPL)
+ * http://www.gnu.org/licenses
+ *
+ * Secondary particle plugin for FLIP simulations
+ *
+ ******************************************************************************/
+
+#include "particle.h"
+#include "commonkernels.h"
+
+namespace Manta {
+
+#pragma region Secondary Particles for FLIP
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+// Secondary Particles for FLIP
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+
+// helper function that clamps the value in potential to the interval [tauMin, tauMax] and
+// normalizes it to [0, 1] afterwards
+Real clampPotential(Real potential, Real tauMin, Real tauMax)
+{
+  return (std::min(potential, tauMax) - std::min(potential, tauMin)) / (tauMax - tauMin);
+}
+
+// computes all three potentials(trapped air, wave crest, kinetic energy) and the neighbor ratio
+// for every fluid cell and stores it in the respective grid. Is less readable but significantly
+// faster than using seperate potential computation
+
+struct knFlipComputeSecondaryParticlePotentials : public KernelBase {
+  knFlipComputeSecondaryParticlePotentials(Grid<Real> &potTA,
+                                           Grid<Real> &potWC,
+                                           Grid<Real> &potKE,
+                                           Grid<Real> &neighborRatio,
+                                           const FlagGrid &flags,
+                                           const MACGrid &v,
+                                           const Grid<Vec3> &normal,
+                                           const int radius,
+                                           const Real tauMinTA,
+                                           const Real tauMaxTA,
+                                           const Real tauMinWC,
+                                           const Real tauMaxWC,
+                                           const Real tauMinKE,
+                                           const Real tauMaxKE,
+                                           const Real scaleFromManta,
+                                           const int itype = FlagGrid::TypeFluid,
+                                           const int jtype = FlagGrid::TypeObstacle |
+                                                             FlagGrid::TypeOutflow |
+                                                             FlagGrid::TypeInflow)
+      : KernelBase(&potTA, radius),
+        potTA(potTA),
+        potWC(potWC),
+        potKE(potKE),
+        neighborRatio(neighborRatio),
+        flags(flags),
+        v(v),
+        normal(normal),
+        radius(radius),
+        tauMinTA(tauMinTA),
+        tauMaxTA(tauMaxTA),
+        tauMinWC(tauMinWC),
+        tauMaxWC(tauMaxWC),
+        tauMinKE(tauMinKE),
+        tauMaxKE(tauMaxKE),
+        scaleFromManta(scaleFromManta),
+        itype(itype),
+        jtype(jtype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Real> &potTA,
+                 Grid<Real> &potWC,
+                 Grid<Real> &potKE,
+                 Grid<Real> &neighborRatio,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 const Grid<Vec3> &normal,
+                 const int radius,
+                 const Real tauMinTA,
+                 const Real tauMaxTA,
+                 const Real tauMinWC,
+                 const Real tauMaxWC,
+                 const Real tauMinKE,
+                 const Real tauMaxKE,
+                 const Real scaleFromManta,
+                 const int itype = FlagGrid::TypeFluid,
+                 const int jtype = FlagGrid::TypeObstacle | FlagGrid::TypeOutflow |
+                                   FlagGrid::TypeInflow) const
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    // compute trapped air potential + wave crest potential + neighbor ratio at once
+    const Vec3 &xi = scaleFromManta * Vec3(i, j, k);  // scale to unit cube
+    const Vec3 &vi = scaleFromManta * v.getCentered(i, j, k);
+    const Vec3 &ni = getNormalized(normal(i, j, k));
+    Real vdiff = 0;         // for trapped air
+    Real kappa = 0;         // for wave crests
+    int countFluid = 0;     // for neighbor ratio
+    int countMaxFluid = 0;  // for neighbor ratio
+
+    // iterate over neighboring cells within radius
+    for (IndexInt x = i - radius; x <= i + radius; x++) {
+      for (IndexInt y = j - radius; y <= j + radius; y++) {
+        for (IndexInt z = k - radius; z <= k + radius; z++) {
+          if ((x == i && y == j && z == k) || !flags.isInBounds(Vec3i(x, y, z)) ||
+              (flags(x, y, z) & jtype))
+            continue;
+
+          if (flags(x, y, z) & itype) {
+            countFluid++;
+            countMaxFluid++;
+          }
+          else {
+            countMaxFluid++;
+          }
+
+          const Vec3 &xj = scaleFromManta * Vec3(x, y, z);  // scale to unit cube
+          const Vec3 &vj = scaleFromManta * v.getCentered(x, y, z);
+          const Vec3 &nj = getNormalized(normal(x, y, z));
+          const Vec3 xij = xi - xj;
+          const Vec3 vij = vi - vj;
+          Real h = !potTA.is3D() ?
+                       1.414 * radius :
+                       1.732 * radius;  // estimate sqrt(2)*radius resp. sqrt(3)*radius for h, due
+                                        // to squared resp. cubic neighbor area
+          vdiff += norm(vij) * (1 - dot(getNormalized(vij), getNormalized(xij))) *
+                   (1 - norm(xij) / h);
+
+          if (dot(getNormalized(xij), ni) < 0) {  // identifies wave crests
+            kappa += (1 - dot(ni, nj)) * (1 - norm(xij) / h);
+          }
+        }
+      }
+    }
+
+    neighborRatio(i, j, k) = float(countFluid) / float(countMaxFluid);
+
+    potTA(i, j, k) = clampPotential(vdiff, tauMinTA, tauMaxTA);
+    if (dot(getNormalized(vi), ni) >= 0.6) {  // avoid to mark boarders of the scene as wave crest
+      potWC(i, j, k) = clampPotential(kappa, tauMinWC, tauMaxWC);
+    }
+    else {
+      potWC(i, j, k) = Real(0);
+    }
+
+    // compute kinetic energy potential
+    Real ek =
+        Real(0.5) * 125 *
+        normSquare(
+            vi);  // use arbitrary constant for mass, potential adjusts with thresholds anyways
+    potKE(i, j, k) = clampPotential(ek, tauMinKE, tauMaxKE);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return potTA;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return potWC;
+  }
+  typedef Grid<Real> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return potKE;
+  }
+  typedef Grid<Real> type2;
+  inline Grid<Real> &getArg3()
+  {
+    return neighborRatio;
+  }
+  typedef Grid<Real> type3;
+  inline const FlagGrid &getArg4()
+  {
+    return flags;
+  }
+  typedef FlagGrid type4;
+  inline const MACGrid &getArg5()
+  {
+    return v;
+  }
+  typedef MACGrid type5;
+  inline const Grid<Vec3> &getArg6()
+  {
+    return normal;
+  }
+  typedef Grid<Vec3> type6;
+  inline const int &getArg7()
+  {
+    return radius;
+  }
+  typedef int type7;
+  inline const Real &getArg8()
+  {
+    return tauMinTA;
+  }
+  typedef Real type8;
+  inline const Real &getArg9()
+  {
+    return tauMaxTA;
+  }
+  typedef Real type9;
+  inline const Real &getArg10()
+  {
+    return tauMinWC;
+  }
+  typedef Real type10;
+  inline const Real &getArg11()
+  {
+    return tauMaxWC;
+  }
+  typedef Real type11;
+  inline const Real &getArg12()
+  {
+    return tauMinKE;
+  }
+  typedef Real type12;
+  inline const Real &getArg13()
+  {
+    return tauMaxKE;
+  }
+  typedef Real type13;
+  inline const Real &getArg14()
+  {
+    return scaleFromManta;
+  }
+  typedef Real type14;
+  inline const int &getArg15()
+  {
+    return itype;
+  }
+  typedef int type15;
+  inline const int &getArg16()
+  {
+    return jtype;
+  }
+  typedef int type16;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipComputeSecondaryParticlePotentials ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = radius; j < _maxY; j++)
+          for (int i = radius; i < _maxX; i++)
+            op(i,
+               j,
+               k,
+               potTA,
+               potWC,
+               potKE,
+               neighborRatio,
+               flags,
+               v,
+               normal,
+               radius,
+               tauMinTA,
+               tauMaxTA,
+               tauMinWC,
+               tauMaxWC,
+               tauMinKE,
+               tauMaxKE,
+               scaleFromManta,
+               itype,
+               jtype);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = radius; i < _maxX; i++)
+          op(i,
+             j,
+             k,
+             potTA,
+             potWC,
+             potKE,
+             neighborRatio,
+             flags,
+             v,
+             normal,
+             radius,
+             tauMinTA,
+             tauMaxTA,
+             tauMinWC,
+             tauMaxWC,
+             tauMinKE,
+             tauMaxKE,
+             scaleFromManta,
+             itype,
+             jtype);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(radius, maxY), *this);
+  }
+  Grid<Real> &potTA;
+  Grid<Real> &potWC;
+  Grid<Real> &potKE;
+  Grid<Real> &neighborRatio;
+  const FlagGrid &flags;
+  const MACGrid &v;
+  const Grid<Vec3> &normal;
+  const int radius;
+  const Real tauMinTA;
+  const Real tauMaxTA;
+  const Real tauMinWC;
+  const Real tauMaxWC;
+  const Real tauMinKE;
+  const Real tauMaxKE;
+  const Real scaleFromManta;
+  const int itype;
+  const int jtype;
+};
+
+void flipComputeSecondaryParticlePotentials(Grid<Real> &potTA,
+                                            Grid<Real> &potWC,
+                                            Grid<Real> &potKE,
+                                            Grid<Real> &neighborRatio,
+                                            const FlagGrid &flags,
+                                            const MACGrid &v,
+                                            Grid<Vec3> &normal,
+                                            const Grid<Real> &phi,
+                                            const int radius,
+                                            const Real tauMinTA,
+                                            const Real tauMaxTA,
+                                            const Real tauMinWC,
+                                            const Real tauMaxWC,
+                                            const Real tauMinKE,
+                                            const Real tauMaxKE,
+                                            const Real scaleFromManta,
+                                            const int itype = FlagGrid::TypeFluid,
+                                            const int jtype = FlagGrid::TypeObstacle |
+                                                              FlagGrid::TypeOutflow |
+                                                              FlagGrid::TypeInflow)
+{
+  potTA.clear();
+  potWC.clear();
+  potKE.clear();
+  neighborRatio.clear();
+  GradientOp(normal, phi);
+  knFlipComputeSecondaryParticlePotentials(potTA,
+                                           potWC,
+                                           potKE,
+                                           neighborRatio,
+                                           flags,
+                                           v,
+                                           normal,
+                                           radius,
+                                           tauMinTA,
+                                           tauMaxTA,
+                                           tauMinWC,
+                                           tauMaxWC,
+                                           tauMinKE,
+                                           tauMaxKE,
+                                           scaleFromManta,
+                                           itype,
+                                           jtype);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipComputeSecondaryParticlePotentials", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &potTA = *_args.getPtr<Grid<Real>>("potTA", 0, &_lock);
+      Grid<Real> &potWC = *_args.getPtr<Grid<Real>>("potWC", 1, &_lock);
+      Grid<Real> &potKE = *_args.getPtr<Grid<Real>>("potKE", 2, &_lock);
+      Grid<Real> &neighborRatio = *_args.getPtr<Grid<Real>>("neighborRatio", 3, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 4, &_lock);
+      const MACGrid &v = *_args.getPtr<MACGrid>("v", 5, &_lock);
+      Grid<Vec3> &normal = *_args.getPtr<Grid<Vec3>>("normal", 6, &_lock);
+      const Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 7, &_lock);
+      const int radius = _args.get<int>("radius", 8, &_lock);
+      const Real tauMinTA = _args.get<Real>("tauMinTA", 9, &_lock);
+      const Real tauMaxTA = _args.get<Real>("tauMaxTA", 10, &_lock);
+      const Real tauMinWC = _args.get<Real>("tauMinWC", 11, &_lock);
+      const Real tauMaxWC = _args.get<Real>("tauMaxWC", 12, &_lock);
+      const Real tauMinKE = _args.get<Real>("tauMinKE", 13, &_lock);
+      const Real tauMaxKE = _args.get<Real>("tauMaxKE", 14, &_lock);
+      const Real scaleFromManta = _args.get<Real>("scaleFromManta", 15, &_lock);
+      const int itype = _args.getOpt<int>("itype", 16, FlagGrid::TypeFluid, &_lock);
+      const int jtype = _args.getOpt<int>("jtype",
+                                          17,
+                                          FlagGrid::TypeObstacle | FlagGrid::TypeOutflow |
+                                              FlagGrid::TypeInflow,
+                                          &_lock);
+      _retval = getPyNone();
+      flipComputeSecondaryParticlePotentials(potTA,
+                                             potWC,
+                                             potKE,
+                                             neighborRatio,
+                                             flags,
+                                             v,
+                                             normal,
+                                             phi,
+                                             radius,
+                                             tauMinTA,
+                                             tauMaxTA,
+                                             tauMinWC,
+                                             tauMaxWC,
+                                             tauMinKE,
+                                             tauMaxKE,
+                                             scaleFromManta,
+                                             itype,
+                                             jtype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipComputeSecondaryParticlePotentials", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipComputeSecondaryParticlePotentials", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipComputeSecondaryParticlePotentials(
+    "", "flipComputeSecondaryParticlePotentials", _W_0);
+extern "C" {
+void PbRegister_flipComputeSecondaryParticlePotentials()
+{
+  KEEP_UNUSED(_RP_flipComputeSecondaryParticlePotentials);
+}
+}
+
+// adds secondary particles to &pts_sec for every fluid cell in &flags according to the potential
+// grids &potTA, &potWC and &potKE secondary particles are uniformly sampled in every fluid cell in
+// a randomly offset cylinder in fluid movement direction In contrast to
+// flipSampleSecondaryParticles this uses more cylinders per cell and interpolates velocity and
+// potentials. To control number of cylinders in each dimension adjust radius(0.25=>2 cyl,
+// 0.1666=>3 cyl, 0.125=>3cyl etc.).
+
+struct knFlipSampleSecondaryParticlesMoreCylinders : public KernelBase {
+  knFlipSampleSecondaryParticlesMoreCylinders(const FlagGrid &flags,
+                                              const MACGrid &v,
+                                              BasicParticleSystem &pts_sec,
+                                              ParticleDataImpl<Vec3> &v_sec,
+                                              ParticleDataImpl<Real> &l_sec,
+                                              const Real lMin,
+                                              const Real lMax,
+                                              const Grid<Real> &potTA,
+                                              const Grid<Real> &potWC,
+                                              const Grid<Real> &potKE,
+                                              const Grid<Real> &neighborRatio,
+                                              const Real c_s,
+                                              const Real c_b,
+                                              const Real k_ta,
+                                              const Real k_wc,
+                                              const Real dt,
+                                              const int itype = FlagGrid::TypeFluid)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        v(v),
+        pts_sec(pts_sec),
+        v_sec(v_sec),
+        l_sec(l_sec),
+        lMin(lMin),
+        lMax(lMax),
+        potTA(potTA),
+        potWC(potWC),
+        potKE(potKE),
+        neighborRatio(neighborRatio),
+        c_s(c_s),
+        c_b(c_b),
+        k_ta(k_ta),
+        k_wc(k_wc),
+        dt(dt),
+        itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 BasicParticleSystem &pts_sec,
+                 ParticleDataImpl<Vec3> &v_sec,
+                 ParticleDataImpl<Real> &l_sec,
+                 const Real lMin,
+                 const Real lMax,
+                 const Grid<Real> &potTA,
+                 const Grid<Real> &potWC,
+                 const Grid<Real> &potKE,
+                 const Grid<Real> &neighborRatio,
+                 const Real c_s,
+                 const Real c_b,
+                 const Real k_ta,
+                 const Real k_wc,
+                 const Real dt,
+                 const int itype = FlagGrid::TypeFluid)
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    RandomStream mRand(9832);
+    Real radius =
+        0.25;  // diameter=0.5 => sampling with two cylinders in each dimension since cell size=1
+    for (Real x = i - radius; x <= i + radius; x += 2 * radius) {
+      for (Real y = j - radius; y <= j + radius; y += 2 * radius) {
+        for (Real z = k - radius; z <= k + radius; z += 2 * radius) {
+
+          Vec3 xi = Vec3(x, y, z);
+          Real KE = potKE.getInterpolated(xi);
+          Real TA = potTA.getInterpolated(xi);
+          Real WC = potWC.getInterpolated(xi);
+
+          const int n = KE * (k_ta * TA + k_wc * WC) * dt;  // number of secondary particles
+          if (n == 0)
+            continue;
+          Vec3 vi = v.getInterpolated(xi);
+          Vec3 dir = dt * vi;  // direction of movement of current particle
+          Vec3 e1 = getNormalized(Vec3(dir.z, 0, -dir.x));  // perpendicular to dir
+          Vec3 e2 = getNormalized(
+              cross(e1, dir));  // perpendicular to dir and e1, so e1 and e1 create reference plane
+
+          for (int di = 0; di < n; di++) {
+            const Real r = radius * sqrt(mRand.getReal());        // distance to cylinder axis
+            const Real theta = mRand.getReal() * Real(2) * M_PI;  // azimuth
+            const Real h = mRand.getReal() * norm(dt * vi);       // distance to reference plane
+            Vec3 xd = xi + r * cos(theta) * e1 + r * sin(theta) * e2 + h * getNormalized(vi);
+            if (!flags.is3D())
+              xd.z = 0;
+            pts_sec.add(xd);
+
+            v_sec[v_sec.size() - 1] = r * cos(theta) * e1 + r * sin(theta) * e2 +
+                                      vi;  // init velocity of new particle
+            Real temp = (KE + TA + WC) / 3;
+            l_sec[l_sec.size() - 1] = ((lMax - lMin) * temp) + lMin +
+                                      mRand.getReal() * 0.1;  // init lifetime of new particle
+
+            // init type of new particle
+            if (neighborRatio(i, j, k) < c_s) {
+              pts_sec[pts_sec.size() - 1].flag = ParticleBase::PSPRAY;
+            }
+            else if (neighborRatio(i, j, k) > c_b) {
+              pts_sec[pts_sec.size() - 1].flag = ParticleBase::PBUBBLE;
+            }
+            else {
+              pts_sec[pts_sec.size() - 1].flag = ParticleBase::PFOAM;
+            }
+          }
+        }
+      }
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return v;
+  }
+  typedef MACGrid type1;
+  inline BasicParticleSystem &getArg2()
+  {
+    return pts_sec;
+  }
+  typedef BasicParticleSystem type2;
+  inline ParticleDataImpl<Vec3> &getArg3()
+  {
+    return v_sec;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline ParticleDataImpl<Real> &getArg4()
+  {
+    return l_sec;
+  }
+  typedef ParticleDataImpl<Real> type4;
+  inline const Real &getArg5()
+  {
+    return lMin;
+  }
+  typedef Real type5;
+  inline const Real &getArg6()
+  {
+    return lMax;
+  }
+  typedef Real type6;
+  inline const Grid<Real> &getArg7()
+  {
+    return potTA;
+  }
+  typedef Grid<Real> type7;
+  inline const Grid<Real> &getArg8()
+  {
+    return potWC;
+  }
+  typedef Grid<Real> type8;
+  inline const Grid<Real> &getArg9()
+  {
+    return potKE;
+  }
+  typedef Grid<Real> type9;
+  inline const Grid<Real> &getArg10()
+  {
+    return neighborRatio;
+  }
+  typedef Grid<Real> type10;
+  inline const Real &getArg11()
+  {
+    return c_s;
+  }
+  typedef Real type11;
+  inline const Real &getArg12()
+  {
+    return c_b;
+  }
+  typedef Real type12;
+  inline const Real &getArg13()
+  {
+    return k_ta;
+  }
+  typedef Real type13;
+  inline const Real &getArg14()
+  {
+    return k_wc;
+  }
+  typedef Real type14;
+  inline const Real &getArg15()
+  {
+    return dt;
+  }
+  typedef Real type15;
+  inline const int &getArg16()
+  {
+    return itype;
+  }
+  typedef int type16;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipSampleSecondaryParticlesMoreCylinders ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void run()
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    for (int k = minZ; k < maxZ; k++)
+      for (int j = 0; j < _maxY; j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i,
+             j,
+             k,
+             flags,
+             v,
+             pts_sec,
+             v_sec,
+             l_sec,
+             lMin,
+             lMax,
+             potTA,
+             potWC,
+             potKE,
+             neighborRatio,
+             c_s,
+             c_b,
+             k_ta,
+             k_wc,
+             dt,
+             itype);
+  }
+  const FlagGrid &flags;
+  const MACGrid &v;
+  BasicParticleSystem &pts_sec;
+  ParticleDataImpl<Vec3> &v_sec;
+  ParticleDataImpl<Real> &l_sec;
+  const Real lMin;
+  const Real lMax;
+  const Grid<Real> &potTA;
+  const Grid<Real> &potWC;
+  const Grid<Real> &potKE;
+  const Grid<Real> &neighborRatio;
+  const Real c_s;
+  const Real c_b;
+  const Real k_ta;
+  const Real k_wc;
+  const Real dt;
+  const int itype;
+};
+
+// adds secondary particles to &pts_sec for every fluid cell in &flags according to the potential
+// grids &potTA, &potWC and &potKE secondary particles are uniformly sampled in every fluid cell in
+// a randomly offset cylinder in fluid movement direction
+
+struct knFlipSampleSecondaryParticles : public KernelBase {
+  knFlipSampleSecondaryParticles(const FlagGrid &flags,
+                                 const MACGrid &v,
+                                 BasicParticleSystem &pts_sec,
+                                 ParticleDataImpl<Vec3> &v_sec,
+                                 ParticleDataImpl<Real> &l_sec,
+                                 const Real lMin,
+                                 const Real lMax,
+                                 const Grid<Real> &potTA,
+                                 const Grid<Real> &potWC,
+                                 const Grid<Real> &potKE,
+                                 const Grid<Real> &neighborRatio,
+                                 const Real c_s,
+                                 const Real c_b,
+                                 const Real k_ta,
+                                 const Real k_wc,
+                                 const Real dt,
+                                 const int itype = FlagGrid::TypeFluid)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        v(v),
+        pts_sec(pts_sec),
+        v_sec(v_sec),
+        l_sec(l_sec),
+        lMin(lMin),
+        lMax(lMax),
+        potTA(potTA),
+        potWC(potWC),
+        potKE(potKE),
+        neighborRatio(neighborRatio),
+        c_s(c_s),
+        c_b(c_b),
+        k_ta(k_ta),
+        k_wc(k_wc),
+        dt(dt),
+        itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 BasicParticleSystem &pts_sec,
+                 ParticleDataImpl<Vec3> &v_sec,
+                 ParticleDataImpl<Real> &l_sec,
+                 const Real lMin,
+                 const Real lMax,
+                 const Grid<Real> &potTA,
+                 const Grid<Real> &potWC,
+                 const Grid<Real> &potKE,
+                 const Grid<Real> &neighborRatio,
+                 const Real c_s,
+                 const Real c_b,
+                 const Real k_ta,
+                 const Real k_wc,
+                 const Real dt,
+                 const int itype = FlagGrid::TypeFluid)
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    Real KE = potKE(i, j, k);
+    Real TA = potTA(i, j, k);
+    Real WC = potWC(i, j, k);
+
+    const int n = KE * (k_ta * TA + k_wc * WC) * dt;  // number of secondary particles
+    if (n == 0)
+      return;
+    RandomStream mRand(9832);
+
+    Vec3 xi = Vec3(i + mRand.getReal(),
+                   j + mRand.getReal(),
+                   k + mRand.getReal());  // randomized offset uniform in cell
+    Vec3 vi = v.getInterpolated(xi);
+    Vec3 dir = dt * vi;                               // direction of movement of current particle
+    Vec3 e1 = getNormalized(Vec3(dir.z, 0, -dir.x));  // perpendicular to dir
+    Vec3 e2 = getNormalized(
+        cross(e1, dir));  // perpendicular to dir and e1, so e1 and e1 create reference plane
+
+    for (int di = 0; di < n; di++) {
+      const Real r = Real(0.5) * sqrt(mRand.getReal());     // distance to cylinder axis
+      const Real theta = mRand.getReal() * Real(2) * M_PI;  // azimuth
+      const Real h = mRand.getReal() * norm(dt * vi);       // distance to reference plane
+      Vec3 xd = xi + r * cos(theta) * e1 + r * sin(theta) * e2 + h * getNormalized(vi);
+      if (!flags.is3D())
+        xd.z = 0;
+      pts_sec.add(xd);
+
+      v_sec[v_sec.size() - 1] = r * cos(theta) * e1 + r * sin(theta) * e2 +
+                                vi;  // init velocity of new particle
+      Real temp = (KE + TA + WC) / 3;
+      l_sec[l_sec.size() - 1] = ((lMax - lMin) * temp) + lMin +
+                                mRand.getReal() * 0.1;  // init lifetime of new particle
+
+      // init type of new particle
+      if (neighborRatio(i, j, k) < c_s) {
+        pts_sec[pts_sec.size() - 1].flag = ParticleBase::PSPRAY;
+      }
+      else if (neighborRatio(i, j, k) > c_b) {
+        pts_sec[pts_sec.size() - 1].flag = ParticleBase::PBUBBLE;
+      }
+      else {
+        pts_sec[pts_sec.size() - 1].flag = ParticleBase::PFOAM;
+      }
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return v;
+  }
+  typedef MACGrid type1;
+  inline BasicParticleSystem &getArg2()
+  {
+    return pts_sec;
+  }
+  typedef BasicParticleSystem type2;
+  inline ParticleDataImpl<Vec3> &getArg3()
+  {
+    return v_sec;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline ParticleDataImpl<Real> &getArg4()
+  {
+    return l_sec;
+  }
+  typedef ParticleDataImpl<Real> type4;
+  inline const Real &getArg5()
+  {
+    return lMin;
+  }
+  typedef Real type5;
+  inline const Real &getArg6()
+  {
+    return lMax;
+  }
+  typedef Real type6;
+  inline const Grid<Real> &getArg7()
+  {
+    return potTA;
+  }
+  typedef Grid<Real> type7;
+  inline const Grid<Real> &getArg8()
+  {
+    return potWC;
+  }
+  typedef Grid<Real> type8;
+  inline const Grid<Real> &getArg9()
+  {
+    return potKE;
+  }
+  typedef Grid<Real> type9;
+  inline const Grid<Real> &getArg10()
+  {
+    return neighborRatio;
+  }
+  typedef Grid<Real> type10;
+  inline const Real &getArg11()
+  {
+    return c_s;
+  }
+  typedef Real type11;
+  inline const Real &getArg12()
+  {
+    return c_b;
+  }
+  typedef Real type12;
+  inline const Real &getArg13()
+  {
+    return k_ta;
+  }
+  typedef Real type13;
+  inline const Real &getArg14()
+  {
+    return k_wc;
+  }
+  typedef Real type14;
+  inline const Real &getArg15()
+  {
+    return dt;
+  }
+  typedef Real type15;
+  inline const int &getArg16()
+  {
+    return itype;
+  }
+  typedef int type16;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipSampleSecondaryParticles ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void run()
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    for (int k = minZ; k < maxZ; k++)
+      for (int j = 0; j < _maxY; j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i,
+             j,
+             k,
+             flags,
+             v,
+             pts_sec,
+             v_sec,
+             l_sec,
+             lMin,
+             lMax,
+             potTA,
+             potWC,
+             potKE,
+             neighborRatio,
+             c_s,
+             c_b,
+             k_ta,
+             k_wc,
+             dt,
+             itype);
+  }
+  const FlagGrid &flags;
+  const MACGrid &v;
+  BasicParticleSystem &pts_sec;
+  ParticleDataImpl<Vec3> &v_sec;
+  ParticleDataImpl<Real> &l_sec;
+  const Real lMin;
+  const Real lMax;
+  const Grid<Real> &potTA;
+  const Grid<Real> &potWC;
+  const Grid<Real> &potKE;
+  const Grid<Real> &neighborRatio;
+  const Real c_s;
+  const Real c_b;
+  const Real k_ta;
+  const Real k_wc;
+  const Real dt;
+  const int itype;
+};
+
+void flipSampleSecondaryParticles(const std::string mode,
+                                  const FlagGrid &flags,
+                                  const MACGrid &v,
+                                  BasicParticleSystem &pts_sec,
+                                  ParticleDataImpl<Vec3> &v_sec,
+                                  ParticleDataImpl<Real> &l_sec,
+                                  const Real lMin,
+                                  const Real lMax,
+                                  const Grid<Real> &potTA,
+                                  const Grid<Real> &potWC,
+                                  const Grid<Real> &potKE,
+                                  const Grid<Real> &neighborRatio,
+                                  const Real c_s,
+                                  const Real c_b,
+                                  const Real k_ta,
+                                  const Real k_wc,
+                                  const Real dt,
+                                  const int itype = FlagGrid::TypeFluid)
+{
+  if (mode == "single") {
+    knFlipSampleSecondaryParticles(flags,
+                                   v,
+                                   pts_sec,
+                                   v_sec,
+                                   l_sec,
+                                   lMin,
+                                   lMax,
+                                   potTA,
+                                   potWC,
+                                   potKE,
+                                   neighborRatio,
+                                   c_s,
+                                   c_b,
+                                   k_ta,
+                                   k_wc,
+                                   dt,
+                                   itype);
+  }
+  else if (mode == "multiple") {
+    knFlipSampleSecondaryParticlesMoreCylinders(flags,
+                                                v,
+                                                pts_sec,
+                                                v_sec,
+                                                l_sec,
+                                                lMin,
+                                                lMax,
+                                                potTA,
+                                                potWC,
+                                                potKE,
+                                                neighborRatio,
+                                                c_s,
+                                                c_b,
+                                                k_ta,
+                                                k_wc,
+                                                dt,
+                                                itype);
+  }
+  else {
+    throw std::invalid_argument("Unknown mode: use \"single\" or \"multiple\" instead!");
+  }
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipSampleSecondaryParticles", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const std::string mode = _args.get<std::string>("mode", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      const MACGrid &v = *_args.getPtr<MACGrid>("v", 2, &_lock);
+      BasicParticleSystem &pts_sec = *_args.getPtr<BasicParticleSystem>("pts_sec", 3, &_lock);
+      ParticleDataImpl<Vec3> &v_sec = *_args.getPtr<ParticleDataImpl<Vec3>>("v_sec", 4, &_lock);
+      ParticleDataImpl<Real> &l_sec = *_args.getPtr<ParticleDataImpl<Real>>("l_sec", 5, &_lock);
+      const Real lMin = _args.get<Real>("lMin", 6, &_lock);
+      const Real lMax = _args.get<Real>("lMax", 7, &_lock);
+      const Grid<Real> &potTA = *_args.getPtr<Grid<Real>>("potTA", 8, &_lock);
+      const Grid<Real> &potWC = *_args.getPtr<Grid<Real>>("potWC", 9, &_lock);
+      const Grid<Real> &potKE = *_args.getPtr<Grid<Real>>("potKE", 10, &_lock);
+      const Grid<Real> &neighborRatio = *_args.getPtr<Grid<Real>>("neighborRatio", 11, &_lock);
+      const Real c_s = _args.get<Real>("c_s", 12, &_lock);
+      const Real c_b = _args.get<Real>("c_b", 13, &_lock);
+      const Real k_ta = _args.get<Real>("k_ta", 14, &_lock);
+      const Real k_wc = _args.get<Real>("k_wc", 15, &_lock);
+      const Real dt = _args.get<Real>("dt", 16, &_lock);
+      const int itype = _args.getOpt<int>("itype", 17, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      flipSampleSecondaryParticles(mode,
+                                   flags,
+                                   v,
+                                   pts_sec,
+                                   v_sec,
+                                   l_sec,
+                                   lMin,
+                                   lMax,
+                                   potTA,
+                                   potWC,
+                                   potKE,
+                                   neighborRatio,
+                                   c_s,
+                                   c_b,
+                                   k_ta,
+                                   k_wc,
+                                   dt,
+                                   itype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipSampleSecondaryParticles", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipSampleSecondaryParticles", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipSampleSecondaryParticles("",
+                                                           "flipSampleSecondaryParticles",
+                                                           _W_1);
+extern "C" {
+void PbRegister_flipSampleSecondaryParticles()
+{
+  KEEP_UNUSED(_RP_flipSampleSecondaryParticles);
+}
+}
+
+// evaluates cubic spline with radius h and distance l in dim dimensions
+Real cubicSpline(const Real h, const Real l, const int dim)
+{
+  const Real h2 = square(h), h3 = h2 * h, h4 = h3 * h, h5 = h4 * h;
+  const Real c[] = {
+      Real(2e0 / (3e0 * h)), Real(10e0 / (7e0 * M_PI * h2)), Real(1e0 / (M_PI * h3))};
+  const Real q = l / h;
+  if (q < 1e0)
+    return c[dim - 1] * (1e0 - 1.5 * square(q) + 0.75 * cubed(q));
+  else if (q < 2e0)
+    return c[dim - 1] * (0.25 * cubed(2e0 - q));
+  return 0;
+}
+
+// updates position &pts_sec.pos and velocity &v_sec of secondary particles according to the
+// particle type determined by the neighbor ratio with linear interpolation
+
+struct knFlipUpdateSecondaryParticlesLinear : public KernelBase {
+  knFlipUpdateSecondaryParticlesLinear(BasicParticleSystem &pts_sec,
+                                       ParticleDataImpl<Vec3> &v_sec,
+                                       ParticleDataImpl<Real> &l_sec,
+                                       const ParticleDataImpl<Vec3> &f_sec,
+                                       const FlagGrid &flags,
+                                       const MACGrid &v,
+                                       const Grid<Real> &neighborRatio,
+                                       const Vec3 gravity,
+                                       const Real k_b,
+                                       const Real k_d,
+                                       const Real c_s,
+                                       const Real c_b,
+                                       const Real dt,
+                                       const int exclude,
+                                       const int antitunneling)
+      : KernelBase(pts_sec.size()),
+        pts_sec(pts_sec),
+        v_sec(v_sec),
+        l_sec(l_sec),
+        f_sec(f_sec),
+        flags(flags),
+        v(v),
+        neighborRatio(neighborRatio),
+        gravity(gravity),
+        k_b(k_b),
+        k_d(k_d),
+        c_s(c_s),
+        c_b(c_b),
+        dt(dt),
+        exclude(exclude),
+        antitunneling(antitunneling)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 BasicParticleSystem &pts_sec,
+                 ParticleDataImpl<Vec3> &v_sec,
+                 ParticleDataImpl<Real> &l_sec,
+                 const ParticleDataImpl<Vec3> &f_sec,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 const Grid<Real> &neighborRatio,
+                 const Vec3 gravity,
+                 const Real k_b,
+                 const Real k_d,
+                 const Real c_s,
+                 const Real c_b,
+                 const Real dt,
+                 const int exclude,
+                 const int antitunneling) const
+  {
+
+    if (!pts_sec.isActive(idx) || pts_sec[idx].flag & exclude)
+      return;
+    if (!flags.isInBounds(pts_sec[idx].pos)) {
+      pts_sec.kill(idx);
+      return;
+    }
+
+    Vec3i gridpos = toVec3i(pts_sec[idx].pos);
+    int i = gridpos.x;
+    int j = gridpos.y;
+    int k = gridpos.z;
+
+    // spray particle
+    if (neighborRatio(gridpos) < c_s) {
+      pts_sec[idx].flag |= ParticleBase::PSPRAY;
+      pts_sec[idx].flag &= ~(ParticleBase::PBUBBLE | ParticleBase::PFOAM);
+      v_sec[idx] += dt *
+                    ((f_sec[idx] / 1) + gravity);  // TODO: if forces are added (e.g. fluid
+                                                   // guiding), add parameter for mass instead of 1
+
+      // anti tunneling for small obstacles
+      for (int ct = 1; ct < antitunneling; ct++) {
+        Vec3i tempPos = toVec3i(pts_sec[idx].pos +
+                                ct * (1 / Real(antitunneling)) * dt * v_sec[idx]);
+        if (!flags.isInBounds(tempPos) || flags(tempPos) & FlagGrid::TypeObstacle) {
+          pts_sec.kill(idx);
+          return;
+        }
+      }
+      pts_sec[idx].pos += dt * v_sec[idx];
+    }
+
+    // air bubble particle
+    else if (neighborRatio(gridpos) > c_b) {
+      pts_sec[idx].flag |= ParticleBase::PBUBBLE;
+      pts_sec[idx].flag &= ~(ParticleBase::PSPRAY | ParticleBase::PFOAM);
+
+      const Vec3 vj = (v.getInterpolated(pts_sec[idx].pos) - v_sec[idx]) / dt;
+      v_sec[idx] += dt * (k_b * -gravity + k_d * vj);
+
+      // anti tunneling for small obstacles
+      for (int ct = 1; ct < antitunneling; ct++) {
+        Vec3i tempPos = toVec3i(pts_sec[idx].pos +
+                                ct * (1 / Real(antitunneling)) * dt * v_sec[idx]);
+        if (!flags.isInBounds(tempPos) || flags(tempPos) & FlagGrid::TypeObstacle) {
+          pts_sec.kill(idx);
+          return;
+        }
+      }
+      pts_sec[idx].pos += dt * v_sec[idx];
+    }
+
+    // foam particle
+    else {
+      pts_sec[idx].flag |= ParticleBase::PFOAM;
+      pts_sec[idx].flag &= ~(ParticleBase::PBUBBLE | ParticleBase::PSPRAY);
+
+      const Vec3 vj = v.getInterpolated(pts_sec[idx].pos);
+      // anti tunneling for small obstacles
+      for (int ct = 1; ct < antitunneling; ct++) {
+        Vec3i tempPos = toVec3i(pts_sec[idx].pos + ct * (1 / Real(antitunneling)) * dt * vj);
+        if (!flags.isInBounds(tempPos) || flags(tempPos) & FlagGrid::TypeObstacle) {
+          pts_sec.kill(idx);
+          return;
+        }
+      }
+      pts_sec[idx].pos += dt * v.getInterpolated(pts_sec[idx].pos);
+    }
+
+    // lifetime
+    l_sec[idx] -= dt;
+    if (l_sec[idx] <= Real(0)) {
+      pts_sec.kill(idx);
+    }
+  }
+  inline BasicParticleSystem &getArg0()
+  {
+    return pts_sec;
+  }
+  typedef BasicParticleSystem type0;
+  inline ParticleDataImpl<Vec3> &getArg1()
+  {
+    return v_sec;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline ParticleDataImpl<Real> &getArg2()
+  {
+    return l_sec;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  inline const ParticleDataImpl<Vec3> &getArg3()
+  {
+    return f_sec;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline const FlagGrid &getArg4()
+  {
+    return flags;
+  }
+  typedef FlagGrid type4;
+  inline const MACGrid &getArg5()
+  {
+    return v;
+  }
+  typedef MACGrid type5;
+  inline const Grid<Real> &getArg6()
+  {
+    return neighborRatio;
+  }
+  typedef Grid<Real> type6;
+  inline const Vec3 &getArg7()
+  {
+    return gravity;
+  }
+  typedef Vec3 type7;
+  inline const Real &getArg8()
+  {
+    return k_b;
+  }
+  typedef Real type8;
+  inline const Real &getArg9()
+  {
+    return k_d;
+  }
+  typedef Real type9;
+  inline const Real &getArg10()
+  {
+    return c_s;
+  }
+  typedef Real type10;
+  inline const Real &getArg11()
+  {
+    return c_b;
+  }
+  typedef Real type11;
+  inline const Real &getArg12()
+  {
+    return dt;
+  }
+  typedef Real type12;
+  inline const int &getArg13()
+  {
+    return exclude;
+  }
+  typedef int type13;
+  inline const int &getArg14()
+  {
+    return antitunneling;
+  }
+  typedef int type14;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipUpdateSecondaryParticlesLinear ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx,
+         pts_sec,
+         v_sec,
+         l_sec,
+         f_sec,
+         flags,
+         v,
+         neighborRatio,
+         gravity,
+         k_b,
+         k_d,
+         c_s,
+         c_b,
+         dt,
+         exclude,
+         antitunneling);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystem &pts_sec;
+  ParticleDataImpl<Vec3> &v_sec;
+  ParticleDataImpl<Real> &l_sec;
+  const ParticleDataImpl<Vec3> &f_sec;
+  const FlagGrid &flags;
+  const MACGrid &v;
+  const Grid<Real> &neighborRatio;
+  const Vec3 gravity;
+  const Real k_b;
+  const Real k_d;
+  const Real c_s;
+  const Real c_b;
+  const Real dt;
+  const int exclude;
+  const int antitunneling;
+};
+// updates position &pts_sec.pos and velocity &v_sec of secondary particles according to the
+// particle type determined by the neighbor ratio with cubic spline interpolation
+
+struct knFlipUpdateSecondaryParticlesCubic : public KernelBase {
+  knFlipUpdateSecondaryParticlesCubic(BasicParticleSystem &pts_sec,
+                                      ParticleDataImpl<Vec3> &v_sec,
+                                      ParticleDataImpl<Real> &l_sec,
+                                      const ParticleDataImpl<Vec3> &f_sec,
+                                      const FlagGrid &flags,
+                                      const MACGrid &v,
+                                      const Grid<Real> &neighborRatio,
+                                      const int radius,
+                                      const Vec3 gravity,
+                                      const Real k_b,
+                                      const Real k_d,
+                                      const Real c_s,
+                                      const Real c_b,
+                                      const Real dt,
+                                      const int exclude,
+                                      const int antitunneling,
+                                      const int itype)
+      : KernelBase(pts_sec.size()),
+        pts_sec(pts_sec),
+        v_sec(v_sec),
+        l_sec(l_sec),
+        f_sec(f_sec),
+        flags(flags),
+        v(v),
+        neighborRatio(neighborRatio),
+        radius(radius),
+        gravity(gravity),
+        k_b(k_b),
+        k_d(k_d),
+        c_s(c_s),
+        c_b(c_b),
+        dt(dt),
+        exclude(exclude),
+        antitunneling(antitunneling),
+        itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 BasicParticleSystem &pts_sec,
+                 ParticleDataImpl<Vec3> &v_sec,
+                 ParticleDataImpl<Real> &l_sec,
+                 const ParticleDataImpl<Vec3> &f_sec,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 const Grid<Real> &neighborRatio,
+                 const int radius,
+                 const Vec3 gravity,
+                 const Real k_b,
+                 const Real k_d,
+                 const Real c_s,
+                 const Real c_b,
+                 const Real dt,
+                 const int exclude,
+                 const int antitunneling,
+                 const int itype) const
+  {
+
+    if (!pts_sec.isActive(idx) || pts_sec[idx].flag & exclude)
+      return;
+    if (!flags.isInBounds(pts_sec[idx].pos)) {
+      pts_sec.kill(idx);
+      return;
+    }
+
+    Vec3i gridpos = toVec3i(pts_sec[idx].pos);
+    int i = gridpos.x;
+    int j = gridpos.y;
+    int k = gridpos.z;
+
+    // spray particle
+    if (neighborRatio(gridpos) < c_s) {
+      pts_sec[idx].flag |= ParticleBase::PSPRAY;
+      pts_sec[idx].flag &= ~(ParticleBase::PBUBBLE | ParticleBase::PFOAM);
+      v_sec[idx] += dt *
+                    ((f_sec[idx] / 1) + gravity);  // TODO: if forces are added (e.g. fluid
+                                                   // guiding), add parameter for mass instead of 1
+
+      // anti tunneling for small obstacles
+      for (int ct = 1; ct < antitunneling; ct++) {
+        Vec3i tempPos = toVec3i(pts_sec[idx].pos +
+                                ct * (1 / Real(antitunneling)) * dt * v_sec[idx]);
+        if (!flags.isInBounds(tempPos) || flags(tempPos) & FlagGrid::TypeObstacle) {
+          pts_sec.kill(idx);
+          return;
+        }
+      }
+      pts_sec[idx].pos += dt * v_sec[idx];
+    }
+
+    // air bubble particle
+    else if (neighborRatio(gridpos) > c_b) {
+      pts_sec[idx].flag |= ParticleBase::PBUBBLE;
+      pts_sec[idx].flag &= ~(ParticleBase::PSPRAY | ParticleBase::PFOAM);
+      const Vec3 &xi = pts_sec[idx].pos;
+      Vec3 sumNumerator = Vec3(0, 0, 0);
+      Real sumDenominator = 0;
+      for (IndexInt x = i - radius; x <= i + radius; x++) {
+        for (IndexInt y = j - radius; y <= j + radius; y++) {
+          for (IndexInt z = k - radius; z <= k + radius; z++) {
+            Vec3i xj = Vec3i(x, y, z);
+            if ((x == i && y == j && z == k) || !flags.isInBounds(xj))
+              continue;
+            if (!(flags(xj) & itype))
+              continue;
+            const Real len_xij = norm(xi - Vec3(x, y, z));
+
+            int dim = flags.is3D() ? 3 : 2;
+            Real dist = flags.is3D() ? 1.732 : 1.414;
+            Real weight = cubicSpline(radius * dist, len_xij, dim);
+            sumNumerator += v.getCentered(xj) *
+                            weight;  // estimate next position by current velocity
+            sumDenominator += weight;
+          }
+        }
+      }
+      const Vec3 temp = ((sumNumerator / sumDenominator) - v_sec[idx]) / dt;
+      v_sec[idx] += dt * (k_b * -gravity + k_d * temp);
+
+      // anti tunneling for small obstacles
+      for (int ct = 1; ct < antitunneling; ct++) {
+        Vec3i tempPos = toVec3i(pts_sec[idx].pos +
+                                ct * (1 / Real(antitunneling)) * dt * v_sec[idx]);
+        if (!flags.isInBounds(tempPos) || flags(tempPos) & FlagGrid::TypeObstacle) {
+          pts_sec.kill(idx);
+          return;
+        }
+      }
+      pts_sec[idx].pos += dt * v_sec[idx];
+    }
+
+    // foam particle
+    else {
+      pts_sec[idx].flag |= ParticleBase::PFOAM;
+      pts_sec[idx].flag &= ~(ParticleBase::PBUBBLE | ParticleBase::PSPRAY);
+      const Vec3 &xi = pts_sec[idx].pos;
+      Vec3 sumNumerator = Vec3(0, 0, 0);
+      Real sumDenominator = 0;
+      for (IndexInt x = i - radius; x <= i + radius; x++) {
+        for (IndexInt y = j - radius; y <= j + radius; y++) {
+          for (IndexInt z = k - radius; z <= k + radius; z++) {
+            Vec3i xj = Vec3i(x, y, z);
+            if ((x == i && y == j && z == k) || !flags.isInBounds(xj))
+              continue;
+            if (!(flags(xj) & itype))
+              continue;
+            const Real len_xij = norm(xi - Vec3(x, y, z));
+
+            int dim = flags.is3D() ? 3 : 2;
+            Real dist = flags.is3D() ? 1.732 : 1.414;
+            Real weight = cubicSpline(radius * dist, len_xij, dim);
+            sumNumerator += v.getCentered(xj) *
+                            weight;  // estimate next position by current velocity
+            sumDenominator += weight;
+          }
+        }
+      }
+
+      // anti tunneling for small obstacles
+      for (int ct = 1; ct < antitunneling; ct++) {
+        Vec3i tempPos = toVec3i(pts_sec[idx].pos + ct * (1 / Real(antitunneling)) * dt *
+                                                       (sumNumerator / sumDenominator));
+        if (!flags.isInBounds(tempPos) || flags(tempPos) & FlagGrid::TypeObstacle) {
+          pts_sec.kill(idx);
+          return;
+        }
+      }
+      pts_sec[idx].pos += dt * (sumNumerator / sumDenominator);
+    }
+
+    // lifetime
+    l_sec[idx] -= dt;
+    if (l_sec[idx] <= Real(0)) {
+      pts_sec.kill(idx);
+    }
+  }
+  inline BasicParticleSystem &getArg0()
+  {
+    return pts_sec;
+  }
+  typedef BasicParticleSystem type0;
+  inline ParticleDataImpl<Vec3> &getArg1()
+  {
+    return v_sec;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline ParticleDataImpl<Real> &getArg2()
+  {
+    return l_sec;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  inline const ParticleDataImpl<Vec3> &getArg3()
+  {
+    return f_sec;
+  }
+  typedef ParticleDataImpl<Vec3> type3;
+  inline const FlagGrid &getArg4()
+  {
+    return flags;
+  }
+  typedef FlagGrid type4;
+  inline const MACGrid &getArg5()
+  {
+    return v;
+  }
+  typedef MACGrid type5;
+  inline const Grid<Real> &getArg6()
+  {
+    return neighborRatio;
+  }
+  typedef Grid<Real> type6;
+  inline const int &getArg7()
+  {
+    return radius;
+  }
+  typedef int type7;
+  inline const Vec3 &getArg8()
+  {
+    return gravity;
+  }
+  typedef Vec3 type8;
+  inline const Real &getArg9()
+  {
+    return k_b;
+  }
+  typedef Real type9;
+  inline const Real &getArg10()
+  {
+    return k_d;
+  }
+  typedef Real type10;
+  inline const Real &getArg11()
+  {
+    return c_s;
+  }
+  typedef Real type11;
+  inline const Real &getArg12()
+  {
+    return c_b;
+  }
+  typedef Real type12;
+  inline const Real &getArg13()
+  {
+    return dt;
+  }
+  typedef Real type13;
+  inline const int &getArg14()
+  {
+    return exclude;
+  }
+  typedef int type14;
+  inline const int &getArg15()
+  {
+    return antitunneling;
+  }
+  typedef int type15;
+  inline const int &getArg16()
+  {
+    return itype;
+  }
+  typedef int type16;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipUpdateSecondaryParticlesCubic ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx,
+         pts_sec,
+         v_sec,
+         l_sec,
+         f_sec,
+         flags,
+         v,
+         neighborRatio,
+         radius,
+         gravity,
+         k_b,
+         k_d,
+         c_s,
+         c_b,
+         dt,
+         exclude,
+         antitunneling,
+         itype);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystem &pts_sec;
+  ParticleDataImpl<Vec3> &v_sec;
+  ParticleDataImpl<Real> &l_sec;
+  const ParticleDataImpl<Vec3> &f_sec;
+  const FlagGrid &flags;
+  const MACGrid &v;
+  const Grid<Real> &neighborRatio;
+  const int radius;
+  const Vec3 gravity;
+  const Real k_b;
+  const Real k_d;
+  const Real c_s;
+  const Real c_b;
+  const Real dt;
+  const int exclude;
+  const int antitunneling;
+  const int itype;
+};
+
+void flipUpdateSecondaryParticles(const std::string mode,
+                                  BasicParticleSystem &pts_sec,
+                                  ParticleDataImpl<Vec3> &v_sec,
+                                  ParticleDataImpl<Real> &l_sec,
+                                  const ParticleDataImpl<Vec3> &f_sec,
+                                  FlagGrid &flags,
+                                  const MACGrid &v,
+                                  const Grid<Real> &neighborRatio,
+                                  const int radius,
+                                  const Vec3 gravity,
+                                  const Real k_b,
+                                  const Real k_d,
+                                  const Real c_s,
+                                  const Real c_b,
+                                  const Real dt,
+                                  const int exclude = ParticleBase::PTRACER,
+                                  const int antitunneling = 0,
+                                  const int itype = FlagGrid::TypeFluid)
+{
+
+  Vec3 g = gravity / flags.getDx();
+  if (mode == "linear") {
+    knFlipUpdateSecondaryParticlesLinear(pts_sec,
+                                         v_sec,
+                                         l_sec,
+                                         f_sec,
+                                         flags,
+                                         v,
+                                         neighborRatio,
+                                         g,
+                                         k_b,
+                                         k_d,
+                                         c_s,
+                                         c_b,
+                                         dt,
+                                         exclude,
+                                         antitunneling);
+  }
+  else if (mode == "cubic") {
+    knFlipUpdateSecondaryParticlesCubic(pts_sec,
+                                        v_sec,
+                                        l_sec,
+                                        f_sec,
+                                        flags,
+                                        v,
+                                        neighborRatio,
+                                        radius,
+                                        g,
+                                        k_b,
+                                        k_d,
+                                        c_s,
+                                        c_b,
+                                        dt,
+                                        exclude,
+                                        antitunneling,
+                                        itype);
+  }
+  else {
+    throw std::invalid_argument("Unknown mode: use \"linear\" or \"cubic\" instead!");
+  }
+  pts_sec.doCompress();
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipUpdateSecondaryParticles", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const std::string mode = _args.get<std::string>("mode", 0, &_lock);
+      BasicParticleSystem &pts_sec = *_args.getPtr<BasicParticleSystem>("pts_sec", 1, &_lock);
+      ParticleDataImpl<Vec3> &v_sec = *_args.getPtr<ParticleDataImpl<Vec3>>("v_sec", 2, &_lock);
+      ParticleDataImpl<Real> &l_sec = *_args.getPtr<ParticleDataImpl<Real>>("l_sec", 3, &_lock);
+      const ParticleDataImpl<Vec3> &f_sec = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "f_sec", 4, &_lock);
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 5, &_lock);
+      const MACGrid &v = *_args.getPtr<MACGrid>("v", 6, &_lock);
+      const Grid<Real> &neighborRatio = *_args.getPtr<Grid<Real>>("neighborRatio", 7, &_lock);
+      const int radius = _args.get<int>("radius", 8, &_lock);
+      const Vec3 gravity = _args.get<Vec3>("gravity", 9, &_lock);
+      const Real k_b = _args.get<Real>("k_b", 10, &_lock);
+      const Real k_d = _args.get<Real>("k_d", 11, &_lock);
+      const Real c_s = _args.get<Real>("c_s", 12, &_lock);
+      const Real c_b = _args.get<Real>("c_b", 13, &_lock);
+      const Real dt = _args.get<Real>("dt", 14, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 15, ParticleBase::PTRACER, &_lock);
+      const int antitunneling = _args.getOpt<int>("antitunneling", 16, 0, &_lock);
+      const int itype = _args.getOpt<int>("itype", 17, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      flipUpdateSecondaryParticles(mode,
+                                   pts_sec,
+                                   v_sec,
+                                   l_sec,
+                                   f_sec,
+                                   flags,
+                                   v,
+                                   neighborRatio,
+                                   radius,
+                                   gravity,
+                                   k_b,
+                                   k_d,
+                                   c_s,
+                                   c_b,
+                                   dt,
+                                   exclude,
+                                   antitunneling,
+                                   itype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipUpdateSecondaryParticles", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipUpdateSecondaryParticles", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipUpdateSecondaryParticles("",
+                                                           "flipUpdateSecondaryParticles",
+                                                           _W_2);
+extern "C" {
+void PbRegister_flipUpdateSecondaryParticles()
+{
+  KEEP_UNUSED(_RP_flipUpdateSecondaryParticles);
+}
+}
+
+// removes secondary particles in &pts_sec that are inside boundaries (cells that are marked as
+// obstacle/outflow in &flags)
+
+struct knFlipDeleteParticlesInObstacle : public KernelBase {
+  knFlipDeleteParticlesInObstacle(BasicParticleSystem &pts, const FlagGrid &flags)
+      : KernelBase(pts.size()), pts(pts), flags(flags)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, BasicParticleSystem &pts, const FlagGrid &flags) const
+  {
+
+    if (!pts.isActive(idx))
+      return;
+
+    const Vec3 &xi = pts[idx].pos;
+    const Vec3i xidx = toVec3i(xi);
+    // remove particles that completely left the bounds
+    if (!flags.isInBounds(xidx)) {
+      pts.kill(idx);
+      return;
+    }
+    int gridIndex = flags.index(xidx);
+    // remove particles that penetrate obstacles
+    if (flags[gridIndex] == FlagGrid::TypeObstacle || flags[gridIndex] == FlagGrid::TypeOutflow) {
+      pts.kill(idx);
+    }
+  }
+  inline BasicParticleSystem &getArg0()
+  {
+    return pts;
+  }
+  typedef BasicParticleSystem type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipDeleteParticlesInObstacle ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, pts, flags);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystem &pts;
+  const FlagGrid &flags;
+};
+
+void flipDeleteParticlesInObstacle(BasicParticleSystem &pts, const FlagGrid &flags)
+{
+
+  knFlipDeleteParticlesInObstacle(pts, flags);
+  pts.doCompress();
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipDeleteParticlesInObstacle", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      BasicParticleSystem &pts = *_args.getPtr<BasicParticleSystem>("pts", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      _retval = getPyNone();
+      flipDeleteParticlesInObstacle(pts, flags);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipDeleteParticlesInObstacle", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipDeleteParticlesInObstacle", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipDeleteParticlesInObstacle("",
+                                                            "flipDeleteParticlesInObstacle",
+                                                            _W_3);
+extern "C" {
+void PbRegister_flipDeleteParticlesInObstacle()
+{
+  KEEP_UNUSED(_RP_flipDeleteParticlesInObstacle);
+}
+}
+
+// helper method to debug statistical data from grid
+
+void debugGridInfo(const FlagGrid &flags,
+                   Grid<Real> &grid,
+                   std::string name,
+                   const int itype = FlagGrid::TypeFluid)
+{
+  FluidSolver *s = flags.getParent();
+  int countFluid = 0;
+  int countLargerZero = 0;
+  Real avg = 0;
+  Real max = 0;
+  Real sum = 0;
+  Real avgLargerZero = 0;
+  FOR_IJK_BND(grid, 1)
+  {
+    if (!(flags(i, j, k) & itype))
+      continue;
+    countFluid++;
+    if (grid(i, j, k) > 0)
+      countLargerZero++;
+    sum += grid(i, j, k);
+    if (grid(i, j, k) > max)
+      max = grid(i, j, k);
+  }
+  avg = sum / std::max(Real(countFluid), Real(1));
+  avgLargerZero = sum / std::max(Real(countLargerZero), Real(1));
+
+  debMsg("Step: " << s->mFrame << " - Grid " << name << "\n\tcountFluid \t\t" << countFluid
+                  << "\n\tcountLargerZero \t" << countLargerZero << "\n\tsum \t\t\t" << sum
+                  << "\n\tavg \t\t\t" << avg << "\n\tavgLargerZero \t\t" << avgLargerZero
+                  << "\n\tmax \t\t\t" << max,
+         1);
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "debugGridInfo", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 1, &_lock);
+      std::string name = _args.get<std::string>("name", 2, &_lock);
+      const int itype = _args.getOpt<int>("itype", 3, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      debugGridInfo(flags, grid, name, itype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "debugGridInfo", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("debugGridInfo", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_debugGridInfo("", "debugGridInfo", _W_4);
+extern "C" {
+void PbRegister_debugGridInfo()
+{
+  KEEP_UNUSED(_RP_debugGridInfo);
+}
+}
+
+// The following methods are helper functions to recreate the velocity and flag grid from the
+// underlying FLIP simulation. They cannot simply be loaded because of the upres to a higher
+// resolution, instead a levelset is used.
+
+struct knSetFlagsFromLevelset : public KernelBase {
+  knSetFlagsFromLevelset(FlagGrid &flags,
+                         const Grid<Real> &phi,
+                         const int exclude = FlagGrid::TypeObstacle,
+                         const int itype = FlagGrid::TypeFluid)
+      : KernelBase(&flags, 0), flags(flags), phi(phi), exclude(exclude), itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 FlagGrid &flags,
+                 const Grid<Real> &phi,
+                 const int exclude = FlagGrid::TypeObstacle,
+                 const int itype = FlagGrid::TypeFluid) const
+  {
+    if (phi(idx) < 0 && !(flags(idx) & exclude))
+      flags(idx) = itype;
+  }
+  inline FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type1;
+  inline const int &getArg2()
+  {
+    return exclude;
+  }
+  typedef int type2;
+  inline const int &getArg3()
+  {
+    return itype;
+  }
+  typedef int type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetFlagsFromLevelset ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, flags, phi, exclude, itype);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  FlagGrid &flags;
+  const Grid<Real> &phi;
+  const int exclude;
+  const int itype;
+};
+
+void setFlagsFromLevelset(FlagGrid &flags,
+                          const Grid<Real> &phi,
+                          const int exclude = FlagGrid::TypeObstacle,
+                          const int itype = FlagGrid::TypeFluid)
+{
+  knSetFlagsFromLevelset(flags, phi, exclude, itype);
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setFlagsFromLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 1, &_lock);
+      const int exclude = _args.getOpt<int>("exclude", 2, FlagGrid::TypeObstacle, &_lock);
+      const int itype = _args.getOpt<int>("itype", 3, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      setFlagsFromLevelset(flags, phi, exclude, itype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setFlagsFromLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setFlagsFromLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setFlagsFromLevelset("", "setFlagsFromLevelset", _W_5);
+extern "C" {
+void PbRegister_setFlagsFromLevelset()
+{
+  KEEP_UNUSED(_RP_setFlagsFromLevelset);
+}
+}
+
+struct knSetMACFromLevelset : public KernelBase {
+  knSetMACFromLevelset(MACGrid &v, const Grid<Real> &phi, const Vec3 c)
+      : KernelBase(&v, 0), v(v), phi(phi), c(c)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, MACGrid &v, const Grid<Real> &phi, const Vec3 c) const
+  {
+    if (phi.getInterpolated(Vec3(i, j, k)) > 0)
+      v(i, j, k) = c;
+  }
+  inline MACGrid &getArg0()
+  {
+    return v;
+  }
+  typedef MACGrid type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type1;
+  inline const Vec3 &getArg2()
+  {
+    return c;
+  }
+  typedef Vec3 type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel knSetMACFromLevelset ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, v, phi, c);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, v, phi, c);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  MACGrid &v;
+  const Grid<Real> &phi;
+  const Vec3 c;
+};
+
+void setMACFromLevelset(MACGrid &v, const Grid<Real> &phi, const Vec3 c)
+{
+  knSetMACFromLevelset(v, phi, c);
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "setMACFromLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &v = *_args.getPtr<MACGrid>("v", 0, &_lock);
+      const Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 1, &_lock);
+      const Vec3 c = _args.get<Vec3>("c", 2, &_lock);
+      _retval = getPyNone();
+      setMACFromLevelset(v, phi, c);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "setMACFromLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("setMACFromLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_setMACFromLevelset("", "setMACFromLevelset", _W_6);
+extern "C" {
+void PbRegister_setMACFromLevelset()
+{
+  KEEP_UNUSED(_RP_setMACFromLevelset);
+}
+}
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+// END Secondary Particles for FLIP
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+#pragma endregion
+
+#pragma region Legacy Methods(still useful for debugging)
+//-----------------------------------------------------------------------------------------------------------------------------------
+//-----------------
+// Legacy Methods (still useful for debugging)
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+
+// LEGACY METHOD! Use flipComputeSecondaryParticlePotentials instead!
+// computes trapped air potential for all fluid cells in &flags and saves it in &pot
+
+struct knFlipComputePotentialTrappedAir : public KernelBase {
+  knFlipComputePotentialTrappedAir(Grid<Real> &pot,
+                                   const FlagGrid &flags,
+                                   const MACGrid &v,
+                                   const int radius,
+                                   const Real tauMin,
+                                   const Real tauMax,
+                                   const Real scaleFromManta,
+                                   const int itype = FlagGrid::TypeFluid,
+                                   const int jtype = FlagGrid::TypeFluid)
+      : KernelBase(&pot, 1),
+        pot(pot),
+        flags(flags),
+        v(v),
+        radius(radius),
+        tauMin(tauMin),
+        tauMax(tauMax),
+        scaleFromManta(scaleFromManta),
+        itype(itype),
+        jtype(jtype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Real> &pot,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 const int radius,
+                 const Real tauMin,
+                 const Real tauMax,
+                 const Real scaleFromManta,
+                 const int itype = FlagGrid::TypeFluid,
+                 const int jtype = FlagGrid::TypeFluid) const
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    const Vec3 &xi = scaleFromManta * Vec3(i, j, k);  // scale to unit cube
+    const Vec3 &vi = scaleFromManta * v.getCentered(i, j, k);
+    Real vdiff = 0;
+    for (IndexInt x = i - radius; x <= i + radius; x++) {
+      for (IndexInt y = j - radius; y <= j + radius; y++) {
+        for (IndexInt z = k - radius; z <= k + radius; z++) {
+          if ((x == i && y == j && z == k) || !(flags(x, y, z) & jtype))
+            continue;
+
+          const Vec3 &xj = scaleFromManta * Vec3(x, y, z);  // scale to unit cube
+          const Vec3 &vj = scaleFromManta * v.getCentered(x, y, z);
+          const Vec3 xij = xi - xj;
+          const Vec3 vij = vi - vj;
+          Real h = !pot.is3D() ? 1.414 * radius :
+                                 1.732 * radius;  // estimate sqrt(2)*radius resp. sqrt(3)*radius
+                                                  // for h, due to squared resp. cubic neighbor area
+          vdiff += norm(vij) * (1 - dot(getNormalized(vij), getNormalized(xij))) *
+                   (1 - norm(xij) / h);
+        }
+      }
+    }
+    pot(i, j, k) = (std::min(vdiff, tauMax) - std::min(vdiff, tauMin)) / (tauMax - tauMin);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return pot;
+  }
+  typedef Grid<Real> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return v;
+  }
+  typedef MACGrid type2;
+  inline const int &getArg3()
+  {
+    return radius;
+  }
+  typedef int type3;
+  inline const Real &getArg4()
+  {
+    return tauMin;
+  }
+  typedef Real type4;
+  inline const Real &getArg5()
+  {
+    return tauMax;
+  }
+  typedef Real type5;
+  inline const Real &getArg6()
+  {
+    return scaleFromManta;
+  }
+  typedef Real type6;
+  inline const int &getArg7()
+  {
+    return itype;
+  }
+  typedef int type7;
+  inline const int &getArg8()
+  {
+    return jtype;
+  }
+  typedef int type8;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipComputePotentialTrappedAir ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, pot, flags, v, radius, tauMin, tauMax, scaleFromManta, itype, jtype);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, pot, flags, v, radius, tauMin, tauMax, scaleFromManta, itype, jtype);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &pot;
+  const FlagGrid &flags;
+  const MACGrid &v;
+  const int radius;
+  const Real tauMin;
+  const Real tauMax;
+  const Real scaleFromManta;
+  const int itype;
+  const int jtype;
+};
+
+void flipComputePotentialTrappedAir(Grid<Real> &pot,
+                                    const FlagGrid &flags,
+                                    const MACGrid &v,
+                                    const int radius,
+                                    const Real tauMin,
+                                    const Real tauMax,
+                                    const Real scaleFromManta,
+                                    const int itype = FlagGrid::TypeFluid,
+                                    const int jtype = FlagGrid::TypeFluid)
+{
+  pot.clear();
+  knFlipComputePotentialTrappedAir(
+      pot, flags, v, radius, tauMin, tauMax, scaleFromManta, itype, jtype);
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipComputePotentialTrappedAir", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      const MACGrid &v = *_args.getPtr<MACGrid>("v", 2, &_lock);
+      const int radius = _args.get<int>("radius", 3, &_lock);
+      const Real tauMin = _args.get<Real>("tauMin", 4, &_lock);
+      const Real tauMax = _args.get<Real>("tauMax", 5, &_lock);
+      const Real scaleFromManta = _args.get<Real>("scaleFromManta", 6, &_lock);
+      const int itype = _args.getOpt<int>("itype", 7, FlagGrid::TypeFluid, &_lock);
+      const int jtype = _args.getOpt<int>("jtype", 8, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      flipComputePotentialTrappedAir(
+          pot, flags, v, radius, tauMin, tauMax, scaleFromManta, itype, jtype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipComputePotentialTrappedAir", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipComputePotentialTrappedAir", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipComputePotentialTrappedAir("",
+                                                             "flipComputePotentialTrappedAir",
+                                                             _W_7);
+extern "C" {
+void PbRegister_flipComputePotentialTrappedAir()
+{
+  KEEP_UNUSED(_RP_flipComputePotentialTrappedAir);
+}
+}
+
+// LEGACY METHOD! Use flipComputeSecondaryParticlePotentials instead!
+// computes kinetic energy potential for all fluid cells in &flags and saves it in &pot
+
+struct knFlipComputePotentialKineticEnergy : public KernelBase {
+  knFlipComputePotentialKineticEnergy(Grid<Real> &pot,
+                                      const FlagGrid &flags,
+                                      const MACGrid &v,
+                                      const Real tauMin,
+                                      const Real tauMax,
+                                      const Real scaleFromManta,
+                                      const int itype = FlagGrid::TypeFluid)
+      : KernelBase(&pot, 0),
+        pot(pot),
+        flags(flags),
+        v(v),
+        tauMin(tauMin),
+        tauMax(tauMax),
+        scaleFromManta(scaleFromManta),
+        itype(itype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Real> &pot,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 const Real tauMin,
+                 const Real tauMax,
+                 const Real scaleFromManta,
+                 const int itype = FlagGrid::TypeFluid) const
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    const Vec3 &vi = scaleFromManta * v.getCentered(i, j, k);  // scale to unit cube
+    Real ek =
+        Real(0.5) * 125 *
+        normSquare(
+            vi);  // use arbitrary constant for mass, potential adjusts with thresholds anyways
+    pot(i, j, k) = (std::min(ek, tauMax) - std::min(ek, tauMin)) / (tauMax - tauMin);
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return pot;
+  }
+  typedef Grid<Real> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return v;
+  }
+  typedef MACGrid type2;
+  inline const Real &getArg3()
+  {
+    return tauMin;
+  }
+  typedef Real type3;
+  inline const Real &getArg4()
+  {
+    return tauMax;
+  }
+  typedef Real type4;
+  inline const Real &getArg5()
+  {
+    return scaleFromManta;
+  }
+  typedef Real type5;
+  inline const int &getArg6()
+  {
+    return itype;
+  }
+  typedef int type6;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipComputePotentialKineticEnergy ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, pot, flags, v, tauMin, tauMax, scaleFromManta, itype);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, pot, flags, v, tauMin, tauMax, scaleFromManta, itype);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Real> &pot;
+  const FlagGrid &flags;
+  const MACGrid &v;
+  const Real tauMin;
+  const Real tauMax;
+  const Real scaleFromManta;
+  const int itype;
+};
+
+void flipComputePotentialKineticEnergy(Grid<Real> &pot,
+                                       const FlagGrid &flags,
+                                       const MACGrid &v,
+                                       const Real tauMin,
+                                       const Real tauMax,
+                                       const Real scaleFromManta,
+                                       const int itype = FlagGrid::TypeFluid)
+{
+  pot.clear();
+  knFlipComputePotentialKineticEnergy(pot, flags, v, tauMin, tauMax, scaleFromManta, itype);
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipComputePotentialKineticEnergy", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      const MACGrid &v = *_args.getPtr<MACGrid>("v", 2, &_lock);
+      const Real tauMin = _args.get<Real>("tauMin", 3, &_lock);
+      const Real tauMax = _args.get<Real>("tauMax", 4, &_lock);
+      const Real scaleFromManta = _args.get<Real>("scaleFromManta", 5, &_lock);
+      const int itype = _args.getOpt<int>("itype", 6, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      flipComputePotentialKineticEnergy(pot, flags, v, tauMin, tauMax, scaleFromManta, itype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipComputePotentialKineticEnergy", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipComputePotentialKineticEnergy", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipComputePotentialKineticEnergy(
+    "", "flipComputePotentialKineticEnergy", _W_8);
+extern "C" {
+void PbRegister_flipComputePotentialKineticEnergy()
+{
+  KEEP_UNUSED(_RP_flipComputePotentialKineticEnergy);
+}
+}
+
+// LEGACY METHOD! Use flipComputeSecondaryParticlePotentials instead!
+// computes wave crest potential for all fluid cells in &flags and saves it in &pot
+
+struct knFlipComputePotentialWaveCrest : public KernelBase {
+  knFlipComputePotentialWaveCrest(Grid<Real> &pot,
+                                  const FlagGrid &flags,
+                                  const MACGrid &v,
+                                  const int radius,
+                                  Grid<Vec3> &normal,
+                                  const Real tauMin,
+                                  const Real tauMax,
+                                  const Real scaleFromManta,
+                                  const int itype = FlagGrid::TypeFluid,
+                                  const int jtype = FlagGrid::TypeFluid)
+      : KernelBase(&pot, 1),
+        pot(pot),
+        flags(flags),
+        v(v),
+        radius(radius),
+        normal(normal),
+        tauMin(tauMin),
+        tauMax(tauMax),
+        scaleFromManta(scaleFromManta),
+        itype(itype),
+        jtype(jtype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<Real> &pot,
+                 const FlagGrid &flags,
+                 const MACGrid &v,
+                 const int radius,
+                 Grid<Vec3> &normal,
+                 const Real tauMin,
+                 const Real tauMax,
+                 const Real scaleFromManta,
+                 const int itype = FlagGrid::TypeFluid,
+                 const int jtype = FlagGrid::TypeFluid) const
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    const Vec3 &xi = scaleFromManta * Vec3(i, j, k);  // scale to unit cube
+    const Vec3 &vi = scaleFromManta * v.getCentered(i, j, k);
+    const Vec3 &ni = normal(i, j, k);
+    Real kappa = 0;
+    for (IndexInt x = i - radius; x <= i + radius; x++) {
+      for (IndexInt y = j - radius; y <= j + radius; y++) {
+        for (IndexInt z = k - radius; z <= k + radius; z++) {
+          if ((x == i && y == j && z == k) || !(flags(x, y, z) & jtype))
+            continue;
+          const Vec3 &xj = scaleFromManta * Vec3(x, y, z);  // scale to unit cube
+          const Vec3 &nj = normal(x, y, z);
+          const Vec3 xij = xi - xj;
+          if (dot(getNormalized(xij), ni) < 0) {  // identifies wave crests
+            Real h = !pot.is3D() ?
+                         1.414 * radius :
+                         1.732 * radius;  // estimate sqrt(2)*radius resp. sqrt(3)*radius for h,
+                                          // due to squared resp. cubic neighbor area
+            kappa += (1 - dot(ni, nj)) * (1 - norm(xij) / h);
+          }
+        }
+      }
+    }
+
+    if (dot(getNormalized(vi), ni) >= 0.6) {  // avoid to mark boarders of the scene as wave crest
+      pot(i, j, k) = (std::min(kappa, tauMax) - std::min(kappa, tauMin)) / (tauMax - tauMin);
+    }
+    else {
+      pot(i, j, k) = Real(0);
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return pot;
+  }
+  typedef Grid<Real> type0;
+  inline const FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return v;
+  }
+  typedef MACGrid type2;
+  inline const int &getArg3()
+  {
+    return radius;
+  }
+  typedef int type3;
+  inline Grid<Vec3> &getArg4()
+  {
+    return normal;
+  }
+  typedef Grid<Vec3> type4;
+  inline const Real &getArg5()
+  {
+    return tauMin;
+  }
+  typedef Real type5;
+  inline const Real &getArg6()
+  {
+    return tauMax;
+  }
+  typedef Real type6;
+  inline const Real &getArg7()
+  {
+    return scaleFromManta;
+  }
+  typedef Real type7;
+  inline const int &getArg8()
+  {
+    return itype;
+  }
+  typedef int type8;
+  inline const int &getArg9()
+  {
+    return jtype;
+  }
+  typedef int type9;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipComputePotentialWaveCrest ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i,
+               j,
+               k,
+               pot,
+               flags,
+               v,
+               radius,
+               normal,
+               tauMin,
+               tauMax,
+               scaleFromManta,
+               itype,
+               jtype);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, pot, flags, v, radius, normal, tauMin, tauMax, scaleFromManta, itype, jtype);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  Grid<Real> &pot;
+  const FlagGrid &flags;
+  const MACGrid &v;
+  const int radius;
+  Grid<Vec3> &normal;
+  const Real tauMin;
+  const Real tauMax;
+  const Real scaleFromManta;
+  const int itype;
+  const int jtype;
+};
+
+void flipComputePotentialWaveCrest(Grid<Real> &pot,
+                                   const FlagGrid &flags,
+                                   const MACGrid &v,
+                                   const int radius,
+                                   Grid<Vec3> &normal,
+                                   const Real tauMin,
+                                   const Real tauMax,
+                                   const Real scaleFromManta,
+                                   const int itype = FlagGrid::TypeFluid,
+                                   const int jtype = FlagGrid::TypeFluid)
+{
+
+  pot.clear();
+  knFlipComputePotentialWaveCrest(
+      pot, flags, v, radius, normal, tauMin, tauMax, scaleFromManta, itype, jtype);
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipComputePotentialWaveCrest", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      const MACGrid &v = *_args.getPtr<MACGrid>("v", 2, &_lock);
+      const int radius = _args.get<int>("radius", 3, &_lock);
+      Grid<Vec3> &normal = *_args.getPtr<Grid<Vec3>>("normal", 4, &_lock);
+      const Real tauMin = _args.get<Real>("tauMin", 5, &_lock);
+      const Real tauMax = _args.get<Real>("tauMax", 6, &_lock);
+      const Real scaleFromManta = _args.get<Real>("scaleFromManta", 7, &_lock);
+      const int itype = _args.getOpt<int>("itype", 8, FlagGrid::TypeFluid, &_lock);
+      const int jtype = _args.getOpt<int>("jtype", 9, FlagGrid::TypeFluid, &_lock);
+      _retval = getPyNone();
+      flipComputePotentialWaveCrest(
+          pot, flags, v, radius, normal, tauMin, tauMax, scaleFromManta, itype, jtype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipComputePotentialWaveCrest", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipComputePotentialWaveCrest", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipComputePotentialWaveCrest("",
+                                                            "flipComputePotentialWaveCrest",
+                                                            _W_9);
+extern "C" {
+void PbRegister_flipComputePotentialWaveCrest()
+{
+  KEEP_UNUSED(_RP_flipComputePotentialWaveCrest);
+}
+}
+
+// LEGACY METHOD! Use flipComputeSecondaryParticlePotentials instead!
+// computes normal grid &normal as gradient of levelset &phi and normalizes it
+
+struct knFlipComputeSurfaceNormals : public KernelBase {
+  knFlipComputeSurfaceNormals(Grid<Vec3> &normal, const Grid<Real> &phi)
+      : KernelBase(&normal, 0), normal(normal), phi(phi)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, Grid<Vec3> &normal, const Grid<Real> &phi) const
+  {
+    normal[idx] = getNormalized(normal[idx]);
+  }
+  inline Grid<Vec3> &getArg0()
+  {
+    return normal;
+  }
+  typedef Grid<Vec3> type0;
+  inline const Grid<Real> &getArg1()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipComputeSurfaceNormals ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, normal, phi);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  Grid<Vec3> &normal;
+  const Grid<Real> &phi;
+};
+
+void flipComputeSurfaceNormals(Grid<Vec3> &normal, const Grid<Real> &phi)
+{
+  GradientOp(normal, phi);
+  knFlipComputeSurfaceNormals(normal, phi);
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipComputeSurfaceNormals", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &normal = *_args.getPtr<Grid<Vec3>>("normal", 0, &_lock);
+      const Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 1, &_lock);
+      _retval = getPyNone();
+      flipComputeSurfaceNormals(normal, phi);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipComputeSurfaceNormals", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipComputeSurfaceNormals", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipComputeSurfaceNormals("", "flipComputeSurfaceNormals", _W_10);
+extern "C" {
+void PbRegister_flipComputeSurfaceNormals()
+{
+  KEEP_UNUSED(_RP_flipComputeSurfaceNormals);
+}
+}
+
+// LEGACY METHOD! Use flipComputeSecondaryParticlePotentials instead!
+// computes the neighbor ratio for every fluid cell in &flags as the number of fluid neighbors over
+// the maximum possible number of fluid neighbors
+
+struct knFlipUpdateNeighborRatio : public KernelBase {
+  knFlipUpdateNeighborRatio(const FlagGrid &flags,
+                            Grid<Real> &neighborRatio,
+                            const int radius,
+                            const int itype = FlagGrid::TypeFluid,
+                            const int jtype = FlagGrid::TypeObstacle)
+      : KernelBase(&flags, 1),
+        flags(flags),
+        neighborRatio(neighborRatio),
+        radius(radius),
+        itype(itype),
+        jtype(jtype)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &neighborRatio,
+                 const int radius,
+                 const int itype = FlagGrid::TypeFluid,
+                 const int jtype = FlagGrid::TypeObstacle) const
+  {
+
+    if (!(flags(i, j, k) & itype))
+      return;
+
+    int countFluid = 0;
+    int countMaxFluid = 0;
+    for (IndexInt x = i - radius; x <= i + radius; x++) {
+      for (IndexInt y = j - radius; y <= j + radius; y++) {
+        for (IndexInt z = k - radius; z <= k + radius; z++) {
+          if ((x == i && y == j && z == k) || (flags(x, y, z) & jtype))
+            continue;
+          if (flags(x, y, z) & itype) {
+            countFluid++;
+            countMaxFluid++;
+          }
+          else {
+            countMaxFluid++;
+          }
+        }
+      }
+    }
+    neighborRatio(i, j, k) = float(countFluid) / float(countMaxFluid);
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return neighborRatio;
+  }
+  typedef Grid<Real> type1;
+  inline const int &getArg2()
+  {
+    return radius;
+  }
+  typedef int type2;
+  inline const int &getArg3()
+  {
+    return itype;
+  }
+  typedef int type3;
+  inline const int &getArg4()
+  {
+    return jtype;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knFlipUpdateNeighborRatio ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, neighborRatio, radius, itype, jtype);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, neighborRatio, radius, itype, jtype);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &neighborRatio;
+  const int radius;
+  const int itype;
+  const int jtype;
+};
+
+void flipUpdateNeighborRatio(const FlagGrid &flags,
+                             Grid<Real> &neighborRatio,
+                             const int radius,
+                             const int itype = FlagGrid::TypeFluid,
+                             const int jtype = FlagGrid::TypeObstacle)
+{
+
+  neighborRatio.clear();
+  knFlipUpdateNeighborRatio(flags, neighborRatio, radius, itype, jtype);
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "flipUpdateNeighborRatio", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &neighborRatio = *_args.getPtr<Grid<Real>>("neighborRatio", 1, &_lock);
+      const int radius = _args.get<int>("radius", 2, &_lock);
+      const int itype = _args.getOpt<int>("itype", 3, FlagGrid::TypeFluid, &_lock);
+      const int jtype = _args.getOpt<int>("jtype", 4, FlagGrid::TypeObstacle, &_lock);
+      _retval = getPyNone();
+      flipUpdateNeighborRatio(flags, neighborRatio, radius, itype, jtype);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "flipUpdateNeighborRatio", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("flipUpdateNeighborRatio", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_flipUpdateNeighborRatio("", "flipUpdateNeighborRatio", _W_11);
+extern "C" {
+void PbRegister_flipUpdateNeighborRatio()
+{
+  KEEP_UNUSED(_RP_flipUpdateNeighborRatio);
+}
+}
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+// Legacy Methods (still useful for debugging)
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+#pragma endregion
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/surfaceturbulence.cpp b/extern/mantaflow/preprocessed/plugin/surfaceturbulence.cpp
new file mode 100644
index 00000000000..465314f51ed
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/surfaceturbulence.cpp
@@ -0,0 +1,2189 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2016 Olivier Mercier, oli.mercier@gmail.com
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Surface Turbulence for Particle-Based Liquid Simulations
+ * Mercier et al., SIGGRAPH Asia 2015
+ *
+ * Possible speedups :
+ * - only initialize surface points around coarse particles near the surface. Use the flags in the
+ *fluid grid and only use cells with non-fluid neighbors.
+ *
+ ******************************************************************************/
+
+// use chrono stl for detailed timing only if available
+#ifdef __GNUC__
+#  if __GNUC__ < 5
+#    define USE_CHRONO 0
+#  endif
+#endif
+
+#if MANTA_WITHCPP11 == 1
+#  ifndef USE_CHRONO
+#    define USE_CHRONO 1
+#  endif
+#endif
+
+#include <iomanip>
+#if USE_CHRONO == 1
+#  include <chrono>
+#endif
+#include "particle.h"
+
+using namespace std;
+namespace Manta {
+
+// own namespace for globals
+namespace SurfaceTurbulence {
+
+//
+// **** surface turbulence parameters ****
+//
+struct SurfaceTurbulenceParameters {
+  int res;
+  Real outerRadius;
+  int surfaceDensity;
+  int nbSurfaceMaintenanceIterations;
+  Real dt;
+  Real waveSpeed;
+  Real waveDamping;
+  Real waveSeedFrequency;
+  Real waveMaxAmplitude;
+  Real waveMaxFrequency;
+  Real waveMaxSeedingAmplitude;  // as ratio of max amp;
+  Real waveSeedingCurvatureThresholdRegionCenter;
+  Real waveSeedingCurvatureThresholdRegionRadius;
+  Real waveSeedStepSizeRatioOfMax;
+  Real innerRadius;
+  Real meanFineDistance;
+  Real constraintA;
+  Real normalRadius;
+  Real tangentRadius;
+  Real bndXm, bndXp, bndYm, bndYp, bndZm, bndZp;
+};
+SurfaceTurbulenceParameters params;
+
+//
+// **** acceleration grid for particle neighbor queries ****
+//
+struct ParticleAccelGrid {
+  int res;
+  vector<int> ***indices;
+
+  void init(int inRes)
+  {
+    res = inRes;
+    indices = new vector<int> **[res];
+    for (int i = 0; i < res; i++) {
+      indices[i] = new vector<int> *[res];
+      for (int j = 0; j < res; j++) {
+        indices[i][j] = new vector<int>[res];
+      }
+    }
+  }
+
+  void fillWith(const BasicParticleSystem &particles)
+  {
+    // clear
+    for (int i = 0; i < res; i++) {
+      for (int j = 0; j < res; j++) {
+        for (int k = 0; k < res; k++) {
+          indices[i][j][k].clear();
+        }
+      }
+    }
+
+    // fill
+    for (int id = 0; id < particles.size(); id++) {
+      Vec3 pos = particles.getPos(id);
+      int i = clamp<int>(floor(pos.x / params.res * res), 0, res - 1);
+      int j = clamp<int>(floor(pos.y / params.res * res), 0, res - 1);
+      int k = clamp<int>(floor(pos.z / params.res * res), 0, res - 1);
+      indices[i][j][k].push_back(id);
+    }
+  }
+
+  void fillWith(const ParticleDataImpl<Vec3> &particles)
+  {
+    // clear
+    for (int i = 0; i < res; i++) {
+      for (int j = 0; j < res; j++) {
+        for (int k = 0; k < res; k++) {
+          indices[i][j][k].clear();
+        }
+      }
+    }
+
+    // fill
+    for (int id = 0; id < particles.size(); id++) {
+      Vec3 pos = particles[id];
+      int i = clamp<int>(floor(pos.x / params.res * res), 0, res - 1);
+      int j = clamp<int>(floor(pos.y / params.res * res), 0, res - 1);
+      int k = clamp<int>(floor(pos.z / params.res * res), 0, res - 1);
+      indices[i][j][k].push_back(id);
+    }
+  }
+};
+
+#define LOOP_NEIGHBORS_BEGIN(points, center, radius) \
+  int minI = clamp<int>( \
+      floor((center.x - radius) / params.res * points.accel->res), 0, points.accel->res - 1); \
+  int maxI = clamp<int>( \
+      floor((center.x + radius) / params.res * points.accel->res), 0, points.accel->res - 1); \
+  int minJ = clamp<int>( \
+      floor((center.y - radius) / params.res * points.accel->res), 0, points.accel->res - 1); \
+  int maxJ = clamp<int>( \
+      floor((center.y + radius) / params.res * points.accel->res), 0, points.accel->res - 1); \
+  int minK = clamp<int>( \
+      floor((center.z - radius) / params.res * points.accel->res), 0, points.accel->res - 1); \
+  int maxK = clamp<int>( \
+      floor((center.z + radius) / params.res * points.accel->res), 0, points.accel->res - 1); \
+  for (int i = minI; i <= maxI; i++) { \
+    for (int j = minJ; j <= maxJ; j++) { \
+      for (int k = minK; k <= maxK; k++) { \
+        for (int idLOOPNEIGHBORS = 0; \
+             idLOOPNEIGHBORS < (int)points.accel->indices[i][j][k].size(); \
+             idLOOPNEIGHBORS++) { \
+          int idn = points.accel->indices[i][j][k][idLOOPNEIGHBORS]; \
+          if (points.isActive(idn)) {
+#define LOOP_NEIGHBORS_END \
+  } \
+  } \
+  } \
+  } \
+  }
+
+#define LOOP_GHOSTS_POS_BEGIN(pos, radius) \
+  int flagLOOPGHOSTS = -1; \
+  Vec3 gPos; \
+  while (flagLOOPGHOSTS < 6) { \
+    if (flagLOOPGHOSTS < 0 && pos.x - params.bndXm <= radius) { \
+      flagLOOPGHOSTS = 0; \
+      gPos = Vec3(2.f * params.bndXm - pos.x, pos.y, pos.z); \
+    } \
+    else if (flagLOOPGHOSTS < 1 && params.bndXp - pos.x <= radius) { \
+      flagLOOPGHOSTS = 1; \
+      gPos = Vec3(2.f * params.bndXp - pos.x, pos.y, pos.z); \
+    } \
+    else if (flagLOOPGHOSTS < 2 && pos.y - params.bndYm <= radius) { \
+      flagLOOPGHOSTS = 2; \
+      gPos = Vec3(pos.x, 2.f * params.bndYm - pos.y, pos.z); \
+    } \
+    else if (flagLOOPGHOSTS < 3 && params.bndYp - pos.y <= radius) { \
+      flagLOOPGHOSTS = 3; \
+      gPos = Vec3(pos.x, 2.f * params.bndYp - pos.y, pos.z); \
+    } \
+    else if (flagLOOPGHOSTS < 4 && pos.z - params.bndZm <= radius) { \
+      flagLOOPGHOSTS = 4; \
+      gPos = Vec3(pos.x, pos.y, 2.f * params.bndZm - pos.z); \
+    } \
+    else if (flagLOOPGHOSTS < 5 && params.bndZp - pos.Z <= radius) { \
+      flagLOOPGHOSTS = 5; \
+      gPos = Vec3(pos.x, pos.y, 2.f * params.bndZp - pos.z); \
+    } \
+    else { \
+      flagLOOPGHOSTS = 6; \
+      gPos = Vec3(pos.x, pos.y, pos.z); \
+    }
+#define LOOP_GHOSTS_POS_NORMAL_BEGIN(pos, normal, radius) \
+  int flagLOOPGHOSTS = -1; \
+  Vec3 gPos, gNormal; \
+  while (flagLOOPGHOSTS < 6) { \
+    if (flagLOOPGHOSTS < 0 && pos.x - params.bndXm <= radius) { \
+      flagLOOPGHOSTS = 0; \
+      gPos = Vec3(2.f * params.bndXm - pos.x, pos.y, pos.z); \
+      gNormal = Vec3(-normal.x, normal.y, normal.z); \
+    } \
+    else if (flagLOOPGHOSTS < 1 && params.bndXp - pos.x <= radius) { \
+      flagLOOPGHOSTS = 1; \
+      gPos = Vec3(2.f * params.bndXp - pos.x, pos.y, pos.z); \
+      gNormal = Vec3(-normal.x, normal.y, normal.z); \
+    } \
+    else if (flagLOOPGHOSTS < 2 && pos.y - params.bndYm <= radius) { \
+      flagLOOPGHOSTS = 2; \
+      gPos = Vec3(pos.x, 2.f * params.bndYm - pos.y, pos.z); \
+      gNormal = Vec3(normal.x, -normal.y, normal.z); \
+    } \
+    else if (flagLOOPGHOSTS < 3 && params.bndYp - pos.y <= radius) { \
+      flagLOOPGHOSTS = 3; \
+      gPos = Vec3(pos.x, 2.f * params.bndYp - pos.y, pos.z); \
+      gNormal = Vec3(normal.x, -normal.y, normal.z); \
+    } \
+    else if (flagLOOPGHOSTS < 4 && pos.z - params.bndZm <= radius) { \
+      flagLOOPGHOSTS = 4; \
+      gPos = Vec3(pos.x, pos.y, 2.f * params.bndZm - pos.z); \
+      gNormal = Vec3(normal.x, normal.y, -normal.z); \
+    } \
+    else if (flagLOOPGHOSTS < 5 && params.bndZp - pos.Z <= radius) { \
+      flagLOOPGHOSTS = 5; \
+      gPos = Vec3(pos.x, pos.y, 2.f * params.bndZp - pos.z); \
+      gNormal = Vec3(normal.x, normal.y, -normal.z); \
+    } \
+    else { \
+      flagLOOPGHOSTS = 6; \
+      gPos = pos; \
+      gNormal = normal; \
+    }
+#define LOOP_GHOSTS_END }
+
+//
+// **** Wrappers around point sets to attach it an acceleration grid ****
+//
+struct PointSetWrapper {
+  ParticleAccelGrid *accel;
+
+  PointSetWrapper(ParticleAccelGrid *inAccel)
+  {
+    accel = inAccel;
+  }
+  virtual void updateAccel() = 0;
+};
+
+struct BasicParticleSystemWrapper : PointSetWrapper {
+  BasicParticleSystem *points;
+
+  BasicParticleSystemWrapper(ParticleAccelGrid *inAccel) : PointSetWrapper(inAccel)
+  {
+  }
+
+  Vec3 getPos(int id) const
+  {
+    return points->getPos(id);
+  }
+  void setPos(int id, Vec3 pos)
+  {
+    points->setPos(id, pos);
+  }
+  void updateAccel()
+  {
+    accel->fillWith(*points);
+  }
+  void clear()
+  {
+    points->clear();
+  }
+  int size() const
+  {
+    return points->size();
+  }
+  bool isActive(int id) const
+  {
+    return points->isActive(id);
+  }
+  void addParticle(Vec3 pos)
+  {
+    points->addParticle(pos);
+  }
+  int getStatus(int id) const
+  {
+    return points->getStatus(id);
+  }
+  void addBuffered(Vec3 pos)
+  {
+    points->addBuffered(pos);
+  }
+  void doCompress()
+  {
+    points->doCompress();
+  }
+  void insertBufferedParticles()
+  {
+    points->insertBufferedParticles();
+  }
+  void kill(int id)
+  {
+    points->kill(id);
+  }
+
+  bool hasNeighbor(Vec3 pos, Real radius) const
+  {
+    bool answer = false;
+    int minI = clamp<int>(floor((pos.x - radius) / params.res * accel->res), 0, accel->res - 1);
+    int maxI = clamp<int>(floor((pos.x + radius) / params.res * accel->res), 0, accel->res - 1);
+    int minJ = clamp<int>(floor((pos.y - radius) / params.res * accel->res), 0, accel->res - 1);
+    int maxJ = clamp<int>(floor((pos.y + radius) / params.res * accel->res), 0, accel->res - 1);
+    int minK = clamp<int>(floor((pos.z - radius) / params.res * accel->res), 0, accel->res - 1);
+    int maxK = clamp<int>(floor((pos.z + radius) / params.res * accel->res), 0, accel->res - 1);
+    for (int i = minI; i <= maxI; i++) {
+      for (int j = minJ; j <= maxJ; j++) {
+        for (int k = minK; k <= maxK; k++) {
+          for (int id = 0; id < (int)accel->indices[i][j][k].size(); id++) {
+            if (points->isActive(accel->indices[i][j][k][id]) &&
+                norm(points->getPos(accel->indices[i][j][k][id]) - pos) <= radius) {
+              answer = true;
+              break;
+            }
+          }
+          if (answer)
+            break;
+        }
+        if (answer)
+          break;
+      }
+      if (answer)
+        break;
+    }
+    return answer;
+  }
+
+  bool hasNeighborOtherThanItself(int idx, Real radius) const
+  {
+    bool answer = false;
+    Vec3 pos = points->getPos(idx);
+    int minI = clamp<int>(floor((pos.x - radius) / params.res * accel->res), 0, accel->res - 1);
+    int maxI = clamp<int>(floor((pos.x + radius) / params.res * accel->res), 0, accel->res - 1);
+    int minJ = clamp<int>(floor((pos.y - radius) / params.res * accel->res), 0, accel->res - 1);
+    int maxJ = clamp<int>(floor((pos.y + radius) / params.res * accel->res), 0, accel->res - 1);
+    int minK = clamp<int>(floor((pos.z - radius) / params.res * accel->res), 0, accel->res - 1);
+    int maxK = clamp<int>(floor((pos.z + radius) / params.res * accel->res), 0, accel->res - 1);
+    for (int i = minI; i <= maxI; i++) {
+      for (int j = minJ; j <= maxJ; j++) {
+        for (int k = minK; k <= maxK; k++) {
+          for (int id = 0; id < (int)accel->indices[i][j][k].size(); id++) {
+            if (accel->indices[i][j][k][id] != idx &&
+                points->isActive(accel->indices[i][j][k][id]) &&
+                norm(points->getPos(accel->indices[i][j][k][id]) - pos) <= radius) {
+              answer = true;
+              break;
+            }
+          }
+          if (answer)
+            break;
+        }
+        if (answer)
+          break;
+      }
+      if (answer)
+        break;
+    }
+    return answer;
+  }
+
+  void removeInvalidIndices(vector<int> &indices)
+  {
+    vector<int> copy;
+    copy.resize(indices.size());
+    for (int i = 0; i < (int)indices.size(); i++) {
+      copy[i] = indices[i];
+    }
+    indices.clear();
+    for (int i = 0; i < (int)copy.size(); i++) {
+      if (points->isActive(copy[i])) {
+        indices.push_back(copy[i]);
+      }
+    }
+  }
+};
+
+struct ParticleDataImplVec3Wrapper : PointSetWrapper {
+  ParticleDataImpl<Vec3> *points;
+
+  ParticleDataImplVec3Wrapper(ParticleAccelGrid *inAccel) : PointSetWrapper(inAccel)
+  {
+  }
+
+  Vec3 getVec3(int id) const
+  {
+    return (*points)[id];
+  }
+  void setVec3(int id, Vec3 vec)
+  {
+    (*points)[id] = vec;
+  }
+  void updateAccel()
+  {
+    accel->fillWith(*points);
+  }
+  bool isActive(int i) const
+  {
+    return true;
+  }
+};
+
+//
+// **** globals ****
+//
+ParticleAccelGrid accelCoarse, accelSurface;
+BasicParticleSystemWrapper coarseParticles(&accelCoarse), surfacePoints(&accelSurface);
+ParticleDataImplVec3Wrapper coarseParticlesPrevPos(
+    &accelCoarse);             // WARNING: reusing the coarse accel grid to save space, don't query
+                               // coarseParticlesPrevPos and coarseParticles at the same time.
+vector<Vec3> tempSurfaceVec3;  // to store misc info on surface points
+vector<Real> tempSurfaceFloat;  // to store misc info on surface points
+int frameCount = 0;
+
+//
+//**** weighting kernels *****
+//
+Real triangularWeight(Real distance, Real radius)
+{
+  return 1.0f - distance / radius;
+}
+Real exponentialWeight(Real distance, Real radius, Real falloff)
+{
+  if (distance > radius)
+    return 0;
+  Real tmp = distance / radius;
+  return expf(-falloff * tmp * tmp);
+}
+
+Real weightKernelAdvection(Real distance)
+{
+  if (distance > 2.f * params.outerRadius) {
+    return 0;
+  }
+  else {
+    return triangularWeight(distance, 2.f * params.outerRadius);
+  }
+}
+
+Real weightKernelCoarseDensity(Real distance)
+{
+  return exponentialWeight(distance, params.outerRadius, 2.0f);
+}
+
+Real weightSurfaceNormal(Real distance)
+{
+  if (distance > params.normalRadius) {
+    return 0;
+  }
+  else {
+    return triangularWeight(distance, params.normalRadius);
+  }
+}
+
+Real weightSurfaceTangent(Real distance)
+{
+  if (distance > params.tangentRadius) {
+    return 0;
+  }
+  else {
+    return triangularWeight(distance, params.tangentRadius);
+  }
+}
+
+//
+// **** utility ****
+//
+
+bool isInDomain(Vec3 pos)
+{
+  return params.bndXm <= pos.x && pos.x <= params.bndXp && params.bndYm <= pos.y &&
+         pos.y <= params.bndYp && params.bndZm <= pos.z && pos.z <= params.bndZp;
+}
+
+Real smoothstep(Real edgeLeft, Real edgeRight, Real val)
+{
+  Real x = clamp((val - edgeLeft) / (edgeRight - edgeLeft), Real(0.), Real(1.));
+  return x * x * (3 - 2 * x);
+}
+
+//
+// **** surface initialization ****
+//
+
+void initFines(const BasicParticleSystemWrapper &coarseParticles,
+               BasicParticleSystemWrapper &surfacePoints,
+               const FlagGrid &flags)
+{
+  unsigned int discretization = (unsigned int)M_PI * (params.outerRadius + params.innerRadius) /
+                                params.meanFineDistance;
+  Real dtheta = 2 * params.meanFineDistance / (params.outerRadius + params.innerRadius);
+  Real outerRadius2 = params.outerRadius * params.outerRadius;
+
+  surfacePoints.clear();
+  for (int idx = 0; idx < (int)coarseParticles.size(); idx++) {
+
+    if (idx % 500 == 0) {
+      cout << "Initializing surface points : " << setprecision(4)
+           << 100.f * idx / coarseParticles.size() << "%" << endl;
+    }
+
+    if (coarseParticles.isActive(idx)) {
+
+      // check flags if we are near surface
+      bool nearSurface = false;
+      Vec3 pos = coarseParticles.getPos(idx);
+      for (int i = -1; i <= 1; i++) {
+        for (int j = -1; j <= 1; j++) {
+          for (int k = -1; k <= 1; k++) {
+            if (!flags.isFluid(((int)pos.x) + i, ((int)pos.y) + j, ((int)pos.z) + k)) {
+              nearSurface = true;
+              break;
+            }
+          }
+        }
+      }
+
+      if (nearSurface) {
+        for (unsigned int i = 0; i <= discretization / 2; ++i) {
+          Real discretization2 = Real(floor(2 * M_PI * sin(i * dtheta) / dtheta) + 1);
+          for (Real phi = 0; phi < 2 * M_PI; phi += Real(2 * M_PI / discretization2)) {
+            Real theta = i * dtheta;
+            Vec3 normal(sin(theta) * cos(phi), cos(theta), sin(theta) * sin(phi));
+            Vec3 position = coarseParticles.getPos(idx) + params.outerRadius * normal;
+
+            bool valid = true;
+            LOOP_NEIGHBORS_BEGIN(coarseParticles, position, 2.f * params.outerRadius)
+            if (idx != idn && normSquare(position - coarseParticles.getPos(idn)) < outerRadius2) {
+              valid = false;
+              break;
+            }
+            LOOP_NEIGHBORS_END
+            if (valid) {
+              surfacePoints.addParticle(position);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+//
+// **** surface advection ****
+//
+
+struct advectSurfacePoints : public KernelBase {
+  advectSurfacePoints(BasicParticleSystemWrapper &surfacePoints,
+                      const BasicParticleSystemWrapper &coarseParticles,
+                      const ParticleDataImplVec3Wrapper &coarseParticlesPrevPos)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        coarseParticles(coarseParticles),
+        coarseParticlesPrevPos(coarseParticlesPrevPos)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 BasicParticleSystemWrapper &surfacePoints,
+                 const BasicParticleSystemWrapper &coarseParticles,
+                 const ParticleDataImplVec3Wrapper &coarseParticlesPrevPos) const
+  {
+    if (surfacePoints.isActive(idx)) {
+      Vec3 avgDisplacement(0, 0, 0);
+      Real totalWeight = 0;
+      Vec3 p = surfacePoints.getPos(idx);
+      LOOP_NEIGHBORS_BEGIN(
+          coarseParticlesPrevPos, surfacePoints.getPos(idx), 2.0f * params.outerRadius)
+      if ((coarseParticles.getStatus(idn) & ParticleBase::PNEW) == 0 &&
+          (coarseParticles.getStatus(idn) & ParticleBase::PDELETE) == 0) {
+        Vec3 disp = coarseParticles.getPos(idn) - coarseParticlesPrevPos.getVec3(idn);
+        Real distance = norm(coarseParticlesPrevPos.getVec3(idn) - p);
+        Real w = weightKernelAdvection(distance);
+        avgDisplacement += w * disp;
+        totalWeight += w;
+      }
+      LOOP_NEIGHBORS_END
+      if (totalWeight != 0)
+        avgDisplacement /= totalWeight;
+      surfacePoints.setPos(idx, p + avgDisplacement);
+    }
+  }
+  inline BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const BasicParticleSystemWrapper &getArg1()
+  {
+    return coarseParticles;
+  }
+  typedef BasicParticleSystemWrapper type1;
+  inline const ParticleDataImplVec3Wrapper &getArg2()
+  {
+    return coarseParticlesPrevPos;
+  }
+  typedef ParticleDataImplVec3Wrapper type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel advectSurfacePoints ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, coarseParticles, coarseParticlesPrevPos);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystemWrapper &surfacePoints;
+  const BasicParticleSystemWrapper &coarseParticles;
+  const ParticleDataImplVec3Wrapper &coarseParticlesPrevPos;
+};
+
+//
+// **** value and gradient of level-set band constraint ****
+//
+Real computeConstraintLevel(const BasicParticleSystemWrapper &coarseParticles, Vec3 pos)
+{
+  Real lvl = 0.0f;
+  LOOP_NEIGHBORS_BEGIN(coarseParticles, pos, 1.5f * params.outerRadius)
+  lvl += expf(-params.constraintA * normSquare(coarseParticles.getPos(idn) - pos));
+  LOOP_NEIGHBORS_END
+  if (lvl > 1.0f)
+    lvl = 1.0f;
+  lvl = (sqrtf(-logf(lvl) / params.constraintA) - params.innerRadius) /
+        (params.outerRadius - params.innerRadius);
+  return lvl;
+}
+
+Vec3 computeConstraintGradient(const BasicParticleSystemWrapper &coarseParticles, Vec3 pos)
+{
+  Vec3 gradient(0, 0, 0);
+  LOOP_NEIGHBORS_BEGIN(coarseParticles, pos, 1.5f * params.outerRadius)
+  gradient += 2.f * params.constraintA *
+              (Real)(expf(-params.constraintA * normSquare(coarseParticles.getPos(idn) - pos))) *
+              (pos - coarseParticles.getPos(idn));
+  LOOP_NEIGHBORS_END
+  return getNormalized(gradient);
+}
+
+//
+// **** compute surface normals ****
+//
+
+struct computeSurfaceNormals : public KernelBase {
+  computeSurfaceNormals(const BasicParticleSystemWrapper &surfacePoints,
+                        const BasicParticleSystemWrapper &coarseParticles,
+                        ParticleDataImpl<Vec3> &surfaceNormals)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        coarseParticles(coarseParticles),
+        surfaceNormals(surfaceNormals)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 const BasicParticleSystemWrapper &coarseParticles,
+                 ParticleDataImpl<Vec3> &surfaceNormals) const
+  {
+    Vec3 pos = surfacePoints.getPos(idx);
+
+    // approx normal with gradient
+    Vec3 gradient = computeConstraintGradient(coarseParticles, pos);
+
+    // get tangent frame
+    Vec3 n = getNormalized(gradient);
+    Vec3 vx(1, 0, 0);
+    Vec3 vy(0, 1, 0);
+    Real dotX = dot(n, vx);
+    Real dotY = dot(n, vy);
+    Vec3 t1 = getNormalized(fabs(dotX) < fabs(dotY) ? cross(n, vx) : cross(n, vy));
+    Vec3 t2 = getNormalized(cross(n, t1));  // initial frame
+
+    // linear fit of neighboring surface points in approximated tangent frame
+    Real sw = 0, swx = 0, swy = 0, swxy = 0, swx2 = 0, swy2 = 0, swxz = 0, swyz = 0, swz = 0;
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.normalRadius)
+    LOOP_GHOSTS_POS_BEGIN(surfacePoints.getPos(idn), params.normalRadius)
+    Real x = dot(gPos - pos, t1);
+    Real y = dot(gPos - pos, t2);
+    Real z = dot(gPos - pos, n);
+    Real w = weightSurfaceNormal(norm(pos - gPos));
+    swx2 += w * x * x;
+    swy2 += w * y * y;
+    swxy += w * x * y;
+    swxz += w * x * z;
+    swyz += w * y * z;
+    swx += w * x;
+    swy += w * y;
+    swz += w * z;
+    sw += w;
+    LOOP_GHOSTS_END
+    LOOP_NEIGHBORS_END
+    Real det = -sw * swxy * swxy + 2.f * swx * swxy * swy - swx2 * swy * swy - swx * swx * swy2 +
+               sw * swx2 * swy2;
+    if (det == 0) {
+      surfaceNormals[idx] = Vec3(0, 0, 0);
+    }
+    else {
+      Vec3 abc = 1.f / det *
+                 Vec3(swxz * (-swy * swy + sw * swy2) + swyz * (-sw * swxy + swx * swy) +
+                          swz * (swxy * swy - swx * swy2),
+                      swxz * (-sw * swxy + swx * swy) + swyz * (-swx * swx + sw * swx2) +
+                          swz * (swx * swxy - swx2 * swy),
+                      swxz * (swxy * swy - swx * swy2) + swyz * (swx * swxy - swx2 * swy) +
+                          swz * (-swxy * swxy + swx2 * swy2));
+      Vec3 normal = -getNormalized(t1 * abc.x + t2 * abc.y - n);
+      if (dot(gradient, normal) < 0) {
+        normal = -normal;
+      }
+      surfaceNormals[idx] = normal;
+    }
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const BasicParticleSystemWrapper &getArg1()
+  {
+    return coarseParticles;
+  }
+  typedef BasicParticleSystemWrapper type1;
+  inline ParticleDataImpl<Vec3> &getArg2()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeSurfaceNormals ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, coarseParticles, surfaceNormals);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  const BasicParticleSystemWrapper &coarseParticles;
+  ParticleDataImpl<Vec3> &surfaceNormals;
+};
+
+//
+// **** smooth surface normals ****
+//
+
+struct computeAveragedNormals : public KernelBase {
+  computeAveragedNormals(const BasicParticleSystemWrapper &surfacePoints,
+                         const ParticleDataImpl<Vec3> &surfaceNormals)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceNormals(surfaceNormals)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 const ParticleDataImpl<Vec3> &surfaceNormals) const
+  {
+    Vec3 pos = surfacePoints.getPos(idx);
+    Vec3 newNormal = Vec3(0, 0, 0);
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.normalRadius)
+    Real w = weightSurfaceNormal(norm(pos - surfacePoints.getPos(idn)));
+    newNormal += w * surfaceNormals[idn];
+    LOOP_NEIGHBORS_END
+    tempSurfaceVec3[idx] = getNormalized(newNormal);
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const ParticleDataImpl<Vec3> &getArg1()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeAveragedNormals ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceNormals);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  const ParticleDataImpl<Vec3> &surfaceNormals;
+};
+
+struct assignNormals : public KernelBase {
+  assignNormals(const BasicParticleSystemWrapper &surfacePoints,
+                ParticleDataImpl<Vec3> &surfaceNormals)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceNormals(surfaceNormals)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 ParticleDataImpl<Vec3> &surfaceNormals) const
+  {
+    surfaceNormals[idx] = tempSurfaceVec3[idx];
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline ParticleDataImpl<Vec3> &getArg1()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel assignNormals ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceNormals);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  ParticleDataImpl<Vec3> &surfaceNormals;
+};
+
+void smoothSurfaceNormals(const BasicParticleSystemWrapper &surfacePoints,
+                          ParticleDataImpl<Vec3> &surfaceNormals)
+{
+  tempSurfaceVec3.resize(surfacePoints.size());
+
+  computeAveragedNormals(surfacePoints, surfaceNormals);
+  assignNormals(surfacePoints, surfaceNormals);
+}
+
+//
+// **** addition/deletion of particles. Not parallel to prevent write/delete conflicts ****
+//
+
+void addDeleteSurfacePoints(BasicParticleSystemWrapper &surfacePoints)
+{
+  int fixedSize = surfacePoints.size();
+  for (int idx = 0; idx < fixedSize; idx++) {
+    // compute proxy tangent displacement
+    Vec3 pos = surfacePoints.getPos(idx);
+
+    Vec3 gradient = computeConstraintGradient(coarseParticles, pos);
+
+    Real wt = 0;
+    Vec3 tangentDisplacement(0, 0, 0);
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.tangentRadius)
+    if (idn != idx) {
+      Vec3 dir = pos - surfacePoints.getPos(idn);
+      Real length = norm(dir);
+      dir = getNormalized(dir);
+
+      // Decompose direction into normal and tangent directions.
+      Vec3 dn = dot(dir, gradient) * gradient;
+      Vec3 dt = dir - dn;
+
+      Real w = weightSurfaceTangent(length);
+      wt += w;
+      tangentDisplacement += w * dt;
+    }
+    LOOP_NEIGHBORS_END
+    if (norm(tangentDisplacement) != 0) {
+      tangentDisplacement = getNormalized(tangentDisplacement);
+    }
+
+    // check density criterion, add surface point if necessary
+    Vec3 creationPos = pos + params.meanFineDistance * tangentDisplacement;
+    if (isInDomain(creationPos) &&
+        !surfacePoints.hasNeighbor(creationPos, params.meanFineDistance - (1e-6))) {
+      // create point
+      surfacePoints.addBuffered(creationPos);
+    }
+  }
+
+  surfacePoints.doCompress();
+  surfacePoints.insertBufferedParticles();
+
+  // check density criterion, delete surface points if necessary
+  fixedSize = surfacePoints.size();
+  for (int idx = 0; idx < fixedSize; idx++) {
+    if (!isInDomain(surfacePoints.getPos(idx)) ||
+        surfacePoints.hasNeighborOtherThanItself(idx, 0.67 * params.meanFineDistance)) {
+      surfacePoints.kill(idx);
+    }
+  }
+
+  // delete surface points if no coarse neighbors in advection radius
+  fixedSize = surfacePoints.size();
+  for (int idx = 0; idx < fixedSize; idx++) {
+    Vec3 pos = surfacePoints.getPos(idx);
+    if (!coarseParticles.hasNeighbor(pos, 2.f * params.outerRadius)) {
+      surfacePoints.kill(idx);
+    }
+  }
+
+  // delete surface point if too far from constraint
+  fixedSize = surfacePoints.size();
+  for (int idx = 0; idx < fixedSize; idx++) {
+    Real level = computeConstraintLevel(coarseParticles, surfacePoints.getPos(idx));
+    if (level < -0.2 || level > 1.2) {
+      surfacePoints.kill(idx);
+    }
+  }
+
+  surfacePoints.doCompress();
+  surfacePoints.insertBufferedParticles();
+}
+
+//
+// **** surface maintenance ****
+//
+
+struct computeSurfaceDensities : public KernelBase {
+  computeSurfaceDensities(const BasicParticleSystemWrapper &surfacePoints, void *dummy)
+      : KernelBase(surfacePoints.size()), surfacePoints(surfacePoints), dummy(dummy)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const BasicParticleSystemWrapper &surfacePoints, void *dummy) const
+  {
+    Vec3 pos = surfacePoints.getPos(idx);
+    Real density = 0;
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.normalRadius)
+    LOOP_GHOSTS_POS_BEGIN(surfacePoints.getPos(idn), params.normalRadius)
+    density += weightSurfaceNormal(norm(pos - gPos));
+    LOOP_GHOSTS_END
+    LOOP_NEIGHBORS_END
+    tempSurfaceFloat[idx] = density;
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline void *getArg1()
+  {
+    return dummy;
+  }
+  typedef void type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeSurfaceDensities ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, dummy);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  void *dummy;
+};
+
+struct computeSurfaceDisplacements : public KernelBase {
+  computeSurfaceDisplacements(const BasicParticleSystemWrapper &surfacePoints,
+                              const ParticleDataImpl<Vec3> &surfaceNormals)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceNormals(surfaceNormals)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 const ParticleDataImpl<Vec3> &surfaceNormals) const
+  {
+    Vec3 pos = surfacePoints.getPos(idx);
+    Vec3 normal = surfaceNormals[idx];
+
+    Vec3 displacementNormal(0, 0, 0);
+    Vec3 displacementTangent(0, 0, 0);
+    Real wTotal = 0;
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.normalRadius)
+
+    LOOP_GHOSTS_POS_NORMAL_BEGIN(
+        surfacePoints.getPos(idn), surfaceNormals[idn], params.normalRadius)
+    Vec3 dir = pos - gPos;
+    Real length = norm(dir);
+    Vec3 dn = dot(dir, surfaceNormals[idx]) * surfaceNormals[idx];
+    Vec3 dt = dir - dn;
+    if (tempSurfaceFloat[idn] == 0) {
+      continue;
+    }
+    Real w = weightSurfaceNormal(length) / tempSurfaceFloat[idn];
+
+    Vec3 crossVec = getNormalized(cross(normal, -dir));
+    Vec3 projectedNormal = getNormalized(gNormal - dot(crossVec, gNormal) * crossVec);
+    if (dot(projectedNormal, normal) < 0 || abs(dot(normal, normal + projectedNormal)) < 1e-6) {
+      continue;
+    }
+    dn = -dot(normal + projectedNormal, dir) / dot(normal, normal + projectedNormal) * normal;
+
+    displacementNormal += w * dn;
+    displacementTangent += w * getNormalized(dt);
+    wTotal += w;
+    LOOP_GHOSTS_END
+
+    LOOP_NEIGHBORS_END
+    if (wTotal != 0) {
+      displacementNormal /= wTotal;
+      displacementTangent /= wTotal;
+    }
+    displacementNormal *= .75f;
+    displacementTangent *= .25f * params.meanFineDistance;
+    tempSurfaceVec3[idx] = displacementNormal + displacementTangent;
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const ParticleDataImpl<Vec3> &getArg1()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeSurfaceDisplacements ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceNormals);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  const ParticleDataImpl<Vec3> &surfaceNormals;
+};
+
+struct applySurfaceDisplacements : public KernelBase {
+  applySurfaceDisplacements(BasicParticleSystemWrapper &surfacePoints, void *dummy)
+      : KernelBase(surfacePoints.size()), surfacePoints(surfacePoints), dummy(dummy)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, BasicParticleSystemWrapper &surfacePoints, void *dummy) const
+  {
+    surfacePoints.setPos(idx, surfacePoints.getPos(idx) + tempSurfaceVec3[idx]);
+  }
+  inline BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline void *getArg1()
+  {
+    return dummy;
+  }
+  typedef void type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel applySurfaceDisplacements ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, dummy);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystemWrapper &surfacePoints;
+  void *dummy;
+};
+
+void regularizeSurfacePoints(BasicParticleSystemWrapper &surfacePoints,
+                             const ParticleDataImpl<Vec3> &surfaceNormals)
+{
+  tempSurfaceVec3.resize(surfacePoints.size());
+  tempSurfaceFloat.resize(surfacePoints.size());
+
+  computeSurfaceDensities(surfacePoints, 0);
+  computeSurfaceDisplacements(surfacePoints, surfaceNormals);
+  applySurfaceDisplacements(surfacePoints, 0);
+}
+
+struct constrainSurface : public KernelBase {
+  constrainSurface(BasicParticleSystemWrapper &surfacePoints,
+                   const BasicParticleSystemWrapper &coarseParticles)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        coarseParticles(coarseParticles)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 BasicParticleSystemWrapper &surfacePoints,
+                 const BasicParticleSystemWrapper &coarseParticles) const
+  {
+    Vec3 pos = surfacePoints.getPos(idx);
+    Real level = computeConstraintLevel(coarseParticles, surfacePoints.getPos(idx));
+    if (level > 1) {
+      surfacePoints.setPos(
+          idx,
+          pos - (params.outerRadius - params.innerRadius) * (level - 1) *
+                    computeConstraintGradient(coarseParticles, surfacePoints.getPos(idx)));
+    }
+    else if (level < 0) {
+      surfacePoints.setPos(
+          idx,
+          pos - (params.outerRadius - params.innerRadius) * level *
+                    computeConstraintGradient(coarseParticles, surfacePoints.getPos(idx)));
+    }
+  }
+  inline BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const BasicParticleSystemWrapper &getArg1()
+  {
+    return coarseParticles;
+  }
+  typedef BasicParticleSystemWrapper type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel constrainSurface ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, coarseParticles);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  BasicParticleSystemWrapper &surfacePoints;
+  const BasicParticleSystemWrapper &coarseParticles;
+};
+
+struct interpolateNewWaveData : public KernelBase {
+  interpolateNewWaveData(const BasicParticleSystemWrapper &surfacePoints,
+                         ParticleDataImpl<Real> &surfaceWaveH,
+                         ParticleDataImpl<Real> &surfaceWaveDtH,
+                         ParticleDataImpl<Real> &surfaceWaveSeed,
+                         ParticleDataImpl<Real> &surfaceWaveSeedAmplitude)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceWaveH(surfaceWaveH),
+        surfaceWaveDtH(surfaceWaveDtH),
+        surfaceWaveSeed(surfaceWaveSeed),
+        surfaceWaveSeedAmplitude(surfaceWaveSeedAmplitude)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 ParticleDataImpl<Real> &surfaceWaveH,
+                 ParticleDataImpl<Real> &surfaceWaveDtH,
+                 ParticleDataImpl<Real> &surfaceWaveSeed,
+                 ParticleDataImpl<Real> &surfaceWaveSeedAmplitude) const
+  {
+    if (surfacePoints.getStatus(idx) & ParticleBase::PNEW) {
+      Vec3 pos = surfacePoints.getPos(idx);
+      surfaceWaveH[idx] = 0;
+      surfaceWaveDtH[idx] = 0;
+      Real wTotal = 0;
+      LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.tangentRadius)
+      if (!(surfacePoints.getStatus(idn) & ParticleBase::PNEW)) {
+        Real w = weightSurfaceTangent(norm(pos - surfacePoints.getPos(idn)));
+        surfaceWaveH[idx] += w * surfaceWaveH[idn];
+        surfaceWaveDtH[idx] += w * surfaceWaveDtH[idn];
+        surfaceWaveSeed[idx] += w * surfaceWaveSeed[idn];
+        surfaceWaveSeedAmplitude[idx] += w * surfaceWaveSeedAmplitude[idn];
+        wTotal += w;
+      }
+      LOOP_NEIGHBORS_END
+      if (wTotal != 0) {
+        surfaceWaveH[idx] /= wTotal;
+        surfaceWaveDtH[idx] /= wTotal;
+        surfaceWaveSeed[idx] /= wTotal;
+        surfaceWaveSeedAmplitude[idx] /= wTotal;
+      }
+    }
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline ParticleDataImpl<Real> &getArg1()
+  {
+    return surfaceWaveH;
+  }
+  typedef ParticleDataImpl<Real> type1;
+  inline ParticleDataImpl<Real> &getArg2()
+  {
+    return surfaceWaveDtH;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  inline ParticleDataImpl<Real> &getArg3()
+  {
+    return surfaceWaveSeed;
+  }
+  typedef ParticleDataImpl<Real> type3;
+  inline ParticleDataImpl<Real> &getArg4()
+  {
+    return surfaceWaveSeedAmplitude;
+  }
+  typedef ParticleDataImpl<Real> type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel interpolateNewWaveData ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx,
+         surfacePoints,
+         surfaceWaveH,
+         surfaceWaveDtH,
+         surfaceWaveSeed,
+         surfaceWaveSeedAmplitude);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  ParticleDataImpl<Real> &surfaceWaveH;
+  ParticleDataImpl<Real> &surfaceWaveDtH;
+  ParticleDataImpl<Real> &surfaceWaveSeed;
+  ParticleDataImpl<Real> &surfaceWaveSeedAmplitude;
+};
+
+void surfaceMaintenance(const BasicParticleSystemWrapper &coarseParticles,
+                        BasicParticleSystemWrapper &surfacePoints,
+                        ParticleDataImpl<Vec3> &surfaceNormals,
+                        ParticleDataImpl<Real> &surfaceWaveH,
+                        ParticleDataImpl<Real> &surfaceWaveDtH,
+                        ParticleDataImpl<Real> &surfaceWaveSeed,
+                        ParticleDataImpl<Real> &surfaceWaveSeedAmplitude,
+                        int nbIterations)
+{
+  int countIterations = nbIterations;
+  while (countIterations > 0) {
+    addDeleteSurfacePoints(surfacePoints);
+    surfacePoints.updateAccel();
+    computeSurfaceNormals(surfacePoints, coarseParticles, surfaceNormals);
+    smoothSurfaceNormals(surfacePoints, surfaceNormals);
+
+    regularizeSurfacePoints(surfacePoints, surfaceNormals);
+    surfacePoints.updateAccel();
+    constrainSurface(surfacePoints, coarseParticles);
+    surfacePoints.updateAccel();
+
+    interpolateNewWaveData(
+        surfacePoints, surfaceWaveH, surfaceWaveDtH, surfaceWaveSeed, surfaceWaveSeedAmplitude);
+
+    countIterations--;
+  }
+}
+
+//
+// **** surface wave seeding and evolution ****
+//
+
+struct addSeed : public KernelBase {
+  addSeed(const BasicParticleSystemWrapper &surfacePoints,
+          ParticleDataImpl<Real> &surfaceWaveH,
+          const ParticleDataImpl<Real> &surfaceWaveSeed)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceWaveH(surfaceWaveH),
+        surfaceWaveSeed(surfaceWaveSeed)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 ParticleDataImpl<Real> &surfaceWaveH,
+                 const ParticleDataImpl<Real> &surfaceWaveSeed) const
+  {
+    surfaceWaveH[idx] += surfaceWaveSeed[idx];
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline ParticleDataImpl<Real> &getArg1()
+  {
+    return surfaceWaveH;
+  }
+  typedef ParticleDataImpl<Real> type1;
+  inline const ParticleDataImpl<Real> &getArg2()
+  {
+    return surfaceWaveSeed;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel addSeed ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceWaveH, surfaceWaveSeed);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  ParticleDataImpl<Real> &surfaceWaveH;
+  const ParticleDataImpl<Real> &surfaceWaveSeed;
+};
+
+struct computeSurfaceWaveNormal : public KernelBase {
+  computeSurfaceWaveNormal(const BasicParticleSystemWrapper &surfacePoints,
+                           const ParticleDataImpl<Vec3> &surfaceNormals,
+                           const ParticleDataImpl<Real> &surfaceWaveH)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceNormals(surfaceNormals),
+        surfaceWaveH(surfaceWaveH)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 const ParticleDataImpl<Vec3> &surfaceNormals,
+                 const ParticleDataImpl<Real> &surfaceWaveH) const
+  {
+    Vec3 pos = surfacePoints.getPos(idx);
+
+    // get tangent frame
+    Vec3 n = getNormalized(surfaceNormals[idx]);
+    Vec3 vx(1, 0, 0);
+    Vec3 vy(0, 1, 0);
+    Real dotX = dot(n, vx);
+    Real dotY = dot(n, vy);
+    Vec3 t1 = getNormalized(fabs(dotX) < fabs(dotY) ? cross(n, vx) : cross(n, vy));
+    Vec3 t2 = getNormalized(cross(n, t1));
+
+    // linear fit
+    Real sw = 0, swx = 0, swy = 0, swxy = 0, swx2 = 0, swy2 = 0, swxz = 0, swyz = 0, swz = 0;
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pos, params.tangentRadius)
+    LOOP_GHOSTS_POS_BEGIN(surfacePoints.getPos(idn), params.tangentRadius)
+    Real x = dot(gPos - pos, t1);
+    Real y = dot(gPos - pos, t2);
+    Real z = surfaceWaveH[idn];
+    Real w = weightSurfaceTangent(norm(pos - gPos));
+    swx2 += w * x * x;
+    swy2 += w * y * y;
+    swxy += w * x * y;
+    swxz += w * x * z;
+    swyz += w * y * z;
+    swx += w * x;
+    swy += w * y;
+    swz += w * z;
+    sw += w;
+    LOOP_GHOSTS_END
+    LOOP_NEIGHBORS_END
+    Real det = -sw * swxy * swxy + 2.f * swx * swxy * swy - swx2 * swy * swy - swx * swx * swy2 +
+               sw * swx2 * swy2;
+    if (det == 0) {
+      tempSurfaceVec3[idx] = Vec3(0, 0, 0);
+    }
+    else {
+      Vec3 abc = 1.f / det *
+                 Vec3(swxz * (-swy * swy + sw * swy2) + swyz * (-sw * swxy + swx * swy) +
+                          swz * (swxy * swy - swx * swy2),
+                      swxz * (-sw * swxy + swx * swy) + swyz * (-swx * swx + sw * swx2) +
+                          swz * (swx * swxy - swx2 * swy),
+                      swxz * (swxy * swy - swx * swy2) + swyz * (swx * swxy - swx2 * swy) +
+                          swz * (-swxy * swxy + swx2 * swy2));
+      Vec3 waveNormal = -getNormalized(vx * abc.x + vy * abc.y - Vec3(0, 0, 1));
+      tempSurfaceVec3[idx] = waveNormal;
+    }
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const ParticleDataImpl<Vec3> &getArg1()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline const ParticleDataImpl<Real> &getArg2()
+  {
+    return surfaceWaveH;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeSurfaceWaveNormal ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceNormals, surfaceWaveH);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  const ParticleDataImpl<Vec3> &surfaceNormals;
+  const ParticleDataImpl<Real> &surfaceWaveH;
+};
+
+struct computeSurfaceWaveLaplacians : public KernelBase {
+  computeSurfaceWaveLaplacians(const BasicParticleSystemWrapper &surfacePoints,
+                               const ParticleDataImpl<Vec3> &surfaceNormals,
+                               const ParticleDataImpl<Real> &surfaceWaveH)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceNormals(surfaceNormals),
+        surfaceWaveH(surfaceWaveH)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 const ParticleDataImpl<Vec3> &surfaceNormals,
+                 const ParticleDataImpl<Real> &surfaceWaveH) const
+  {
+    Real laplacian = 0;
+    Real wTotal = 0;
+    Vec3 pPos = surfacePoints.getPos(idx);
+    Vec3 pNormal = surfaceNormals[idx];
+
+    Vec3 vx(1, 0, 0);
+    Vec3 vy(0, 1, 0);
+    Real dotX = dot(pNormal, vx);
+    Real dotY = dot(pNormal, vy);
+    Vec3 t1 = getNormalized(fabs(dotX) < fabs(dotY) ? cross(pNormal, vx) : cross(pNormal, vy));
+    Vec3 t2 = getNormalized(cross(pNormal, t1));
+
+    Vec3 pWaveNormal = tempSurfaceVec3[idx];
+    Real ph = surfaceWaveH[idx];
+    if (pWaveNormal.z == 0) {
+      tempSurfaceFloat[idx] = 0;
+    }
+    else {
+
+      LOOP_NEIGHBORS_BEGIN(surfacePoints, pPos, params.tangentRadius)
+      Real nh = surfaceWaveH[idn];
+      LOOP_GHOSTS_POS_BEGIN(surfacePoints.getPos(idn), params.tangentRadius)
+      Vec3 dir = gPos - pPos;
+      Real lengthDir = norm(dir);
+      if (lengthDir < 1e-5)
+        continue;
+      Vec3 tangentDir = lengthDir * getNormalized(dir - dot(dir, pNormal) * pNormal);
+      Real dirX = dot(tangentDir, t1);
+      Real dirY = dot(tangentDir, t2);
+      Real dz = nh - ph - (-pWaveNormal.x / pWaveNormal.z) * dirX -
+                (-pWaveNormal.y / pWaveNormal.z) * dirY;
+      Real w = weightSurfaceTangent(norm(pPos - gPos));
+      wTotal += w;
+      laplacian += clamp(w * 4 * dz / (lengthDir * lengthDir), Real(-100.), Real(100.));
+      LOOP_GHOSTS_END
+      LOOP_NEIGHBORS_END
+      if (wTotal != 0) {
+        tempSurfaceFloat[idx] = laplacian / wTotal;
+      }
+      else {
+        tempSurfaceFloat[idx] = 0;
+      }
+    }
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const ParticleDataImpl<Vec3> &getArg1()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  inline const ParticleDataImpl<Real> &getArg2()
+  {
+    return surfaceWaveH;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeSurfaceWaveLaplacians ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceNormals, surfaceWaveH);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  const ParticleDataImpl<Vec3> &surfaceNormals;
+  const ParticleDataImpl<Real> &surfaceWaveH;
+};
+
+struct evolveWave : public KernelBase {
+  evolveWave(const BasicParticleSystemWrapper &surfacePoints,
+             ParticleDataImpl<Real> &surfaceWaveH,
+             ParticleDataImpl<Real> &surfaceWaveDtH,
+             const ParticleDataImpl<Real> &surfaceWaveSeed)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceWaveH(surfaceWaveH),
+        surfaceWaveDtH(surfaceWaveDtH),
+        surfaceWaveSeed(surfaceWaveSeed)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 ParticleDataImpl<Real> &surfaceWaveH,
+                 ParticleDataImpl<Real> &surfaceWaveDtH,
+                 const ParticleDataImpl<Real> &surfaceWaveSeed) const
+  {
+    surfaceWaveDtH[idx] += params.waveSpeed * params.waveSpeed * params.dt * tempSurfaceFloat[idx];
+    surfaceWaveDtH[idx] /= (1 + params.dt * params.waveDamping);
+    surfaceWaveH[idx] += params.dt * surfaceWaveDtH[idx];
+    surfaceWaveH[idx] /= (1 + params.dt * params.waveDamping);
+    surfaceWaveH[idx] -= surfaceWaveSeed[idx];
+
+    // clamp H and DtH (to prevent rare extreme behaviors)
+    surfaceWaveDtH[idx] = clamp(surfaceWaveDtH[idx],
+                                -params.waveMaxFrequency * params.waveMaxAmplitude,
+                                params.waveMaxFrequency * params.waveMaxAmplitude);
+    surfaceWaveH[idx] = clamp(
+        surfaceWaveH[idx], -params.waveMaxAmplitude, params.waveMaxAmplitude);
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline ParticleDataImpl<Real> &getArg1()
+  {
+    return surfaceWaveH;
+  }
+  typedef ParticleDataImpl<Real> type1;
+  inline ParticleDataImpl<Real> &getArg2()
+  {
+    return surfaceWaveDtH;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  inline const ParticleDataImpl<Real> &getArg3()
+  {
+    return surfaceWaveSeed;
+  }
+  typedef ParticleDataImpl<Real> type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel evolveWave ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceWaveH, surfaceWaveDtH, surfaceWaveSeed);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  ParticleDataImpl<Real> &surfaceWaveH;
+  ParticleDataImpl<Real> &surfaceWaveDtH;
+  const ParticleDataImpl<Real> &surfaceWaveSeed;
+};
+
+struct computeSurfaceCurvature : public KernelBase {
+  computeSurfaceCurvature(const BasicParticleSystemWrapper &surfacePoints,
+                          const ParticleDataImpl<Vec3> &surfaceNormals)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceNormals(surfaceNormals)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 const ParticleDataImpl<Vec3> &surfaceNormals) const
+  {
+    Vec3 pPos = surfacePoints.getPos(idx);
+    Real wTotal = 0;
+    Real curv = 0;
+    Vec3 pNormal = surfaceNormals[idx];
+
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pPos, params.normalRadius)
+    LOOP_GHOSTS_POS_NORMAL_BEGIN(
+        surfacePoints.getPos(idn), surfaceNormals[idn], params.normalRadius)
+    Vec3 dir = pPos - gPos;
+    if (dot(pNormal, gNormal) < 0) {
+      continue;
+    }  // backfacing
+    Real dist = norm(dir);
+    if (dist < params.normalRadius / 100.f) {
+      continue;
+    }
+
+    Real distn = dot(dir, pNormal);
+
+    Real w = weightSurfaceNormal(dist);
+    curv += w * distn;
+    wTotal += w;
+    LOOP_GHOSTS_END
+    LOOP_NEIGHBORS_END
+    if (wTotal != 0) {
+      curv /= wTotal;
+    }
+    tempSurfaceFloat[idx] = fabs(curv);
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline const ParticleDataImpl<Vec3> &getArg1()
+  {
+    return surfaceNormals;
+  }
+  typedef ParticleDataImpl<Vec3> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel computeSurfaceCurvature ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceNormals);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  const ParticleDataImpl<Vec3> &surfaceNormals;
+};
+
+struct smoothCurvature : public KernelBase {
+  smoothCurvature(const BasicParticleSystemWrapper &surfacePoints,
+                  ParticleDataImpl<Real> &surfaceWaveSource)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceWaveSource(surfaceWaveSource)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 ParticleDataImpl<Real> &surfaceWaveSource) const
+  {
+    Vec3 pPos = surfacePoints.getPos(idx);
+    Real curv = 0;
+    Real wTotal = 0;
+
+    LOOP_NEIGHBORS_BEGIN(surfacePoints, pPos, params.normalRadius)
+    Real w = weightSurfaceNormal(norm(pPos - surfacePoints.getPos(idn)));
+    curv += w * tempSurfaceFloat[idn];
+    wTotal += w;
+    LOOP_NEIGHBORS_END
+    if (wTotal != 0) {
+      curv /= wTotal;
+    }
+    surfaceWaveSource[idx] = curv;
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline ParticleDataImpl<Real> &getArg1()
+  {
+    return surfaceWaveSource;
+  }
+  typedef ParticleDataImpl<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel smoothCurvature ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceWaveSource);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  ParticleDataImpl<Real> &surfaceWaveSource;
+};
+
+struct seedWaves : public KernelBase {
+  seedWaves(const BasicParticleSystemWrapper &surfacePoints,
+            ParticleDataImpl<Real> &surfaceWaveSeed,
+            ParticleDataImpl<Real> &surfaceWaveSeedAmplitude,
+            ParticleDataImpl<Real> &surfaceWaveSource)
+      : KernelBase(surfacePoints.size()),
+        surfacePoints(surfacePoints),
+        surfaceWaveSeed(surfaceWaveSeed),
+        surfaceWaveSeedAmplitude(surfaceWaveSeedAmplitude),
+        surfaceWaveSource(surfaceWaveSource)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 const BasicParticleSystemWrapper &surfacePoints,
+                 ParticleDataImpl<Real> &surfaceWaveSeed,
+                 ParticleDataImpl<Real> &surfaceWaveSeedAmplitude,
+                 ParticleDataImpl<Real> &surfaceWaveSource) const
+  {
+    Real source = smoothstep(params.waveSeedingCurvatureThresholdRegionCenter -
+                                 params.waveSeedingCurvatureThresholdRegionRadius,
+                             params.waveSeedingCurvatureThresholdRegionCenter +
+                                 params.waveSeedingCurvatureThresholdRegionRadius,
+                             (Real)surfaceWaveSource[idx]) *
+                      2.f -
+                  1.f;
+    Real freq = params.waveSeedFrequency;
+    Real theta = params.dt * frameCount * params.waveSpeed * freq;
+    Real costheta = cosf(theta);
+    Real maxSeedAmplitude = params.waveMaxSeedingAmplitude * params.waveMaxAmplitude;
+
+    surfaceWaveSeedAmplitude[idx] = clamp<Real>(surfaceWaveSeedAmplitude[idx] +
+                                                    source * params.waveSeedStepSizeRatioOfMax *
+                                                        maxSeedAmplitude,
+                                                0.f,
+                                                maxSeedAmplitude);
+    surfaceWaveSeed[idx] = surfaceWaveSeedAmplitude[idx] * costheta;
+
+    // source values for display (not used after this point anyway)
+    surfaceWaveSource[idx] = (source >= 0) ? 1 : 0;
+  }
+  inline const BasicParticleSystemWrapper &getArg0()
+  {
+    return surfacePoints;
+  }
+  typedef BasicParticleSystemWrapper type0;
+  inline ParticleDataImpl<Real> &getArg1()
+  {
+    return surfaceWaveSeed;
+  }
+  typedef ParticleDataImpl<Real> type1;
+  inline ParticleDataImpl<Real> &getArg2()
+  {
+    return surfaceWaveSeedAmplitude;
+  }
+  typedef ParticleDataImpl<Real> type2;
+  inline ParticleDataImpl<Real> &getArg3()
+  {
+    return surfaceWaveSource;
+  }
+  typedef ParticleDataImpl<Real> type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel seedWaves ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, surfacePoints, surfaceWaveSeed, surfaceWaveSeedAmplitude, surfaceWaveSource);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  const BasicParticleSystemWrapper &surfacePoints;
+  ParticleDataImpl<Real> &surfaceWaveSeed;
+  ParticleDataImpl<Real> &surfaceWaveSeedAmplitude;
+  ParticleDataImpl<Real> &surfaceWaveSource;
+};
+
+void surfaceWaves(const BasicParticleSystemWrapper &surfacePoints,
+                  const ParticleDataImpl<Vec3> &surfaceNormals,
+                  ParticleDataImpl<Real> &surfaceWaveH,
+                  ParticleDataImpl<Real> &surfaceWaveDtH,
+                  ParticleDataImpl<Real> &surfaceWaveSource,
+                  ParticleDataImpl<Real> &surfaceWaveSeed,
+                  ParticleDataImpl<Real> &surfaceWaveSeedAmplitude)
+{
+  addSeed(surfacePoints, surfaceWaveH, surfaceWaveSeed);
+  computeSurfaceWaveNormal(surfacePoints, surfaceNormals, surfaceWaveH);
+  computeSurfaceWaveLaplacians(surfacePoints, surfaceNormals, surfaceWaveH);
+  evolveWave(surfacePoints, surfaceWaveH, surfaceWaveDtH, surfaceWaveSeed);
+  computeSurfaceCurvature(surfacePoints, surfaceNormals);
+  smoothCurvature(surfacePoints, surfaceWaveSource);
+  seedWaves(surfacePoints, surfaceWaveSeed, surfaceWaveSeedAmplitude, surfaceWaveSource);
+}
+
+//
+// **** main function ****
+//
+
+void particleSurfaceTurbulence(const FlagGrid &flags,
+                               BasicParticleSystem &coarseParts,
+                               ParticleDataImpl<Vec3> &coarsePartsPrevPos,
+                               BasicParticleSystem &surfPoints,
+                               ParticleDataImpl<Vec3> &surfaceNormals,
+                               ParticleDataImpl<Real> &surfaceWaveH,
+                               ParticleDataImpl<Real> &surfaceWaveDtH,
+                               BasicParticleSystem &surfacePointsDisplaced,
+                               ParticleDataImpl<Real> &surfaceWaveSource,
+                               ParticleDataImpl<Real> &surfaceWaveSeed,
+                               ParticleDataImpl<Real> &surfaceWaveSeedAmplitude,
+                               int res,
+                               Real outerRadius = 1.0f,
+                               int surfaceDensity = 20,
+                               int nbSurfaceMaintenanceIterations = 4,
+                               Real dt = 0.005f,
+                               Real waveSpeed = 16.0f,
+                               Real waveDamping = 0.0f,
+                               Real waveSeedFrequency = 4,
+                               Real waveMaxAmplitude = 0.25f,
+                               Real waveMaxFrequency = 800,
+                               Real waveMaxSeedingAmplitude = 0.5,
+                               Real waveSeedingCurvatureThresholdRegionCenter = 0.025f,
+                               Real waveSeedingCurvatureThresholdRegionRadius = 0.01f,
+                               Real waveSeedStepSizeRatioOfMax = 0.05f)
+{
+#if USE_CHRONO == 1
+  static std::chrono::high_resolution_clock::time_point begin, end;
+  end = std::chrono::high_resolution_clock::now();
+  cout << std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count() / 1000000000.f
+       << " : time sim" << endl;
+  begin = std::chrono::high_resolution_clock::now();
+#endif
+
+  // wrap data
+  coarseParticles.points = &coarseParts;
+  coarseParticlesPrevPos.points = &coarsePartsPrevPos;
+  surfacePoints.points = &surfPoints;
+
+  // copy parameters
+  params.res = res;
+  params.outerRadius = outerRadius;
+  params.surfaceDensity = surfaceDensity;
+  params.nbSurfaceMaintenanceIterations = nbSurfaceMaintenanceIterations;
+  params.dt = dt;
+  params.waveSpeed = waveSpeed;
+  params.waveDamping = waveDamping;
+  params.waveSeedFrequency = waveSeedFrequency;
+  params.waveMaxAmplitude = waveMaxAmplitude;
+  params.waveMaxFrequency = waveMaxFrequency;
+  params.waveMaxSeedingAmplitude = waveMaxSeedingAmplitude;
+  params.waveSeedingCurvatureThresholdRegionCenter = waveSeedingCurvatureThresholdRegionCenter;
+  params.waveSeedingCurvatureThresholdRegionRadius = waveSeedingCurvatureThresholdRegionRadius;
+  params.waveSeedStepSizeRatioOfMax = waveSeedStepSizeRatioOfMax;
+
+  // compute other parameters
+  params.innerRadius = params.outerRadius / 2.0;
+  params.meanFineDistance = M_PI * (params.outerRadius + params.innerRadius) /
+                            params.surfaceDensity;
+  params.constraintA = logf(2.0f / (1.0f + weightKernelCoarseDensity(params.outerRadius +
+                                                                     params.innerRadius))) /
+                       (powf((params.outerRadius + params.innerRadius) / 2, 2) -
+                        params.innerRadius * params.innerRadius);
+  params.normalRadius = 0.5f * (params.outerRadius + params.innerRadius);
+  params.tangentRadius = 2.1f * params.meanFineDistance;
+  params.bndXm = params.bndYm = params.bndZm = 2;
+  params.bndXp = params.bndYp = params.bndZp = params.res - 2;
+
+  if (frameCount == 0) {
+
+    // initialize accel grids
+    accelCoarse.init(2.f * res / params.outerRadius);
+    accelSurface.init(1.f * res / (2.f * params.meanFineDistance));
+
+    // update coarse accel structure
+    coarseParticles.updateAccel();
+
+    // create surface points
+    initFines(coarseParticles, surfacePoints, flags);
+
+    // smooth surface
+    surfaceMaintenance(coarseParticles,
+                       surfacePoints,
+                       surfaceNormals,
+                       surfaceWaveH,
+                       surfaceWaveDtH,
+                       surfaceWaveSeed,
+                       surfaceWaveSeedAmplitude,
+                       6 * params.nbSurfaceMaintenanceIterations);
+
+    // set wave values to zero
+    for (int idx = 0; idx < surfacePoints.size(); idx++) {
+      surfaceWaveH[idx] = 0;
+      surfaceWaveDtH[idx] = 0;
+      surfaceWaveSeed[idx] = 0;
+      surfaceWaveSeedAmplitude[idx] = 0;
+    }
+  }
+  else {
+
+    // update coarse accel structure with previous coarse particles positions
+    coarseParticlesPrevPos.updateAccel();
+
+    // advect surface points following coarse particles
+    advectSurfacePoints(surfacePoints, coarseParticles, coarseParticlesPrevPos);
+    surfacePoints.updateAccel();
+
+    // update acceleration structure for surface points
+    coarseParticles.updateAccel();
+
+    // surface maintenance
+    surfaceMaintenance(coarseParticles,
+                       surfacePoints,
+                       surfaceNormals,
+                       surfaceWaveH,
+                       surfaceWaveDtH,
+                       surfaceWaveSeed,
+                       surfaceWaveSeedAmplitude,
+                       params.nbSurfaceMaintenanceIterations);
+
+    // surface waves
+    surfaceWaves(surfacePoints,
+                 surfaceNormals,
+                 surfaceWaveH,
+                 surfaceWaveDtH,
+                 surfaceWaveSource,
+                 surfaceWaveSeed,
+                 surfaceWaveSeedAmplitude);
+  }
+  frameCount++;
+
+  // save positions as previous positions for next step
+  for (int id = 0; id < coarseParticles.size(); id++) {
+    if ((coarseParticles.getStatus(id) & ParticleBase::PNEW) == 0 &&
+        (coarseParticles.getStatus(id) & ParticleBase::PDELETE) == 0) {
+      coarseParticlesPrevPos.setVec3(id, coarseParticles.getPos(id));
+    }
+  }
+
+  // create displaced points for display
+  surfacePointsDisplaced.clear();
+  for (int idx = 0; idx < surfacePoints.size(); idx++) {
+    if ((surfacePoints.getStatus(idx) & ParticleBase::PDELETE) == 0) {
+      surfacePointsDisplaced.addParticle(surfacePoints.getPos(idx) +
+                                         surfaceNormals[idx] * surfaceWaveH[idx]);
+    }
+  }
+
+#if USE_CHRONO == 1
+  end = std::chrono::high_resolution_clock::now();
+  cout << std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count() / 1000000000.f
+       << " : time upres" << endl;
+  begin = std::chrono::high_resolution_clock::now();
+#endif
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "particleSurfaceTurbulence", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      BasicParticleSystem &coarseParts = *_args.getPtr<BasicParticleSystem>(
+          "coarseParts", 1, &_lock);
+      ParticleDataImpl<Vec3> &coarsePartsPrevPos = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "coarsePartsPrevPos", 2, &_lock);
+      BasicParticleSystem &surfPoints = *_args.getPtr<BasicParticleSystem>(
+          "surfPoints", 3, &_lock);
+      ParticleDataImpl<Vec3> &surfaceNormals = *_args.getPtr<ParticleDataImpl<Vec3>>(
+          "surfaceNormals", 4, &_lock);
+      ParticleDataImpl<Real> &surfaceWaveH = *_args.getPtr<ParticleDataImpl<Real>>(
+          "surfaceWaveH", 5, &_lock);
+      ParticleDataImpl<Real> &surfaceWaveDtH = *_args.getPtr<ParticleDataImpl<Real>>(
+          "surfaceWaveDtH", 6, &_lock);
+      BasicParticleSystem &surfacePointsDisplaced = *_args.getPtr<BasicParticleSystem>(
+          "surfacePointsDisplaced", 7, &_lock);
+      ParticleDataImpl<Real> &surfaceWaveSource = *_args.getPtr<ParticleDataImpl<Real>>(
+          "surfaceWaveSource", 8, &_lock);
+      ParticleDataImpl<Real> &surfaceWaveSeed = *_args.getPtr<ParticleDataImpl<Real>>(
+          "surfaceWaveSeed", 9, &_lock);
+      ParticleDataImpl<Real> &surfaceWaveSeedAmplitude = *_args.getPtr<ParticleDataImpl<Real>>(
+          "surfaceWaveSeedAmplitude", 10, &_lock);
+      int res = _args.get<int>("res", 11, &_lock);
+      Real outerRadius = _args.getOpt<Real>("outerRadius", 12, 1.0f, &_lock);
+      int surfaceDensity = _args.getOpt<int>("surfaceDensity", 13, 20, &_lock);
+      int nbSurfaceMaintenanceIterations = _args.getOpt<int>(
+          "nbSurfaceMaintenanceIterations", 14, 4, &_lock);
+      Real dt = _args.getOpt<Real>("dt", 15, 0.005f, &_lock);
+      Real waveSpeed = _args.getOpt<Real>("waveSpeed", 16, 16.0f, &_lock);
+      Real waveDamping = _args.getOpt<Real>("waveDamping", 17, 0.0f, &_lock);
+      Real waveSeedFrequency = _args.getOpt<Real>("waveSeedFrequency", 18, 4, &_lock);
+      Real waveMaxAmplitude = _args.getOpt<Real>("waveMaxAmplitude", 19, 0.25f, &_lock);
+      Real waveMaxFrequency = _args.getOpt<Real>("waveMaxFrequency", 20, 800, &_lock);
+      Real waveMaxSeedingAmplitude = _args.getOpt<Real>(
+          "waveMaxSeedingAmplitude", 21, 0.5, &_lock);
+      Real waveSeedingCurvatureThresholdRegionCenter = _args.getOpt<Real>(
+          "waveSeedingCurvatureThresholdRegionCenter", 22, 0.025f, &_lock);
+      Real waveSeedingCurvatureThresholdRegionRadius = _args.getOpt<Real>(
+          "waveSeedingCurvatureThresholdRegionRadius", 23, 0.01f, &_lock);
+      Real waveSeedStepSizeRatioOfMax = _args.getOpt<Real>(
+          "waveSeedStepSizeRatioOfMax", 24, 0.05f, &_lock);
+      _retval = getPyNone();
+      particleSurfaceTurbulence(flags,
+                                coarseParts,
+                                coarsePartsPrevPos,
+                                surfPoints,
+                                surfaceNormals,
+                                surfaceWaveH,
+                                surfaceWaveDtH,
+                                surfacePointsDisplaced,
+                                surfaceWaveSource,
+                                surfaceWaveSeed,
+                                surfaceWaveSeedAmplitude,
+                                res,
+                                outerRadius,
+                                surfaceDensity,
+                                nbSurfaceMaintenanceIterations,
+                                dt,
+                                waveSpeed,
+                                waveDamping,
+                                waveSeedFrequency,
+                                waveMaxAmplitude,
+                                waveMaxFrequency,
+                                waveMaxSeedingAmplitude,
+                                waveSeedingCurvatureThresholdRegionCenter,
+                                waveSeedingCurvatureThresholdRegionRadius,
+                                waveSeedStepSizeRatioOfMax);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "particleSurfaceTurbulence", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("particleSurfaceTurbulence", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_particleSurfaceTurbulence("", "particleSurfaceTurbulence", _W_0);
+extern "C" {
+void PbRegister_particleSurfaceTurbulence()
+{
+  KEEP_UNUSED(_RP_particleSurfaceTurbulence);
+}
+}
+
+void debugCheckParts(const BasicParticleSystem &parts, const FlagGrid &flags)
+{
+  for (int idx = 0; idx < parts.size(); idx++) {
+    Vec3i p = toVec3i(parts.getPos(idx));
+    if (!flags.isInBounds(p)) {
+      debMsg("bad position??? " << idx << " " << parts.getPos(idx), 1);
+      exit(1);
+    }
+  }
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "debugCheckParts", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
+      _retval = getPyNone();
+      debugCheckParts(parts, flags);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "debugCheckParts", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("debugCheckParts", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_debugCheckParts("", "debugCheckParts", _W_1);
+extern "C" {
+void PbRegister_debugCheckParts()
+{
+  KEEP_UNUSED(_RP_debugCheckParts);
+}
+}
+
+}  // namespace SurfaceTurbulence
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/vortexplugins.cpp b/extern/mantaflow/preprocessed/plugin/vortexplugins.cpp
new file mode 100644
index 00000000000..c2a21d82689
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/vortexplugins.cpp
@@ -0,0 +1,695 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Plugins for using vortex sheet meshes
+ *
+ ******************************************************************************/
+
+#include <iostream>
+#include "vortexsheet.h"
+#include "vortexpart.h"
+#include "shapes.h"
+#include "commonkernels.h"
+#include "conjugategrad.h"
+#include "randomstream.h"
+#include "levelset.h"
+
+using namespace std;
+
+namespace Manta {
+
+//! Mark area of mesh inside shape as fixed nodes.
+//! Remove all other fixed nodes if 'exclusive' is set
+
+void markAsFixed(Mesh &mesh, const Shape *shape, bool exclusive = true)
+{
+  for (int i = 0; i < mesh.numNodes(); i++) {
+    if (shape->isInside(mesh.nodes(i).pos))
+      mesh.nodes(i).flags |= Mesh::NfFixed;
+    else if (exclusive)
+      mesh.nodes(i).flags &= ~Mesh::NfFixed;
+  }
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "markAsFixed", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+      const Shape *shape = _args.getPtr<Shape>("shape", 1, &_lock);
+      bool exclusive = _args.getOpt<bool>("exclusive", 2, true, &_lock);
+      _retval = getPyNone();
+      markAsFixed(mesh, shape, exclusive);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "markAsFixed", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("markAsFixed", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_markAsFixed("", "markAsFixed", _W_0);
+extern "C" {
+void PbRegister_markAsFixed()
+{
+  KEEP_UNUSED(_RP_markAsFixed);
+}
+}
+
+//! Adapt texture coordinates of mesh inside shape
+//! to obtain an effective inflow effect
+
+void texcoordInflow(VortexSheetMesh &mesh, const Shape *shape, const MACGrid &vel)
+{
+  static Vec3 t0 = Vec3::Zero;
+
+  // get mean velocity
+  int cnt = 0;
+  Vec3 meanV(0.0);
+  FOR_IJK(vel)
+  {
+    if (shape->isInsideGrid(i, j, k)) {
+      cnt++;
+      meanV += vel.getCentered(i, j, k);
+    }
+  }
+  meanV /= (Real)cnt;
+  t0 -= mesh.getParent()->getDt() * meanV;
+  mesh.setReferenceTexOffset(t0);
+
+  // apply mean velocity
+  for (int i = 0; i < mesh.numNodes(); i++) {
+    if (shape->isInside(mesh.nodes(i).pos)) {
+      Vec3 tc = mesh.nodes(i).pos + t0;
+      mesh.tex1(i) = tc;
+      mesh.tex2(i) = tc;
+    }
+  }
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "texcoordInflow", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
+      const Shape *shape = _args.getPtr<Shape>("shape", 1, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 2, &_lock);
+      _retval = getPyNone();
+      texcoordInflow(mesh, shape, vel);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "texcoordInflow", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("texcoordInflow", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_texcoordInflow("", "texcoordInflow", _W_1);
+extern "C" {
+void PbRegister_texcoordInflow()
+{
+  KEEP_UNUSED(_RP_texcoordInflow);
+}
+}
+
+;
+
+//! Init smoke density values of the mesh surface inside source shape
+
+void meshSmokeInflow(VortexSheetMesh &mesh, const Shape *shape, Real amount)
+{
+  for (int t = 0; t < mesh.numTris(); t++) {
+    if (shape->isInside(mesh.getFaceCenter(t)))
+      mesh.sheet(t).smokeAmount = amount;
+  }
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "meshSmokeInflow", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
+      const Shape *shape = _args.getPtr<Shape>("shape", 1, &_lock);
+      Real amount = _args.get<Real>("amount", 2, &_lock);
+      _retval = getPyNone();
+      meshSmokeInflow(mesh, shape, amount);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "meshSmokeInflow", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("meshSmokeInflow", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_meshSmokeInflow("", "meshSmokeInflow", _W_2);
+extern "C" {
+void PbRegister_meshSmokeInflow()
+{
+  KEEP_UNUSED(_RP_meshSmokeInflow);
+}
+}
+
+struct KnAcceleration : public KernelBase {
+  KnAcceleration(MACGrid &a, const MACGrid &v1, const MACGrid &v0, const Real idt)
+      : KernelBase(&a, 0), a(a), v1(v1), v0(v0), idt(idt)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      IndexInt idx, MACGrid &a, const MACGrid &v1, const MACGrid &v0, const Real idt) const
+  {
+    a[idx] = (v1[idx] - v0[idx]) * idt;
+  }
+  inline MACGrid &getArg0()
+  {
+    return a;
+  }
+  typedef MACGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return v1;
+  }
+  typedef MACGrid type1;
+  inline const MACGrid &getArg2()
+  {
+    return v0;
+  }
+  typedef MACGrid type2;
+  inline const Real &getArg3()
+  {
+    return idt;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnAcceleration ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, a, v1, v0, idt);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  MACGrid &a;
+  const MACGrid &v1;
+  const MACGrid &v0;
+  const Real idt;
+};
+
+//! Add vorticity to vortex sheets based on buoyancy
+
+void vorticitySource(VortexSheetMesh &mesh,
+                     Vec3 gravity,
+                     const MACGrid *vel = NULL,
+                     const MACGrid *velOld = NULL,
+                     Real scale = 0.1,
+                     Real maxAmount = 0,
+                     Real mult = 1.0)
+{
+  Real dt = mesh.getParent()->getDt();
+  Real dx = mesh.getParent()->getDx();
+  MACGrid acceleration(mesh.getParent());
+  if (vel)
+    KnAcceleration(acceleration, *vel, *velOld, 1.0 / dt);
+  const Real A = -1.0;
+  Real maxV = 0, meanV = 0;
+
+  for (int t = 0; t < mesh.numTris(); t++) {
+    Vec3 fn = mesh.getFaceNormal(t);
+    Vec3 source;
+    if (vel) {
+      Vec3 a = acceleration.getInterpolated(mesh.getFaceCenter(t));
+      source = A * cross(fn, a - gravity) * scale;
+    }
+    else {
+      source = A * cross(fn, -gravity) * scale;
+    }
+
+    if (mesh.isTriangleFixed(t))
+      source = 0;
+
+    mesh.sheet(t).vorticity *= mult;
+    mesh.sheet(t).vorticity += dt * source / dx;
+    // upper limit
+    Real v = norm(mesh.sheet(t).vorticity);
+    if (maxAmount > 0 && v > maxAmount)
+      mesh.sheet(t).vorticity *= maxAmount / v;
+
+    // stats
+    if (v > maxV)
+      maxV = v;
+    meanV += v;
+  }
+
+  cout << "vorticity: max " << maxV << " / mean " << meanV / mesh.numTris() << endl;
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "vorticitySource", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
+      Vec3 gravity = _args.get<Vec3>("gravity", 1, &_lock);
+      const MACGrid *vel = _args.getPtrOpt<MACGrid>("vel", 2, NULL, &_lock);
+      const MACGrid *velOld = _args.getPtrOpt<MACGrid>("velOld", 3, NULL, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 4, 0.1, &_lock);
+      Real maxAmount = _args.getOpt<Real>("maxAmount", 5, 0, &_lock);
+      Real mult = _args.getOpt<Real>("mult", 6, 1.0, &_lock);
+      _retval = getPyNone();
+      vorticitySource(mesh, gravity, vel, velOld, scale, maxAmount, mult);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "vorticitySource", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("vorticitySource", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_vorticitySource("", "vorticitySource", _W_3);
+extern "C" {
+void PbRegister_vorticitySource()
+{
+  KEEP_UNUSED(_RP_vorticitySource);
+}
+}
+
+void smoothVorticity(VortexSheetMesh &mesh, int iter = 1, Real sigma = 0.2, Real alpha = 0.8)
+{
+  const Real mult = -0.5 / sigma / sigma;
+
+  // pre-calculate positions and weights
+  vector<Vec3> vort(mesh.numTris()), pos(mesh.numTris());
+  vector<Real> weights(3 * mesh.numTris());
+  vector<int> index(3 * mesh.numTris());
+  for (int i = 0; i < mesh.numTris(); i++) {
+    pos[i] = mesh.getFaceCenter(i);
+    mesh.sheet(i).vorticitySmoothed = mesh.sheet(i).vorticity;
+  }
+  for (int i = 0; i < mesh.numTris(); i++) {
+    for (int c = 0; c < 3; c++) {
+      int oc = mesh.corners(i, c).opposite;
+      if (oc >= 0) {
+        int t = mesh.corners(oc).tri;
+        weights[3 * i + c] = exp(normSquare(pos[t] - pos[i]) * mult);
+        index[3 * i + c] = t;
+      }
+      else {
+        weights[3 * i + c] = 0;
+        index[3 * i + c] = 0;
+      }
+    }
+  }
+
+  for (int it = 0; it < iter; ++it) {
+    // first, preload
+    for (int i = 0; i < mesh.numTris(); i++)
+      vort[i] = mesh.sheet(i).vorticitySmoothed;
+
+    for (int i = 0, idx = 0; i < mesh.numTris(); i++) {
+      // loop over adjacent tris
+      Real sum = 1.0f;
+      Vec3 v = vort[i];
+      for (int c = 0; c < 3; c++, idx++) {
+        Real w = weights[index[idx]];
+        v += w * vort[index[idx]];
+        sum += w;
+      }
+      mesh.sheet(i).vorticitySmoothed = v / sum;
+    }
+  }
+  for (int i = 0; i < mesh.numTris(); i++)
+    mesh.sheet(i).vorticitySmoothed *= alpha;
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "smoothVorticity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
+      int iter = _args.getOpt<int>("iter", 1, 1, &_lock);
+      Real sigma = _args.getOpt<Real>("sigma", 2, 0.2, &_lock);
+      Real alpha = _args.getOpt<Real>("alpha", 3, 0.8, &_lock);
+      _retval = getPyNone();
+      smoothVorticity(mesh, iter, sigma, alpha);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "smoothVorticity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("smoothVorticity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_smoothVorticity("", "smoothVorticity", _W_4);
+extern "C" {
+void PbRegister_smoothVorticity()
+{
+  KEEP_UNUSED(_RP_smoothVorticity);
+}
+}
+
+//! Seed Vortex Particles inside shape with K41 characteristics
+void VPseedK41(VortexParticleSystem &system,
+               const Shape *shape,
+               Real strength = 0,
+               Real sigma0 = 0.2,
+               Real sigma1 = 1.0,
+               Real probability = 1.0,
+               Real N = 3.0)
+{
+  Grid<Real> temp(system.getParent());
+  const Real dt = system.getParent()->getDt();
+  static RandomStream rand(3489572);
+  Real s0 = pow((Real)sigma0, (Real)(-N + 1.0));
+  Real s1 = pow((Real)sigma1, (Real)(-N + 1.0));
+
+  FOR_IJK(temp)
+  {
+    if (shape->isInsideGrid(i, j, k)) {
+      if (rand.getReal() < probability * dt) {
+        Real p = rand.getReal();
+        Real sigma = pow((1.0 - p) * s0 + p * s1, 1. / (-N + 1.0));
+        Vec3 randDir(rand.getReal(), rand.getReal(), rand.getReal());
+        Vec3 posUpd(i + rand.getReal(), j + rand.getReal(), k + rand.getReal());
+        normalize(randDir);
+        Vec3 vorticity = randDir * strength * pow((Real)sigma, (Real)(-10. / 6. + N / 2.0));
+        system.add(VortexParticleData(posUpd, vorticity, sigma));
+      }
+    }
+  }
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "VPseedK41", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      VortexParticleSystem &system = *_args.getPtr<VortexParticleSystem>("system", 0, &_lock);
+      const Shape *shape = _args.getPtr<Shape>("shape", 1, &_lock);
+      Real strength = _args.getOpt<Real>("strength", 2, 0, &_lock);
+      Real sigma0 = _args.getOpt<Real>("sigma0", 3, 0.2, &_lock);
+      Real sigma1 = _args.getOpt<Real>("sigma1", 4, 1.0, &_lock);
+      Real probability = _args.getOpt<Real>("probability", 5, 1.0, &_lock);
+      Real N = _args.getOpt<Real>("N", 6, 3.0, &_lock);
+      _retval = getPyNone();
+      VPseedK41(system, shape, strength, sigma0, sigma1, probability, N);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "VPseedK41", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("VPseedK41", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_VPseedK41("", "VPseedK41", _W_5);
+extern "C" {
+void PbRegister_VPseedK41()
+{
+  KEEP_UNUSED(_RP_VPseedK41);
+}
+}
+
+//! Vortex-in-cell integration
+
+void VICintegration(VortexSheetMesh &mesh,
+                    Real sigma,
+                    Grid<Vec3> &vel,
+                    const FlagGrid &flags,
+                    Grid<Vec3> *vorticity = NULL,
+                    Real cgMaxIterFac = 1.5,
+                    Real cgAccuracy = 1e-3,
+                    Real scale = 0.01,
+                    int precondition = 0)
+{
+
+  MuTime t0;
+  const Real fac = 16.0;  // experimental factor to balance out regularization
+
+  // if no vort grid is given, use a temporary one
+  Grid<Vec3> vortTemp(mesh.getParent());
+  Grid<Vec3> &vort = (vorticity) ? (*vorticity) : (vortTemp);
+  vort.clear();
+
+  // map vorticity to grid using Peskin kernel
+  int sgi = ceil(sigma);
+  Real pkfac = M_PI / sigma;
+  const int numTris = mesh.numTris();
+  for (int t = 0; t < numTris; t++) {
+    Vec3 pos = mesh.getFaceCenter(t);
+    Vec3 v = mesh.sheet(t).vorticity * mesh.getFaceArea(t) * fac;
+
+    // inner kernel
+    // first, summate
+    Real sum = 0;
+    for (int i = -sgi; i < sgi; i++) {
+      if (pos.x + i < 0 || (int)pos.x + i >= vort.getSizeX())
+        continue;
+      for (int j = -sgi; j < sgi; j++) {
+        if (pos.y + j < 0 || (int)pos.y + j >= vort.getSizeY())
+          continue;
+        for (int k = -sgi; k < sgi; k++) {
+          if (pos.z + k < 0 || (int)pos.z + k >= vort.getSizeZ())
+            continue;
+          Vec3i cell(pos.x + i, pos.y + j, pos.z + k);
+          if (!flags.isFluid(cell))
+            continue;
+          Vec3 d = pos -
+                   Vec3(i + 0.5 + floor(pos.x), j + 0.5 + floor(pos.y), k + 0.5 + floor(pos.z));
+          Real dl = norm(d);
+          if (dl > sigma)
+            continue;
+          // precalc Peskin kernel
+          sum += 1.0 + cos(dl * pkfac);
+        }
+      }
+    }
+    // then, apply normalized kernel
+    Real wnorm = 1.0 / sum;
+    for (int i = -sgi; i < sgi; i++) {
+      if (pos.x + i < 0 || (int)pos.x + i >= vort.getSizeX())
+        continue;
+      for (int j = -sgi; j < sgi; j++) {
+        if (pos.y + j < 0 || (int)pos.y + j >= vort.getSizeY())
+          continue;
+        for (int k = -sgi; k < sgi; k++) {
+          if (pos.z + k < 0 || (int)pos.z + k >= vort.getSizeZ())
+            continue;
+          Vec3i cell(pos.x + i, pos.y + j, pos.z + k);
+          if (!flags.isFluid(cell))
+            continue;
+          Vec3 d = pos -
+                   Vec3(i + 0.5 + floor(pos.x), j + 0.5 + floor(pos.y), k + 0.5 + floor(pos.z));
+          Real dl = norm(d);
+          if (dl > sigma)
+            continue;
+          Real w = (1.0 + cos(dl * pkfac)) * wnorm;
+          vort(cell) += v * w;
+        }
+      }
+    }
+  }
+
+  // Prepare grids for poisson solve
+  Grid<Vec3> vortexCurl(mesh.getParent());
+  Grid<Real> rhs(mesh.getParent());
+  Grid<Real> solution(mesh.getParent());
+  Grid<Real> residual(mesh.getParent());
+  Grid<Real> search(mesh.getParent());
+  Grid<Real> temp1(mesh.getParent());
+  Grid<Real> A0(mesh.getParent());
+  Grid<Real> Ai(mesh.getParent());
+  Grid<Real> Aj(mesh.getParent());
+  Grid<Real> Ak(mesh.getParent());
+  Grid<Real> pca0(mesh.getParent());
+  Grid<Real> pca1(mesh.getParent());
+  Grid<Real> pca2(mesh.getParent());
+  Grid<Real> pca3(mesh.getParent());
+
+  MakeLaplaceMatrix(flags, A0, Ai, Aj, Ak);
+  CurlOp(vort, vortexCurl);
+
+  // Solve vector poisson equation
+  for (int c = 0; c < 3; c++) {
+    // construct rhs
+    if (vel.getType() & GridBase::TypeMAC)
+      GetShiftedComponent(vortexCurl, rhs, c);
+    else
+      GetComponent(vortexCurl, rhs, c);
+
+    // prepare CG solver
+    const int maxIter = (int)(cgMaxIterFac * vel.getSize().max());
+    GridCgInterface *gcg = new GridCg<ApplyMatrix>(
+        solution, rhs, residual, search, flags, temp1, &A0, &Ai, &Aj, &Ak);
+    gcg->setAccuracy(cgAccuracy);
+    gcg->setUseL2Norm(true);
+    gcg->setICPreconditioner(
+        (GridCgInterface::PreconditionType)precondition, &pca0, &pca1, &pca2, &pca3);
+
+    // iterations
+    for (int iter = 0; iter < maxIter; iter++) {
+      if (!gcg->iterate())
+        iter = maxIter;
+    }
+    debMsg("VICintegration CG iterations:" << gcg->getIterations() << ", res:" << gcg->getSigma(),
+           1);
+    delete gcg;
+
+    // copy back
+    solution *= scale;
+    SetComponent(vel, solution, c);
+  }
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "VICintegration", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
+      Real sigma = _args.get<Real>("sigma", 1, &_lock);
+      Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 2, &_lock);
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
+      Grid<Vec3> *vorticity = _args.getPtrOpt<Grid<Vec3>>("vorticity", 4, NULL, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 5, 1.5, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 6, 1e-3, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 7, 0.01, &_lock);
+      int precondition = _args.getOpt<int>("precondition", 8, 0, &_lock);
+      _retval = getPyNone();
+      VICintegration(
+          mesh, sigma, vel, flags, vorticity, cgMaxIterFac, cgAccuracy, scale, precondition);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "VICintegration", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("VICintegration", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_VICintegration("", "VICintegration", _W_6);
+extern "C" {
+void PbRegister_VICintegration()
+{
+  KEEP_UNUSED(_RP_VICintegration);
+}
+}
+
+//! Obtain density field from levelset with linear gradient of size sigma over the interface
+void densityFromLevelset(const LevelsetGrid &phi,
+                         Grid<Real> &density,
+                         Real value = 1.0,
+                         Real sigma = 1.0)
+{
+  FOR_IJK(phi)
+  {
+    // remove boundary
+    if (i < 2 || j < 2 || k < 2 || i >= phi.getSizeX() - 2 || j >= phi.getSizeY() - 2 ||
+        k >= phi.getSizeZ() - 2)
+      density(i, j, k) = 0;
+    else if (phi(i, j, k) < -sigma)
+      density(i, j, k) = value;
+    else if (phi(i, j, k) > sigma)
+      density(i, j, k) = 0;
+    else
+      density(i, j, k) = clamp(
+          (Real)(0.5 * value / sigma * (1.0 - phi(i, j, k))), (Real)0.0, value);
+  }
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "densityFromLevelset", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 0, &_lock);
+      Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
+      Real value = _args.getOpt<Real>("value", 2, 1.0, &_lock);
+      Real sigma = _args.getOpt<Real>("sigma", 3, 1.0, &_lock);
+      _retval = getPyNone();
+      densityFromLevelset(phi, density, value, sigma);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "densityFromLevelset", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("densityFromLevelset", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_densityFromLevelset("", "densityFromLevelset", _W_7);
+extern "C" {
+void PbRegister_densityFromLevelset()
+{
+  KEEP_UNUSED(_RP_densityFromLevelset);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/waveletturbulence.cpp b/extern/mantaflow/preprocessed/plugin/waveletturbulence.cpp
new file mode 100644
index 00000000000..9d3bdaa3f21
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/waveletturbulence.cpp
@@ -0,0 +1,1292 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Functions for calculating wavelet turbulence,
+ * plus helpers to compute vorticity, and strain rate magnitude
+ *
+ ******************************************************************************/
+
+#include "vectorbase.h"
+#include "shapes.h"
+#include "commonkernels.h"
+#include "noisefield.h"
+
+using namespace std;
+
+namespace Manta {
+
+//*****************************************************************************
+
+// first some fairly generic interpolation functions for grids with multiple sizes
+
+//! same as in grid.h , but takes an additional optional "desired" size
+inline void calcGridSizeFactorMod(
+    Vec3i s1, Vec3i s2, Vec3i optSize, Vec3 scale, Vec3 &sourceFactor, Vec3 &retOff)
+{
+  for (int c = 0; c < 3; c++) {
+    if (optSize[c] > 0) {
+      s2[c] = optSize[c];
+    }
+  }
+  sourceFactor = calcGridSizeFactor(s1, s2) / scale;
+  retOff = -retOff * sourceFactor + sourceFactor * 0.5;
+}
+
+void interpolateGrid(Grid<Real> &target,
+                     const Grid<Real> &source,
+                     Vec3 scale = Vec3(1.),
+                     Vec3 offset = Vec3(0.),
+                     Vec3i size = Vec3i(-1, -1, -1),
+                     int orderSpace = 1)
+{
+  Vec3 sourceFactor(1.), off2 = offset;
+  calcGridSizeFactorMod(source.getSize(), target.getSize(), size, scale, sourceFactor, off2);
+
+  // a brief note on a mantaflow specialty: the target grid has to be the first argument here!
+  // the parent fluidsolver object is taken from the first grid, and it determines the size of the
+  // loop for the kernel call. as we're writing into target, it's important to loop exactly over
+  // all cells of the target grid... (note, when calling the plugin in python, it doesnt matter
+  // anymore).
+
+  // sourceFactor offset necessary to shift eval points by half a small cell width
+  knInterpolateGridTempl<Real>(target, source, sourceFactor, off2, orderSpace);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "interpolateGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 0, &_lock);
+      const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 1, &_lock);
+      Vec3 scale = _args.getOpt<Vec3>("scale", 2, Vec3(1.), &_lock);
+      Vec3 offset = _args.getOpt<Vec3>("offset", 3, Vec3(0.), &_lock);
+      Vec3i size = _args.getOpt<Vec3i>("size", 4, Vec3i(-1, -1, -1), &_lock);
+      int orderSpace = _args.getOpt<int>("orderSpace", 5, 1, &_lock);
+      _retval = getPyNone();
+      interpolateGrid(target, source, scale, offset, size, orderSpace);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "interpolateGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("interpolateGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_interpolateGrid("", "interpolateGrid", _W_0);
+extern "C" {
+void PbRegister_interpolateGrid()
+{
+  KEEP_UNUSED(_RP_interpolateGrid);
+}
+}
+
+void interpolateGridVec3(Grid<Vec3> &target,
+                         const Grid<Vec3> &source,
+                         Vec3 scale = Vec3(1.),
+                         Vec3 offset = Vec3(0.),
+                         Vec3i size = Vec3i(-1, -1, -1),
+                         int orderSpace = 1)
+{
+  Vec3 sourceFactor(1.), off2 = offset;
+  calcGridSizeFactorMod(source.getSize(), target.getSize(), size, scale, sourceFactor, off2);
+  knInterpolateGridTempl<Vec3>(target, source, sourceFactor, off2, orderSpace);
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "interpolateGridVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 0, &_lock);
+      const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 1, &_lock);
+      Vec3 scale = _args.getOpt<Vec3>("scale", 2, Vec3(1.), &_lock);
+      Vec3 offset = _args.getOpt<Vec3>("offset", 3, Vec3(0.), &_lock);
+      Vec3i size = _args.getOpt<Vec3i>("size", 4, Vec3i(-1, -1, -1), &_lock);
+      int orderSpace = _args.getOpt<int>("orderSpace", 5, 1, &_lock);
+      _retval = getPyNone();
+      interpolateGridVec3(target, source, scale, offset, size, orderSpace);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "interpolateGridVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("interpolateGridVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_interpolateGridVec3("", "interpolateGridVec3", _W_1);
+extern "C" {
+void PbRegister_interpolateGridVec3()
+{
+  KEEP_UNUSED(_RP_interpolateGridVec3);
+}
+}
+
+//! interpolate a mac velocity grid from one size to another size
+
+struct KnInterpolateMACGrid : public KernelBase {
+  KnInterpolateMACGrid(MACGrid &target,
+                       const MACGrid &source,
+                       const Vec3 &sourceFactor,
+                       const Vec3 &off,
+                       int orderSpace)
+      : KernelBase(&target, 0),
+        target(target),
+        source(source),
+        sourceFactor(sourceFactor),
+        off(off),
+        orderSpace(orderSpace)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 MACGrid &target,
+                 const MACGrid &source,
+                 const Vec3 &sourceFactor,
+                 const Vec3 &off,
+                 int orderSpace) const
+  {
+    Vec3 pos = Vec3(i, j, k) * sourceFactor + off;
+
+    Real vx = source.getInterpolatedHi(pos - Vec3(0.5, 0, 0), orderSpace)[0];
+    Real vy = source.getInterpolatedHi(pos - Vec3(0, 0.5, 0), orderSpace)[1];
+    Real vz = 0.f;
+    if (source.is3D())
+      vz = source.getInterpolatedHi(pos - Vec3(0, 0, 0.5), orderSpace)[2];
+
+    target(i, j, k) = Vec3(vx, vy, vz);
+  }
+  inline MACGrid &getArg0()
+  {
+    return target;
+  }
+  typedef MACGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return source;
+  }
+  typedef MACGrid type1;
+  inline const Vec3 &getArg2()
+  {
+    return sourceFactor;
+  }
+  typedef Vec3 type2;
+  inline const Vec3 &getArg3()
+  {
+    return off;
+  }
+  typedef Vec3 type3;
+  inline int &getArg4()
+  {
+    return orderSpace;
+  }
+  typedef int type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnInterpolateMACGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, target, source, sourceFactor, off, orderSpace);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, target, source, sourceFactor, off, orderSpace);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  MACGrid &target;
+  const MACGrid &source;
+  const Vec3 &sourceFactor;
+  const Vec3 &off;
+  int orderSpace;
+};
+
+void interpolateMACGrid(MACGrid &target,
+                        const MACGrid &source,
+                        Vec3 scale = Vec3(1.),
+                        Vec3 offset = Vec3(0.),
+                        Vec3i size = Vec3i(-1, -1, -1),
+                        int orderSpace = 1)
+{
+  Vec3 sourceFactor(1.), off2 = offset;
+  calcGridSizeFactorMod(source.getSize(), target.getSize(), size, scale, sourceFactor, off2);
+  KnInterpolateMACGrid(target, source, sourceFactor, off2, orderSpace);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "interpolateMACGrid", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      MACGrid &target = *_args.getPtr<MACGrid>("target", 0, &_lock);
+      const MACGrid &source = *_args.getPtr<MACGrid>("source", 1, &_lock);
+      Vec3 scale = _args.getOpt<Vec3>("scale", 2, Vec3(1.), &_lock);
+      Vec3 offset = _args.getOpt<Vec3>("offset", 3, Vec3(0.), &_lock);
+      Vec3i size = _args.getOpt<Vec3i>("size", 4, Vec3i(-1, -1, -1), &_lock);
+      int orderSpace = _args.getOpt<int>("orderSpace", 5, 1, &_lock);
+      _retval = getPyNone();
+      interpolateMACGrid(target, source, scale, offset, size, orderSpace);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "interpolateMACGrid", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("interpolateMACGrid", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_interpolateMACGrid("", "interpolateMACGrid", _W_2);
+extern "C" {
+void PbRegister_interpolateMACGrid()
+{
+  KEEP_UNUSED(_RP_interpolateMACGrid);
+}
+}
+
+//*****************************************************************************
+
+//! Apply vector noise to grid, this is a simplified version - no position scaling or UVs
+
+struct knApplySimpleNoiseVec3 : public KernelBase {
+  knApplySimpleNoiseVec3(const FlagGrid &flags,
+                         Grid<Vec3> &target,
+                         const WaveletNoiseField &noise,
+                         Real scale,
+                         const Grid<Real> *weight)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        target(target),
+        noise(noise),
+        scale(scale),
+        weight(weight)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Vec3> &target,
+                 const WaveletNoiseField &noise,
+                 Real scale,
+                 const Grid<Real> *weight) const
+  {
+    if (!flags.isFluid(i, j, k))
+      return;
+    Real factor = 1;
+    if (weight)
+      factor = (*weight)(i, j, k);
+    target(i, j, k) += noise.evaluateCurl(Vec3(i, j, k) + Vec3(0.5)) * scale * factor;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Vec3> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<Vec3> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline Real &getArg3()
+  {
+    return scale;
+  }
+  typedef Real type3;
+  inline const Grid<Real> *getArg4()
+  {
+    return weight;
+  }
+  typedef Grid<Real> type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knApplySimpleNoiseVec3 ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, target, noise, scale, weight);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, target, noise, scale, weight);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Vec3> &target;
+  const WaveletNoiseField &noise;
+  Real scale;
+  const Grid<Real> *weight;
+};
+
+void applySimpleNoiseVec3(const FlagGrid &flags,
+                          Grid<Vec3> &target,
+                          const WaveletNoiseField &noise,
+                          Real scale = 1.0,
+                          const Grid<Real> *weight = NULL)
+{
+  // note - passing a MAC grid here is slightly inaccurate, we should evaluate each component
+  // separately
+  knApplySimpleNoiseVec3(flags, target, noise, scale, weight);
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "applySimpleNoiseVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
+      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, NULL, &_lock);
+      _retval = getPyNone();
+      applySimpleNoiseVec3(flags, target, noise, scale, weight);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "applySimpleNoiseVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("applySimpleNoiseVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_applySimpleNoiseVec3("", "applySimpleNoiseVec3", _W_3);
+extern "C" {
+void PbRegister_applySimpleNoiseVec3()
+{
+  KEEP_UNUSED(_RP_applySimpleNoiseVec3);
+}
+}
+
+//! Simple noise for a real grid , follows applySimpleNoiseVec3
+
+struct knApplySimpleNoiseReal : public KernelBase {
+  knApplySimpleNoiseReal(const FlagGrid &flags,
+                         Grid<Real> &target,
+                         const WaveletNoiseField &noise,
+                         Real scale,
+                         const Grid<Real> *weight)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        target(target),
+        noise(noise),
+        scale(scale),
+        weight(weight)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &target,
+                 const WaveletNoiseField &noise,
+                 Real scale,
+                 const Grid<Real> *weight) const
+  {
+    if (!flags.isFluid(i, j, k))
+      return;
+    Real factor = 1;
+    if (weight)
+      factor = (*weight)(i, j, k);
+    target(i, j, k) += noise.evaluate(Vec3(i, j, k) + Vec3(0.5)) * scale * factor;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<Real> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline Real &getArg3()
+  {
+    return scale;
+  }
+  typedef Real type3;
+  inline const Grid<Real> *getArg4()
+  {
+    return weight;
+  }
+  typedef Grid<Real> type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel knApplySimpleNoiseReal ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, target, noise, scale, weight);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, target, noise, scale, weight);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &target;
+  const WaveletNoiseField &noise;
+  Real scale;
+  const Grid<Real> *weight;
+};
+
+void applySimpleNoiseReal(const FlagGrid &flags,
+                          Grid<Real> &target,
+                          const WaveletNoiseField &noise,
+                          Real scale = 1.0,
+                          const Grid<Real> *weight = NULL)
+{
+  knApplySimpleNoiseReal(flags, target, noise, scale, weight);
+}
+static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "applySimpleNoiseReal", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
+      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, NULL, &_lock);
+      _retval = getPyNone();
+      applySimpleNoiseReal(flags, target, noise, scale, weight);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "applySimpleNoiseReal", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("applySimpleNoiseReal", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_applySimpleNoiseReal("", "applySimpleNoiseReal", _W_4);
+extern "C" {
+void PbRegister_applySimpleNoiseReal()
+{
+  KEEP_UNUSED(_RP_applySimpleNoiseReal);
+}
+}
+
+//! Apply vector-based wavelet noise to target grid
+//! This is the version with more functionality - supports uv grids, and on-the-fly interpolation
+//! of input grids.
+
+struct knApplyNoiseVec3 : public KernelBase {
+  knApplyNoiseVec3(const FlagGrid &flags,
+                   Grid<Vec3> &target,
+                   const WaveletNoiseField &noise,
+                   Real scale,
+                   Real scaleSpatial,
+                   const Grid<Real> *weight,
+                   const Grid<Vec3> *uv,
+                   bool uvInterpol,
+                   const Vec3 &sourceFactor)
+      : KernelBase(&flags, 0),
+        flags(flags),
+        target(target),
+        noise(noise),
+        scale(scale),
+        scaleSpatial(scaleSpatial),
+        weight(weight),
+        uv(uv),
+        uvInterpol(uvInterpol),
+        sourceFactor(sourceFactor)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Vec3> &target,
+                 const WaveletNoiseField &noise,
+                 Real scale,
+                 Real scaleSpatial,
+                 const Grid<Real> *weight,
+                 const Grid<Vec3> *uv,
+                 bool uvInterpol,
+                 const Vec3 &sourceFactor) const
+  {
+    if (!flags.isFluid(i, j, k))
+      return;
+
+    // get weighting, interpolate if necessary
+    Real w = 1;
+    if (weight) {
+      if (!uvInterpol) {
+        w = (*weight)(i, j, k);
+      }
+      else {
+        w = weight->getInterpolated(Vec3(i, j, k) * sourceFactor);
+      }
+    }
+
+    // compute position where to evaluate the noise
+    Vec3 pos = Vec3(i, j, k) + Vec3(0.5);
+    if (uv) {
+      if (!uvInterpol) {
+        pos = (*uv)(i, j, k);
+      }
+      else {
+        pos = uv->getInterpolated(Vec3(i, j, k) * sourceFactor);
+        // uv coordinates are in local space - so we need to adjust the values of the positions
+        pos /= sourceFactor;
+      }
+    }
+    pos *= scaleSpatial;
+
+    Vec3 noiseVec3 = noise.evaluateCurl(pos) * scale * w;
+    // noiseVec3=pos; // debug , show interpolated positions
+    target(i, j, k) += noiseVec3;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Vec3> &getArg1()
+  {
+    return target;
+  }
+  typedef Grid<Vec3> type1;
+  inline const WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline Real &getArg3()
+  {
+    return scale;
+  }
+  typedef Real type3;
+  inline Real &getArg4()
+  {
+    return scaleSpatial;
+  }
+  typedef Real type4;
+  inline const Grid<Real> *getArg5()
+  {
+    return weight;
+  }
+  typedef Grid<Real> type5;
+  inline const Grid<Vec3> *getArg6()
+  {
+    return uv;
+  }
+  typedef Grid<Vec3> type6;
+  inline bool &getArg7()
+  {
+    return uvInterpol;
+  }
+  typedef bool type7;
+  inline const Vec3 &getArg8()
+  {
+    return sourceFactor;
+  }
+  typedef Vec3 type8;
+  void runMessage()
+  {
+    debMsg("Executing kernel knApplyNoiseVec3 ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i,
+               j,
+               k,
+               flags,
+               target,
+               noise,
+               scale,
+               scaleSpatial,
+               weight,
+               uv,
+               uvInterpol,
+               sourceFactor);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i,
+             j,
+             k,
+             flags,
+             target,
+             noise,
+             scale,
+             scaleSpatial,
+             weight,
+             uv,
+             uvInterpol,
+             sourceFactor);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Vec3> &target;
+  const WaveletNoiseField &noise;
+  Real scale;
+  Real scaleSpatial;
+  const Grid<Real> *weight;
+  const Grid<Vec3> *uv;
+  bool uvInterpol;
+  const Vec3 &sourceFactor;
+};
+
+void applyNoiseVec3(const FlagGrid &flags,
+                    Grid<Vec3> &target,
+                    const WaveletNoiseField &noise,
+                    Real scale = 1.0,
+                    Real scaleSpatial = 1.0,
+                    const Grid<Real> *weight = NULL,
+                    const Grid<Vec3> *uv = NULL)
+{
+  // check whether the uv grid has a different resolution
+  bool uvInterpol = false;
+  // and pre-compute conversion (only used if uvInterpol==true)
+  // used for both uv and weight grid...
+  Vec3 sourceFactor = Vec3(1.);
+  if (uv) {
+    uvInterpol = (target.getSize() != uv->getSize());
+    sourceFactor = calcGridSizeFactor(uv->getSize(), target.getSize());
+  }
+  else if (weight) {
+    uvInterpol = (target.getSize() != weight->getSize());
+    sourceFactor = calcGridSizeFactor(weight->getSize(), target.getSize());
+  }
+  if (uv && weight)
+    assertMsg(uv->getSize() == weight->getSize(), "UV and weight grid have to match!");
+
+  // note - passing a MAC grid here is slightly inaccurate, we should evaluate each component
+  // separately
+  knApplyNoiseVec3(
+      flags, target, noise, scale, scaleSpatial, weight, uv, uvInterpol, sourceFactor);
+}
+static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "applyNoiseVec3", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
+      const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
+      Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
+      Real scaleSpatial = _args.getOpt<Real>("scaleSpatial", 4, 1.0, &_lock);
+      const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 5, NULL, &_lock);
+      const Grid<Vec3> *uv = _args.getPtrOpt<Grid<Vec3>>("uv", 6, NULL, &_lock);
+      _retval = getPyNone();
+      applyNoiseVec3(flags, target, noise, scale, scaleSpatial, weight, uv);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "applyNoiseVec3", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("applyNoiseVec3", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_applyNoiseVec3("", "applyNoiseVec3", _W_5);
+extern "C" {
+void PbRegister_applyNoiseVec3()
+{
+  KEEP_UNUSED(_RP_applyNoiseVec3);
+}
+}
+
+//! Compute energy of a staggered velocity field (at cell center)
+
+struct KnApplyComputeEnergy : public KernelBase {
+  KnApplyComputeEnergy(const FlagGrid &flags, const MACGrid &vel, Grid<Real> &energy)
+      : KernelBase(&flags, 0), flags(flags), vel(vel), energy(energy)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const FlagGrid &flags, const MACGrid &vel, Grid<Real> &energy) const
+  {
+    Real e = 0.f;
+    if (flags.isFluid(i, j, k)) {
+      Vec3 v = vel.getCentered(i, j, k);
+      e = 0.5 * (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    }
+    energy(i, j, k) = e;
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline const MACGrid &getArg1()
+  {
+    return vel;
+  }
+  typedef MACGrid type1;
+  inline Grid<Real> &getArg2()
+  {
+    return energy;
+  }
+  typedef Grid<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnApplyComputeEnergy ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, flags, vel, energy);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, flags, vel, energy);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const FlagGrid &flags;
+  const MACGrid &vel;
+  Grid<Real> &energy;
+};
+
+void computeEnergy(const FlagGrid &flags, const MACGrid &vel, Grid<Real> &energy)
+{
+  KnApplyComputeEnergy(flags, vel, energy);
+}
+static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "computeEnergy", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
+      Grid<Real> &energy = *_args.getPtr<Grid<Real>>("energy", 2, &_lock);
+      _retval = getPyNone();
+      computeEnergy(flags, vel, energy);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "computeEnergy", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("computeEnergy", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_computeEnergy("", "computeEnergy", _W_6);
+extern "C" {
+void PbRegister_computeEnergy()
+{
+  KEEP_UNUSED(_RP_computeEnergy);
+}
+}
+
+void computeWaveletCoeffs(Grid<Real> &input)
+{
+  Grid<Real> temp1(input.getParent()), temp2(input.getParent());
+  WaveletNoiseField::computeCoefficients(input, temp1, temp2);
+}
+static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "computeWaveletCoeffs", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &input = *_args.getPtr<Grid<Real>>("input", 0, &_lock);
+      _retval = getPyNone();
+      computeWaveletCoeffs(input);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "computeWaveletCoeffs", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("computeWaveletCoeffs", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_computeWaveletCoeffs("", "computeWaveletCoeffs", _W_7);
+extern "C" {
+void PbRegister_computeWaveletCoeffs()
+{
+  KEEP_UNUSED(_RP_computeWaveletCoeffs);
+}
+}
+
+// note - alomst the same as for vorticity confinement
+void computeVorticity(const MACGrid &vel, Grid<Vec3> &vorticity, Grid<Real> *norm = NULL)
+{
+  Grid<Vec3> velCenter(vel.getParent());
+  GetCentered(velCenter, vel);
+  CurlOp(velCenter, vorticity);
+  if (norm)
+    GridNorm(*norm, vorticity);
+}
+static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "computeVorticity", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Vec3> &vorticity = *_args.getPtr<Grid<Vec3>>("vorticity", 1, &_lock);
+      Grid<Real> *norm = _args.getPtrOpt<Grid<Real>>("norm", 2, NULL, &_lock);
+      _retval = getPyNone();
+      computeVorticity(vel, vorticity, norm);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "computeVorticity", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("computeVorticity", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_computeVorticity("", "computeVorticity", _W_8);
+extern "C" {
+void PbRegister_computeVorticity()
+{
+  KEEP_UNUSED(_RP_computeVorticity);
+}
+}
+
+// note - very similar to KnComputeProductionStrain, but for use as wavelet turb weighting
+
+struct KnComputeStrainRateMag : public KernelBase {
+  KnComputeStrainRateMag(const MACGrid &vel, const Grid<Vec3> &velCenter, Grid<Real> &prod)
+      : KernelBase(&vel, 1), vel(vel), velCenter(velCenter), prod(prod)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, const MACGrid &vel, const Grid<Vec3> &velCenter, Grid<Real> &prod) const
+  {
+    // compute Sij = 1/2 * (dU_i/dx_j + dU_j/dx_i)
+    Vec3 diag = Vec3(vel(i + 1, j, k).x, vel(i, j + 1, k).y, 0.) - vel(i, j, k);
+    if (vel.is3D())
+      diag[2] += vel(i, j, k + 1).z;
+    else
+      diag[2] = 0.;
+
+    Vec3 ux = 0.5 * (velCenter(i + 1, j, k) - velCenter(i - 1, j, k));
+    Vec3 uy = 0.5 * (velCenter(i, j + 1, k) - velCenter(i, j - 1, k));
+    Vec3 uz;
+    if (vel.is3D())
+      uz = 0.5 * (velCenter(i, j, k + 1) - velCenter(i, j, k - 1));
+
+    Real S12 = 0.5 * (ux.y + uy.x);
+    Real S13 = 0.5 * (ux.z + uz.x);
+    Real S23 = 0.5 * (uy.z + uz.y);
+    Real S2 = square(diag.x) + square(diag.y) + square(diag.z) + 2.0 * square(S12) +
+              2.0 * square(S13) + 2.0 * square(S23);
+    prod(i, j, k) = S2;
+  }
+  inline const MACGrid &getArg0()
+  {
+    return vel;
+  }
+  typedef MACGrid type0;
+  inline const Grid<Vec3> &getArg1()
+  {
+    return velCenter;
+  }
+  typedef Grid<Vec3> type1;
+  inline Grid<Real> &getArg2()
+  {
+    return prod;
+  }
+  typedef Grid<Real> type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnComputeStrainRateMag ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, vel, velCenter, prod);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, vel, velCenter, prod);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const MACGrid &vel;
+  const Grid<Vec3> &velCenter;
+  Grid<Real> &prod;
+};
+void computeStrainRateMag(const MACGrid &vel, Grid<Real> &mag)
+{
+  Grid<Vec3> velCenter(vel.getParent());
+  GetCentered(velCenter, vel);
+  KnComputeStrainRateMag(vel, velCenter, mag);
+}
+static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "computeStrainRateMag", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Real> &mag = *_args.getPtr<Grid<Real>>("mag", 1, &_lock);
+      _retval = getPyNone();
+      computeStrainRateMag(vel, mag);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "computeStrainRateMag", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("computeStrainRateMag", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_computeStrainRateMag("", "computeStrainRateMag", _W_9);
+extern "C" {
+void PbRegister_computeStrainRateMag()
+{
+  KEEP_UNUSED(_RP_computeStrainRateMag);
+}
+}
+
+// extrapolate a real grid into a flagged region (based on initial flags)
+// by default extrapolates from fluid to obstacle cells
+template<class T>
+void extrapolSimpleFlagsHelper(const FlagGrid &flags,
+                               Grid<T> &val,
+                               int distance = 4,
+                               int flagFrom = FlagGrid::TypeFluid,
+                               int flagTo = FlagGrid::TypeObstacle)
+{
+  Grid<int> tmp(flags.getParent());
+  int dim = (flags.is3D() ? 3 : 2);
+  const Vec3i nb[6] = {Vec3i(1, 0, 0),
+                       Vec3i(-1, 0, 0),
+                       Vec3i(0, 1, 0),
+                       Vec3i(0, -1, 0),
+                       Vec3i(0, 0, 1),
+                       Vec3i(0, 0, -1)};
+
+  // remove all fluid cells (set to 1)
+  tmp.clear();
+  bool foundTarget = false;
+  FOR_IJK_BND(flags, 0)
+  {
+    if (flags(i, j, k) & flagFrom)
+      tmp(Vec3i(i, j, k)) = 1;
+    if (!foundTarget && (flags(i, j, k) & flagTo))
+      foundTarget = true;
+  }
+  // optimization, skip extrapolation if we dont have any cells to extrapolate to
+  if (!foundTarget) {
+    debMsg("No target cells found, skipping extrapolation", 1);
+    return;
+  }
+
+  // extrapolate for given distance
+  for (int d = 1; d < 1 + distance; ++d) {
+
+    // TODO, parallelize
+    FOR_IJK_BND(flags, 1)
+    {
+      if (tmp(i, j, k) != 0)
+        continue;
+      if (!(flags(i, j, k) & flagTo))
+        continue;
+
+      // copy from initialized neighbors
+      Vec3i p(i, j, k);
+      int nbs = 0;
+      T avgVal = 0.;
+      for (int n = 0; n < 2 * dim; ++n) {
+        if (tmp(p + nb[n]) == d) {
+          avgVal += val(p + nb[n]);
+          nbs++;
+        }
+      }
+
+      if (nbs > 0) {
+        tmp(p) = d + 1;
+        val(p) = avgVal / nbs;
+      }
+    }
+
+  }  // distance
+}
+
+void extrapolateSimpleFlags(const FlagGrid &flags,
+                            GridBase *val,
+                            int distance = 4,
+                            int flagFrom = FlagGrid::TypeFluid,
+                            int flagTo = FlagGrid::TypeObstacle)
+{
+  if (val->getType() & GridBase::TypeReal) {
+    extrapolSimpleFlagsHelper<Real>(flags, *((Grid<Real> *)val), distance, flagFrom, flagTo);
+  }
+  else if (val->getType() & GridBase::TypeInt) {
+    extrapolSimpleFlagsHelper<int>(flags, *((Grid<int> *)val), distance, flagFrom, flagTo);
+  }
+  else if (val->getType() & GridBase::TypeVec3) {
+    extrapolSimpleFlagsHelper<Vec3>(flags, *((Grid<Vec3> *)val), distance, flagFrom, flagTo);
+  }
+  else
+    errMsg("extrapolateSimpleFlags: Grid Type is not supported (only int, Real, Vec3)");
+}
+static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "extrapolateSimpleFlags", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      GridBase *val = _args.getPtr<GridBase>("val", 1, &_lock);
+      int distance = _args.getOpt<int>("distance", 2, 4, &_lock);
+      int flagFrom = _args.getOpt<int>("flagFrom", 3, FlagGrid::TypeFluid, &_lock);
+      int flagTo = _args.getOpt<int>("flagTo", 4, FlagGrid::TypeObstacle, &_lock);
+      _retval = getPyNone();
+      extrapolateSimpleFlags(flags, val, distance, flagFrom, flagTo);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "extrapolateSimpleFlags", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("extrapolateSimpleFlags", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_extrapolateSimpleFlags("", "extrapolateSimpleFlags", _W_10);
+extern "C" {
+void PbRegister_extrapolateSimpleFlags()
+{
+  KEEP_UNUSED(_RP_extrapolateSimpleFlags);
+}
+}
+
+//! convert vel to a centered grid, then compute its curl
+void getCurl(const MACGrid &vel, Grid<Real> &vort, int comp)
+{
+  Grid<Vec3> velCenter(vel.getParent()), curl(vel.getParent());
+
+  GetCentered(velCenter, vel);
+  CurlOp(velCenter, curl);
+  GetComponent(curl, vort, comp);
+}
+static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "getCurl", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
+      Grid<Real> &vort = *_args.getPtr<Grid<Real>>("vort", 1, &_lock);
+      int comp = _args.get<int>("comp", 2, &_lock);
+      _retval = getPyNone();
+      getCurl(vel, vort, comp);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "getCurl", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("getCurl", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_getCurl("", "getCurl", _W_11);
+extern "C" {
+void PbRegister_getCurl()
+{
+  KEEP_UNUSED(_RP_getCurl);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/plugin/waves.cpp b/extern/mantaflow/preprocessed/plugin/waves.cpp
new file mode 100644
index 00000000000..7745dce4711
--- /dev/null
+++ b/extern/mantaflow/preprocessed/plugin/waves.cpp
@@ -0,0 +1,483 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Wave equation
+ *
+ ******************************************************************************/
+
+#include "levelset.h"
+#include "commonkernels.h"
+#include "particle.h"
+#include "conjugategrad.h"
+#include <cmath>
+
+using namespace std;
+
+namespace Manta {
+
+/******************************************************************************
+ *
+ * explicit integration
+ *
+ ******************************************************************************/
+
+struct knCalcSecDeriv2d : public KernelBase {
+  knCalcSecDeriv2d(const Grid<Real> &v, Grid<Real> &ret) : KernelBase(&v, 1), v(v), ret(ret)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, const Grid<Real> &v, Grid<Real> &ret) const
+  {
+    ret(i, j, k) = (-4. * v(i, j, k) + v(i - 1, j, k) + v(i + 1, j, k) + v(i, j - 1, k) +
+                    v(i, j + 1, k));
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return v;
+  }
+  typedef Grid<Real> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return ret;
+  }
+  typedef Grid<Real> type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel knCalcSecDeriv2d ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, v, ret);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, v, ret);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const Grid<Real> &v;
+  Grid<Real> &ret;
+};
+;
+
+//! calculate a second derivative for the wave equation
+void calcSecDeriv2d(const Grid<Real> &v, Grid<Real> &curv)
+{
+  knCalcSecDeriv2d(v, curv);
+}
+static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "calcSecDeriv2d", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const Grid<Real> &v = *_args.getPtr<Grid<Real>>("v", 0, &_lock);
+      Grid<Real> &curv = *_args.getPtr<Grid<Real>>("curv", 1, &_lock);
+      _retval = getPyNone();
+      calcSecDeriv2d(v, curv);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "calcSecDeriv2d", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("calcSecDeriv2d", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_calcSecDeriv2d("", "calcSecDeriv2d", _W_0);
+extern "C" {
+void PbRegister_calcSecDeriv2d()
+{
+  KEEP_UNUSED(_RP_calcSecDeriv2d);
+}
+}
+
+// mass conservation
+
+struct knTotalSum : public KernelBase {
+  knTotalSum(Grid<Real> &h) : KernelBase(&h, 1), h(h), sum(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &h, double &sum)
+  {
+    sum += h(i, j, k);
+  }
+  inline operator double()
+  {
+    return sum;
+  }
+  inline double &getRet()
+  {
+    return sum;
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return h;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel knTotalSum ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, h, sum);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, h, sum);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_reduce(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_reduce(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  knTotalSum(knTotalSum &o, tbb::split) : KernelBase(o), h(o.h), sum(0)
+  {
+  }
+  void join(const knTotalSum &o)
+  {
+    sum += o.sum;
+  }
+  Grid<Real> &h;
+  double sum;
+};
+
+//! calculate the sum of all values in a grid (for wave equation solves)
+Real totalSum(Grid<Real> &height)
+{
+  knTotalSum ts(height);
+  return ts.sum;
+}
+static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "totalSum", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &height = *_args.getPtr<Grid<Real>>("height", 0, &_lock);
+      _retval = toPy(totalSum(height));
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "totalSum", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("totalSum", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_totalSum("", "totalSum", _W_1);
+extern "C" {
+void PbRegister_totalSum()
+{
+  KEEP_UNUSED(_RP_totalSum);
+}
+}
+
+//! normalize all values in a grid (for wave equation solves)
+void normalizeSumTo(Grid<Real> &height, Real target)
+{
+  knTotalSum ts(height);
+  Real factor = target / ts.sum;
+  height.multConst(factor);
+}
+static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "normalizeSumTo", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      Grid<Real> &height = *_args.getPtr<Grid<Real>>("height", 0, &_lock);
+      Real target = _args.get<Real>("target", 1, &_lock);
+      _retval = getPyNone();
+      normalizeSumTo(height, target);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "normalizeSumTo", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("normalizeSumTo", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_normalizeSumTo("", "normalizeSumTo", _W_2);
+extern "C" {
+void PbRegister_normalizeSumTo()
+{
+  KEEP_UNUSED(_RP_normalizeSumTo);
+}
+}
+
+/******************************************************************************
+ *
+ * implicit time integration
+ *
+ ******************************************************************************/
+
+//! Kernel: Construct the right-hand side of the poisson equation
+
+struct MakeRhsWE : public KernelBase {
+  MakeRhsWE(const FlagGrid &flags,
+            Grid<Real> &rhs,
+            const Grid<Real> &ut,
+            const Grid<Real> &utm1,
+            Real s,
+            bool crankNic = false)
+      : KernelBase(&flags, 1), flags(flags), rhs(rhs), ut(ut), utm1(utm1), s(s), crankNic(crankNic)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const FlagGrid &flags,
+                 Grid<Real> &rhs,
+                 const Grid<Real> &ut,
+                 const Grid<Real> &utm1,
+                 Real s,
+                 bool crankNic = false) const
+  {
+    rhs(i, j, k) = (2. * ut(i, j, k) - utm1(i, j, k));
+    if (crankNic) {
+      rhs(i, j, k) += s * (-4. * ut(i, j, k) + 1. * ut(i - 1, j, k) + 1. * ut(i + 1, j, k) +
+                           1. * ut(i, j - 1, k) + 1. * ut(i, j + 1, k));
+    }
+  }
+  inline const FlagGrid &getArg0()
+  {
+    return flags;
+  }
+  typedef FlagGrid type0;
+  inline Grid<Real> &getArg1()
+  {
+    return rhs;
+  }
+  typedef Grid<Real> type1;
+  inline const Grid<Real> &getArg2()
+  {
+    return ut;
+  }
+  typedef Grid<Real> type2;
+  inline const Grid<Real> &getArg3()
+  {
+    return utm1;
+  }
+  typedef Grid<Real> type3;
+  inline Real &getArg4()
+  {
+    return s;
+  }
+  typedef Real type4;
+  inline bool &getArg5()
+  {
+    return crankNic;
+  }
+  typedef bool type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel MakeRhsWE ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 1; j < _maxY; j++)
+          for (int i = 1; i < _maxX; i++)
+            op(i, j, k, flags, rhs, ut, utm1, s, crankNic);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 1; i < _maxX; i++)
+          op(i, j, k, flags, rhs, ut, utm1, s, crankNic);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
+  }
+  const FlagGrid &flags;
+  Grid<Real> &rhs;
+  const Grid<Real> &ut;
+  const Grid<Real> &utm1;
+  Real s;
+  bool crankNic;
+};
+
+//! do a CG solve for the wave equation (note, out grid only there for debugging... could be
+//! removed)
+
+void cgSolveWE(const FlagGrid &flags,
+               Grid<Real> &ut,
+               Grid<Real> &utm1,
+               Grid<Real> &out,
+               bool crankNic = false,
+               Real cSqr = 0.25,
+               Real cgMaxIterFac = 1.5,
+               Real cgAccuracy = 1e-5)
+{
+  // reserve temp grids
+  FluidSolver *parent = flags.getParent();
+  Grid<Real> rhs(parent);
+  Grid<Real> residual(parent);
+  Grid<Real> search(parent);
+  Grid<Real> A0(parent);
+  Grid<Real> Ai(parent);
+  Grid<Real> Aj(parent);
+  Grid<Real> Ak(parent);
+  Grid<Real> tmp(parent);
+  // solution...
+  out.clear();
+
+  // setup matrix and boundaries
+  MakeLaplaceMatrix(flags, A0, Ai, Aj, Ak);
+  Real dt = parent->getDt();
+  Real s = dt * dt * cSqr * 0.5;
+  FOR_IJK(flags)
+  {
+    Ai(i, j, k) *= s;
+    Aj(i, j, k) *= s;
+    Ak(i, j, k) *= s;
+    A0(i, j, k) *= s;
+    A0(i, j, k) += 1.;
+  }
+
+  // compute divergence and init right hand side
+  rhs.clear();
+  // h=dt
+  // rhs:   = 2 ut - ut-1
+  // A:    (h2 c2/ dx)=s   ,  (1+4s)uij + s ui-1j + ...
+  // Cr.Nic.
+  // rhs:  cr nic = 2 ut - ut-1 + h^2c^2/2 b
+  // A:    (h2 c2/2 dx)=s   ,  (1+4s)uij + s ui-1j + ...
+  MakeRhsWE kernMakeRhs(flags, rhs, ut, utm1, s, crankNic);
+
+  const int maxIter = (int)(cgMaxIterFac * flags.getSize().max()) * (flags.is3D() ? 1 : 4);
+  GridCgInterface *gcg;
+  if (flags.is3D())
+    gcg = new GridCg<ApplyMatrix>(out, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+  else
+    gcg = new GridCg<ApplyMatrix2D>(out, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak);
+
+  gcg->setAccuracy(cgAccuracy);
+
+  // no preconditioning for now...
+  for (int iter = 0; iter < maxIter; iter++) {
+    if (!gcg->iterate())
+      iter = maxIter;
+  }
+  debMsg("cgSolveWaveEq iterations:" << gcg->getIterations() << ", res:" << gcg->getSigma(), 1);
+
+  utm1.swap(ut);
+  ut.copyFrom(out);
+
+  delete gcg;
+}
+static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+{
+  try {
+    PbArgs _args(_linargs, _kwds);
+    FluidSolver *parent = _args.obtainParent();
+    bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+    pbPreparePlugin(parent, "cgSolveWE", !noTiming);
+    PyObject *_retval = 0;
+    {
+      ArgLocker _lock;
+      const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+      Grid<Real> &ut = *_args.getPtr<Grid<Real>>("ut", 1, &_lock);
+      Grid<Real> &utm1 = *_args.getPtr<Grid<Real>>("utm1", 2, &_lock);
+      Grid<Real> &out = *_args.getPtr<Grid<Real>>("out", 3, &_lock);
+      bool crankNic = _args.getOpt<bool>("crankNic", 4, false, &_lock);
+      Real cSqr = _args.getOpt<Real>("cSqr", 5, 0.25, &_lock);
+      Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 6, 1.5, &_lock);
+      Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 7, 1e-5, &_lock);
+      _retval = getPyNone();
+      cgSolveWE(flags, ut, utm1, out, crankNic, cSqr, cgMaxIterFac, cgAccuracy);
+      _args.check();
+    }
+    pbFinalizePlugin(parent, "cgSolveWE", !noTiming);
+    return _retval;
+  }
+  catch (std::exception &e) {
+    pbSetError("cgSolveWE", e.what());
+    return 0;
+  }
+}
+static const Pb::Register _RP_cgSolveWE("", "cgSolveWE", _W_3);
+extern "C" {
+void PbRegister_cgSolveWE()
+{
+  KEEP_UNUSED(_RP_cgSolveWE);
+}
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/python/defines.py b/extern/mantaflow/preprocessed/python/defines.py
new file mode 100644
index 00000000000..1c7f01ab034
--- /dev/null
+++ b/extern/mantaflow/preprocessed/python/defines.py
@@ -0,0 +1,11 @@
+
+
+
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+
+
+
diff --git a/extern/mantaflow/preprocessed/python/defines.py.reg.cpp b/extern/mantaflow/preprocessed/python/defines.py.reg.cpp
new file mode 100644
index 00000000000..1866957534c
--- /dev/null
+++ b/extern/mantaflow/preprocessed/python/defines.py.reg.cpp
@@ -0,0 +1,24 @@
+#include "registry.h"
+static const Pb::Register _reg(
+    "python/defines.py",
+    "################################################################################\n#\n# "
+    "MantaFlow fluid solver framework\n# Copyright 2011 Tobias Pfaff, Nils Thuerey \n#\n# This "
+    "program is free software, distributed under the terms of the\n# Apache License, Version 2.0 "
+    "\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Defines some constants for use in "
+    "python "
+    "subprograms\n#\n#############################################################################"
+    "####\n\n# mantaflow conventions\nReal = float\n\n# some defines to make C code and scripts "
+    "more alike...\nfalse = False\ntrue  = True\nVec3  = vec3\nVec4  = vec4\nVec3Grid = "
+    "VecGrid\n\n# grid flags\nFlagFluid    = 1\nFlagObstacle = 2\nFlagEmpty    = 4\nFlagInflow   "
+    "= 8\nFlagOutflow  = 16\nFlagStick    = 64\nFlagReserved = 256\n# and same for "
+    "FlagGrid::CellType enum names:\nTypeFluid    = 1\nTypeObstacle = 2\nTypeEmpty    = "
+    "4\nTypeInflow   = 8\nTypeOutflow  = 16\nTypeStick    = 64\nTypeReserved = 256\n\n# "
+    "integration mode\nIntEuler = 0\nIntRK2   = 1\nIntRK4   = 2\n\n# CG preconditioner\nPcNone    "
+    "  = 0\nPcMIC       = 1\nPcMGDynamic = 2\nPcMGStatic  = 3\n\n# particles\nPtypeSpray   = "
+    "2\nPtypeBubble  = 4\nPtypeFoam    = 8\nPtypeTracer  = 16\n\n\n\n\n");
+extern "C" {
+void PbRegister_file_0()
+{
+  KEEP_UNUSED(_reg);
+}
+}
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/registration.cpp b/extern/mantaflow/preprocessed/registration.cpp
new file mode 100644
index 00000000000..e86d19f7f7a
--- /dev/null
+++ b/extern/mantaflow/preprocessed/registration.cpp
@@ -0,0 +1,382 @@
+extern "C" {
+extern void PbRegister_mantaMsg();
+extern void PbRegister_printBuildInfo();
+extern void PbRegister_setDebugLevel();
+extern void PbRegister_assertNumpy();
+extern void PbRegister_cgSolveDiffusion();
+extern void PbRegister_gridMaxDiff();
+extern void PbRegister_gridMaxDiffInt();
+extern void PbRegister_gridMaxDiffVec3();
+extern void PbRegister_copyMacToVec3();
+extern void PbRegister_convertMacToVec3();
+extern void PbRegister_resampleVec3ToMac();
+extern void PbRegister_resampleMacToVec3();
+extern void PbRegister_copyLevelsetToReal();
+extern void PbRegister_copyVec3ToReal();
+extern void PbRegister_copyRealToVec3();
+extern void PbRegister_convertLevelsetToReal();
+extern void PbRegister_swapComponents();
+extern void PbRegister_getUvWeight();
+extern void PbRegister_resetUvGrid();
+extern void PbRegister_updateUvWeight();
+extern void PbRegister_getGridAvg();
+extern void PbRegister_getComponent();
+extern void PbRegister_setComponent();
+extern void PbRegister_markIsolatedFluidCell();
+extern void PbRegister_copyMACData();
+extern void PbRegister_getComp4d();
+extern void PbRegister_setComp4d();
+extern void PbRegister_grid4dMaxDiff();
+extern void PbRegister_grid4dMaxDiffInt();
+extern void PbRegister_grid4dMaxDiffVec3();
+extern void PbRegister_grid4dMaxDiffVec4();
+extern void PbRegister_setRegion4d();
+extern void PbRegister_setRegion4dVec4();
+extern void PbRegister_getSliceFrom4d();
+extern void PbRegister_getSliceFrom4dVec();
+extern void PbRegister_interpolateGrid4d();
+extern void PbRegister_interpolateGrid4dVec();
+extern void PbRegister_extrapolateMACSimple();
+extern void PbRegister_extrapolateMACFromWeight();
+extern void PbRegister_extrapolateLsSimple();
+extern void PbRegister_extrapolateVec3Simple();
+extern void PbRegister_getUniFileSize();
+extern void PbRegister_printUniFileInfoString();
+extern void PbRegister_getNpzFileSize();
+extern void PbRegister_quantizeGrid();
+extern void PbRegister_quantizeGridVec3();
+extern void PbRegister_resetPhiInObs();
+extern void PbRegister_advectSemiLagrange();
+extern void PbRegister_addGravity();
+extern void PbRegister_addGravityNoScale();
+extern void PbRegister_addBuoyancy();
+extern void PbRegister_setOpenBound();
+extern void PbRegister_resetOutflow();
+extern void PbRegister_setInflowBcs();
+extern void PbRegister_setWallBcs();
+extern void PbRegister_setInitialVelocity();
+extern void PbRegister_vorticityConfinement();
+extern void PbRegister_addForceField();
+extern void PbRegister_setForceField();
+extern void PbRegister_dissolveSmoke();
+extern void PbRegister_apicMapPartsToMAC();
+extern void PbRegister_apicMapMACGridToParts();
+extern void PbRegister_sampleFlagsWithParticles();
+extern void PbRegister_sampleLevelsetWithParticles();
+extern void PbRegister_sampleShapeWithParticles();
+extern void PbRegister_markFluidCells();
+extern void PbRegister_testInitGridWithPos();
+extern void PbRegister_adjustNumber();
+extern void PbRegister_debugIntToReal();
+extern void PbRegister_gridParticleIndex();
+extern void PbRegister_unionParticleLevelset();
+extern void PbRegister_averagedParticleLevelset();
+extern void PbRegister_improvedParticleLevelset();
+extern void PbRegister_pushOutofObs();
+extern void PbRegister_mapPartsToMAC();
+extern void PbRegister_mapPartsToGrid();
+extern void PbRegister_mapPartsToGridVec3();
+extern void PbRegister_mapGridToParts();
+extern void PbRegister_mapGridToPartsVec3();
+extern void PbRegister_mapMACToParts();
+extern void PbRegister_flipVelocityUpdate();
+extern void PbRegister_combineGridVel();
+extern void PbRegister_getLaplacian();
+extern void PbRegister_getCurvature();
+extern void PbRegister_processBurn();
+extern void PbRegister_updateFlame();
+extern void PbRegister_getSpiralVelocity();
+extern void PbRegister_setGradientYWeight();
+extern void PbRegister_PD_fluid_guiding();
+extern void PbRegister_releaseBlurPrecomp();
+extern void PbRegister_KEpsilonComputeProduction();
+extern void PbRegister_KEpsilonSources();
+extern void PbRegister_KEpsilonBcs();
+extern void PbRegister_KEpsilonGradientDiffusion();
+extern void PbRegister_densityInflow();
+extern void PbRegister_addNoise();
+extern void PbRegister_setNoisePdata();
+extern void PbRegister_setNoisePdataVec3();
+extern void PbRegister_setNoisePdataInt();
+extern void PbRegister_obstacleGradient();
+extern void PbRegister_obstacleLevelset();
+extern void PbRegister_applyEmission();
+extern void PbRegister_densityInflowMeshNoise();
+extern void PbRegister_densityInflowMesh();
+extern void PbRegister_checkSymmetry();
+extern void PbRegister_checkSymmetryVec3();
+extern void PbRegister_projectPpmFull();
+extern void PbRegister_addTestParts();
+extern void PbRegister_pdataMaxDiff();
+extern void PbRegister_calcCenterOfMass();
+extern void PbRegister_updateFractions();
+extern void PbRegister_setObstacleFlags();
+extern void PbRegister_initVortexVelocity();
+extern void PbRegister_blurMacGrid();
+extern void PbRegister_blurRealGrid();
+extern void PbRegister_smoothMesh();
+extern void PbRegister_subdivideMesh();
+extern void PbRegister_killSmallComponents();
+extern void PbRegister_releaseMG();
+extern void PbRegister_computePressureRhs();
+extern void PbRegister_solvePressureSystem();
+extern void PbRegister_correctVelocity();
+extern void PbRegister_solvePressure();
+extern void PbRegister_addForcePvel();
+extern void PbRegister_updateVelocityFromDeltaPos();
+extern void PbRegister_eulerStep();
+extern void PbRegister_setPartType();
+extern void PbRegister_flipComputeSecondaryParticlePotentials();
+extern void PbRegister_flipSampleSecondaryParticles();
+extern void PbRegister_flipUpdateSecondaryParticles();
+extern void PbRegister_flipDeleteParticlesInObstacle();
+extern void PbRegister_debugGridInfo();
+extern void PbRegister_setFlagsFromLevelset();
+extern void PbRegister_setMACFromLevelset();
+extern void PbRegister_flipComputePotentialTrappedAir();
+extern void PbRegister_flipComputePotentialKineticEnergy();
+extern void PbRegister_flipComputePotentialWaveCrest();
+extern void PbRegister_flipComputeSurfaceNormals();
+extern void PbRegister_flipUpdateNeighborRatio();
+extern void PbRegister_particleSurfaceTurbulence();
+extern void PbRegister_debugCheckParts();
+extern void PbRegister_markAsFixed();
+extern void PbRegister_texcoordInflow();
+extern void PbRegister_meshSmokeInflow();
+extern void PbRegister_vorticitySource();
+extern void PbRegister_smoothVorticity();
+extern void PbRegister_VPseedK41();
+extern void PbRegister_VICintegration();
+extern void PbRegister_densityFromLevelset();
+extern void PbRegister_interpolateGrid();
+extern void PbRegister_interpolateGridVec3();
+extern void PbRegister_interpolateMACGrid();
+extern void PbRegister_applySimpleNoiseVec3();
+extern void PbRegister_applySimpleNoiseReal();
+extern void PbRegister_applyNoiseVec3();
+extern void PbRegister_computeEnergy();
+extern void PbRegister_computeWaveletCoeffs();
+extern void PbRegister_computeVorticity();
+extern void PbRegister_computeStrainRateMag();
+extern void PbRegister_extrapolateSimpleFlags();
+extern void PbRegister_getCurl();
+extern void PbRegister_calcSecDeriv2d();
+extern void PbRegister_totalSum();
+extern void PbRegister_normalizeSumTo();
+extern void PbRegister_cgSolveWE();
+extern void PbRegister_file_0();
+extern void PbRegister_file_1();
+extern void PbRegister_file_2();
+extern void PbRegister_file_3();
+extern void PbRegister_file_4();
+extern void PbRegister_file_5();
+extern void PbRegister_file_6();
+extern void PbRegister_file_7();
+extern void PbRegister_file_8();
+extern void PbRegister_file_9();
+extern void PbRegister_file_10();
+extern void PbRegister_file_11();
+extern void PbRegister_file_12();
+extern void PbRegister_file_13();
+extern void PbRegister_file_14();
+extern void PbRegister_file_15();
+extern void PbRegister_file_16();
+extern void PbRegister_file_17();
+extern void PbRegister_file_18();
+extern void PbRegister_file_19();
+extern void PbRegister_file_20();
+extern void PbRegister_file_21();
+}
+
+namespace Pb {
+void MantaEnsureRegistration()
+{
+  PbRegister_mantaMsg();
+  PbRegister_printBuildInfo();
+  PbRegister_setDebugLevel();
+  PbRegister_assertNumpy();
+  PbRegister_cgSolveDiffusion();
+  PbRegister_gridMaxDiff();
+  PbRegister_gridMaxDiffInt();
+  PbRegister_gridMaxDiffVec3();
+  PbRegister_copyMacToVec3();
+  PbRegister_convertMacToVec3();
+  PbRegister_resampleVec3ToMac();
+  PbRegister_resampleMacToVec3();
+  PbRegister_copyLevelsetToReal();
+  PbRegister_copyVec3ToReal();
+  PbRegister_copyRealToVec3();
+  PbRegister_convertLevelsetToReal();
+  PbRegister_swapComponents();
+  PbRegister_getUvWeight();
+  PbRegister_resetUvGrid();
+  PbRegister_updateUvWeight();
+  PbRegister_getGridAvg();
+  PbRegister_getComponent();
+  PbRegister_setComponent();
+  PbRegister_markIsolatedFluidCell();
+  PbRegister_copyMACData();
+  PbRegister_getComp4d();
+  PbRegister_setComp4d();
+  PbRegister_grid4dMaxDiff();
+  PbRegister_grid4dMaxDiffInt();
+  PbRegister_grid4dMaxDiffVec3();
+  PbRegister_grid4dMaxDiffVec4();
+  PbRegister_setRegion4d();
+  PbRegister_setRegion4dVec4();
+  PbRegister_getSliceFrom4d();
+  PbRegister_getSliceFrom4dVec();
+  PbRegister_interpolateGrid4d();
+  PbRegister_interpolateGrid4dVec();
+  PbRegister_extrapolateMACSimple();
+  PbRegister_extrapolateMACFromWeight();
+  PbRegister_extrapolateLsSimple();
+  PbRegister_extrapolateVec3Simple();
+  PbRegister_getUniFileSize();
+  PbRegister_printUniFileInfoString();
+  PbRegister_getNpzFileSize();
+  PbRegister_quantizeGrid();
+  PbRegister_quantizeGridVec3();
+  PbRegister_resetPhiInObs();
+  PbRegister_advectSemiLagrange();
+  PbRegister_addGravity();
+  PbRegister_addGravityNoScale();
+  PbRegister_addBuoyancy();
+  PbRegister_setOpenBound();
+  PbRegister_resetOutflow();
+  PbRegister_setInflowBcs();
+  PbRegister_setWallBcs();
+  PbRegister_setInitialVelocity();
+  PbRegister_vorticityConfinement();
+  PbRegister_addForceField();
+  PbRegister_setForceField();
+  PbRegister_dissolveSmoke();
+  PbRegister_apicMapPartsToMAC();
+  PbRegister_apicMapMACGridToParts();
+  PbRegister_sampleFlagsWithParticles();
+  PbRegister_sampleLevelsetWithParticles();
+  PbRegister_sampleShapeWithParticles();
+  PbRegister_markFluidCells();
+  PbRegister_testInitGridWithPos();
+  PbRegister_adjustNumber();
+  PbRegister_debugIntToReal();
+  PbRegister_gridParticleIndex();
+  PbRegister_unionParticleLevelset();
+  PbRegister_averagedParticleLevelset();
+  PbRegister_improvedParticleLevelset();
+  PbRegister_pushOutofObs();
+  PbRegister_mapPartsToMAC();
+  PbRegister_mapPartsToGrid();
+  PbRegister_mapPartsToGridVec3();
+  PbRegister_mapGridToParts();
+  PbRegister_mapGridToPartsVec3();
+  PbRegister_mapMACToParts();
+  PbRegister_flipVelocityUpdate();
+  PbRegister_combineGridVel();
+  PbRegister_getLaplacian();
+  PbRegister_getCurvature();
+  PbRegister_processBurn();
+  PbRegister_updateFlame();
+  PbRegister_getSpiralVelocity();
+  PbRegister_setGradientYWeight();
+  PbRegister_PD_fluid_guiding();
+  PbRegister_releaseBlurPrecomp();
+  PbRegister_KEpsilonComputeProduction();
+  PbRegister_KEpsilonSources();
+  PbRegister_KEpsilonBcs();
+  PbRegister_KEpsilonGradientDiffusion();
+  PbRegister_densityInflow();
+  PbRegister_addNoise();
+  PbRegister_setNoisePdata();
+  PbRegister_setNoisePdataVec3();
+  PbRegister_setNoisePdataInt();
+  PbRegister_obstacleGradient();
+  PbRegister_obstacleLevelset();
+  PbRegister_applyEmission();
+  PbRegister_densityInflowMeshNoise();
+  PbRegister_densityInflowMesh();
+  PbRegister_checkSymmetry();
+  PbRegister_checkSymmetryVec3();
+  PbRegister_projectPpmFull();
+  PbRegister_addTestParts();
+  PbRegister_pdataMaxDiff();
+  PbRegister_calcCenterOfMass();
+  PbRegister_updateFractions();
+  PbRegister_setObstacleFlags();
+  PbRegister_initVortexVelocity();
+  PbRegister_blurMacGrid();
+  PbRegister_blurRealGrid();
+  PbRegister_smoothMesh();
+  PbRegister_subdivideMesh();
+  PbRegister_killSmallComponents();
+  PbRegister_releaseMG();
+  PbRegister_computePressureRhs();
+  PbRegister_solvePressureSystem();
+  PbRegister_correctVelocity();
+  PbRegister_solvePressure();
+  PbRegister_addForcePvel();
+  PbRegister_updateVelocityFromDeltaPos();
+  PbRegister_eulerStep();
+  PbRegister_setPartType();
+  PbRegister_flipComputeSecondaryParticlePotentials();
+  PbRegister_flipSampleSecondaryParticles();
+  PbRegister_flipUpdateSecondaryParticles();
+  PbRegister_flipDeleteParticlesInObstacle();
+  PbRegister_debugGridInfo();
+  PbRegister_setFlagsFromLevelset();
+  PbRegister_setMACFromLevelset();
+  PbRegister_flipComputePotentialTrappedAir();
+  PbRegister_flipComputePotentialKineticEnergy();
+  PbRegister_flipComputePotentialWaveCrest();
+  PbRegister_flipComputeSurfaceNormals();
+  PbRegister_flipUpdateNeighborRatio();
+  PbRegister_particleSurfaceTurbulence();
+  PbRegister_debugCheckParts();
+  PbRegister_markAsFixed();
+  PbRegister_texcoordInflow();
+  PbRegister_meshSmokeInflow();
+  PbRegister_vorticitySource();
+  PbRegister_smoothVorticity();
+  PbRegister_VPseedK41();
+  PbRegister_VICintegration();
+  PbRegister_densityFromLevelset();
+  PbRegister_interpolateGrid();
+  PbRegister_interpolateGridVec3();
+  PbRegister_interpolateMACGrid();
+  PbRegister_applySimpleNoiseVec3();
+  PbRegister_applySimpleNoiseReal();
+  PbRegister_applyNoiseVec3();
+  PbRegister_computeEnergy();
+  PbRegister_computeWaveletCoeffs();
+  PbRegister_computeVorticity();
+  PbRegister_computeStrainRateMag();
+  PbRegister_extrapolateSimpleFlags();
+  PbRegister_getCurl();
+  PbRegister_calcSecDeriv2d();
+  PbRegister_totalSum();
+  PbRegister_normalizeSumTo();
+  PbRegister_cgSolveWE();
+  PbRegister_file_0();
+  PbRegister_file_1();
+  PbRegister_file_2();
+  PbRegister_file_3();
+  PbRegister_file_4();
+  PbRegister_file_5();
+  PbRegister_file_6();
+  PbRegister_file_7();
+  PbRegister_file_8();
+  PbRegister_file_9();
+  PbRegister_file_10();
+  PbRegister_file_11();
+  PbRegister_file_12();
+  PbRegister_file_13();
+  PbRegister_file_14();
+  PbRegister_file_15();
+  PbRegister_file_16();
+  PbRegister_file_17();
+  PbRegister_file_18();
+  PbRegister_file_19();
+  PbRegister_file_20();
+  PbRegister_file_21();
+}
+}  // namespace Pb
diff --git a/extern/mantaflow/preprocessed/shapes.cpp b/extern/mantaflow/preprocessed/shapes.cpp
new file mode 100644
index 00000000000..4095758cbc0
--- /dev/null
+++ b/extern/mantaflow/preprocessed/shapes.cpp
@@ -0,0 +1,1010 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Shape classes
+ *
+ ******************************************************************************/
+
+#include "shapes.h"
+#include "commonkernels.h"
+#include "mesh.h"
+
+using namespace std;
+namespace Manta {
+
+//******************************************************************************
+// Shape class members
+
+Shape::Shape(FluidSolver *parent) : PbClass(parent), mType(TypeNone)
+{
+}
+
+LevelsetGrid Shape::computeLevelset()
+{
+  // note - 3d check deactivated! TODO double check...
+  LevelsetGrid phi(getParent());
+  generateLevelset(phi);
+  return phi;
+}
+
+bool Shape::isInside(const Vec3 &pos) const
+{
+  return false;
+}
+
+//! Kernel: Apply a shape to a grid, setting value inside
+
+template<class T> struct ApplyShapeToGrid : public KernelBase {
+  ApplyShapeToGrid(Grid<T> *grid, Shape *shape, T value, FlagGrid *respectFlags)
+      : KernelBase(grid, 0), grid(grid), shape(shape), value(value), respectFlags(respectFlags)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, Grid<T> *grid, Shape *shape, T value, FlagGrid *respectFlags) const
+  {
+    if (respectFlags && respectFlags->isObstacle(i, j, k))
+      return;
+    if (shape->isInsideGrid(i, j, k))
+      (*grid)(i, j, k) = value;
+  }
+  inline Grid<T> *getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<T> type0;
+  inline Shape *getArg1()
+  {
+    return shape;
+  }
+  typedef Shape type1;
+  inline T &getArg2()
+  {
+    return value;
+  }
+  typedef T type2;
+  inline FlagGrid *getArg3()
+  {
+    return respectFlags;
+  }
+  typedef FlagGrid type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyShapeToGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, shape, value, respectFlags);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, shape, value, respectFlags);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> *grid;
+  Shape *shape;
+  T value;
+  FlagGrid *respectFlags;
+};
+
+//! Kernel: Apply a shape to a grid, setting value inside (scaling by SDF value)
+
+template<class T> struct ApplyShapeToGridSmooth : public KernelBase {
+  ApplyShapeToGridSmooth(
+      Grid<T> *grid, Grid<Real> &phi, Real sigma, Real shift, T value, FlagGrid *respectFlags)
+      : KernelBase(grid, 0),
+        grid(grid),
+        phi(phi),
+        sigma(sigma),
+        shift(shift),
+        value(value),
+        respectFlags(respectFlags)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 Grid<T> *grid,
+                 Grid<Real> &phi,
+                 Real sigma,
+                 Real shift,
+                 T value,
+                 FlagGrid *respectFlags) const
+  {
+    if (respectFlags && respectFlags->isObstacle(i, j, k))
+      return;
+    const Real p = phi(i, j, k) - shift;
+    if (p < -sigma)
+      (*grid)(i, j, k) = value;
+    else if (p < sigma)
+      (*grid)(i, j, k) = value * (0.5f * (1.0f - p / sigma));
+  }
+  inline Grid<T> *getArg0()
+  {
+    return grid;
+  }
+  typedef Grid<T> type0;
+  inline Grid<Real> &getArg1()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type1;
+  inline Real &getArg2()
+  {
+    return sigma;
+  }
+  typedef Real type2;
+  inline Real &getArg3()
+  {
+    return shift;
+  }
+  typedef Real type3;
+  inline T &getArg4()
+  {
+    return value;
+  }
+  typedef T type4;
+  inline FlagGrid *getArg5()
+  {
+    return respectFlags;
+  }
+  typedef FlagGrid type5;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyShapeToGridSmooth ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, phi, sigma, shift, value, respectFlags);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, phi, sigma, shift, value, respectFlags);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<T> *grid;
+  Grid<Real> &phi;
+  Real sigma;
+  Real shift;
+  T value;
+  FlagGrid *respectFlags;
+};
+
+//! Kernel: Apply a shape to a MAC grid, setting value inside
+
+struct ApplyShapeToMACGrid : public KernelBase {
+  ApplyShapeToMACGrid(MACGrid *grid, Shape *shape, Vec3 value, FlagGrid *respectFlags)
+      : KernelBase(grid, 0), grid(grid), shape(shape), value(value), respectFlags(respectFlags)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, MACGrid *grid, Shape *shape, Vec3 value, FlagGrid *respectFlags) const
+  {
+    if (respectFlags && respectFlags->isObstacle(i, j, k))
+      return;
+    if (shape->isInside(Vec3(i, j + 0.5, k + 0.5)))
+      (*grid)(i, j, k).x = value.x;
+    if (shape->isInside(Vec3(i + 0.5, j, k + 0.5)))
+      (*grid)(i, j, k).y = value.y;
+    if (shape->isInside(Vec3(i + 0.5, j + 0.5, k)))
+      (*grid)(i, j, k).z = value.z;
+  }
+  inline MACGrid *getArg0()
+  {
+    return grid;
+  }
+  typedef MACGrid type0;
+  inline Shape *getArg1()
+  {
+    return shape;
+  }
+  typedef Shape type1;
+  inline Vec3 &getArg2()
+  {
+    return value;
+  }
+  typedef Vec3 type2;
+  inline FlagGrid *getArg3()
+  {
+    return respectFlags;
+  }
+  typedef FlagGrid type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel ApplyShapeToMACGrid ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, grid, shape, value, respectFlags);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, grid, shape, value, respectFlags);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  MACGrid *grid;
+  Shape *shape;
+  Vec3 value;
+  FlagGrid *respectFlags;
+};
+
+void Shape::applyToGrid(GridBase *grid, FlagGrid *respectFlags)
+{
+#if NOPYTHON != 1
+  if (grid->getType() & GridBase::TypeInt)
+    ApplyShapeToGrid<int>((Grid<int> *)grid, this, _args.get<int>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeReal)
+    ApplyShapeToGrid<Real>((Grid<Real> *)grid, this, _args.get<Real>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeMAC)
+    ApplyShapeToMACGrid((MACGrid *)grid, this, _args.get<Vec3>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeVec3)
+    ApplyShapeToGrid<Vec3>((Grid<Vec3> *)grid, this, _args.get<Vec3>("value"), respectFlags);
+  else
+    errMsg("Shape::applyToGrid(): unknown grid type");
+#else
+  errMsg("Not yet supported...");
+#endif
+}
+
+void Shape::applyToGridSmooth(GridBase *grid, Real sigma, Real shift, FlagGrid *respectFlags)
+{
+  Grid<Real> phi(grid->getParent());
+  generateLevelset(phi);
+
+#if NOPYTHON != 1
+  if (grid->getType() & GridBase::TypeInt)
+    ApplyShapeToGridSmooth<int>(
+        (Grid<int> *)grid, phi, sigma, shift, _args.get<int>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeReal)
+    ApplyShapeToGridSmooth<Real>(
+        (Grid<Real> *)grid, phi, sigma, shift, _args.get<Real>("value"), respectFlags);
+  else if (grid->getType() & GridBase::TypeVec3)
+    ApplyShapeToGridSmooth<Vec3>(
+        (Grid<Vec3> *)grid, phi, sigma, shift, _args.get<Vec3>("value"), respectFlags);
+  else
+    errMsg("Shape::applyToGridSmooth(): unknown grid type");
+#else
+  errMsg("Not yet supported...");
+#endif
+}
+
+void Shape::collideMesh(Mesh &mesh)
+{
+  const Real margin = 0.2;
+
+  Grid<Real> phi(getParent());
+  Grid<Vec3> grad(getParent());
+  generateLevelset(phi);
+  GradientOp(grad, phi);
+
+  const int num = mesh.numNodes();
+  for (int i = 0; i < num; i++) {
+    const Vec3 &p = mesh.nodes(i).pos;
+    mesh.nodes(i).flags &= ~(Mesh::NfCollide | Mesh::NfMarked);
+    if (!phi.isInBounds(p, 1))
+      continue;
+
+    for (int iter = 0; iter < 10; iter++) {
+      const Real dist = phi.getInterpolated(p);
+      if (dist < margin) {
+        Vec3 n = grad.getInterpolated(p);
+        normalize(n);
+        mesh.nodes(i).pos += (margin - dist) * n;
+        mesh.nodes(i).flags |= Mesh::NfCollide | Mesh::NfMarked;
+      }
+      else
+        break;
+    }
+  }
+}
+
+//******************************************************************************
+// Derived shape class members
+
+Box::Box(FluidSolver *parent, Vec3 center, Vec3 p0, Vec3 p1, Vec3 size) : Shape(parent)
+{
+  mType = TypeBox;
+  if (center.isValid() && size.isValid()) {
+    mP0 = center - size;
+    mP1 = center + size;
+  }
+  else if (p0.isValid() && p1.isValid()) {
+    mP0 = p0;
+    mP1 = p1;
+  }
+  else
+    errMsg("Box: specify either p0,p1 or size,center");
+}
+
+bool Box::isInside(const Vec3 &pos) const
+{
+  return (pos.x >= mP0.x && pos.y >= mP0.y && pos.z >= mP0.z && pos.x <= mP1.x && pos.y <= mP1.y &&
+          pos.z <= mP1.z);
+}
+
+void Box::generateMesh(Mesh *mesh)
+{
+  const int quadidx[24] = {0, 4, 6, 2, 3, 7, 5, 1, 0, 1, 5, 4, 6, 7, 3, 2, 0, 2, 3, 1, 5, 7, 6, 4};
+  const int nodebase = mesh->numNodes();
+  int oldtri = mesh->numTris();
+  for (int i = 0; i < 8; i++) {
+    Node p;
+    p.flags = 0;
+    p.pos = mP0;
+    if (i & 1)
+      p.pos.x = mP1.x;
+    if (i & 2)
+      p.pos.y = mP1.y;
+    if (i & 4)
+      p.pos.z = mP1.z;
+    mesh->addNode(p);
+  }
+  for (int i = 0; i < 6; i++) {
+    mesh->addTri(Triangle(nodebase + quadidx[i * 4 + 0],
+                          nodebase + quadidx[i * 4 + 1],
+                          nodebase + quadidx[i * 4 + 3]));
+    mesh->addTri(Triangle(nodebase + quadidx[i * 4 + 1],
+                          nodebase + quadidx[i * 4 + 2],
+                          nodebase + quadidx[i * 4 + 3]));
+  }
+  mesh->rebuildCorners(oldtri, -1);
+  mesh->rebuildLookup(oldtri, -1);
+}
+
+//! Kernel: Analytic SDF for box shape
+struct BoxSDF : public KernelBase {
+  BoxSDF(Grid<Real> &phi, const Vec3 &p1, const Vec3 &p2)
+      : KernelBase(&phi, 0), phi(phi), p1(p1), p2(p2)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &phi, const Vec3 &p1, const Vec3 &p2) const
+  {
+    const Vec3 p(i + 0.5, j + 0.5, k + 0.5);
+    if (p.x <= p2.x && p.x >= p1.x && p.y <= p2.y && p.y >= p1.y && p.z <= p2.z && p.z >= p1.z) {
+      // inside: minimal surface distance
+      Real mx = max(p.x - p2.x, p1.x - p.x);
+      Real my = max(p.y - p2.y, p1.y - p.y);
+      Real mz = max(p.z - p2.z, p1.z - p.z);
+      if (!phi.is3D())
+        mz = mx;  // skip for 2d...
+      phi(i, j, k) = max(mx, max(my, mz));
+    }
+    else if (p.y <= p2.y && p.y >= p1.y && p.z <= p2.z && p.z >= p1.z) {
+      // outside plane X
+      phi(i, j, k) = max(p.x - p2.x, p1.x - p.x);
+    }
+    else if (p.x <= p2.x && p.x >= p1.x && p.z <= p2.z && p.z >= p1.z) {
+      // outside plane Y
+      phi(i, j, k) = max(p.y - p2.y, p1.y - p.y);
+    }
+    else if (p.x <= p2.x && p.x >= p1.x && p.y <= p2.y && p.y >= p1.y) {
+      // outside plane Z
+      phi(i, j, k) = max(p.z - p2.z, p1.z - p.z);
+    }
+    else if (p.x > p1.x && p.x < p2.x) {
+      // lines X
+      Real m1 = sqrt(square(p1.y - p.y) + square(p1.z - p.z));
+      Real m2 = sqrt(square(p2.y - p.y) + square(p1.z - p.z));
+      Real m3 = sqrt(square(p1.y - p.y) + square(p2.z - p.z));
+      Real m4 = sqrt(square(p2.y - p.y) + square(p2.z - p.z));
+      phi(i, j, k) = min(m1, min(m2, min(m3, m4)));
+    }
+    else if (p.y > p1.y && p.y < p2.y) {
+      // lines Y
+      Real m1 = sqrt(square(p1.x - p.x) + square(p1.z - p.z));
+      Real m2 = sqrt(square(p2.x - p.x) + square(p1.z - p.z));
+      Real m3 = sqrt(square(p1.x - p.x) + square(p2.z - p.z));
+      Real m4 = sqrt(square(p2.x - p.x) + square(p2.z - p.z));
+      phi(i, j, k) = min(m1, min(m2, min(m3, m4)));
+    }
+    else if (p.z > p1.x && p.z < p2.z) {
+      // lines Z
+      Real m1 = sqrt(square(p1.y - p.y) + square(p1.x - p.x));
+      Real m2 = sqrt(square(p2.y - p.y) + square(p1.x - p.x));
+      Real m3 = sqrt(square(p1.y - p.y) + square(p2.x - p.x));
+      Real m4 = sqrt(square(p2.y - p.y) + square(p2.x - p.x));
+      phi(i, j, k) = min(m1, min(m2, min(m3, m4)));
+    }
+    else {
+      // points
+      Real m = norm(p - Vec3(p1.x, p1.y, p1.z));
+      m = min(m, norm(p - Vec3(p1.x, p1.y, p2.z)));
+      m = min(m, norm(p - Vec3(p1.x, p2.y, p1.z)));
+      m = min(m, norm(p - Vec3(p1.x, p2.y, p2.z)));
+      m = min(m, norm(p - Vec3(p2.x, p1.y, p1.z)));
+      m = min(m, norm(p - Vec3(p2.x, p1.y, p2.z)));
+      m = min(m, norm(p - Vec3(p2.x, p2.y, p1.z)));
+      m = min(m, norm(p - Vec3(p2.x, p2.y, p2.z)));
+      phi(i, j, k) = m;
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type0;
+  inline const Vec3 &getArg1()
+  {
+    return p1;
+  }
+  typedef Vec3 type1;
+  inline const Vec3 &getArg2()
+  {
+    return p2;
+  }
+  typedef Vec3 type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel BoxSDF ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, phi, p1, p2);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, phi, p1, p2);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Real> &phi;
+  const Vec3 &p1;
+  const Vec3 &p2;
+};
+void Box::generateLevelset(Grid<Real> &phi)
+{
+  BoxSDF(phi, mP0, mP1);
+}
+
+Sphere::Sphere(FluidSolver *parent, Vec3 center, Real radius, Vec3 scale)
+    : Shape(parent), mCenter(center), mScale(scale), mRadius(radius)
+{
+  mType = TypeSphere;
+}
+
+bool Sphere::isInside(const Vec3 &pos) const
+{
+  return normSquare((pos - mCenter) / mScale) <= mRadius * mRadius;
+}
+
+struct Tri {
+  Vec3 t[3];
+  int i[3];
+  Tri(Vec3 a, Vec3 b, Vec3 c)
+  {
+    t[0] = a;
+    t[1] = b;
+    t[2] = c;
+  }
+};
+void Sphere::generateMesh(Mesh *mesh)
+{
+  vector<Tri> tris;
+  const int iterations = 3;
+  int oldtri = mesh->numTris();
+
+  // start with octahedron
+  const Real d = sqrt(0.5);
+  Vec3 p[6] = {Vec3(0, 1, 0),
+               Vec3(0, -1, 0),
+               Vec3(-d, 0, -d),
+               Vec3(d, 0, -d),
+               Vec3(d, 0, d),
+               Vec3(-d, 0, d)};
+  tris.push_back(Tri(p[0], p[4], p[3]));
+  tris.push_back(Tri(p[0], p[5], p[4]));
+  tris.push_back(Tri(p[0], p[2], p[5]));
+  tris.push_back(Tri(p[0], p[3], p[2]));
+  tris.push_back(Tri(p[1], p[3], p[4]));
+  tris.push_back(Tri(p[1], p[4], p[5]));
+  tris.push_back(Tri(p[1], p[5], p[2]));
+  tris.push_back(Tri(p[1], p[2], p[3]));
+
+  // Bisect each edge and move to the surface of a unit sphere
+  for (int it = 0; it < iterations; it++) {
+    int ntold = tris.size();
+    for (int i = 0; i < ntold; i++) {
+      Vec3 pa = 0.5 * (tris[i].t[0] + tris[i].t[1]);
+      Vec3 pb = 0.5 * (tris[i].t[1] + tris[i].t[2]);
+      Vec3 pc = 0.5 * (tris[i].t[2] + tris[i].t[0]);
+      normalize(pa);
+      normalize(pb);
+      normalize(pc);
+
+      tris.push_back(Tri(tris[i].t[0], pa, pc));
+      tris.push_back(Tri(pa, tris[i].t[1], pb));
+      tris.push_back(Tri(pb, tris[i].t[2], pc));
+      tris[i].t[0] = pa;
+      tris[i].t[1] = pb;
+      tris[i].t[2] = pc;
+    }
+  }
+
+  // index + scale
+  vector<Vec3> nodes;
+  for (size_t i = 0; i < tris.size(); i++) {
+    for (int t = 0; t < 3; t++) {
+      Vec3 p = mCenter + tris[i].t[t] * mRadius * mScale;
+      // vector already there ?
+      int idx = nodes.size();
+      for (size_t j = 0; j < nodes.size(); j++) {
+        if (p == nodes[j]) {
+          idx = j;
+          break;
+        }
+      }
+      if (idx == (int)nodes.size())
+        nodes.push_back(p);
+      tris[i].i[t] = idx;
+    }
+  }
+
+  // add the to mesh
+  const int ni = mesh->numNodes();
+  for (size_t i = 0; i < nodes.size(); i++) {
+    mesh->addNode(Node(nodes[i]));
+  }
+  for (size_t t = 0; t < tris.size(); t++)
+    mesh->addTri(Triangle(tris[t].i[0] + ni, tris[t].i[1] + ni, tris[t].i[2] + ni));
+
+  mesh->rebuildCorners(oldtri, -1);
+  mesh->rebuildLookup(oldtri, -1);
+}
+
+struct SphereSDF : public KernelBase {
+  SphereSDF(Grid<Real> &phi, Vec3 center, Real radius, Vec3 scale)
+      : KernelBase(&phi, 0), phi(phi), center(center), radius(radius), scale(scale)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i, int j, int k, Grid<Real> &phi, Vec3 center, Real radius, Vec3 scale) const
+  {
+    phi(i, j, k) = norm((Vec3(i + 0.5, j + 0.5, k + 0.5) - center) / scale) - radius;
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type0;
+  inline Vec3 &getArg1()
+  {
+    return center;
+  }
+  typedef Vec3 type1;
+  inline Real &getArg2()
+  {
+    return radius;
+  }
+  typedef Real type2;
+  inline Vec3 &getArg3()
+  {
+    return scale;
+  }
+  typedef Vec3 type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel SphereSDF ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, phi, center, radius, scale);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, phi, center, radius, scale);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Real> &phi;
+  Vec3 center;
+  Real radius;
+  Vec3 scale;
+};
+void Sphere::generateLevelset(Grid<Real> &phi)
+{
+  SphereSDF(phi, mCenter, mRadius, mScale);
+}
+
+Cylinder::Cylinder(FluidSolver *parent, Vec3 center, Real radius, Vec3 z)
+    : Shape(parent), mCenter(center), mRadius(radius)
+{
+  mType = TypeCylinder;
+  mZDir = z;
+  mZ = normalize(mZDir);
+}
+
+bool Cylinder::isInside(const Vec3 &pos) const
+{
+  Real z = dot(pos - mCenter, mZDir);
+  if (fabs(z) > mZ)
+    return false;
+  Real r2 = normSquare(pos - mCenter) - square(z);
+  return r2 < square(mRadius);
+}
+
+void Cylinder::generateMesh(Mesh *mesh)
+{
+  // generate coordinate system
+  Vec3 x = getOrthogonalVector(mZDir) * mRadius;
+  Vec3 y = cross(x, mZDir);
+  Vec3 z = mZDir * mZ;
+  int oldtri = mesh->numTris();
+
+  // construct node ring
+  const int N = 20;
+  const int base = mesh->numNodes();
+  for (int i = 0; i < N; i++) {
+    const Real phi = 2.0 * M_PI * (Real)i / (Real)N;
+    Vec3 r = x * cos(phi) + y * sin(phi) + mCenter;
+    mesh->addNode(Node(r + z));
+    mesh->addNode(Node(r - z));
+  }
+  // top/bottom center
+  mesh->addNode(Node(mCenter + z));
+  mesh->addNode(Node(mCenter - z));
+
+  // connect with tris
+  for (int i = 0; i < N; i++) {
+    int cur = base + 2 * i;
+    int next = base + 2 * ((i + 1) % N);
+    // outside
+    mesh->addTri(Triangle(cur, next, cur + 1));
+    mesh->addTri(Triangle(next, next + 1, cur + 1));
+    // upper / lower
+    mesh->addTri(Triangle(cur, base + 2 * N, next));
+    mesh->addTri(Triangle(cur + 1, next + 1, base + 2 * N + 1));
+  }
+
+  mesh->rebuildCorners(oldtri, -1);
+  mesh->rebuildLookup(oldtri, -1);
+}
+
+struct CylinderSDF : public KernelBase {
+  CylinderSDF(Grid<Real> &phi, Vec3 center, Real radius, Vec3 zaxis, Real maxz)
+      : KernelBase(&phi, 0), phi(phi), center(center), radius(radius), zaxis(zaxis), maxz(maxz)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(
+      int i, int j, int k, Grid<Real> &phi, Vec3 center, Real radius, Vec3 zaxis, Real maxz) const
+  {
+    Vec3 p = Vec3(i + 0.5, j + 0.5, k + 0.5) - center;
+    Real z = fabs(dot(p, zaxis));
+    Real r = sqrt(normSquare(p) - z * z);
+    if (z < maxz) {
+      // cylinder z area
+      if (r < radius)
+        phi(i, j, k) = max(r - radius, z - maxz);
+      else
+        phi(i, j, k) = r - radius;
+    }
+    else if (r < radius) {
+      // cylinder top area
+      phi(i, j, k) = fabs(z - maxz);
+    }
+    else {
+      // edge
+      phi(i, j, k) = sqrt(square(z - maxz) + square(r - radius));
+    }
+  }
+  inline Grid<Real> &getArg0()
+  {
+    return phi;
+  }
+  typedef Grid<Real> type0;
+  inline Vec3 &getArg1()
+  {
+    return center;
+  }
+  typedef Vec3 type1;
+  inline Real &getArg2()
+  {
+    return radius;
+  }
+  typedef Real type2;
+  inline Vec3 &getArg3()
+  {
+    return zaxis;
+  }
+  typedef Vec3 type3;
+  inline Real &getArg4()
+  {
+    return maxz;
+  }
+  typedef Real type4;
+  void runMessage()
+  {
+    debMsg("Executing kernel CylinderSDF ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, phi, center, radius, zaxis, maxz);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, phi, center, radius, zaxis, maxz);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  Grid<Real> &phi;
+  Vec3 center;
+  Real radius;
+  Vec3 zaxis;
+  Real maxz;
+};
+void Cylinder::generateLevelset(Grid<Real> &phi)
+{
+  CylinderSDF(phi, mCenter, mRadius, mZDir, mZ);
+}
+
+Slope::Slope(FluidSolver *parent, Real anglexy, Real angleyz, Real origin, Vec3 gs)
+    : Shape(parent), mAnglexy(anglexy), mAngleyz(angleyz), mOrigin(origin), mGs(gs)
+{
+  mType = TypeSlope;
+}
+
+void Slope::generateMesh(Mesh *mesh)
+{
+
+  const int oldtri = mesh->numTris();
+
+  Vec3 v1(0., mOrigin, 0.);
+  mesh->addNode(Node(v1));
+
+  Real dy1 = mGs.z * std::tan(mAngleyz);
+  Vec3 v2(0., mOrigin - dy1, mGs.z);
+  mesh->addNode(Node(v2));
+
+  Real dy2 = mGs.x * std::tan(mAnglexy);
+  Vec3 v3(mGs.x, v2.y - dy2, mGs.z);
+  mesh->addNode(Node(v3));
+
+  Vec3 v4(mGs.x, mOrigin - dy2, 0.);
+  mesh->addNode(Node(v4));
+
+  mesh->addTri(Triangle(0, 1, 2));
+  mesh->addTri(Triangle(2, 3, 0));
+
+  mesh->rebuildCorners(oldtri, -1);
+  mesh->rebuildLookup(oldtri, -1);
+}
+
+bool Slope::isInside(const Vec3 &pos) const
+{
+
+  const Real alpha = -mAnglexy * M_PI / 180.;
+  const Real beta = -mAngleyz * M_PI / 180.;
+
+  Vec3 n(0, 1, 0);
+
+  n.x = std::sin(alpha) * std::cos(beta);
+  n.y = std::cos(alpha) * std::cos(beta);
+  n.z = std::sin(beta);
+
+  normalize(n);
+
+  const Real fac = std::sqrt(n.x * n.x + n.y * n.y + n.z * n.z);
+
+  return ((n.x * (double)pos.x + n.y * (double)pos.y + n.z * (double)pos.z - mOrigin) / fac) <= 0.;
+}
+
+struct SlopeSDF : public KernelBase {
+  SlopeSDF(const Vec3 &n, Grid<Real> &phiObs, const Real &fac, const Real &origin)
+      : KernelBase(&phiObs, 0), n(n), phiObs(phiObs), fac(fac), origin(origin)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(int i,
+                 int j,
+                 int k,
+                 const Vec3 &n,
+                 Grid<Real> &phiObs,
+                 const Real &fac,
+                 const Real &origin) const
+  {
+
+    phiObs(i, j, k) = (n.x * (double)i + n.y * (double)j + n.z * (double)k - origin) * fac;
+  }
+  inline const Vec3 &getArg0()
+  {
+    return n;
+  }
+  typedef Vec3 type0;
+  inline Grid<Real> &getArg1()
+  {
+    return phiObs;
+  }
+  typedef Grid<Real> type1;
+  inline const Real &getArg2()
+  {
+    return fac;
+  }
+  typedef Real type2;
+  inline const Real &getArg3()
+  {
+    return origin;
+  }
+  typedef Real type3;
+  void runMessage()
+  {
+    debMsg("Executing kernel SlopeSDF ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    const int _maxX = maxX;
+    const int _maxY = maxY;
+    if (maxZ > 1) {
+      for (int k = __r.begin(); k != (int)__r.end(); k++)
+        for (int j = 0; j < _maxY; j++)
+          for (int i = 0; i < _maxX; i++)
+            op(i, j, k, n, phiObs, fac, origin);
+    }
+    else {
+      const int k = 0;
+      for (int j = __r.begin(); j != (int)__r.end(); j++)
+        for (int i = 0; i < _maxX; i++)
+          op(i, j, k, n, phiObs, fac, origin);
+    }
+  }
+  void run()
+  {
+    if (maxZ > 1)
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
+    else
+      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
+  }
+  const Vec3 &n;
+  Grid<Real> &phiObs;
+  const Real &fac;
+  const Real &origin;
+};
+
+void Slope::generateLevelset(Grid<Real> &phi)
+{
+
+  const Real alpha = -mAnglexy * M_PI / 180.;
+  const Real beta = -mAngleyz * M_PI / 180.;
+
+  Vec3 n(0, 1, 0);
+
+  n.x = std::sin(alpha) * std::cos(beta);
+  n.y = std::cos(alpha) * std::cos(beta);
+  n.z = std::sin(beta);
+
+  normalize(n);
+
+  const Real fac = 1. / std::sqrt(n.x * n.x + n.y * n.y + n.z * n.z);
+
+  SlopeSDF(n, phi, fac, mOrigin);
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/shapes.h b/extern/mantaflow/preprocessed/shapes.h
new file mode 100644
index 00000000000..09d3d23d938
--- /dev/null
+++ b/extern/mantaflow/preprocessed/shapes.h
@@ -0,0 +1,665 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * shapes classes
+ *
+ ******************************************************************************/
+
+#ifndef _SHAPES_H
+#define _SHAPES_H
+
+#include "manta.h"
+#include "vectorbase.h"
+#include "levelset.h"
+
+namespace Manta {
+
+// forward declaration
+class Mesh;
+
+//! Base class for all shapes
+class Shape : public PbClass {
+ public:
+  enum GridType { TypeNone = 0, TypeBox = 1, TypeSphere = 2, TypeCylinder = 3, TypeSlope = 4 };
+
+  Shape(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Shape::Shape", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new Shape(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Shape::Shape", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::Shape", e.what());
+      return -1;
+    }
+  }
+
+  //! Get the type of grid
+  inline GridType getType() const
+  {
+    return mType;
+  }
+
+  //! Apply shape to flag grid, set inside cells to <value>
+  void applyToGrid(GridBase *grid, FlagGrid *respectFlags = 0);
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
+        FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 1, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->applyToGrid(grid, respectFlags);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::applyToGrid", e.what());
+      return 0;
+    }
+  }
+
+  void applyToGridSmooth(GridBase *grid,
+                         Real sigma = 1.0,
+                         Real shift = 0,
+                         FlagGrid *respectFlags = 0);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
+        Real sigma = _args.getOpt<Real>("sigma", 1, 1.0, &_lock);
+        Real shift = _args.getOpt<Real>("shift", 2, 0, &_lock);
+        FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 3, 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->applyToGridSmooth(grid, sigma, shift, respectFlags);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::applyToGridSmooth", e.what());
+      return 0;
+    }
+  }
+
+  LevelsetGrid computeLevelset();
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->computeLevelset());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::computeLevelset", e.what());
+      return 0;
+    }
+  }
+
+  void collideMesh(Mesh &mesh);
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->collideMesh(mesh);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::collideMesh", e.what());
+      return 0;
+    }
+  }
+
+  virtual Vec3 getCenter() const
+  {
+    return Vec3::Zero;
+  }
+  static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getCenter());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::getCenter", e.what());
+      return 0;
+    }
+  }
+
+  virtual void setCenter(const Vec3 &center)
+  {
+  }
+  static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        const Vec3 &center = _args.get<Vec3>("center", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setCenter(center);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::setCenter", e.what());
+      return 0;
+    }
+  }
+
+  virtual Vec3 getExtent() const
+  {
+    return Vec3::Zero;
+  }
+  static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = toPy(pbo->getExtent());
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Shape::getExtent", e.what());
+      return 0;
+    }
+  }
+
+  //! Inside test of the shape
+  virtual bool isInside(const Vec3 &pos) const;
+  inline bool isInsideGrid(int i, int j, int k) const
+  {
+    return isInside(Vec3(i + 0.5, j + 0.5, k + 0.5));
+  };
+
+  virtual void generateMesh(Mesh *mesh){};
+  virtual void generateLevelset(Grid<Real> &phi){};
+
+ protected:
+  GridType mType;
+ public:
+  PbArgs _args;
+}
+#define _C_Shape
+;
+
+//! Dummy shape
+class NullShape : public Shape {
+ public:
+  NullShape(FluidSolver *parent) : Shape(parent)
+  {
+  }
+  static int _W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "NullShape::NullShape", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new NullShape(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "NullShape::NullShape", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("NullShape::NullShape", e.what());
+      return -1;
+    }
+  }
+
+  virtual bool isInside(const Vec3 &pos) const
+  {
+    return false;
+  }
+  virtual void generateMesh(Mesh *mesh)
+  {
+  }
+
+ protected:
+  virtual void generateLevelset(Grid<Real> &phi)
+  {
+    gridSetConst<Real>(phi, 1000.0f);
+  }
+ public:
+  PbArgs _args;
+}
+#define _C_NullShape
+;
+
+//! Box shape
+class Box : public Shape {
+ public:
+  Box(FluidSolver *parent,
+      Vec3 center = Vec3::Invalid,
+      Vec3 p0 = Vec3::Invalid,
+      Vec3 p1 = Vec3::Invalid,
+      Vec3 size = Vec3::Invalid);
+  static int _W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Box::Box", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        Vec3 center = _args.getOpt<Vec3>("center", 1, Vec3::Invalid, &_lock);
+        Vec3 p0 = _args.getOpt<Vec3>("p0", 2, Vec3::Invalid, &_lock);
+        Vec3 p1 = _args.getOpt<Vec3>("p1", 3, Vec3::Invalid, &_lock);
+        Vec3 size = _args.getOpt<Vec3>("size", 4, Vec3::Invalid, &_lock);
+        obj = new Box(parent, center, p0, p1, size);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Box::Box", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Box::Box", e.what());
+      return -1;
+    }
+  }
+
+  inline Vec3 getSize() const
+  {
+    return mP1 - mP0;
+  }
+  inline Vec3 getP0() const
+  {
+    return mP0;
+  }
+  inline Vec3 getP1() const
+  {
+    return mP1;
+  }
+  virtual void setCenter(const Vec3 &center)
+  {
+    Vec3 dh = 0.5 * (mP1 - mP0);
+    mP0 = center - dh;
+    mP1 = center + dh;
+  }
+  virtual Vec3 getCenter() const
+  {
+    return 0.5 * (mP1 + mP0);
+  }
+  virtual Vec3 getExtent() const
+  {
+    return getSize();
+  }
+  virtual bool isInside(const Vec3 &pos) const;
+  virtual void generateMesh(Mesh *mesh);
+  virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+  Vec3 mP0, mP1;
+ public:
+  PbArgs _args;
+}
+#define _C_Box
+;
+
+//! Spherical shape
+class Sphere : public Shape {
+ public:
+  Sphere(FluidSolver *parent, Vec3 center, Real radius, Vec3 scale = Vec3(1, 1, 1));
+  static int _W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Sphere::Sphere", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        Vec3 center = _args.get<Vec3>("center", 1, &_lock);
+        Real radius = _args.get<Real>("radius", 2, &_lock);
+        Vec3 scale = _args.getOpt<Vec3>("scale", 3, Vec3(1, 1, 1), &_lock);
+        obj = new Sphere(parent, center, radius, scale);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Sphere::Sphere", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Sphere::Sphere", e.what());
+      return -1;
+    }
+  }
+
+  virtual void setCenter(const Vec3 &center)
+  {
+    mCenter = center;
+  }
+  virtual Vec3 getCenter() const
+  {
+    return mCenter;
+  }
+  inline Real getRadius() const
+  {
+    return mRadius;
+  }
+  virtual Vec3 getExtent() const
+  {
+    return Vec3(2.0 * mRadius);
+  }
+  virtual bool isInside(const Vec3 &pos) const;
+  virtual void generateMesh(Mesh *mesh);
+  virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+  Vec3 mCenter, mScale;
+  Real mRadius;
+ public:
+  PbArgs _args;
+}
+#define _C_Sphere
+;
+
+//! Cylindrical shape
+class Cylinder : public Shape {
+ public:
+  Cylinder(FluidSolver *parent, Vec3 center, Real radius, Vec3 z);
+  static int _W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Cylinder::Cylinder", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        Vec3 center = _args.get<Vec3>("center", 1, &_lock);
+        Real radius = _args.get<Real>("radius", 2, &_lock);
+        Vec3 z = _args.get<Vec3>("z", 3, &_lock);
+        obj = new Cylinder(parent, center, radius, z);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Cylinder::Cylinder", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Cylinder::Cylinder", e.what());
+      return -1;
+    }
+  }
+
+  void setRadius(Real r)
+  {
+    mRadius = r;
+  }
+  static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real r = _args.get<Real>("r", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setRadius(r);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Cylinder::setRadius", e.what());
+      return 0;
+    }
+  }
+
+  void setZ(Vec3 z)
+  {
+    mZDir = z;
+    mZ = normalize(mZDir);
+  }
+  static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Vec3 z = _args.get<Vec3>("z", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->setZ(z);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Cylinder::setZ", e.what());
+      return 0;
+    }
+  }
+
+  virtual void setCenter(const Vec3 &center)
+  {
+    mCenter = center;
+  }
+  virtual Vec3 getCenter() const
+  {
+    return mCenter;
+  }
+  inline Real getRadius() const
+  {
+    return mRadius;
+  }
+  inline Vec3 getZ() const
+  {
+    return mZ * mZDir;
+  }
+  virtual Vec3 getExtent() const
+  {
+    return Vec3(2.0 * sqrt(square(mZ) + square(mRadius)));
+  }
+  virtual bool isInside(const Vec3 &pos) const;
+  virtual void generateMesh(Mesh *mesh);
+  virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+  Vec3 mCenter, mZDir;
+  Real mRadius, mZ;
+ public:
+  PbArgs _args;
+}
+#define _C_Cylinder
+;
+
+//! Slope shape
+// generates a levelset based on a plane
+// plane is specified by two angles and an offset on the y axis in (offset vector would be ( 0,
+// offset, 0) ) the two angles are specified in degrees, between: y-axis and x-axis
+//                                                   y-axis and z-axis
+class Slope : public Shape {
+ public:
+  Slope(FluidSolver *parent, Real anglexy, Real angleyz, Real origin, Vec3 gs);
+  static int _W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Slope::Slope", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        Real anglexy = _args.get<Real>("anglexy", 1, &_lock);
+        Real angleyz = _args.get<Real>("angleyz", 2, &_lock);
+        Real origin = _args.get<Real>("origin", 3, &_lock);
+        Vec3 gs = _args.get<Vec3>("gs", 4, &_lock);
+        obj = new Slope(parent, anglexy, angleyz, origin, gs);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Slope::Slope", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Slope::Slope", e.what());
+      return -1;
+    }
+  }
+
+  virtual void setOrigin(const Real &origin)
+  {
+    mOrigin = origin;
+  }
+  virtual void setAnglexy(const Real &anglexy)
+  {
+    mAnglexy = anglexy;
+  }
+  virtual void setAngleyz(const Real &angleyz)
+  {
+    mAnglexy = angleyz;
+  }
+
+  inline Real getOrigin() const
+  {
+    return mOrigin;
+  }
+  inline Real getmAnglexy() const
+  {
+    return mAnglexy;
+  }
+  inline Real getmAngleyz() const
+  {
+    return mAngleyz;
+  }
+  virtual bool isInside(const Vec3 &pos) const;
+  virtual void generateMesh(Mesh *mesh);
+  virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+  Real mAnglexy, mAngleyz;
+  Real mOrigin;
+  Vec3 mGs;
+ public:
+  PbArgs _args;
+}
+#define _C_Slope
+;
+
+}  // namespace Manta
+#endif
diff --git a/extern/mantaflow/preprocessed/shapes.h.reg.cpp b/extern/mantaflow/preprocessed/shapes.h.reg.cpp
new file mode 100644
index 00000000000..72c9c61284c
--- /dev/null
+++ b/extern/mantaflow/preprocessed/shapes.h.reg.cpp
@@ -0,0 +1,73 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "shapes.h"
+namespace Manta {
+#ifdef _C_Box
+static const Pb::Register _R_12("Box", "Box", "Shape");
+template<> const char *Namify<Box>::S = "Box";
+static const Pb::Register _R_13("Box", "Box", Box::_W_9);
+#endif
+#ifdef _C_Cylinder
+static const Pb::Register _R_14("Cylinder", "Cylinder", "Shape");
+template<> const char *Namify<Cylinder>::S = "Cylinder";
+static const Pb::Register _R_15("Cylinder", "Cylinder", Cylinder::_W_11);
+static const Pb::Register _R_16("Cylinder", "setRadius", Cylinder::_W_12);
+static const Pb::Register _R_17("Cylinder", "setZ", Cylinder::_W_13);
+#endif
+#ifdef _C_NullShape
+static const Pb::Register _R_18("NullShape", "NullShape", "Shape");
+template<> const char *Namify<NullShape>::S = "NullShape";
+static const Pb::Register _R_19("NullShape", "NullShape", NullShape::_W_8);
+#endif
+#ifdef _C_Shape
+static const Pb::Register _R_20("Shape", "Shape", "PbClass");
+template<> const char *Namify<Shape>::S = "Shape";
+static const Pb::Register _R_21("Shape", "Shape", Shape::_W_0);
+static const Pb::Register _R_22("Shape", "applyToGrid", Shape::_W_1);
+static const Pb::Register _R_23("Shape", "applyToGridSmooth", Shape::_W_2);
+static const Pb::Register _R_24("Shape", "computeLevelset", Shape::_W_3);
+static const Pb::Register _R_25("Shape", "collideMesh", Shape::_W_4);
+static const Pb::Register _R_26("Shape", "getCenter", Shape::_W_5);
+static const Pb::Register _R_27("Shape", "setCenter", Shape::_W_6);
+static const Pb::Register _R_28("Shape", "getExtent", Shape::_W_7);
+#endif
+#ifdef _C_Slope
+static const Pb::Register _R_29("Slope", "Slope", "Shape");
+template<> const char *Namify<Slope>::S = "Slope";
+static const Pb::Register _R_30("Slope", "Slope", Slope::_W_14);
+#endif
+#ifdef _C_Sphere
+static const Pb::Register _R_31("Sphere", "Sphere", "Shape");
+template<> const char *Namify<Sphere>::S = "Sphere";
+static const Pb::Register _R_32("Sphere", "Sphere", Sphere::_W_10);
+#endif
+extern "C" {
+void PbRegister_file_12()
+{
+  KEEP_UNUSED(_R_12);
+  KEEP_UNUSED(_R_13);
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+  KEEP_UNUSED(_R_23);
+  KEEP_UNUSED(_R_24);
+  KEEP_UNUSED(_R_25);
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/test.cpp b/extern/mantaflow/preprocessed/test.cpp
new file mode 100644
index 00000000000..b90c886efe7
--- /dev/null
+++ b/extern/mantaflow/preprocessed/test.cpp
@@ -0,0 +1,133 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Use this file to test new functionality
+ *
+ ******************************************************************************/
+
+#include "levelset.h"
+#include "commonkernels.h"
+#include "particle.h"
+#include <cmath>
+
+using namespace std;
+
+namespace Manta {
+
+// two simple example kernels
+
+struct reductionTest : public KernelBase {
+  reductionTest(const Grid<Real> &v) : KernelBase(&v, 0), v(v), sum(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &v, double &sum)
+  {
+    sum += v[idx];
+  }
+  inline operator double()
+  {
+    return sum;
+  }
+  inline double &getRet()
+  {
+    return sum;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return v;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel reductionTest ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, v, sum);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  reductionTest(reductionTest &o, tbb::split) : KernelBase(o), v(o.v), sum(0)
+  {
+  }
+  void join(const reductionTest &o)
+  {
+    sum += o.sum;
+  }
+  const Grid<Real> &v;
+  double sum;
+};
+
+struct minReduction : public KernelBase {
+  minReduction(const Grid<Real> &v) : KernelBase(&v, 0), v(v), sum(0)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx, const Grid<Real> &v, double &sum)
+  {
+    if (sum < v[idx])
+      sum = v[idx];
+  }
+  inline operator double()
+  {
+    return sum;
+  }
+  inline double &getRet()
+  {
+    return sum;
+  }
+  inline const Grid<Real> &getArg0()
+  {
+    return v;
+  }
+  typedef Grid<Real> type0;
+  void runMessage()
+  {
+    debMsg("Executing kernel minReduction ", 3);
+    debMsg("Kernel range"
+               << " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r)
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, v, sum);
+  }
+  void run()
+  {
+    tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  minReduction(minReduction &o, tbb::split) : KernelBase(o), v(o.v), sum(0)
+  {
+  }
+  void join(const minReduction &o)
+  {
+    sum = min(sum, o.sum);
+  }
+  const Grid<Real> &v;
+  double sum;
+};
+
+// ... add more test code here if necessary ...
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/timing.cpp b/extern/mantaflow/preprocessed/timing.cpp
new file mode 100644
index 00000000000..ae572032e4a
--- /dev/null
+++ b/extern/mantaflow/preprocessed/timing.cpp
@@ -0,0 +1,128 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Plugin timing
+ *
+ ******************************************************************************/
+
+#include "timing.h"
+#include <fstream>
+
+using namespace std;
+namespace Manta {
+
+TimingData::TimingData() : updated(false), num(0)
+{
+}
+
+void TimingData::start(FluidSolver *parent, const string &name)
+{
+  mLastPlugin = name;
+  mPluginTimer.get();
+}
+
+void TimingData::stop(FluidSolver *parent, const string &name)
+{
+  if (mLastPlugin == name && name != "FluidSolver::step") {
+    updated = true;
+    const string parentName = parent ? parent->getName() : "";
+    MuTime diff = mPluginTimer.update();
+    vector<TimingSet> &cur = mData[name];
+    for (vector<TimingSet>::iterator it = cur.begin(); it != cur.end(); it++) {
+      if (it->solver == parentName) {
+        it->cur += diff;
+        it->updated = true;
+        return;
+      }
+    }
+    TimingSet s;
+    s.solver = parentName;
+    s.cur = diff;
+    s.updated = true;
+    cur.push_back(s);
+  }
+}
+
+void TimingData::step()
+{
+  if (updated)
+    num++;
+  std::map<std::string, std::vector<TimingSet>>::iterator it;
+  for (it = mData.begin(); it != mData.end(); it++) {
+    for (vector<TimingSet>::iterator it2 = it->second.begin(); it2 != it->second.end(); it2++) {
+      if (it2->updated) {
+        it2->total += it2->cur;
+        it2->num++;
+      }
+      it2->cur.clear();
+      it2->updated = false;
+    }
+  }
+  updated = false;
+}
+
+void TimingData::print()
+{
+  MuTime total;
+  total.clear();
+  std::map<std::string, std::vector<TimingSet>>::iterator it;
+  for (it = mData.begin(); it != mData.end(); it++)
+    for (vector<TimingSet>::iterator it2 = it->second.begin(); it2 != it->second.end(); it2++)
+      total += it2->cur;
+
+  printf("\n-- STEP %3d ----------------------------\n", num);
+  for (it = mData.begin(); it != mData.end(); it++) {
+    for (vector<TimingSet>::iterator it2 = it->second.begin(); it2 != it->second.end(); it2++) {
+      if (!it2->updated)
+        continue;
+      string name = it->first;
+      if (it->second.size() > 1 && !it2->solver.empty())
+        name += "[" + it2->solver + "]";
+      printf("[%4.1f%%] %s (%s)\n",
+             100.0 * ((Real)it2->cur.time / (Real)total.time),
+             name.c_str(),
+             it2->cur.toString().c_str());
+    }
+  }
+  step();
+
+  printf("----------------------------------------\n");
+  printf("Total : %s\n\n", total.toString().c_str());
+}
+
+void TimingData::saveMean(const string &filename)
+{
+  ofstream ofs(filename.c_str());
+  step();
+  if (!ofs.good())
+    errMsg("can't open " + filename + " as timing log");
+  ofs << "Mean timings of " << num << " steps :" << endl << endl;
+  MuTime total;
+  total.clear();
+  std::map<std::string, std::vector<TimingSet>>::iterator it;
+  for (it = mData.begin(); it != mData.end(); it++)
+    for (vector<TimingSet>::iterator it2 = it->second.begin(); it2 != it->second.end(); it2++) {
+      total += it2->cur;
+      string name = it->first;
+      if (it->second.size() > 1)
+        name += "[" + it2->solver + "]";
+
+      ofs << name << " " << (it2->total / it2->num) << endl;
+    }
+
+  ofs << endl << "Total : " << total << " (mean " << total / num << ")" << endl;
+  ofs.close();
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/timing.h b/extern/mantaflow/preprocessed/timing.h
new file mode 100644
index 00000000000..a05e5cd3323
--- /dev/null
+++ b/extern/mantaflow/preprocessed/timing.h
@@ -0,0 +1,157 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Plugin timing
+ *
+ ******************************************************************************/
+
+#ifndef _TIMING_H
+#define _TIMING_H
+
+#include "manta.h"
+#include <map>
+namespace Manta {
+
+class TimingData {
+ private:
+  TimingData();
+
+ public:
+  static TimingData &instance()
+  {
+    static TimingData a;
+    return a;
+  }
+
+  void print();
+  void saveMean(const std::string &filename);
+  void start(FluidSolver *parent, const std::string &name);
+  void stop(FluidSolver *parent, const std::string &name);
+
+ protected:
+  void step();
+  struct TimingSet {
+    TimingSet() : num(0), updated(false)
+    {
+      cur.clear();
+      total.clear();
+    }
+    MuTime cur, total;
+    int num;
+    bool updated;
+    std::string solver;
+  };
+  bool updated;
+
+  int num;
+  MuTime mPluginTimer;
+  std::string mLastPlugin;
+  std::map<std::string, std::vector<TimingSet>> mData;
+};
+
+// Python interface
+class Timings : public PbClass {
+ public:
+  Timings() : PbClass(0)
+  {
+  }
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "Timings::Timings", !noTiming);
+      {
+        ArgLocker _lock;
+        obj = new Timings();
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "Timings::Timings", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("Timings::Timings", e.what());
+      return -1;
+    }
+  }
+
+  void display()
+  {
+    TimingData::instance().print();
+  }
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Timings::display", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->display();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Timings::display", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Timings::display", e.what());
+      return 0;
+    }
+  }
+  void saveMean(std::string file)
+  {
+    TimingData::instance().saveMean(file);
+  }
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "Timings::saveMean", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        std::string file = _args.get<std::string>("file", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->saveMean(file);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "Timings::saveMean", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("Timings::saveMean", e.what());
+      return 0;
+    }
+  }
+
+ public:
+  PbArgs _args;
+}
+#define _C_Timings
+;
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/timing.h.reg.cpp b/extern/mantaflow/preprocessed/timing.h.reg.cpp
new file mode 100644
index 00000000000..c0f63ec7850
--- /dev/null
+++ b/extern/mantaflow/preprocessed/timing.h.reg.cpp
@@ -0,0 +1,24 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "timing.h"
+namespace Manta {
+#ifdef _C_Timings
+static const Pb::Register _R_16("Timings", "Timings", "PbClass");
+template<> const char *Namify<Timings>::S = "Timings";
+static const Pb::Register _R_17("Timings", "Timings", Timings::_W_0);
+static const Pb::Register _R_18("Timings", "display", Timings::_W_1);
+static const Pb::Register _R_19("Timings", "saveMean", Timings::_W_2);
+#endif
+extern "C" {
+void PbRegister_file_16()
+{
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+  KEEP_UNUSED(_R_19);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/turbulencepart.cpp b/extern/mantaflow/preprocessed/turbulencepart.cpp
new file mode 100644
index 00000000000..168ae9cc2f2
--- /dev/null
+++ b/extern/mantaflow/preprocessed/turbulencepart.cpp
@@ -0,0 +1,288 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.ynu.org/licenses
+ *
+ * Turbulence particles
+ *
+ ******************************************************************************/
+
+#include "turbulencepart.h"
+#include "shapes.h"
+#include "randomstream.h"
+
+using namespace std;
+namespace Manta {
+
+TurbulenceParticleSystem::TurbulenceParticleSystem(FluidSolver *parent, WaveletNoiseField &noise)
+    : ParticleSystem<TurbulenceParticleData>(parent), noise(noise)
+{
+}
+
+ParticleBase *TurbulenceParticleSystem::clone()
+{
+  TurbulenceParticleSystem *nm = new TurbulenceParticleSystem(getParent(), noise);
+  compress();
+
+  nm->mData = mData;
+  nm->setName(getName());
+  return nm;
+}
+
+inline Vec3 hsv2rgb(Real h, Real s, Real v)
+{
+  Real r = 0, g = 0, b = 0;
+
+  int i = (int)(h * 6);
+  Real f = h * 6 - i;
+  Real p = v * (1 - s);
+  Real q = v * (1 - f * s);
+  Real t = v * (1 - (1 - f) * s);
+
+  switch (i % 6) {
+    case 0:
+      r = v, g = t, b = p;
+      break;
+    case 1:
+      r = q, g = v, b = p;
+      break;
+    case 2:
+      r = p, g = v, b = t;
+      break;
+    case 3:
+      r = p, g = q, b = v;
+      break;
+    case 4:
+      r = t, g = p, b = v;
+      break;
+    case 5:
+      r = v, g = p, b = q;
+      break;
+    default:
+      break;
+  }
+
+  return Vec3(r, g, b);
+}
+
+void TurbulenceParticleSystem::seed(Shape *shape, int num)
+{
+  static RandomStream rand(34894231);
+  Vec3 sz = shape->getExtent(), p0 = shape->getCenter() - sz * 0.5;
+  for (int i = 0; i < num; i++) {
+    Vec3 p;
+    do {
+      p = rand.getVec3() * sz + p0;
+    } while (!shape->isInside(p));
+    Real z = (p.z - p0.z) / sz.z;
+    add(TurbulenceParticleData(p, hsv2rgb(z, 0.75, 1.0)));
+  }
+}
+
+void TurbulenceParticleSystem::resetTexCoords(int num, const Vec3 &inflow)
+{
+  if (num == 0) {
+    for (int i = 0; i < size(); i++)
+      mData[i].tex0 = mData[i].pos - inflow;
+  }
+  else {
+    for (int i = 0; i < size(); i++)
+      mData[i].tex1 = mData[i].pos - inflow;
+  }
+}
+
+struct KnSynthesizeTurbulence : public KernelBase {
+  KnSynthesizeTurbulence(TurbulenceParticleSystem &p,
+                         FlagGrid &flags,
+                         WaveletNoiseField &noise,
+                         Grid<Real> &kGrid,
+                         Real alpha,
+                         Real dt,
+                         int octaves,
+                         Real scale,
+                         Real invL0,
+                         Real kmin)
+      : KernelBase(p.size()),
+        p(p),
+        flags(flags),
+        noise(noise),
+        kGrid(kGrid),
+        alpha(alpha),
+        dt(dt),
+        octaves(octaves),
+        scale(scale),
+        invL0(invL0),
+        kmin(kmin)
+  {
+    runMessage();
+    run();
+  }
+  inline void op(IndexInt idx,
+                 TurbulenceParticleSystem &p,
+                 FlagGrid &flags,
+                 WaveletNoiseField &noise,
+                 Grid<Real> &kGrid,
+                 Real alpha,
+                 Real dt,
+                 int octaves,
+                 Real scale,
+                 Real invL0,
+                 Real kmin) const
+  {
+    const Real PERSISTENCE = 0.56123f;
+
+    const Vec3 pos(p[idx].pos);
+    if (flags.isInBounds(pos)) {  // && !flags.isObstacle(pos)) {
+      Real k2 = kGrid.getInterpolated(pos) - kmin;
+      Real ks = k2 < 0 ? 0.0 : sqrt(k2);
+
+      // Wavelet noise lookup
+      Real amplitude = scale * ks;
+      Real multiplier = invL0;
+      Vec3 vel(0.);
+      for (int o = 0; o < octaves; o++) {
+        // Vec3 ns = noise.evaluateCurl(p[i].pos * multiplier) * amplitude;
+        Vec3 n0 = noise.evaluateCurl(p[idx].tex0 * multiplier) * amplitude;
+        Vec3 n1 = noise.evaluateCurl(p[idx].tex1 * multiplier) * amplitude;
+        vel += alpha * n0 + (1.0f - alpha) * n1;
+
+        // next scale
+        amplitude *= PERSISTENCE;
+        multiplier *= 2.0f;
+      }
+
+      // advection
+      Vec3 dx = vel * dt;
+      p[idx].pos += dx;
+      p[idx].tex0 += dx;
+      p[idx].tex1 += dx;
+    }
+  }
+  inline TurbulenceParticleSystem &getArg0()
+  {
+    return p;
+  }
+  typedef TurbulenceParticleSystem type0;
+  inline FlagGrid &getArg1()
+  {
+    return flags;
+  }
+  typedef FlagGrid type1;
+  inline WaveletNoiseField &getArg2()
+  {
+    return noise;
+  }
+  typedef WaveletNoiseField type2;
+  inline Grid<Real> &getArg3()
+  {
+    return kGrid;
+  }
+  typedef Grid<Real> type3;
+  inline Real &getArg4()
+  {
+    return alpha;
+  }
+  typedef Real type4;
+  inline Real &getArg5()
+  {
+    return dt;
+  }
+  typedef Real type5;
+  inline int &getArg6()
+  {
+    return octaves;
+  }
+  typedef int type6;
+  inline Real &getArg7()
+  {
+    return scale;
+  }
+  typedef Real type7;
+  inline Real &getArg8()
+  {
+    return invL0;
+  }
+  typedef Real type8;
+  inline Real &getArg9()
+  {
+    return kmin;
+  }
+  typedef Real type9;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnSynthesizeTurbulence ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, p, flags, noise, kGrid, alpha, dt, octaves, scale, invL0, kmin);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  TurbulenceParticleSystem &p;
+  FlagGrid &flags;
+  WaveletNoiseField &noise;
+  Grid<Real> &kGrid;
+  Real alpha;
+  Real dt;
+  int octaves;
+  Real scale;
+  Real invL0;
+  Real kmin;
+};
+
+void TurbulenceParticleSystem::synthesize(FlagGrid &flags,
+                                          Grid<Real> &k,
+                                          int octaves,
+                                          Real switchLength,
+                                          Real L0,
+                                          Real scale,
+                                          Vec3 inflowBias)
+{
+  static Real ctime = 0;
+  static Vec3 inflow(0.);
+  Real dt = getParent()->getDt();
+
+  // collect inflow bias
+  inflow += inflowBias * dt;
+
+  // alpha: hat function over time
+  Real oldAlpha = 2.0f * nmod(ctime / switchLength, Real(1.0));
+  ctime += dt;
+  Real alpha = 2.0f * nmod(ctime / switchLength, Real(1.0));
+
+  if (oldAlpha < 1.0f && alpha >= 1.0f)
+    resetTexCoords(0, inflow);
+  if (oldAlpha > alpha)
+    resetTexCoords(1, inflow);
+  if (alpha > 1.0f)
+    alpha = 2.0f - alpha;
+  alpha = 1.0;
+
+  KnSynthesizeTurbulence(
+      *this, flags, noise, k, alpha, dt, octaves, scale, 1.0f / L0, 1.5 * square(0.1));
+}
+
+void TurbulenceParticleSystem::deleteInObstacle(FlagGrid &flags)
+{
+  for (int i = 0; i < size(); i++)
+    if (flags.isObstacle(mData[i].pos))
+      mData[i].flag |= PDELETE;
+  compress();
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/turbulencepart.h b/extern/mantaflow/preprocessed/turbulencepart.h
new file mode 100644
index 00000000000..7e7fbae15fd
--- /dev/null
+++ b/extern/mantaflow/preprocessed/turbulencepart.h
@@ -0,0 +1,210 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Turbulence particles
+ *
+ ******************************************************************************/
+
+#ifndef _TURBULENCEPART_H_
+#define _TURBULENCEPART_H_
+
+#include "particle.h"
+#include "noisefield.h"
+
+namespace Manta {
+class Shape;
+
+struct TurbulenceParticleData {
+  TurbulenceParticleData() : pos(0.0), color(1.), tex0(0.0), tex1(0.0), flag(0)
+  {
+  }
+  TurbulenceParticleData(const Vec3 &p, const Vec3 &color = Vec3(1.))
+      : pos(p), color(color), tex0(p), tex1(p), flag(0)
+  {
+  }
+  Vec3 pos, color;
+  Vec3 tex0, tex1;
+  int flag;
+  static ParticleBase::SystemType getType()
+  {
+    return ParticleBase::TURBULENCE;
+  }
+};
+
+//! Turbulence particles
+class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
+ public:
+  TurbulenceParticleSystem(FluidSolver *parent, WaveletNoiseField &noise);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "TurbulenceParticleSystem::TurbulenceParticleSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 1, &_lock);
+        obj = new TurbulenceParticleSystem(parent, noise);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(
+          obj->getParent(), "TurbulenceParticleSystem::TurbulenceParticleSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("TurbulenceParticleSystem::TurbulenceParticleSystem", e.what());
+      return -1;
+    }
+  }
+
+  void resetTexCoords(int num, const Vec3 &inflow);
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      TurbulenceParticleSystem *pbo = dynamic_cast<TurbulenceParticleSystem *>(
+          Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::resetTexCoords", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        int num = _args.get<int>("num", 0, &_lock);
+        const Vec3 &inflow = _args.get<Vec3>("inflow", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->resetTexCoords(num, inflow);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "TurbulenceParticleSystem::resetTexCoords", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("TurbulenceParticleSystem::resetTexCoords", e.what());
+      return 0;
+    }
+  }
+
+  void seed(Shape *source, int num);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      TurbulenceParticleSystem *pbo = dynamic_cast<TurbulenceParticleSystem *>(
+          Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::seed", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Shape *source = _args.getPtr<Shape>("source", 0, &_lock);
+        int num = _args.get<int>("num", 1, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->seed(source, num);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "TurbulenceParticleSystem::seed", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("TurbulenceParticleSystem::seed", e.what());
+      return 0;
+    }
+  }
+
+  void synthesize(FlagGrid &flags,
+                  Grid<Real> &k,
+                  int octaves = 2,
+                  Real switchLength = 10.0,
+                  Real L0 = 0.1,
+                  Real scale = 1.0,
+                  Vec3 inflowBias = 0.0);
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      TurbulenceParticleSystem *pbo = dynamic_cast<TurbulenceParticleSystem *>(
+          Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::synthesize", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 1, &_lock);
+        int octaves = _args.getOpt<int>("octaves", 2, 2, &_lock);
+        Real switchLength = _args.getOpt<Real>("switchLength", 3, 10.0, &_lock);
+        Real L0 = _args.getOpt<Real>("L0", 4, 0.1, &_lock);
+        Real scale = _args.getOpt<Real>("scale", 5, 1.0, &_lock);
+        Vec3 inflowBias = _args.getOpt<Vec3>("inflowBias", 6, 0.0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->synthesize(flags, k, octaves, switchLength, L0, scale, inflowBias);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "TurbulenceParticleSystem::synthesize", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("TurbulenceParticleSystem::synthesize", e.what());
+      return 0;
+    }
+  }
+
+  void deleteInObstacle(FlagGrid &flags);
+  static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      TurbulenceParticleSystem *pbo = dynamic_cast<TurbulenceParticleSystem *>(
+          Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::deleteInObstacle", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->deleteInObstacle(flags);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "TurbulenceParticleSystem::deleteInObstacle", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("TurbulenceParticleSystem::deleteInObstacle", e.what());
+      return 0;
+    }
+  }
+
+  virtual ParticleBase *clone();
+
+ private:
+  WaveletNoiseField &noise;
+ public:
+  PbArgs _args;
+}
+#define _C_TurbulenceParticleSystem
+;
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/turbulencepart.h.reg.cpp b/extern/mantaflow/preprocessed/turbulencepart.h.reg.cpp
new file mode 100644
index 00000000000..1f035908830
--- /dev/null
+++ b/extern/mantaflow/preprocessed/turbulencepart.h.reg.cpp
@@ -0,0 +1,89 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "turbulencepart.h"
+namespace Manta {
+#ifdef _C_ParticleSystem
+static const Pb::Register _R_21("ParticleSystem<TurbulenceParticleData>",
+                                "ParticleSystem<TurbulenceParticleData>",
+                                "ParticleBase");
+template<>
+const char *Namify<ParticleSystem<TurbulenceParticleData>>::S =
+    "ParticleSystem<TurbulenceParticleData>";
+static const Pb::Register _R_22("ParticleSystem<TurbulenceParticleData>",
+                                "ParticleSystem",
+                                ParticleSystem<TurbulenceParticleData>::_W_2);
+static const Pb::Register _R_23("ParticleSystem<TurbulenceParticleData>",
+                                "pySize",
+                                ParticleSystem<TurbulenceParticleData>::_W_3);
+static const Pb::Register _R_24("ParticleSystem<TurbulenceParticleData>",
+                                "setPos",
+                                ParticleSystem<TurbulenceParticleData>::_W_4);
+static const Pb::Register _R_25("ParticleSystem<TurbulenceParticleData>",
+                                "getPos",
+                                ParticleSystem<TurbulenceParticleData>::_W_5);
+static const Pb::Register _R_26("ParticleSystem<TurbulenceParticleData>",
+                                "getPosPdata",
+                                ParticleSystem<TurbulenceParticleData>::_W_6);
+static const Pb::Register _R_27("ParticleSystem<TurbulenceParticleData>",
+                                "setPosPdata",
+                                ParticleSystem<TurbulenceParticleData>::_W_7);
+static const Pb::Register _R_28("ParticleSystem<TurbulenceParticleData>",
+                                "clear",
+                                ParticleSystem<TurbulenceParticleData>::_W_8);
+static const Pb::Register _R_29("ParticleSystem<TurbulenceParticleData>",
+                                "advectInGrid",
+                                ParticleSystem<TurbulenceParticleData>::_W_9);
+static const Pb::Register _R_30("ParticleSystem<TurbulenceParticleData>",
+                                "projectOutside",
+                                ParticleSystem<TurbulenceParticleData>::_W_10);
+static const Pb::Register _R_31("ParticleSystem<TurbulenceParticleData>",
+                                "projectOutOfBnd",
+                                ParticleSystem<TurbulenceParticleData>::_W_11);
+#endif
+#ifdef _C_TurbulenceParticleSystem
+static const Pb::Register _R_32("TurbulenceParticleSystem",
+                                "TurbulenceParticleSystem",
+                                "ParticleSystem<TurbulenceParticleData>");
+template<> const char *Namify<TurbulenceParticleSystem>::S = "TurbulenceParticleSystem";
+static const Pb::Register _R_33("TurbulenceParticleSystem",
+                                "TurbulenceParticleSystem",
+                                TurbulenceParticleSystem::_W_0);
+static const Pb::Register _R_34("TurbulenceParticleSystem",
+                                "resetTexCoords",
+                                TurbulenceParticleSystem::_W_1);
+static const Pb::Register _R_35("TurbulenceParticleSystem",
+                                "seed",
+                                TurbulenceParticleSystem::_W_2);
+static const Pb::Register _R_36("TurbulenceParticleSystem",
+                                "synthesize",
+                                TurbulenceParticleSystem::_W_3);
+static const Pb::Register _R_37("TurbulenceParticleSystem",
+                                "deleteInObstacle",
+                                TurbulenceParticleSystem::_W_4);
+#endif
+extern "C" {
+void PbRegister_file_21()
+{
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+  KEEP_UNUSED(_R_23);
+  KEEP_UNUSED(_R_24);
+  KEEP_UNUSED(_R_25);
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+  KEEP_UNUSED(_R_33);
+  KEEP_UNUSED(_R_34);
+  KEEP_UNUSED(_R_35);
+  KEEP_UNUSED(_R_36);
+  KEEP_UNUSED(_R_37);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/vortexpart.cpp b/extern/mantaflow/preprocessed/vortexpart.cpp
new file mode 100644
index 00000000000..0eba2743ee8
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexpart.cpp
@@ -0,0 +1,251 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Vortex particles
+ * (warning, the vortex methods are currently experimental, and not fully supported!)
+ *
+ ******************************************************************************/
+
+#include "vortexpart.h"
+#include "integrator.h"
+#include "mesh.h"
+
+using namespace std;
+namespace Manta {
+
+// vortex particle effect: (cyl coord around wp)
+// u = -|wp|*rho*exp( (-rho^2-z^2)/(2sigma^2) ) e_phi
+inline Vec3 VortexKernel(const Vec3 &p, const vector<VortexParticleData> &vp, Real scale)
+{
+  Vec3 u(0.0);
+  for (size_t i = 0; i < vp.size(); i++) {
+    if (vp[i].flag & ParticleBase::PDELETE)
+      continue;
+
+    // cutoff radius
+    const Vec3 r = p - vp[i].pos;
+    const Real rlen2 = normSquare(r);
+    const Real sigma2 = square(vp[i].sigma);
+    if (rlen2 > 6.0 * sigma2 || rlen2 < 1e-8)
+      continue;
+
+    // split vortex strength
+    Vec3 vortNorm = vp[i].vorticity;
+    Real strength = normalize(vortNorm) * scale;
+
+    // transform in cylinder coordinate system
+    const Real rlen = sqrt(rlen2);
+    const Real z = dot(r, vortNorm);
+    const Vec3 ePhi = cross(r, vortNorm) / rlen;
+    const Real rho2 = rlen2 - z * z;
+
+    Real vortex = 0;
+    if (rho2 > 1e-10) {
+      // evaluate Kernel
+      vortex = strength * sqrt(rho2) * exp(rlen2 * -0.5 / sigma2);
+    }
+    u += vortex * ePhi;
+  }
+  return u;
+}
+
+struct _KnVpAdvectMesh : public KernelBase {
+  _KnVpAdvectMesh(const KernelBase &base,
+                  vector<Node> &nodes,
+                  const vector<VortexParticleData> &vp,
+                  Real scale,
+                  vector<Vec3> &u)
+      : KernelBase(base), nodes(nodes), vp(vp), scale(scale), u(u)
+  {
+  }
+  inline void op(IndexInt idx,
+                 vector<Node> &nodes,
+                 const vector<VortexParticleData> &vp,
+                 Real scale,
+                 vector<Vec3> &u) const
+  {
+    if (nodes[idx].flags & Mesh::NfFixed)
+      u[idx] = 0.0;
+    else
+      u[idx] = VortexKernel(nodes[idx].pos, vp, scale);
+  }
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, nodes, vp, scale, u);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  vector<Node> &nodes;
+  const vector<VortexParticleData> &vp;
+  Real scale;
+  vector<Vec3> &u;
+};
+struct KnVpAdvectMesh : public KernelBase {
+  KnVpAdvectMesh(vector<Node> &nodes, const vector<VortexParticleData> &vp, Real scale)
+      : KernelBase(nodes.size()),
+        _inner(KernelBase(nodes.size()), nodes, vp, scale, u),
+        nodes(nodes),
+        vp(vp),
+        scale(scale),
+        u((size))
+  {
+    runMessage();
+    run();
+  }
+  void run()
+  {
+    _inner.run();
+  }
+  inline operator vector<Vec3>()
+  {
+    return u;
+  }
+  inline vector<Vec3> &getRet()
+  {
+    return u;
+  }
+  inline vector<Node> &getArg0()
+  {
+    return nodes;
+  }
+  typedef vector<Node> type0;
+  inline const vector<VortexParticleData> &getArg1()
+  {
+    return vp;
+  }
+  typedef vector<VortexParticleData> type1;
+  inline Real &getArg2()
+  {
+    return scale;
+  }
+  typedef Real type2;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnVpAdvectMesh ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  _KnVpAdvectMesh _inner;
+  vector<Node> &nodes;
+  const vector<VortexParticleData> &vp;
+  Real scale;
+  vector<Vec3> u;
+};
+
+struct _KnVpAdvectSelf : public KernelBase {
+  _KnVpAdvectSelf(const KernelBase &base,
+                  vector<VortexParticleData> &vp,
+                  Real scale,
+                  vector<Vec3> &u)
+      : KernelBase(base), vp(vp), scale(scale), u(u)
+  {
+  }
+  inline void op(IndexInt idx, vector<VortexParticleData> &vp, Real scale, vector<Vec3> &u) const
+  {
+    if (vp[idx].flag & ParticleBase::PDELETE)
+      u[idx] = 0.0;
+    else
+      u[idx] = VortexKernel(vp[idx].pos, vp, scale);
+  }
+  void operator()(const tbb::blocked_range<IndexInt> &__r) const
+  {
+    for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
+      op(idx, vp, scale, u);
+  }
+  void run()
+  {
+    tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this);
+  }
+  vector<VortexParticleData> &vp;
+  Real scale;
+  vector<Vec3> &u;
+};
+struct KnVpAdvectSelf : public KernelBase {
+  KnVpAdvectSelf(vector<VortexParticleData> &vp, Real scale)
+      : KernelBase(vp.size()),
+        _inner(KernelBase(vp.size()), vp, scale, u),
+        vp(vp),
+        scale(scale),
+        u((size))
+  {
+    runMessage();
+    run();
+  }
+  void run()
+  {
+    _inner.run();
+  }
+  inline operator vector<Vec3>()
+  {
+    return u;
+  }
+  inline vector<Vec3> &getRet()
+  {
+    return u;
+  }
+  inline vector<VortexParticleData> &getArg0()
+  {
+    return vp;
+  }
+  typedef vector<VortexParticleData> type0;
+  inline Real &getArg1()
+  {
+    return scale;
+  }
+  typedef Real type1;
+  void runMessage()
+  {
+    debMsg("Executing kernel KnVpAdvectSelf ", 3);
+    debMsg("Kernel range"
+               << " size " << size << " ",
+           4);
+  };
+  _KnVpAdvectSelf _inner;
+  vector<VortexParticleData> &vp;
+  Real scale;
+  vector<Vec3> u;
+};
+
+VortexParticleSystem::VortexParticleSystem(FluidSolver *parent)
+    : ParticleSystem<VortexParticleData>(parent)
+{
+}
+
+void VortexParticleSystem::advectSelf(Real scale, int integrationMode)
+{
+  KnVpAdvectSelf kernel(mData, scale * getParent()->getDt());
+  integratePointSet(kernel, integrationMode);
+}
+
+void VortexParticleSystem::applyToMesh(Mesh &mesh, Real scale, int integrationMode)
+{
+  KnVpAdvectMesh kernel(mesh.getNodeData(), mData, scale * getParent()->getDt());
+  integratePointSet(kernel, integrationMode);
+}
+
+ParticleBase *VortexParticleSystem::clone()
+{
+  VortexParticleSystem *nm = new VortexParticleSystem(getParent());
+  compress();
+
+  nm->mData = mData;
+  nm->setName(getName());
+  return nm;
+}
+
+}  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/vortexpart.h b/extern/mantaflow/preprocessed/vortexpart.h
new file mode 100644
index 00000000000..20335c20058
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexpart.h
@@ -0,0 +1,138 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Vortex particles
+ * (warning, the vortex methods are currently experimental, and not fully supported!)
+ *
+ ******************************************************************************/
+
+#ifndef _VORTEXPART_H
+#define _VORTEXPART_H
+
+#include "particle.h"
+
+namespace Manta {
+class Mesh;
+
+struct VortexParticleData {
+  VortexParticleData() : pos(0.0), vorticity(0.0), sigma(0), flag(0)
+  {
+  }
+  VortexParticleData(const Vec3 &p, const Vec3 &v, Real sig)
+      : pos(p), vorticity(v), sigma(sig), flag(0)
+  {
+  }
+  Vec3 pos, vorticity;
+  Real sigma;
+  int flag;
+  static ParticleBase::SystemType getType()
+  {
+    return ParticleBase::VORTEX;
+  }
+};
+
+//! Vortex particles
+class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
+ public:
+  VortexParticleSystem(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "VortexParticleSystem::VortexParticleSystem", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new VortexParticleSystem(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "VortexParticleSystem::VortexParticleSystem", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexParticleSystem::VortexParticleSystem", e.what());
+      return -1;
+    }
+  }
+
+  void advectSelf(Real scale = 1.0, int integrationMode = IntRK4);
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::advectSelf", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Real scale = _args.getOpt<Real>("scale", 0, 1.0, &_lock);
+        int integrationMode = _args.getOpt<int>("integrationMode", 1, IntRK4, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->advectSelf(scale, integrationMode);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexParticleSystem::advectSelf", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexParticleSystem::advectSelf", e.what());
+      return 0;
+    }
+  }
+
+  void applyToMesh(Mesh &mesh, Real scale = 1.0, int integrationMode = IntRK4);
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::applyToMesh", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+        Real scale = _args.getOpt<Real>("scale", 1, 1.0, &_lock);
+        int integrationMode = _args.getOpt<int>("integrationMode", 2, IntRK4, &_lock);
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->applyToMesh(mesh, scale, integrationMode);
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexParticleSystem::applyToMesh", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexParticleSystem::applyToMesh", e.what());
+      return 0;
+    }
+  }
+
+  virtual ParticleBase *clone();
+ public:
+  PbArgs _args;
+}
+#define _C_VortexParticleSystem
+;
+
+}  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/vortexpart.h.reg.cpp b/extern/mantaflow/preprocessed/vortexpart.h.reg.cpp
new file mode 100644
index 00000000000..0dad1802f3c
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexpart.h.reg.cpp
@@ -0,0 +1,76 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "vortexpart.h"
+namespace Manta {
+#ifdef _C_ParticleSystem
+static const Pb::Register _R_20("ParticleSystem<VortexParticleData>",
+                                "ParticleSystem<VortexParticleData>",
+                                "ParticleBase");
+template<>
+const char *Namify<ParticleSystem<VortexParticleData>>::S = "ParticleSystem<VortexParticleData>";
+static const Pb::Register _R_21("ParticleSystem<VortexParticleData>",
+                                "ParticleSystem",
+                                ParticleSystem<VortexParticleData>::_W_2);
+static const Pb::Register _R_22("ParticleSystem<VortexParticleData>",
+                                "pySize",
+                                ParticleSystem<VortexParticleData>::_W_3);
+static const Pb::Register _R_23("ParticleSystem<VortexParticleData>",
+                                "setPos",
+                                ParticleSystem<VortexParticleData>::_W_4);
+static const Pb::Register _R_24("ParticleSystem<VortexParticleData>",
+                                "getPos",
+                                ParticleSystem<VortexParticleData>::_W_5);
+static const Pb::Register _R_25("ParticleSystem<VortexParticleData>",
+                                "getPosPdata",
+                                ParticleSystem<VortexParticleData>::_W_6);
+static const Pb::Register _R_26("ParticleSystem<VortexParticleData>",
+                                "setPosPdata",
+                                ParticleSystem<VortexParticleData>::_W_7);
+static const Pb::Register _R_27("ParticleSystem<VortexParticleData>",
+                                "clear",
+                                ParticleSystem<VortexParticleData>::_W_8);
+static const Pb::Register _R_28("ParticleSystem<VortexParticleData>",
+                                "advectInGrid",
+                                ParticleSystem<VortexParticleData>::_W_9);
+static const Pb::Register _R_29("ParticleSystem<VortexParticleData>",
+                                "projectOutside",
+                                ParticleSystem<VortexParticleData>::_W_10);
+static const Pb::Register _R_30("ParticleSystem<VortexParticleData>",
+                                "projectOutOfBnd",
+                                ParticleSystem<VortexParticleData>::_W_11);
+#endif
+#ifdef _C_VortexParticleSystem
+static const Pb::Register _R_31("VortexParticleSystem",
+                                "VortexParticleSystem",
+                                "ParticleSystem<VortexParticleData>");
+template<> const char *Namify<VortexParticleSystem>::S = "VortexParticleSystem";
+static const Pb::Register _R_32("VortexParticleSystem",
+                                "VortexParticleSystem",
+                                VortexParticleSystem::_W_0);
+static const Pb::Register _R_33("VortexParticleSystem", "advectSelf", VortexParticleSystem::_W_1);
+static const Pb::Register _R_34("VortexParticleSystem", "applyToMesh", VortexParticleSystem::_W_2);
+#endif
+extern "C" {
+void PbRegister_file_20()
+{
+  KEEP_UNUSED(_R_20);
+  KEEP_UNUSED(_R_21);
+  KEEP_UNUSED(_R_22);
+  KEEP_UNUSED(_R_23);
+  KEEP_UNUSED(_R_24);
+  KEEP_UNUSED(_R_25);
+  KEEP_UNUSED(_R_26);
+  KEEP_UNUSED(_R_27);
+  KEEP_UNUSED(_R_28);
+  KEEP_UNUSED(_R_29);
+  KEEP_UNUSED(_R_30);
+  KEEP_UNUSED(_R_31);
+  KEEP_UNUSED(_R_32);
+  KEEP_UNUSED(_R_33);
+  KEEP_UNUSED(_R_34);
+}
+}
+}  // namespace Manta
\ No newline at end of file
diff --git a/extern/mantaflow/preprocessed/vortexsheet.cpp b/extern/mantaflow/preprocessed/vortexsheet.cpp
new file mode 100644
index 00000000000..695b881006d
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexsheet.cpp
@@ -0,0 +1,116 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Vortex sheets
+ * (warning, the vortex methods are currently experimental, and not fully supported!)
+ *
+ ******************************************************************************/
+
+#include "vortexsheet.h"
+#include "solvana.h"
+
+using namespace std;
+namespace Manta {
+
+// *****************************************************************************
+// VorticityChannel class members
+
+// *****************************************************************************
+// VortexSheet Mesh class members
+
+VortexSheetMesh::VortexSheetMesh(FluidSolver *parent) : Mesh(parent), mTexOffset(0.0f)
+{
+  addTriChannel(&mVorticity);
+  addNodeChannel(&mTex1);
+  addNodeChannel(&mTex2);
+  addNodeChannel(&mTurb);
+}
+
+Mesh *VortexSheetMesh::clone()
+{
+  VortexSheetMesh *nm = new VortexSheetMesh(mParent);
+  *nm = *this;
+  nm->setName(getName());
+  return nm;
+}
+
+void VortexSheetMesh::calcVorticity()
+{
+  for (size_t tri = 0; tri < mTris.size(); tri++) {
+    VortexSheetInfo &v = mVorticity.data[tri];
+    Vec3 e0 = getEdge(tri, 0), e1 = getEdge(tri, 1), e2 = getEdge(tri, 2);
+    Real area = getFaceArea(tri);
+
+    if (area < 1e-10) {
+      v.smokeAmount = 0;
+      v.vorticity = 0;
+    }
+    else {
+      v.smokeAmount = 0;
+      v.vorticity = (v.circulation[0] * e0 + v.circulation[1] * e1 + v.circulation[2] * e2) / area;
+    }
+  }
+}
+
+void VortexSheetMesh::calcCirculation()
+{
+  for (size_t tri = 0; tri < mTris.size(); tri++) {
+    VortexSheetInfo &v = mVorticity.data[tri];
+    Vec3 e0 = getEdge(tri, 0), e1 = getEdge(tri, 1), e2 = getEdge(tri, 2);
+    Real area = getFaceArea(tri);
+
+    if (area < 1e-10 || normSquare(v.vorticity) < 1e-10) {
+      v.circulation = 0;
+      continue;
+    }
+
+    float cx, cy, cz;
+    SolveOverconstraint34(e0.x,
+                          e0.y,
+                          e0.z,
+                          e1.x,
+                          e1.y,
+                          e1.z,
+                          e2.x,
+                          e2.y,
+                          e2.z,
+                          v.vorticity.x,
+                          v.vorticity.y,
+                          v.vorticity.z,
+                          cx,
+                          cy,
+                          cz);
+    v.circulation = Vec3(cx, cy, cz) * area;
+  }
+}
+
+void VortexSheetMesh::resetTex1()
+{
+  for (size_t i = 0; i < mNodes.size(); i++)
+    mTex1.data[i] = mNodes[i].pos + mTexOffset;
+}
+
+void VortexSheetMesh::resetTex2()
+{
+  for (size_t i = 0; i < mNodes.size(); i++)
+    mTex2.data[i] = mNodes[i].pos + mTexOffset;
+}
+
+void VortexSheetMesh::reinitTexCoords()
+{
+  resetTex1();
+  resetTex2();
+}
+
+};  // namespace Manta
diff --git a/extern/mantaflow/preprocessed/vortexsheet.h b/extern/mantaflow/preprocessed/vortexsheet.h
new file mode 100644
index 00000000000..1fd53784f48
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexsheet.h
@@ -0,0 +1,251 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Vortex sheets
+ * (warning, the vortex methods are currently experimental, and not fully supported!)
+ *
+ ******************************************************************************/
+
+#ifndef _VORTEXSHEET_H
+#define _VORTEXSHEET_H
+
+#include "mesh.h"
+
+namespace Manta {
+
+//! Stores vortex sheet info
+struct VortexSheetInfo {
+  VortexSheetInfo()
+      : vorticity(0.0),
+        vorticitySmoothed(0.0),
+        circulation(0.0),
+        smokeAmount(1.0),
+        smokeParticles(0.0)
+  {
+  }
+
+  Vec3 vorticity;
+  Vec3 vorticitySmoothed;
+  Vec3 circulation;
+  Real smokeAmount, smokeParticles;
+};
+
+//! Manages vortex sheet info
+struct VorticityChannel : public SimpleTriChannel<VortexSheetInfo> {
+  virtual TriChannel *clone()
+  {
+    VorticityChannel *vc = new VorticityChannel();
+    *vc = *this;
+    return vc;
+  }
+};
+
+//! Manages 3D texture coordinates
+struct TexCoord3Channel : public SimpleNodeChannel<Vec3> {
+  virtual NodeChannel *clone()
+  {
+    TexCoord3Channel *tc = new TexCoord3Channel();
+    *tc = *this;
+    return tc;
+  }
+
+  void addInterpol(int a, int b, Real alpha)
+  {
+    data.push_back((1.0 - alpha) * data[a] + alpha * data[b]);
+  }
+  void mergeWith(int node, int delnode, Real alpha)
+  {
+    data[node] = 0.5 * (data[node] + data[delnode]);
+  }
+};
+
+struct TurbulenceInfo {
+  TurbulenceInfo() : k(0.0), epsilon(0.0)
+  {
+  }
+  TurbulenceInfo(const TurbulenceInfo &a, const TurbulenceInfo &b, Real alpha)
+      : k((1.0 - alpha) * a.k + alpha * b.k),
+        epsilon((1.0 - alpha) * a.epsilon + alpha * b.epsilon)
+  {
+  }
+  Real k, epsilon;
+};
+
+//! Manages k-epsilon information
+struct TurbulenceChannel : public SimpleNodeChannel<TurbulenceInfo> {
+  virtual NodeChannel *clone()
+  {
+    TurbulenceChannel *tc = new TurbulenceChannel();
+    *tc = *this;
+    return tc;
+  }
+
+  void addInterpol(int a, int b, Real alpha)
+  {
+    data.push_back(TurbulenceInfo(data[a], data[b], alpha));
+  }
+  void mergeWith(int node, int delnode, Real alpha)
+  {
+    data[node] = TurbulenceInfo(data[node], data[delnode], 0.5);
+  }
+};
+
+//! Typed Mesh with a vorticity and 2 texcoord3 channels
+class VortexSheetMesh : public Mesh {
+ public:
+  VortexSheetMesh(FluidSolver *parent);
+  static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    PbClass *obj = Pb::objFromPy(_self);
+    if (obj)
+      delete obj;
+    try {
+      PbArgs _args(_linargs, _kwds);
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(0, "VortexSheetMesh::VortexSheetMesh", !noTiming);
+      {
+        ArgLocker _lock;
+        FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+        obj = new VortexSheetMesh(parent);
+        obj->registerObject(_self, &_args);
+        _args.check();
+      }
+      pbFinalizePlugin(obj->getParent(), "VortexSheetMesh::VortexSheetMesh", !noTiming);
+      return 0;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexSheetMesh::VortexSheetMesh", e.what());
+      return -1;
+    }
+  }
+
+  virtual Mesh *clone();
+
+  virtual MeshType getType()
+  {
+    return TypeVortexSheet;
+  }
+
+  inline VortexSheetInfo &sheet(int i)
+  {
+    return mVorticity.data[i];
+  };
+  inline Vec3 &tex1(int i)
+  {
+    return mTex1.data[i];
+  }
+  inline Vec3 &tex2(int i)
+  {
+    return mTex2.data[i];
+  }
+  inline TurbulenceInfo &turb(int i)
+  {
+    return mTurb.data[i];
+  }
+  void setReferenceTexOffset(const Vec3 &ref)
+  {
+    mTexOffset = ref;
+  }
+  void resetTex1();
+  void resetTex2();
+
+  void calcCirculation();
+  static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcCirculation", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->calcCirculation();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexSheetMesh::calcCirculation", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexSheetMesh::calcCirculation", e.what());
+      return 0;
+    }
+  }
+
+  void calcVorticity();
+  static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcVorticity", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->calcVorticity();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexSheetMesh::calcVorticity", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexSheetMesh::calcVorticity", e.what());
+      return 0;
+    }
+  }
+
+  void reinitTexCoords();
+  static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+  {
+    try {
+      PbArgs _args(_linargs, _kwds);
+      VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
+      bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+      pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::reinitTexCoords", !noTiming);
+      PyObject *_retval = 0;
+      {
+        ArgLocker _lock;
+        pbo->_args.copy(_args);
+        _retval = getPyNone();
+        pbo->reinitTexCoords();
+        pbo->_args.check();
+      }
+      pbFinalizePlugin(pbo->getParent(), "VortexSheetMesh::reinitTexCoords", !noTiming);
+      return _retval;
+    }
+    catch (std::exception &e) {
+      pbSetError("VortexSheetMesh::reinitTexCoords", e.what());
+      return 0;
+    }
+  }
+
+ protected:
+  Vec3 mTexOffset;
+  VorticityChannel mVorticity;
+  TexCoord3Channel mTex1, mTex2;
+  TurbulenceChannel mTurb;
+ public:
+  PbArgs _args;
+}
+#define _C_VortexSheetMesh
+;
+
+};  // namespace Manta
+
+#endif
diff --git a/extern/mantaflow/preprocessed/vortexsheet.h.reg.cpp b/extern/mantaflow/preprocessed/vortexsheet.h.reg.cpp
new file mode 100644
index 00000000000..c86f530f771
--- /dev/null
+++ b/extern/mantaflow/preprocessed/vortexsheet.h.reg.cpp
@@ -0,0 +1,26 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep link).
+
+#include "vortexsheet.h"
+namespace Manta {
+#ifdef _C_VortexSheetMesh
+static const Pb::Register _R_14("VortexSheetMesh", "VortexSheetMesh", "Mesh");
+template<> const char *Namify<VortexSheetMesh>::S = "VortexSheetMesh";
+static const Pb::Register _R_15("VortexSheetMesh", "VortexSheetMesh", VortexSheetMesh::_W_0);
+static const Pb::Register _R_16("VortexSheetMesh", "calcCirculation", VortexSheetMesh::_W_1);
+static const Pb::Register _R_17("VortexSheetMesh", "calcVorticity", VortexSheetMesh::_W_2);
+static const Pb::Register _R_18("VortexSheetMesh", "reinitTexCoords", VortexSheetMesh::_W_3);
+#endif
+extern "C" {
+void PbRegister_file_14()
+{
+  KEEP_UNUSED(_R_14);
+  KEEP_UNUSED(_R_15);
+  KEEP_UNUSED(_R_16);
+  KEEP_UNUSED(_R_17);
+  KEEP_UNUSED(_R_18);
+}
+}
+}  // namespace Manta
\ No newline at end of file