GeneralDomainDecomposition.h

Go to the documentation of this file.

 
#pragma once
 
#include <optional>
 
#include "DomainDecompMPIBase.h"
#include "LoadBalancer.h"
 
class GeneralDomainDecomposition : public DomainDecompMPIBase {
public:
    GeneralDomainDecomposition(double interactionLength, Domain* domain, bool forceGrid);
 
    // documentation see father class (DomainDecompBase.h)
    ~~GeneralDomainDecomposition() override;
 
    void readXML(XMLfileUnits& xmlconfig) override;
 
    // documentation see father class (DomainDecompBase.h)
    double getBoundingBoxMin(int dimension, Domain* domain) override;
 
    // documentation see father class (DomainDecompBase.h)
    double getBoundingBoxMax(int dimension, Domain* domain) override;
 
    void balanceAndExchange(double lastTraversalTime, bool forceRebalancing, ParticleContainer* moleculeContainer,
                            Domain* domain) override;
 
    // returns a vector of the neighbour ranks in x y and z direction (only neighbours connected by an area to local
    // area)
    std::vector<int> getNeighbourRanks() override {
        throw std::runtime_error("GeneralDomainDecomposition::getNeighbourRanks() not yet implemented");
    }
 
    // returns a vector of all 26 neighbour ranks in x y and z direction
    std::vector<int> getNeighbourRanksFullShell() override {
        throw std::runtime_error("GeneralDomainDecomposition::getNeighbourRanksFullShell() not yet implemented");
    }
 
    // documentation in base class
    void prepareNonBlockingStage(bool forceRebalancing, ParticleContainer* moleculeContainer, Domain* domain,
                                 unsigned int stageNumber) override {
        throw std::runtime_error("GeneralDomainDecomposition::prepareNonBlockingStage() not yet implemented");
    }
 
    // documentation in base class
    void finishNonBlockingStage(bool forceRebalancing, ParticleContainer* moleculeContainer, Domain* domain,
                                unsigned int stageNumber) override {
        throw std::runtime_error("GeneralDomainDecomposition::prepareNonBlockingStage() not yet implemented");
    }
 
    // documentation in base class
    bool queryBalanceAndExchangeNonBlocking(bool forceRebalancing, ParticleContainer* moleculeContainer, Domain* domain,
                                            double etime) override {
        throw std::runtime_error(
            "GeneralDomainDecomposition::queryBalanceAndExchangeNonBlocking() not yet implemented");
    }
 
    std::vector<CommunicationPartner> getNeighboursFromHaloRegion(Domain* domain, const HaloRegion& haloRegion,
                                                                  double cutoff) override {
        throw std::runtime_error("GeneralDomainDecomposition::getNeighboursFromHaloRegion() not yet implemented");
    }
 
private:
    void initializeALL();
 
    static std::array<size_t, 3> getOptimalGrid(const std::array<double, 3>& domainLength, int numProcs);
 
    static std::array<size_t, 3> getCoordsFromRank(const std::array<size_t, 3>& gridSize, int rank);
 
    static std::tuple<std::array<double, 3>, std::array<double, 3>> initializeRegularGrid(
        const std::array<double, 3>& domainLength, const std::array<size_t, 3>& gridSize,
        const std::array<size_t, 3>& gridCoords);
 
    static bool queryRebalancing(size_t step, size_t updateFrequency, size_t initPhase, size_t initUpdateFrequency,
                                 double lastTraversalTime);
 
    void initCommPartners(ParticleContainer* moleculeContainer, Domain* domain);
 
    void migrateParticles(Domain* domain, ParticleContainer* particleContainer, std::array<double, 3> newMin,
                          std::array<double, 3> newMax);
 
    std::pair<std::array<double, 3>, std::array<double, 3>> latchToGridSize(std::array<double, 3> boxMin,
                                                                            std::array<double, 3> boxMax) {
        for (size_t ind = 0; ind < 3; ++ind) {
            double currentGridSize = (*_gridSize)[ind];
            // For boxmin, the lower domain boundary is 0, so that's always fine!
            boxMin[ind] = std::round(boxMin[ind] / currentGridSize) * currentGridSize;
            // update boxmax only if it isn't at the very top of the domain!
            if (boxMax[ind] != _domainLength[ind]) {
                boxMax[ind] = std::round(boxMax[ind] / currentGridSize) * currentGridSize;
            }
        }
        return {boxMin, boxMax};
    }
 
    // variables
    std::array<double, 3> _boxMin;
    std::array<double, 3> _boxMax;
 
    std::array<double, 3> _domainLength;
    double _interactionLength;
 
    size_t _steps{0};
    size_t _rebuildFrequency{10000};
 
    size_t _initPhase{0};
    size_t _initFrequency{500};
 
    std::optional<std::array<double, 3>> _gridSize{};
 
    bool _forceLatchingToLinkedCellsGrid{false};
 
    std::unique_ptr<LoadBalancer> _loadBalancer{nullptr};
 
    friend class GeneralDomainDecompositionTest;
};