Contains all parameters needed to run a simulation. More...

#include <SimulationParams.h>

Collaboration diagram for SimulationParams:

Classes
struct	DirectSumType
	Struct to specify the type of the particle container as DirectSumType. More...

struct	LinkedCellsType
	Struct to specify the type of the particle container as LinkedCellsType (needs domain_size and cutoff_radius) More...

Public Member Functions
	SimulationParams (const std::filesystem::path &input_file_path, double delta_t, double end_time, const std::variant< DirectSumType, LinkedCellsType > &container_type, const std::vector< std::shared_ptr< SimulationInterceptor >> &interceptors, const std::vector< std::shared_ptr< SimpleForceSource >> &simple_forces, const std::vector< std::shared_ptr< PairwiseForceSource >> &pairwise_forces, const std::vector< std::shared_ptr< TargettedForceSource >> &targetted_forces, bool fresh=false, const std::filesystem::path &base_path="./output", size_t start_iteration=0)
	Construct a new SimulationParams object. More...

void	logSummary (int depth=0) const
	Prints a summary of the simulation parameters to the console. More...

Public Attributes
std::filesystem::path	input_file_path
	Path to the input file of the simulation. More...

std::size_t	input_file_hash
	Hash of the input file of the simulation. More...

std::filesystem::path	output_dir_path
	Path to the directory in which to save the simulation output. More...

double	delta_t
	Time step of a single simulation iteration. More...

double	end_time
	End time of the simulation. More...

std::vector< std::shared_ptr< SimulationInterceptor > >	interceptors
	List of interceptors to be used in the simulation. More...

std::variant< DirectSumType, LinkedCellsType >	container_type
	Type of the particle container. More...

std::vector< std::shared_ptr< SimpleForceSource > >	simple_forces
	Simple Forces to be applied to the particles. More...

std::vector< std::shared_ptr< PairwiseForceSource > >	pairwise_forces
	Pairwise Forces to be applied to the particles. More...

std::vector< std::shared_ptr< TargettedForceSource > >	targetted_forces
	Targetted Forces to be applied to the particles. More...

size_t	num_particles
	Number of particles in the simulation. More...

bool	fresh
	Flag to indicate whether the simulation should be run from scratch, or whether cached data should be used. More...

size_t	start_iteration
	Start iteration of the simulation. More...

Detailed Description

Contains all parameters needed to run a simulation.

This class is used to pass the parameters from the input file / CLI to the Simulation class.

Definition at line 22 of file SimulationParams.h.

Constructor & Destructor Documentation

◆ SimulationParams()

SimulationParams::SimulationParams	(	const std::filesystem::path &	input_file_path,
		double	delta_t,
		double	end_time,
		const std::variant< DirectSumType, LinkedCellsType > &	container_type,
		const std::vector< std::shared_ptr< SimulationInterceptor >> &	interceptors,
		const std::vector< std::shared_ptr< SimpleForceSource >> &	simple_forces,
		const std::vector< std::shared_ptr< PairwiseForceSource >> &	pairwise_forces,
		const std::vector< std::shared_ptr< TargettedForceSource >> &	targetted_forces,
		bool	fresh = `false`,
		const std::filesystem::path &	base_path = `"./output"`,
		size_t	start_iteration = `0`
	)

Construct a new SimulationParams object.

Parameters

input_file_path	Path to the input file of the simulation
delta_t	Time step of a single simulation iteration
end_time	End time of the simulation
container_type	Type of the particle container
interceptors	List of interceptors to be used in the simulation
simple_forces	Simple Forces to be applied to the particles
pairwise_forces	Forces to be applied to the particles
targetted_forces	Targetted Forces to be applied to the particles
fresh	Flag to indicate whether the simulation should be run from scratch, or whether cached data should be used
base_path	Base path to the output directory. This is used to construct the output directory path if none is given explicitly. Defaults to "./output/"
start_iteration	Start iteration of the simulation

Definition at line 27 of file SimulationParams.cpp.

     : input_file_path(std::filesystem::absolute(input_file_path)),
       delta_t(delta_t),
       end_time(end_time),
       interceptors(interceptors),
       container_type(container_type),
       simple_forces(simple_forces),
       pairwise_forces(pairwise_forces),
       targetted_forces(targetted_forces),
       fresh(fresh),
       start_iteration(start_iteration) {
     if (end_time < 0) {
         Logger::logger->error("End time must be positive");
         throw std::runtime_error("End time must be positive");
     }
     if (delta_t < 0) {
         Logger::logger->error("Delta t must be positive");
         throw std::runtime_error("Delta t must be positive");
     }
  
     this->output_dir_path = constructOutputPath(base_path, input_file_path.stem().string());
  
     this->input_file_hash = ChkptPointFileReader::calculateHash(input_file_path);
  
     this->num_particles = 0;
 }

Member Function Documentation

◆ logSummary()

void SimulationParams::logSummary ( int depth = 0 ) const

Prints a summary of the simulation parameters to the console.

Parameters

depth determines the indentation of the log message

Definition at line 60 of file SimulationParams.cpp.

                                                  {
     std::string indent = std::string(depth * 2, ' ');
  
     std::string force_names =
         std::accumulate(
             simple_forces.begin(), simple_forces.end(), std::string{},
             [](const std::string& acc, const std::shared_ptr<SimpleForceSource>& force) { return acc + std::string(*force) + ", "; }) +
         std::accumulate(
             pairwise_forces.begin(), pairwise_forces.end(), std::string{},
             [](const std::string& acc, const std::shared_ptr<PairwiseForceSource>& force) { return acc + std::string(*force) + ", "; });
  
     Logger::logger->info("{}╔════════════════════════════════════════", indent);
     Logger::logger->info("{}╟┤{}Simulation arguments: {}", indent, ansi_yellow_bold, ansi_end);
     Logger::logger->info("{}║  Input file path: {}", indent, input_file_path.string());
     Logger::logger->info("{}║  Output directory path: {}", indent, output_dir_path.string());
     Logger::logger->info("{}║  Start iteration: {}", indent, start_iteration);
     Logger::logger->info("{}║  Delta_t: {}", indent, delta_t);
     Logger::logger->info("{}║  End_time: {}", indent, end_time);
     Logger::logger->info("{}║  Reuse cached data: {}", indent, !fresh);
  
     // Print Physical setup
     Logger::logger->info("{}╟┤{}Physical setup: {}", indent, ansi_yellow_bold, ansi_end);
     Logger::logger->info("{}║  Number of particles: {}", indent, num_particles);
     Logger::logger->info("{}║  Number of forces: {}", indent, pairwise_forces.size() + simple_forces.size());
     Logger::logger->info("{}║  Forces: {}", indent, force_names);
  
     Logger::logger->info("{}╟┤{}Container: {}", indent, ansi_yellow_bold, ansi_end);
  
     if (std::holds_alternative<SimulationParams::LinkedCellsType>(container_type)) {
         auto lc_container = std::get<SimulationParams::LinkedCellsType>(container_type);
  
         using LC = LinkedCellsContainer;
  
         auto domain_size = lc_container.domain_size;
         Logger::logger->info("{}║  Linked Cells", indent);
         Logger::logger->info("{}║  Domain size: {} x {} x {}", indent, domain_size[0], domain_size[1], domain_size[2]);
         Logger::logger->info("{}║  Cutoff radius: {}", indent, lc_container.cutoff_radius);
         Logger::logger->info("{}║   ┌Left: {}", indent, LC::boundaryConditionToString(lc_container.boundary_conditions[0]));
         Logger::logger->info("{}║   ├Right: {}", indent, LC::boundaryConditionToString(lc_container.boundary_conditions[1]));
         Logger::logger->info("{}║   ├Bottom: {}", indent, LC::boundaryConditionToString(lc_container.boundary_conditions[2]));
         Logger::logger->info("{}║   ├Top: {}", indent, LC::boundaryConditionToString(lc_container.boundary_conditions[3]));
         Logger::logger->info("{}║   ├Back: {}", indent, LC::boundaryConditionToString(lc_container.boundary_conditions[4]));
         Logger::logger->info("{}║   └Front: {}", indent, LC::boundaryConditionToString(lc_container.boundary_conditions[5]));
     } else if (std::holds_alternative<SimulationParams::DirectSumType>(container_type)) {
         Logger::logger->info("{}║  Direct Sum", indent);
     } else {
         Logger::logger->error("Invalid container type");
         throw std::runtime_error("Invalid container type");
     }
  
     Logger::logger->info("{}╟┤{}Interceptors: {}", indent, ansi_yellow_bold, ansi_end);
     if (interceptors.empty()) {
         Logger::logger->info("{}║  None", indent);
     } else {
         for (auto& interceptor : interceptors) {
             interceptor->logSummary(depth);
         }
     }
  
 #ifdef _OPENMP
     Logger::logger->info("{}╟┤{}Maximum Number of Threads:{} {}", indent, ansi_yellow_bold, ansi_end, omp_get_max_threads());
 #endif
  
     Logger::logger->info("{}╚════════════════════════════════════════", indent);
 }

Member Data Documentation

◆ container_type

std::variant<DirectSumType, LinkedCellsType> SimulationParams::container_type

Type of the particle container.

Definition at line 89 of file SimulationParams.h.

◆ delta_t

double SimulationParams::delta_t

Time step of a single simulation iteration.

Definition at line 74 of file SimulationParams.h.

◆ end_time

double SimulationParams::end_time

End time of the simulation.

Definition at line 79 of file SimulationParams.h.

◆ fresh

bool SimulationParams::fresh

Flag to indicate whether the simulation should be run from scratch, or whether cached data should be used.

Definition at line 114 of file SimulationParams.h.

◆ input_file_hash

std::size_t SimulationParams::input_file_hash

Hash of the input file of the simulation.

Definition at line 64 of file SimulationParams.h.

◆ input_file_path

std::filesystem::path SimulationParams::input_file_path

Path to the input file of the simulation.

Definition at line 59 of file SimulationParams.h.

◆ interceptors

std::vector<std::shared_ptr<SimulationInterceptor> > SimulationParams::interceptors

List of interceptors to be used in the simulation.

Definition at line 84 of file SimulationParams.h.

◆ num_particles

size_t SimulationParams::num_particles

Number of particles in the simulation.

Definition at line 109 of file SimulationParams.h.

◆ output_dir_path

std::filesystem::path SimulationParams::output_dir_path

Path to the directory in which to save the simulation output.

Definition at line 69 of file SimulationParams.h.

◆ pairwise_forces

std::vector<std::shared_ptr<PairwiseForceSource> > SimulationParams::pairwise_forces

Pairwise Forces to be applied to the particles.

Definition at line 99 of file SimulationParams.h.

◆ simple_forces

std::vector<std::shared_ptr<SimpleForceSource> > SimulationParams::simple_forces

Simple Forces to be applied to the particles.

Definition at line 94 of file SimulationParams.h.

◆ start_iteration

size_t SimulationParams::start_iteration

Start iteration of the simulation.

Definition at line 119 of file SimulationParams.h.

◆ targetted_forces

std::vector<std::shared_ptr<TargettedForceSource> > SimulationParams::targetted_forces

Targetted Forces to be applied to the particles.

Definition at line 104 of file SimulationParams.h.

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

Classes

Public Member Functions

Public Attributes