LinkedCells.h

#pragma once
 
#ifndef MARDYN_AUTOPAS
 
#include <vector>
#include <array>
#include <memory>
 
#include "particleContainer/ParticleContainer.h"
#include "particleContainer/ParticleIterator.h"
#include "particleContainer/RegionParticleIterator.h"
#include "particleContainer/ParticleCell.h"
 
#include "WrapOpenMP.h"
 
template<class CellTemplate>
class CellPairTraversals;
template<class CellTemplate>
class TraversalTuner;
 
class ResortCellProcessorSliced;
 
 
class LinkedCells : public ParticleContainer {
 
    friend class LinkedCellsTest;
#ifdef VTK
    friend class VTKGridWriter;
#endif
 
 
public:
    LinkedCells(
        double bBoxMin[3], double bBoxMax[3], double cutoffRadius
    );
 
    LinkedCells();
    ~LinkedCells();
 
    void readXML(XMLfileUnits& xmlconfig) override;
 
    int getHaloWidthNumCells() override {
        return _haloWidthInNumCells[0];
    }
 
    // documentation see father class (ParticleContainer.h)
    bool rebuild(double bBoxMin[3], double bBoxMax[3]) override;
 
    void update() override;
 
    void update_via_copies();
    void update_via_coloring();
    void update_via_traversal();
    void update_via_sliced_traversal();
 
    bool addParticle(Molecule& particle, bool inBoxCheckedAlready = false, bool checkWhetherDuplicate = false, const bool& rebuildCaches=false) override;
 
    void addParticles(std::vector<Molecule>& particles, bool checkWhetherDuplicate=false) override;
 
//  void traversePairs(ParticlePairsHandler* particlePairsHandler);
 
    void traverseCells(CellProcessor& cellProcessor) override;
 
    void traverseNonInnermostCells(CellProcessor& cellProcessor) override;
 
    void traversePartialInnermostCells(CellProcessor& cellProcessor, unsigned int stage, int stageCount) override;
 
    unsigned long getNumberOfParticles() override;
 
    // @todo: where is this function called?
    void clear() override;
 
    void deleteOuterParticles() override;
 
    double get_halo_L(int index) const override;
 
    double getCutoff() const override { return _cutoffRadius; }
    void setCutoff(double rc) override { _cutoffRadius = rc; }
 
    void deleteMolecule(ParticleIterator &moleculeIter, const bool& rebuildCaches) override;
    /* TODO: The particle container should not contain any physics, search a new place for this. */
    double getEnergy(ParticlePairsHandler* particlePairsHandler, Molecule* m1, CellProcessor& cellProcessor) override;
 
    int* getBoxWidthInNumCells() {
        return _boxWidthInNumCells;
    }
 
    double* getCellLength() override {
        return _cellLength;
    }
    
    std::variant<ParticleIterator, SingleCellIterator<ParticleCell>> getMoleculeAtPosition(const double pos[3]) override;
 
    unsigned long int getCellIndexOfMolecule(Molecule* molecule) const;
 
    unsigned long int getCellIndexOfPoint(const double point[3]) const;
 
    ParticleCell& getCellReference(int idx){ return _cells[idx];}
 
    // documentation in base class
    virtual void updateInnerMoleculeCaches() override;
 
    // documentation in base class
    virtual void updateBoundaryAndHaloMoleculeCaches() override;
 
    // documentation in base class
    virtual void updateMoleculeCaches() override;
 
    ParticleIterator iterator (ParticleIterator::Type t) override {
        ParticleIterator :: CellIndex_T offset = mardyn_get_thread_num();
        ParticleIterator :: CellIndex_T stride = mardyn_get_num_threads();
 
        return ParticleIterator(t, &_cells, offset, stride);
    }
    RegionParticleIterator regionIterator(const double startRegion[3], const double endRegion[3],
                                          ParticleIterator::Type type) override;
 
    size_t getTotalSize() override;
    void printSubInfo(int offset) override;
    std::string getName() override;
 
    bool requiresForceExchange() const override; // new
 
    unsigned long initCubicGrid(std::array<unsigned long, 3> numMoleculesPerDimension,
                                std::array<double, 3> simBoxLength, size_t seed_offset) override;
 
    std::vector<unsigned long> getParticleCellStatistics() override;
 
    std::string getConfigurationAsString() override;
 
private:
    //####################################
    //######### PRIVATE METHODS ##########
    //####################################
 
    void check_molecules_in_box();
 
    void initializeCells();
 
    void initializeTraversal();
 
    void calculateNeighbourIndices(std::vector<long>& forward, std::vector<long>& backward) const;
 
    std::array<std::pair<unsigned long, unsigned long>, 14> calculateCellPairOffsets() const;
 
    long int cellIndexOf3DIndex(long int xIndex, long int yIndex, long int zIndex) const;
 
    void threeDIndexOfCellIndex(int ind, int r[3], const int dim[3]) const;
 
    void deleteParticlesOutsideBox(double boxMin[3], double boxMax[3]);
 
    void getCellIndicesOfRegion(const double startRegion[3], const double endRegion[3], unsigned int &startRegionCellIndex, unsigned int &endRegionCellIndex);
 
    RegionParticleIterator getRegionParticleIterator(
            const double startRegion[3], const double endRegion[3],
            const unsigned int startRegionCellIndex,
            const unsigned int endRegionCellIndex, ParticleIterator::Type type);
 
    //####################################
    //##### PRIVATE MEMBER VARIABLES #####
    //####################################
 
    std::vector<ParticleCell> _cells; 
 
    std::vector<unsigned long> _haloCellIndices; 
 
    std::unique_ptr<TraversalTuner<ParticleCell>> _traversalTuner; // new
 
    double _haloBoundingBoxMin[3]; 
    double _haloBoundingBoxMax[3]; 
 
    int _cellsPerDimension[3]; 
    int _haloWidthInNumCells[3]; 
    int _boxWidthInNumCells[3]; 
    double _haloLength[3]; 
    double _cellLength[3]; 
    double _cellLengthReciprocal[3]; 
    double _cutoffRadius; 
    unsigned _cellsInCutoff = 1; 
 
    bool _cellsValid;
 
    ResortCellProcessorSliced * _resortCellProcessorSliced;
};
 
#endif  // MARDYN_AUTOPAS