wash.hpp

Go to the documentation of this file.

#pragma once

// Ensure that the compilation stage has defined an implementation specific flag
// this is used to enable some optional parameters and features in e.g. the Particle class
// Usually the user should not see this message as the wash tool will define the appropriate flag for them.
#if !defined WASH_WSER && !defined WASH_WISB && !defined WASH_WEST && !defined WASH_CSTONE && !defined WASH_WONE
#error "Please specify an implementation when compiling WASH"
#endif 

// DIM is the compile-time flag for the dimensionality of the simulation, dictating
// the dimensionality of the vector to use. This should be specified in the implementation library.
#ifndef DIM
#error "Please define -DDIM=d when compiling WASH"
#endif

#include <chrono>
#include <cassert>
#include <chrono>
#include <functional>
#include <optional>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>

#include "io.hpp"
#include "particle.hpp"
#include "particle_data.hpp"
#include "util.hpp"
#include "vector.hpp"
#include "kernels.hpp"

#define defineWashForceKernel(kernel_name, particle_name) \
    void kernel_name (wash::Particle& particle_name, \
    const std::vector<wash::Particle>::const_iterator& begin, \
    const std::vector<wash::Particle>::const_iterator& end)

#define defineWashVoidKernel(kernel_name) \
    void kernel_name (void)

#define defineWashUpdateKernel(kernel_name, particle_name) \
    void kernel_name (wash::Particle& particle_name)

#define defineWashReductionKernel(kernel_name, particle_name) \
    double kernel_name (const wash::Particle& particle_name)

#define washForEachNeighbour(var_name, body) \
    _Pragma("omp simd")\
    for (auto it = begin; it != end; it++) {\
        const auto& var_name = *it;\
        { body }\
    }

namespace wash {

    uint64_t get_max_iterations();

    void set_max_iterations(const uint64_t iterations);

    void set_bounding_box(const double min, const double max, const bool periodic);

    void set_bounding_box(const double xmin, const double xmax, const double ymin, const double ymax, const double zmin,
                          const double zmax, const bool x_periodic, const bool y_periodic, const bool z_periodic);

    void add_force_scalar(const std::string force);

    void add_force_vector(const std::string force);

    void add_variable(const std::string variable, double init_value = 0.0);

    void add_init_update_kernel(const UpdateFuncT func);

    void add_init_void_kernel(const VoidFuncT func);

    void add_force_kernel(const ForceFuncT func);

    void add_update_kernel(const UpdateFuncT func);

    void add_reduction_kernel(const MapFuncT map_func, const ReduceOp reduce_op, double* variable);

    void add_void_kernel(const VoidFuncT func);

    void set_default_neighbor_search(const unsigned max_count);

    void set_neighbor_search_kernel(const NeighborsFuncT func, const unsigned max_count);

    double get_variable(const std::string& variable);

    double* use_variable(const std::string& variable);

    void set_variable(const std::string& variable, const double value);

    // /**
    //  * @brief Get the vector of all particles in the simulation
    //  *
    //  * @return std::vector<Particle>&
    //  */
    // std::vector<Particle>& get_particles();

    void start();

    void set_simulation_name(const std::string name);

    void set_output_file_name(const std::string name);


    double eucdist(const Particle& p, const Particle& q);

    void set_particle_count(const size_t count);

    size_t get_particle_count();

    void set_dimension(int dim);

    void set_io(const std::string format, size_t output_nth, bool timings = true);
};