ProgressBarInterceptor Class Reference

#include <ProgressBarInterceptor.h>

Inheritance diagram for ProgressBarInterceptor:

Collaboration diagram for ProgressBarInterceptor:

Public Member Functions
void	onSimulationStart (Simulation &simulation) override
	This function initalized the start time of the simulation and the previous time point. More...
void	operator() (size_t iteration, Simulation &simulation) override
	This function is called on every nth iteration. It prints a progress bar to the console and updates the previous time point. More...
void	onSimulationEnd (size_t iteration, Simulation &simulation) override
	This function is empty as the progress bar doesnt need to do anything at the end of the simulation. More...
	operator std::string () const override
	The string representation of this interceptor. More...
void	logSummary (int depth) const override
	Logs the summary of the progress bar. More...
Public Member Functions inherited from SimulationInterceptor
virtual	~SimulationInterceptor ()=default
	Destroy the Simulation Interceptor object. More...
void	notify (size_t iteration, Simulation &simulation)
	This function is called by the simulation loop on every iteration. Whenever the iteration is a multiple of every_nth_iteration, the operator() function is called. More...

Private Attributes
size_t	expected_iterations
std::chrono::high_resolution_clock::time_point	t_start
std::chrono::high_resolution_clock::time_point	t_end
std::chrono::high_resolution_clock::time_point	t_prev
size_t	last_particle_count = 0
size_t	last_iteration = 0
double	last_remaining_seconds = 0
double	last_particle_updates_per_second = 0

Additional Inherited Members
Protected Attributes inherited from SimulationInterceptor
size_t	every_nth_iteration = 1

Detailed Description

Definition at line 7 of file ProgressBarInterceptor.h.

Member Function Documentation

logSummary()

void ProgressBarInterceptor::logSummary ( int  depth ) const

overridevirtual

Logs the summary of the progress bar.

Implements SimulationInterceptor.

Definition at line 117 of file ProgressBarInterceptor.cpp.

                                                       {
    std::string indent = std::string(depth * 2, ' ');
 
    Logger::logger->info("{}╟┤{}ProgressBar: {}", indent, ansi_orange_bold, ansi_end);
    Logger::logger->info("{}║   ├Enabled", indent);
}

onSimulationEnd()

void ProgressBarInterceptor::onSimulationEnd ( size_t  iteration, Simulation &  simulation  )

overridevirtual

This function is empty as the progress bar doesnt need to do anything at the end of the simulation.

Parameters

iteration	The current iteration
simulation	The simulation object

Implements SimulationInterceptor.

Definition at line 113 of file ProgressBarInterceptor.cpp.

                                                                                     {
    printProgress(simulation.params.input_file_path, 100, expected_iterations, expected_iterations, 0, -1, true);
}

onSimulationStart()

void ProgressBarInterceptor::onSimulationStart ( Simulation &  simulation )

overridevirtual

This function initalized the start time of the simulation and the previous time point.

Parameters

simulation

The simulation object

Implements SimulationInterceptor.

Definition at line 56 of file ProgressBarInterceptor.cpp.

                                                                     {
    t_start = std::chrono::high_resolution_clock::now();
    t_prev = t_start;
 
    expected_iterations = static_cast<size_t>(std::ceil(simulation.params.end_time / simulation.params.delta_t));
 
    SimulationInterceptor::every_nth_iteration = std::max(1, static_cast<int>(expected_iterations / 1000.0));
 
    const size_t percentage = std::min(100ul, static_cast<size_t>(100.0 * static_cast<double>(simulation.params.start_iteration) /
                                                                  static_cast<double>(expected_iterations)));
 
    last_particle_count = simulation.particle_container->size();
    last_iteration = simulation.params.start_iteration;
 
    last_remaining_seconds = -1;
    last_particle_updates_per_second = -1;
 
    Logger::logger->flush();
    printProgress(simulation.params.input_file_path, percentage, simulation.params.start_iteration, expected_iterations, -1, -1);
}

operator std::string()

ProgressBarInterceptor::operator std::string ( ) const

explicitoverridevirtual

The string representation of this interceptor.

Returns

std::string

This is used to write the final summary of the Interceptors to the console.

Implements SimulationInterceptor.

Definition at line 124 of file ProgressBarInterceptor.cpp.

{ return ""; }

operator()()

void ProgressBarInterceptor::operator() ( size_t  iteration, Simulation &  simulation  )

overridevirtual

This function is called on every nth iteration. It prints a progress bar to the console and updates the previous time point.

Parameters

iteration	The current iteration
simulation	The simulation object

Implements SimulationInterceptor.

Definition at line 77 of file ProgressBarInterceptor.cpp.

                                                                                {
    // calculate time since last write
    auto t_now = std::chrono::high_resolution_clock::now();
    const double seconds_since_last_write = std::chrono::duration<double>(t_now - t_prev).count();
    t_prev = t_now;
 
    // calculate estimated remaining time
    const int estimated_remaining_seconds = std::floor(seconds_since_last_write * static_cast<double>(expected_iterations - iteration) /
                                                       static_cast<double>(every_nth_iteration));
 
    // calculate percentage
    const size_t percentage =
        std::min(100ul, static_cast<size_t>(100.0 * static_cast<double>(iteration) / static_cast<double>(expected_iterations)));
 
    // calculate particle updates per second
    size_t current_particle_count = simulation.particle_container->size();
    size_t particle_updates = (current_particle_count + last_particle_count) / 2 * (iteration - last_iteration);
 
    double particle_updates_per_second = static_cast<double>(particle_updates) / seconds_since_last_write;
    last_particle_count = current_particle_count;
    last_iteration = iteration;
 
    // Smooth out the estimated remaining time and the updates per second
    if (last_remaining_seconds < 0) last_remaining_seconds = estimated_remaining_seconds;
    if (last_particle_updates_per_second < 0) last_particle_updates_per_second = particle_updates_per_second;
 
    double smoothed_remaining_seconds = (estimated_remaining_seconds + last_remaining_seconds) / 2;
    double smoothed_particle_updates_per_second = (particle_updates_per_second + last_particle_updates_per_second) / 2;
 
    printProgress(simulation.params.input_file_path, percentage, iteration, expected_iterations, smoothed_remaining_seconds,
                  smoothed_particle_updates_per_second);
 
    last_remaining_seconds = smoothed_remaining_seconds;
    last_particle_updates_per_second = smoothed_particle_updates_per_second;
}

Member Data Documentation

expected_iterations

size_t ProgressBarInterceptor::expected_iterations

private

Definition at line 51 of file ProgressBarInterceptor.h.

last_iteration

size_t ProgressBarInterceptor::last_iteration = 0

private

Definition at line 56 of file ProgressBarInterceptor.h.

last_particle_count

size_t ProgressBarInterceptor::last_particle_count = 0

private

Definition at line 55 of file ProgressBarInterceptor.h.

last_particle_updates_per_second

double ProgressBarInterceptor::last_particle_updates_per_second = 0

private

Definition at line 58 of file ProgressBarInterceptor.h.

last_remaining_seconds

double ProgressBarInterceptor::last_remaining_seconds = 0

private

Definition at line 57 of file ProgressBarInterceptor.h.

t_end

std::chrono::high_resolution_clock::time_point ProgressBarInterceptor::t_end

private

Definition at line 53 of file ProgressBarInterceptor.h.

t_prev

std::chrono::high_resolution_clock::time_point ProgressBarInterceptor::t_prev

private

Definition at line 54 of file ProgressBarInterceptor.h.

t_start

std::chrono::high_resolution_clock::time_point ProgressBarInterceptor::t_start

private

Definition at line 52 of file ProgressBarInterceptor.h.

---

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

• ProgressBarInterceptor.h
• ProgressBarInterceptor.cpp