Chute.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 CHUTE_H
#define CHUTE_H
#include "HGRID_3D.h"

class Chute : public HGRID_3D { 
public:
    
    Chute()
    {
        constructor();
        #ifdef CONSTUCTOR_OUTPUT
            std::cerr << "Chute() finished" << std::endl;
        #endif      
    }
    
    //The copy-constructor of MD has to be called because the link from MD to HGRID_base is virtual
    Chute(MD& other) : MD(other), HGRID_3D(other)
        {
        constructor();
        #ifdef CONSTUCTOR_OUTPUT
            std::cerr << "Chute(MD& other) finished" << std::endl;
        #endif      
    }
    Chute(HGRID_base& other) : MD(other), HGRID_3D(other)
        {
        constructor();
        #ifdef CONSTUCTOR_OUTPUT
            std::cerr << "Chute(HGRID_base& other)  finished" << std::endl;
        #endif      
    }
    Chute(HGRID_3D& other) : MD(other), HGRID_3D(other)
        {
        constructor();
        #ifdef CONSTUCTOR_OUTPUT
            std::cerr << "Chute(HGRID_3D& other) finished" << std::endl;
        #endif      
    }
    
    void constructor();
    
    void make_chute_periodic(){is_periodic=true;}
    
    bool get_IsPeriodic() {return is_periodic;}
    
    void setup_particles_initial_conditions();
    
    void read(std::istream& is);

    virtual void write(std::ostream& os);
    
    void print(std::ostream& os, bool print_all=false);

    void set_FixedParticleRadius(Mdouble new_){if (new_ >= 0.0) FixedParticleRadius=new_; else std::cerr << "WARNING : Fixed particle radius must be greater than or equal to zero" << std::endl;}
    Mdouble get_FixedParticleRadius(){return FixedParticleRadius;}
    
    void set_RandomizedBottom(int new_){RandomizedBottom = new_;}
    int get_RandomizedBottom(){return RandomizedBottom;}
    
    void set_ChuteAngle(Mdouble new_){Mdouble gravity = get_gravity().GetLength(); if (gravity==0) {std::cerr<<"WARNING: zero gravity";} set_ChuteAngle(new_, gravity);}
    void set_ChuteAngle(Mdouble new_, Mdouble gravity){if (new_>=-90.0&&new_<=90.0) {ChuteAngle = new_*constants::pi/180.0; set_gravity(Vec3D(sin(ChuteAngle), 0.0, -cos(ChuteAngle))*gravity);} else std::cerr << "WARNING : Chute angle must be within [-90,90]" << std::endl;}
    //void set_ChuteAngle(Mdouble new_, Mdouble gravity){if (new_>=0.0&&new_<=90.0) {ChuteAngle = new_; set_gravity(Vec3D(sin(ChuteAngle*pi/180.0), 0.0, -cos(ChuteAngle*pi/180.0))*gravity);} else std::cerr << "WARNING : Chute angle must be within [0,90]" << std::endl;}
    Mdouble get_ChuteAngle(){return ChuteAngle;}
    Mdouble get_ChuteAngleDegrees(){return ChuteAngle*180./constants::pi;}

    void set_max_failed(unsigned int new_){max_failed = new_;}
    unsigned int get_max_failed(){return max_failed;}
    
    void set_InflowParticleRadius(Mdouble new_){
        if (new_>=0.0) {MinInflowParticleRadius=MaxInflowParticleRadius=new_;} else std::cerr << "WARNING : Inflow particle must be greater than or equal to zero" << std::endl;
    }
    void set_InflowParticleRadius(Mdouble new_min, Mdouble new_max){
        if (new_min>=0.0)     {MinInflowParticleRadius=new_min;} else std::cerr << "WARNING : Min. inflow particle radius must be nonnegative" << std::endl;
        if (new_max>=new_min) {MaxInflowParticleRadius=new_max;} else std::cerr << "WARNING : Max. inflow particle radius must be >= min. inflow particle radius" << std::endl;
    }
    void set_MinInflowParticleRadius(Mdouble new_min){
        if (new_min<=MaxInflowParticleRadius) {MinInflowParticleRadius=new_min;} else std::cerr << "WARNING : Max. inflow particle radius must be >= min. inflow particle radius" << std::endl;
    }
    void set_MaxInflowParticleRadius(Mdouble new_max){
        if (new_max>=MinInflowParticleRadius) {MaxInflowParticleRadius=new_max;} else std::cerr << "WARNING : Max. inflow particle radius must be >= min. inflow particle radius" << std::endl;
    }
    Mdouble get_InflowParticleRadius(){return 0.5*(MinInflowParticleRadius+MaxInflowParticleRadius);}
    Mdouble get_MinInflowParticleRadius(){return MinInflowParticleRadius;}
    Mdouble get_MaxInflowParticleRadius(){return MaxInflowParticleRadius;}

    void set_InflowHeight(Mdouble new_){
        if (new_ >= MinInflowParticleRadius+MaxInflowParticleRadius)  { InflowHeight=new_; set_zmax(1.2*InflowHeight); } else std::cerr << "WARNING : Inflow height not changed to " << new_ << ", value must be greater than or equal to diameter of inflow particle" << std::endl;
    }
    Mdouble get_InflowHeight(){return InflowHeight;}
    
    void set_InflowVelocity(Mdouble new_){
        if (new_ >= 0.0) InflowVelocity=new_; else std::cerr << "WARNING : Inflow velocity not changed, value must be greater than or equal to zero" << std::endl;
    }
    Mdouble get_InflowVelocity(){return InflowVelocity;}

    void set_InflowVelocityVariance(Mdouble new_){
        if (new_>=0.0&&new_<=1.0) InflowVelocityVariance=new_; else std::cerr << "WARNING : Inflow velocity variance not changed, value must be within [0,1]" << std::endl;
    }
    Mdouble get_InflowVelocityVariance(){return InflowVelocityVariance;}

    void set_InitialHeight(Mdouble new_){
        std::cerr << "WARNING : set_InitialHeight(Mdouble) is a deprecated function, use set_InflowHeight(Mdouble) instead." << std::endl;
        set_InflowHeight(new_);
    }
    Mdouble get_InitialHeight(){
        std::cerr << "WARNING : get_InitialHeight(Mdouble) is a deprecated function, use get_InflowHeight(Mdouble) instead." << std::endl;
        return get_InflowHeight();
    }
    void set_InitialVelocity(Mdouble new_){
        std::cerr << "WARNING : set_InitialVelocity(Mdouble) is a deprecated function, use set_InflowVelocity(Mdouble) instead." << std::endl;
        set_InflowVelocity(new_);
    }
    Mdouble get_InitialVelocity(){
        std::cerr << "WARNING : get_InitialVelocity(Mdouble) is a deprecated function, use get_InflowVelocity(Mdouble) instead." << std::endl;
        return get_InflowVelocity();
    }
    void set_InitialVelocityVariance(Mdouble new_){
        std::cerr << "WARNING : set_InitialVelocityVariance(Mdouble) is a deprecated function, use set_InflowVelocityVariance(Mdouble) instead." << std::endl;
        set_InflowVelocityVariance(new_);
    }
    Mdouble get_InitialVelocityVariance(){
        std::cerr << "WARNING : get_InitialVelocityVariance(Mdouble) is a deprecated function, use get_InflowVelocityVariance(Mdouble) instead." << std::endl;
        return get_InflowVelocityVariance();
    }
    
    void set_ChuteWidth(Mdouble new_){set_ymax(new_);}
    Mdouble get_ChuteWidth(){return get_ymax();}
    virtual void set_ChuteLength(Mdouble new_){set_xmax(new_);}
    Mdouble get_ChuteLength(){return get_xmax();}

    int readNextArgument(unsigned int& i, unsigned int argc, char *argv[]);

    void set_collision_time_and_restitution_coefficient(Mdouble tc, Mdouble eps);
    
    Mdouble get_collision_time();
    
    Mdouble get_restitution_coefficient();

    void set_dt(){std::cout<<"Chute set_dt"<<std::endl;set_dt(.02 * get_collision_time());}
    void set_dt(Mdouble dt){MD::set_dt(dt);}
    
    BaseParticle* getSmallestParticle();
    
    BaseParticle* getLargestParticle();
    
    BaseParticle* get_P0(){return &P0;}
    
    Mdouble get_SmallestParticleInteractionRadius();

    Mdouble get_LightestParticleMass();

protected:
    
    virtual bool IsInsertable(BaseParticle &P);
    
    void add_particle(BaseParticle &P);
    
    void actions_before_time_step();

    virtual void add_particles();
    
    void clean_chute();
    
    void initialize_inflow_particle();
    
    virtual void create_inflow_particle();
    
    virtual void create_bottom();
    
    void cout_time();


    Mdouble get_LargestParticleInteractionRadius(); 

protected:
    
    Mdouble FixedParticleRadius; //<radius of the fixed particles at the bottom
    int RandomizedBottom; //<distinguishes between grid-like (0), one-layer randomized (1), and thick random dense (2) bottom
    Mdouble ChuteAngle; //<chute angle in degrees

    Mdouble MinInflowParticleRadius; //<minimal radius of inflowing particles
    Mdouble MaxInflowParticleRadius; //<maximal radius of inflowing particles
    Mdouble InflowVelocity; //<Average inflow velocity in x-direction
    Mdouble InflowVelocityVariance; //Inflow velocity variance in x-direction
    Mdouble InflowHeight; //<Height of inflow
    int max_failed;//indicates how many attempts are undertake to insert a new particle before each timestep
    int num_created;//internal variable; increases by one for each particle inserted
    TangentialSpringParticle P0; //<standard particle used for the inflow

private:

    bool is_periodic;
        
};




#endif