BaseInteraction.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 BASEINTERACTION_H
#define BASEINTERACTION_H

#include <vector>
#include "BaseObject.h"
#include "Math/Vector.h"
#include "Math/Matrix.h"
#include "Logger.h"

class InteractionHandler;

class BaseParticle;

class BaseWall;

class BaseSpecies;

class BaseInteractable;


class BaseInteraction : public BaseObject
{
public:
    BaseInteraction(BaseInteractable* P, BaseInteractable* I, unsigned timeStamp);
    
    BaseInteraction();
    
    BaseInteraction(const BaseInteraction& p);
    
    ~BaseInteraction() override;
    
    virtual void actionsOnErase()
    {};
    
    virtual void computeForce();
    
    void read(std::istream& is) override;
    
    void write(std::ostream& os) const override;
    
    void writeToFStat(std::ostream& os, Mdouble time) const;
    
    std::string getName() const override;
    
    virtual Mdouble getElasticEnergy() const;
    
    void setDistance(Mdouble distance);
    
    void setNormal(Vec3D normal);
    
    void setOverlap(Mdouble overlap);
    
    void setContactPoint(Vec3D contactPoint);
    
    void setTimeStamp(unsigned timeStamp);
    
    void setSpecies(const BaseSpecies* species);
    
    void setP(BaseInteractable* P);
    
    void setI(BaseInteractable* I);

    void importP(BaseInteractable *P);

    void importI(BaseInteractable *I);
    
    Vec3D getIP() const;
    
    Vec3D getIC() const;
    
    Vec3D getCP() const;
    
    void setLagrangeMultiplier(Mdouble multiplier)
    {
        lagrangeMultiplier_ = multiplier;
    }
    
    Mdouble getLagrangeMultiplier()
    {
        return lagrangeMultiplier_;
    }
    
    void setHandler(InteractionHandler* handler);
    
    InteractionHandler* getHandler() const;
    
    const Vec3D& getForce() const
    { return force_; }
    
    const Vec3D& getTorque() const
    { return torque_; }
    
    const Vec3D& getNormal() const
    { return normal_; }
    
    const Vec3D& getContactPoint() const
    { return contactPoint_; }
    
    Mdouble getOverlap() const
    { return overlap_; }
    
    Mdouble getContactRadius() const;
    
    void removeFromHandler();
    
    void copySwitchPointer(const BaseInteractable* original, BaseInteractable* ghost) const;
    
    void gatherContactStatistics();
    
    BaseInteractable* getP()
    {
        logger.assert(P_ != nullptr, "First particle in interaction % is nullptr", getId());
        return P_;
    }
    
    BaseInteractable* getI()
    {
        logger.assert(I_ != nullptr, "Second particle in interaction % is nullptr", getId());
        return I_;
    }
    
    const BaseInteractable* getP() const
    {
        logger.assert(P_ != nullptr, "First particle in interaction % is nullptr", getId());
        return P_;
    }
    
    const BaseInteractable* getI() const
    {
        logger.assert(I_ != nullptr, "Second particle in interaction % is nullptr", getId());
        return I_;
    }
    
    Mdouble getTimeStamp() const
    { return timeStamp_; }
    
    virtual void integrate(Mdouble timeStep);
    
    virtual Mdouble getTangentialOverlap() const;
    
    Mdouble getDistance() const;
    
    const Vec3D& getRelativeVelocity() const;
    
    Mdouble getNormalRelativeVelocity() const;
    
    Mdouble getAbsoluteNormalForce() const;
    
    virtual BaseInteraction* copy() const = 0;
    
    void setFStatData(std::fstream& fstat, BaseParticle* P, BaseWall* I);
    
    void setFStatData(std::fstream& fstat, BaseParticle* P, BaseParticle* I);
    
    unsigned int getMultiContactIdentifier() const;
    
    void setMultiContactIdentifier(unsigned int multiContactIdentifier_);
    
    virtual void rotateHistory(Matrix3D& rotationMatrix);
    
    virtual void actionsAfterTimeStep();
    
    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;
    
    void setForce(Vec3D force);

protected:
    
    virtual const Vec3D getTangentialForce() const;
    
    Mdouble getEffectiveRadius() const;
    
    Mdouble getEffectiveMass() const;
    
    //functions that only the derived Interactions have to know about:
    void addForce(Vec3D force);
    
    /*
     * \brief add a torque increment to the total torque.
     */
    void addTorque(Vec3D torque);
    
    //these functions are only used for normal forces and should be made private by the normal forces:
    
    void setTorque(Vec3D torque);
    
    void setRelativeVelocity(Vec3D relativeVelocity);
    
    void setNormalRelativeVelocity(Mdouble normalRelativeVelocit);
    
    void setAbsoluteNormalForce(Mdouble absoluteNormalForce);
    
    virtual Mdouble getElasticEnergyAtEquilibrium(Mdouble adhesiveForce) const
    { return 0; }
    
    virtual void reverseHistory();
    
    
    void writeInteraction(std::ostream& os, bool created) const;

public:
    
    const BaseSpecies* getBaseSpecies() const;
    
    // create the mpi data type for the history data class
    virtual void createMPIType();
    
    // creates the array for the history data
    virtual void* createMPIInteractionDataArray(unsigned int numberOfInteractions) const;
    
    virtual void deleteMPIInteractionDataArray(void* dataArray);
    
    virtual void getMPIInteraction(void* historyDataArray, unsigned int index) const;
    
    
    virtual void getInteractionDetails(void* interactionDataArray, unsigned int index, unsigned int& identificationP,
                                       unsigned int& identificationI, bool& isWallInteraction, unsigned& timeStamp);
    
    
    //Sets the interactionData from the MPI class into the current thingy
    virtual void setMPIInteraction(void* interactionDataArray, unsigned int index, bool resetPointers);
    
    void
    setBasicMPIInteractionValues(int P, int I, unsigned timeStamp, Vec3D force, Vec3D torque, bool isWallInteraction,
                                 bool resetPointers);
    
    void setIdentificationP(unsigned int identification);
    
    void setIdentificationI(int identification);
    
    void setWallInteraction(bool flag);
    
    unsigned int getIdentificationP();
    
    int getIdentificationI();
    
    bool isWallInteraction();

    // returns true is the interaction is an 'internal' bond.
    // This is used in BaseInteraction::writeToFstat to detect internal bonds;
    // these internal forces are not written to fstat and thus don't contribute to fstatistics.
    virtual bool isBonded() const {return false;}

private:
    
    
    InteractionHandler* handler_;
    
    BaseInteractable* P_;
    
    BaseInteractable* I_;
    
    
    // used in mpi code, which can't deal with the pointers above
    unsigned int identificationP_;
    int identificationI_;
    bool isWallInteraction_;
    
    Vec3D contactPoint_;
    
    Vec3D relativeVelocity_;
    
    Mdouble normalRelativeVelocity_;
    
    Mdouble absoluteNormalForce_;
    
    Mdouble distance_;
    
    Vec3D force_;
    
    Vec3D torque_;
    
    unsigned timeStamp_;
    
    Vec3D normal_;
    
    Mdouble overlap_;
    
    const BaseSpecies* species_;
    
    Mdouble lagrangeMultiplier_;

    unsigned multiContactIdentifier_;
};

#endif