BaseInteractable.h

Go to the documentation of this file.

//Copyright (c) 2013-2014, 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 BASEINTERACTABLE_H
#define BASEINTERACTABLE_H

#include <list>
#include <functional>

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

class BaseParticle;
class ParticleSpecies;
class BaseInteraction;
class InteractionHandler;
class BaseInteractable : public BaseObject
{
public:
    BaseInteractable();

    BaseInteractable(const BaseInteractable &p);

    virtual ~BaseInteractable();

    virtual void read(std::istream& is) = 0;

    virtual void write(std::ostream& os) const = 0;

    unsigned int getIndSpecies() const;

    virtual void setIndSpecies(unsigned int indSpecies);

    const ParticleSpecies* getSpecies() const;

    void setSpecies(const ParticleSpecies* species);

    const Vec3D& getForce() const;

    const Vec3D& getTorque() const;

    void setForce(const Vec3D& force);

    void setTorque(const Vec3D& torque);

    void addForce(const Vec3D& addForce);

    void addTorque(const Vec3D& addTorque);

    const Vec3D& getPosition() const;

    const Vec3D& getOrientation() const;

    void setPosition(const Vec3D& position);

    void setOrientation(const Vec3D& orientation);

    virtual void move(const Vec3D& move);

    void rotate(const Vec3D& rotate);

    const std::list<BaseInteraction*>& getInteractions() const;

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

    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<Vec3D (double)>& prescribedOrientation);

    void applyPrescribedOrientation(double time);

    void setPrescribedAngularVelocity(const std::function<Vec3D (double)>& prescribedAngularVelocity);

    void applyPrescribedAngularVelocity(double time);

    virtual std::vector<BaseInteraction*> getInteractionWith(BaseParticle *P, Mdouble timeStamp, InteractionHandler* interactionHandler)=0;

    virtual const Vec3D getVelocityAtContact(const Vec3D& contact) const;

    void integrateBeforeForceComputation(double time, double timeStep);

    void integrateAfterForceComputation(double time, double timeStep);

private:
    std::function<Vec3D (double)> prescribedPosition_;
    
    std::function<Vec3D (double)> prescribedVelocity_;
    
    std::function<Vec3D (double)> prescribedOrientation_;
    
    std::function<Vec3D (double)> prescribedAngularVelocity_;

    Vec3D position_;

    Vec3D orientation_;

    Vec3D angularVelocity_;

    Vec3D force_;

    Vec3D torque_;
       
    const ParticleSpecies* species_;

    unsigned int indSpecies_;

    Vec3D velocity_;

    std::list<BaseInteraction*> interactions_;
};

#include <SpeciesHandler.h>
#endif