Cleanup: Fluid renaming from old 'manta' naming to new 'fluid' naming

Changed variable names from mmd, mds, mfs, and mes to fmd, fds, ffs, and fes. The author of this commits lights a candle for all the merge conflicts this will cause.

4 files changed, 542 insertions, 542 deletions

diff --git a/intern/mantaflow/extern/manta_fluid_API.h b/intern/mantaflow/extern/manta_fluid_API.h
index d78aa6732b1..1dbfc6bdd9c 100644
--- a/intern/mantaflow/extern/manta_fluid_API.h
+++ b/intern/mantaflow/extern/manta_fluid_API.h
@@ -31,52 +31,52 @@ extern "C" {
 struct MANTA;
 
 /* Fluid functions */
-struct MANTA *manta_init(int *res, struct FluidModifierData *mmd);
+struct MANTA *manta_init(int *res, struct FluidModifierData *fmd);
 void manta_free(struct MANTA *fluid);
-void manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *mmd);
-void manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *mmd);
-void manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *mmd);
-void manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *mmd);
-int manta_write_config(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_write_data(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_write_noise(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_read_config(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
+void manta_ensure_obstacle(struct MANTA *fluid, struct FluidModifierData *fmd);
+void manta_ensure_guiding(struct MANTA *fluid, struct FluidModifierData *fmd);
+void manta_ensure_invelocity(struct MANTA *fluid, struct FluidModifierData *fmd);
+void manta_ensure_outflow(struct MANTA *fluid, struct FluidModifierData *fmd);
+int manta_write_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_write_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_write_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_read_config(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
 int manta_read_data(struct MANTA *fluid,
-                    struct FluidModifierData *mmd,
+                    struct FluidModifierData *fmd,
                     int framenr,
                     bool resumable);
 int manta_read_noise(struct MANTA *fluid,
-                     struct FluidModifierData *mmd,
+                     struct FluidModifierData *fmd,
                      int framenr,
                      bool resumable);
-int manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
+int manta_read_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
 int manta_read_particles(struct MANTA *fluid,
-                         struct FluidModifierData *mmd,
+                         struct FluidModifierData *fmd,
                          int framenr,
                          bool resumable);
 int manta_read_guiding(struct MANTA *fluid,
-                       struct FluidModifierData *mmd,
+                       struct FluidModifierData *fmd,
                        int framenr,
                        bool sourceDomain);
-int manta_bake_data(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_has_data(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_has_noise(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
-int manta_has_particles(struct MANTA *fluid, struct FluidModifierData *mmd, int framenr);
+int manta_bake_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_bake_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_bake_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_bake_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_bake_guiding(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_has_data(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_has_noise(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_has_mesh(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
+int manta_has_particles(struct MANTA *fluid, struct FluidModifierData *fmd, int framenr);
 int manta_has_guiding(struct MANTA *fluid,
-                      struct FluidModifierData *mmd,
+                      struct FluidModifierData *fmd,
                       int framenr,
                       bool domain);
 
-void manta_update_variables(struct MANTA *fluid, struct FluidModifierData *mmd);
+void manta_update_variables(struct MANTA *fluid, struct FluidModifierData *fmd);
 int manta_get_frame(struct MANTA *fluid);
 float manta_get_timestep(struct MANTA *fluid);
 void manta_adapt_timestep(struct MANTA *fluid);
-bool manta_needs_realloc(struct MANTA *fluid, struct FluidModifierData *mmd);
+bool manta_needs_realloc(struct MANTA *fluid, struct FluidModifierData *fmd);
 
 /* Fluid accessors */
 size_t manta_get_index(int x, int max_x, int y, int max_y, int z /*, int max_z */);
@@ -110,7 +110,7 @@ float *manta_get_phiout_in(struct MANTA *fluid);
 float *manta_get_phioutstatic_in(struct MANTA *fluid);
 
 /* Smoke functions */
-void manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *mmd);
+void manta_smoke_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
 void manta_smoke_export(struct MANTA *smoke,
                         float *dt,
                         float *dx,
@@ -151,9 +151,9 @@ void manta_smoke_turbulence_get_rgba_fixed_color(struct MANTA *smoke,
                                                  float color[3],
                                                  float *data,
                                                  int sequential);
-void manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *mmd);
-void manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *mmd);
-void manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *mmd);
+void manta_smoke_ensure_heat(struct MANTA *smoke, struct FluidModifierData *fmd);
+void manta_smoke_ensure_fire(struct MANTA *smoke, struct FluidModifierData *fmd);
+void manta_smoke_ensure_colors(struct MANTA *smoke, struct FluidModifierData *fmd);
 
 /* Smoke accessors */
 float *manta_smoke_get_density(struct MANTA *smoke);
@@ -190,8 +190,8 @@ void manta_smoke_turbulence_get_res(struct MANTA *smoke, int *res);
 int manta_smoke_turbulence_get_cells(struct MANTA *smoke);
 
 /* Liquid functions */
-void manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *mmd);
-void manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *mmd);
+void manta_liquid_export_script(struct MANTA *smoke, struct FluidModifierData *fmd);
+void manta_liquid_ensure_sndparts(struct MANTA *fluid, struct FluidModifierData *fmd);
 
 /* Liquid accessors */
 int manta_liquid_get_particle_res_x(struct MANTA *liquid);
diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp
index a008100a3e2..43121f08f2d 100644
--- a/intern/mantaflow/intern/MANTA_main.cpp
+++ b/intern/mantaflow/intern/MANTA_main.cpp
@@ -67,34 +67,34 @@ int MANTA::with_debug(0);
 /* Number of mesh triangles that the cache reads at once (with zlib). */
 #define TRIANGLE_CHUNK 20000
 
-MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
+MANTA::MANTA(int *res, FluidModifierData *fmd) : mCurrentID(++solverID)
 {
   if (with_debug)
     cout << "FLUID: " << mCurrentID << " with res(" << res[0] << ", " << res[1] << ", " << res[2]
          << ")" << endl;
 
-  FluidDomainSettings *mds = mmd->domain;
-  mds->fluid = this;
-
-  mUsingLiquid = (mds->type == FLUID_DOMAIN_TYPE_LIQUID);
-  mUsingSmoke = (mds->type == FLUID_DOMAIN_TYPE_GAS);
-  mUsingNoise = (mds->flags & FLUID_DOMAIN_USE_NOISE) && mUsingSmoke;
-  mUsingFractions = (mds->flags & FLUID_DOMAIN_USE_FRACTIONS) && mUsingLiquid;
-  mUsingMesh = (mds->flags & FLUID_DOMAIN_USE_MESH) && mUsingLiquid;
-  mUsingDiffusion = (mds->flags & FLUID_DOMAIN_USE_DIFFUSION) && mUsingLiquid;
-  mUsingMVel = (mds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) && mUsingLiquid;
-  mUsingGuiding = (mds->flags & FLUID_DOMAIN_USE_GUIDE);
-  mUsingDrops = (mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && mUsingLiquid;
-  mUsingBubbles = (mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && mUsingLiquid;
-  mUsingFloats = (mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && mUsingLiquid;
-  mUsingTracers = (mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) && mUsingLiquid;
-
-  mUsingHeat = (mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) && mUsingSmoke;
-  mUsingFire = (mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) && mUsingSmoke;
-  mUsingColors = (mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) && mUsingSmoke;
-  mUsingObstacle = (mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE);
-  mUsingInvel = (mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL);
-  mUsingOutflow = (mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW);
+  FluidDomainSettings *fds = fmd->domain;
+  fds->fluid = this;
+
+  mUsingLiquid = (fds->type == FLUID_DOMAIN_TYPE_LIQUID);
+  mUsingSmoke = (fds->type == FLUID_DOMAIN_TYPE_GAS);
+  mUsingNoise = (fds->flags & FLUID_DOMAIN_USE_NOISE) && mUsingSmoke;
+  mUsingFractions = (fds->flags & FLUID_DOMAIN_USE_FRACTIONS) && mUsingLiquid;
+  mUsingMesh = (fds->flags & FLUID_DOMAIN_USE_MESH) && mUsingLiquid;
+  mUsingDiffusion = (fds->flags & FLUID_DOMAIN_USE_DIFFUSION) && mUsingLiquid;
+  mUsingMVel = (fds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) && mUsingLiquid;
+  mUsingGuiding = (fds->flags & FLUID_DOMAIN_USE_GUIDE);
+  mUsingDrops = (fds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY) && mUsingLiquid;
+  mUsingBubbles = (fds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) && mUsingLiquid;
+  mUsingFloats = (fds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) && mUsingLiquid;
+  mUsingTracers = (fds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) && mUsingLiquid;
+
+  mUsingHeat = (fds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) && mUsingSmoke;
+  mUsingFire = (fds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) && mUsingSmoke;
+  mUsingColors = (fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) && mUsingSmoke;
+  mUsingObstacle = (fds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE);
+  mUsingInvel = (fds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL);
+  mUsingOutflow = (fds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW);
 
   // Simulation constants
   mTempAmb = 0;  // TODO: Maybe use this later for buoyancy calculation
@@ -103,7 +103,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
   mResZ = res[2];
   mMaxRes = MAX3(mResX, mResY, mResZ);
   mTotalCells = mResX * mResY * mResZ;
-  mResGuiding = mds->res;
+  mResGuiding = fds->res;
 
   // Smoke low res grids
   mDensity = nullptr;
@@ -194,7 +194,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
   initializeMantaflow();
 
   // Initializa RNA map with values that Python will need
-  initializeRNAMap(mmd);
+  initializeRNAMap(fmd);
 
   // Initialize Mantaflow variables in Python
   // Liquid
@@ -209,7 +209,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
       initOutflow();
 
     if (mUsingDrops || mUsingBubbles || mUsingFloats || mUsingTracers) {
-      mUpresParticle = mds->particle_scale;
+      mUpresParticle = fds->particle_scale;
       mResXParticle = mUpresParticle * mResX;
       mResYParticle = mUpresParticle * mResY;
       mResZParticle = mUpresParticle * mResZ;
@@ -220,7 +220,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
     }
 
     if (mUsingMesh) {
-      mUpresMesh = mds->mesh_scale;
+      mUpresMesh = fds->mesh_scale;
       mResXMesh = mUpresMesh * mResX;
       mResYMesh = mUpresMesh * mResY;
       mResZMesh = mUpresMesh * mResZ;
@@ -236,7 +236,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
     }
 
     if (mUsingGuiding) {
-      mResGuiding = (mds->guide_parent) ? mds->guide_res : mds->res;
+      mResGuiding = (fds->guide_parent) ? fds->guide_res : fds->res;
       initGuiding();
     }
     if (mUsingFractions) {
@@ -262,12 +262,12 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
       initOutflow();
 
     if (mUsingGuiding) {
-      mResGuiding = (mds->guide_parent) ? mds->guide_res : mds->res;
+      mResGuiding = (fds->guide_parent) ? fds->guide_res : fds->res;
       initGuiding();
     }
 
     if (mUsingNoise) {
-      int amplify = mds->noise_scale;
+      int amplify = fds->noise_scale;
       mResXNoise = amplify * mResX;
       mResYNoise = amplify * mResY;
       mResZNoise = amplify * mResZ;
@@ -285,7 +285,7 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
   updatePointers();
 }
 
-void MANTA::initDomain(FluidModifierData *mmd)
+void MANTA::initDomain(FluidModifierData *fmd)
 {
   // Vector will hold all python commands that are to be executed
   vector<string> pythonCommands;
@@ -303,50 +303,50 @@ void MANTA::initDomain(FluidModifierData *mmd)
                      fluid_bake_mesh + fluid_bake_particles + fluid_bake_guiding +
                      fluid_file_import + fluid_file_export + fluid_pre_step + fluid_post_step +
                      fluid_adapt_time_step + fluid_time_stepping;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
   runPythonString(pythonCommands);
 }
 
-void MANTA::initNoise(FluidModifierData *mmd)
+void MANTA::initNoise(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_variables_noise + fluid_solver_noise;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
 }
 
-void MANTA::initSmoke(FluidModifierData *mmd)
+void MANTA::initSmoke(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = smoke_variables + smoke_alloc + smoke_adaptive_step + smoke_save_data +
                      smoke_load_data + smoke_step;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
 }
 
-void MANTA::initSmokeNoise(FluidModifierData *mmd)
+void MANTA::initSmokeNoise(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = smoke_variables_noise + smoke_alloc_noise + smoke_wavelet_noise +
                      smoke_save_noise + smoke_load_noise + smoke_step_noise;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
   mUsingNoise = true;
 }
 
-void MANTA::initHeat(FluidModifierData *mmd)
+void MANTA::initHeat(FluidModifierData *fmd)
 {
   if (!mHeat) {
     vector<string> pythonCommands;
     string tmpString = smoke_alloc_heat + smoke_with_heat;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -354,12 +354,12 @@ void MANTA::initHeat(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initFire(FluidModifierData *mmd)
+void MANTA::initFire(FluidModifierData *fmd)
 {
   if (!mFuel) {
     vector<string> pythonCommands;
     string tmpString = smoke_alloc_fire + smoke_with_fire;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -367,12 +367,12 @@ void MANTA::initFire(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initFireHigh(FluidModifierData *mmd)
+void MANTA::initFireHigh(FluidModifierData *fmd)
 {
   if (!mFuelHigh) {
     vector<string> pythonCommands;
     string tmpString = smoke_alloc_fire_noise + smoke_with_fire;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -380,12 +380,12 @@ void MANTA::initFireHigh(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initColors(FluidModifierData *mmd)
+void MANTA::initColors(FluidModifierData *fmd)
 {
   if (!mColorR) {
     vector<string> pythonCommands;
     string tmpString = smoke_alloc_colors + smoke_init_colors + smoke_with_colors;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -393,12 +393,12 @@ void MANTA::initColors(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initColorsHigh(FluidModifierData *mmd)
+void MANTA::initColorsHigh(FluidModifierData *fmd)
 {
   if (!mColorRHigh) {
     vector<string> pythonCommands;
     string tmpString = smoke_alloc_colors_noise + smoke_init_colors_noise + smoke_with_colors;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -406,13 +406,13 @@ void MANTA::initColorsHigh(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initLiquid(FluidModifierData *mmd)
+void MANTA::initLiquid(FluidModifierData *fmd)
 {
   if (!mPhiIn) {
     vector<string> pythonCommands;
     string tmpString = liquid_variables + liquid_alloc + liquid_init_phi + liquid_save_data +
                        liquid_load_data + liquid_adaptive_step + liquid_step;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -420,44 +420,44 @@ void MANTA::initLiquid(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initMesh(FluidModifierData *mmd)
+void MANTA::initMesh(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_variables_mesh + fluid_solver_mesh + liquid_load_mesh;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
   mUsingMesh = true;
 }
 
-void MANTA::initLiquidMesh(FluidModifierData *mmd)
+void MANTA::initLiquidMesh(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = liquid_alloc_mesh + liquid_step_mesh + liquid_save_mesh;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
   mUsingMesh = true;
 }
 
-void MANTA::initCurvature(FluidModifierData *mmd)
+void MANTA::initCurvature(FluidModifierData *fmd)
 {
   std::vector<std::string> pythonCommands;
-  std::string finalString = parseScript(liquid_alloc_curvature, mmd);
+  std::string finalString = parseScript(liquid_alloc_curvature, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
   mUsingDiffusion = true;
 }
 
-void MANTA::initObstacle(FluidModifierData *mmd)
+void MANTA::initObstacle(FluidModifierData *fmd)
 {
   if (!mPhiObsIn) {
     vector<string> pythonCommands;
     string tmpString = fluid_alloc_obstacle + fluid_with_obstacle;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -465,13 +465,13 @@ void MANTA::initObstacle(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initGuiding(FluidModifierData *mmd)
+void MANTA::initGuiding(FluidModifierData *fmd)
 {
   if (!mPhiGuideIn) {
     vector<string> pythonCommands;
     string tmpString = fluid_variables_guiding + fluid_solver_guiding + fluid_alloc_guiding +
                        fluid_save_guiding + fluid_load_vel + fluid_load_guiding;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -479,23 +479,23 @@ void MANTA::initGuiding(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initFractions(FluidModifierData *mmd)
+void MANTA::initFractions(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_alloc_fractions + fluid_with_fractions;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
   mUsingFractions = true;
 }
 
-void MANTA::initInVelocity(FluidModifierData *mmd)
+void MANTA::initInVelocity(FluidModifierData *fmd)
 {
   if (!mInVelocityX) {
     vector<string> pythonCommands;
     string tmpString = fluid_alloc_invel + fluid_with_invel;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -503,12 +503,12 @@ void MANTA::initInVelocity(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initOutflow(FluidModifierData *mmd)
+void MANTA::initOutflow(FluidModifierData *fmd)
 {
   if (!mPhiOutIn) {
     vector<string> pythonCommands;
     string tmpString = fluid_alloc_outflow + fluid_with_outflow;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -516,24 +516,24 @@ void MANTA::initOutflow(FluidModifierData *mmd)
   }
 }
 
-void MANTA::initSndParts(FluidModifierData *mmd)
+void MANTA::initSndParts(FluidModifierData *fmd)
 {
   vector<string> pythonCommands;
   string tmpString = fluid_variables_particles + fluid_solver_particles;
-  string finalString = parseScript(tmpString, mmd);
+  string finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
 }
 
-void MANTA::initLiquidSndParts(FluidModifierData *mmd)
+void MANTA::initLiquidSndParts(FluidModifierData *fmd)
 {
   if (!mSndParticleData) {
     vector<string> pythonCommands;
     string tmpString = liquid_alloc_particles + liquid_variables_particles +
                        liquid_step_particles + fluid_with_sndparts + liquid_load_particles +
                        liquid_save_particles;
-    string finalString = parseScript(tmpString, mmd);
+    string finalString = parseScript(tmpString, fmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -557,7 +557,7 @@ MANTA::~MANTA()
   // Initializa RNA map with values that Python will need
   initializeRNAMap();
 
-  // Leave out mmd argument in parseScript since only looking up IDs
+  // Leave out fmd argument in parseScript since only looking up IDs
   string finalString = parseScript(tmpString);
   pythonCommands.push_back(finalString);
   result = runPythonString(pythonCommands);
@@ -664,56 +664,56 @@ static string getBooleanString(int value)
   return (value) ? "True" : "False";
 }
 
-void MANTA::initializeRNAMap(FluidModifierData *mmd)
+void MANTA::initializeRNAMap(FluidModifierData *fmd)
 {
   if (with_debug)
     cout << "MANTA::initializeRNAMap()" << endl;
 
   mRNAMap["ID"] = to_string(mCurrentID);
 
-  if (!mmd) {
+  if (!fmd) {
     if (with_debug)
       cout << "Fluid: No modifier data given in RNA map setup - returning early" << endl;
     return;
   }
 
-  FluidDomainSettings *mds = mmd->domain;
-  bool is2D = (mds->solver_res == 2);
+  FluidDomainSettings *fds = fmd->domain;
+  bool is2D = (fds->solver_res == 2);
 
   string borderCollisions = "";
-  if ((mds->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
+  if ((fds->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
     borderCollisions += "x";
-  if ((mds->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
+  if ((fds->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
     borderCollisions += "X";
-  if ((mds->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
+  if ((fds->border_collisions & FLUID_DOMAIN_BORDER_FRONT) == 0)
     borderCollisions += "y";
-  if ((mds->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
+  if ((fds->border_collisions & FLUID_DOMAIN_BORDER_BACK) == 0)
     borderCollisions += "Y";
-  if ((mds->border_collisions & FLUID_DOMAIN_BORDER_BOTTOM) == 0)
+  if ((fds->border_collisions & FLUID_DOMAIN_BORDER_BOTTOM) == 0)
     borderCollisions += "z";
-  if ((mds->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0)
+  if ((fds->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0)
     borderCollisions += "Z";
 
   string simulationMethod = "";
-  if (mds->simulation_method & FLUID_DOMAIN_METHOD_FLIP)
+  if (fds->simulation_method & FLUID_DOMAIN_METHOD_FLIP)
     simulationMethod += "'FLIP'";
-  else if (mds->simulation_method & FLUID_DOMAIN_METHOD_APIC)
+  else if (fds->simulation_method & FLUID_DOMAIN_METHOD_APIC)
     simulationMethod += "'APIC'";
 
   string particleTypesStr = "";
-  if (mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY)
+  if (fds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY)
     particleTypesStr += "PtypeSpray";
-  if (mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) {
+  if (fds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) {
     if (!particleTypesStr.empty())
       particleTypesStr += "|";
     particleTypesStr += "PtypeBubble";
   }
-  if (mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) {
+  if (fds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM) {
     if (!particleTypesStr.empty())
       particleTypesStr += "|";
     particleTypesStr += "PtypeFoam";
   }
-  if (mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) {
+  if (fds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER) {
     if (!particleTypesStr.empty())
       particleTypesStr += "|";
     particleTypesStr += "PtypeTracer";
@@ -724,73 +724,73 @@ void MANTA::initializeRNAMap(FluidModifierData *mmd)
   int particleTypes = (FLUID_DOMAIN_PARTICLE_SPRAY | FLUID_DOMAIN_PARTICLE_BUBBLE |
                        FLUID_DOMAIN_PARTICLE_FOAM | FLUID_DOMAIN_PARTICLE_TRACER);
 
-  string cacheDirectory(mds->cache_directory);
+  string cacheDirectory(fds->cache_directory);
 
-  float viscosity = mds->viscosity_base * pow(10.0f, -mds->viscosity_exponent);
-  float domainSize = MAX3(mds->global_size[0], mds->global_size[1], mds->global_size[2]);
+  float viscosity = fds->viscosity_base * pow(10.0f, -fds->viscosity_exponent);
+  float domainSize = MAX3(fds->global_size[0], fds->global_size[1], fds->global_size[2]);
 
   string vdbCompressionMethod = "Compression_None";
-  if (mds->openvdb_compression == VDB_COMPRESSION_NONE)
+  if (fds->openvdb_compression == VDB_COMPRESSION_NONE)
     vdbCompressionMethod = "Compression_None";
-  else if (mds->openvdb_compression == VDB_COMPRESSION_ZIP)
+  else if (fds->openvdb_compression == VDB_COMPRESSION_ZIP)
     vdbCompressionMethod = "Compression_Zip";
-  else if (mds->openvdb_compression == VDB_COMPRESSION_BLOSC)
+  else if (fds->openvdb_compression == VDB_COMPRESSION_BLOSC)
     vdbCompressionMethod = "Compression_Blosc";
 
   string vdbPrecisionHalf = "True";
-  if (mds->openvdb_data_depth == VDB_PRECISION_HALF_FLOAT)
+  if (fds->openvdb_data_depth == VDB_PRECISION_HALF_FLOAT)
     vdbPrecisionHalf = "True";
-  else if (mds->openvdb_data_depth == VDB_PRECISION_FULL_FLOAT)
+  else if (fds->openvdb_data_depth == VDB_PRECISION_FULL_FLOAT)
     vdbPrecisionHalf = "False";
 
-  mRNAMap["USING_SMOKE"] = getBooleanString(mds->type == FLUID_DOMAIN_TYPE_GAS);
-  mRNAMap["USING_LIQUID"] = getBooleanString(mds->type == FLUID_DOMAIN_TYPE_LIQUID);
-  mRNAMap["USING_COLORS"] = getBooleanString(mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS);
-  mRNAMap["USING_HEAT"] = getBooleanString(mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT);
-  mRNAMap["USING_FIRE"] = getBooleanString(mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE);
-  mRNAMap["USING_NOISE"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_NOISE);
-  mRNAMap["USING_OBSTACLE"] = getBooleanString(mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE);
-  mRNAMap["USING_GUIDING"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_GUIDE);
-  mRNAMap["USING_INVEL"] = getBooleanString(mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL);
-  mRNAMap["USING_OUTFLOW"] = getBooleanString(mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW);
-  mRNAMap["USING_LOG_DISSOLVE"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG);
-  mRNAMap["USING_DISSOLVE"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_DISSOLVE);
+  mRNAMap["USING_SMOKE"] = getBooleanString(fds->type == FLUID_DOMAIN_TYPE_GAS);
+  mRNAMap["USING_LIQUID"] = getBooleanString(fds->type == FLUID_DOMAIN_TYPE_LIQUID);
+  mRNAMap["USING_COLORS"] = getBooleanString(fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS);
+  mRNAMap["USING_HEAT"] = getBooleanString(fds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT);
+  mRNAMap["USING_FIRE"] = getBooleanString(fds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE);
+  mRNAMap["USING_NOISE"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_NOISE);
+  mRNAMap["USING_OBSTACLE"] = getBooleanString(fds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE);
+  mRNAMap["USING_GUIDING"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_GUIDE);
+  mRNAMap["USING_INVEL"] = getBooleanString(fds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL);
+  mRNAMap["USING_OUTFLOW"] = getBooleanString(fds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW);
+  mRNAMap["USING_LOG_DISSOLVE"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG);
+  mRNAMap["USING_DISSOLVE"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_DISSOLVE);
   mRNAMap["DOMAIN_CLOSED"] = getBooleanString(borderCollisions.compare("") == 0);
-  mRNAMap["CACHE_RESUMABLE"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE);
-  mRNAMap["USING_ADAPTIVETIME"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME);
-  mRNAMap["USING_SPEEDVECTORS"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS);
-  mRNAMap["USING_FRACTIONS"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_FRACTIONS);
-  mRNAMap["DELETE_IN_OBSTACLE"] = getBooleanString(mds->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE);
-  mRNAMap["USING_DIFFUSION"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_DIFFUSION);
-  mRNAMap["USING_MESH"] = getBooleanString(mds->flags & FLUID_DOMAIN_USE_MESH);
-  mRNAMap["USING_IMPROVED_MESH"] = getBooleanString(mds->mesh_generator ==
+  mRNAMap["CACHE_RESUMABLE"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE);
+  mRNAMap["USING_ADAPTIVETIME"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME);
+  mRNAMap["USING_SPEEDVECTORS"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS);
+  mRNAMap["USING_FRACTIONS"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_FRACTIONS);
+  mRNAMap["DELETE_IN_OBSTACLE"] = getBooleanString(fds->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE);
+  mRNAMap["USING_DIFFUSION"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_DIFFUSION);
+  mRNAMap["USING_MESH"] = getBooleanString(fds->flags & FLUID_DOMAIN_USE_MESH);
+  mRNAMap["USING_IMPROVED_MESH"] = getBooleanString(fds->mesh_generator ==
                                                     FLUID_DOMAIN_MESH_IMPROVED);
-  mRNAMap["USING_SNDPARTS"] = getBooleanString(mds->particle_type & particleTypes);
-  mRNAMap["SNDPARTICLE_BOUNDARY_DELETE"] = getBooleanString(mds->sndparticle_boundary ==
+  mRNAMap["USING_SNDPARTS"] = getBooleanString(fds->particle_type & particleTypes);
+  mRNAMap["SNDPARTICLE_BOUNDARY_DELETE"] = getBooleanString(fds->sndparticle_boundary ==
                                                             SNDPARTICLE_BOUNDARY_DELETE);
-  mRNAMap["SNDPARTICLE_BOUNDARY_PUSHOUT"] = getBooleanString(mds->sndparticle_boundary ==
+  mRNAMap["SNDPARTICLE_BOUNDARY_PUSHOUT"] = getBooleanString(fds->sndparticle_boundary ==
                                                              SNDPARTICLE_BOUNDARY_PUSHOUT);
 
-  mRNAMap["SOLVER_DIM"] = to_string(mds->solver_res);
+  mRNAMap["SOLVER_DIM"] = to_string(fds->solver_res);
   mRNAMap["BOUND_CONDITIONS"] = borderCollisions;
-  mRNAMap["BOUNDARY_WIDTH"] = to_string(mds->boundary_width);
+  mRNAMap["BOUNDARY_WIDTH"] = to_string(fds->boundary_width);
   mRNAMap["RES"] = to_string(mMaxRes);
   mRNAMap["RESX"] = to_string(mResX);
   mRNAMap["RESY"] = (is2D) ? to_string(mResZ) : to_string(mResY);
   mRNAMap["RESZ"] = (is2D) ? to_string(1) : to_string(mResZ);
-  mRNAMap["TIME_SCALE"] = to_string(mds->time_scale);
-  mRNAMap["FRAME_LENGTH"] = to_string(mds->frame_length);
-  mRNAMap["CFL"] = to_string(mds->cfl_condition);
-  mRNAMap["DT"] = to_string(mds->dt);
-  mRNAMap["TIMESTEPS_MIN"] = to_string(mds->timesteps_minimum);
-  mRNAMap["TIMESTEPS_MAX"] = to_string(mds->timesteps_maximum);
-  mRNAMap["TIME_TOTAL"] = to_string(mds->time_total);
-  mRNAMap["TIME_PER_FRAME"] = to_string(mds->time_per_frame);
-  mRNAMap["VORTICITY"] = to_string(mds->vorticity);
-  mRNAMap["FLAME_VORTICITY"] = to_string(mds->flame_vorticity);
-  mRNAMap["NOISE_SCALE"] = to_string(mds->noise_scale);
-  mRNAMap["MESH_SCALE"] = to_string(mds->mesh_scale);
-  mRNAMap["PARTICLE_SCALE"] = to_string(mds->particle_scale);
+  mRNAMap["TIME_SCALE"] = to_string(fds->time_scale);
+  mRNAMap["FRAME_LENGTH"] = to_string(fds->frame_length);
+  mRNAMap["CFL"] = to_string(fds->cfl_condition);
+  mRNAMap["DT"] = to_string(fds->dt);
+  mRNAMap["TIMESTEPS_MIN"] = to_string(fds->timesteps_minimum);
+  mRNAMap["TIMESTEPS_MAX"] = to_string(fds->timesteps_maximum);
+  mRNAMap["TIME_TOTAL"] = to_string(fds->time_total);
+  mRNAMap["TIME_PER_FRAME"] = to_string(fds->time_per_frame);
+  mRNAMap["VORTICITY"] = to_string(fds->vorticity);
+  mRNAMap["FLAME_VORTICITY"] = to_string(fds->flame_vorticity);
+  mRNAMap["NOISE_SCALE"] = to_string(fds->noise_scale);
+  mRNAMap["MESH_SCALE"] = to_string(fds->mesh_scale);
+  mRNAMap["PARTICLE_SCALE"] = to_string(fds->particle_scale);
   mRNAMap["NOISE_RESX"] = to_string(mResXNoise);
   mRNAMap["NOISE_RESY"] = (is2D) ? to_string(mResZNoise) : to_string(mResYNoise);
   mRNAMap["NOISE_RESZ"] = (is2D) ? to_string(1) : to_string(mResZNoise);
@@ -803,76 +803,76 @@ void MANTA::initializeRNAMap(FluidModifierData *mmd)
   mRNAMap["GUIDING_RESX"] = to_string(mResGuiding[0]);
   mRNAMap["GUIDING_RESY"] = (is2D) ? to_string(mResGuiding[2]) : to_string(mResGuiding[1]);
   mRNAMap["GUIDING_RESZ"] = (is2D) ? to_string(1) : to_string(mResGuiding[2]);
-  mRNAMap["MIN_RESX"] = to_string(mds->res_min[0]);
-  mRNAMap["MIN_RESY"] = to_string(mds->res_min[1]);
-  mRNAMap["MIN_RESZ"] = to_string(mds->res_min[2]);
-  mRNAMap["BASE_RESX"] = to_string(mds->base_res[0]);
-  mRNAMap["BASE_RESY"] = to_string(mds->base_res[1]);
-  mRNAMap["BASE_RESZ"] = to_string(mds->base_res[2]);
-  mRNAMap["WLT_STR"] = to_string(mds->noise_strength);
-  mRNAMap["NOISE_POSSCALE"] = to_string(mds->noise_pos_scale);
-  mRNAMap["NOISE_TIMEANIM"] = to_string(mds->noise_time_anim);
-  mRNAMap["COLOR_R"] = to_string(mds->active_color[0]);
-  mRNAMap["COLOR_G"] = to_string(mds->active_color[1]);
-  mRNAMap["COLOR_B"] = to_string(mds->active_color[2]);
-  mRNAMap["BUOYANCY_ALPHA"] = to_string(mds->alpha);
-  mRNAMap["BUOYANCY_BETA"] = to_string(mds->beta);
-  mRNAMap["DISSOLVE_SPEED"] = to_string(mds->diss_speed);
-  mRNAMap["BURNING_RATE"] = to_string(mds->burning_rate);
-  mRNAMap["FLAME_SMOKE"] = to_string(mds->flame_smoke);
-  mRNAMap["IGNITION_TEMP"] = to_string(mds->flame_ignition);
-  mRNAMap["MAX_TEMP"] = to_string(mds->flame_max_temp);
-  mRNAMap["FLAME_SMOKE_COLOR_X"] = to_string(mds->flame_smoke_color[0]);
-  mRNAMap["FLAME_SMOKE_COLOR_Y"] = to_string(mds->flame_smoke_color[1]);
-  mRNAMap["FLAME_SMOKE_COLOR_Z"] = to_string(mds->flame_smoke_color[2]);
-  mRNAMap["CURRENT_FRAME"] = to_string(int(mmd->time));
-  mRNAMap["START_FRAME"] = to_string(mds->cache_frame_start);
-  mRNAMap["END_FRAME"] = to_string(mds->cache_frame_end);
-  mRNAMap["CACHE_DATA_FORMAT"] = getCacheFileEnding(mds->cache_data_format);
-  mRNAMap["CACHE_MESH_FORMAT"] = getCacheFileEnding(mds->cache_mesh_format);
-  mRNAMap["CACHE_NOISE_FORMAT"] = getCacheFileEnding(mds->cache_noise_format);
-  mRNAMap["CACHE_PARTICLE_FORMAT"] = getCacheFileEnding(mds->cache_particle_format);
+  mRNAMap["MIN_RESX"] = to_string(fds->res_min[0]);
+  mRNAMap["MIN_RESY"] = to_string(fds->res_min[1]);
+  mRNAMap["MIN_RESZ"] = to_string(fds->res_min[2]);
+  mRNAMap["BASE_RESX"] = to_string(fds->base_res[0]);
+  mRNAMap["BASE_RESY"] = to_string(fds->base_res[1]);
+  mRNAMap["BASE_RESZ"] = to_string(fds->base_res[2]);
+  mRNAMap["WLT_STR"] = to_string(fds->noise_strength);
+  mRNAMap["NOISE_POSSCALE"] = to_string(fds->noise_pos_scale);
+  mRNAMap["NOISE_TIMEANIM"] = to_string(fds->noise_time_anim);
+  mRNAMap["COLOR_R"] = to_string(fds->active_color[0]);
+  mRNAMap["COLOR_G"] = to_string(fds->active_color[1]);
+  mRNAMap["COLOR_B"] = to_string(fds->active_color[2]);
+  mRNAMap["BUOYANCY_ALPHA"] = to_string(fds->alpha);
+  mRNAMap["BUOYANCY_BETA"] = to_string(fds->beta);
+  mRNAMap["DISSOLVE_SPEED"] = to_string(fds->diss_speed);
+  mRNAMap["BURNING_RATE"] = to_string(fds->burning_rate);
+  mRNAMap["FLAME_SMOKE"] = to_string(fds->flame_smoke);
+  mRNAMap["IGNITION_TEMP"] = to_string(fds->flame_ignition);
+  mRNAMap["MAX_TEMP"] = to_string(fds->flame_max_temp);
+  mRNAMap["FLAME_SMOKE_COLOR_X"] = to_string(fds->flame_smoke_color[0]);
+  mRNAMap["FLAME_SMOKE_COLOR_Y"] = to_string(fds->flame_smoke_color[1]);
+  mRNAMap["FLAME_SMOKE_COLOR_Z"] = to_string(fds->flame_smoke_color[2]);
+  mRNAMap["CURRENT_FRAME"] = to_string(int(fmd->time));
+  mRNAMap["START_FRAME"] = to_string(fds->cache_frame_start);
+  mRNAMap["END_FRAME"] = to_string(fds->cache_frame_end);
+  mRNAMap["CACHE_DATA_FORMAT"] = getCacheFileEnding(fds->cache_data_format);
+  mRNAMap["CACHE_MESH_FORMAT"] = getCacheFileEnding(fds->cache_mesh_format);
+  mRNAMap["CACHE_NOISE_FORMAT"] = getCacheFileEnding(fds->cache_noise_format);
+  mRNAMap["CACHE_PARTICLE_FORMAT"] = getCacheFileEnding(fds->cache_particle_format);
   mRNAMap["SIMULATION_METHOD"] = simulationMethod;
-  mRNAMap["FLIP_RATIO"] = to_string(mds->flip_ratio);
-  mRNAMap["PARTICLE_RANDOMNESS"] = to_string(mds->particle_randomness);
-  mRNAMap["PARTICLE_NUMBER"] = to_string(mds->particle_number);
-  mRNAMap["PARTICLE_MINIMUM"] = to_string(mds->particle_minimum);
-  mRNAMap["PARTICLE_MAXIMUM"] = to_string(mds->particle_maximum);
-  mRNAMap["PARTICLE_RADIUS"] = to_string(mds->particle_radius);
-  mRNAMap["FRACTIONS_THRESHOLD"] = to_string(mds->fractions_threshold);
-  mRNAMap["MESH_CONCAVE_UPPER"] = to_string(mds->mesh_concave_upper);
-  mRNAMap["MESH_CONCAVE_LOWER"] = to_string(mds->mesh_concave_lower);
-  mRNAMap["MESH_PARTICLE_RADIUS"] = to_string(mds->mesh_particle_radius);
-  mRNAMap["MESH_SMOOTHEN_POS"] = to_string(mds->mesh_smoothen_pos);
-  mRNAMap["MESH_SMOOTHEN_NEG"] = to_string(mds->mesh_smoothen_neg);
-  mRNAMap["PARTICLE_BAND_WIDTH"] = to_string(mds->particle_band_width);
-  mRNAMap["SNDPARTICLE_TAU_MIN_WC"] = to_string(mds->sndparticle_tau_min_wc);
-  mRNAMap["SNDPARTICLE_TAU_MAX_WC"] = to_string(mds->sndparticle_tau_max_wc);
-  mRNAMap["SNDPARTICLE_TAU_MIN_TA"] = to_string(mds->sndparticle_tau_min_ta);
-  mRNAMap["SNDPARTICLE_TAU_MAX_TA"] = to_string(mds->sndparticle_tau_max_ta);
-  mRNAMap["SNDPARTICLE_TAU_MIN_K"] = to_string(mds->sndparticle_tau_min_k);
-  mRNAMap["SNDPARTICLE_TAU_MAX_K"] = to_string(mds->sndparticle_tau_max_k);
-  mRNAMap["SNDPARTICLE_K_WC"] = to_string(mds->sndparticle_k_wc);
-  mRNAMap["SNDPARTICLE_K_TA"] = to_string(mds->sndparticle_k_ta);
-  mRNAMap["SNDPARTICLE_K_B"] = to_string(mds->sndparticle_k_b);
-  mRNAMap["SNDPARTICLE_K_D"] = to_string(mds->sndparticle_k_d);
-  mRNAMap["SNDPARTICLE_L_MIN"] = to_string(mds->sndparticle_l_min);
-  mRNAMap["SNDPARTICLE_L_MAX"] = to_string(mds->sndparticle_l_max);
-  mRNAMap["SNDPARTICLE_POTENTIAL_RADIUS"] = to_string(mds->sndparticle_potential_radius);
-  mRNAMap["SNDPARTICLE_UPDATE_RADIUS"] = to_string(mds->sndparticle_update_radius);
-  mRNAMap["LIQUID_SURFACE_TENSION"] = to_string(mds->surface_tension);
+  mRNAMap["FLIP_RATIO"] = to_string(fds->flip_ratio);
+  mRNAMap["PARTICLE_RANDOMNESS"] = to_string(fds->particle_randomness);
+  mRNAMap["PARTICLE_NUMBER"] = to_string(fds->particle_number);
+  mRNAMap["PARTICLE_MINIMUM"] = to_string(fds->particle_minimum);
+  mRNAMap["PARTICLE_MAXIMUM"] = to_string(fds->particle_maximum);
+  mRNAMap["PARTICLE_RADIUS"] = to_string(fds->particle_radius);
+  mRNAMap["FRACTIONS_THRESHOLD"] = to_string(fds->fractions_threshold);
+  mRNAMap["MESH_CONCAVE_UPPER"] = to_string(fds->mesh_concave_upper);
+  mRNAMap["MESH_CONCAVE_LOWER"] = to_string(fds->mesh_concave_lower);
+  mRNAMap["MESH_PARTICLE_RADIUS"] = to_string(fds->mesh_particle_radius);
+  mRNAMap["MESH_SMOOTHEN_POS"] = to_string(fds->mesh_smoothen_pos);
+  mRNAMap["MESH_SMOOTHEN_NEG"] = to_string(fds->mesh_smoothen_neg);
+  mRNAMap["PARTICLE_BAND_WIDTH"] = to_string(fds->particle_band_width);
+  mRNAMap["SNDPARTICLE_TAU_MIN_WC"] = to_string(fds->sndparticle_tau_min_wc);
+  mRNAMap["SNDPARTICLE_TAU_MAX_WC"] = to_string(fds->sndparticle_tau_max_wc);
+  mRNAMap["SNDPARTICLE_TAU_MIN_TA"] = to_string(fds->sndparticle_tau_min_ta);
+  mRNAMap["SNDPARTICLE_TAU_MAX_TA"] = to_string(fds->sndparticle_tau_max_ta);
+  mRNAMap["SNDPARTICLE_TAU_MIN_K"] = to_string(fds->sndparticle_tau_min_k);
+  mRNAMap["SNDPARTICLE_TAU_MAX_K"] = to_string(fds->sndparticle_tau_max_k);
+  mRNAMap["SNDPARTICLE_K_WC"] = to_string(fds->sndparticle_k_wc);
+  mRNAMap["SNDPARTICLE_K_TA"] = to_string(fds->sndparticle_k_ta);
+  mRNAMap["SNDPARTICLE_K_B"] = to_string(fds->sndparticle_k_b);
+  mRNAMap["SNDPARTICLE_K_D"] = to_string(fds->sndparticle_k_d);
+  mRNAMap["SNDPARTICLE_L_MIN"] = to_string(fds->sndparticle_l_min);
+  mRNAMap["SNDPARTICLE_L_MAX"] = to_string(fds->sndparticle_l_max);
+  mRNAMap["SNDPARTICLE_POTENTIAL_RADIUS"] = to_string(fds->sndparticle_potential_radius);
+  mRNAMap["SNDPARTICLE_UPDATE_RADIUS"] = to_string(fds->sndparticle_update_radius);
+  mRNAMap["LIQUID_SURFACE_TENSION"] = to_string(fds->surface_tension);
   mRNAMap["FLUID_VISCOSITY"] = to_string(viscosity);
   mRNAMap["FLUID_DOMAIN_SIZE"] = to_string(domainSize);
-  mRNAMap["FLUID_DOMAIN_SIZE_X"] = to_string(mds->global_size[0]);
-  mRNAMap["FLUID_DOMAIN_SIZE_Y"] = to_string(mds->global_size[1]);
-  mRNAMap["FLUID_DOMAIN_SIZE_Z"] = to_string(mds->global_size[2]);
+  mRNAMap["FLUID_DOMAIN_SIZE_X"] = to_string(fds->global_size[0]);
+  mRNAMap["FLUID_DOMAIN_SIZE_Y"] = to_string(fds->global_size[1]);
+  mRNAMap["FLUID_DOMAIN_SIZE_Z"] = to_string(fds->global_size[2]);
   mRNAMap["SNDPARTICLE_TYPES"] = particleTypesStr;
-  mRNAMap["GUIDING_ALPHA"] = to_string(mds->guide_alpha);
-  mRNAMap["GUIDING_BETA"] = to_string(mds->guide_beta);
-  mRNAMap["GUIDING_FACTOR"] = to_string(mds->guide_vel_factor);
-  mRNAMap["GRAVITY_X"] = to_string(mds->gravity[0]);
-  mRNAMap["GRAVITY_Y"] = to_string(mds->gravity[1]);
-  mRNAMap["GRAVITY_Z"] = to_string(mds->gravity[2]);
+  mRNAMap["GUIDING_ALPHA"] = to_string(fds->guide_alpha);
+  mRNAMap["GUIDING_BETA"] = to_string(fds->guide_beta);
+  mRNAMap["GUIDING_FACTOR"] = to_string(fds->guide_vel_factor);
+  mRNAMap["GRAVITY_X"] = to_string(fds->gravity[0]);
+  mRNAMap["GRAVITY_Y"] = to_string(fds->gravity[1]);
+  mRNAMap["GRAVITY_Z"] = to_string(fds->gravity[2]);
   mRNAMap["CACHE_DIR"] = cacheDirectory;
   mRNAMap["COMPRESSION_OPENVDB"] = vdbCompressionMethod;
   mRNAMap["PRECISION_OPENVDB"] = vdbPrecisionHalf;
@@ -1063,7 +1063,7 @@ string MANTA::parseLine(const string &line)
   return res;
 }
 
-string MANTA::parseScript(const string &setup_string, FluidModifierData *mmd)
+string MANTA::parseScript(const string &setup_string, FluidModifierData *fmd)
 {
   if (MANTA::with_debug)
     cout << "MANTA::parseScript()" << endl;
@@ -1073,8 +1073,8 @@ string MANTA::parseScript(const string &setup_string, FluidModifierData *mmd)
   string line = "";
 
   // Update RNA map if modifier data is handed over
-  if (mmd) {
-    initializeRNAMap(mmd);
+  if (fmd) {
+    initializeRNAMap(fmd);
   }
   while (getline(f, line)) {
     res << parseLine(line) << "\n";
@@ -1096,16 +1096,16 @@ static string escapeSlashes(string const &s)
   return result;
 }
 
-bool MANTA::writeConfiguration(FluidModifierData *mmd, int framenr)
+bool MANTA::writeConfiguration(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::writeConfiguration()" << endl;
 
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_CONFIG);
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_CONFIG);
   string format = FLUID_DOMAIN_EXTENSION_UNI;
-  string file = getFile(mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_NAME_CONFIG, format, framenr);
+  string file = getFile(fmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_NAME_CONFIG, format, framenr);
 
   /* Create 'config' subdir if it does not exist already. */
   BLI_dir_create_recursive(directory.c_str());
@@ -1116,38 +1116,38 @@ bool MANTA::writeConfiguration(FluidModifierData *mmd, int framenr)
     return false;
   }
 
-  gzwrite(gzf, &mds->active_fields, sizeof(int));
-  gzwrite(gzf, &mds->res, 3 * sizeof(int));
-  gzwrite(gzf, &mds->dx, sizeof(float));
-  gzwrite(gzf, &mds->dt, sizeof(float));
-  gzwrite(gzf, &mds->p0, 3 * sizeof(float));
-  gzwrite(gzf, &mds->p1, 3 * sizeof(float));
-  gzwrite(gzf, &mds->dp0, 3 * sizeof(float));
-  gzwrite(gzf, &mds->shift, 3 * sizeof(int));
-  gzwrite(gzf, &mds->obj_shift_f, 3 * sizeof(float));
-  gzwrite(gzf, &mds->obmat, 16 * sizeof(float));
-  gzwrite(gzf, &mds->base_res, 3 * sizeof(int));
-  gzwrite(gzf, &mds->res_min, 3 * sizeof(int));
-  gzwrite(gzf, &mds->res_max, 3 * sizeof(int));
-  gzwrite(gzf, &mds->active_color, 3 * sizeof(float));
-  gzwrite(gzf, &mds->time_total, sizeof(int));
+  gzwrite(gzf, &fds->active_fields, sizeof(int));
+  gzwrite(gzf, &fds->res, 3 * sizeof(int));
+  gzwrite(gzf, &fds->dx, sizeof(float));
+  gzwrite(gzf, &fds->dt, sizeof(float));
+  gzwrite(gzf, &fds->p0, 3 * sizeof(float));
+  gzwrite(gzf, &fds->p1, 3 * sizeof(float));
+  gzwrite(gzf, &fds->dp0, 3 * sizeof(float));
+  gzwrite(gzf, &fds->shift, 3 * sizeof(int));
+  gzwrite(gzf, &fds->obj_shift_f, 3 * sizeof(float));
+  gzwrite(gzf, &fds->obmat, 16 * sizeof(float));
+  gzwrite(gzf, &fds->base_res, 3 * sizeof(int));
+  gzwrite(gzf, &fds->res_min, 3 * sizeof(int));
+  gzwrite(gzf, &fds->res_max, 3 * sizeof(int));
+  gzwrite(gzf, &fds->active_color, 3 * sizeof(float));
+  gzwrite(gzf, &fds->time_total, sizeof(int));
   gzwrite(gzf, &FLUID_CACHE_VERSION, 4 * sizeof(char));
 
   return (gzclose(gzf) == Z_OK);
 }
 
-bool MANTA::writeData(FluidModifierData *mmd, int framenr)
+bool MANTA::writeData(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::writeData()" << endl;
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_DATA);
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
-  string resumable_cache = !(mds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE) ? "False" : "True";
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_DATA);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
+  string resumable_cache = !(fds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE) ? "False" : "True";
 
   if (mUsingSmoke) {
     ss.str("");
@@ -1164,18 +1164,18 @@ bool MANTA::writeData(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::writeNoise(FluidModifierData *mmd, int framenr)
+bool MANTA::writeNoise(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::writeNoise()" << endl;
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_NOISE);
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
-  string resumable_cache = !(mds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE) ? "False" : "True";
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_NOISE);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
+  string resumable_cache = !(fds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE) ? "False" : "True";
 
   if (mUsingSmoke && mUsingNoise) {
     ss.str("");
@@ -1186,19 +1186,19 @@ bool MANTA::writeNoise(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::readConfiguration(FluidModifierData *mmd, int framenr)
+bool MANTA::readConfiguration(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::readConfiguration()" << endl;
 
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
   float dummy;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_CONFIG);
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_CONFIG);
   string format = FLUID_DOMAIN_EXTENSION_UNI;
-  string file = getFile(mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_NAME_CONFIG, format, framenr);
+  string file = getFile(fmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_NAME_CONFIG, format, framenr);
 
-  if (!hasConfig(mmd, framenr))
+  if (!hasConfig(fmd, framenr))
     return false;
 
   gzFile gzf = (gzFile)BLI_gzopen(file.c_str(), "rb"); /* Do some compression. */
@@ -1207,29 +1207,29 @@ bool MANTA::readConfiguration(FluidModifierData *mmd, int framenr)
     return false;
   }
 
-  gzread(gzf, &mds->active_fields, sizeof(int));
-  gzread(gzf, &mds->res, 3 * sizeof(int));
-  gzread(gzf, &mds->dx, sizeof(float));
+  gzread(gzf, &fds->active_fields, sizeof(int));
+  gzread(gzf, &fds->res, 3 * sizeof(int));
+  gzread(gzf, &fds->dx, sizeof(float));
   gzread(gzf, &dummy, sizeof(float)); /* dt not needed right now. */
-  gzread(gzf, &mds->p0, 3 * sizeof(float));
-  gzread(gzf, &mds->p1, 3 * sizeof(float));
-  gzread(gzf, &mds->dp0, 3 * sizeof(float));
-  gzread(gzf, &mds->shift, 3 * sizeof(int));
-  gzread(gzf, &mds->obj_shift_f, 3 * sizeof(float));
-  gzread(gzf, &mds->obmat, 16 * sizeof(float));
-  gzread(gzf, &mds->base_res, 3 * sizeof(int));
-  gzread(gzf, &mds->res_min, 3 * sizeof(int));
-  gzread(gzf, &mds->res_max, 3 * sizeof(int));
-  gzread(gzf, &mds->active_color, 3 * sizeof(float));
-  gzread(gzf, &mds->time_total, sizeof(int));
-  gzread(gzf, &mds->cache_id, 4 * sizeof(char)); /* Older caches might have no id. */
-
-  mds->total_cells = mds->res[0] * mds->res[1] * mds->res[2];
+  gzread(gzf, &fds->p0, 3 * sizeof(float));
+  gzread(gzf, &fds->p1, 3 * sizeof(float));
+  gzread(gzf, &fds->dp0, 3 * sizeof(float));
+  gzread(gzf, &fds->shift, 3 * sizeof(int));
+  gzread(gzf, &fds->obj_shift_f, 3 * sizeof(float));
+  gzread(gzf, &fds->obmat, 16 * sizeof(float));
+  gzread(gzf, &fds->base_res, 3 * sizeof(int));
+  gzread(gzf, &fds->res_min, 3 * sizeof(int));
+  gzread(gzf, &fds->res_max, 3 * sizeof(int));
+  gzread(gzf, &fds->active_color, 3 * sizeof(float));
+  gzread(gzf, &fds->time_total, sizeof(int));
+  gzread(gzf, &fds->cache_id, 4 * sizeof(char)); /* Older caches might have no id. */
+
+  fds->total_cells = fds->res[0] * fds->res[1] * fds->res[2];
 
   return (gzclose(gzf) == Z_OK);
 }
 
-bool MANTA::readData(FluidModifierData *mmd, int framenr, bool resumable)
+bool MANTA::readData(FluidModifierData *fmd, int framenr, bool resumable)
 {
   if (with_debug)
     cout << "MANTA::readData()" << endl;
@@ -1239,15 +1239,15 @@ bool MANTA::readData(FluidModifierData *mmd, int framenr, bool resumable)
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
   bool result = true;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_DATA);
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_DATA);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
   string resumable_cache = (!resumable) ? "False" : "True";
 
   /* Sanity check: Are cache files present? */
-  if (!hasData(mmd, framenr))
+  if (!hasData(fmd, framenr))
     return false;
 
   if (mUsingSmoke) {
@@ -1267,7 +1267,7 @@ bool MANTA::readData(FluidModifierData *mmd, int framenr, bool resumable)
   return result;
 }
 
-bool MANTA::readNoise(FluidModifierData *mmd, int framenr, bool resumable)
+bool MANTA::readNoise(FluidModifierData *fmd, int framenr, bool resumable)
 {
   if (with_debug)
     cout << "MANTA::readNoise()" << endl;
@@ -1277,18 +1277,18 @@ bool MANTA::readNoise(FluidModifierData *mmd, int framenr, bool resumable)
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_NOISE);
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_NOISE);
   string resumable_cache = (!resumable) ? "False" : "True";
 
   /* Support older caches which had more granular file format control. */
-  char format = (!strcmp(mds->cache_id, FLUID_CACHE_VERSION)) ? mds->cache_data_format :
-                                                                mds->cache_noise_format;
+  char format = (!strcmp(fds->cache_id, FLUID_CACHE_VERSION)) ? fds->cache_data_format :
+                                                                fds->cache_noise_format;
   string volume_format = getCacheFileEnding(format);
 
   /* Sanity check: Are cache files present? */
-  if (!hasNoise(mmd, framenr))
+  if (!hasNoise(fmd, framenr))
     return false;
 
   ss.str("");
@@ -1299,7 +1299,7 @@ bool MANTA::readNoise(FluidModifierData *mmd, int framenr, bool resumable)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::readMesh(FluidModifierData *mmd, int framenr)
+bool MANTA::readMesh(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::readMesh()" << endl;
@@ -1309,14 +1309,14 @@ bool MANTA::readMesh(FluidModifierData *mmd, int framenr)
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_MESH);
-  string mesh_format = getCacheFileEnding(mds->cache_mesh_format);
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_MESH);
+  string mesh_format = getCacheFileEnding(fds->cache_mesh_format);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
 
   /* Sanity check: Are cache files present? */
-  if (!hasMesh(mmd, framenr))
+  if (!hasMesh(fmd, framenr))
     return false;
 
   ss.str("");
@@ -1334,7 +1334,7 @@ bool MANTA::readMesh(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::readParticles(FluidModifierData *mmd, int framenr, bool resumable)
+bool MANTA::readParticles(FluidModifierData *fmd, int framenr, bool resumable)
 {
   if (with_debug)
     cout << "MANTA::readParticles()" << endl;
@@ -1346,18 +1346,18 @@ bool MANTA::readParticles(FluidModifierData *mmd, int framenr, bool resumable)
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
-  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_PARTICLES);
+  string directory = getDirectory(fmd, FLUID_DOMAIN_DIR_PARTICLES);
   string resumable_cache = (!resumable) ? "False" : "True";
 
   /* Support older caches which had more granular file format control. */
-  char format = (!strcmp(mds->cache_id, FLUID_CACHE_VERSION)) ? mds->cache_data_format :
-                                                                mds->cache_particle_format;
+  char format = (!strcmp(fds->cache_id, FLUID_CACHE_VERSION)) ? fds->cache_data_format :
+                                                                fds->cache_particle_format;
   string volume_format = getCacheFileEnding(format);
 
   /* Sanity check: Are cache files present? */
-  if (!hasParticles(mmd, framenr))
+  if (!hasParticles(fmd, framenr))
     return false;
 
   ss.str("");
@@ -1368,27 +1368,27 @@ bool MANTA::readParticles(FluidModifierData *mmd, int framenr, bool resumable)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
+bool MANTA::readGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain)
 {
   if (with_debug)
     cout << "MANTA::readGuiding()" << endl;
 
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   if (!mUsingGuiding)
     return false;
-  if (!mds)
+  if (!fds)
     return false;
 
   ostringstream ss;
   vector<string> pythonCommands;
 
-  string directory = (sourceDomain) ? getDirectory(mmd, FLUID_DOMAIN_DIR_DATA) :
-                                      getDirectory(mmd, FLUID_DOMAIN_DIR_GUIDE);
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
+  string directory = (sourceDomain) ? getDirectory(fmd, FLUID_DOMAIN_DIR_DATA) :
+                                      getDirectory(fmd, FLUID_DOMAIN_DIR_GUIDE);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
 
   /* Sanity check: Are cache files present? */
-  if (!hasGuiding(mmd, framenr, sourceDomain))
+  if (!hasGuiding(fmd, framenr, sourceDomain))
     return false;
 
   if (sourceDomain) {
@@ -1406,7 +1406,7 @@ bool MANTA::readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::bakeData(FluidModifierData *mmd, int framenr)
+bool MANTA::bakeData(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::bakeData()" << endl;
@@ -1414,19 +1414,19 @@ bool MANTA::bakeData(FluidModifierData *mmd, int framenr)
   string tmpString, finalString;
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   char cacheDirData[FILE_MAX], cacheDirGuiding[FILE_MAX];
   cacheDirData[0] = '\0';
   cacheDirGuiding[0] = '\0';
 
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
 
   BLI_path_join(
-      cacheDirData, sizeof(cacheDirData), mds->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
+      cacheDirData, sizeof(cacheDirData), fds->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
   BLI_path_join(cacheDirGuiding,
                 sizeof(cacheDirGuiding),
-                mds->cache_directory,
+                fds->cache_directory,
                 FLUID_DOMAIN_DIR_GUIDE,
                 nullptr);
   BLI_path_make_safe(cacheDirData);
@@ -1440,22 +1440,22 @@ bool MANTA::bakeData(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::bakeNoise(FluidModifierData *mmd, int framenr)
+bool MANTA::bakeNoise(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::bakeNoise()" << endl;
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   char cacheDirNoise[FILE_MAX];
   cacheDirNoise[0] = '\0';
 
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
 
   BLI_path_join(
-      cacheDirNoise, sizeof(cacheDirNoise), mds->cache_directory, FLUID_DOMAIN_DIR_NOISE, nullptr);
+      cacheDirNoise, sizeof(cacheDirNoise), fds->cache_directory, FLUID_DOMAIN_DIR_NOISE, nullptr);
   BLI_path_make_safe(cacheDirNoise);
 
   ss.str("");
@@ -1466,23 +1466,23 @@ bool MANTA::bakeNoise(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::bakeMesh(FluidModifierData *mmd, int framenr)
+bool MANTA::bakeMesh(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::bakeMesh()" << endl;
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   char cacheDirMesh[FILE_MAX];
   cacheDirMesh[0] = '\0';
 
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
-  string mesh_format = getCacheFileEnding(mds->cache_mesh_format);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
+  string mesh_format = getCacheFileEnding(fds->cache_mesh_format);
 
   BLI_path_join(
-      cacheDirMesh, sizeof(cacheDirMesh), mds->cache_directory, FLUID_DOMAIN_DIR_MESH, nullptr);
+      cacheDirMesh, sizeof(cacheDirMesh), fds->cache_directory, FLUID_DOMAIN_DIR_MESH, nullptr);
   BLI_path_make_safe(cacheDirMesh);
 
   ss.str("");
@@ -1493,24 +1493,24 @@ bool MANTA::bakeMesh(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::bakeParticles(FluidModifierData *mmd, int framenr)
+bool MANTA::bakeParticles(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::bakeParticles()" << endl;
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   char cacheDirParticles[FILE_MAX];
   cacheDirParticles[0] = '\0';
 
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
-  string resumable_cache = !(mds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE) ? "False" : "True";
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
+  string resumable_cache = !(fds->flags & FLUID_DOMAIN_USE_RESUMABLE_CACHE) ? "False" : "True";
 
   BLI_path_join(cacheDirParticles,
                 sizeof(cacheDirParticles),
-                mds->cache_directory,
+                fds->cache_directory,
                 FLUID_DOMAIN_DIR_PARTICLES,
                 nullptr);
   BLI_path_make_safe(cacheDirParticles);
@@ -1523,23 +1523,23 @@ bool MANTA::bakeParticles(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::bakeGuiding(FluidModifierData *mmd, int framenr)
+bool MANTA::bakeGuiding(FluidModifierData *fmd, int framenr)
 {
   if (with_debug)
     cout << "MANTA::bakeGuiding()" << endl;
 
   ostringstream ss;
   vector<string> pythonCommands;
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   char cacheDirGuiding[FILE_MAX];
   cacheDirGuiding[0] = '\0';
 
-  string volume_format = getCacheFileEnding(mds->cache_data_format);
+  string volume_format = getCacheFileEnding(fds->cache_data_format);
 
   BLI_path_join(cacheDirGuiding,
                 sizeof(cacheDirGuiding),
-                mds->cache_directory,
+                fds->cache_directory,
                 FLUID_DOMAIN_DIR_GUIDE,
                 nullptr);
   BLI_path_make_safe(cacheDirGuiding);
@@ -1552,7 +1552,7 @@ bool MANTA::bakeGuiding(FluidModifierData *mmd, int framenr)
   return runPythonString(pythonCommands);
 }
 
-bool MANTA::updateVariables(FluidModifierData *mmd)
+bool MANTA::updateVariables(FluidModifierData *fmd)
 {
   string tmpString, finalString;
   vector<string> pythonCommands;
@@ -1576,13 +1576,13 @@ bool MANTA::updateVariables(FluidModifierData *mmd)
   if (mUsingMesh)
     tmpString += fluid_variables_mesh;
 
-  finalString = parseScript(tmpString, mmd);
+  finalString = parseScript(tmpString, fmd);
   pythonCommands.push_back(finalString);
 
   return runPythonString(pythonCommands);
 }
 
-void MANTA::exportSmokeScript(FluidModifierData *mmd)
+void MANTA::exportSmokeScript(FluidModifierData *fmd)
 {
   if (with_debug)
     cout << "MANTA::exportSmokeScript()" << endl;
@@ -1590,10 +1590,10 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
   char cacheDir[FILE_MAX] = "\0";
   char cacheDirScript[FILE_MAX] = "\0";
 
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mds->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, nullptr);
+      cacheDir, sizeof(cacheDir), fds->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDir);
   /* Create 'script' subdir if it does not exist already */
   BLI_dir_create_recursive(cacheDir);
@@ -1601,14 +1601,14 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
       cacheDirScript, sizeof(cacheDirScript), cacheDir, FLUID_DOMAIN_SMOKE_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDir);
 
-  bool noise = mds->flags & FLUID_DOMAIN_USE_NOISE;
-  bool heat = mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT;
-  bool colors = mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS;
-  bool fire = mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE;
-  bool obstacle = mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE;
-  bool guiding = mds->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE;
-  bool invel = mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL;
-  bool outflow = mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW;
+  bool noise = fds->flags & FLUID_DOMAIN_USE_NOISE;
+  bool heat = fds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT;
+  bool colors = fds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS;
+  bool fire = fds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE;
+  bool obstacle = fds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE;
+  bool guiding = fds->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE;
+  bool invel = fds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL;
+  bool outflow = fds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW;
 
   string manta_script;
 
@@ -1681,7 +1681,7 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
   manta_script += header_main + smoke_standalone + fluid_standalone;
 
   // Fill in missing variables in script
-  string final_script = MANTA::parseScript(manta_script, mmd);
+  string final_script = MANTA::parseScript(manta_script, fmd);
 
   // Write script
   ofstream myfile;
@@ -1690,7 +1690,7 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
   myfile.close();
 }
 
-void MANTA::exportLiquidScript(FluidModifierData *mmd)
+void MANTA::exportLiquidScript(FluidModifierData *fmd)
 {
   if (with_debug)
     cout << "MANTA::exportLiquidScript()" << endl;
@@ -1698,10 +1698,10 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
   char cacheDir[FILE_MAX] = "\0";
   char cacheDirScript[FILE_MAX] = "\0";
 
-  FluidDomainSettings *mds = mmd->domain;
+  FluidDomainSettings *fds = fmd->domain;
 
   BLI_path_join(
-      cacheDir, sizeof(cacheDir), mds->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, nullptr);
+      cacheDir, sizeof(cacheDir), fds->cache_directory, FLUID_DOMAIN_DIR_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDir);
   /* Create 'script' subdir if it does not exist already */
   BLI_dir_create_recursive(cacheDir);
@@ -1709,16 +1709,16 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
       cacheDirScript, sizeof(cacheDirScript), cacheDir, FLUID_DOMAIN_LIQUID_SCRIPT, nullptr);
   BLI_path_make_safe(cacheDirScript);
 
-  bool mesh = mds->flags & FLUID_DOMAIN_USE_MESH;
-  bool drops = mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY;
-  bool bubble = mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE;
-  bool floater = mds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM;
-  bool tracer = mds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER;
-  bool obstacle = mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE;
-  bool fractions = mds->flags & FLUID_DOMAIN_USE_FRACTIONS;
-  bool guiding = mds->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE;
-  bool invel = mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL;
-  bool outflow = mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW;
+  bool mesh = fds->flags & FLUID_DOMAIN_USE_MESH;
+  bool drops = fds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY;
+  bool bubble = fds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE;
+  bool floater = fds->particle_type & FLUID_DOMAIN_PARTICLE_FOAM;
+  bool tracer = fds->particle_type & FLUID_DOMAIN_PARTICLE_TRACER;
+  bool obstacle = fds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE;
+  bool fractions = fds->flags & FLUID_DOMAIN_USE_FRACTIONS;
+  bool guiding = fds->active_fields & FLUID_DOMAIN_ACTIVE_GUIDE;
+  bool invel = fds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL;
+  bool outflow = fds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW;
 
   string manta_script;
 
@@ -1789,7 +1789,7 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
   manta_script += header_main + liquid_standalone + fluid_standalone;
 
   // Fill in missing variables in script
-  string final_script = MANTA::parseScript(manta_script, mmd);
+  string final_script = MANTA::parseScript(manta_script, fmd);
 
   // Write script
   ofstream myfile;
@@ -1932,10 +1932,10 @@ float MANTA::getTimestep()
   return (float)pyObjectToDouble(callPythonFunction(solver, func, true));
 }
 
-bool MANTA::needsRealloc(FluidModifierData *mmd)
+bool MANTA::needsRealloc(FluidModifierData *fmd)
 {
-  FluidDomainSettings *mds = mmd->domain;
-  return (mds->res[0] != mResX || mds->res[1] != mResY || mds->res[2] != mResZ);
+  FluidDomainSettings *fds = fmd->domain;
+  return (fds->res[0] != mResX || fds->res[1] != mResY || fds->res[2] != mResZ);
 }
 
 void MANTA::adaptTimestep()
@@ -2091,23 +2091,23 @@ void MANTA::updatePointers()
   mNoiseFromFile = false;
 }
 
-bool MANTA::hasConfig(FluidModifierData *mmd, int framenr)
+bool MANTA::hasConfig(FluidModifierData *fmd, int framenr)
 {
   string extension = FLUID_DOMAIN_EXTENSION_UNI;
   return BLI_exists(
-      getFile(mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_NAME_CONFIG, extension, framenr).c_str());
+      getFile(fmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_NAME_CONFIG, extension, framenr).c_str());
 }
 
-bool MANTA::hasData(FluidModifierData *mmd, int framenr)
+bool MANTA::hasData(FluidModifierData *fmd, int framenr)
 {
-  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
+  string extension = getCacheFileEnding(fmd->domain->cache_data_format);
   bool exists = BLI_exists(
-      getFile(mmd, FLUID_DOMAIN_DIR_DATA, FLUID_NAME_DATA, extension, framenr).c_str());
+      getFile(fmd, FLUID_DOMAIN_DIR_DATA, FLUID_NAME_DATA, extension, framenr).c_str());
 
   /* Check single file naming. */
   if (!exists) {
     string filename = (mUsingSmoke) ? FLUID_NAME_DENSITY : FLUID_NAME_PP;
-    exists = BLI_exists(getFile(mmd, FLUID_DOMAIN_DIR_DATA, filename, extension, framenr).c_str());
+    exists = BLI_exists(getFile(fmd, FLUID_DOMAIN_DIR_DATA, filename, extension, framenr).c_str());
   }
   if (with_debug)
     cout << "Fluid: Has Data: " << exists << endl;
@@ -2115,24 +2115,24 @@ bool MANTA::hasData(FluidModifierData *mmd, int framenr)
   return exists;
 }
 
-bool MANTA::hasNoise(FluidModifierData *mmd, int framenr)
+bool MANTA::hasNoise(FluidModifierData *fmd, int framenr)
 {
-  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
+  string extension = getCacheFileEnding(fmd->domain->cache_data_format);
   bool exists = BLI_exists(
-      getFile(mmd, FLUID_DOMAIN_DIR_NOISE, FLUID_NAME_NOISE, extension, framenr).c_str());
+      getFile(fmd, FLUID_DOMAIN_DIR_NOISE, FLUID_NAME_NOISE, extension, framenr).c_str());
 
   /* Check single file naming. */
   if (!exists) {
-    extension = getCacheFileEnding(mmd->domain->cache_data_format);
+    extension = getCacheFileEnding(fmd->domain->cache_data_format);
     exists = BLI_exists(
-        getFile(mmd, FLUID_DOMAIN_DIR_NOISE, FLUID_NAME_DENSITY_NOISE, extension, framenr)
+        getFile(fmd, FLUID_DOMAIN_DIR_NOISE, FLUID_NAME_DENSITY_NOISE, extension, framenr)
             .c_str());
   }
   /* Check single file naming with deprecated extension. */
   if (!exists) {
-    extension = getCacheFileEnding(mmd->domain->cache_noise_format);
+    extension = getCacheFileEnding(fmd->domain->cache_noise_format);
     exists = BLI_exists(
-        getFile(mmd, FLUID_DOMAIN_DIR_NOISE, FLUID_NAME_DENSITY_NOISE, extension, framenr)
+        getFile(fmd, FLUID_DOMAIN_DIR_NOISE, FLUID_NAME_DENSITY_NOISE, extension, framenr)
             .c_str());
   }
   if (with_debug)
@@ -2141,16 +2141,16 @@ bool MANTA::hasNoise(FluidModifierData *mmd, int framenr)
   return exists;
 }
 
-bool MANTA::hasMesh(FluidModifierData *mmd, int framenr)
+bool MANTA::hasMesh(FluidModifierData *fmd, int framenr)
 {
-  string extension = getCacheFileEnding(mmd->domain->cache_mesh_format);
+  string extension = getCacheFileEnding(fmd->domain->cache_mesh_format);
   bool exists = BLI_exists(
-      getFile(mmd, FLUID_DOMAIN_DIR_MESH, FLUID_NAME_MESH, extension, framenr).c_str());
+      getFile(fmd, FLUID_DOMAIN_DIR_MESH, FLUID_NAME_MESH, extension, framenr).c_str());
 
   /* Check old file naming. */
   if (!exists) {
     exists = BLI_exists(
-        getFile(mmd, FLUID_DOMAIN_DIR_MESH, FLUID_NAME_LMESH, extension, framenr).c_str());
+        getFile(fmd, FLUID_DOMAIN_DIR_MESH, FLUID_NAME_LMESH, extension, framenr).c_str());
   }
   if (with_debug)
     cout << "Fluid: Has Mesh: " << exists << endl;
@@ -2158,24 +2158,24 @@ bool MANTA::hasMesh(FluidModifierData *mmd, int framenr)
   return exists;
 }
 
-bool MANTA::hasParticles(FluidModifierData *mmd, int framenr)
+bool MANTA::hasParticles(FluidModifierData *fmd, int framenr)
 {
-  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
+  string extension = getCacheFileEnding(fmd->domain->cache_data_format);
   bool exists = BLI_exists(
-      getFile(mmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_NAME_PARTICLES, extension, framenr).c_str());
+      getFile(fmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_NAME_PARTICLES, extension, framenr).c_str());
 
   /* Check single file naming. */
   if (!exists) {
-    extension = getCacheFileEnding(mmd->domain->cache_data_format);
+    extension = getCacheFileEnding(fmd->domain->cache_data_format);
     exists = BLI_exists(
-        getFile(mmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_NAME_PP_PARTICLES, extension, framenr)
+        getFile(fmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_NAME_PP_PARTICLES, extension, framenr)
             .c_str());
   }
   /* Check single file naming with deprecated extension. */
   if (!exists) {
-    extension = getCacheFileEnding(mmd->domain->cache_particle_format);
+    extension = getCacheFileEnding(fmd->domain->cache_particle_format);
     exists = BLI_exists(
-        getFile(mmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_NAME_PP_PARTICLES, extension, framenr)
+        getFile(fmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_NAME_PP_PARTICLES, extension, framenr)
             .c_str());
   }
   if (with_debug)
@@ -2184,32 +2184,32 @@ bool MANTA::hasParticles(FluidModifierData *mmd, int framenr)
   return exists;
 }
 
-bool MANTA::hasGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
+bool MANTA::hasGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain)
 {
   string subdirectory = (sourceDomain) ? FLUID_DOMAIN_DIR_DATA : FLUID_DOMAIN_DIR_GUIDE;
   string filename = (sourceDomain) ? FLUID_NAME_VELOCITY : FLUID_NAME_GUIDEVEL;
-  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
-  bool exists = BLI_exists(getFile(mmd, subdirectory, filename, extension, framenr).c_str());
+  string extension = getCacheFileEnding(fmd->domain->cache_data_format);
+  bool exists = BLI_exists(getFile(fmd, subdirectory, filename, extension, framenr).c_str());
   if (with_debug)
     cout << "Fluid: Has Guiding: " << exists << endl;
 
   return exists;
 }
 
-string MANTA::getDirectory(FluidModifierData *mmd, string subdirectory)
+string MANTA::getDirectory(FluidModifierData *fmd, string subdirectory)
 {
   char directory[FILE_MAX];
   BLI_path_join(
-      directory, sizeof(directory), mmd->domain->cache_directory, subdirectory.c_str(), nullptr);
+      directory, sizeof(directory), fmd->domain->cache_directory, subdirectory.c_str(), nullptr);
   BLI_path_make_safe(directory);
   return directory;
 }
 
 string MANTA::getFile(
-    FluidModifierData *mmd, string subdirectory, string fname, string extension, int framenr)
+    FluidModifierData *fmd, string subdirectory, string fname, string extension, int framenr)
 {
   char targetFile[FILE_MAX];
-  string path = getDirectory(mmd, subdirectory);
+  string path = getDirectory(fmd, subdirectory);
   string filename = fname + "_####" + extension;
   BLI_join_dirfile(targetFile, sizeof(targetFile), path.c_str(), filename.c_str());
   BLI_path_frame(targetFile, framenr, 0);
diff --git a/intern/mantaflow/intern/MANTA_main.h b/intern/mantaflow/intern/MANTA_main.h
index 38cbd33ea0a..dae2aea4e08 100644
--- a/intern/mantaflow/intern/MANTA_main.h
+++ b/intern/mantaflow/intern/MANTA_main.h
@@ -37,7 +37,7 @@ using std::vector;
 
 struct MANTA {
  public:
-  MANTA(int *res, struct FluidModifierData *mmd);
+  MANTA(int *res, struct FluidModifierData *fmd);
   MANTA(){};
   virtual ~MANTA();
 
@@ -61,68 +61,68 @@ struct MANTA {
   } Triangle;
 
   // Manta step, handling everything
-  void step(struct FluidModifierData *mmd, int startFrame);
+  void step(struct FluidModifierData *fmd, int startFrame);
 
   // Grid initialization functions
-  void initHeat(struct FluidModifierData *mmd = NULL);
-  void initFire(struct FluidModifierData *mmd = NULL);
-  void initColors(struct FluidModifierData *mmd = NULL);
-  void initFireHigh(struct FluidModifierData *mmd = NULL);
-  void initColorsHigh(struct FluidModifierData *mmd = NULL);
-  void initLiquid(FluidModifierData *mmd = NULL);
-  void initLiquidMesh(FluidModifierData *mmd = NULL);
-  void initObstacle(FluidModifierData *mmd = NULL);
-  void initCurvature(FluidModifierData *mmd = NULL);
-  void initGuiding(FluidModifierData *mmd = NULL);
-  void initFractions(FluidModifierData *mmd = NULL);
-  void initInVelocity(FluidModifierData *mmd = NULL);
-  void initOutflow(FluidModifierData *mmd = NULL);
-  void initSndParts(FluidModifierData *mmd = NULL);
-  void initLiquidSndParts(FluidModifierData *mmd = NULL);
+  void initHeat(struct FluidModifierData *fmd = NULL);
+  void initFire(struct FluidModifierData *fmd = NULL);
+  void initColors(struct FluidModifierData *fmd = NULL);
+  void initFireHigh(struct FluidModifierData *fmd = NULL);
+  void initColorsHigh(struct FluidModifierData *fmd = NULL);
+  void initLiquid(FluidModifierData *fmd = NULL);
+  void initLiquidMesh(FluidModifierData *fmd = NULL);
+  void initObstacle(FluidModifierData *fmd = NULL);
+  void initCurvature(FluidModifierData *fmd = NULL);
+  void initGuiding(FluidModifierData *fmd = NULL);
+  void initFractions(FluidModifierData *fmd = NULL);
+  void initInVelocity(FluidModifierData *fmd = NULL);
+  void initOutflow(FluidModifierData *fmd = NULL);
+  void initSndParts(FluidModifierData *fmd = NULL);
+  void initLiquidSndParts(FluidModifierData *fmd = NULL);
 
   // Pointer transfer: Mantaflow -> Blender
   void updatePointers();
 
   // Write cache
-  bool writeConfiguration(FluidModifierData *mmd, int framenr);
-  bool writeData(FluidModifierData *mmd, int framenr);
-  bool writeNoise(FluidModifierData *mmd, int framenr);
+  bool writeConfiguration(FluidModifierData *fmd, int framenr);
+  bool writeData(FluidModifierData *fmd, int framenr);
+  bool writeNoise(FluidModifierData *fmd, int framenr);
   // write calls for mesh and particles were left in bake calls for now
 
   // Read cache (via Manta save/load)
-  bool readConfiguration(FluidModifierData *mmd, int framenr);
-  bool readData(FluidModifierData *mmd, int framenr, bool resumable);
-  bool readNoise(FluidModifierData *mmd, int framenr, bool resumable);
-  bool readMesh(FluidModifierData *mmd, int framenr);
-  bool readParticles(FluidModifierData *mmd, int framenr, bool resumable);
-  bool readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain);
+  bool readConfiguration(FluidModifierData *fmd, int framenr);
+  bool readData(FluidModifierData *fmd, int framenr, bool resumable);
+  bool readNoise(FluidModifierData *fmd, int framenr, bool resumable);
+  bool readMesh(FluidModifierData *fmd, int framenr);
+  bool readParticles(FluidModifierData *fmd, int framenr, bool resumable);
+  bool readGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain);
 
   // Read cache (via file read functions in MANTA - e.g. read .bobj.gz meshes, .uni particles)
-  bool updateMeshStructures(FluidModifierData *mmd, int framenr);
-  bool updateFlipStructures(FluidModifierData *mmd, int framenr);
-  bool updateParticleStructures(FluidModifierData *mmd, int framenr);
-  bool updateSmokeStructures(FluidModifierData *mmd, int framenr);
-  bool updateNoiseStructures(FluidModifierData *mmd, int framenr);
-  bool updateVariables(FluidModifierData *mmd);
+  bool updateMeshStructures(FluidModifierData *fmd, int framenr);
+  bool updateFlipStructures(FluidModifierData *fmd, int framenr);
+  bool updateParticleStructures(FluidModifierData *fmd, int framenr);
+  bool updateSmokeStructures(FluidModifierData *fmd, int framenr);
+  bool updateNoiseStructures(FluidModifierData *fmd, int framenr);
+  bool updateVariables(FluidModifierData *fmd);
 
   // Bake cache
-  bool bakeData(FluidModifierData *mmd, int framenr);
-  bool bakeNoise(FluidModifierData *mmd, int framenr);
-  bool bakeMesh(FluidModifierData *mmd, int framenr);
-  bool bakeParticles(FluidModifierData *mmd, int framenr);
-  bool bakeGuiding(FluidModifierData *mmd, int framenr);
+  bool bakeData(FluidModifierData *fmd, int framenr);
+  bool bakeNoise(FluidModifierData *fmd, int framenr);
+  bool bakeMesh(FluidModifierData *fmd, int framenr);
+  bool bakeParticles(FluidModifierData *fmd, int framenr);
+  bool bakeGuiding(FluidModifierData *fmd, int framenr);
 
   // IO for Mantaflow scene script
-  void exportSmokeScript(struct FluidModifierData *mmd);
-  void exportLiquidScript(struct FluidModifierData *mmd);
+  void exportSmokeScript(struct FluidModifierData *fmd);
+  void exportLiquidScript(struct FluidModifierData *fmd);
 
   // Check cache status by frame
-  bool hasConfig(FluidModifierData *mmd, int framenr);
-  bool hasData(FluidModifierData *mmd, int framenr);
-  bool hasNoise(FluidModifierData *mmd, int framenr);
-  bool hasMesh(FluidModifierData *mmd, int framenr);
-  bool hasParticles(FluidModifierData *mmd, int framenr);
-  bool hasGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain);
+  bool hasConfig(FluidModifierData *fmd, int framenr);
+  bool hasData(FluidModifierData *fmd, int framenr);
+  bool hasNoise(FluidModifierData *fmd, int framenr);
+  bool hasMesh(FluidModifierData *fmd, int framenr);
+  bool hasParticles(FluidModifierData *fmd, int framenr);
+  bool hasGuiding(FluidModifierData *fmd, int framenr, bool sourceDomain);
 
   inline size_t getTotalCells()
   {
@@ -739,7 +739,7 @@ struct MANTA {
   float getTimestep();
   void adaptTimestep();
 
-  bool needsRealloc(FluidModifierData *mmd);
+  bool needsRealloc(FluidModifierData *fmd);
 
  private:
   // simulation constants
@@ -874,20 +874,20 @@ struct MANTA {
   vector<pVel> *mSndParticleVelocity;
   vector<float> *mSndParticleLife;
 
-  void initializeRNAMap(struct FluidModifierData *mmd = NULL);
-  void initDomain(struct FluidModifierData *mmd = NULL);
-  void initNoise(struct FluidModifierData *mmd = NULL);
-  void initMesh(struct FluidModifierData *mmd = NULL);
-  void initSmoke(struct FluidModifierData *mmd = NULL);
-  void initSmokeNoise(struct FluidModifierData *mmd = NULL);
+  void initializeRNAMap(struct FluidModifierData *fmd = NULL);
+  void initDomain(struct FluidModifierData *fmd = NULL);
+  void initNoise(struct FluidModifierData *fmd = NULL);
+  void initMesh(struct FluidModifierData *fmd = NULL);
+  void initSmoke(struct FluidModifierData *fmd = NULL);
+  void initSmokeNoise(struct FluidModifierData *fmd = NULL);
   void initializeMantaflow();
   void terminateMantaflow();
   bool runPythonString(vector<string> commands);
   string getRealValue(const string &varName);
   string parseLine(const string &line);
-  string parseScript(const string &setup_string, FluidModifierData *mmd = NULL);
-  string getDirectory(struct FluidModifierData *mmd, string subdirectory);
-  string getFile(struct FluidModifierData *mmd,
+  string parseScript(const string &setup_string, FluidModifierData *fmd = NULL);
+  string getDirectory(struct FluidModifierData *fmd, string subdirectory);
+  string getFile(struct FluidModifierData *fmd,
                  string subdirectory,
                  string fname,
                  string extension,
diff --git a/intern/mantaflow/intern/manta_fluid_API.cpp b/intern/mantaflow/intern/manta_fluid_API.cpp
index f1607f1bd99..1db3da63ecc 100644
--- a/intern/mantaflow/intern/manta_fluid_API.cpp
+++ b/intern/mantaflow/intern/manta_fluid_API.cpp
@@ -27,9 +27,9 @@
 #include "manta_fluid_API.h"
 
 /* Fluid functions */
-MANTA *manta_init(int *res, struct FluidModifierData *mmd)
+MANTA *manta_init(int *res, struct FluidModifierData *fmd)
 {
-  return new MANTA(res, mmd);
+  return new MANTA(res, fmd);
 }
 void manta_free(MANTA *fluid)
 {
@@ -37,173 +37,173 @@ void manta_free(MANTA *fluid)
   fluid = nullptr;
 }
 
-void manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *mmd)
+void manta_ensure_obstacle(MANTA *fluid, struct FluidModifierData *fmd)
 {
   if (!fluid)
     return;
-  fluid->initObstacle(mmd);
+  fluid->initObstacle(fmd);
   fluid->updatePointers();
 }
-void manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *mmd)
+void manta_ensure_guiding(MANTA *fluid, struct FluidModifierData *fmd)
 {
   if (!fluid)
     return;
-  fluid->initGuiding(mmd);
+  fluid->initGuiding(fmd);
   fluid->updatePointers();
 }
-void manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *mmd)
+void manta_ensure_invelocity(MANTA *fluid, struct FluidModifierData *fmd)
 {
   if (!fluid)
     return;
-  fluid->initInVelocity(mmd);
+  fluid->initInVelocity(fmd);
   fluid->updatePointers();
 }
-void manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *mmd)
+void manta_ensure_outflow(MANTA *fluid, struct FluidModifierData *fmd)
 {
   if (!fluid)
     return;
-  fluid->initOutflow(mmd);
+  fluid->initOutflow(fmd);
   fluid->updatePointers();
 }
 
-int manta_write_config(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_write_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->writeConfiguration(mmd, framenr);
+  return fluid->writeConfiguration(fmd, framenr);
 }
 
-int manta_write_data(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_write_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->writeData(mmd, framenr);
+  return fluid->writeData(fmd, framenr);
 }
 
-int manta_write_noise(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_write_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->writeNoise(mmd, framenr);
+  return fluid->writeNoise(fmd, framenr);
 }
 
-int manta_read_config(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_read_config(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->readConfiguration(mmd, framenr);
+  return fluid->readConfiguration(fmd, framenr);
 }
 
-int manta_read_data(MANTA *fluid, FluidModifierData *mmd, int framenr, bool resumable)
+int manta_read_data(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->readData(mmd, framenr, resumable);
+  return fluid->readData(fmd, framenr, resumable);
 }
 
-int manta_read_noise(MANTA *fluid, FluidModifierData *mmd, int framenr, bool resumable)
+int manta_read_noise(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->readNoise(mmd, framenr, resumable);
+  return fluid->readNoise(fmd, framenr, resumable);
 }
 
-int manta_read_mesh(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_read_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->readMesh(mmd, framenr);
+  return fluid->readMesh(fmd, framenr);
 }
 
-int manta_read_particles(MANTA *fluid, FluidModifierData *mmd, int framenr, bool resumable)
+int manta_read_particles(MANTA *fluid, FluidModifierData *fmd, int framenr, bool resumable)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->readParticles(mmd, framenr, resumable);
+  return fluid->readParticles(fmd, framenr, resumable);
 }
 
-int manta_read_guiding(MANTA *fluid, FluidModifierData *mmd, int framenr, bool sourceDomain)
+int manta_read_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool sourceDomain)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->readGuiding(mmd, framenr, sourceDomain);
+  return fluid->readGuiding(fmd, framenr, sourceDomain);
 }
 
-int manta_bake_data(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_bake_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->bakeData(mmd, framenr);
+  return fluid->bakeData(fmd, framenr);
 }
 
-int manta_bake_noise(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_bake_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->bakeNoise(mmd, framenr);
+  return fluid->bakeNoise(fmd, framenr);
 }
 
-int manta_bake_mesh(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_bake_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->bakeMesh(mmd, framenr);
+  return fluid->bakeMesh(fmd, framenr);
 }
 
-int manta_bake_particles(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_bake_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->bakeParticles(mmd, framenr);
+  return fluid->bakeParticles(fmd, framenr);
 }
 
-int manta_bake_guiding(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_bake_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->bakeGuiding(mmd, framenr);
+  return fluid->bakeGuiding(fmd, framenr);
 }
 
-int manta_has_data(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_has_data(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->hasData(mmd, framenr);
+  return fluid->hasData(fmd, framenr);
 }
 
-int manta_has_noise(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_has_noise(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->hasNoise(mmd, framenr);
+  return fluid->hasNoise(fmd, framenr);
 }
 
-int manta_has_mesh(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_has_mesh(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->hasMesh(mmd, framenr);
+  return fluid->hasMesh(fmd, framenr);
 }
 
-int manta_has_particles(MANTA *fluid, FluidModifierData *mmd, int framenr)
+int manta_has_particles(MANTA *fluid, FluidModifierData *fmd, int framenr)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->hasParticles(mmd, framenr);
+  return fluid->hasParticles(fmd, framenr);
 }
 
-int manta_has_guiding(MANTA *fluid, FluidModifierData *mmd, int framenr, bool domain)
+int manta_has_guiding(MANTA *fluid, FluidModifierData *fmd, int framenr, bool domain)
 {
-  if (!fluid || !mmd)
+  if (!fluid || !fmd)
     return 0;
-  return fluid->hasGuiding(mmd, framenr, domain);
+  return fluid->hasGuiding(fmd, framenr, domain);
 }
 
-void manta_update_variables(MANTA *fluid, FluidModifierData *mmd)
+void manta_update_variables(MANTA *fluid, FluidModifierData *fmd)
 {
   if (!fluid)
     return;
-  fluid->updateVariables(mmd);
+  fluid->updateVariables(fmd);
 }
 
 int manta_get_frame(MANTA *fluid)
@@ -227,11 +227,11 @@ void manta_adapt_timestep(MANTA *fluid)
   fluid->adaptTimestep();
 }
 
-bool manta_needs_realloc(MANTA *fluid, FluidModifierData *mmd)
+bool manta_needs_realloc(MANTA *fluid, FluidModifierData *fmd)
 {
   if (!fluid)
     return false;
-  return fluid->needsRealloc(mmd);
+  return fluid->needsRealloc(fmd);
 }
 
 /* Fluid accessors */
@@ -361,11 +361,11 @@ float *manta_get_phioutstatic_in(MANTA *fluid)
 }
 
 /* Smoke functions */
-void manta_smoke_export_script(MANTA *smoke, FluidModifierData *mmd)
+void manta_smoke_export_script(MANTA *smoke, FluidModifierData *fmd)
 {
-  if (!smoke || !mmd)
+  if (!smoke || !fmd)
     return;
-  smoke->exportSmokeScript(mmd);
+  smoke->exportSmokeScript(fmd);
 }
 
 void manta_smoke_export(MANTA *smoke,
@@ -527,31 +527,31 @@ void manta_smoke_turbulence_get_rgba_fixed_color(MANTA *smoke,
   get_rgba_fixed_color(color, smoke->getTotalCellsHigh(), data, sequential);
 }
 
-void manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *mmd)
+void manta_smoke_ensure_heat(MANTA *smoke, struct FluidModifierData *fmd)
 {
   if (smoke) {
-    smoke->initHeat(mmd);
+    smoke->initHeat(fmd);
     smoke->updatePointers();
   }
 }
 
-void manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *mmd)
+void manta_smoke_ensure_fire(MANTA *smoke, struct FluidModifierData *fmd)
 {
   if (smoke) {
-    smoke->initFire(mmd);
+    smoke->initFire(fmd);
     if (smoke->usingNoise()) {
-      smoke->initFireHigh(mmd);
+      smoke->initFireHigh(fmd);
     }
     smoke->updatePointers();
   }
 }
 
-void manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *mmd)
+void manta_smoke_ensure_colors(MANTA *smoke, struct FluidModifierData *fmd)
 {
   if (smoke) {
-    smoke->initColors(mmd);
+    smoke->initColors(fmd);
     if (smoke->usingNoise()) {
-      smoke->initColorsHigh(mmd);
+      smoke->initColorsHigh(fmd);
     }
     smoke->updatePointers();
   }
@@ -700,17 +700,17 @@ int manta_smoke_turbulence_get_cells(MANTA *smoke)
 }
 
 /* Liquid functions */
-void manta_liquid_export_script(MANTA *liquid, FluidModifierData *mmd)
+void manta_liquid_export_script(MANTA *liquid, FluidModifierData *fmd)
 {
-  if (!liquid || !mmd)
+  if (!liquid || !fmd)
     return;
-  liquid->exportLiquidScript(mmd);
+  liquid->exportLiquidScript(fmd);
 }
 
-void manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *mmd)
+void manta_liquid_ensure_sndparts(MANTA *liquid, struct FluidModifierData *fmd)
 {
   if (liquid) {
-    liquid->initLiquidSndParts(mmd);
+    liquid->initLiquidSndParts(fmd);
     liquid->updatePointers();
   }
 }