BaseParticle.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 BASEPARTICLE_H
#define BASEPARTICLE_H
 
#include <vector>
#include "Math/Vector.h"
#include "BaseInteractable.h"
#include "HGridCell.h"
#include "Species/ParticleSpecies.h"
 
class ParticleHandler;
 
class SpeciesHandler;
 
class HGrid;
 
class BaseInteraction;
 
#ifdef CONTACT_LIST_HGRID
class PossibleContact;
#endif
 
class BaseParticle : public BaseInteractable
{
public:
    BaseParticle();
    
    BaseParticle(const BaseParticle& p);
    
    explicit BaseParticle(const ParticleSpecies* s);
    
    ~BaseParticle() override;
    
    virtual BaseParticle* copy() const = 0;
 
    virtual Mdouble getVolume() const;
    
    void fixParticle();
    
    bool isFixed() const override
    { return (invMass_ == 0.0); }
    
    bool isMPIParticle() const;
    
    void setMPIParticle(bool flag);
    
    bool isInMPIDomain();
    
    void setInMPIDomain(bool flag);
    
    bool isInPeriodicDomain() const;
    
    void setInPeriodicDomain(bool flag);
    
    bool isPeriodicGhostParticle() const;
    
    void setPeriodicGhostParticle(bool flag);
    
    bool isMaserParticle() const;
    
    void setMaserParticle(bool flag);
    
    void setCommunicationComplexity(unsigned complexity);
    
    unsigned getCommunicationComplexity();
    
    void setPeriodicComplexity(std::vector<int> complexity);
    
    void setPeriodicComplexity(int index, int value);
    
    const std::vector<int>& getPeriodicComplexity();
    
    void setPreviousPeriodicComplexity(std::vector<int> complexity);
    
    const std::vector<int>& getPreviousPeriodicComplexity() const;
    
    int getPeriodicComplexity(int index);
    
    //void setCurrentPeriodicPosition(Vec3D position);
    
    //Vec3D getCurrentPeriodicPosition();   
    
    void unfix();
    
    void read(std::istream& is) override;
    
    virtual void oldRead(std::istream& is);
    
    void write(std::ostream& os) const override;
    
    std::string getName() const override;
    
    virtual void setInfo(Mdouble info);
    
    virtual Mdouble getInfo() const;
 
    void setTimeStamp(unsigned timeStamp);
 
    unsigned getTimeStamp() const;
    
    void printHGrid(std::ostream& os) const;
    
    unsigned int getHGridLevel() const
    { return hGridCell.getHGridLevel(); }
    
    BaseParticle* getHGridNextObject() const
    { return hGridNextObject_; }
    
    BaseParticle* getHGridPrevObject() const
    { return hGridPrevObject_; }
 
#ifdef CONTACT_LIST_HGRID
    
    PossibleContact* getFirstPossibleContact() const;
#endif
    
    int getHGridX() const
    { return hGridCell.getHGridX(); }
    
    int getHGridY() const
    { return hGridCell.getHGridY(); }
    
    int getHGridZ() const
    { return hGridCell.getHGridZ(); }
    
    MatrixSymmetric3D getInvInertia() const
    { return invInertia_; }
    
    Mdouble getInvMass() const override
    { return invMass_; }
 
    Mdouble getCurvature(const Vec3D& labFixedCoordinates) const override
    { return 1.0/radius_; }
 
    virtual Mdouble getKineticEnergy() const;
    
    virtual Mdouble getRotationalEnergy() const;
    
    Mdouble getGravitationalEnergy() const;
    
    Mdouble getMass() const
    { return 1.0 / invMass_; }
 
    virtual Mdouble getSurfaceArea() const
    { return 4.0*constants::pi*getRadius()*getRadius(); }
    
    Vec3D getMomentum() const
    { return getVelocity() / invMass_; }
 
    MatrixSymmetric3D getInertia() const
    { return invInertia_.inverse(); }
    
    Vec3D getAngularMomentum() const;
 
    BaseParticle* getPeriodicFromParticle() const
    { return periodicFromParticle_; }
    
    Mdouble getRadius() const
    { return radius_; }
    
    Mdouble getMaxInteractionRadius() const {
        return getRadius() + getSpecies()->getMaxInteractionDistance() * 0.5;
    }
    
    Mdouble getInteractionDistance(const BaseInteractable* i) const
    {
        //const auto mixedSpecies = getSpecies()->getHandler()->getMixedObject(getSpecies(),particle->getSpecies());
        //return mixedSpecies->getInteractionDistance();
        return getSpecies()->getMixedSpecies(i->getSpecies())->getInteractionDistance();
    }
    
    Mdouble getSumOfInteractionRadii(const BaseParticle* particle) const {
        return getRadius() + particle->getRadius() + getInteractionDistance((const BaseInteractable*)particle);
    }
    
    Mdouble getWallInteractionRadius(const BaseWall* wall) const {
        return getRadius() + getInteractionDistance((const BaseInteractable*)wall);
    }
 
    const Vec3D& getPreviousPosition() const
    { return previousPosition_; }
    
    const Vec3D getDisplacement2(Mdouble xmin, Mdouble xmax, Mdouble ymin, Mdouble ymax, Mdouble zmin, Mdouble zmax,
                                 Mdouble t) const;
    
    virtual void setInertia();
    
    void setInertia(MatrixSymmetric3D inertia);
    
    void setInverseInertia(MatrixSymmetric3D inverseInertia);
    
    void setInfiniteInertia();
    
    void setPeriodicFromParticle(BaseParticle* p)
    { periodicFromParticle_ = p; };
    
    void setHGridX(const int x)
    { hGridCell.setHGridX(x); }
    
    void setHGridY(const int y)
    { hGridCell.setHGridY(y); }
    
    void setHGridZ(const int z)
    { hGridCell.setHGridZ(z); }
    
    void setHGridLevel(const unsigned int level)
    { hGridCell.setHGridLevel(level); }
    
    void setHGridNextObject(BaseParticle* p)
    { hGridNextObject_ = p; }
    
    void setHGridPrevObject(BaseParticle* p)
    { hGridPrevObject_ = p; }
 
#ifdef CONTACT_LIST_HGRID
    void setFirstPossibleContact(PossibleContact* PC);
#endif
    
    virtual void setRadius(Mdouble radius);
    
    /*
     * The below 6 functions had to be declared virtual here in order to allow access of these functions in ParticleHandler class in the function writeVTK.
     */
    
    virtual Vec3D getAxes() const;
    
    virtual Mdouble getExponentEps1() const;
    
    virtual Mdouble getExponentEps2() const;
    
    
    virtual void setAxes(const Vec3D& axes){ }
    
    virtual void setExponents(const Mdouble& eps1, const Mdouble& eps2){}
    
    //
    MERCURYDPM_DEPRECATED
    void setMass(Mdouble mass);
    
    void setMassForP3Statistics(Mdouble mass);
 
    void setPreviousPosition(const Vec3D& pos);
    
    void movePrevious(const Vec3D& posMove);
    
    void accelerate(const Vec3D& vel);
    
    void angularAccelerate(const Vec3D& angVel);
 
    void setHandler(ParticleHandler* handler);
    
    ParticleHandler* getHandler() const;
    
    BaseInteraction* getInteractionWith(BaseParticle* P, unsigned timeStamp, InteractionHandler* interactionHandler) override;
    
    virtual bool isInContactWith(const BaseParticle* P) const;
    
    virtual void integrateBeforeForceComputation(double time, double timeStep);
    
    virtual void integrateAfterForceComputation(double time, double timeStep);
    
    unsigned int getParticleDimensions() const;
    
    MERCURYDPM_DEPRECATED
    void setIndSpecies(unsigned int indSpecies) override;
    
    virtual void setSpecies(const ParticleSpecies* species);
 
    virtual void actionsBeforeTimeStep() {}
 
    virtual unsigned getNumberOfFieldsVTK() const;
    
    virtual std::string getTypeVTK(unsigned i) const;
    
    virtual std::string getNameVTK(unsigned i) const;
    
    virtual std::vector<Mdouble> getFieldVTK(unsigned i) const;
    
    virtual void actionsAfterTimeStep() {}
 
    virtual bool isSphericalParticle() const = 0;
 
    //const HGridCell& getHGridCell() const;
    const HGridCell& getHGridCell() const
    { return hGridCell; }
 
    virtual void computeMass(const ParticleSpecies& s);
 
    BaseParticle* getClump() const
    {
        return clumpParticle_;
    }
 
    bool isClump() const
    {
        return isClump_;
    }
 
    bool isPebble() const
    {
        return isPebble_;
    }
 
    virtual Vec3D getCenterOfMass() {return Vec3D(0,0,0);}
    //+++++++++++++++++++++++++++++
 
 
public:
 
    Mdouble radius_; 
    Mdouble invMass_; 
    MatrixSymmetric3D invInertia_; 
 
private:
 
    ParticleHandler* handler_;
 
#ifdef CONTACT_LIST_HGRID
    PossibleContact* firstPossibleContact;
#endif
    
    HGridCell hGridCell;
    
    BaseParticle* hGridNextObject_; 
    BaseParticle* hGridPrevObject_; 
    
    BaseParticle* periodicFromParticle_; 
    
    //MPI particle attributes
    bool isMPIParticle_; 
    bool isInMPIDomain_; 
    unsigned communicationComplexity_; //Determins if the particle in the corner of a domain, rib, side or not at all
    
    //Periodic boundary particle attributes
    bool isInPeriodicDomain_; 
    bool isPeriodicGhostParticle_; 
    std::vector<int> previousPeriodicComplexity_; 
    std::vector<int> periodicComplexity_;  
    bool isMaserParticle_; 
 
    Vec3D previousPosition_; 
    
    friend void ParticleSpecies::computeMass(BaseParticle*) const;
    
    Mdouble info_; // by default, the species ID (if a species is set)
 
    unsigned timeStamp_;
 
public:
 
    virtual void actionsAfterAddObject() {} 
 
    BaseParticle* clumpParticle_; 
 
    bool isPebble_; 
 
    bool isClump_; 
};
 
#endif