Domain.h

Go to the documentation of this file.

//Copyright (c) 2013-2020, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


#ifndef Domain_H
#define Domain_H

#include "BaseObject.h"
#include "MpiContainer.h"
#include "Math/Vector.h"
#include "ParticleHandler.h"
#include <vector>
#include <set>

class DPMBase;

class DomainHandler;

class BaseParticle;

class MPIParticle;

class MPIParticlePosition;

class MPIParticleVelocity;

class MPIParticleForce;

class Domain final : public BaseObject
{
public:
    Domain();
    
    explicit Domain(std::vector<unsigned> globalMeshIndex);
    
    Domain(const Domain& d);
    
    ~Domain() override;
    
    void constructor();
    
    virtual Domain* copy() const;
    
    void read(std::istream& is) override;
    
    void write(std::ostream& os) const override;
    
    std::string getName() const override;
    
    void setRange(Direction direction, Mdouble min, Mdouble max);
    
    void setBounds(std::vector<double> domainLeft, std::vector<double> domainRight, bool computeMiddle);
    
    std::vector<double> getDomainMin();
    
    std::vector<double> getDomainMax();
    
    int getRank();
    
    void setRank(int rank);
    
    void setHandler(DomainHandler* handler);
    
    DomainHandler* getHandler() const;
    
    int getGlobalIndex();
    
    std::vector<unsigned> getGlobalMeshIndex();
    
    void setGlobalMeshIndex(std::vector<unsigned> globalMeshIndex);
    
    void disableBoundary(unsigned localIndex);
    
    void disableBoundaries();
    
    std::vector<bool> getActiveBoundaryList();
    
    bool containsParticle(BaseParticle* particle, Mdouble offset = 0.0);
    
    bool isInGreaterDomain(BaseParticle* particle);
    
    bool isInInnerDomain(BaseParticle* particle);
    
    bool isInCommunicationZone(BaseParticle* particle);
    
    void createLookUpTable();
    
    int getLocalIndex(int i, int j, int k);
    
    int getLocalIndex(std::vector<int> localMeshIndex);
    
    std::vector<int> getLocalIndexInverse(int localMeshIndex);
    
    BaseParticle* findParticleInList(unsigned int identification, std::vector<BaseParticle*> particleList);
    
    std::vector<int> findNearbyBoundaries(BaseParticle* particle, Mdouble offset = 0);
    
    bool inBoundary(BaseParticle* particle, int localIndex);
    
    void addParticlesToLists(BaseParticle* particle, std::vector<std::vector<BaseParticle*> >& list);
    
    void findNewMPIParticles(const ParticleHandler& particleHandler);
    
    void findNewMPIParticle(BaseParticle* particle);

    /*
     * Checks whether a particle is in the list of new particles received by this thread
     */
    bool isInNewBoundaryParticleList(BaseParticle* object,int localIndex) const;
    void findNewMPIInteractions();
    
    void collectBoundaryParticleData(int localIndex);
    
    void collectInteractionData(int localIndex);
    
    void processReceivedBoundaryParticleData(unsigned index, std::vector<BaseParticle*>& newParticles);
    
    void processSentBoundaryParticles(unsigned index);
    
    void processReceivedInteractionData(unsigned index, std::vector<BaseParticle*>& newParticles);

    /*
     * Writes a list of all MPI particles on each thread to the logger.
     */
    void debugInformation();

    void
    sendAndReceiveCount(MercuryMPITag tag, unsigned& countReceive, unsigned& countSend, unsigned localIndexNeighbour);
    
    void prepareBoundaryDataTransmission();
    
    void prepareBoundaryDataTransmission(BaseParticle* particle);
    
    void performBoundaryDataTransmission();
    
    void finaliseBoundaryDataTransmission();
    
    void updateParticles(std::set<BaseParticle*>& ghostParticlesToBeDeleted);
    
    void updateParticlePosition(int localIndex);
    
    void updateParticleVelocity(int localIndex);
    
    void preparePositionAndVelocityUpdate();
    
    void finalisePositionAndVelocityUpdate(std::set<BaseParticle*>& ghostParticlesToBeDeleted);
    
    void prepareVelocityUpdate();
    
    void finaliseVelocityUpdate();
    
    template<typename T>
    void sendAndReceiveMPIData(MercuryMPITag tag, MercuryMPIType type,
                               T* receiveData, unsigned receiveCount,
                               T* sendData, unsigned sendCount, unsigned localIndexNeighbour)
    {
        int globalIndexNeighbour = localIndexToGlobalIndexTable_[localIndexNeighbour];
        int processor = localIndexToProcessorList_[localIndexNeighbour];
        int tagReceive = globalIndexNeighbour * MAX_PROC + globalIndex_ * 10 + tag;
        int tagSend = globalIndex_ * MAX_PROC + globalIndexNeighbour * 10 + tag;
        
        //Communicate the requests
        if (receiveCount != 0)
        {
            MPIContainer::Instance().receive(receiveData, type, receiveCount, processor, tagReceive);
        }
        if (sendCount != 0)
        {
            MPIContainer::Instance().send(sendData, type, sendCount, processor, tagSend);
        }
    }
    
    void addNewParticles();
    
    void addParticle(BaseParticle* particle);
    
    void updateStatus(std::set<BaseParticle*>& ghostParticlesToBeDeleted);
    
    void updateVelocity();
    
    unsigned int getNumberOfMPIParticles();
    
    unsigned int getNumberOfTrueMPIParticles();
    
    void flushParticles(std::set<BaseParticle*>& toBeDeletedList);
    
    void flushParticlesFromList(std::vector<BaseParticle*>& list, std::set<BaseParticle*>& toBeDeletedList);
    
    Vec3D getMiddle() const ;

    void cleanCommunicationLists();
    
    void cleanCommunicationList(std::vector<BaseParticle*>& list);

private:
    DomainHandler* domainHandler_;
    
    std::vector<double> domainMin_;
    
    std::vector<double> domainMax_;
    
    Vec3D middle_;
    
    int globalIndex_;
    
    std::vector<unsigned> globalMeshIndex_;
    
    std::vector<int> localIndexToGlobalIndexTable_;
    
    std::vector<int> localIndexToProcessorList_;
    
    std::vector<bool> activeBoundaryList_;
    
    std::vector<int> boundaryList_;
    
    std::vector<std::vector<BaseParticle*> > boundaryParticleList_;
    
    std::vector<std::vector<BaseParticle*> > boundaryParticleListNeighbour_;
    
    std::vector<std::vector<BaseParticle*> > newBoundaryParticleList_;
    
    std::vector<std::vector<BaseInteraction*> > newInteractionList_;
    
    std::vector<unsigned> numberOfParticlesSend_;
    
    std::vector<unsigned> numberOfParticlesReceive_;
    
    std::vector<unsigned> numNewInteractionsSend_;
    
    std::vector<unsigned> numNewInteractionsReceive_;
    
    std::vector<std::vector<MPIParticle> > boundaryParticleDataSend_;
    
    std::vector<std::vector<MPIParticle> > boundaryParticleDataReceive_;
    
    std::vector<std::vector<MPIParticlePosition> > updatePositionDataSend_;
    
    std::vector<std::vector<MPIParticlePosition> > updatePositionDataReceive_;
    
    std::vector<std::vector<MPIParticleVelocity> > updateVelocityDataSend_;
    
    std::vector<std::vector<MPIParticleVelocity> > updateVelocityDataReceive_;
    
    std::vector<void*> interactionDataSend_;
    
    std::vector<void*> interactionDataReceive_;
    
    int rank_;
};

#endif