Simulation.h

Go to the documentation of this file.

 
#pragma once
#include "io/output/FileWriter.h"
#include "io/output/WriterFactory.h"
#include "io/output/XMLWriter.h"
#include "objects/FlowSimulationAnalyzer.h"
#include "objects/ParticleContainer.h"
#include "objects/Thermostat.h"
#include "strategies/StrategyFactory.h"
#include "utils/Arguments.h"
#include "utils/Timer.h"
#include <cassert>
#include <memory>
#include <optional>
#include <string>
 
#if (!defined(DO_BENCHMARKING) && !defined(DO_PROFILING))
#define SIM_SERIALIZE_XML(_a, _b, _c, _d, _e)                                                                          \
    do {                                                                                                               \
        XMLWriter xmlw{_a};                                                                                            \
        xmlw.serialize(_b, _c, _d, _e);                                                                                \
    } while (0)
#define SIM_INIT_WRITER(_a, _b, _c) _a = WriterFactory::createWriter(_b, _c)
#define SIM_WRITE_OUTPUT(_a, _b, _c, _d, _e)                                                                           \
    do {                                                                                                               \
        if (_a % _b == 0) {                                                                                            \
            _c->writeParticles(_d, _a, _e);                                                                            \
        }                                                                                                              \
    } while (0)
#define SIM_ANALYZE_FLOW(_a, _b)                                                                                       \
    do {                                                                                                               \
        _a.analyzeFlow(_b);                                                                                            \
    } while (0)
#else
#define SIM_SERIALIZE_XML(_a, _b, _c, _d, _e) (void)0
#define SIM_INIT_WRITER(_a, _b, _c) (void)0
#define SIM_WRITE_OUTPUT(_a, _b, _c, _d, _e) (void)0
#define SIM_ANALYZE_FLOW(_a, _b) (void)0
#endif
 
#ifdef NOUTFLOW
#define CHECK_NOUTFLOW(_x, _y)                                                                                         \
    if (std::any_of(_x._y.begin(), _x._y.end(),                                                                        \
                    [](BoundaryCondition condition) { return condition == BoundaryCondition::OUTFLOW; })) {            \
        CLIUtils::error("Cannot run simulation with outflow conditions when NOUTFLOW is defined! Please recompile "    \
                        "the program without defining it.");                                                           \
    }
#else
#define CHECK_NOUTFLOW(_x, _y) (void)0
#endif
 
class Simulation {
  protected:
    ParticleContainer &m_particles;
 
    Arguments &m_args;
 
    Thermostat &m_thermostat;
 
    FlowSimulationAnalyzer &m_analyzer;
 
    int m_totalIt;
 
    std::unique_ptr<FileWriter> m_writer;
 
    TimeIntegrationFuncs::VFunc m_calculateV;
 
    TimeIntegrationFuncs::XFunc m_calculateX;
 
    StrategyFactory::FFunc m_calculateF;
 
    Timer m_timer;
 
    void initializeBase();
 
    void runSimulationLoop(CellContainer *lc = nullptr);
 
  public:
    Simulation(ParticleContainer &pc, Arguments &args, Thermostat &t, FlowSimulationAnalyzer &analyzer);
 
    virtual ~Simulation();
 
    virtual void runSimulation();
 
    ParticleContainer &getParticles();
};