LeesEdwardsBoundary.cc

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.

#include "LeesEdwardsBoundary.h"
#include "ParticleHandler.h"
#include "Particles/BaseParticle.h"
#include "DPMBase.h"

void LeesEdwardsBoundary::set(std::function<double (double)> shift, std::function<double (double)> velocity, Mdouble left, Mdouble right, Mdouble down, Mdouble up)
{
    shift_ = shift;
    velocity_ = velocity;
    left_ = left;
    right_ = right;
    down_ = down;
    up_ = up;
}

void LeesEdwardsBoundary::read(std::istream& is)
{
    std::string dummy;
    BaseBoundary::read(is);
    Mdouble shift;
    Mdouble velocity;
    is>>dummy>>left_>>dummy>>right_>>dummy>>down_>>dummy>>up_>>dummy>>shift>>dummy>>velocity;
    shift_=[shift,velocity] (double time UNUSED) { return shift+velocity*time;};
    velocity_=[velocity] (double time UNUSED) {return velocity;};
}

void LeesEdwardsBoundary::write(std::ostream& os) const
{
    BaseBoundary::write(os);
    Mdouble time = getHandler()->getDPMBase()->getTime();
    os<<" left "<<left_<<" right "<<right_<<" down "<<down_<<" up "<<up_<<" shift "<<shift_(time)<<" vel "<<velocity_(time);
}

std::string LeesEdwardsBoundary::getName() const
{
    return "LeesEdwardsBoundary";
}

LeesEdwardsBoundary* LeesEdwardsBoundary::copy() const
{
    return new LeesEdwardsBoundary(*this);
}

Mdouble LeesEdwardsBoundary::getHorizontalDistance(BaseParticle& p, bool& positive)
{
    Mdouble left = p.getPosition().X - left_;
    Mdouble right = right_ - p.getPosition().X;
    if (left < right)
    {
        positive = true;
        return left;
    } else
    {
        positive = false;
        return right;
    }
}

Mdouble LeesEdwardsBoundary::getVerticalDistance(BaseParticle& p, bool& positive)
{
    Mdouble down = p.getPosition().Y - down_;
    Mdouble up = up_ - p.getPosition().Y;
    if (down < up)
    {
        positive = true;
        return down;
    } else
    {
        positive = false;
        return up;
    }
}

void LeesEdwardsBoundary::shiftHorizontalPosition(BaseParticle* p, bool positive)
{
    if (positive)
    {
        p->move(Vec3D(right_ - left_, 0.0, 0.0));
    } else
    {
        p->move(Vec3D(left_ - right_, 0.0, 0.0));
    }
}

void LeesEdwardsBoundary::shiftVerticalPosition(BaseParticle* p, bool positive)
{
    Mdouble time = getHandler()->getDPMBase()->getTime();
    if (positive)
    {
        p->move(Vec3D(shift_(time), up_ - down_, 0.0));
        p->addVelocity(Vec3D(velocity_(time), 0.0, 0.0));
    } else
    {
        p->move(Vec3D(-shift_(time), down_ - up_, 0.0));
        p->addVelocity(Vec3D(-velocity_(time), 0.0, 0.0));
    }
}

void LeesEdwardsBoundary::createHorizontalPeriodicParticles(BaseParticle* p, ParticleHandler& pH)
{
    bool positive;      // TRUE if the particle is closest to the left boundary 
                        // wall (set by getVerticalDistance in the following if-statement)
    // check if particle is close enough to either of the walls
    if (getHorizontalDistance(*p, positive) < p->getInteractionRadius() + pH.getLargestParticle()->getInteractionRadius())
    {
        // create a periodic copy of the particle
        BaseParticle* F0 = p->copy();
        pH.addObject(F0);
        F0->copyInteractionsForPeriodicParticles(*p);

        // If Particle is doubly shifted, get correct original particle
        BaseParticle* From = p;
        while (From->getPeriodicFromParticle() != nullptr)
            From = From->getPeriodicFromParticle();
        F0->setPeriodicFromParticle(From);
        
        // shift the copy to the 'periodic' position
        shiftHorizontalPosition(F0, positive);
        
        // NB: No extra creation of possible vertical copies of the horizontal copy 
        // here (as compared to createVerticalPeriodicParticles), because these would
        // overlap with the extra creation of horizontal copies in createVerticalPeriodicParticles.
    }
}

void LeesEdwardsBoundary::createVerticalPeriodicParticles(BaseParticle* p, ParticleHandler& pH)
{
    bool positive;      // TRUE if the particle is closest to the bottom boundary 
                        // wall (set by getVerticalDistance in the following if-statement)
    // check if particle is close enough to either of the walls
    if (getVerticalDistance(*p, positive) < p->getInteractionRadius() + pH.getLargestParticle()->getInteractionRadius())
    {   
        // create a periodic copy of the particle
        BaseParticle* F0 = p->copy();
        pH.addObject(F0);
        F0->copyInteractionsForPeriodicParticles(*p);

        // If Particle is doubly shifted, get correct original particle
        BaseParticle* From = p;
        while (From->getPeriodicFromParticle() != nullptr)
            From = From->getPeriodicFromParticle();
        F0->setPeriodicFromParticle(From);
        
        // shift the copy to the 'periodic' position
        shiftVerticalPosition(F0, positive);
        while (getHorizontalDistance(*F0, positive) < 0)
        {
            shiftHorizontalPosition(F0, positive);
        }
        
        // Create horizontal periodic copies of the copy particle, if needed (i.e.,
        // if the original particle is in one of the boundary corners).
        createHorizontalPeriodicParticles(pH.getLastObject(), pH);
    }
}

void LeesEdwardsBoundary::createPeriodicParticles(BaseParticle* p, ParticleHandler& pH)
{
    createVerticalPeriodicParticles(p, pH);
    createHorizontalPeriodicParticles(p, pH);
}

bool LeesEdwardsBoundary::checkBoundaryAfterParticleMoved(BaseParticle* p, ParticleHandler& pH UNUSED)
{
    bool positive;
    while (getVerticalDistance(*p, positive) < 0)
    {
        shiftVerticalPosition(p, positive);
    }
    while (getHorizontalDistance(*p, positive) < 0)
    {
        shiftHorizontalPosition(p, positive);
    }
    return false;
}


Mdouble LeesEdwardsBoundary::getCurrentShift()
{
    Mdouble time = getHandler()->getDPMBase()->getTime();
    return shift_(time);
}

Mdouble LeesEdwardsBoundary::getCurrentVelocity()
{
    Mdouble time = getHandler()->getDPMBase()->getTime();
    return velocity_(time);
}

void LeesEdwardsBoundary::setShift(std::function<double (double)> shift)
{
    shift_ = shift;
}

void LeesEdwardsBoundary::setVelocity(std::function<double (double)> velocity)
{
    velocity_ = velocity;
}