SimulationParams.h

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <variant>
#include <vector>
 
#include "particles/containers/linkedcells/LinkedCellsContainer.h"
#include "physics/pairwiseforces/PairwiseForceSource.h"
#include "physics/simpleforces/SimpleForceSource.h"
#include "physics/targettedforces/TargettedForceSource.h"
#include "simulation/interceptors/SimulationInterceptor.h"
 
class SimulationParams {
   public:
    struct DirectSumType {
        explicit operator std::string() const { return "DirectSum"; }
    };
 
    struct LinkedCellsType {
        std::array<double, 3> domain_size;
        double cutoff_radius;
        std::array<LinkedCellsContainer::BoundaryCondition, 6> boundary_conditions;
 
        LinkedCellsType() = delete;
        LinkedCellsType(const std::array<double, 3>& domain_size, double cutoff_radius,
                        const std::array<LinkedCellsContainer::BoundaryCondition, 6>& boundary_conditions)
            : domain_size(domain_size), cutoff_radius(cutoff_radius), boundary_conditions(boundary_conditions) {}
 
        explicit operator std::string() const {
            return "LinkedCells ([" + std::to_string(domain_size[0]) + "x" + std::to_string(domain_size[1]) + "x" +
                   std::to_string(domain_size[2]) + "];" + std::to_string(cutoff_radius) + ";[" +
                   LinkedCellsContainer::boundaryConditionToString(boundary_conditions[0]) + "|" +
                   LinkedCellsContainer::boundaryConditionToString(boundary_conditions[1]) + "|" +
                   LinkedCellsContainer::boundaryConditionToString(boundary_conditions[2]) + "|" +
                   LinkedCellsContainer::boundaryConditionToString(boundary_conditions[3]) + "|" +
                   LinkedCellsContainer::boundaryConditionToString(boundary_conditions[4]) + "|" +
                   LinkedCellsContainer::boundaryConditionToString(boundary_conditions[5]) + "])";
        }
    };
 
    std::filesystem::path input_file_path;
 
    std::size_t input_file_hash;
 
    std::filesystem::path output_dir_path;
 
    double delta_t;
 
    double end_time;
 
    std::vector<std::shared_ptr<SimulationInterceptor>> interceptors;
 
    std::variant<DirectSumType, LinkedCellsType> container_type;
 
    std::vector<std::shared_ptr<SimpleForceSource>> simple_forces;
 
    std::vector<std::shared_ptr<PairwiseForceSource>> pairwise_forces;
 
    std::vector<std::shared_ptr<TargettedForceSource>> targetted_forces;
 
    size_t num_particles;
 
    bool fresh;
 
    size_t start_iteration;
 
    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);
 
    void logSummary(int depth = 0) const;
};