d2/dae/BaseParticle_8h_source.html

//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 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 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_; }


    Mdouble getKineticEnergy() const;


    Mdouble getRotationalEnergy() const;


    Mdouble getGravitationalEnergy() const;


    Mdouble getMass() const

    { return 1.0 / invMass_; }


    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& getDisplacement() const

    { return displacement_; }


    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){}


    //

    MERCURY_DEPRECATED

    void setMass(Mdouble mass);


    void setMassForP3Statistics(Mdouble mass);


    void setDisplacement(const Vec3D& disp);


    void setPreviousPosition(const Vec3D& pos);


    void movePrevious(const Vec3D& posMove);


    void accelerate(const Vec3D& vel);


    void angularAccelerate(const Vec3D& angVel);


    void addDisplacement(const Vec3D& addDisp);


    void setHandler(ParticleHandler* handler);


    ParticleHandler* getHandler() const;


    BaseInteraction* getInteractionWith(BaseParticle* P, unsigned timeStamp, InteractionHandler* interactionHandler) override;


    virtual bool isInContactWith(const BaseParticle* P) const;


    void integrateBeforeForceComputation(double time, double timeStep);


    void integrateAfterForceComputation(double time, double timeStep);


    unsigned int getParticleDimensions() const;


    MERCURY_DEPRECATED

    void setIndSpecies(unsigned int indSpecies) override;


    void setSpecies(const ParticleSpecies* species);


    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 {return false;}


    //const HGridCell& getHGridCell() const;

    const HGridCell& getHGridCell() const

    { return hGridCell; }


    virtual void computeMass(const ParticleSpecies& s);


protected:


    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 displacement_;

    Vec3D previousPosition_;


    friend void ParticleSpecies::computeMass(BaseParticle*) const;


    Mdouble info_; // by default, the species ID (if a species is set)

};


#endif