Simulation Class Reference

Class to run a simulation. More...

#include <Simulation.h>

Collaboration diagram for Simulation:

Public Member Functions
	Simulation (const std::vector< Particle > &particles, const SimulationParams &params, IntegrationMethod integration_method=IntegrationMethod::VERLET)
	Construct a new Simulation object and initialize all the necessary components. More...
	~Simulation ()
SimulationOverview	runSimulation ()
	Runs the simulation, using the parameters given at construction and returns a SimulationOverview object containing some data. More...

Private Attributes
const SimulationParams &	params
	Reference to the simulation parameters object. More...
std::unique_ptr< ParticleContainer >	particle_container
	Reference to the ParticleContainer on whose content the simulation is performed. More...
std::unique_ptr< IntegrationFunctor >	integration_functor
	Functor used to integrate the particles. More...

Friends
class	ProgressBarInterceptor
class	FrameWriterInterceptor
class	TemperatureSensorInterceptor
class	ThermostatInterceptor
class	ParticleUpdateCounterInterceptor
class	RadialDistributionFunctionInterceptor
class	DiffusionFunctionInterceptor
class	VelocityProfileInterceptor

Detailed Description

Class to run a simulation.

This class collects all the components needed to run a simulation, and provides a method to run it.

Definition at line 20 of file Simulation.h.

Constructor & Destructor Documentation

Simulation()

Simulation::Simulation	(	const std::vector< Particle > &	particles,
		const SimulationParams &	params,
		IntegrationMethod	integration_method = IntegrationMethod::VERLET
	)

Construct a new Simulation object and initialize all the necessary components.

Parameters

particles	Reference to the ParticleContainer on whose content the simulation is performed
params	Parameters for the simulation. See the class SimulationParams for more information
integration_method	The integration method to use for the simulation (Default: IntegrationMethod::VERLET)

Definition at line 21 of file Simulation.cpp.

    : params(params), integration_functor(get_integration_functor(integration_method)) {
    // Create particle container
    if (std::holds_alternative<SimulationParams::LinkedCellsType>(params.container_type)) {
        auto lc_type = std::get<SimulationParams::LinkedCellsType>(params.container_type);
        particle_container =
            std::make_unique<LinkedCellsContainer>(lc_type.domain_size, lc_type.cutoff_radius, lc_type.boundary_conditions);
    } else if (std::holds_alternative<SimulationParams::DirectSumType>(params.container_type)) {
        particle_container = std::make_unique<DirectSumContainer>();
    } else {
        throw std::runtime_error("Unknown container type");
    }
 
    // Add particles to container
    particle_container->reserve(initial_particles.size());
    for (auto& particle : initial_particles) {
        particle_container->addParticle(particle);
    }
}

~Simulation()

Simulation::~Simulation ( )

default

Member Function Documentation

runSimulation()

SimulationOverview Simulation::runSimulation

(

)

Runs the simulation, using the parameters given at construction and returns a SimulationOverview object containing some data.

Returns

SimulationOverview object containing some data about the simulation performed

Definition at line 43 of file Simulation.cpp.

                                             {
    size_t iteration = params.start_iteration;
    double simulated_time = params.start_iteration * params.delta_t;
 
    // Calculate initial forces
    particle_container->prepareForceCalculation();
    particle_container->applySimpleForces(params.simple_forces);
    particle_container->applyPairwiseForces(params.pairwise_forces);
    particle_container->applyTargettedForces(params.targetted_forces, simulated_time);
 
    Logger::logger->info("Simulation started...");
 
    std::time_t t_start_helper = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    Logger::logger->info("Start time: {}", fmt::format("{:%A %Y-%m-%d %H:%M:%S}", fmt::localtime(t_start_helper)));
 
    // Notify interceptors that the simulation is about to start
    for (auto& interceptor : params.interceptors) {
        (*interceptor).onSimulationStart(*this);
    }
 
    auto t_start = std::chrono::high_resolution_clock::now();
 
    while (simulated_time < params.end_time) {
        integration_functor->step(particle_container, params.simple_forces, params.pairwise_forces, params.targetted_forces, params.delta_t,
                                  simulated_time);
 
        ++iteration;
        simulated_time += params.delta_t;
 
        // Notify interceptors of the current iteration
        for (auto& interceptor : params.interceptors) {
            (*interceptor).notify(iteration, *this);
        }
    }
 
    auto t_end = std::chrono::high_resolution_clock::now();
 
    // Notify interceptors that the simulation has ended
    for (auto& interceptor : params.interceptors) {
        (*interceptor).onSimulationEnd(iteration, *this);
    }
 
    Logger::logger->info("Simulation finished.");
    Logger::logger->info("End time: {}", fmt::format("{:%A %Y-%m-%d %H:%M:%S}", fmt::localtime(t_end)));
 
    std::vector<std::string> interceptor_summaries;
    for (auto& interceptor : params.interceptors) {
        auto summary = std::string(*interceptor);
        if (!summary.empty()) {
            interceptor_summaries.push_back(summary);
        }
    }
 
    auto total_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(t_end - t_start).count();
 
    SimulationOverview overview{params, total_time_ms / 1000.0, iteration, interceptor_summaries,
                                std::vector<Particle>(particle_container->begin(), particle_container->end())};
 
    return overview;
}

Friends And Related Function Documentation

DiffusionFunctionInterceptor

friend class DiffusionFunctionInterceptor

friend

Definition at line 66 of file Simulation.h.

FrameWriterInterceptor

friend class FrameWriterInterceptor

friend

Definition at line 61 of file Simulation.h.

ParticleUpdateCounterInterceptor

friend class ParticleUpdateCounterInterceptor

friend

Definition at line 64 of file Simulation.h.

ProgressBarInterceptor

friend class ProgressBarInterceptor

friend

Befriend the interceptors to allow them to access the private members of this class

Definition at line 60 of file Simulation.h.

RadialDistributionFunctionInterceptor

friend class RadialDistributionFunctionInterceptor

friend

Definition at line 65 of file Simulation.h.

TemperatureSensorInterceptor

friend class TemperatureSensorInterceptor

friend

Definition at line 62 of file Simulation.h.

ThermostatInterceptor

friend class ThermostatInterceptor

friend

Definition at line 63 of file Simulation.h.

VelocityProfileInterceptor

friend class VelocityProfileInterceptor

friend

Definition at line 67 of file Simulation.h.

Member Data Documentation

integration_functor

std::unique_ptr<IntegrationFunctor> Simulation::integration_functor

private

Functor used to integrate the particles.

Definition at line 55 of file Simulation.h.

params

const SimulationParams& Simulation::params

private

Reference to the simulation parameters object.

Definition at line 45 of file Simulation.h.

particle_container

std::unique_ptr<ParticleContainer> Simulation::particle_container

private

Reference to the ParticleContainer on whose content the simulation is performed.

Definition at line 50 of file Simulation.h.

---

The documentation for this class was generated from the following files:

• Simulation.h
• Simulation.cpp