#include "SimulatorBase.h"

#include "SPlisHSPlasH/Utilities/SceneLoader.h"

#include "SPlisHSPlasH/Utilities/SceneWriter.h"

#include "SceneConfiguration.h"

#include "Utilities/FileSystem.h"

#include "SPlisHSPlasH/TimeManager.h"

#include "Utilities/PartioReaderWriter.h"

#include "SPlisHSPlasH/Emitter.h"

#include "SPlisHSPlasH/EmitterSystem.h"

#include "SPlisHSPlasH/Simulation.h"

#include "SPlisHSPlasH/NonPressureForceBase.h"

#include "NumericParameter.h"

#include "Utilities/Logger.h"

#include "Utilities/Timing.h"

#include "Utilities/Counting.h"

#include "Utilities/Version.h"

#include "Utilities/SystemInfo.h"

#include "extern/partio/src/lib/Partio.h"

#include "SPlisHSPlasH/Utilities/GaussQuadrature.h"

#include "SPlisHSPlasH/Utilities/SimpleQuadrature.h"

#include "extern/cxxopts/cxxopts.hpp"

#include "Simulator/GUI/Simulator_GUI_Base.h"

#include "SPlisHSPlasH/Utilities/VolumeSampling.h"

#include "Utilities/BinaryFileReaderWriter.h"

#include "PositionBasedDynamicsWrapper/PBDBoundarySimulator.h"

#include "StaticBoundarySimulator.h"

#include "Exporter/ExporterBase.h"

#include "SPlisHSPlasH/Utilities/MeshImport.h"

#if USE_NFD_FILE_DIALOG

#include "extern/nfd/include/nfd.h"

#endif

#ifdef USE_EMBEDDED_PYTHON

#include "pySPlisHSPlasH/Embedded.h"

#endif

INIT_LOGGING

INIT_TIMING

INIT_COUNTING

using namespace SPH;

using namespace std;

using namespace GenParam;

using namespace Utilities;

int SimulatorBase::PAUSE = -1;

int SimulatorBase::PAUSE_AT = -1;

int SimulatorBase::STOP_AT = -1;

int SimulatorBase::NUM_STEPS_PER_RENDER = -1;

int SimulatorBase::DATA_EXPORT_FPS = -1;

int SimulatorBase::PARTICLE_EXPORT_ATTRIBUTES = -1;

int SimulatorBase::STATE_EXPORT = -1;

int SimulatorBase::STATE_EXPORT_FPS = -1;

int SimulatorBase::ASYNC_EXPORT = -1;

int SimulatorBase::RENDER_WALLS = -1;

int SimulatorBase::EXPORT_OBJECT_SPLITTING = -1;

int SimulatorBase::ENUM_WALLS_NONE = -1;

int SimulatorBase::ENUM_WALLS_PARTICLES_ALL = -1;

int SimulatorBase::ENUM_WALLS_PARTICLES_NO_WALLS = -1;

int SimulatorBase::ENUM_WALLS_GEOMETRY_ALL = -1;

int SimulatorBase::ENUM_WALLS_GEOMETRY_NO_WALLS = -1;

int SimulatorBase::CAMERA_POSITION = -1;

int SimulatorBase::CAMERA_LOOKAT = -1;

SimulatorBase::SimulatorBase()

{

Utilities::logger.addSink(shared_ptr<Utilities::ConsoleSink>(new Utilities::ConsoleSink(Utilities::LogLevel::INFO)));

m_boundarySimulator = nullptr;

m_gui = nullptr;

m_isStaticScene = true;

m_numberOfStepsPerRenderUpdate = 4;

m_renderWalls = 4;

m_doPause = true;

m_pauseAt = -1.0;

m_stopAt = -1.0;

m_useParticleCaching = true;

m_useGUI = true;

m_enableRigidBodyVTKExport = false;

m_enableRigidBodyExport = false;

m_enableStateExport = false;

m_enableAsyncExport = false;

m_enableObjectSplitting = false;

m_cameraPosition = Vector3r(0.0, 3.0, 8.0);

m_cameraLookAt = Vector3r::Zero();

m_framesPerSecond = 25;

m_framesPerSecondState = 1;

m_nextFrameTime = 0.0;

m_nextFrameTimeState = 0.0;

m_frameCounter = 1;

m_isFirstFrame = true;

m_isFirstFrameVTK = true;

m_firstState = true;

m_colorField.resize(1, "velocity");

m_colorMapType.resize(1, 0);

m_renderMinValue.resize(1, 0.0);

m_renderMaxValue.resize(1, 5.0);

m_visible.resize(1, true);

m_particleAttributes = "velocity";

m_timeStepCB = nullptr;

m_resetCB = nullptr;

m_updateGUI = false;

m_currentObjectId = 0;

#ifdef DL_OUTPUT

m_nextTiming = 1.0;

#endif

#ifdef USE_EMBEDDED_PYTHON

m_scriptObject = nullptr;

#endif

}

SimulatorBase::~SimulatorBase()

{

}

void SimulatorBase::initParameters()

{

ParameterObject::initParameters();

PAUSE = createBoolParameter("pause", "Pause", &m_doPause);

setGroup(PAUSE, "General|General");

setDescription(PAUSE, "Pause simulation.");

setHotKey(PAUSE, "space");

PAUSE_AT = createNumericParameter("pauseAt", "Pause simulation at", &m_pauseAt);

setGroup(PAUSE_AT, "General|General");

setDescription(PAUSE_AT, "Pause simulation at the given time. When the value is negative, the simulation is not paused.");

STOP_AT = createNumericParameter("stopAt", "Stop simulation at", &m_stopAt);

setGroup(STOP_AT, "General|General");

setDescription(STOP_AT, "Stop simulation at the given time. When the value is negative, the simulation is not stopped.");

NUM_STEPS_PER_RENDER = createNumericParameter("numberOfStepsPerRenderUpdate", "# time steps / update", &m_numberOfStepsPerRenderUpdate);

setGroup(NUM_STEPS_PER_RENDER, "Visualization");

setDescription(NUM_STEPS_PER_RENDER, "Number of simulation steps per rendered frame.");

static_cast<NumericParameter<unsigned int>*>(getParameter(NUM_STEPS_PER_RENDER))->setMinValue(1);

RENDER_WALLS = createEnumParameter("renderWalls", "Render walls", &m_renderWalls);

setGroup(RENDER_WALLS, "Visualization");

setDescription(RENDER_WALLS, "Make walls visible/invisible.");

EnumParameter *enumParam = static_cast<EnumParameter*>(getParameter(RENDER_WALLS));

enumParam->addEnumValue("None", ENUM_WALLS_NONE);

enumParam->addEnumValue("Particles (all)", ENUM_WALLS_PARTICLES_ALL);

enumParam->addEnumValue("Particles (no walls)", ENUM_WALLS_PARTICLES_NO_WALLS);

enumParam->addEnumValue("Geometry (all)", ENUM_WALLS_GEOMETRY_ALL);

enumParam->addEnumValue("Geometry (no walls)", ENUM_WALLS_GEOMETRY_NO_WALLS);

CAMERA_POSITION = createVectorParameter("cameraPosition", "Camera position", 3u, m_cameraPosition.data());

setGroup(CAMERA_POSITION, "Visualization");

setDescription(CAMERA_POSITION, "Initial position of the camera.");

setReadOnly(CAMERA_POSITION, true);

setVisible(CAMERA_POSITION, false);

CAMERA_LOOKAT = createVectorParameter("cameraLookat", "Camera lookat", 3u, m_cameraLookAt.data());

setGroup(CAMERA_LOOKAT, "Visualization");

setDescription(CAMERA_LOOKAT, "Lookat point of the camera.");

setReadOnly(CAMERA_LOOKAT, true);

setVisible(CAMERA_LOOKAT, false);

DATA_EXPORT_FPS = createNumericParameter("dataExportFPS", "Export FPS", &m_framesPerSecond);

setGroup(DATA_EXPORT_FPS, "Export|General");

setDescription(DATA_EXPORT_FPS, "Frame rate of partio, vtk and rigid body export.");

STATE_EXPORT = createBoolParameter("enableStateExport", "Simulation state export", &m_enableStateExport);

setGroup(STATE_EXPORT, "Export|General");

setDescription(STATE_EXPORT, "Enable/disable export of complete simulation state.");

STATE_EXPORT_FPS = createNumericParameter("stateExportFPS", "State export FPS", &m_framesPerSecondState);

setGroup(STATE_EXPORT_FPS, "Export|General");

setDescription(STATE_EXPORT_FPS, "Frame rate of simulation state export.");

PARTICLE_EXPORT_ATTRIBUTES = createStringParameter("particleAttributes", "Export attributes", &m_particleAttributes);

getParameter(PARTICLE_EXPORT_ATTRIBUTES)->setReadOnly(true);

setGroup(PARTICLE_EXPORT_ATTRIBUTES, "Export|General");

setDescription(PARTICLE_EXPORT_ATTRIBUTES, "Attributes that are exported in the partio files (except id and position).");

ASYNC_EXPORT = createBoolParameter("enableAsyncExport", "Asynchronous export", &m_enableAsyncExport);

setGroup(ASYNC_EXPORT, "Export|General");

setDescription(ASYNC_EXPORT, "Enable/disable asynchronous export of data. The total performance is faster but disable it when measuring the timings of simulation components. \n\n Currently only supported by partio exporter.");

for (size_t i = 0; i < m_particleExporters.size(); i++)

{

m_particleExporters[i].m_id = createBoolParameter(m_particleExporters[i].m_key, m_particleExporters[i].m_name,

[i,this]() -> bool { return m_particleExporters[i].m_exporter->getActive(); },

[i,this](bool active) { m_particleExporters[i].m_exporter->setActive(active); });

setGroup(m_particleExporters[i].m_id, "Export|Particle exporters");

setDescription(m_particleExporters[i].m_id, m_particleExporters[i].m_description);

}

for (size_t i = 0; i < m_rbExporters.size(); i++)

{

m_rbExporters[i].m_id = createBoolParameter(m_rbExporters[i].m_key, m_rbExporters[i].m_name,

[i, this]() -> bool { return m_rbExporters[i].m_exporter->getActive(); },

[i, this](bool active) { m_rbExporters[i].m_exporter->setActive(active); });

setGroup(m_rbExporters[i].m_id, "Export|Rigid body exporters");

setDescription(m_rbExporters[i].m_id, m_rbExporters[i].m_description);

}

EXPORT_OBJECT_SPLITTING = createBoolParameter("enableObjectSplitting", "Split SPH objects", &m_enableObjectSplitting);

setGroup(EXPORT_OBJECT_SPLITTING, "Export|General");

setDescription(EXPORT_OBJECT_SPLITTING, "Enable/disable an export of the SPH particles with an indiviual file per object.");

getParameter(EXPORT_OBJECT_SPLITTING)->setReadOnly(true);

}

void SimulatorBase::run()

{

initSimulation();

runSimulation();

cleanup();

}

void SimulatorBase::init(std::vector<std::string> argv, const std::string &windowName)

{

m_argc = static_cast<int>(argv.size());

m_argv_vec.clear();

m_argv_vec.reserve(argv.size());

for (auto & a : argv)

m_argv_vec.push_back(&a[0]);

m_argv = m_argv_vec.data();

init(m_argc, m_argv, windowName);

}

void SimulatorBase::init(int argc, char **argv, const std::string &windowName)

{

m_argc = argc;

m_argv = argv;

m_windowName = windowName;

createExporters();

initParameters();

m_exePath = FileSystem::getProgramPath();

setUseParticleCaching(true);

try

{

cxxopts::Options options(argv[0], "SPlisHSPlasH - An open-source library for the physically-based simulation of fluids.");

options

.positional_help("[scene file]")

.show_positional_help();

options.add_options()

("h,help", "Print help")

("v,version", "Print version")

("no-cache", "Disable caching of boundary samples/maps.")

("state-file", "State file (state_<time>.bin) that should be loaded.", cxxopts::value<std::string>())

("output-dir", "Output directory for log file and partio files.", cxxopts::value<std::string>())

("no-initial-pause", "Disable initial pause when starting the simulation.")

("no-gui", "Disable GUI.")

("stopAt", "Sets or overwrites the stopAt parameter of the scene.", cxxopts::value<Real>())

("param", "Sets or overwrites a parameter of the scene.\n\n"

"- Setting a fluid parameter:\n\t<fluid-id>:<parameter-name>:<value>\n"

"- Example: --param Fluid:viscosity:0.01\n\n"

"- Setting a configuration parameter:\n\t<parameter-name>:<value>\n"

"- Example: --param cflMethod:1\n"

, cxxopts::value<std::string>())

;

options.add_options("invisible")

("scene-file", "Scene file", cxxopts::value<std::string>());

options.parse_positional("scene-file");

auto result = options.parse(argc, argv);

if (result.count("help"))

{

std::cout << options.help({ "" }) << std::endl;

exit(0);

}

if (result.count("version"))

{

std::cout << SPLISHSPLASH_VERSION << std::endl;

exit(0);

}

if (result.count("no-cache"))

{

setUseParticleCaching(false);

}

if (result.count("no-gui"))

{

setUseGUI(false);

}

else

{

// the buffer sink is only used in the GUI

Utilities::logger.addSink(shared_ptr<Utilities::BufferSink>(new Utilities::BufferSink(Utilities::LogLevel::DEBUG)));

}

m_cmdLineStopAt = false;

if (result.count("stopAt"))

{

m_stopAt = result["stopAt"].as<Real>();

m_cmdLineStopAt = true;

}

if (result.count("param"))

{

const string paramStr = result["param"].as<std::string>();

Utilities::StringTools::tokenize(paramStr, m_paramTokens, ":");

// add third element to get a unified method for all parameters

if (m_paramTokens.size() == 2)

m_paramTokens.insert(m_paramTokens.begin(), "config");

if (m_paramTokens.size() != 3)

{

LOG_ERR << "--param has wrong syntax!";

LOG_ERR << "Example 1: --param Fluid:viscosity:0.01";

LOG_ERR << "Example 2: --param cflMethod:1";

exit(1);

}

}

std::string sceneFile = "";

if (result.count("scene-file"))

{

sceneFile = result["scene-file"].as<std::string>();

if (FileSystem::isRelativePath(sceneFile))

sceneFile = FileSystem::normalizePath(m_exePath + "/" + sceneFile);

}

#ifdef USE_NFD_FILE_DIALOG

else

{

std::string scenePath = FileSystem::normalizePath(m_exePath + "/../data/Scenes/");

if (!FileSystem::isDirectory(scenePath))

scenePath = m_exePath;

std::replace(scenePath.begin(), scenePath.end(), '/', '\\');

//sceneFile = FileSystem::fileDialog(0, scenePath.c_str(), "*.json");

sceneFile = openFileDialog(scenePath, "Scene files", "json");

if (sceneFile == "")

exit(0);

}

#else

else

{

std::cout << options.help({ "" }) << std::endl;

exit(0);

}

#endif

SceneConfiguration::getCurrent()->setSceneFile(sceneFile);

m_outputPath = FileSystem::normalizePath(getExePath() + "/output/" + FileSystem::getFileName(sceneFile));

if (result.count("output-dir"))

{

m_outputPath = result["output-dir"].as<std::string>();

}

m_cmdLineNoInitialPause = false;

if (result.count("no-initial-pause"))

{

m_doPause = false;

m_cmdLineNoInitialPause = true;

}

setStateFile("");

if (result.count("state-file"))

{

setStateFile(result["state-file"].as<std::string>());

if (FileSystem::isRelativePath(getStateFile()))

setStateFile(FileSystem::normalizePath(m_exePath + "/" + getStateFile()));

}

}

catch (const cxxopts::exceptions::exception& e)

{

std::cout << "error parsing options: " << e.what() << std::endl;

exit(1);

}

std::string logPath = FileSystem::normalizePath(m_outputPath + "/log");

FileSystem::makeDirs(logPath);

Utilities::logger.addSink(shared_ptr<Utilities::FileSink>(new Utilities::FileSink(Utilities::LogLevel::DEBUG, logPath + "/SPH_log.txt")));

LOG_INFO << "SPlisHSPlasH version: " << SPLISHSPLASH_VERSION;

LOG_DEBUG << "Git refspec: " << GIT_REFSPEC;

LOG_DEBUG << "Git SHA1: " << GIT_SHA1;

LOG_DEBUG << "Git status: " << GIT_LOCAL_STATUS;

LOG_DEBUG << "Host name: " << SystemInfo::getHostName();

#if defined(USE_cuNSearch)

LOG_INFO << "Neighborhood search: cuNSearch";

#elif defined(USE_CompactNSearch)

LOG_INFO << "Neighborhood search: CompactNSearch";

#elif defined(USE_TreeNSearch)

LOG_INFO << "Neighborhood search: TreeNSearch";

#endif

if (!getUseParticleCaching())

LOG_INFO << "Boundary cache disabled.";

LOG_INFO << "Output directory: " << m_outputPath;

//////////////////////////////////////////////////////////////////////////

// read scene

//////////////////////////////////////////////////////////////////////////

m_sceneLoader = std::unique_ptr<SceneLoader>(new SceneLoader());

const std::string& sceneFile = SceneConfiguration::getCurrent()->getSceneFile();

Utilities::SceneLoader::Scene& scene = SceneConfiguration::getCurrent()->getScene();

if (sceneFile != "")

m_sceneLoader->readScene(sceneFile.c_str(), scene);

else

return;

if (scene.sim2D)

m_cameraPosition = Vector3r(0.0, 0.0, 8.0);

else

m_cameraPosition = Vector3r(0.0, 3.0, 8.0);

//////////////////////////////////////////////////////////////////////////

// init boundary simulation

//////////////////////////////////////////////////////////////////////////

m_isStaticScene = true;

for (unsigned int i = 0; i < scene.boundaryModels.size(); i++)

{

if (scene.boundaryModels[i]->dynamic)

{

m_isStaticScene = false;

break;

}

}

if (m_isStaticScene)

{

LOG_INFO << "Initialize static boundary simulation";

m_boundarySimulator = new StaticBoundarySimulator(this);

}

else

{

LOG_INFO << "Initialize dynamic boundary simulation";

m_boundarySimulator = new PBDBoundarySimulator(this);

}

initExporters();

}

void SimulatorBase::initSimulation()

{

const std::string& sceneFile = SceneConfiguration::getCurrent()->getSceneFile();

const Utilities::SceneLoader::Scene& scene = SceneConfiguration::getCurrent()->getScene();

#ifdef DL_OUTPUT

// copy scene files in output so that the simulation can be reproduced

std::string sceneFilePath = FileSystem::normalizePath(m_outputPath + "/scene");

FileSystem::makeDirs(sceneFilePath);

FileSystem::copyFile(sceneFile, sceneFilePath + "/" + FileSystem::getFileNameWithExt(sceneFile));

std::string modelsFilePath = FileSystem::normalizePath(m_outputPath + "/models");

FileSystem::makeDirs(modelsFilePath);

for (unsigned int i = 0; i < scene.boundaryModels.size(); i++)

{

std::string meshFileName = scene.boundaryModels[i]->meshFile;

if (meshFileName != "")

{

if (FileSystem::isRelativePath(meshFileName))

meshFileName = FileSystem::normalizePath(FileSystem::getFilePath(sceneFile) + "/" + meshFileName);

FileSystem::copyFile(meshFileName, modelsFilePath + "/" + FileSystem::getFileNameWithExt(meshFileName));

}

std::string mapFileName = scene.boundaryModels[i]->mapFile;

if (mapFileName != "")

{

if (FileSystem::isRelativePath(mapFileName))

mapFileName = FileSystem::normalizePath(FileSystem::getFilePath(sceneFile) + "/" + mapFileName);

FileSystem::copyFile(scene.boundaryModels[i]->mapFile, modelsFilePath + "/" + FileSystem::getFileNameWithExt(scene.boundaryModels[i]->mapFile));

}

std::string samplesFileName = scene.boundaryModels[i]->samplesFile;

if (samplesFileName != "")

{

if (FileSystem::isRelativePath(samplesFileName))

samplesFileName = FileSystem::normalizePath(FileSystem::getFilePath(sceneFile) + "/" + samplesFileName);

FileSystem::copyFile(samplesFileName, modelsFilePath + "/" + FileSystem::getFileNameWithExt(samplesFileName));

}

}

for (unsigned int i = 0; i < scene.fluidModels.size(); i++)

{

std::string samplesFileName = scene.fluidModels[i]->samplesFile;

if (samplesFileName != "")

{

if (FileSystem::isRelativePath(samplesFileName))

samplesFileName = FileSystem::normalizePath(FileSystem::getFilePath(sceneFile) + "/" + samplesFileName);

FileSystem::copyFile(samplesFileName, modelsFilePath + "/" + FileSystem::getFileNameWithExt(samplesFileName));

}

}

std::string progFilePath = FileSystem::normalizePath(m_outputPath + "/program");

FileSystem::makeDirs(progFilePath);

FileSystem::copyFile(m_argv[0], progFilePath + "/" + FileSystem::getFileNameWithExt(m_argv[0]));

std::string diffFilePath = FileSystem::normalizePath(m_exePath + "/git_diff.txt");

FileSystem::copyFile(diffFilePath, progFilePath + "/git_diff.txt");

#endif

Simulation *sim = Simulation::getCurrent();

sim->init(scene.particleRadius, scene.sim2D);

buildModel();

#ifdef USE_DEBUG_TOOLS

sim->createDebugTools();

#endif

readParameters();

if (m_useGUI)

m_gui->init(m_windowName.c_str());

m_boundarySimulator->init();

if (m_useGUI)

{

Simulation *sim = Simulation::getCurrent();

for (unsigned int i = 0; i < sim->numberOfFluidModels(); i++)

{

FluidModel *model = sim->getFluidModel(i);

const std::string &key = model->getId();

model->setDragMethodChangedCallback([this, model]() { m_gui->initSimulationParameterGUI(); getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getDragBase()); });

model->setSurfaceMethodChangedCallback([this, model]() { m_gui->initSimulationParameterGUI(); getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getSurfaceTensionBase()); });

model->setViscosityMethodChangedCallback([this, model]() { m_gui->initSimulationParameterGUI(); getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getViscosityBase()); });

model->setVorticityMethodChangedCallback([this, model]() { m_gui->initSimulationParameterGUI(); getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getVorticityBase()); });

model->setElasticityMethodChangedCallback([this, model]() { reset(); m_gui->initSimulationParameterGUI(); getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getElasticityBase()); });

}

m_gui->initSimulationParameterGUI();

Simulation::getCurrent()->setSimulationMethodChangedCallback([this]() {

reset();

m_gui->initSimulationParameterGUI();

getSceneLoader()->readTimeStepParameterObject("Configuration", Simulation::getCurrent()->getTimeStep());

#ifdef USE_DEBUG_TOOLS

getSceneLoader()->readParameterObject("Configuration", Simulation::getCurrent()->getDebugTools());

#endif

});

}

updateScalarField();

sim->setZSortCallback([this]() { if (m_gui) m_gui->updateZSort(); });

}

void SimulatorBase::deferredInit()

{

m_boundarySimulator->initBoundaryData();

Simulation* sim = Simulation::getCurrent();

if (sim->getBoundaryHandlingMethod() == BoundaryHandlingMethods::Akinci2012)

{

unsigned int nBoundaryParticles = 0;

for (unsigned int i = 0; i < sim->numberOfBoundaryModels(); i++)

nBoundaryParticles += static_cast<BoundaryModel_Akinci2012*>(sim->getBoundaryModel(i))->numberOfParticles();

LOG_INFO << "Number of boundary particles: " << nBoundaryParticles;

}

#ifdef USE_EMBEDDED_PYTHON

m_scriptObject = new ScriptObject(this);

m_scriptObject->init();

getSceneLoader()->readParameterObject("Configuration", (ParameterObject*)m_scriptObject);

#else

if (getSceneLoader()->hasValue("Configuration", "scriptFile"))

LOG_WARN << "Key 'scriptFile' is set in the scene but SPlisHSPlasH is built without embedded Python support.";

#endif

if (m_useGUI)

{

for (unsigned int i = 0; i < sim->numberOfFluidModels(); i++)

{

FluidModel* model = sim->getFluidModel(i);

if (model->getXSPH())

getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getXSPH());

if (model->getDragBase())

getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getDragBase());

if (model->getSurfaceTensionBase())

getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getSurfaceTensionBase());

if (model->getViscosityBase())

getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getViscosityBase());

if (model->getVorticityBase())

getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getVorticityBase());

if (model->getElasticityBase())

getSceneLoader()->readMaterialParameterObject(model->getId(), (NonPressureForceBase*)model->getElasticityBase());

}

getSceneLoader()->readTimeStepParameterObject("Configuration", Simulation::getCurrent()->getTimeStep());

m_gui->initSimulationParameterGUI();

}

sim->setSimulationInitialized(true);

m_boundarySimulator->deferredInit();

}

void SimulatorBase::runSimulation()

{

deferredInit();

if (getStateFile() != "")

{

// avoid that command line parameter is overwritten

const Real temp = m_stopAt;

loadState(getStateFile());

if (m_cmdLineStopAt)

m_stopAt = temp;

if (m_cmdLineNoInitialPause)

m_doPause = false;

}

setCommandLineParameter();

if (!m_useGUI)

{

const Real stopAt = getValue<Real>(SimulatorBase::STOP_AT);

if (stopAt < 0.0)

{

LOG_ERR << "StopAt parameter must be set when starting without GUI.";

exit(1);

}

while (true)

{

if (!timeStepNoGUI())

break;

}

}

else

m_gui->run();

}

void SimulatorBase::cleanup()

{

if (m_useGUI)

m_gui->cleanup();

#ifdef USE_EMBEDDED_PYTHON

delete m_scriptObject;

if (Embedded::hasCurrent())

delete Embedded::getCurrent();

#endif

delete SceneConfiguration::getCurrent();

delete Simulation::getCurrent();

delete m_boundarySimulator;

cleanupExporters();

// print stats before loggers are deleted

Utilities::Timing::printAverageTimes();

Utilities::Timing::printTimeSums();

Utilities::Counting::printAverageCounts();

Utilities::Counting::printCounterSums();

auto& sinks = Utilities::logger.getSinks();

while (sinks.size() != 0)

Utilities::logger.removeSink(sinks[0]);

}

void SimulatorBase::readParameters()

{

m_sceneLoader->readParameterObject("Configuration", this);

m_sceneLoader->readParameterObject("Configuration", TimeManager::getCurrent());

m_sceneLoader->readParameterObject("Configuration", Simulation::getCurrent());

m_sceneLoader->readTimeStepParameterObject("Configuration", Simulation::getCurrent()->getTimeStep());

#ifdef USE_DEBUG_TOOLS

m_sceneLoader->readParameterObject("Configuration", Simulation::getCurrent()->getDebugTools());

#endif

Simulation *sim = Simulation::getCurrent();

const Utilities::SceneLoader::Scene& scene = SceneConfiguration::getCurrent()->getScene();

for (unsigned int i = 0; i < sim->numberOfFluidModels(); i++)

{

FluidModel *model = sim->getFluidModel(i);

const std::string &key = model->getId();

m_sceneLoader->readMaterialParameterObject(key, model);

m_sceneLoader->readMaterialParameterObject(key, (NonPressureForceBase*)model->getXSPH());

m_sceneLoader->readMaterialParameterObject(key, (NonPressureForceBase*) model->getDragBase());

m_sceneLoader->readMaterialParameterObject(key, (NonPressureForceBase*) model->getSurfaceTensionBase());

m_sceneLoader->readMaterialParameterObject(key, (NonPressureForceBase*) model->getViscosityBase());

m_sceneLoader->readMaterialParameterObject(key, (NonPressureForceBase*) model->getVorticityBase());

m_sceneLoader->readMaterialParameterObject(key, (NonPressureForceBase*) model->getElasticityBase());

for (auto material : scene.materials)

{

if (material->id == key)

{

setColorField(i, material->colorField);

setColorMapType(i, material->colorMapType);

setRenderMinValue(i, material->minVal);

setRenderMaxValue(i, material->maxVal);

setVisible(i, material->visible);

}

}

}

}

void SimulatorBase::setCommandLineParameter()

{

Simulation *sim = Simulation::getCurrent();

if (m_paramTokens.size() != 3)

return;

setCommandLineParameter((ParameterObject*)sim);

setCommandLineParameter((ParameterObject*)sim->getTimeStep());

#ifdef USE_DEBUG_TOOLS

setCommandLineParameter((ParameterObject*)sim->getDebugTools());

#endif

for (unsigned int i = 0; i < sim->numberOfFluidModels(); i++)

{

FluidModel *model = sim->getFluidModel(i);

const std::string &key = model->getId();

if (m_paramTokens[0] == key)

{

setCommandLineParameter((ParameterObject*)model);

setCommandLineParameter((ParameterObject*)model->getXSPH());

setCommandLineParameter((ParameterObject*)model->getDragBase());

setCommandLineParameter((ParameterObject*)model->getSurfaceTensionBase());

setCommandLineParameter((ParameterObject*)model->getViscosityBase());

setCommandLineParameter((ParameterObject*)model->getVorticityBase());

setCommandLineParameter((ParameterObject*)model->getElasticityBase());

}

}

}

void SimulatorBase::setCommandLineParameter(GenParam::ParameterObject *paramObj)

{

if (paramObj == nullptr)

return;

const unsigned int numParams = paramObj->numParameters();

for (unsigned int j = 0; j < numParams; j++)

{

ParameterBase *paramBase = paramObj->getParameter(j);

if (m_paramTokens[1] == paramBase->getName())

{

if (paramBase->getType() == RealParameterType)

{

const Real val = stof(m_paramTokens[2]);

static_cast<NumericParameter<Real>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::UINT32)

{

const unsigned int val = stoi(m_paramTokens[2]);

static_cast<NumericParameter<unsigned int>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::UINT16)

{

const unsigned short val = stoi(m_paramTokens[2]);

static_cast<NumericParameter<unsigned short>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::UINT8)

{

const unsigned char val = stoi(m_paramTokens[2]);

static_cast<NumericParameter<unsigned char>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::INT32)

{

const int val = stoi(m_paramTokens[2]);

static_cast<NumericParameter<int>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::INT16)

{

const short val = stoi(m_paramTokens[2]);

static_cast<NumericParameter<short>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::INT8)

{

const char val = stoi(m_paramTokens[2]);

static_cast<NumericParameter<char>*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::ENUM)

{

const int val = stoi(m_paramTokens[2]);

static_cast<EnumParameter*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == ParameterBase::BOOL)

{

const bool val = stoi(m_paramTokens[2]);

static_cast<BoolParameter*>(paramBase)->setValue(val);

}

else if (paramBase->getType() == RealVectorParameterType)

{

if (static_cast<VectorParameter<Real>*>(paramBase)->getDim() == 3)

{

vector<string> tokens;

Utilities::StringTools::tokenize(m_paramTokens[2], tokens, ",");

if (tokens.size() == 3)

{

Vector3r val(stof(tokens[0]), stof(tokens[1]), stof(tokens[2]));

static_cast<VectorParameter<Real>*>(paramBase)->setValue(val.data());

}

}

}

else if (paramBase->getType() == ParameterBase::STRING)

{

const std::string val = m_paramTokens[2];

static_cast<StringParameter*>(paramBase)->setValue(val);

}

}

}

}

void SimulatorBase::cleanupExporters()

{

for (size_t i = 0; i < m_particleExporters.size(); i++)

delete m_particleExporters[i].m_exporter;

m_particleExporters.clear();

for (size_t i = 0; i < m_rbExporters.size(); i++)

delete m_rbExporters[i].m_exporter;

m_rbExporters.clear();

}

void SimulatorBase::initExporters()

{

for (size_t i = 0; i < m_particleExporters.size(); i++)

m_particleExporters[i].m_exporter->init(m_outputPath);

for (size_t i = 0; i < m_rbExporters.size(); i++)

m_rbExporters[i].m_exporter->init(m_outputPath);

}

void SimulatorBase::buildModel()

{

initFluidData();

createEmitters();

createAnimationFields();

Simulation *sim = Simulation::getCurrent();

if (sim->getTimeStep())

sim->getTimeStep()->resize();

if (!sim->is2DSimulation())

{

sim->setValue(Simulation::KERNEL_METHOD, Simulation::ENUM_KERNEL_PRECOMPUTED_CUBIC);

sim->setValue(Simulation::GRAD_KERNEL_METHOD, Simulation::ENUM_GRADKERNEL_PRECOMPUTED_CUBIC);

}

else

{

sim->setValue(Simulation::KERNEL_METHOD, Simulation::ENUM_KERNEL_CUBIC_2D);

sim->setValue(Simulation::GRAD_KERNEL_METHOD, Simulation::ENUM_GRADKERNEL_CUBIC_2D);

}

}

void SimulatorBase::reset()

{

Utilities::Timing::printAverageTimes();

Utilities::Timing::reset();

Utilities::Counting::printAverageCounts();

Utilities::Counting::reset();

// reset the time step size if using a CFL condition

if (Simulation::getCurrent()->getValue<int>(Simulation::CFL_METHOD) != Simulation::ENUM_CFL_NONE)

getSceneLoader()->readParameterObject("Configuration", TimeManager::getCurrent());

Simulation::getCurrent()->reset();

#ifdef USE_DEBUG_TOOLS

Simulation::getCurrent()->getDebugTools()->reset();

#endif

m_boundarySimulator->reset();

NeighborhoodSearchWrapper* ns = Simulation::getCurrent()->getNeighborhoodSearch();

ns->reset();

if (m_gui)

m_gui->reset();

m_nextFrameTime = 0.0;

m_nextFrameTimeState = 0.0;

m_frameCounter = 1;

m_isFirstFrame = true;

m_isFirstFrameVTK = true;

#ifdef DL_OUTPUT

m_nextTiming = 1.0;

#endif

updateScalarField();

for (size_t i = 0; i < m_particleExporters.size(); i++)

m_particleExporters[i].m_exporter->reset();

for (size_t i = 0; i < m_rbExporters.size(); i++)

m_rbExporters[i].m_exporter->reset();

if (m_resetCB)

m_resetCB();

#ifdef USE_EMBEDDED_PYTHON

if (m_scriptObject)

m_scriptObject->execResetFct();

#endif

}

void SimulatorBase::singleTimeStep()

{

const unsigned int numSteps = getValue<unsigned int>(SimulatorBase::NUM_STEPS_PER_RENDER);

setValue<unsigned int>(SimulatorBase::NUM_STEPS_PER_RENDER, 1);

setValue<bool>(SimulatorBase::PAUSE, false);

timeStep();

setValue<unsigned int>(SimulatorBase::NUM_STEPS_PER_RENDER, numSteps);

setValue<bool>(SimulatorBase::PAUSE, true);

const Real stopAt = getValue<Real>(SimulatorBase::STOP_AT);

if (m_gui && (stopAt > 0.0) && (stopAt < TimeManager::getCurrent()->getTime()))

m_gui->stop();

}

void SimulatorBase::timeStep()

{

if (m_updateGUI)

{

m_gui->initSimulationParameterGUI();

m_updateGUI = false;

}

const Real stopAt = getValue<Real>(SimulatorBase::STOP_AT);

if (m_gui && (stopAt > 0.0) && (stopAt < TimeManager::getCurrent()->getTime()))

m_gui->stop();

const Real pauseAt = getValue<Real>(SimulatorBase::PAUSE_AT);

if ((pauseAt > 0.0) && (pauseAt < TimeManager::getCurrent()->getTime()))

setValue(SimulatorBase::PAUSE, true);

if (getValue<bool>(SimulatorBase::PAUSE))

return;

// Simulation code

Simulation *sim = Simulation::getCurrent();

const bool sim2D = sim->is2DSimulation();

const unsigned int numSteps = getValue<unsigned int>(SimulatorBase::NUM_STEPS_PER_RENDER);

for (unsigned int i = 0; i < numSteps; i++)

{

START_TIMING("SimStep");

Simulation::getCurrent()->getTimeStep()->step();

STOP_TIMING_AVG;

m_boundarySimulator->timeStep();

step();

INCREASE_COUNTER("Time step size", TimeManager::getCurrent()->getTimeStepSize());

// Make sure that particles stay in xy-plane in a 2D simulation

if (sim2D)

{

for (unsigned int i = 0; i < sim->numberOfFluidModels(); i++)

{

FluidModel *model = sim->getFluidModel(i);

for (unsigned int i = 0; i < model->numActiveParticles(); i++)

{

model->getPosition(i)[2] = 0.0;

model->getVelocity(i)[2] = 0.0;

}

}

}

#ifdef USE_DEBUG_TOOLS

Simulation::getCurrent()->getDebugTools()->step();

#endif

if (m_timeStepCB)

m_timeStepCB();

#ifdef USE_EMBEDDED_PYTHON

if (m_scriptObject)

m_scriptObject->execStepFct();

#endif

}

updateScalarField();

}

bool SimulatorBase::timeStepNoGUI()

{

const Real stopAt = getValue<Real>(SimulatorBase::STOP_AT);

if ((stopAt > 0.0) && (stopAt < TimeManager::getCurrent()->getTime()))

return false;

// Simulation code

Simulation *sim = Simulation::getCurrent();

const bool sim2D = sim->is2DSimulation();

START_TIMING("SimStep");

Simulation::getCurrent()->getTimeStep()->step();

STOP_TIMING_AVG;

m_boundarySimulator->timeStep();

step();

INCREASE_COUNTER("Time step size", TimeManager::getCurrent()->getTimeStepSize());

// Make sure that particles stay in xy-plane in a 2D simulation

if (sim2D)

{

for (unsigned int i = 0; i < sim->numberOfFluidModels(); i++)

{

FluidModel *model = sim->getFluidModel(i);

for (unsigned int i = 0; i < model->numActiveParticles(); i++)

{

model->getPosition(i)[2] = 0.0;

model->getVelocity(i)[2] = 0.0;

}