ParticleHandler.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef PARTICLE_HANDLER_H
#define PARTICLE_HANDLER_H
 
#include "BaseHandler.h"
#include "Particles/BaseParticle.h"
#include "Math/PSD.h"
 
class SpeciesHandler;
 
class BaseSpecies;
 
enum AttributeType
{
    MIN = 0, MAX = 1
};
 
class ParticleHandler : public BaseHandler<BaseParticle>
{
public:
    ParticleHandler();
    
    ParticleHandler(const ParticleHandler& PH);
    
    ParticleHandler& operator=(const ParticleHandler& rhs);
    
    ~ParticleHandler() override;
    
    void addExistingObject(BaseParticle* P) override;
    
    void addObject(BaseParticle* P) override;
    
    void addObject(int fromProcessor, BaseParticle* P);
    
    void addGhostObject(int fromProcessor, int toProcessor, BaseParticle* p);
    
    void addGhostObject(BaseParticle* P) override;
    
    void removeObject(unsigned int index) override;
    
    void removeGhostObject(unsigned int index);
    
    void removeLastObject();
    
    void computeSmallestParticle();
    
    void computeLargestParticle();
    
    BaseParticle* getSmallestParticleLocal() const;
    
    BaseParticle* getSmallestParticle() const;
    
    BaseParticle* getLargestParticleLocal() const;
    
    BaseParticle* getLargestParticle() const;
    
    Mdouble getSmallestInteractionRadiusLocal() const;
    
    Mdouble getSmallestInteractionRadius() const;
    
    Mdouble getLargestInteractionRadiusLocal() const;
    
    Mdouble getLargestInteractionRadius() const;
    
    BaseParticle* getFastestParticleLocal() const;
    
    BaseParticle* getFastestParticle() const;
    
    Mdouble getKineticEnergy() const;
    
    Mdouble getRotationalEnergy() const;
    
    Mdouble getMass() const;
    
    Vec3D getMassTimesPosition() const;
    
    Vec3D getCentreOfMass() const;
    
    Vec3D getMomentum() const;
    
    Vec3D getAngularMomentum() const;
    
    Mdouble getVolume() const;
    
    Mdouble getMeanRadius() const;
    
    BaseParticle* getLowestPositionComponentParticleLocal(int i) const;
    
    BaseParticle* getLowestPositionComponentParticle(int i) const;
    
    BaseParticle* getHighestPositionComponentParticleLocal(int i) const;
    
    BaseParticle* getHighestPositionComponentParticle(int i) const;
    
    BaseParticle* getLowestVelocityComponentParticleLocal(int i) const;
    
    BaseParticle* getLowestVelocityComponentParticle(int i) const;
    
    BaseParticle* getHighestVelocityComponentParticleLocal(int i) const;
    
    BaseParticle* getHighestVelocityComponentParticle(int i) const;
    
    //Mdouble getParticleAttributeLocal(std::function<Mdouble (BaseParticle*)> attribute, AttributeType type) const;
    
    template<typename T>
    typename std::enable_if<std::is_scalar<T>::value, T>::type
    getParticleAttributeLocal(std::function<T(BaseParticle*)> attribute, AttributeType type) const
    {
        T attributeParticle;
        T attributeFinal;
        
        if ((*this).getSize() == 0)
        {
            logger(WARN, "ParticleHandler is empty: returning 0.0");
            attributeFinal = 0;
            return 0.0;
        }
        else
        {
            //Initialise with the first particle found
            attributeParticle = attribute(objects_[0]);
            attributeFinal = attributeParticle;
            
            //Find the final attribute
            for (BaseParticle* particle : (*this))
            {
                //Obtain the attribute
                if (!(particle->isMPIParticle() || particle->isPeriodicGhostParticle() || particle->isFixed()))
                {
                    attributeParticle = attribute(particle);
                }
                
                //Decide what to do with the magnitude of the attribute
                switch (type)
                {
                    case AttributeType::MIN :
                        if (attributeParticle < attributeFinal)
                        {
                            attributeFinal = attributeParticle;
                        }
                        break;
                    case AttributeType::MAX :
                        if (attributeParticle > attributeFinal)
                        {
                            attributeFinal = attributeParticle;
                        }
                        break;
                    default :
                        logger(ERROR, "Attribute type is not recognised");
                        break;
                }
            }
            return attributeFinal;
        }
    }
    
    template<typename T>
    typename std::enable_if<std::is_scalar<T>::value, T>::type
    getParticleAttribute(std::function<T(BaseParticle*)> attribute, AttributeType type) const
    {
#ifdef MERCURYDPM_USE_MPI
        T particleAttributeLocal = getParticleAttributeLocal(attribute, type);
        T particleAttributeGlobal;
 
        //Communicate local to global using the approriate rule
        MPIContainer& communicator = MPIContainer::Instance();
        switch(type)
        {
            case AttributeType::MIN :
                communicator.allReduce(particleAttributeLocal,particleAttributeGlobal,MPI_MIN);
                break;
            case AttributeType::MAX :
                communicator.allReduce(particleAttributeLocal,particleAttributeGlobal,MPI_MAX);
                break;
            default :
                logger(ERROR,"Attribute type is not recognised");
                break;
        }
        return particleAttributeGlobal;
#else
        return getParticleAttributeLocal(attribute, type);
#endif
    }
    
    Mdouble getHighestPositionX() const;
    
    void clear() override;
    
    unsigned int getNumberOfFixedParticles() const;
    
    unsigned int getNumberOfUnfixedParticles() const;
    
    static BaseParticle* createObject(const std::string& type);
    
    BaseParticle* readAndCreateObject(std::istream& is);
 
//    /*!
//     * \brief Create a new particle, based on the information from old-style restart data.
//     */
//    void readAndCreateOldObject(std::istream &is, const std::string& type);
    
    void readAndAddObject(std::istream& is) override;
    
    void write(std::ostream& os) const;
    
    void checkExtrema(BaseParticle* P);
    
    void checkExtremaOnDelete(BaseParticle* P);
    
    void computeAllMasses(unsigned int indSpecies);
    
    void computeAllMasses();
    
    void addedFixedParticle();
    
    void removedFixedParticle();
    
    std::string getName() const override;
    
    unsigned int getNumberOfRealObjects() const;
    
    unsigned int getNumberOfObjects() const override;
    
    unsigned int getNumberOfFixedObjectsLocal() const;
    
    unsigned int getNumberOfFixedObjects() const;
    
    unsigned int getNumberOfRealObjectsLocal() const;
 
    void actionsBeforeTimeStep();
 
    void actionsAfterTimeStep();
 
    double getLiquidFilmVolume() const;
 
    void saveNumberPSDtoCSV(std::string csvFileName, std::vector<double> diameterBins = {}) const;
 
    PSD getPSD(std::vector<Mdouble> bins = {}, Mdouble scaleFactor = 1.0) const;
 
private:
    
    Mdouble getKineticEnergyLocal() const;
    
    Mdouble getRotationalEnergyLocal() const;
    
    Mdouble getMassLocal() const;
    
    Mdouble getVolumeLocal() const;
    
    Vec3D getMassTimesPositionLocal() const;
    
    Mdouble getSumRadiusLocal() const;
    
    BaseParticle* largestParticle_;
    
    BaseParticle* smallestParticle_;
    
    unsigned int NFixedParticles_;
};
 
#endif