BaseInteractable.cc

Go to the documentation of this file.

//Copyright (c) 2013-2015, 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.


#include "BaseInteractable.h"
#include "Particles/BaseParticle.h"
#include "Interactions/BaseInteraction.h"
#include "Species/ParticleSpecies.h"

BaseInteractable::BaseInteractable()
{
    position_.setZero();
    orientation_.setZero();
    velocity_.setZero();
    angularVelocity_.setZero();
    force_.setZero();
    torque_.setZero();
    indSpecies_ = 0;
    species_ = nullptr;
    prescribedPosition_ = nullptr;
    prescribedVelocity_ = nullptr;
    prescribedOrientation_ = nullptr;
    prescribedAngularVelocity_ = nullptr;
    logger(DEBUG, "BaseInteractable::BaseInteractable() finished");
}

BaseInteractable::BaseInteractable(const BaseInteractable &p)
        : BaseObject(p)
{
    interactions_.clear();
    position_ = p.position_;
    orientation_ = p.orientation_;
    velocity_ = p.velocity_;
    angularVelocity_ = p.angularVelocity_;
    force_ = p.force_;
    torque_ = p.torque_;
    species_ = p.species_;
    indSpecies_ = p.indSpecies_;
    prescribedPosition_ = p.prescribedPosition_;
    prescribedVelocity_ = p.prescribedVelocity_;
    prescribedOrientation_ = p.prescribedOrientation_;
    prescribedAngularVelocity_ = p.prescribedAngularVelocity_;
    logger(DEBUG,"BaseInteractable::BaseInteractable(const BaseInteractable &p finished");
}

BaseInteractable::~BaseInteractable()
{
    logger(VERBOSE, "Deleting BaseInteractable with index= % and id = % size = %", getIndex(),getId(),interactions_.size());
    while (interactions_.size() > 0)
    {
        interactions_.front()->removeFromHandler();
    }
    logger(DEBUG,"BaseInteractable::~BaseInteractable() finished");
}

unsigned int BaseInteractable::getIndSpecies() const
{
    return indSpecies_;
}

MERCURY_DEPRECATED void BaseInteractable::setIndSpecies(unsigned int indSpecies)
{
    indSpecies_ = indSpecies;
}

const ParticleSpecies* BaseInteractable::getSpecies() const
{
    //logger.assert(species_,"Species of % % has to be defined",getName(),getIndex());
    return species_;
}

void BaseInteractable::setSpecies(const ParticleSpecies* species)
{
    if (species->getHandler() == nullptr)
    {
        logger(ERROR, "Error: Species is not part of any handler yet");
    }
    
    species_ = species;
    indSpecies_ = species->getIndex();
}

const Vec3D& BaseInteractable::getForce() const
{
    return force_;
}

const Vec3D& BaseInteractable::getTorque() const
{
    return torque_;
}

void BaseInteractable::setForce(const Vec3D& force)
{
    force_ = force;
}

void BaseInteractable::setTorque(const Vec3D& torque)
{
    torque_ = torque;
}

void BaseInteractable::addForce(const Vec3D& addForce)
{
    force_ += addForce;
}

void BaseInteractable::addTorque(const Vec3D& addTorque)
{
    torque_ += addTorque;
}

const Vec3D& BaseInteractable::getPosition() const
{
    return position_;
}

const Vec3D& BaseInteractable::getOrientation() const
{
    return orientation_;
}

void BaseInteractable::setPosition(const Vec3D& position)
{
    position_ = position;
}


void BaseInteractable::setOrientation(const Vec3D& orientation)
{
    orientation_ = orientation;
}

void BaseInteractable::move(const Vec3D& move)
{
    position_ += move;
}

void BaseInteractable::rotate(const Vec3D& rotate)
{
    orientation_ += rotate;
}

void BaseInteractable::read(std::istream& is)
{
    BaseObject::read(is);
    std::string dummy;
    is >> dummy >> indSpecies_;
    is >> dummy >> position_;
    is >> dummy;
    //this if-statement is added to read Kasper van der Vaart's data files, which contain an additional variable named positionAbsolute
    if (dummy.compare("positionAbsolute") == 0)
    {
        is >> dummy >> dummy >> dummy  >> dummy;
    }
    is >> orientation_ >> dummy;
    is >> dummy >> velocity_;
    is >> dummy >> angularVelocity_ >> dummy;
    is >> dummy >> force_;
    is >> dummy >> torque_;
}

void BaseInteractable::write(std::ostream& os) const
{
    BaseObject::write(os);
    os << " indSpecies " << indSpecies_
            << " position " << position_
            << " orientation " << orientation_ << " " << 0.0
            << " velocity " << velocity_
            << " angularVelocity " << angularVelocity_ << " " << 0.0
            << " force " << force_
            << " torque " << torque_;
}

const std::list<BaseInteraction*>& BaseInteractable::getInteractions() const
{
    return interactions_;
}

void BaseInteractable::addInteraction(BaseInteraction* I)
{
    interactions_.push_back(I);
}

bool BaseInteractable::removeInteraction(BaseInteraction* I)
{
    for (std::list<BaseInteraction*>::iterator it = interactions_.begin(); it != interactions_.end(); ++it)
    {
        if (I == (*it))
        {
            logger(VERBOSE, "Removing interaction from % between % and %",getId(),I->getI()->getId(),I->getP()->getId());
            interactions_.erase(it);
            return true;
        }
    }
    logger(WARN, "Error in BaseInteractable::removeInteraction: Interaction could not be removed");
    return false;
}

const Vec3D& BaseInteractable::getVelocity() const
{
    return velocity_;
}

const Vec3D& BaseInteractable::getAngularVelocity() const
{
    return angularVelocity_;
}

void BaseInteractable::setVelocity(const Vec3D& velocity)
{
    velocity_ = velocity;
}

void BaseInteractable::setAngularVelocity(const Vec3D& angularVelocity)
{
    angularVelocity_ = angularVelocity;
}

void BaseInteractable::addVelocity(const Vec3D& velocity)
{
    velocity_ += velocity;
}

void BaseInteractable::addAngularVelocity(const Vec3D& angularVelocity)
{
    angularVelocity_ += angularVelocity;
}
const Vec3D BaseInteractable::getVelocityAtContact(const Vec3D& contact) const
{
    return getVelocity() - Vec3D::cross(contact - getPosition(), getAngularVelocity());
}

void BaseInteractable::copyInteractionsForPeriodicParticles(const BaseInteractable& pOriginal)
{
    for (BaseInteraction* interaction : pOriginal.interactions_)
    {
        //So here this is the ghost and it is the interaction of the ghost/
        interaction->copySwitchPointer(&pOriginal, this);
    }
}

void BaseInteractable::setPrescribedPosition(const std::function<Vec3D (double)>& prescribedPosition)
{
    prescribedPosition_ = prescribedPosition;
}

void BaseInteractable::applyPrescribedPosition(double time)
{
    if(prescribedPosition_)
    {
        setPosition(prescribedPosition_(time));
    }
}

void BaseInteractable::setPrescribedVelocity(const std::function<Vec3D (double)>& prescribedVelocity)
{
    prescribedVelocity_ = prescribedVelocity;
}

void BaseInteractable::applyPrescribedVelocity(double time)
{
    if(prescribedVelocity_)
    {
        setVelocity(prescribedVelocity_(time));
    }
}

void BaseInteractable::setPrescribedOrientation(const std::function<Vec3D (double)>& prescribedOrientation)
{
    prescribedOrientation_ = prescribedOrientation;
}

void BaseInteractable::applyPrescribedOrientation(double time)
{
    if(prescribedOrientation_)
    {
        setOrientation(prescribedOrientation_(time));
    }
}

/*
 * \details This functions sets a std::function which specifies the 
 *          AngularVeclocity of an interactable. This function takes a double 
 *          the time and returns a Vec3D which is the new angular velocity.
 *          See also BaseInteractable::setPrescribedOrientation
 *          Note this functions works the same way as 
 *          BaseInteractable::setPosition and BaseInteractable::setVeclocity.
 */
void BaseInteractable::setPrescribedAngularVelocity(const std::function<Vec3D (double)>& prescribedAngularVelocity)
{
    prescribedAngularVelocity_ = prescribedAngularVelocity;
}

void BaseInteractable::applyPrescribedAngularVelocity(double time)
{
    if(prescribedAngularVelocity_)
    {
        setAngularVelocity(prescribedAngularVelocity_(time));
    }
}

void BaseInteractable::integrateBeforeForceComputation(double time, double timeStep)
{
    if (prescribedPosition_ )
    {
        if (prescribedVelocity_ )
        {
            //Both the velocity and position are defined; as we are using leap
            //frog method so the velocity is evaluated half a time later.
            applyPrescribedPosition(time + timeStep);
            applyPrescribedVelocity(time + 0.5 * timeStep);
        }
        else
        {
            //Only the position is defined.
            //Velocity is evaluated from a finite different of the Position
            //Note, we use 0.5 +- 0.1 timeStep for the velocity eval.
            applyPrescribedPosition(time + timeStep);
            setVelocity((prescribedPosition_(time + 0.6 * timeStep) - prescribedPosition_(time + 0.4 * timeStep)) / (0.2 * timeStep));
        }
    }
    else
    {
        if (prescribedVelocity_ )
        {
            //Only the velocity is set. The position is calculated from the
            //the integral of velocity.
            applyPrescribedVelocity(time + 0.5 * timeStep);
            move(getVelocity() * timeStep);
        }
        else
        {
            //Neither is set move based on the computed velocity of the object.
            move(getVelocity() * timeStep);
        }
    }
    if (prescribedOrientation_)
    {
        if (prescribedAngularVelocity_)
        {
            applyPrescribedOrientation(time + timeStep);
            applyPrescribedAngularVelocity(time + 0.5 * timeStep);
        }
        else
        {
            applyPrescribedOrientation(time + timeStep);
            setAngularVelocity((prescribedOrientation_(time + 0.6 * timeStep) - prescribedOrientation_(time + 0.4 * timeStep)) / (0.2 * timeStep));
        }
    }
    else
    {
        if (prescribedAngularVelocity_)
        {
            applyPrescribedAngularVelocity(time + 0.5 * timeStep);
            rotate(getAngularVelocity() * timeStep);
        }
        else
        {
            rotate(getAngularVelocity() * timeStep);
        }
    }
}

void BaseInteractable::integrateAfterForceComputation(double time, double timeStep)
{
    if (prescribedPosition_)
    {
        if (prescribedVelocity_)
        {
            applyPrescribedVelocity(time + timeStep);
        }
        else
        {
            setVelocity((prescribedPosition_(time + 1.1 * timeStep) - prescribedPosition_(time + 0.9 * timeStep)) / (0.2 * timeStep));
        }
    }
    else
    {
        if (prescribedVelocity_)
        {
            applyPrescribedVelocity(time + 0.5 * timeStep);
        }
    }
    if (prescribedOrientation_)
    {
        if (prescribedAngularVelocity_)
        {
            applyPrescribedAngularVelocity(time + timeStep);
        }
        else
        {
            setAngularVelocity((prescribedOrientation_(time + 1.1 * timeStep) - prescribedOrientation_(time + 0.9 * timeStep)) / (0.2 * timeStep));
        }
    }
    else
    {
        if (prescribedAngularVelocity_)
        {
            applyPrescribedAngularVelocity(time + 0.5 * timeStep);
        }
    }
}