Simulation.h

#ifndef SIMULATION_H_
#define SIMULATION_H_
 
#include <memory>
#include <any>
 
#include "ensemble/CavityEnsemble.h"
#include "io/TimerProfiler.h"
#include "thermostats/VelocityScalingThermostat.h"
#include "utils/FixedSizeQueue.h"
#include "utils/FunctionWrapper.h"
#include "utils/SysMon.h"
 
// plugins
#include "plugins/PluginFactory.h"
 
#if !defined (SIMULATION_SRC) or defined (IN_IDE_PARSER)
class Simulation;
extern Simulation* global_simulation;
#endif
 
class ParticleInsertion;
class Ensemble;
 
 
 
#define _simulation (*global_simulation)
 
#include <list>
#include <vector>
#include <string>
#include <io/TaskTimingProfiler.h>
 
#ifdef STEEREO
class SteereoSimSteering;
class SteereoCouplingSim;
#endif
 
class Domain;
class ParticleContainer;
class ParticlePairsHandler;
class CellProcessor;
class Integrator;
class PluginBase;
class DomainDecompBase;
class InputBase;
class RDF;
class FlopCounter;
class LongRangeCorrection;
class Homogeneous;
class Planar;
class TemperatureControl;
class MemoryProfiler;
 
// by Stefan Becker
const int VELSCALE_THERMOSTAT = 1;
 
namespace bhfmm {
class FastMultipoleMethod;
} // bhfmm
 
 
class Simulation {
private:
    Simulation(Simulation &simulation);
    Simulation& operator=(Simulation &simulation);
    void updateForces();
 
public:
    Simulation();
 
    ~Simulation();
 
    void readXML(XMLfileUnits& xmlconfig);
 
    static void exit(int exitcode);
 
    void readConfigFile(std::string filename);
 
    void initConfigXML(const std::string& inputfilename);
 
    void prepare_start();
 
    void simulate();
 
 
    void pluginEndStepCall(unsigned long simstep);
 
    void finalize();
 
    void updateParticleContainerAndDecomposition(double lastTraversalTime, bool useTimers);
 
    void performOverlappingDecompositionAndCellTraversalStep(double etime);
 
    void setDomainDecomposition(DomainDecompBase* domainDecomposition);
 
    DomainDecompBase& domainDecomposition() { return *_domainDecomposition; }
 
    Domain* getDomain() { return _domain; }
 
    Integrator* getIntegrator() {return _integrator; }
 
    ParticleContainer* getMoleculeContainer() { return _moleculeContainer; }
 
    void setNumTimesteps( unsigned long steps ) { _numberOfTimesteps = steps; }
    unsigned long getNumTimesteps() { return _numberOfTimesteps; }
    unsigned long getNumInitTimesteps() { return _initSimulation; }
    unsigned long getSimulationStep() { return _simstep; }
    void setLoopAbortTime(double time) {
        global_log->info() << "Max loop-abort-time set: " << time << "\n";
        _wallTimeEnabled = true;
        _maxWallTime = time;
    }
 
    double getcutoffRadius() const { return _cutoffRadius; }
    void setcutoffRadius(double cutoffRadius) { _cutoffRadius = cutoffRadius; }
    double getLJCutoff() const { return _LJCutoffRadius; }
    void setLJCutoff(double LJCutoffRadius) { _LJCutoffRadius = LJCutoffRadius; }
    unsigned long getTotalNumberOfMolecules() const;
 
    double Tfactor(unsigned long simstep);
 
    void initCanonical(unsigned long t) { this->_initCanonical = t; }
    void initGrandCanonical(unsigned long t) { this->_initGrandCanonical = t; }
    void initStatistics(unsigned long t) { this->_initStatistics = t; }
    unsigned long getInitStatistics() const { return this->_initStatistics; }
 
    void setSimulationTime(double curtime) { _simulationTime = curtime; }
    void advanceSimulationTime(double timestep) { _simulationTime += timestep; }
    double getSimulationTime() { return _simulationTime; }
 
    void setEnsemble(Ensemble *ensemble) { _ensemble = ensemble; }
    Ensemble* getEnsemble() { return _ensemble; }
 
    std::shared_ptr<MemoryProfiler> getMemoryProfiler() {
        return _memoryProfiler;
    }
 
    TimerProfiler* timers() {
        return &_timerProfiler;
    }
 
    double getH() {return h;}
    void setH(double h_extern) {h = h_extern;}
 
private:
 
 
    double _simulationTime; 
    unsigned long _maxMoleculeId;
 
    double _cutoffRadius;
 
    double _LJCutoffRadius;
 
    unsigned _collectThermostatDirectedVelocity;
 
    int _thermostatType;
 
    unsigned long _numberOfTimesteps;
public:
    unsigned long getNumberOfTimesteps() const;
 
private:
    unsigned long _simstep;             
    unsigned long _initSimulation;
    unsigned long _initCanonical;
    unsigned long _initGrandCanonical;
    unsigned long _initStatistics;
 
    Ensemble* _ensemble;
 
    ParticleContainer* _moleculeContainer;
 
    ParticlePairsHandler* _particlePairsHandler;
 
    CellProcessor* _cellProcessor;
 
    DomainDecompBase* _domainDecomposition;
 
    Integrator* _integrator;
 
    Domain* _domain;
 
    InputBase* _inputReader;
 
    std::string _outputPrefix;
 
    unsigned _momentumInterval;
 
    Random _rand;
 
    LongRangeCorrection* _longRangeCorrection;
 
    TemperatureControl* _temperatureControl;
 
    bhfmm::FastMultipoleMethod* _FMM;
 
    TimerProfiler _timerProfiler;
 
    std::shared_ptr<MemoryProfiler> _memoryProfiler;
 
#ifdef TASKTIMINGPROFILE
    TaskTimingProfiler* _taskTimingProfiler;
#endif
public:
#ifdef TASKTIMINGPROFILE
    TaskTimingProfiler* getTaskTimingProfiler(){
        return _taskTimingProfiler;
    }
#endif
    double getAndResetOneLoopCompTime() {
        if(_loopCompTimeSteps==0){
            return 1.;
        }
        double t = _loopCompTime/_loopCompTimeSteps;
        _loopCompTime = 0.;
        _loopCompTimeSteps = 0;
        return t;
    }
    void setOutputPrefix( std::string prefix ) { _outputPrefix = prefix; }
    void setOutputPrefix( char *prefix ) { _outputPrefix = std::string( prefix ); }
    std::string getOutputPrefix() { return _outputPrefix; }
 
    void enableFinalCheckpoint() { _finalCheckpoint = true; }
    void disableFinalCheckpoint() { _finalCheckpoint = false; }
 
    void useLegacyCellProcessor() { _legacyCellProcessor = true; }
 
    void enableMemoryProfiler() {
        _memoryProfiler = std::make_shared<MemoryProfiler>();
        _memoryProfiler->registerObject(reinterpret_cast<MemoryProfilable**>(&_moleculeContainer));
        _memoryProfiler->registerObject(reinterpret_cast<MemoryProfilable**>(&_domainDecomposition));
    }
 
    void setForcedCheckpointTime(double time) { _forced_checkpoint_time = time; }
 
    void initialize();
 
    PluginBase* getPlugin(const std::string& name);
 
    std::list<PluginBase*>* getPluginList(){
        return &_plugins;
    }
 
    void initGlobalEnergyLog();
    void writeGlobalEnergyLog(const double& globalUpot, const double& globalT, const double& globalPressure);
 
    CellProcessor *getCellProcessor() const;
 
    void refreshParticleIDs();
 
    bool keepRunning();
 
private:
 
    Timer* _timerForLoad{nullptr};
 
    Timer _timeFromStart;
    double _maxWallTime = -1;
    bool _wallTimeEnabled = false;
 
    bool _finalCheckpoint;
 
    bool _legacyCellProcessor = false;
 
    bool _overlappingP2P {false};
 
    std::list<PluginBase*> _plugins;
 
    std::map<std::string, FunctionWrapper> _callbacks;
 
    VelocityScalingThermostat _velocityScalingThermostat;
 
    double h;
 
    double _forced_checkpoint_time;
 
    double _loopCompTime;
 
    int _loopCompTimeSteps;
 
    unsigned long _nWriteFreqGlobalEnergy;
    std::string _globalEnergyLogFilename;
 
    struct PrepareStartOptions {
        bool refreshIDs;
    } _prepare_start_opt;
 
    FixedSizeQueue<double> _lastTraversalTimeHistory;
};
#endif /*SIMULATION_H_*/