CellContainer.h

Go to the documentation of this file.

 
#pragma once
#include "Cell.h"
#include "Particle.h"
#include "ParticleContainer.h"
#include "io/input/FileReader.h"
#include "io/output/WriterFactory.h"
#include "utils/CellUtils.h"
#include "utils/OMPWrapper.h"
#include <array>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
 
// NOTE 1: you could probably use arrays instead of vectors and make this a template class,
// since we can compute the number of cells beforehand.
 
// NOTE 2: i only extended halo cells one cell past the boundary. theoretically, they could continue infinitely, but
// that would be a nightmare to manage.
 
class CellContainer {
    using ContainerType = std::vector<Cell>;
 
  private:
    ContainerType cells;
    std::vector<omp_lock_t> cellLocks;
    std::vector<std::reference_wrapper<Cell>> borderCells;
    std::vector<std::reference_wrapper<Cell>> haloCells;
    std::vector<std::reference_wrapper<Cell>> iterableCells;
    std::array<double, 3> domainSize;
    std::array<double, 3> cellSize{0, 0, 0};
    std::array<size_t, 3> numCells{1, 1, 1};
    std::array<BoundaryCondition, 6> conditions;
    double cutoff;
    size_t dim;
    bool anyPeriodic{false};
    ParticleContainer &particles;
 
  public:
    CellContainer(const std::array<double, 3> &domainSize, const std::array<BoundaryCondition, 6> &conditions,
                  double cutoff, ParticleContainer &particles, size_t dim = 3);
 
    ~CellContainer();
 
    ContainerType::iterator begin();
 
    ContainerType::iterator end();
 
    ParticleContainer::PairIterator beginPairs();
 
    ParticleContainer::PairIterator endPairs();
 
    ContainerType::const_iterator begin() const;
 
    ContainerType::const_iterator end() const;
 
    class SpecialParticleIterator {
      private:
        std::vector<std::reference_wrapper<Cell>>::iterator outerIt;
        std::vector<std::reference_wrapper<Cell>>::iterator outerEnd;
        std::forward_list<std::reference_wrapper<Particle>>::iterator innerIt;
        std::forward_list<std::reference_wrapper<Particle>>::iterator innerEnd;
        void advance();
 
      public:
        SpecialParticleIterator(std::vector<std::reference_wrapper<Cell>>::iterator start,
                                std::vector<std::reference_wrapper<Cell>>::iterator end);
 
        Particle &operator*();
 
        SpecialParticleIterator &operator++();
 
        bool operator!=(const SpecialParticleIterator &other) const;
 
        bool operator==(const SpecialParticleIterator &other) const;
    };
 
    SpecialParticleIterator boundaryBegin();
 
    SpecialParticleIterator boundaryEnd();
 
    SpecialParticleIterator haloBegin();
 
    SpecialParticleIterator haloEnd();
 
    Cell &operator[](size_t index);
 
    const Cell &operator[](size_t index) const;
 
    std::vector<Cell> &getCells();
 
    const std::vector<Cell> &getCells() const;
 
    std::vector<std::reference_wrapper<Cell>> &getBorderCells();
 
    const std::vector<std::reference_wrapper<Cell>> &getBorderCells() const;
 
    std::vector<std::reference_wrapper<Cell>> &getHaloCells();
 
    const std::vector<std::reference_wrapper<Cell>> &getHaloCells() const;
 
    std::vector<std::reference_wrapper<Cell>> &getIterableCells();
 
    const std::vector<std::reference_wrapper<Cell>> &getIterableCells() const;
 
    void removeHaloCellParticles();
 
    int getCellIndex(const std::array<double, 3> &position);
 
    void deleteParticle(Particle &p);
 
    bool addParticle(Particle &p);
 
    bool moveParticle(Particle &p);
 
    std::array<int, 3> getVirtualCellCoordinates(int index) const;
 
    std::array<double, 3> getMirrorPosition(const std::array<double, 3> &position, const Cell &from, const Cell &to,
                                            int direction) const;
 
    int getOppositeNeighbor(int cellIndex, HaloLocation direction) const;
 
    void calculateNeighbors(int cellIndex);
 
    const std::vector<int> &getNeighbors(int cellIndex) const;
 
    std::vector<std::reference_wrapper<Cell>> getNeighborCells(int cellIndex);
 
    int getOppositeOfHalo(const Cell &from, HaloLocation location);
 
    int getOppositeOfBorder(const Cell &from, BorderLocation location);
 
    std::vector<int> getOppositeOfBorderCorner(const Cell &from, std::vector<BorderLocation> &locations);
 
    std::vector<std::vector<BorderLocation>> getBorderCombinations(std::vector<BorderLocation> &locations);
 
    const std::array<double, 3> &getDomainSize() const;
 
    const std::array<double, 3> &getCellSize() const;
 
    const std::array<size_t, 3> &getNumCells() const;
 
    const std::array<BoundaryCondition, 6> &getConditions() const;
 
    double getCutoff() const;
 
    size_t getDim() const;
 
    bool getAnyPeriodic() const;
 
    ParticleContainer &getParticles();
 
    const ParticleContainer &getParticles() const;
 
    size_t size() const;
 
    size_t activeSize() const;
 
    void printCellIndices() const;
 
    void printCellContents() const;
};