Fluid: Cleanup use of std in MANTA wrapper

Moved std namespace to beginning of class.

2 files changed, 568 insertions, 589 deletions

diff --git a/intern/mantaflow/intern/MANTA_main.cpp b/intern/mantaflow/intern/MANTA_main.cpp
index 995cce4a1ce..d59c7464934 100644
--- a/intern/mantaflow/intern/MANTA_main.cpp
+++ b/intern/mantaflow/intern/MANTA_main.cpp
@@ -48,7 +48,16 @@
 
 #include "MEM_guardedalloc.h"
 
-std::atomic<int> MANTA::solverID(0);
+using std::cerr;
+using std::cout;
+using std::endl;
+using std::ifstream;
+using std::istringstream;
+using std::ofstream;
+using std::ostringstream;
+using std::to_string;
+
+atomic<int> MANTA::solverID(0);
 int MANTA::with_debug(0);
 
 /* Number of particles that the cache reads at once (with zlib). */
@@ -61,8 +70,8 @@ int MANTA::with_debug(0);
 MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
 {
   if (with_debug)
-    std::cout << "FLUID: " << mCurrentID << " with res(" << res[0] << ", " << res[1] << ", "
-              << res[2] << ")" << std::endl;
+    cout << "FLUID: " << mCurrentID << " with res(" << res[0] << ", " << res[1] << ", " << res[2]
+         << ")" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   mds->fluid = this;
@@ -274,32 +283,32 @@ MANTA::MANTA(int *res, FluidModifierData *mmd) : mCurrentID(++solverID)
 void MANTA::initDomain(FluidModifierData *mmd)
 {
   // Vector will hold all python commands that are to be executed
-  std::vector<std::string> pythonCommands;
+  vector<string> pythonCommands;
 
   // Set manta debug level first
   pythonCommands.push_back(manta_import + manta_debuglevel);
 
-  std::ostringstream ss;
+  ostringstream ss;
   ss << "set_manta_debuglevel(" << with_debug << ")";
   pythonCommands.push_back(ss.str());
 
   // Now init basic fluid domain
-  std::string tmpString = fluid_variables + fluid_solver + fluid_alloc + fluid_cache_helper +
-                          fluid_bake_multiprocessing + fluid_bake_data + fluid_bake_noise +
-                          fluid_bake_mesh + fluid_bake_particles + fluid_bake_guiding +
-                          fluid_file_import + fluid_file_export + fluid_save_data +
-                          fluid_load_data + fluid_pre_step + fluid_post_step +
-                          fluid_adapt_time_step + fluid_time_stepping;
-  std::string finalString = parseScript(tmpString, mmd);
+  string tmpString = fluid_variables + fluid_solver + fluid_alloc + fluid_cache_helper +
+                     fluid_bake_multiprocessing + fluid_bake_data + fluid_bake_noise +
+                     fluid_bake_mesh + fluid_bake_particles + fluid_bake_guiding +
+                     fluid_file_import + fluid_file_export + fluid_save_data + fluid_load_data +
+                     fluid_pre_step + fluid_post_step + fluid_adapt_time_step +
+                     fluid_time_stepping;
+  string finalString = parseScript(tmpString, mmd);
   pythonCommands.push_back(finalString);
   runPythonString(pythonCommands);
 }
 
 void MANTA::initNoise(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = fluid_variables_noise + fluid_solver_noise;
-  std::string finalString = parseScript(tmpString, mmd);
+  vector<string> pythonCommands;
+  string tmpString = fluid_variables_noise + fluid_solver_noise;
+  string finalString = parseScript(tmpString, mmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -307,10 +316,10 @@ void MANTA::initNoise(FluidModifierData *mmd)
 
 void MANTA::initSmoke(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = smoke_variables + smoke_alloc + smoke_adaptive_step + smoke_save_data +
-                          smoke_load_data + smoke_step;
-  std::string finalString = parseScript(tmpString, mmd);
+  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);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -318,10 +327,10 @@ void MANTA::initSmoke(FluidModifierData *mmd)
 
 void MANTA::initSmokeNoise(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = smoke_variables_noise + smoke_alloc_noise + smoke_wavelet_noise +
-                          smoke_save_noise + smoke_load_noise + smoke_step_noise;
-  std::string finalString = parseScript(tmpString, mmd);
+  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);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -331,9 +340,9 @@ void MANTA::initSmokeNoise(FluidModifierData *mmd)
 void MANTA::initHeat(FluidModifierData *mmd)
 {
   if (!mHeat) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = smoke_alloc_heat + smoke_with_heat;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = smoke_alloc_heat + smoke_with_heat;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -344,9 +353,9 @@ void MANTA::initHeat(FluidModifierData *mmd)
 void MANTA::initFire(FluidModifierData *mmd)
 {
   if (!mFuel) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = smoke_alloc_fire + smoke_with_fire;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = smoke_alloc_fire + smoke_with_fire;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -357,9 +366,9 @@ void MANTA::initFire(FluidModifierData *mmd)
 void MANTA::initFireHigh(FluidModifierData *mmd)
 {
   if (!mFuelHigh) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = smoke_alloc_fire_noise + smoke_with_fire;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = smoke_alloc_fire_noise + smoke_with_fire;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -370,9 +379,9 @@ void MANTA::initFireHigh(FluidModifierData *mmd)
 void MANTA::initColors(FluidModifierData *mmd)
 {
   if (!mColorR) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = smoke_alloc_colors + smoke_init_colors + smoke_with_colors;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = smoke_alloc_colors + smoke_init_colors + smoke_with_colors;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -383,9 +392,9 @@ void MANTA::initColors(FluidModifierData *mmd)
 void MANTA::initColorsHigh(FluidModifierData *mmd)
 {
   if (!mColorRHigh) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = smoke_alloc_colors_noise + smoke_init_colors_noise + smoke_with_colors;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = smoke_alloc_colors_noise + smoke_init_colors_noise + smoke_with_colors;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -396,10 +405,10 @@ void MANTA::initColorsHigh(FluidModifierData *mmd)
 void MANTA::initLiquid(FluidModifierData *mmd)
 {
   if (!mPhiIn) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = liquid_variables + liquid_alloc + liquid_init_phi + liquid_save_data +
-                            liquid_load_data + liquid_adaptive_step + liquid_step;
-    std::string finalString = parseScript(tmpString, mmd);
+    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);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -409,9 +418,9 @@ void MANTA::initLiquid(FluidModifierData *mmd)
 
 void MANTA::initMesh(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = fluid_variables_mesh + fluid_solver_mesh + liquid_load_mesh;
-  std::string finalString = parseScript(tmpString, mmd);
+  vector<string> pythonCommands;
+  string tmpString = fluid_variables_mesh + fluid_solver_mesh + liquid_load_mesh;
+  string finalString = parseScript(tmpString, mmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -420,9 +429,9 @@ void MANTA::initMesh(FluidModifierData *mmd)
 
 void MANTA::initLiquidMesh(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = liquid_alloc_mesh + liquid_step_mesh + liquid_save_mesh;
-  std::string finalString = parseScript(tmpString, mmd);
+  vector<string> pythonCommands;
+  string tmpString = liquid_alloc_mesh + liquid_step_mesh + liquid_save_mesh;
+  string finalString = parseScript(tmpString, mmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -432,9 +441,9 @@ void MANTA::initLiquidMesh(FluidModifierData *mmd)
 void MANTA::initObstacle(FluidModifierData *mmd)
 {
   if (!mPhiObsIn) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = fluid_alloc_obstacle + fluid_with_obstacle;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = fluid_alloc_obstacle + fluid_with_obstacle;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -445,10 +454,10 @@ void MANTA::initObstacle(FluidModifierData *mmd)
 void MANTA::initGuiding(FluidModifierData *mmd)
 {
   if (!mPhiGuideIn) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = fluid_variables_guiding + fluid_solver_guiding + fluid_alloc_guiding +
-                            fluid_save_guiding + fluid_load_vel + fluid_load_guiding;
-    std::string finalString = parseScript(tmpString, mmd);
+    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);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -458,9 +467,9 @@ void MANTA::initGuiding(FluidModifierData *mmd)
 
 void MANTA::initFractions(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = fluid_alloc_fractions + fluid_with_fractions;
-  std::string finalString = parseScript(tmpString, mmd);
+  vector<string> pythonCommands;
+  string tmpString = fluid_alloc_fractions + fluid_with_fractions;
+  string finalString = parseScript(tmpString, mmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -470,9 +479,9 @@ void MANTA::initFractions(FluidModifierData *mmd)
 void MANTA::initInVelocity(FluidModifierData *mmd)
 {
   if (!mInVelocityX) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = fluid_alloc_invel + fluid_with_invel;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = fluid_alloc_invel + fluid_with_invel;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -483,9 +492,9 @@ void MANTA::initInVelocity(FluidModifierData *mmd)
 void MANTA::initOutflow(FluidModifierData *mmd)
 {
   if (!mPhiOutIn) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = fluid_alloc_outflow + fluid_with_outflow;
-    std::string finalString = parseScript(tmpString, mmd);
+    vector<string> pythonCommands;
+    string tmpString = fluid_alloc_outflow + fluid_with_outflow;
+    string finalString = parseScript(tmpString, mmd);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -495,9 +504,9 @@ void MANTA::initOutflow(FluidModifierData *mmd)
 
 void MANTA::initSndParts(FluidModifierData *mmd)
 {
-  std::vector<std::string> pythonCommands;
-  std::string tmpString = fluid_variables_particles + fluid_solver_particles;
-  std::string finalString = parseScript(tmpString, mmd);
+  vector<string> pythonCommands;
+  string tmpString = fluid_variables_particles + fluid_solver_particles;
+  string finalString = parseScript(tmpString, mmd);
   pythonCommands.push_back(finalString);
 
   runPythonString(pythonCommands);
@@ -506,11 +515,11 @@ void MANTA::initSndParts(FluidModifierData *mmd)
 void MANTA::initLiquidSndParts(FluidModifierData *mmd)
 {
   if (!mSndParticleData) {
-    std::vector<std::string> pythonCommands;
-    std::string tmpString = liquid_alloc_particles + liquid_variables_particles +
-                            liquid_step_particles + fluid_with_sndparts + liquid_load_particles +
-                            liquid_save_particles;
-    std::string finalString = parseScript(tmpString, mmd);
+    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);
     pythonCommands.push_back(finalString);
 
     runPythonString(pythonCommands);
@@ -520,12 +529,12 @@ void MANTA::initLiquidSndParts(FluidModifierData *mmd)
 MANTA::~MANTA()
 {
   if (with_debug)
-    std::cout << "~FLUID: " << mCurrentID << " with res(" << mResX << ", " << mResY << ", "
-              << mResZ << ")" << std::endl;
+    cout << "~FLUID: " << mCurrentID << " with res(" << mResX << ", " << mResY << ", " << mResZ
+         << ")" << endl;
 
   // Destruction string for Python
-  std::string tmpString = "";
-  std::vector<std::string> pythonCommands;
+  string tmpString = "";
+  vector<string> pythonCommands;
   bool result = false;
 
   tmpString += manta_import;
@@ -535,7 +544,7 @@ MANTA::~MANTA()
   initializeRNAMap();
 
   // Leave out mmd argument in parseScript since only looking up IDs
-  std::string finalString = parseScript(tmpString);
+  string finalString = parseScript(tmpString);
   pythonCommands.push_back(finalString);
   result = runPythonString(pythonCommands);
 
@@ -543,12 +552,12 @@ MANTA::~MANTA()
   (void)result;  // not needed in release
 }
 
-bool MANTA::runPythonString(std::vector<std::string> commands)
+bool MANTA::runPythonString(vector<string> commands)
 {
   int success = -1;
   PyGILState_STATE gilstate = PyGILState_Ensure();
-  for (std::vector<std::string>::iterator it = commands.begin(); it != commands.end(); ++it) {
-    std::string command = *it;
+  for (vector<string>::iterator it = commands.begin(); it != commands.end(); ++it) {
+    string command = *it;
 
 #ifdef WIN32
     // special treatment for windows when running python code
@@ -573,10 +582,10 @@ bool MANTA::runPythonString(std::vector<std::string> commands)
 void MANTA::initializeMantaflow()
 {
   if (with_debug)
-    std::cout << "Fluid: Initializing Mantaflow framework" << std::endl;
+    cout << "Fluid: Initializing Mantaflow framework" << endl;
 
-  std::string filename = "manta_scene_" + std::to_string(mCurrentID) + ".py";
-  std::vector<std::string> fill = std::vector<std::string>();
+  string filename = "manta_scene_" + to_string(mCurrentID) + ".py";
+  vector<string> fill = vector<string>();
 
   // Initialize extension classes and wrappers
   srand(0);
@@ -588,17 +597,17 @@ void MANTA::initializeMantaflow()
 void MANTA::terminateMantaflow()
 {
   if (with_debug)
-    std::cout << "Fluid: Releasing Mantaflow framework" << std::endl;
+    cout << "Fluid: Releasing Mantaflow framework" << endl;
 
   PyGILState_STATE gilstate = PyGILState_Ensure();
   Pb::finalize();  // Namespace from Mantaflow (registry)
   PyGILState_Release(gilstate);
 }
 
-static std::string getCacheFileEnding(char cache_format)
+static string getCacheFileEnding(char cache_format)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::getCacheFileEnding()" << std::endl;
+    cout << "MANTA::getCacheFileEnding()" << endl;
 
   switch (cache_format) {
     case FLUID_DOMAIN_FILE_UNI:
@@ -612,8 +621,8 @@ static std::string getCacheFileEnding(char cache_format)
     case FLUID_DOMAIN_FILE_OBJECT:
       return FLUID_DOMAIN_EXTENSION_OBJ;
     default:
-      std::cerr << "Fluid Error -- Could not find file extension. Using default file extension."
-                << std::endl;
+      cerr << "Fluid Error -- Could not find file extension. Using default file extension."
+           << endl;
       return FLUID_DOMAIN_EXTENSION_UNI;
   }
 }
@@ -621,13 +630,13 @@ static std::string getCacheFileEnding(char cache_format)
 void MANTA::initializeRNAMap(FluidModifierData *mmd)
 {
   if (with_debug)
-    std::cout << "MANTA::initializeRNAMap()" << std::endl;
+    cout << "MANTA::initializeRNAMap()" << endl;
 
-  mRNAMap["ID"] = std::to_string(mCurrentID);
+  mRNAMap["ID"] = to_string(mCurrentID);
 
   if (!mmd) {
     if (with_debug)
-      std::cout << "No modifier data given in RNA map setup - returning early" << std::endl;
+      cout << "No modifier data given in RNA map setup - returning early" << endl;
     return;
   }
 
@@ -638,7 +647,7 @@ void MANTA::initializeRNAMap(FluidModifierData *mmd)
                     FLUID_DOMAIN_BORDER_LEFT | FLUID_DOMAIN_BORDER_RIGHT |
                     FLUID_DOMAIN_BORDER_BOTTOM | FLUID_DOMAIN_BORDER_TOP);
 
-  std::string borderCollisions = "";
+  string borderCollisions = "";
   if ((mds->border_collisions & FLUID_DOMAIN_BORDER_LEFT) == 0)
     borderCollisions += "x";
   if ((mds->border_collisions & FLUID_DOMAIN_BORDER_RIGHT) == 0)
@@ -652,13 +661,13 @@ void MANTA::initializeRNAMap(FluidModifierData *mmd)
   if ((mds->border_collisions & FLUID_DOMAIN_BORDER_TOP) == 0)
     borderCollisions += "Z";
 
-  std::string simulationMethod = "";
+  string simulationMethod = "";
   if (mds->simulation_method & FLUID_DOMAIN_METHOD_FLIP)
     simulationMethod += "'FLIP'";
   else if (mds->simulation_method & FLUID_DOMAIN_METHOD_APIC)
     simulationMethod += "'APIC'";
 
-  std::string particleTypesStr = "";
+  string particleTypesStr = "";
   if (mds->particle_type & FLUID_DOMAIN_PARTICLE_SPRAY)
     particleTypesStr += "PtypeSpray";
   if (mds->particle_type & FLUID_DOMAIN_PARTICLE_BUBBLE) {
@@ -682,172 +691,164 @@ void MANTA::initializeRNAMap(FluidModifierData *mmd)
   int particleTypes = (FLUID_DOMAIN_PARTICLE_SPRAY | FLUID_DOMAIN_PARTICLE_BUBBLE |
                        FLUID_DOMAIN_PARTICLE_FOAM | FLUID_DOMAIN_PARTICLE_TRACER);
 
-  std::string cacheDirectory(mds->cache_directory);
-
-  mRNAMap["USING_SMOKE"] = std::to_string((mds->type == FLUID_DOMAIN_TYPE_GAS) != 0);
-  mRNAMap["USING_LIQUID"] = std::to_string((mds->type == FLUID_DOMAIN_TYPE_LIQUID) != 0);
-  mRNAMap["USING_COLORS"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) != 0);
-  mRNAMap["USING_HEAT"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) != 0);
-  mRNAMap["USING_FIRE"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) != 0);
-  mRNAMap["USING_NOISE"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_NOISE) != 0);
-  mRNAMap["USING_OBSTACLE"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE) !=
-                                             0);
-  mRNAMap["USING_GUIDING"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_GUIDE) != 0);
-  mRNAMap["USING_INVEL"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL) != 0);
-  mRNAMap["USING_OUTFLOW"] = std::to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW) !=
-                                            0);
-  mRNAMap["USING_LOG_DISSOLVE"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG) !=
-                                                 0);
-  mRNAMap["USING_DISSOLVE"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_DISSOLVE) != 0);
-  mRNAMap["SOLVER_DIM"] = std::to_string(mds->solver_res);
-  mRNAMap["DO_OPEN"] = std::to_string(((mds->border_collisions & openDomain) == openDomain) == 0);
+  string cacheDirectory(mds->cache_directory);
+
+  mRNAMap["USING_SMOKE"] = to_string((mds->type == FLUID_DOMAIN_TYPE_GAS) != 0);
+  mRNAMap["USING_LIQUID"] = to_string((mds->type == FLUID_DOMAIN_TYPE_LIQUID) != 0);
+  mRNAMap["USING_COLORS"] = to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_COLORS) != 0);
+  mRNAMap["USING_HEAT"] = to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_HEAT) != 0);
+  mRNAMap["USING_FIRE"] = to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_FIRE) != 0);
+  mRNAMap["USING_NOISE"] = to_string((mds->flags & FLUID_DOMAIN_USE_NOISE) != 0);
+  mRNAMap["USING_OBSTACLE"] = to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_OBSTACLE) != 0);
+  mRNAMap["USING_GUIDING"] = to_string((mds->flags & FLUID_DOMAIN_USE_GUIDE) != 0);
+  mRNAMap["USING_INVEL"] = to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL) != 0);
+  mRNAMap["USING_OUTFLOW"] = to_string((mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW) != 0);
+  mRNAMap["USING_LOG_DISSOLVE"] = to_string((mds->flags & FLUID_DOMAIN_USE_DISSOLVE_LOG) != 0);
+  mRNAMap["USING_DISSOLVE"] = to_string((mds->flags & FLUID_DOMAIN_USE_DISSOLVE) != 0);
+  mRNAMap["SOLVER_DIM"] = to_string(mds->solver_res);
+  mRNAMap["DO_OPEN"] = to_string(((mds->border_collisions & openDomain) == openDomain) == 0);
   mRNAMap["BOUND_CONDITIONS"] = borderCollisions;
-  mRNAMap["BOUNDARY_WIDTH"] = std::to_string(mds->boundary_width);
-  mRNAMap["RES"] = std::to_string(mMaxRes);
-  mRNAMap["RESX"] = std::to_string(mResX);
-  mRNAMap["RESY"] = (is2D) ? std::to_string(mResZ) : std::to_string(mResY);
-  mRNAMap["RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZ);
-  mRNAMap["TIME_SCALE"] = std::to_string(mds->time_scale);
-  mRNAMap["FRAME_LENGTH"] = std::to_string(mds->frame_length);
-  mRNAMap["CFL"] = std::to_string(mds->cfl_condition);
-  mRNAMap["DT"] = std::to_string(mds->dt);
-  mRNAMap["TIMESTEPS_MIN"] = std::to_string(mds->timesteps_minimum);
-  mRNAMap["TIMESTEPS_MAX"] = std::to_string(mds->timesteps_maximum);
-  mRNAMap["TIME_TOTAL"] = std::to_string(mds->time_total);
-  mRNAMap["TIME_PER_FRAME"] = std::to_string(mds->time_per_frame);
-  mRNAMap["VORTICITY"] = std::to_string(mds->vorticity);
-  mRNAMap["FLAME_VORTICITY"] = std::to_string(mds->flame_vorticity);
-  mRNAMap["NOISE_SCALE"] = std::to_string(mds->noise_scale);
-  mRNAMap["MESH_SCALE"] = std::to_string(mds->mesh_scale);
-  mRNAMap["PARTICLE_SCALE"] = std::to_string(mds->particle_scale);
-  mRNAMap["NOISE_RESX"] = std::to_string(mResXNoise);
-  mRNAMap["NOISE_RESY"] = (is2D) ? std::to_string(mResZNoise) : std::to_string(mResYNoise);
-  mRNAMap["NOISE_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZNoise);
-  mRNAMap["MESH_RESX"] = std::to_string(mResXMesh);
-  mRNAMap["MESH_RESY"] = (is2D) ? std::to_string(mResZMesh) : std::to_string(mResYMesh);
-  mRNAMap["MESH_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZMesh);
-  mRNAMap["PARTICLE_RESX"] = std::to_string(mResXParticle);
-  mRNAMap["PARTICLE_RESY"] = (is2D) ? std::to_string(mResZParticle) :
-                                      std::to_string(mResYParticle);
-  mRNAMap["PARTICLE_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResZParticle);
-  mRNAMap["GUIDING_RESX"] = std::to_string(mResGuiding[0]);
-  mRNAMap["GUIDING_RESY"] = (is2D) ? std::to_string(mResGuiding[2]) :
-                                     std::to_string(mResGuiding[1]);
-  mRNAMap["GUIDING_RESZ"] = (is2D) ? std::to_string(1) : std::to_string(mResGuiding[2]);
-  mRNAMap["MIN_RESX"] = std::to_string(mds->res_min[0]);
-  mRNAMap["MIN_RESY"] = std::to_string(mds->res_min[1]);
-  mRNAMap["MIN_RESZ"] = std::to_string(mds->res_min[2]);
-  mRNAMap["BASE_RESX"] = std::to_string(mds->base_res[0]);
-  mRNAMap["BASE_RESY"] = std::to_string(mds->base_res[1]);
-  mRNAMap["BASE_RESZ"] = std::to_string(mds->base_res[2]);
-  mRNAMap["WLT_STR"] = std::to_string(mds->noise_strength);
-  mRNAMap["NOISE_POSSCALE"] = std::to_string(mds->noise_pos_scale);
-  mRNAMap["NOISE_TIMEANIM"] = std::to_string(mds->noise_time_anim);
-  mRNAMap["COLOR_R"] = std::to_string(mds->active_color[0]);
-  mRNAMap["COLOR_G"] = std::to_string(mds->active_color[1]);
-  mRNAMap["COLOR_B"] = std::to_string(mds->active_color[2]);
-  mRNAMap["BUOYANCY_ALPHA"] = std::to_string(mds->alpha);
-  mRNAMap["BUOYANCY_BETA"] = std::to_string(mds->beta);
-  mRNAMap["DISSOLVE_SPEED"] = std::to_string(mds->diss_speed);
-  mRNAMap["BURNING_RATE"] = std::to_string(mds->burning_rate);
-  mRNAMap["FLAME_SMOKE"] = std::to_string(mds->flame_smoke);
-  mRNAMap["IGNITION_TEMP"] = std::to_string(mds->flame_ignition);
-  mRNAMap["MAX_TEMP"] = std::to_string(mds->flame_max_temp);
-  mRNAMap["FLAME_SMOKE_COLOR_X"] = std::to_string(mds->flame_smoke_color[0]);
-  mRNAMap["FLAME_SMOKE_COLOR_Y"] = std::to_string(mds->flame_smoke_color[1]);
-  mRNAMap["FLAME_SMOKE_COLOR_Z"] = std::to_string(mds->flame_smoke_color[2]);
-  mRNAMap["CURRENT_FRAME"] = std::to_string(mmd->time);
-  mRNAMap["START_FRAME"] = std::to_string(mds->cache_frame_start);
-  mRNAMap["END_FRAME"] = std::to_string(mds->cache_frame_end);
-  mRNAMap["CACHE_DATA_FORMAT"] = std::to_string(mds->cache_data_format);
-  mRNAMap["CACHE_MESH_FORMAT"] = std::to_string(mds->cache_mesh_format);
-  mRNAMap["CACHE_NOISE_FORMAT"] = std::to_string(mds->cache_noise_format);
-  mRNAMap["CACHE_PARTICLE_FORMAT"] = std::to_string(mds->cache_particle_format);
+  mRNAMap["BOUNDARY_WIDTH"] = to_string(mds->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["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);
+  mRNAMap["MESH_RESX"] = to_string(mResXMesh);
+  mRNAMap["MESH_RESY"] = (is2D) ? to_string(mResZMesh) : to_string(mResYMesh);
+  mRNAMap["MESH_RESZ"] = (is2D) ? to_string(1) : to_string(mResZMesh);
+  mRNAMap["PARTICLE_RESX"] = to_string(mResXParticle);
+  mRNAMap["PARTICLE_RESY"] = (is2D) ? to_string(mResZParticle) : to_string(mResYParticle);
+  mRNAMap["PARTICLE_RESZ"] = (is2D) ? to_string(1) : to_string(mResZParticle);
+  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(mmd->time);
+  mRNAMap["START_FRAME"] = to_string(mds->cache_frame_start);
+  mRNAMap["END_FRAME"] = to_string(mds->cache_frame_end);
+  mRNAMap["CACHE_DATA_FORMAT"] = to_string(mds->cache_data_format);
+  mRNAMap["CACHE_MESH_FORMAT"] = to_string(mds->cache_mesh_format);
+  mRNAMap["CACHE_NOISE_FORMAT"] = to_string(mds->cache_noise_format);
+  mRNAMap["CACHE_PARTICLE_FORMAT"] = to_string(mds->cache_particle_format);
   mRNAMap["SIMULATION_METHOD"] = simulationMethod;
-  mRNAMap["FLIP_RATIO"] = std::to_string(mds->flip_ratio);
-  mRNAMap["PARTICLE_RANDOMNESS"] = std::to_string(mds->particle_randomness);
-  mRNAMap["PARTICLE_NUMBER"] = std::to_string(mds->particle_number);
-  mRNAMap["PARTICLE_MINIMUM"] = std::to_string(mds->particle_minimum);
-  mRNAMap["PARTICLE_MAXIMUM"] = std::to_string(mds->particle_maximum);
-  mRNAMap["PARTICLE_RADIUS"] = std::to_string(mds->particle_radius);
-  mRNAMap["FRACTIONS_THRESHOLD"] = std::to_string(mds->fractions_threshold);
-  mRNAMap["MESH_CONCAVE_UPPER"] = std::to_string(mds->mesh_concave_upper);
-  mRNAMap["MESH_CONCAVE_LOWER"] = std::to_string(mds->mesh_concave_lower);
-  mRNAMap["MESH_PARTICLE_RADIUS"] = std::to_string(mds->mesh_particle_radius);
-  mRNAMap["MESH_SMOOTHEN_POS"] = std::to_string(mds->mesh_smoothen_pos);
-  mRNAMap["MESH_SMOOTHEN_NEG"] = std::to_string(mds->mesh_smoothen_neg);
-  mRNAMap["USING_MESH"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_MESH) != 0);
-  mRNAMap["USING_IMPROVED_MESH"] = std::to_string(
-      (mds->mesh_generator == FLUID_DOMAIN_MESH_IMPROVED) != 0);
-  mRNAMap["PARTICLE_BAND_WIDTH"] = std::to_string(mds->particle_band_width);
-  mRNAMap["SNDPARTICLE_TAU_MIN_WC"] = std::to_string(mds->sndparticle_tau_min_wc);
-  mRNAMap["SNDPARTICLE_TAU_MAX_WC"] = std::to_string(mds->sndparticle_tau_max_wc);
-  mRNAMap["SNDPARTICLE_TAU_MIN_TA"] = std::to_string(mds->sndparticle_tau_min_ta);
-  mRNAMap["SNDPARTICLE_TAU_MAX_TA"] = std::to_string(mds->sndparticle_tau_max_ta);
-  mRNAMap["SNDPARTICLE_TAU_MIN_K"] = std::to_string(mds->sndparticle_tau_min_k);
-  mRNAMap["SNDPARTICLE_TAU_MAX_K"] = std::to_string(mds->sndparticle_tau_max_k);
-  mRNAMap["SNDPARTICLE_K_WC"] = std::to_string(mds->sndparticle_k_wc);
-  mRNAMap["SNDPARTICLE_K_TA"] = std::to_string(mds->sndparticle_k_ta);
-  mRNAMap["SNDPARTICLE_K_B"] = std::to_string(mds->sndparticle_k_b);
-  mRNAMap["SNDPARTICLE_K_D"] = std::to_string(mds->sndparticle_k_d);
-  mRNAMap["SNDPARTICLE_L_MIN"] = std::to_string(mds->sndparticle_l_min);
-  mRNAMap["SNDPARTICLE_L_MAX"] = std::to_string(mds->sndparticle_l_max);
-  mRNAMap["SNDPARTICLE_BOUNDARY_DELETE"] = std::to_string(
+  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["USING_MESH"] = to_string((mds->flags & FLUID_DOMAIN_USE_MESH) != 0);
+  mRNAMap["USING_IMPROVED_MESH"] = to_string((mds->mesh_generator == FLUID_DOMAIN_MESH_IMPROVED) !=
+                                             0);
+  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_BOUNDARY_DELETE"] = to_string(
       (mds->sndparticle_boundary == SNDPARTICLE_BOUNDARY_DELETE) != 0);
-  mRNAMap["SNDPARTICLE_BOUNDARY_PUSHOUT"] = std::to_string(
+  mRNAMap["SNDPARTICLE_BOUNDARY_PUSHOUT"] = to_string(
       (mds->sndparticle_boundary == SNDPARTICLE_BOUNDARY_PUSHOUT) != 0);
-  mRNAMap["SNDPARTICLE_POTENTIAL_RADIUS"] = std::to_string(mds->sndparticle_potential_radius);
-  mRNAMap["SNDPARTICLE_UPDATE_RADIUS"] = std::to_string(mds->sndparticle_update_radius);
-  mRNAMap["LIQUID_SURFACE_TENSION"] = std::to_string(mds->surface_tension);
-  mRNAMap["FLUID_VISCOSITY"] = std::to_string(mds->viscosity_base *
-                                              pow(10.0f, -mds->viscosity_exponent));
-  mRNAMap["FLUID_DOMAIN_SIZE"] = std::to_string(
+  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["FLUID_VISCOSITY"] = to_string(mds->viscosity_base *
+                                         pow(10.0f, -mds->viscosity_exponent));
+  mRNAMap["FLUID_DOMAIN_SIZE"] = to_string(
       MAX3(mds->global_size[0], mds->global_size[1], mds->global_size[2]));
   mRNAMap["SNDPARTICLE_TYPES"] = particleTypesStr;
-  mRNAMap["USING_SNDPARTS"] = std::to_string((mds->particle_type & particleTypes) != 0);
-  mRNAMap["GUIDING_ALPHA"] = std::to_string(mds->guide_alpha);
-  mRNAMap["GUIDING_BETA"] = std::to_string(mds->guide_beta);
-  mRNAMap["GUIDING_FACTOR"] = std::to_string(mds->guide_vel_factor);
-  mRNAMap["GRAVITY_X"] = std::to_string(mds->gravity[0]);
-  mRNAMap["GRAVITY_Y"] = std::to_string(mds->gravity[1]);
-  mRNAMap["GRAVITY_Z"] = std::to_string(mds->gravity[2]);
+  mRNAMap["USING_SNDPARTS"] = to_string((mds->particle_type & particleTypes) != 0);
+  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["CACHE_DIR"] = cacheDirectory;
-  mRNAMap["CACHE_RESUMABLE"] = std::to_string((mds->cache_type == FLUID_DOMAIN_CACHE_FINAL) == 0);
-  mRNAMap["USING_ADAPTIVETIME"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME) !=
-                                                 0);
-  mRNAMap["USING_SPEEDVECTORS"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) !=
-                                                 0);
-  mRNAMap["USING_FRACTIONS"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_FRACTIONS) != 0);
-  mRNAMap["DELETE_IN_OBSTACLE"] = std::to_string((mds->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE) !=
-                                                 0);
-  mRNAMap["USING_DIFFUSION"] = std::to_string((mds->flags & FLUID_DOMAIN_USE_DIFFUSION) != 0);
+  mRNAMap["CACHE_RESUMABLE"] = to_string((mds->cache_type == FLUID_DOMAIN_CACHE_FINAL) == 0);
+  mRNAMap["USING_ADAPTIVETIME"] = to_string((mds->flags & FLUID_DOMAIN_USE_ADAPTIVE_TIME) != 0);
+  mRNAMap["USING_SPEEDVECTORS"] = to_string((mds->flags & FLUID_DOMAIN_USE_SPEED_VECTORS) != 0);
+  mRNAMap["USING_FRACTIONS"] = to_string((mds->flags & FLUID_DOMAIN_USE_FRACTIONS) != 0);
+  mRNAMap["DELETE_IN_OBSTACLE"] = to_string((mds->flags & FLUID_DOMAIN_DELETE_IN_OBSTACLE) != 0);
+  mRNAMap["USING_DIFFUSION"] = to_string((mds->flags & FLUID_DOMAIN_USE_DIFFUSION) != 0);
 }
 
-std::string MANTA::getRealValue(const std::string &varName)
+string MANTA::getRealValue(const string &varName)
 {
   if (with_debug)
-    std::cout << "MANTA::getRealValue()" << std::endl;
+    cout << "MANTA::getRealValue()" << endl;
 
-  std::unordered_map<std::string, std::string>::iterator it;
+  unordered_map<string, string>::iterator it;
   it = mRNAMap.find(varName);
 
   if (it == mRNAMap.end()) {
-    std::cerr << "Fluid Error -- variable " << varName << " not found in RNA map " << it->second
-              << std::endl;
+    cerr << "Fluid Error -- variable " << varName << " not found in RNA map " << it->second
+         << endl;
     return "";
   }
   if (with_debug) {
-    std::cout << "Found variable " << varName << " with value " << it->second << std::endl;
+    cout << "Found variable " << varName << " with value " << it->second << endl;
   }
 
   return it->second;
 }
 
-std::string MANTA::parseLine(const std::string &line)
+string MANTA::parseLine(const string &line)
 {
   if (line.size() == 0)
     return "";
-  std::string res = "";
+  string res = "";
   int currPos = 0, start_del = 0, end_del = -1;
   bool readingVar = false;
   const char delimiter = '$';
@@ -868,14 +869,14 @@ std::string MANTA::parseLine(const std::string &line)
   return res;
 }
 
-std::string MANTA::parseScript(const std::string &setup_string, FluidModifierData *mmd)
+string MANTA::parseScript(const string &setup_string, FluidModifierData *mmd)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::parseScript()" << std::endl;
+    cout << "MANTA::parseScript()" << endl;
 
-  std::istringstream f(setup_string);
-  std::ostringstream res;
-  std::string line = "";
+  istringstream f(setup_string);
+  ostringstream res;
+  string line = "";
 
   // Update RNA map if modifier data is handed over
   if (mmd) {
@@ -890,7 +891,7 @@ std::string MANTA::parseScript(const std::string &setup_string, FluidModifierDat
 bool MANTA::updateFlipStructures(FluidModifierData *mmd, int framenr)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::updateFlipStructures()" << std::endl;
+    cout << "MANTA::updateFlipStructures()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   mFlipFromFile = false;
@@ -910,8 +911,8 @@ bool MANTA::updateFlipStructures(FluidModifierData *mmd, int framenr)
   mFlipParticleData->clear();
   mFlipParticleVelocity->clear();
 
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
-  std::string file = getFile(
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string file = getFile(
       mmd, FLUID_DOMAIN_DIR_DATA, FLUID_DOMAIN_FILE_PP, pformat.c_str(), framenr);
 
   expected += 1;
@@ -933,7 +934,7 @@ bool MANTA::updateFlipStructures(FluidModifierData *mmd, int framenr)
 bool MANTA::updateMeshStructures(FluidModifierData *mmd, int framenr)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::updateMeshStructures()" << std::endl;
+    cout << "MANTA::updateMeshStructures()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   mMeshFromFile = false;
@@ -956,9 +957,9 @@ bool MANTA::updateMeshStructures(FluidModifierData *mmd, int framenr)
   if (mMeshVelocities)
     mMeshVelocities->clear();
 
-  std::string mformat = getCacheFileEnding(mds->cache_mesh_format);
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string file = getFile(mmd, FLUID_DOMAIN_DIR_MESH, FLUID_DOMAIN_FILE_MESH, mformat, framenr);
+  string mformat = getCacheFileEnding(mds->cache_mesh_format);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string file = getFile(mmd, FLUID_DOMAIN_DIR_MESH, FLUID_DOMAIN_FILE_MESH, mformat, framenr);
 
   expected += 1;
   if (BLI_exists(file.c_str())) {
@@ -981,7 +982,7 @@ bool MANTA::updateMeshStructures(FluidModifierData *mmd, int framenr)
 bool MANTA::updateParticleStructures(FluidModifierData *mmd, int framenr)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::updateParticleStructures()" << std::endl;
+    cout << "MANTA::updateParticleStructures()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   mParticlesFromFile = false;
@@ -1002,8 +1003,8 @@ bool MANTA::updateParticleStructures(FluidModifierData *mmd, int framenr)
   mSndParticleVelocity->clear();
   mSndParticleLife->clear();
 
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
-  std::string file = getFile(
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string file = getFile(
       mmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_DOMAIN_FILE_PPSND, pformat, framenr);
 
   expected += 1;
@@ -1032,7 +1033,7 @@ bool MANTA::updateParticleStructures(FluidModifierData *mmd, int framenr)
 bool MANTA::updateSmokeStructures(FluidModifierData *mmd, int framenr)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::updateGridStructures()" << std::endl;
+    cout << "MANTA::updateGridStructures()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   mSmokeFromFile = false;
@@ -1045,9 +1046,8 @@ bool MANTA::updateSmokeStructures(FluidModifierData *mmd, int framenr)
   int result = 0;
   int expected = 0; /* Expected number of read successes for this frame. */
 
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string file = getFile(
-      mmd, FLUID_DOMAIN_DIR_DATA, FLUID_DOMAIN_FILE_DENSITY, dformat, framenr);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string file = getFile(mmd, FLUID_DOMAIN_DIR_DATA, FLUID_DOMAIN_FILE_DENSITY, dformat, framenr);
 
   expected += 1;
   if (BLI_exists(file.c_str())) {
@@ -1123,7 +1123,7 @@ bool MANTA::updateSmokeStructures(FluidModifierData *mmd, int framenr)
 bool MANTA::updateNoiseStructures(FluidModifierData *mmd, int framenr)
 {
   if (MANTA::with_debug)
-    std::cout << "MANTA::updateNoiseStructures()" << std::endl;
+    cout << "MANTA::updateNoiseStructures()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   mNoiseFromFile = false;
@@ -1136,9 +1136,9 @@ bool MANTA::updateNoiseStructures(FluidModifierData *mmd, int framenr)
   int result = 0;
   int expected = 0; /* Expected number of read successes for this frame. */
 
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string nformat = getCacheFileEnding(mds->cache_noise_format);
-  std::string file = getFile(
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string nformat = getCacheFileEnding(mds->cache_noise_format);
+  string file = getFile(
       mmd, FLUID_DOMAIN_DIR_NOISE, FLUID_DOMAIN_FILE_DENSITYNOISE, nformat, framenr);
 
   expected += 1;
@@ -1204,10 +1204,10 @@ bool MANTA::updateNoiseStructures(FluidModifierData *mmd, int framenr)
 }
 
 /* Dirty hack: Needed to format paths from python code that is run via PyRun_SimpleString */
-static std::string escapeSlashes(std::string const &s)
+static string escapeSlashes(string const &s)
 {
-  std::string result = "";
-  for (std::string::const_iterator i = s.begin(), end = s.end(); i != end; ++i) {
+  string result = "";
+  for (string::const_iterator i = s.begin(), end = s.end(); i != end; ++i) {
     unsigned char c = *i;
     if (c == '\\')
       result += "\\\\";
@@ -1220,21 +1220,20 @@ static std::string escapeSlashes(std::string const &s)
 bool MANTA::writeConfiguration(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::writeConfiguration()" << std::endl;
+    cout << "MANTA::writeConfiguration()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_CONFIG);
-  std::string format = FLUID_DOMAIN_EXTENSION_UNI;
-  std::string file = getFile(
-      mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_DOMAIN_FILE_CONFIG, format, framenr);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_CONFIG);
+  string format = FLUID_DOMAIN_EXTENSION_UNI;
+  string file = getFile(mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_DOMAIN_FILE_CONFIG, format, framenr);
 
   /* Create 'config' subdir if it does not exist already. */
   BLI_dir_create_recursive(directory.c_str());
 
   gzFile gzf = (gzFile)BLI_gzopen(file.c_str(), "wb1");  // do some compression
   if (!gzf) {
-    std::cerr << "Fluid Error -- Cannot open file " << file << std::endl;
+    cerr << "Fluid Error -- Cannot open file " << file << endl;
     return false;
   }
 
@@ -1259,18 +1258,18 @@ bool MANTA::writeConfiguration(FluidModifierData *mmd, int framenr)
 bool MANTA::writeData(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::writeData()" << std::endl;
+    cout << "MANTA::writeData()" << endl;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_DATA);
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_DATA);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   ss.str("");
   ss << "fluid_save_data_" << mCurrentID << "('" << escapeSlashes(directory) << "', " << framenr
@@ -1295,17 +1294,17 @@ bool MANTA::writeData(FluidModifierData *mmd, int framenr)
 bool MANTA::writeNoise(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::writeNoise()" << std::endl;
+    cout << "MANTA::writeNoise()" << endl;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_NOISE);
-  std::string nformat = getCacheFileEnding(mds->cache_noise_format);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_NOISE);
+  string nformat = getCacheFileEnding(mds->cache_noise_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   if (mUsingSmoke && mUsingNoise) {
     ss.str("");
@@ -1319,22 +1318,21 @@ bool MANTA::writeNoise(FluidModifierData *mmd, int framenr)
 bool MANTA::readConfiguration(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::readConfiguration()" << std::endl;
+    cout << "MANTA::readConfiguration()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
   float dummy;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_CONFIG);
-  std::string format = FLUID_DOMAIN_EXTENSION_UNI;
-  std::string file = getFile(
-      mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_DOMAIN_FILE_CONFIG, format, framenr);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_CONFIG);
+  string format = FLUID_DOMAIN_EXTENSION_UNI;
+  string file = getFile(mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_DOMAIN_FILE_CONFIG, format, framenr);
 
   if (!hasConfig(mmd, framenr))
     return false;
 
   gzFile gzf = (gzFile)BLI_gzopen(file.c_str(), "rb");  // do some compression
   if (!gzf) {
-    std::cerr << "Fluid Error -- Cannot open file " << file << std::endl;
+    cerr << "Fluid Error -- Cannot open file " << file << endl;
     return false;
   }
 
@@ -1360,22 +1358,22 @@ bool MANTA::readConfiguration(FluidModifierData *mmd, int framenr)
 bool MANTA::readData(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::readData()" << std::endl;
+    cout << "MANTA::readData()" << endl;
 
   if (!mUsingSmoke && !mUsingLiquid)
     return false;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
   bool result = true;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_DATA);
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_DATA);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   /* Sanity check: Are cache files present? */
   if (!hasData(mmd, framenr))
@@ -1406,20 +1404,20 @@ bool MANTA::readData(FluidModifierData *mmd, int framenr)
 bool MANTA::readNoise(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::readNoise()" << std::endl;
+    cout << "MANTA::readNoise()" << endl;
 
   if (!mUsingSmoke || !mUsingNoise)
     return false;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_NOISE);
-  std::string nformat = getCacheFileEnding(mds->cache_noise_format);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_NOISE);
+  string nformat = getCacheFileEnding(mds->cache_noise_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   /* Sanity check: Are cache files present? */
   if (!hasNoise(mmd, framenr))
@@ -1439,18 +1437,18 @@ bool MANTA::readNoise(FluidModifierData *mmd, int framenr)
 bool MANTA::readMesh(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::readMesh()" << std::endl;
+    cout << "MANTA::readMesh()" << endl;
 
   if (!mUsingLiquid || !mUsingMesh)
     return false;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_MESH);
-  std::string mformat = getCacheFileEnding(mds->cache_mesh_format);
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_MESH);
+  string mformat = getCacheFileEnding(mds->cache_mesh_format);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
 
   /* Sanity check: Are cache files present? */
   if (!hasMesh(mmd, framenr))
@@ -1477,22 +1475,22 @@ bool MANTA::readMesh(FluidModifierData *mmd, int framenr)
 bool MANTA::readParticles(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::readParticles()" << std::endl;
+    cout << "MANTA::readParticles()" << endl;
 
   if (!mUsingLiquid)
     return false;
   if (!mUsingDrops && !mUsingBubbles && !mUsingFloats && !mUsingTracers)
     return false;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
-  std::string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_PARTICLES);
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string directory = getDirectory(mmd, FLUID_DOMAIN_DIR_PARTICLES);
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   /* Sanity check: Are cache files present? */
   if (!hasParticles(mmd, framenr))
@@ -1509,7 +1507,7 @@ bool MANTA::readParticles(FluidModifierData *mmd, int framenr)
 bool MANTA::readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
 {
   if (with_debug)
-    std::cout << "MANTA::readGuiding()" << std::endl;
+    cout << "MANTA::readGuiding()" << endl;
 
   FluidDomainSettings *mds = mmd->domain;
 
@@ -1518,12 +1516,12 @@ bool MANTA::readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
   if (!mds)
     return false;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
 
-  std::string directory = (sourceDomain) ? getDirectory(mmd, FLUID_DOMAIN_DIR_DATA) :
-                                           getDirectory(mmd, FLUID_DOMAIN_DIR_GUIDE);
-  std::string gformat = getCacheFileEnding(mds->cache_data_format);
+  string directory = (sourceDomain) ? getDirectory(mmd, FLUID_DOMAIN_DIR_DATA) :
+                                      getDirectory(mmd, FLUID_DOMAIN_DIR_GUIDE);
+  string gformat = getCacheFileEnding(mds->cache_data_format);
 
   /* Sanity check: Are cache files present? */
   if (!hasGuiding(mmd, framenr, sourceDomain))
@@ -1547,20 +1545,20 @@ bool MANTA::readGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
 bool MANTA::bakeData(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::bakeData()" << std::endl;
+    cout << "MANTA::bakeData()" << endl;
 
-  std::string tmpString, finalString;
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  string tmpString, finalString;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
   char cacheDirData[FILE_MAX], cacheDirGuiding[FILE_MAX];
   cacheDirData[0] = '\0';
   cacheDirGuiding[0] = '\0';
 
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
-  std::string gformat = dformat;  // Use same data format for guiding format
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string gformat = dformat;  // Use same data format for guiding format
 
   BLI_path_join(
       cacheDirData, sizeof(cacheDirData), mds->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
@@ -1584,21 +1582,21 @@ bool MANTA::bakeData(FluidModifierData *mmd, int framenr)
 bool MANTA::bakeNoise(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::bakeNoise()" << std::endl;
+    cout << "MANTA::bakeNoise()" << endl;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
   char cacheDirData[FILE_MAX], cacheDirNoise[FILE_MAX];
   cacheDirData[0] = '\0';
   cacheDirNoise[0] = '\0';
 
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string nformat = getCacheFileEnding(mds->cache_noise_format);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string nformat = getCacheFileEnding(mds->cache_noise_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   BLI_path_join(
       cacheDirData, sizeof(cacheDirData), mds->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
@@ -1619,19 +1617,19 @@ bool MANTA::bakeNoise(FluidModifierData *mmd, int framenr)
 bool MANTA::bakeMesh(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::bakeMesh()" << std::endl;
+    cout << "MANTA::bakeMesh()" << endl;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
   char cacheDirData[FILE_MAX], cacheDirMesh[FILE_MAX];
   cacheDirData[0] = '\0';
   cacheDirMesh[0] = '\0';
 
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string mformat = getCacheFileEnding(mds->cache_mesh_format);
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string mformat = getCacheFileEnding(mds->cache_mesh_format);
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
 
   BLI_path_join(
       cacheDirData, sizeof(cacheDirData), mds->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
@@ -1652,21 +1650,21 @@ bool MANTA::bakeMesh(FluidModifierData *mmd, int framenr)
 bool MANTA::bakeParticles(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::bakeParticles()" << std::endl;
+    cout << "MANTA::bakeParticles()" << endl;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
   char cacheDirData[FILE_MAX], cacheDirParticles[FILE_MAX];
   cacheDirData[0] = '\0';
   cacheDirParticles[0] = '\0';
 
-  std::string dformat = getCacheFileEnding(mds->cache_data_format);
-  std::string pformat = getCacheFileEnding(mds->cache_particle_format);
+  string dformat = getCacheFileEnding(mds->cache_data_format);
+  string pformat = getCacheFileEnding(mds->cache_particle_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   BLI_path_join(
       cacheDirData, sizeof(cacheDirData), mds->cache_directory, FLUID_DOMAIN_DIR_DATA, nullptr);
@@ -1690,19 +1688,19 @@ bool MANTA::bakeParticles(FluidModifierData *mmd, int framenr)
 bool MANTA::bakeGuiding(FluidModifierData *mmd, int framenr)
 {
   if (with_debug)
-    std::cout << "MANTA::bakeGuiding()" << std::endl;
+    cout << "MANTA::bakeGuiding()" << endl;
 
-  std::ostringstream ss;
-  std::vector<std::string> pythonCommands;
+  ostringstream ss;
+  vector<string> pythonCommands;
   FluidDomainSettings *mds = mmd->domain;
 
   char cacheDirGuiding[FILE_MAX];
   cacheDirGuiding[0] = '\0';
 
-  std::string gformat = getCacheFileEnding(mds->cache_data_format);
+  string gformat = getCacheFileEnding(mds->cache_data_format);
 
   bool final_cache = (mds->cache_type == FLUID_DOMAIN_CACHE_FINAL);
-  std::string resumable_cache = (final_cache) ? "False" : "True";
+  string resumable_cache = (final_cache) ? "False" : "True";
 
   BLI_path_join(cacheDirGuiding,
                 sizeof(cacheDirGuiding),
@@ -1721,8 +1719,8 @@ bool MANTA::bakeGuiding(FluidModifierData *mmd, int framenr)
 
 bool MANTA::updateVariables(FluidModifierData *mmd)
 {
-  std::string tmpString, finalString;
-  std::vector<std::string> pythonCommands;
+  string tmpString, finalString;
+  vector<string> pythonCommands;
 
   tmpString += fluid_variables;
   if (mUsingSmoke)
@@ -1752,7 +1750,7 @@ bool MANTA::updateVariables(FluidModifierData *mmd)
 void MANTA::exportSmokeScript(FluidModifierData *mmd)
 {
   if (with_debug)
-    std::cout << "MANTA::exportSmokeScript()" << std::endl;
+    cout << "MANTA::exportSmokeScript()" << endl;
 
   char cacheDir[FILE_MAX] = "\0";
   char cacheDirScript[FILE_MAX] = "\0";
@@ -1777,7 +1775,7 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
   bool invel = mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL;
   bool outflow = mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW;
 
-  std::string manta_script;
+  string manta_script;
 
   // Libraries
   manta_script += header_libraries + manta_import;
@@ -1849,10 +1847,10 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
   manta_script += header_main + smoke_standalone + fluid_standalone;
 
   // Fill in missing variables in script
-  std::string final_script = MANTA::parseScript(manta_script, mmd);
+  string final_script = MANTA::parseScript(manta_script, mmd);
 
   // Write script
-  std::ofstream myfile;
+  ofstream myfile;
   myfile.open(cacheDirScript);
   myfile << final_script;
   myfile.close();
@@ -1861,7 +1859,7 @@ void MANTA::exportSmokeScript(FluidModifierData *mmd)
 void MANTA::exportLiquidScript(FluidModifierData *mmd)
 {
   if (with_debug)
-    std::cout << "MANTA::exportLiquidScript()" << std::endl;
+    cout << "MANTA::exportLiquidScript()" << endl;
 
   char cacheDir[FILE_MAX] = "\0";
   char cacheDirScript[FILE_MAX] = "\0";
@@ -1888,7 +1886,7 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
   bool invel = mds->active_fields & FLUID_DOMAIN_ACTIVE_INVEL;
   bool outflow = mds->active_fields & FLUID_DOMAIN_ACTIVE_OUTFLOW;
 
-  std::string manta_script;
+  string manta_script;
 
   // Libraries
   manta_script += header_libraries + manta_import;
@@ -1958,10 +1956,10 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
   manta_script += header_main + liquid_standalone + fluid_standalone;
 
   // Fill in missing variables in script
-  std::string final_script = MANTA::parseScript(manta_script, mmd);
+  string final_script = MANTA::parseScript(manta_script, mmd);
 
   // Write script
-  std::ofstream myfile;
+  ofstream myfile;
   myfile.open(cacheDirScript);
   myfile << final_script;
   myfile.close();
@@ -1974,14 +1972,12 @@ void MANTA::exportLiquidScript(FluidModifierData *mmd)
  *
  * Important! Return value: New reference or nullptr
  * Caller of this function needs to handle reference count of returned object. */
-static PyObject *callPythonFunction(std::string varName,
-                                    std::string functionName,
-                                    bool isAttribute = false)
+static PyObject *callPythonFunction(string varName, string functionName, bool isAttribute = false)
 {
   if ((varName == "") || (functionName == "")) {
     if (MANTA::with_debug)
-      std::cout << "Missing Python variable name and/or function name -- name is: " << varName
-                << ", function name is: " << functionName << std::endl;
+      cout << "Missing Python variable name and/or function name -- name is: " << varName
+           << ", function name is: " << functionName << endl;
     return nullptr;
   }
 
@@ -2035,8 +2031,8 @@ static void *pyObjectToPointer(PyObject *inputObject)
 
   Py_DECREF(inputObject);
 
-  std::string str(result);
-  std::istringstream in(str);
+  string str(result);
+  istringstream in(str);
   void *dataPointer = nullptr;
   in >> dataPointer;
 
@@ -2083,11 +2079,11 @@ static long pyObjectToLong(PyObject *inputObject)
 int MANTA::getFrame()
 {
   if (with_debug)
-    std::cout << "MANTA::getFrame()" << std::endl;
+    cout << "MANTA::getFrame()" << endl;
 
-  std::string func = "frame";
-  std::string id = std::to_string(mCurrentID);
-  std::string solver = "s" + id;
+  string func = "frame";
+  string id = to_string(mCurrentID);
+  string solver = "s" + id;
 
   return pyObjectToLong(callPythonFunction(solver, func, true));
 }
@@ -2095,11 +2091,11 @@ int MANTA::getFrame()
 float MANTA::getTimestep()
 {
   if (with_debug)
-    std::cout << "MANTA::getTimestep()" << std::endl;
+    cout << "MANTA::getTimestep()" << endl;
 
-  std::string func = "timestep";
-  std::string id = std::to_string(mCurrentID);
-  std::string solver = "s" + id;
+  string func = "timestep";
+  string id = to_string(mCurrentID);
+  string solver = "s" + id;
 
   return (float)pyObjectToDouble(callPythonFunction(solver, func, true));
 }
@@ -2113,10 +2109,10 @@ bool MANTA::needsRealloc(FluidModifierData *mmd)
 void MANTA::adaptTimestep()
 {
   if (with_debug)
-    std::cout << "MANTA::adaptTimestep()" << std::endl;
+    cout << "MANTA::adaptTimestep()" << endl;
 
-  std::vector<std::string> pythonCommands;
-  std::ostringstream ss;
+  vector<string> pythonCommands;
+  ostringstream ss;
 
   ss << "fluid_adapt_time_step_" << mCurrentID << "()";
   pythonCommands.push_back(ss.str());
@@ -2124,14 +2120,14 @@ void MANTA::adaptTimestep()
   runPythonString(pythonCommands);
 }
 
-bool MANTA::updateMeshFromFile(std::string filename)
+bool MANTA::updateMeshFromFile(string filename)
 {
-  std::string fname(filename);
-  std::string::size_type idx;
+  string fname(filename);
+  string::size_type idx;
 
   idx = fname.rfind('.');
-  if (idx != std::string::npos) {
-    std::string extension = fname.substr(idx + 1);
+  if (idx != string::npos) {
+    string extension = fname.substr(idx + 1);
 
     if (extension.compare("gz") == 0)
       return updateMeshFromBobj(filename);
@@ -2140,27 +2136,25 @@ bool MANTA::updateMeshFromFile(std::string filename)
     else if (extension.compare("uni") == 0)
       return updateMeshFromUni(filename);
     else
-      std::cerr << "Fluid Error -- updateMeshFromFile(): Invalid file extension in file: "
-                << filename << std::endl;
+      cerr << "Fluid Error -- updateMeshFromFile(): Invalid file extension in file: " << filename
+           << endl;
   }
   else {
-    std::cerr << "Fluid Error -- updateMeshFromFile(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromFile(): Unable to open file: " << filename << endl;
   }
   return false;
 }
 
-bool MANTA::updateMeshFromBobj(std::string filename)
+bool MANTA::updateMeshFromBobj(string filename)
 {
   if (with_debug)
-    std::cout << "MANTA::updateMeshFromBobj()" << std::endl;
+    cout << "MANTA::updateMeshFromBobj()" << endl;
 
   gzFile gzf;
 
   gzf = (gzFile)BLI_gzopen(filename.c_str(), "rb1");  // do some compression
   if (!gzf) {
-    std::cerr << "Fluid Error -- updateMeshFromBobj(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromBobj(): Unable to open file: " << filename << endl;
     return false;
   }
 
@@ -2169,15 +2163,14 @@ bool MANTA::updateMeshFromBobj(std::string filename)
   // Num vertices
   readBytes = gzread(gzf, &numBuffer, sizeof(int));
   if (!readBytes) {
-    std::cerr
-        << "Fluid Error -- updateMeshFromBobj(): Unable to read number of mesh vertices from "
-        << filename << std::endl;
+    cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read number of mesh vertices from "
+         << filename << endl;
     gzclose(gzf);
     return false;
   }
 
   if (with_debug)
-    std::cout << "read mesh , num verts: " << numBuffer << " , in file: " << filename << std::endl;
+    cout << "read mesh , num verts: " << numBuffer << " , in file: " << filename << endl;
 
   int numChunks = (int)(ceil((float)numBuffer / NODE_CHUNK));
   int readLen, readStart, readEnd, k;
@@ -2198,8 +2191,8 @@ bool MANTA::updateMeshFromBobj(std::string filename)
 
       readBytes = gzread(gzf, bufferVerts, readLen * sizeof(float) * 3);
       if (!readBytes) {
-        std::cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read mesh vertices from "
-                  << filename << std::endl;
+        cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read mesh vertices from "
+             << filename << endl;
         MEM_freeN(bufferVerts);
         gzclose(gzf);
         return false;
@@ -2211,7 +2204,7 @@ bool MANTA::updateMeshFromBobj(std::string filename)
       CLAMP(readEnd, 0, numBuffer);
 
       k = 0;
-      for (std::vector<MANTA::Node>::size_type j = readStart; j < readEnd; j++, k += 3) {
+      for (vector<MANTA::Node>::size_type j = readStart; j < readEnd; j++, k += 3) {
         mMeshNodes->at(j).pos[0] = bufferVerts[k];
         mMeshNodes->at(j).pos[1] = bufferVerts[k + 1];
         mMeshNodes->at(j).pos[2] = bufferVerts[k + 2];
@@ -2224,15 +2217,14 @@ bool MANTA::updateMeshFromBobj(std::string filename)
   // Num normals
   readBytes = gzread(gzf, &numBuffer, sizeof(int));
   if (!readBytes) {
-    std::cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read number of mesh normals from "
-              << filename << std::endl;
+    cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read number of mesh normals from "
+         << filename << endl;
     gzclose(gzf);
     return false;
   }
 
   if (with_debug)
-    std::cout << "read mesh , num normals : " << numBuffer << " , in file: " << filename
-              << std::endl;
+    cout << "read mesh , num normals : " << numBuffer << " , in file: " << filename << endl;
 
   if (numBuffer) {
     // Normals
@@ -2251,8 +2243,8 @@ bool MANTA::updateMeshFromBobj(std::string filename)
 
       readBytes = gzread(gzf, bufferNormals, readLen * sizeof(float) * 3);
       if (!readBytes) {
-        std::cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read mesh normals from "
-                  << filename << std::endl;
+        cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read mesh normals from "
+             << filename << endl;
         MEM_freeN(bufferNormals);
         gzclose(gzf);
         return false;
@@ -2264,7 +2256,7 @@ bool MANTA::updateMeshFromBobj(std::string filename)
       CLAMP(readEnd, 0, numBuffer);
 
       k = 0;
-      for (std::vector<MANTA::Node>::size_type j = readStart; j < readEnd; j++, k += 3) {
+      for (vector<MANTA::Node>::size_type j = readStart; j < readEnd; j++, k += 3) {
         mMeshNodes->at(j).normal[0] = bufferNormals[k];
         mMeshNodes->at(j).normal[1] = bufferNormals[k + 1];
         mMeshNodes->at(j).normal[2] = bufferNormals[k + 2];
@@ -2277,16 +2269,15 @@ bool MANTA::updateMeshFromBobj(std::string filename)
   // Num triangles
   readBytes = gzread(gzf, &numBuffer, sizeof(int));
   if (!readBytes) {
-    std::cerr
-        << "Fluid Error -- updateMeshFromBobj(): Unable to read number of mesh triangles from "
-        << filename << std::endl;
+    cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read number of mesh triangles from "
+         << filename << endl;
     gzclose(gzf);
     return false;
   }
 
   if (with_debug)
-    std::cout << "Fluid: Read mesh , num triangles : " << numBuffer << " , in file: " << filename
-              << std::endl;
+    cout << "Fluid: Read mesh , num triangles : " << numBuffer << " , in file: " << filename
+         << endl;
 
   numChunks = (int)(ceil((float)numBuffer / TRIANGLE_CHUNK));
 
@@ -2306,8 +2297,8 @@ bool MANTA::updateMeshFromBobj(std::string filename)
 
       readBytes = gzread(gzf, bufferTriangles, readLen * sizeof(int) * 3);
       if (!readBytes) {
-        std::cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read mesh triangles from "
-                  << filename << std::endl;
+        cerr << "Fluid Error -- updateMeshFromBobj(): Unable to read mesh triangles from "
+             << filename << endl;
         MEM_freeN(bufferTriangles);
         gzclose(gzf);
         return false;
@@ -2319,7 +2310,7 @@ bool MANTA::updateMeshFromBobj(std::string filename)
       CLAMP(readEnd, 0, numBuffer);
 
       k = 0;
-      for (std::vector<MANTA::Triangle>::size_type j = readStart; j < readEnd; j++, k += 3) {
+      for (vector<MANTA::Triangle>::size_type j = readStart; j < readEnd; j++, k += 3) {
         mMeshTriangles->at(j).c[0] = bufferTriangles[k];
         mMeshTriangles->at(j).c[1] = bufferTriangles[k + 1];
         mMeshTriangles->at(j).c[2] = bufferTriangles[k + 2];
@@ -2331,24 +2322,23 @@ bool MANTA::updateMeshFromBobj(std::string filename)
   return (gzclose(gzf) == Z_OK);
 }
 
-bool MANTA::updateMeshFromObj(std::string filename)
+bool MANTA::updateMeshFromObj(string filename)
 {
   if (with_debug)
-    std::cout << "MANTA::updateMeshFromObj()" << std::endl;
+    cout << "MANTA::updateMeshFromObj()" << endl;
 
-  std::ifstream ifs(filename);
+  ifstream ifs(filename);
   float fbuffer[3];
   int ibuffer[3];
   int cntVerts = 0, cntNormals = 0, cntTris = 0;
 
   if (!ifs.good()) {
-    std::cerr << "Fluid Error -- updateMeshFromObj(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromObj(): Unable to open file: " << filename << endl;
     return false;
   }
 
   while (ifs.good() && !ifs.eof()) {
-    std::string id;
+    string id;
     ifs >> id;
 
     if (id[0] == '#') {
@@ -2362,8 +2352,8 @@ bool MANTA::updateMeshFromObj(std::string filename)
     else if (id == "vn") {
       // normals
       if (getNumVertices() != cntVerts) {
-        std::cerr << "Fluid Error -- updateMeshFromObj(): Invalid number of mesh nodes in file: "
-                  << filename << std::endl;
+        cerr << "Fluid Error -- updateMeshFromObj(): Invalid number of mesh nodes in file: "
+             << filename << endl;
         return false;
       }
 
@@ -2386,20 +2376,20 @@ bool MANTA::updateMeshFromObj(std::string filename)
     }
     else if (id == "g") {
       // group
-      std::string group;
+      string group;
       ifs >> group;
     }
     else if (id == "f") {
       // face
-      std::string face;
+      string face;
       for (int i = 0; i < 3; i++) {
         ifs >> face;
-        if (face.find('/') != std::string::npos)
+        if (face.find('/') != string::npos)
           face = face.substr(0, face.find('/'));  // ignore other indices
         int idx = atoi(face.c_str()) - 1;
         if (idx < 0) {
-          std::cerr << "Fluid Error -- updateMeshFromObj(): Invalid face encountered in file: "
-                    << filename << std::endl;
+          cerr << "Fluid Error -- updateMeshFromObj(): Invalid face encountered in file: "
+               << filename << endl;
           return false;
         }
         ibuffer[i] = idx;
@@ -2421,10 +2411,10 @@ bool MANTA::updateMeshFromObj(std::string filename)
   return true;
 }
 
-bool MANTA::updateMeshFromUni(std::string filename)
+bool MANTA::updateMeshFromUni(string filename)
 {
   if (with_debug)
-    std::cout << "MANTA::updateMeshFromUni()" << std::endl;
+    cout << "MANTA::updateMeshFromUni()" << endl;
 
   gzFile gzf;
   float fbuffer[4];
@@ -2432,8 +2422,7 @@ bool MANTA::updateMeshFromUni(std::string filename)
 
   gzf = (gzFile)BLI_gzopen(filename.c_str(), "rb1");  // do some compression
   if (!gzf) {
-    std::cerr << "Fluid Error -- updateMeshFromUni(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromUni(): Unable to open file: " << filename << endl;
     return false;
   }
 
@@ -2441,13 +2430,13 @@ bool MANTA::updateMeshFromUni(std::string filename)
   char file_magic[5] = {0, 0, 0, 0, 0};
   readBytes = gzread(gzf, file_magic, 4);
   if (!readBytes) {
-    std::cerr << "Fluid Error -- updateMeshFromUni(): Unable to read header in file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromUni(): Unable to read header in file: " << filename
+         << endl;
     gzclose(gzf);
     return false;
   }
 
-  std::vector<pVel> *velocityPointer = mMeshVelocities;
+  vector<pVel> *velocityPointer = mMeshVelocities;
 
   // mdata uni header
   const int STR_LEN_PDATA = 256;
@@ -2463,19 +2452,18 @@ bool MANTA::updateMeshFromUni(std::string filename)
   gzread(gzf, &timestamp, sizeof(unsigned long long));
 
   if (with_debug)
-    std::cout << "Fluid: Read " << ibuffer[0] << " vertices in file: " << filename << std::endl;
+    cout << "Fluid: Read " << ibuffer[0] << " vertices in file: " << filename << endl;
 
   // Sanity checks
   const int meshSize = sizeof(float) * 3 + sizeof(int);
   if (!(bytesPerElement == meshSize) && (elementType == 0)) {
-    std::cerr << "Fluid Error -- updateMeshFromUni(): Invalid header in file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromUni(): Invalid header in file: " << filename << endl;
     gzclose(gzf);
     return false;
   }
   if (!ibuffer[0]) {  // Any vertices present?
-    std::cerr << "Fluid Error -- updateMeshFromUni(): No vertices present in file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateMeshFromUni(): No vertices present in file: " << filename
+         << endl;
     gzclose(gzf);
     return false;
   }
@@ -2490,7 +2478,7 @@ bool MANTA::updateMeshFromUni(std::string filename)
 
     velocityPointer->resize(numParticles);
     MANTA::pVel *bufferPVel;
-    for (std::vector<pVel>::iterator it = velocityPointer->begin(); it != velocityPointer->end();
+    for (vector<pVel>::iterator it = velocityPointer->begin(); it != velocityPointer->end();
          ++it) {
       gzread(gzf, fbuffer, sizeof(float) * 3);
       bufferPVel = (MANTA::pVel *)fbuffer;
@@ -2502,44 +2490,42 @@ bool MANTA::updateMeshFromUni(std::string filename)
   return (gzclose(gzf) == Z_OK);
 }
 
-bool MANTA::updateParticlesFromFile(std::string filename, bool isSecondarySys, bool isVelData)
+bool MANTA::updateParticlesFromFile(string filename, bool isSecondarySys, bool isVelData)
 {
   if (with_debug)
-    std::cout << "MANTA::updateParticlesFromFile()" << std::endl;
+    cout << "MANTA::updateParticlesFromFile()" << endl;
 
-  std::string fname(filename);
-  std::string::size_type idx;
+  string fname(filename);
+  string::size_type idx;
 
   idx = fname.rfind('.');
-  if (idx != std::string::npos) {
-    std::string extension = fname.substr(idx + 1);
+  if (idx != string::npos) {
+    string extension = fname.substr(idx + 1);
 
     if (extension.compare("uni") == 0)
       return updateParticlesFromUni(filename, isSecondarySys, isVelData);
     else
-      std::cerr << "Fluid Error -- updateParticlesFromFile(): Invalid file extension in file: "
-                << filename << std::endl;
+      cerr << "Fluid Error -- updateParticlesFromFile(): Invalid file extension in file: "
+           << filename << endl;
     return false;
   }
   else {
-    std::cerr << "Fluid Error -- updateParticlesFromFile(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateParticlesFromFile(): Unable to open file: " << filename << endl;
     return false;
   }
 }
 
-bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bool isVelData)
+bool MANTA::updateParticlesFromUni(string filename, bool isSecondarySys, bool isVelData)
 {
   if (with_debug)
-    std::cout << "MANTA::updateParticlesFromUni()" << std::endl;
+    cout << "MANTA::updateParticlesFromUni()" << endl;
 
   gzFile gzf;
   int ibuffer[4];
 
   gzf = (gzFile)BLI_gzopen(filename.c_str(), "rb1");  // do some compression
   if (!gzf) {
-    std::cerr << "Fluid Error -- updateParticlesFromUni(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateParticlesFromUni(): Unable to open file: " << filename << endl;
     return false;
   }
 
@@ -2547,24 +2533,24 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
   char file_magic[5] = {0, 0, 0, 0, 0};
   readBytes = gzread(gzf, file_magic, 4);
   if (!readBytes) {
-    std::cerr << "Fluid Error -- updateParticlesFromUni(): Unable to read header in file: "
-              << filename << std::endl;
+    cerr << "Fluid Error -- updateParticlesFromUni(): Unable to read header in file: " << filename
+         << endl;
     gzclose(gzf);
     return false;
   }
 
   if (!strcmp(file_magic, "PB01")) {
-    std::cerr << "Fluid Error -- updateParticlesFromUni(): Particle uni file format v01 not "
-                 "supported anymore."
-              << std::endl;
+    cerr << "Fluid Error -- updateParticlesFromUni(): Particle uni file format v01 not "
+            "supported anymore."
+         << endl;
     gzclose(gzf);
     return false;
   }
 
   // Pointer to FLIP system or to secondary particle system
-  std::vector<pData> *dataPointer = nullptr;
-  std::vector<pVel> *velocityPointer = nullptr;
-  std::vector<float> *lifePointer = nullptr;
+  vector<pData> *dataPointer = nullptr;
+  vector<pVel> *velocityPointer = nullptr;
+  vector<float> *lifePointer = nullptr;
 
   if (isSecondarySys) {
     dataPointer = mSndParticleData;
@@ -2590,19 +2576,19 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
   gzread(gzf, &timestamp, sizeof(unsigned long long));
 
   if (with_debug)
-    std::cout << "Fluid: Read " << ibuffer[0] << " particles in file: " << filename << std::endl;
+    cout << "Fluid: Read " << ibuffer[0] << " particles in file: " << filename << endl;
 
   // Sanity checks
   const int partSysSize = sizeof(float) * 3 + sizeof(int);
   if (!(bytesPerElement == partSysSize) && (elementType == 0)) {
-    std::cerr << "Fluid Error -- updateParticlesFromUni(): Invalid header in file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateParticlesFromUni(): Invalid header in file: " << filename
+         << endl;
     gzclose(gzf);
     return false;
   }
   if (!ibuffer[0]) {  // Any particles present?
     if (with_debug)
-      std::cout << "Fluid: No particles present in file: " << filename << std::endl;
+      cout << "Fluid: No particles present in file: " << filename << endl;
     gzclose(gzf);
     return true;  // return true since having no particles in a cache file is valid
   }
@@ -2630,9 +2616,8 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
 
       readBytes = gzread(gzf, bufferPData, readLen * sizeof(pData));
       if (!readBytes) {
-        std::cerr
-            << "Fluid Error -- updateParticlesFromUni(): Unable to read particle data in file: "
-            << filename << std::endl;
+        cerr << "Fluid Error -- updateParticlesFromUni(): Unable to read particle data in file: "
+             << filename << endl;
         MEM_freeN(bufferPData);
         gzclose(gzf);
         return false;
@@ -2644,7 +2629,7 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
       CLAMP(readEnd, 0, numParticles);
 
       int k = 0;
-      for (std::vector<MANTA::pData>::size_type j = readStart; j < readEnd; j++, k++) {
+      for (vector<MANTA::pData>::size_type j = readStart; j < readEnd; j++, k++) {
         dataPointer->at(j).pos[0] = bufferPData[k].pos[0];
         dataPointer->at(j).pos[1] = bufferPData[k].pos[1];
         dataPointer->at(j).pos[2] = bufferPData[k].pos[2];
@@ -2671,9 +2656,9 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
 
       readBytes = gzread(gzf, bufferPVel, readLen * sizeof(pVel));
       if (!readBytes) {
-        std::cerr << "Fluid Error -- updateParticlesFromUni(): Unable to read particle velocities "
-                     "in file: "
-                  << filename << std::endl;
+        cerr << "Fluid Error -- updateParticlesFromUni(): Unable to read particle velocities "
+                "in file: "
+             << filename << endl;
         MEM_freeN(bufferPVel);
         gzclose(gzf);
         return false;
@@ -2685,7 +2670,7 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
       CLAMP(readEnd, 0, numParticles);
 
       int k = 0;
-      for (std::vector<MANTA::pVel>::size_type j = readStart; j < readEnd; j++, k++) {
+      for (vector<MANTA::pVel>::size_type j = readStart; j < readEnd; j++, k++) {
         velocityPointer->at(j).pos[0] = bufferPVel[k].pos[0];
         velocityPointer->at(j).pos[1] = bufferPVel[k].pos[1];
         velocityPointer->at(j).pos[2] = bufferPVel[k].pos[2];
@@ -2710,9 +2695,8 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
 
       readBytes = gzread(gzf, bufferPLife, readLen * sizeof(float));
       if (!readBytes) {
-        std::cerr
-            << "Fluid Error -- updateParticlesFromUni(): Unable to read particle life in file: "
-            << filename << std::endl;
+        cerr << "Fluid Error -- updateParticlesFromUni(): Unable to read particle life in file: "
+             << filename << endl;
         MEM_freeN(bufferPLife);
         gzclose(gzf);
         return false;
@@ -2724,7 +2708,7 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
       CLAMP(readEnd, 0, numParticles);
 
       int k = 0;
-      for (std::vector<float>::size_type j = readStart; j < readEnd; j++, k++) {
+      for (vector<float>::size_type j = readStart; j < readEnd; j++, k++) {
         lifePointer->at(j) = bufferPLife[k];
       }
       todoParticles -= readLen;
@@ -2734,24 +2718,24 @@ bool MANTA::updateParticlesFromUni(std::string filename, bool isSecondarySys, bo
   return (gzclose(gzf) == Z_OK);
 }
 
-bool MANTA::updateGridFromFile(std::string filename, float *grid, bool isNoise)
+bool MANTA::updateGridFromFile(string filename, float *grid, bool isNoise)
 {
   if (with_debug)
-    std::cout << "MANTA::updateGridFromFile()" << std::endl;
+    cout << "MANTA::updateGridFromFile()" << endl;
 
   if (!grid) {
-    std::cerr << "Fluid Error -- updateGridFromFile(): Cannot read into uninitialized grid (grid "
-                 "is null)."
-              << std::endl;
+    cerr << "Fluid Error -- updateGridFromFile(): Cannot read into uninitialized grid (grid "
+            "is null)."
+         << endl;
     return false;
   }
 
-  std::string fname(filename);
-  std::string::size_type idx;
+  string fname(filename);
+  string::size_type idx;
 
   idx = fname.rfind('.');
-  if (idx != std::string::npos) {
-    std::string extension = fname.substr(idx + 1);
+  if (idx != string::npos) {
+    string extension = fname.substr(idx + 1);
 
     if (extension.compare("uni") == 0)
       return updateGridFromUni(filename, grid, isNoise);
@@ -2762,29 +2746,27 @@ bool MANTA::updateGridFromFile(std::string filename, float *grid, bool isNoise)
     else if (extension.compare("raw") == 0)
       return updateGridFromRaw(filename, grid, isNoise);
     else
-      std::cerr << "Fluid Error -- updateGridFromFile(): Invalid file extension in file: "
-                << filename << std::endl;
+      cerr << "Fluid Error -- updateGridFromFile(): Invalid file extension in file: " << filename
+           << endl;
     return false;
   }
   else {
-    std::cerr << "Fluid Error -- updateGridFromFile(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateGridFromFile(): Unable to open file: " << filename << endl;
     return false;
   }
 }
 
-bool MANTA::updateGridFromUni(std::string filename, float *grid, bool isNoise)
+bool MANTA::updateGridFromUni(string filename, float *grid, bool isNoise)
 {
   if (with_debug)
-    std::cout << "MANTA::updateGridFromUni()" << std::endl;
+    cout << "MANTA::updateGridFromUni()" << endl;
 
   gzFile gzf;
   int ibuffer[4];
 
   gzf = (gzFile)BLI_gzopen(filename.c_str(), "rb1");
   if (!gzf) {
-    std::cerr << "Fluid Error -- updateGridFromUni(): Unable to open file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateGridFromUni(): Unable to open file: " << filename << endl;
     return false;
   }
 
@@ -2792,32 +2774,29 @@ bool MANTA::updateGridFromUni(std::string filename, float *grid, bool isNoise)
   char file_magic[5] = {0, 0, 0, 0, 0};
   readBytes = gzread(gzf, file_magic, 4);
   if (!readBytes) {
-    std::cerr << "Fluid Error -- updateGridFromUni(): Unable to read header in file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateGridFromUni(): Unable to read header in file: " << filename
+         << endl;
     gzclose(gzf);
     return false;
   }
 
   if (!strcmp(file_magic, "DDF2")) {
-    std::cerr
-        << "Fluid Error -- updateGridFromUni(): Grid uni file format DDF2 not supported anymore."
-        << std::endl;
+    cerr << "Fluid Error -- updateGridFromUni(): Grid uni file format DDF2 not supported anymore."
+         << endl;
     gzclose(gzf);
     return false;
   }
 
   if (!strcmp(file_magic, "MNT1")) {
-    std::cerr
-        << "Fluid Error -- updateGridFromUni(): Grid uni file format MNT1 not supported anymore."
-        << std::endl;
+    cerr << "Fluid Error -- updateGridFromUni(): Grid uni file format MNT1 not supported anymore."
+         << endl;
     gzclose(gzf);
     return false;
   }
 
   if (!strcmp(file_magic, "MNT2")) {
-    std::cerr
-        << "Fluid Error -- updateGridFromUni(): Grid uni file format MNT2 not supported anymore."
-        << std::endl;
+    cerr << "Fluid Error -- updateGridFromUni(): Grid uni file format MNT2 not supported anymore."
+         << endl;
     gzclose(gzf);
     return false;
   }
@@ -2842,13 +2821,12 @@ bool MANTA::updateGridFromUni(std::string filename, float *grid, bool isNoise)
   int resZ = (isNoise) ? mResZNoise : mResZ;
 
   if (with_debug)
-    std::cout << "Fluid: Read " << ibuffer[3] << " grid type in file: " << filename << std::endl;
+    cout << "Fluid: Read " << ibuffer[3] << " grid type in file: " << filename << endl;
 
   // Sanity checks
   if (ibuffer[0] != resX || ibuffer[1] != resY || ibuffer[2] != resZ) {
-    std::cout << "Fluid: Grid dim doesn't match, read: (" << ibuffer[0] << ", " << ibuffer[1]
-              << ", " << ibuffer[2] << ") vs setup: (" << resX << ", " << resY << ", " << resZ
-              << ")" << std::endl;
+    cout << "Fluid: Grid dim doesn't match, read: (" << ibuffer[0] << ", " << ibuffer[1] << ", "
+         << ibuffer[2] << ") vs setup: (" << resX << ", " << resY << ", " << resZ << ")" << endl;
     gzclose(gzf);
     return false;
   }
@@ -2859,16 +2837,16 @@ bool MANTA::updateGridFromUni(std::string filename, float *grid, bool isNoise)
   }
 
   if (with_debug)
-    std::cout << "Fluid: Read successfully: " << filename << std::endl;
+    cout << "Fluid: Read successfully: " << filename << endl;
 
   return (gzclose(gzf) == Z_OK);
 }
 
 #if OPENVDB == 1
-bool MANTA::updateGridFromVDB(std::string filename, float *grid, bool isNoise)
+bool MANTA::updateGridFromVDB(string filename, float *grid, bool isNoise)
 {
   if (with_debug)
-    std::cout << "MANTA::updateGridFromVDB()" << std::endl;
+    cout << "MANTA::updateGridFromVDB()" << endl;
 
   openvdb::initialize();
   openvdb::io::File file(filename);
@@ -2876,8 +2854,8 @@ bool MANTA::updateGridFromVDB(std::string filename, float *grid, bool isNoise)
     file.open();
   }
   catch (const openvdb::IoError &) {
-    std::cerr << "Fluid Error -- updateGridFromVDB(): IOError, invalid OpenVDB file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateGridFromVDB(): IOError, invalid OpenVDB file: " << filename
+         << endl;
     return false;
   }
 
@@ -2909,17 +2887,17 @@ bool MANTA::updateGridFromVDB(std::string filename, float *grid, bool isNoise)
 }
 #endif
 
-bool MANTA::updateGridFromRaw(std::string filename, float *grid, bool isNoise)
+bool MANTA::updateGridFromRaw(string filename, float *grid, bool isNoise)
 {
   if (with_debug)
-    std::cout << "MANTA::updateGridFromRaw()" << std::endl;
+    cout << "MANTA::updateGridFromRaw()" << endl;
 
   gzFile gzf;
   int expectedBytes, readBytes;
 
   gzf = (gzFile)BLI_gzopen(filename.c_str(), "rb");
   if (!gzf) {
-    std::cout << "MANTA::updateGridFromRaw(): unable to open file" << std::endl;
+    cout << "MANTA::updateGridFromRaw(): unable to open file" << endl;
     return false;
   }
 
@@ -2930,8 +2908,7 @@ bool MANTA::updateGridFromRaw(std::string filename, float *grid, bool isNoise)
   expectedBytes = sizeof(float) * resX * resY * resZ;
   readBytes = gzread(gzf, grid, expectedBytes);
   if (!readBytes) {
-    std::cerr << "Fluid Error -- updateGridFromRaw(): Unable to read raw file: " << filename
-              << std::endl;
+    cerr << "Fluid Error -- updateGridFromRaw(): Unable to read raw file: " << filename << endl;
     gzclose(gzf);
     return false;
   }
@@ -2944,25 +2921,25 @@ bool MANTA::updateGridFromRaw(std::string filename, float *grid, bool isNoise)
 void MANTA::updatePointers()
 {
   if (with_debug)
-    std::cout << "MANTA::updatePointers()" << std::endl;
-
-  std::string func = "getDataPointer";
-  std::string funcNodes = "getNodesDataPointer";
-  std::string funcTris = "getTrisDataPointer";
-
-  std::string id = std::to_string(mCurrentID);
-  std::string solver = "s" + id;
-  std::string parts = "pp" + id;
-  std::string snd = "sp" + id;
-  std::string mesh = "sm" + id;
-  std::string mesh2 = "mesh" + id;
-  std::string noise = "sn" + id;
-  std::string solver_ext = "_" + solver;
-  std::string parts_ext = "_" + parts;
-  std::string snd_ext = "_" + snd;
-  std::string mesh_ext = "_" + mesh;
-  std::string mesh_ext2 = "_" + mesh2;
-  std::string noise_ext = "_" + noise;
+    cout << "MANTA::updatePointers()" << endl;
+
+  string func = "getDataPointer";
+  string funcNodes = "getNodesDataPointer";
+  string funcTris = "getTrisDataPointer";
+
+  string id = to_string(mCurrentID);
+  string solver = "s" + id;
+  string parts = "pp" + id;
+  string snd = "sp" + id;
+  string mesh = "sm" + id;
+  string mesh2 = "mesh" + id;
+  string noise = "sn" + id;
+  string solver_ext = "_" + solver;
+  string parts_ext = "_" + parts;
+  string snd_ext = "_" + snd;
+  string mesh_ext = "_" + mesh;
+  string mesh_ext2 = "_" + mesh2;
+  string noise_ext = "_" + noise;
 
   mFlags = (int *)pyObjectToPointer(callPythonFunction("flags" + solver_ext, func));
   mPhiIn = (float *)pyObjectToPointer(callPythonFunction("phiIn" + solver_ext, func));
@@ -3049,27 +3026,27 @@ void MANTA::updatePointers()
   }
   if (mUsingLiquid) {
     mPhi = (float *)pyObjectToPointer(callPythonFunction("phi" + solver_ext, func));
-    mFlipParticleData = (std::vector<pData> *)pyObjectToPointer(
+    mFlipParticleData = (vector<pData> *)pyObjectToPointer(
         callPythonFunction("pp" + solver_ext, func));
-    mFlipParticleVelocity = (std::vector<pVel> *)pyObjectToPointer(
+    mFlipParticleVelocity = (vector<pVel> *)pyObjectToPointer(
         callPythonFunction("pVel" + parts_ext, func));
   }
   if (mUsingLiquid && mUsingMesh) {
-    mMeshNodes = (std::vector<Node> *)pyObjectToPointer(
+    mMeshNodes = (vector<Node> *)pyObjectToPointer(
         callPythonFunction("mesh" + mesh_ext, funcNodes));
-    mMeshTriangles = (std::vector<Triangle> *)pyObjectToPointer(
+    mMeshTriangles = (vector<Triangle> *)pyObjectToPointer(
         callPythonFunction("mesh" + mesh_ext, funcTris));
   }
   if (mUsingLiquid && mUsingMVel) {
-    mMeshVelocities = (std::vector<pVel> *)pyObjectToPointer(
+    mMeshVelocities = (vector<pVel> *)pyObjectToPointer(
         callPythonFunction("mVel" + mesh_ext2, func));
   }
   if (mUsingLiquid && (mUsingDrops | mUsingBubbles | mUsingFloats | mUsingTracers)) {
-    mSndParticleData = (std::vector<pData> *)pyObjectToPointer(
+    mSndParticleData = (vector<pData> *)pyObjectToPointer(
         callPythonFunction("ppSnd" + snd_ext, func));
-    mSndParticleVelocity = (std::vector<pVel> *)pyObjectToPointer(
+    mSndParticleVelocity = (vector<pVel> *)pyObjectToPointer(
         callPythonFunction("pVelSnd" + parts_ext, func));
-    mSndParticleLife = (std::vector<float> *)pyObjectToPointer(
+    mSndParticleLife = (vector<float> *)pyObjectToPointer(
         callPythonFunction("pLifeSnd" + parts_ext, func));
   }
 
@@ -3082,21 +3059,21 @@ void MANTA::updatePointers()
 
 bool MANTA::hasConfig(FluidModifierData *mmd, int framenr)
 {
-  std::string extension = getCacheFileEnding(mmd->domain->cache_data_format);
+  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
   return BLI_exists(
       getFile(mmd, FLUID_DOMAIN_DIR_CONFIG, FLUID_DOMAIN_FILE_CONFIG, extension, framenr).c_str());
 }
 
 bool MANTA::hasData(FluidModifierData *mmd, int framenr)
 {
-  std::string filename = (mUsingSmoke) ? FLUID_DOMAIN_FILE_DENSITY : FLUID_DOMAIN_FILE_PP;
-  std::string extension = getCacheFileEnding(mmd->domain->cache_data_format);
+  string filename = (mUsingSmoke) ? FLUID_DOMAIN_FILE_DENSITY : FLUID_DOMAIN_FILE_PP;
+  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
   return BLI_exists(getFile(mmd, FLUID_DOMAIN_DIR_DATA, filename, extension, framenr).c_str());
 }
 
 bool MANTA::hasNoise(FluidModifierData *mmd, int framenr)
 {
-  std::string extension = getCacheFileEnding(mmd->domain->cache_noise_format);
+  string extension = getCacheFileEnding(mmd->domain->cache_noise_format);
   return BLI_exists(
       getFile(mmd, FLUID_DOMAIN_DIR_NOISE, FLUID_DOMAIN_FILE_DENSITYNOISE, extension, framenr)
           .c_str());
@@ -3104,14 +3081,14 @@ bool MANTA::hasNoise(FluidModifierData *mmd, int framenr)
 
 bool MANTA::hasMesh(FluidModifierData *mmd, int framenr)
 {
-  std::string extension = getCacheFileEnding(mmd->domain->cache_mesh_format);
+  string extension = getCacheFileEnding(mmd->domain->cache_mesh_format);
   return BLI_exists(
       getFile(mmd, FLUID_DOMAIN_DIR_MESH, FLUID_DOMAIN_FILE_MESH, extension, framenr).c_str());
 }
 
 bool MANTA::hasParticles(FluidModifierData *mmd, int framenr)
 {
-  std::string extension = getCacheFileEnding(mmd->domain->cache_particle_format);
+  string extension = getCacheFileEnding(mmd->domain->cache_particle_format);
   return BLI_exists(
       getFile(mmd, FLUID_DOMAIN_DIR_PARTICLES, FLUID_DOMAIN_FILE_PPSND, extension, framenr)
           .c_str());
@@ -3119,13 +3096,13 @@ bool MANTA::hasParticles(FluidModifierData *mmd, int framenr)
 
 bool MANTA::hasGuiding(FluidModifierData *mmd, int framenr, bool sourceDomain)
 {
-  std::string subdirectory = (sourceDomain) ? FLUID_DOMAIN_DIR_DATA : FLUID_DOMAIN_DIR_GUIDE;
-  std::string filename = (sourceDomain) ? FLUID_DOMAIN_FILE_VEL : FLUID_DOMAIN_FILE_GUIDEVEL;
-  std::string extension = getCacheFileEnding(mmd->domain->cache_data_format);
+  string subdirectory = (sourceDomain) ? FLUID_DOMAIN_DIR_DATA : FLUID_DOMAIN_DIR_GUIDE;
+  string filename = (sourceDomain) ? FLUID_DOMAIN_FILE_VEL : FLUID_DOMAIN_FILE_GUIDEVEL;
+  string extension = getCacheFileEnding(mmd->domain->cache_data_format);
   return BLI_exists(getFile(mmd, subdirectory, filename, extension, framenr).c_str());
 }
 
-std::string MANTA::getDirectory(FluidModifierData *mmd, std::string subdirectory)
+string MANTA::getDirectory(FluidModifierData *mmd, string subdirectory)
 {
   char directory[FILE_MAX];
   BLI_path_join(
@@ -3134,15 +3111,12 @@ std::string MANTA::getDirectory(FluidModifierData *mmd, std::string subdirectory
   return directory;
 }
 
-std::string MANTA::getFile(FluidModifierData *mmd,
-                           std::string subdirectory,
-                           std::string fname,
-                           std::string extension,
-                           int framenr)
+string MANTA::getFile(
+    FluidModifierData *mmd, string subdirectory, string fname, string extension, int framenr)
 {
   char targetFile[FILE_MAX];
-  std::string path = getDirectory(mmd, subdirectory);
-  std::string filename = fname + extension;
+  string path = getDirectory(mmd, subdirectory);
+  string filename = fname + extension;
   BLI_join_dirfile(targetFile, sizeof(targetFile), path.c_str(), filename.c_str());
   BLI_path_frame(targetFile, framenr, 0);
   return targetFile;
diff --git a/intern/mantaflow/intern/MANTA_main.h b/intern/mantaflow/intern/MANTA_main.h
index 5760e31d28d..9b3fd6aa141 100644
--- a/intern/mantaflow/intern/MANTA_main.h
+++ b/intern/mantaflow/intern/MANTA_main.h
@@ -30,6 +30,11 @@
 #include <unordered_map>
 #include <vector>
 
+using std::atomic;
+using std::string;
+using std::unordered_map;
+using std::vector;
+
 struct MANTA {
  public:
   MANTA(int *res, struct FluidModifierData *mmd);
@@ -415,7 +420,7 @@ struct MANTA {
     return mPhi;
   }
 
-  static std::atomic<int> solverID;
+  static atomic<int> solverID;
   static int with_debug;  // on or off (1 or 0), also sets manta debug level
 
   // Mesh getters
@@ -742,7 +747,7 @@ struct MANTA {
   size_t mTotalCellsMesh;
   size_t mTotalCellsParticles;
 
-  std::unordered_map<std::string, std::string> mRNAMap;
+  unordered_map<string, string> mRNAMap;
 
   int mCurrentID;
 
@@ -855,17 +860,17 @@ struct MANTA {
   float *mPhi;
 
   // Mesh fields
-  std::vector<Node> *mMeshNodes;
-  std::vector<Triangle> *mMeshTriangles;
-  std::vector<pVel> *mMeshVelocities;
+  vector<Node> *mMeshNodes;
+  vector<Triangle> *mMeshTriangles;
+  vector<pVel> *mMeshVelocities;
 
   // Particle fields
-  std::vector<pData> *mFlipParticleData;
-  std::vector<pVel> *mFlipParticleVelocity;
+  vector<pData> *mFlipParticleData;
+  vector<pVel> *mFlipParticleVelocity;
 
-  std::vector<pData> *mSndParticleData;
-  std::vector<pVel> *mSndParticleVelocity;
-  std::vector<float> *mSndParticleLife;
+  vector<pData> *mSndParticleData;
+  vector<pVel> *mSndParticleVelocity;
+  vector<float> *mSndParticleLife;
 
   void initializeRNAMap(struct FluidModifierData *mmd = NULL);
   void initDomain(struct FluidModifierData *mmd = NULL);
@@ -875,26 +880,26 @@ struct MANTA {
   void initSmokeNoise(struct FluidModifierData *mmd = NULL);
   void initializeMantaflow();
   void terminateMantaflow();
-  bool runPythonString(std::vector<std::string> commands);
-  std::string getRealValue(const std::string &varName);
-  std::string parseLine(const std::string &line);
-  std::string parseScript(const std::string &setup_string, FluidModifierData *mmd = NULL);
-  bool updateMeshFromBobj(std::string filename);
-  bool updateMeshFromObj(std::string filename);
-  bool updateMeshFromUni(std::string filename);
-  bool updateParticlesFromUni(std::string filename, bool isSecondarySys, bool isVelData);
-  bool updateGridFromUni(std::string filename, float *grid, bool isNoise);
-  bool updateGridFromVDB(std::string filename, float *grid, bool isNoise);
-  bool updateGridFromRaw(std::string filename, float *grid, bool isNoise);
-  bool updateMeshFromFile(std::string filename);
-  bool updateParticlesFromFile(std::string filename, bool isSecondarySys, bool isVelData);
-  bool updateGridFromFile(std::string filename, float *grid, bool isNoise);
-  std::string getDirectory(struct FluidModifierData *mmd, std::string subdirectory);
-  std::string getFile(struct FluidModifierData *mmd,
-                      std::string subdirectory,
-                      std::string fname,
-                      std::string extension,
-                      int framenr);
+  bool runPythonString(vector<string> commands);
+  string getRealValue(const string &varName);
+  string parseLine(const string &line);
+  string parseScript(const string &setup_string, FluidModifierData *mmd = NULL);
+  bool updateMeshFromBobj(string filename);
+  bool updateMeshFromObj(string filename);
+  bool updateMeshFromUni(string filename);
+  bool updateParticlesFromUni(string filename, bool isSecondarySys, bool isVelData);
+  bool updateGridFromUni(string filename, float *grid, bool isNoise);
+  bool updateGridFromVDB(string filename, float *grid, bool isNoise);
+  bool updateGridFromRaw(string filename, float *grid, bool isNoise);
+  bool updateMeshFromFile(string filename);
+  bool updateParticlesFromFile(string filename, bool isSecondarySys, bool isVelData);
+  bool updateGridFromFile(string filename, float *grid, bool isNoise);
+  string getDirectory(struct FluidModifierData *mmd, string subdirectory);
+  string getFile(struct FluidModifierData *mmd,
+                 string subdirectory,
+                 string fname,
+                 string extension,
+                 int framenr);
 };
 
 #endif