LinkedCellsContainer.h

Go to the documentation of this file.

#pragma once
 
#include <iterator>
#include <ranges>
#include <vector>
 
#include "cells/Cell.h"
#include "particles/containers/ParticleContainer.h"
 
class LinkedCellsContainer : public ParticleContainer {
    std::vector<std::vector<Cell*>> iteration_orders;
 
   public:
    enum class BoundaryCondition { OUTFLOW, REFLECTIVE, PERIODIC };
 
    enum class BoundarySide { LEFT, RIGHT, BOTTOM, TOP, BACK, FRONT };
 
   public:
    LinkedCellsContainer(const std::array<double, 3>& domain_size, double cutoff_radius,
                         const std::array<BoundaryCondition, 6>& boundary_types = {BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW,
                                                                                   BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW,
                                                                                   BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW},
                         int n = 0);
 
    void addParticle(const Particle& p) override;
 
    void addParticle(Particle&& p) override;
 
    void prepareForceCalculation() override;
 
    void applySimpleForces(const std::vector<std::shared_ptr<SimpleForceSource>>& simple_force_sources) override;
 
    void applyPairwiseForces(const std::vector<std::shared_ptr<PairwiseForceSource>>& force_sources) override;
 
    void applyTargettedForces(const std::vector<std::shared_ptr<TargettedForceSource>>& targetted_force_sources,
                              double curr_simulation_time) override;
 
    void reserve(size_t n) override;
 
    size_t size() const override;
 
    Particle& operator[](int i) override;
 
    std::vector<Particle>::iterator begin() override;
 
    std::vector<Particle>::iterator end() override;
 
    std::vector<Particle>::const_iterator begin() const override;
 
    std::vector<Particle>::const_iterator end() const override;
 
    [[nodiscard]] const std::vector<Particle>& getParticles() const override;
 
    const std::array<double, 3>& getDomainSize() const;
 
    double getCutoffRadius() const;
 
    const std::vector<Cell>& getCells();
 
    const std::vector<Cell*>& getBoundaryCells() const;
 
    const std::array<double, 3>& getCellSize() const;
 
    const std::array<int, 3>& getDomainNumCells() const;
 
    int cellCoordToCellIndex(int cx, int cy, int cz) const;
 
    Cell* particlePosToCell(const std::array<double, 3>& pos);
 
    Cell* particlePosToCell(double x, double y, double z);
 
    static std::string boundaryConditionToString(const BoundaryCondition& bc);
 
   private:
    void initCells();
 
    void initCellNeighbourReferences();
 
    void initIterationOrders();
 
    void updateCellsParticleReferences();
 
    void deleteHaloParticles();
 
    friend class ReflectiveBoundaryType;
 
    friend class OutflowBoundaryType;
 
    friend class PeriodicBoundaryType;
 
   private:
    std::vector<Particle> particles;
 
    std::array<double, 3> domain_size;
 
    double cutoff_radius;
 
    std::array<BoundaryCondition, 6> boundary_types;
 
    std::array<double, 3> cell_size;
 
    std::array<int, 3> domain_num_cells;
 
    std::vector<Cell> cells;
 
    std::vector<Cell*> domain_cell_references;
 
    std::vector<Cell*> boundary_cell_references;
 
    std::vector<Cell*> halo_cell_references;
 
    // Boundary cell references with respect to x-axis pointing to the right, y-axis pointing up and z axis pointing out of the screen
 
    std::vector<Cell*> left_boundary_cell_references;
 
    std::vector<Cell*> right_boundary_cell_references;
 
    std::vector<Cell*> bottom_boundary_cell_references;
 
    std::vector<Cell*> top_boundary_cell_references;
 
    std::vector<Cell*> back_boundary_cell_references;
 
    std::vector<Cell*> front_boundary_cell_references;
 
    // Halo cell references with respect to x-axis pointing to the right, y-axis pointing up and z axis pointing out of the screen
 
    std::vector<Cell*> left_halo_cell_references;
 
    std::vector<Cell*> right_halo_cell_references;
 
    std::vector<Cell*> bottom_halo_cell_references;
 
    std::vector<Cell*> top_halo_cell_references;
 
    std::vector<Cell*> back_halo_cell_references;
 
    std::vector<Cell*> front_halo_cell_references;
};