LinkedCellsContainer.h

Go to the documentation of this file.

//
// Created by daniel on 21.05.24.
//
 
#pragma once
#include <vector>
#ifdef _OPENMP
#include <omp.h>
#endif
 
#include "../ParticleContainer.h"
#include "fileHandling/outputWriter/VTKWriter/VTKWriter.h"
#include "particleRepresentation/particle/Particle.h"
#include "utils/enumsStructs.h"
#include "moleculeSimulator/forceCalculation/lennardJones/LennardJonesForce.h"
 
using namespace enumsStructs;
 
class LinkedCellsContainer : public ParticleContainer {
private:
    //Data structure
 
    std::vector<std::vector<Particle> > cells;
 
    size_t currentSize;
 
 
    //Precomputed indices:
    //Most of the indices are precomputed in the constructor and stored in memory to provide fast access in future iterations.
    //We invest here additional memory space to avoid recomputing all indices in each iteration again.
 
    std::array<std::vector<int>, 6> haloCells;
    std::array<std::vector<int>, 6> boundaries;
    std::vector<std::vector<int> > domainCellIterationScheme;
 
 
    //Scheduling for parallelization
    std::vector<int> scheduleParallelNaive;
    std::vector<int> scheduleParallelSophisticated;
 
    //Locks for parallelization
#ifdef _OPENMP
    std::vector<omp_lock_t> locks;
#endif
 
 
    //All parameters used in this model:
 
    int nX;
    int nY;
    int nZ;
    int baseY;
    int baseZ;
    int baseYDomain;
 
    int baseZDomain;
 
    double cellSizeX;
    double cellSizeY;
    double cellSizeZ;
    double rCutOff;
    bool twoD;
 
    std::array<double, 3> domainSize;
 
    outputWriter::VTKWriter vtk_writer;
 
    LennardJonesForce lJF;
 
    BoundarySet boundariesSet;
 
 
    //Helper methods for index calculation
 
    void calculateHaloCellIndices();
 
    void calculateBoundaryCellIndices();
 
    void calculateDomainCellsIterationScheme();
 
    void calculateScheduleParallelSophisticatedHelper(int xStart, int yStart, int zStart);
 
    void calculateScheduleNaive();
 
    void calculateScheduleParallelSophisticated();
 
    double calcDistanceFromBoundary(Particle &p, Side side);
 
    std::array<double, 3> calcGhostParticle(Particle &p, Side side);
 
    void teleportParticlesToOppositeSideHelper(Side sideStart, int dimension, int modus);
 
    void applyForceToOppositeCellsHelper(Side side, std::array<int, 3> cellToProcess);
 
    void applyForceToOppositeEdgeHelper(std::array<int, 3> cellToProcess, std::array<int, 3> offsetCell,
                                        std::array<double, 3> offsetPosition, int dim);
 
    [[nodiscard]] bool isCellInDomain(std::array<int, 3> cell) const;
 
    [[nodiscard]] bool isParticleInDomain(const std::array<double, 3> &position) const;
 
    void applyForcesBetweenTwoCells(int cellTarget, int cellSource, std::array<double, 3> offsetSource);
 
public:
    LinkedCellsContainer(std::array<double, 3> domainSize, double rCutOff, BoundarySet boundarySet);
 
    int calcCellIndex(const std::array<double, 3> &position);
 
    void add(Particle &p) override;
 
    [[nodiscard]] int threeDToOneD(int x, int y, int z) const;
 
    int threeDToOneDDomain(int x, int y, int z) const;
 
    [[nodiscard]] std::array<int, 3> oneDToThreeD(int index) const;
 
    void updateCells();
 
    void clearHaloCells(Side side);
 
    void applyToEachParticle(const std::function<void(Particle &)> &function) override;
 
    void applyToEachParticleInDomain(const std::function<void(Particle &)> &function) override;
 
    void applyToAllUniquePairsInDomain(const std::function<void(Particle &, Particle &)> &function) override;
 
    void applyToAllUniquePairsInDomainOptimized(
        const std::function<void(Particle &, Particle &, std::array<double, 3>, double)> &function);
 
    void applyToAllBoundaryParticles(const std::function<void(Particle &, std::array<double, 3> &)> &function,
                                     Side boundary);
 
    [[nodiscard]] size_t size() const override;
 
    std::array<double, 3> fromLowToHigh(const std::array<double, 3> &position, int dimension);
 
    std::array<double, 3> fromHighToLow(const std::array<double, 3> &position, int dimension);
 
    void teleportParticlesToOppositeSide(Side sideStart);
 
 
    void applyForcesFromOppositeSide(Side side);
 
//The following methods are only needed for parallelization
 
#ifdef _OPENMP
    void applyToAllUniquePairsInDomainParallelReduction(const std::function<void(Particle &, Particle &, int)> &function);
 
    void applyToEachParticleInDomainParallel(const std::function<void(Particle &)> &function);
 
    void applyToAllUniquePairsInDomainParallelHelper(const std::function<void(Particle &, Particle &)> &function, std::vector<int>& scheduling);
 
    void applyToAllUniquePairsInDomainParallelSophisticated(
        const std::function<void(Particle &, Particle &)> &function);
 
    void applyToAllUniquePairsInDomainParallelNaive(const std::function<void(Particle &, Particle &)> &function);
#endif
 
 
    //Getter and setters. Especially the setters should only by used for testing purposes.
 
    std::vector<std::vector<Particle> > &getCells() {
        return cells;
    }
 
    std::array<std::vector<int>, 6> &getHaloCells() {
        return haloCells;
    }
 
    std::array<std::vector<int>, 6> &getBoundaries() {
        return boundaries;
    }
 
    std::vector<std::vector<int> > &getDomainCellIterationScheme() {
        return domainCellIterationScheme;
    }
 
    [[nodiscard]] int getNX() const {
        return nX;
    }
 
    [[nodiscard]] int getNY() const {
        return nY;
    }
 
    [[nodiscard]] int getNZ() const {
        return nZ;
    }
 
    [[nodiscard]] double getCellSizeX() const {
        return cellSizeX;
    }
 
    [[nodiscard]] double getCellSizeY() const {
        return cellSizeY;
    }
 
    [[nodiscard]] double getCellSizeZ() const {
        return cellSizeZ;
    }
 
    [[nodiscard]] double getRCutOff() const {
        return rCutOff;
    }
 
    [[nodiscard]] bool isTwoD() const {
        return twoD;
    }
 
    [[nodiscard]] std::array<double, 3> getDomainSize() const {
        return domainSize;
    }
};