BaseInteractable.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 BASEINTERACTABLE_H
#define BASEINTERACTABLE_H
 
#include <functional>
#include <vector>
#include "BaseObject.h"
#include "Math/Vector.h"
#include "Math/Quaternion.h"
 
class BaseParticle;
 
class ParticleSpecies;
 
class BaseInteraction;
 
class InteractionHandler;
 
class BaseInteractable : public BaseObject
{
public:
    BaseInteractable();
    
    BaseInteractable(const BaseInteractable& p);
    
    ~BaseInteractable() override;
    
    void read(std::istream& is) override;
    
    void write(std::ostream& os) const override;
    
    unsigned int getIndSpecies() const
    { return indSpecies_; }
    
    virtual void setIndSpecies(unsigned int indSpecies)
    { indSpecies_ = indSpecies; }
    
    const ParticleSpecies* getSpecies() const
    {
        return species_;
    }
    
    void setSpecies(const ParticleSpecies* species);
    
    const Vec3D& getForce() const
    { return force_; }
    
    const Vec3D& getTorque() const
    { return torque_; }
    
    void setForce(const Vec3D& force)
    { force_ = force; }
    
    void setTorque(const Vec3D& torque)
    { torque_ = torque; }
    
    void addForce(const Vec3D& addForce);
    
    void addTorque(const Vec3D& addTorque);
    
    /*
     * This function sets the forces and torques acting on an interactable (particle/wall) to zero at teh beginning of computeOneTimeStep.
     *
     * For omp simulations, it further sets does the first step of summing up all forces (and torques) acting on an interactable.
     * It is step 1 of the add-by-reduction approach:
     *  1. Declare a vector forceOMP_, one element per thread, and set it to zero.
     *  2. When a new force needs to be added to the interactable, don't add it immediately.
     *     Add it to forceOMP_[threadNum] instead
     *  3. Add all forces in forceOMP_ together to force_.
     * This reduction approach allows step 2 to be run in parallel, while step 3 needs to be done in sequence.
     * It is efficient, since step 3 is much quicker than step 2.
     */
    virtual void resetForceTorque(int numberOfOMPthreads);
    
    /*
     * This function does the last step of summing up all forces (and torques) acting on an interactable.
     * It is step 3 of the add-by-reduction approach:
     *  1. Declare a vector forceOMP_, one element per thread, and set it to zero.
     *  2. When a new force needs to be added to the interactable, don't add it immediately.
     *     Add it to forceOMP_[threadNum] instead
     *  3. Add all forces in forceOMP_ together to force_.
     * This reduction approach allows step 2 to be run in parallel, while step 3 needs to be done in sequence.
     * It is efficient, since step 3 is much quicker than step 2.
     */
    void sumForceTorqueOMP();
    
    const Vec3D& getPosition() const
    { return position_; }
    
    const Quaternion& getOrientation() const
    { return orientation_; }
    
    virtual void setPosition(const Vec3D& position)
    { position_ = position; }
    
    void setOrientationViaNormal(Vec3D normal);
    
    void setOrientationViaEuler(Vec3D eulerAngle);
    
    virtual void setOrientation(const Quaternion& orientation)
    { orientation_ = orientation; }
    
    virtual void move(const Vec3D& move);
    
    virtual void rotate(const Vec3D& angularVelocityDt);
    
    const std::vector<BaseInteraction*>& getInteractions() const
    { return interactions_; }
    
    void addInteraction(BaseInteraction* I);
    
    bool removeInteraction(BaseInteraction* I);
    
    void copyInteractionsForPeriodicParticles(const BaseInteractable& p);
    
    void setVelocity(const Vec3D& velocity);
    
    void setAngularVelocity(const Vec3D& angularVelocity);
    
    void addVelocity(const Vec3D& velocity)
    { velocity_ += velocity; }
    
    void addAngularVelocity(const Vec3D& angularVelocity);
    
    virtual const Vec3D& getVelocity() const;
    
    virtual const Vec3D& getAngularVelocity() const;
    
    void setPrescribedPosition(const std::function<Vec3D(double)>& prescribedPosition);
    
    void applyPrescribedPosition(double time);
    
    void setPrescribedVelocity(const std::function<Vec3D(double)>& prescribedVelocity);
    
    void applyPrescribedVelocity(double time);
    
    void setPrescribedOrientation(const std::function<Quaternion(double)>& prescribedOrientation);
    
    void applyPrescribedOrientation(double time);
    
    void setPrescribedAngularVelocity(const std::function<Vec3D(double)>& prescribedAngularVelocity);
    
    void applyPrescribedAngularVelocity(double time);
    
    virtual BaseInteraction* getInteractionWith(BaseParticle* P, unsigned timeStamp, InteractionHandler* interactionHandler)=0;
    
    virtual const Vec3D getVelocityAtContact(const Vec3D& contact) const;
    
    void integrateBeforeForceComputation(double time, double timeStep);
    
    void integrateAfterForceComputation(double time, double timeStep);
    
    virtual bool isFixed() const =0;
 
    virtual Mdouble getInvMass() const
    { return 0.0; }
 
    virtual Mdouble getCurvature(const Vec3D& labFixedCoordinates) const
    { return 0.0; }
 
    virtual bool isFaceContact(const Vec3D& normal) const {return true;}
 
private:
    std::function<Vec3D(double)> prescribedPosition_;
    
    std::function<Vec3D(double)> prescribedVelocity_;
    
    std::function<Quaternion(double)> prescribedOrientation_;
    
    std::function<Vec3D(double)> prescribedAngularVelocity_;
    
    Vec3D position_;
    
    Quaternion orientation_;
    
    Vec3D angularVelocity_;
    
    Vec3D force_;
    
    Vec3D torque_;
    
    /*
     * This variable is needed in omp simulations to sum up all forces (and torques) acting on an interactable.
     * It is used in an add-by-reduction approach:
     *  1. Declare a vector forceOMP_, one element per thread, and set it to zero.
     *  2. When a new force needs to be added to the interactable, don't add it immediately.
     *     Add it to forceOMP_[threadNum] instead
     *  3. Add all forces in forceOMP_ together to force_.
     * This reduction approach allows step 2 to be run in parallel, while step 3 needs to be done in sequence.
     * It is efficient, since step 3 is much quicker than step 2.
     */
    std::vector<Vec3D> forceOMP_;
    
    std::vector<Vec3D> torqueOMP_;
 
    const ParticleSpecies* species_;
    
    unsigned int indSpecies_;
    
    Vec3D velocity_;
    
    std::vector<BaseInteraction*> interactions_;
};
 
#endif