Chute.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 "Chute.h"
#include "ChuteBottom.h"
#include "Particles/BaseParticle.h"
#include "Boundaries/ChuteInsertionBoundary.h"
#include "Boundaries/PeriodicBoundary.h"
#include "Walls/InfiniteWall.h"
#include <string>
#include <string.h>
#include <iomanip>
#include <Species/LinearViscoelasticSlidingFrictionSpecies.h>

#include <Logger.h>

Chute::Chute()
{
    constructor();
    logger(DEBUG,"[Chute::Chute()] constructor finished");
}

Chute::Chute(const DPMBase& other)
        : DPMBase(other), Mercury3D(other)
{
    constructor();
    logger(DEBUG,"[Chute::Chute(const DPMBase& other)] copy constructor finished");     
}

Chute::Chute(const MercuryBase& other)
        : DPMBase(other), Mercury3D(other)
{
    constructor();
    logger(DEBUG,"[Chute::Chute(const MercuryBase& other)] copy constructor finished");
}

Chute::Chute(const Mercury3D& other)
        : DPMBase(other), Mercury3D(other)
{
        constructor();
        logger(DEBUG,"[Chute::Chute(const Mercury3D& other) copy constructor finished"); 
}

Chute::Chute(const Chute& other)
        : DPMBase(other), Mercury3D(other),
        chuteAngle_(other.chuteAngle_), 
        fixedParticleRadius_(other.fixedParticleRadius_),
        minInflowParticleRadius_(other.minInflowParticleRadius_), 
        maxInflowParticleRadius_(other.maxInflowParticleRadius_),
        inflowVelocity_(other.inflowVelocity_), 
        inflowVelocityVariance_(other.inflowVelocityVariance_),
        inflowHeight_(other.inflowHeight_), 
        roughBottomType_(other.roughBottomType_),
        maxFailed_(other.maxFailed_), 
        insertionBoundary_(other.insertionBoundary_), 
        isChutePeriodic_(other.isChutePeriodic_)    
{
    logger(DEBUG,"[Chute::Chute(const Chute& other)] copy constructor finished");     
}

void Chute::constructor()
{
    insertionBoundary_ = nullptr;
    isChutePeriodic_ = false;
    setFixedParticleRadius(0.001);
    setRoughBottomType(MONOLAYER_DISORDERED);
    setChuteAngle(0.0);
    
    setMaxFailed(1);
    setInflowParticleRadius(0.001);
    setInflowVelocity(0.1);
    setInflowVelocityVariance(0.0);
    setInflowHeight(0.02);
}

void Chute::read(std::istream& is)
{
    MercuryBase::read(is);
    //read out the full line first, so if there is an error it does not affect 
    //the read of the next line
    std::string line_string;
    std::getline(is, line_string);
    std::cout << "Chuteline=" << line_string << std::endl;
    std::stringstream line(std::stringstream::in | std::stringstream::out);
    line << line_string;
    
    if (getRestartVersion() != "1") //Other versions..
    {
        std::string dummy;
        unsigned int roughBottomType;
        line >> fixedParticleRadius_ 
             >> roughBottomType >> chuteAngle_
             >> minInflowParticleRadius_
             >> maxInflowParticleRadius_
             >> maxFailed_
             >> dummy
             >> inflowVelocity_
             >> inflowVelocityVariance_
             >> inflowHeight_;
        setRoughBottomType(static_cast<RoughBottomType>(roughBottomType));
        //if the Chute Angle is given in degrees, move to radians;
        if (chuteAngle_ > 1.0) {
            logger(WARN, "Restartfile angle converted into radians from degrees! (% rad -> % deg)", chuteAngle_, chuteAngle_ * constants::pi / 180.);
            chuteAngle_ *= constants::pi / 180.;
            
        }
    }
    else //Version 1
    {
        std::string dummy;
        unsigned int roughBottomType;
        line >> dummy >> fixedParticleRadius_ 
             >> dummy >> minInflowParticleRadius_ 
             >> dummy >> maxInflowParticleRadius_
             >> dummy >> roughBottomType 
             >> dummy >> chuteAngle_ 
             >> dummy >> maxFailed_ 
             >> dummy >> dummy
             >> dummy >> inflowVelocity_
             >> dummy >> inflowVelocityVariance_ 
             >> dummy >> inflowHeight_;
        setRoughBottomType(static_cast<RoughBottomType>(roughBottomType));
        //This version always writes radians
    }
    
}

void Chute::write(std::ostream& os, bool writeAllParticles) const
{
    MercuryBase::write(os, writeAllParticles);
    os      << "FixedParticleRadius "      << fixedParticleRadius_
            << " MinInflowParticleRadius " << minInflowParticleRadius_
            << " MaxInflowParticleRadius " << maxInflowParticleRadius_
            << " RoughBottomType "         << roughBottomType_ 
            << " ChuteAngle "              << chuteAngle_ 
            << " MaxFailed "               << maxFailed_ 
            << " NumCreated "              << (insertionBoundary_ ? insertionBoundary_->getNumberOfParticlesInserted() : 0)
            << " InflowVelocity "          << inflowVelocity_ 
            << " InflowVelocityVariance "  << inflowVelocityVariance_ 
            << " InflowHeight "            << inflowHeight_ << std::endl;
}

void Chute::actionsBeforeTimeStep()
{
    cleanChute();
}

void Chute::printTime() const
{
    std::cout << "\rt=" << std::setprecision(3) << std::left << std::setw(6)
              << getTime()
              << ", tmax=" << std::setprecision(3) << std::left << std::setw                                                                                                                                                   (6) << getTimeMax()
              << ", N=" << std::setprecision(3) << std::left << std::setw(6)
              << particleHandler.getNumberOfObjects()
              << std::endl;
    std::cout.flush();
}

void Chute::setupInitialConditions()
{
    if (speciesHandler.getNumberOfObjects() == 0)
    {
        logger(FATAL, "[Chute::setupInitialConditions()] Chute % cannot "
                "complete because no species have been defined.", getName());
    }
    
    // create the chute's side walls in Y-direction
    // (which are solid if the chute is not periodic)
    setupSideWalls();
    
    // create a particle of which (altered) copies will fill the chute insertion
    // boundary
    BaseParticle* p = new BaseParticle;
    // by default, insert particles of species 0
    p->setSpecies(speciesHandler.getObject(0));
    
    // set up the insertion boundary and add to handler
    ChuteInsertionBoundary b1;
    b1.set(p, maxFailed_, Vec3D(getXMin(), getYMin(), getZMin()),
           Vec3D(getXMax(), getYMax(), getZMax()),
           minInflowParticleRadius_, maxInflowParticleRadius_,
           fixedParticleRadius_, inflowVelocity_, inflowVelocityVariance_);
    insertionBoundary_ = boundaryHandler.copyAndAddObject(b1);

    //creates the bottom of the chute
    createBottom();
}

void Chute::setupSideWalls()
{
    // check if walls should be periodic or solid
    if (isChutePeriodic_)
    {
        // create a periodic boundary with walls at yMin_ and yMax_.
        PeriodicBoundary b0;
        b0.set(Vec3D(0.0, 1.0, 0.0), getYMin(), getYMax());
        boundaryHandler.copyAndAddObject(b0);
    }
    else
    {
        // create two infinite solid walls; one at yMin_...
        InfiniteWall w0;
        w0.setSpecies(speciesHandler.getObject(0));
        w0.set(Vec3D(0.0,-1.0, 0.0), Vec3D(0, getYMin(), 0));
        wallHandler.copyAndAddObject(w0);
        // ... and one at yMax_.
        w0.set(Vec3D(0.0, 1.0, 0.0), Vec3D(0, getYMax(), 0));
        wallHandler.copyAndAddObject(w0);
    }
}

void Chute::createBottom()
{
    // smooth bottom:
    if (fabs(getFixedParticleRadius()) < 1e-12 || roughBottomType_ == FLAT)
    {
        // flat wall as bottom
        logger(INFO,"[Chute::createBottom()] create perfectly flat chute bottom");
        
        //bottom wall 
        InfiniteWall w0;
        w0.setSpecies(speciesHandler.getObject(0));
        w0.set(Vec3D(0.0, 0.0, -1.0), Vec3D(0, 0, getZMin()));
        wallHandler.copyAndAddObject(w0);
    }
    else //rough bottom
    {
        // Define standard fixed particle
        BaseParticle F0;
        F0.setSpecies(speciesHandler.getObject(0));
        F0.setHandler(&particleHandler);
        F0.setRadius(getFixedParticleRadius());
        F0.setPosition(Vec3D(0.0, 0.0, 0.0));
        F0.setVelocity(Vec3D(0.0, 0.0, 0.0));
        
        if (roughBottomType_ == MONOLAYER_ORDERED)
        {
            // grid-like fixed-particle bottom
            logger(INFO,"[Chute::createBottom()] create monolayered, ordered rough chute bottom");
            
            // allowed space for each particle in each direction
            Mdouble dx = 2.0 * F0.getRadius();
            Mdouble dy = 2.0 * F0.getRadius();
            
            // number of particles that fit in each direction
            unsigned int nx = static_cast<unsigned int>(std::max(1, static_cast<int>(std::floor((getXMax() - getXMin()) / dx))));
            unsigned int ny = static_cast<unsigned int>(std::max(1, static_cast<int>(std::floor((getYMax() - getYMin()) / dy))));
            
            // adjust particle spacing (in case total space available in given direction
            // is not a multiple of 2*F0.getRadius() )
            dx = (getXMax() - getXMin()) / nx;
            dy = (getYMax() - getYMin()) / ny;
            
            for (unsigned int i = 0; i < nx; i++)
            {
                for (unsigned int j = 0; j < ny; j++)
                {
                    // placing of particles on rectangular grid points 
                    F0.setPosition(Vec3D(F0.getRadius() + dx * i, F0.getRadius() + dy * j, 0.0));
                    particleHandler.copyAndAddObject(F0);
                }
            }
        }
        else if (roughBottomType_ == MONOLAYER_DISORDERED)
        { 
            // random fixed-particle bottom
            logger(INFO,"[Chute::createBottom()] create monolayered disordered rough chute bottom");

            Vec3D position;
            position.X = random.getRandomNumber(F0.getRadius(), getXMax() - F0.getRadius());
            position.Y = random.getRandomNumber(getYMin() + F0.getRadius(), getYMax() - F0.getRadius());
            F0.setPosition(position);
            particleHandler.copyAndAddObject(F0);
            
            hGridActionsBeforeTimeLoop();
            hGridActionsBeforeTimeStep();
            
            //now add more particles
            int failed = 0;
            while (failed < 500)
            {
                //The position components are first stored in a Vec3D, because 
                //if you pass them directly into setPosition the compiler is 
                //allowed to change the order in which the numbers are generated
                position.X = random.getRandomNumber(F0.getRadius(), getXMax() - F0.getRadius());
                position.Y = random.getRandomNumber(getYMin() + F0.getRadius(), getYMax() - F0.getRadius());
                F0.setPosition(position);
                if (checkParticleForInteraction(F0))
                {
                    particleHandler.copyAndAddObject(F0);
                    failed = 0;
                }
                else
                {
                    failed++;
                }
            }

            //bottom wall (create after particle creation, as 
            //checkParticleForInteraction also checks against walls)
            InfiniteWall w0;
            w0.setSpecies(speciesHandler.getObject(0));
            w0.set(Vec3D(0.0, 0.0, -1.0), Vec3D(0, 0, getZMin() - .5 * F0.getRadius()));
            wallHandler.copyAndAddObject(w0);
        }
        else //if (roughBottomType_ == MULTILAYER)
        {
            // multilayered particle bottom
            logger(INFO,"[Chute::createBottom()] create multilayered rough chute bottom");
            
            //'this' points to the current Chute object, the class of which is inherited
            // by the ChuteBottom class. I.e., the bottom is created with the particle 
            // properties from the current class.
            // ChuteBottom::makeRoughBottom() creates a randomly filled, multilayered
            // chute bottom. 
            ChuteBottom bottom(*this);
            bottom.setInflowParticleRadius(getFixedParticleRadius());
            bottom.makeRoughBottom(*this);
        }
        //finally, fix particles to the bottom
        for (BaseParticle* p : particleHandler)
        {
            p->fixParticle();
        }
    }
}

void Chute::cleanChute()
{
    //clean outflow every 100 timesteps
    static int count = 0, maxcount = 100; // please note: static variables are only initialised once, and their values
                                          // are stored even after the method returns. I.e., next time the method is 
                                          // called, the initialisation is ignored and the previously assigned value is used.
    if (count > maxcount)
    {
        // reset counter
        count = 0;
        
        // check all particles
        for (unsigned int i = 0; i < particleHandler.getNumberOfObjects();)
        {
            // check if particle is outside the problem window
            if (particleHandler.getObject(i)->getPosition().X > getXMax() || particleHandler.getObject(i)->getPosition().X < getXMin()) //||particleHandler.getObject(i)->Position.Z+particleHandler.getObject(i)->Radius<zMin_)    
            {
                // if so, delete the particle
                logger(DEBUG,"[Chute::cleanChute()] erased: %", particleHandler.getObject(i));
                particleHandler.removeObject(i);
            }
            else
            {
                i++;
            }
        }
    }
    else
    {
        count++;
    }
}

bool Chute::readNextArgument(int& i, int argc, char* argv[])
{
    if (!strcmp(argv[i], "-inflowHeight"))
    {
        setInflowHeight(atof(argv[i + 1]));
        setZMax(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-inflowVelocity"))
    {
        setInflowVelocity(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-chuteAngle"))
    {
        setChuteAngle(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-chuteLength"))
    {
        setChuteLength(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-chuteWidth"))
    {
        setChuteWidth(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-fixedParticleRadius"))
    {
        setFixedParticleRadius(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-max_failed"))
    {
        setMaxFailed(static_cast<unsigned int>(atoi(argv[i + 1])));
    }
    else if (!strcmp(argv[i], "-inflowParticleRadiusRange"))
    {
        setInflowParticleRadius(atof(argv[i + 1]), atof(argv[i + 2]));
        i++;
    }
    else if (!strcmp(argv[i], "-inflowParticleRadius"))
    {
        setInflowParticleRadius(atof(argv[i + 1]));
    }
    else if (!strcmp(argv[i], "-roughBottomType"))
    {
        std::string str(argv[i + 1]);
        setRoughBottomType(str);
    }
//    else if (!strcmp(argv[i], "-k_eps"))
//    {
//        Mdouble Mass = getLightestParticleMass();
//        //~ Mdouble Mass =  particleHandler.get_LightestParticle()->getMass();
//        speciesHandler.getObject(0)->setStiffnessAndRestitutionCoefficient(atof(argv[i + 1]), atof(argv[i + 2]), Mass);
//        std::cout << "reset contact properties of lightest Particle (mass=" << Mass << ") to k=" << speciesHandler.getObject(0)->getStiffness() << " and dissipation_=" << speciesHandler.getObject(0)->getDissipation() << std::endl;
//        i += 1;
//    }
//    else if (!strcmp(argv[i], "-tc_eps"))
//    {
//        Mdouble Mass = getLightestParticleMass();
//        speciesHandler.getObject(0)->setCollisionTimeAndRestitutionCoefficient(atof(argv[i + 1]), atof(argv[i + 2]), Mass);
//        std::cout << "reset contact properties of lightest Particle (mass=" << Mass << ") to k=" << speciesHandler.getObject(0)->getStiffness() << " and dissipation_=" << speciesHandler.getObject(0)->getDissipation() << std::endl;
//        i += 1;
//    }
//    else if (!strcmp(argv[i], "-tc_eps_beta"))
//    {
//        Mdouble Mass = getLightestParticleMass();
//        FrictionalSpecies* S = dynamic_cast<FrictionalSpecies*>(speciesHandler.getObject(0));
//        S->setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(atof(argv[i + 1]), atof(argv[i + 2]), atof(argv[i + 3]), Mass);
//        std::cout << "reset contact properties of lightest Particle (mass=" << Mass << ") to k=" << S->getStiffness() << ", dissipation_=" << S->getDissipation() << ", kt=" << S->getSlidingStiffness() << " and dispt=" << S->getSlidingDissipation() << std::endl;
//        i += 2;
//    }
    else
        return Mercury3D::readNextArgument(i, argc, argv); //if argv[i] is not found, check the commands in Mercury3D
    return true; //returns true if argv[i] is found
}

void Chute::makeChutePeriodic()
{
    isChutePeriodic_ = true;
}

bool Chute::getIsPeriodic() const
{
    return isChutePeriodic_;
}

void Chute::setFixedParticleRadius(Mdouble fixedParticleRadius)
{
    if (fixedParticleRadius >= 0.0)
    {
        fixedParticleRadius_ = fixedParticleRadius;
    }
    else
    {
        logger(WARN, "[Chute::setFixedParticleRadius()] Fixed particle radius "
                "must be greater than or equal to zero.");
    }
}

Mdouble Chute::getFixedParticleRadius() const
{
    return fixedParticleRadius_;
}

void Chute::setRoughBottomType(RoughBottomType roughBottomType)
{
    roughBottomType_ = roughBottomType;
}

void Chute::setRoughBottomType(std::string roughBottomTypeString)
{
    if (!roughBottomTypeString.compare("MONOLAYER_ORDERED"))
    {
        roughBottomType_ = MONOLAYER_ORDERED;
    }
    else if (!roughBottomTypeString.compare("MONOLAYER_DISORDERED"))
    {
        roughBottomType_ = MONOLAYER_ORDERED;
    }
    else if (!roughBottomTypeString.compare("MULTILAYER"))
    {
        roughBottomType_ = MONOLAYER_ORDERED;
    }
    else if (roughBottomTypeString == "FLAT")
    {
        roughBottomType_ = FLAT;
    }
    else 
    {
        logger(FATAL, "[Chute::setRoughBottomType(std::string)] Invalid "
                      "argument in setRoughBottomType. Given: %",
               roughBottomTypeString);
    }
}

RoughBottomType Chute::getRoughBottomType() const
{
    return roughBottomType_;
}

void Chute::setChuteAngle(Mdouble chuteAngle)
{   
    // retrieve the magnitude of gravity
    Mdouble gravity = getGravity().getLength();
    if (gravity == 0)
    {
        logger(WARN, "[Chute::setChuteAngle()] zero gravity");
    }
    
    // reset the gravity vector, with the given angle
    setChuteAngleAndMagnitudeOfGravity(chuteAngle, gravity);
}

void Chute::setChuteAngleAndMagnitudeOfGravity(Mdouble chuteAngle, Mdouble gravity)
{
    if (chuteAngle >= -90.0 && chuteAngle <= 90.0)
    {
        chuteAngle_ = chuteAngle * constants::pi / 180.0;
        setGravity(Vec3D(sin(chuteAngle_), 0.0, -cos(chuteAngle_)) * gravity);
    }
    else
    {
        logger(WARN, "[Chute::setChuteAngleAndMagnitudeOfGravity()] Chute "
                "angle must be within [-90,90]");
    }
}

Mdouble Chute::getChuteAngle() const
{
    return chuteAngle_;
}

Mdouble Chute::getChuteAngleDegrees() const
{
    return chuteAngle_ * 180.0 / constants::pi;
}

void Chute::setMaxFailed(unsigned int maxFailed)
{
    maxFailed_ = maxFailed;
}

unsigned int Chute::getMaxFailed() const
{
    return maxFailed_;
}

void Chute::setInflowParticleRadius(Mdouble inflowParticleRadius)
{
    if (inflowParticleRadius >= 0.0)
    {
        minInflowParticleRadius_ = inflowParticleRadius;
        maxInflowParticleRadius_ = inflowParticleRadius;
    }
    else
    {
        logger(WARN, "[Chute::setInflowParticleRadius(Mdouble)] Inflow "
                     "particle must be greater than or equal to zero");
    }
}

void Chute::setInflowParticleRadius(Mdouble minInflowParticleRadius,
                                    Mdouble maxInflowParticleRadius)
{
    if (minInflowParticleRadius >= 0.0)
    {
        minInflowParticleRadius_ = minInflowParticleRadius;
    }
    else
    {
        logger(WARN, "[Chute::setInflowParticleRadius(Mdouble,Mdouble)] Min."
                     "inflow particle radius must be nonnegative");
    }
    if (maxInflowParticleRadius >= minInflowParticleRadius)
    {
        maxInflowParticleRadius_ = maxInflowParticleRadius;
    }
    else
    {
        logger(WARN, "[Chute::setInflowParticleRadius(Mdouble,Mdouble)] Max."
                     " inflow particle radius must be >= min. inflow particle "
                     "radius");
    }
}

void Chute::setMinInflowParticleRadius(Mdouble minInflowParticleRadius)
{
    if (minInflowParticleRadius <= maxInflowParticleRadius_)
    {
        minInflowParticleRadius_ = minInflowParticleRadius;
    }
    else
    {
        logger(WARN,"[Chute::setMinInflowParticleRadius()] Min. inflow particle"
                    " radius must be <= max. inflow particle radius");
    }
}

void Chute::setMaxInflowParticleRadius(Mdouble maxInflowParticleRadius)
{
    if (maxInflowParticleRadius >= minInflowParticleRadius_)
    {
        maxInflowParticleRadius_ = maxInflowParticleRadius;
    }
    else
    {
        logger(WARN,"[Chute::setMaxInflowParticleRadius()] Max. inflow particle"
                    " radius must be >= min. inflow particle radius");
    }
}

Mdouble Chute::getInflowParticleRadius() const
{
    return 0.5 * (minInflowParticleRadius_ + maxInflowParticleRadius_);
}

Mdouble Chute::getMinInflowParticleRadius() const
{
    return minInflowParticleRadius_;
}

Mdouble Chute::getMaxInflowParticleRadius() const
{
    return maxInflowParticleRadius_;
}

void Chute::setInflowHeight(Mdouble inflowHeight)
{
    //if (inflowHeight >= minInflowParticleRadius_ + maxInflowParticleRadius_)
    {
        inflowHeight_ = inflowHeight;
        setZMax(1.2 * inflowHeight_);
    }
//    else
//    {
//        std::cerr << "WARNING : Inflow height not changed to " << inflowHeight << ", value must be greater than or equal to diameter of inflow particle" << std::endl;
//    }
}

Mdouble Chute::getInflowHeight() const
{
    return inflowHeight_;
}

void Chute::setInflowVelocity(Mdouble inflowVelocity)
{
    if (inflowVelocity >= 0.0)
    {
        inflowVelocity_ = inflowVelocity;
    }
    else
    {
        logger(WARN,"[Chute::setInflowVelocity()] Inflow velocity not changed, "
                    "value must be greater than or equal to zero");
    }
}

Mdouble Chute::getInflowVelocity() const
{
    return inflowVelocity_;
}

void Chute::setInflowVelocityVariance(Mdouble inflowVelocityVariance)
{
    if (inflowVelocityVariance >= 0.0 && inflowVelocityVariance <= 1.0)
    {
        inflowVelocityVariance_ = inflowVelocityVariance;
    }
    else
    {
        logger(ERROR, "[Chute::setInflowVelocityVariance()] Inflow velocity "
                      "variance not changed, value must be within [0,1]");
        exit(-1);
    }
}

Mdouble Chute::getInflowVelocityVariance() const
{
    return inflowVelocityVariance_;
}

void Chute::setChuteWidth(Mdouble chuteWidth)
{
    setYMax(chuteWidth);
}

Mdouble Chute::getChuteWidth() const
{
    return getYMax();
}

void Chute::setChuteLength(Mdouble chuteLength)
{
    setXMax(chuteLength);
}

Mdouble Chute::getChuteLength() const
{
    return getXMax();
}

void Chute::setInsertionBoundary(InsertionBoundary* insertionBoundary)
{
    insertionBoundary_ = insertionBoundary;
}