Chute.h

Go to the documentation of this file.

#ifndef CHUTE_H
#define CHUTE_H
#include "HGRID_3D.h"

class Chute : public HGRID_3D { 
public:
        
        Chute()
        {
                constructor();
                #ifdef CONSTUCTOR_OUTPUT
                        cerr << "Chute() finished" << 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
                        cerr << "Chute(MD& other) finished" << endl;
                #endif          
        }
        Chute(HGRID_base& other) : MD(other), HGRID_3D(other)
                {
                constructor();
                #ifdef CONSTUCTOR_OUTPUT
                        cerr << "Chute(HGRID_base& other)  finished" << endl;
                #endif          
        }
        Chute(HGRID_3D& other) : MD(other), HGRID_3D(other)
                {
                constructor();
                #ifdef CONSTUCTOR_OUTPUT
                        cerr << "Chute(HGRID_3D& other) finished" << 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);

        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 cerr << "WARNING : Fixed particle radius must be greater than or equal to zero" << 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) {cerr<<"WARNING: zero gravity";} set_ChuteAngle(new_, gravity);}
        void set_ChuteAngle(Mdouble new_, Mdouble gravity){if (new_>=0.0&&new_<=90.0) {ChuteAngle = new_*constants::pi/180.0; set_gravity(Vec3D(sin(ChuteAngle), 0.0, -cos(ChuteAngle))*gravity);} else cerr << "WARNING : Chute angle must be within [0,90]" << 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 cerr << "WARNING : Chute angle must be within [0,90]" << 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 cerr << "WARNING : Inflow particle must be greater than or equal to zero" << endl;
        }
        void set_InflowParticleRadius(Mdouble new_min, Mdouble new_max){
                if (new_min>=0.0)     {MinInflowParticleRadius=new_min;} else cerr << "WARNING : Min. inflow particle radius must be nonnegative" << endl;
                if (new_max>=new_min) {MaxInflowParticleRadius=new_max;} else cerr << "WARNING : Max. inflow particle radius must be >= min. inflow particle radius" << endl;
        }
        void set_MinInflowParticleRadius(Mdouble new_min){
                if (new_min<=MaxInflowParticleRadius) {MinInflowParticleRadius=new_min;} else cerr << "WARNING : Max. inflow particle radius must be >= min. inflow particle radius" << endl;
        }
        void set_MaxInflowParticleRadius(Mdouble new_max){
                if (new_max>=MinInflowParticleRadius) {MaxInflowParticleRadius=new_max;} else cerr << "WARNING : Max. inflow particle radius must be >= min. inflow particle radius" << 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 cerr << "WARNING : Inflow height not changed to " << new_ << ", value must be greater than or equal to diameter of inflow particle" << endl;
        }
        Mdouble get_InflowHeight(){return InflowHeight;}
        
        void set_InflowVelocity(Mdouble new_){
                if (new_ >= 0.0) InflowVelocity=new_; else cerr << "WARNING : Inflow velocity not changed, value must be greater than or equal to zero" << endl;
        }
        Mdouble get_InflowVelocity(){return InflowVelocity;}

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

        void set_InitialHeight(Mdouble new_){
                cerr << "WARNING : set_InitialHeight(Mdouble) is a deprecated function, use set_InflowHeight(Mdouble) instead." << endl;
                set_InflowHeight(new_);
        }
        Mdouble get_InitialHeight(){
                cerr << "WARNING : get_InitialHeight(Mdouble) is a deprecated function, use get_InflowHeight(Mdouble) instead." << endl;
                return get_InflowHeight();
        }
        void set_InitialVelocity(Mdouble new_){
                cerr << "WARNING : set_InitialVelocity(Mdouble) is a deprecated function, use set_InflowVelocity(Mdouble) instead." << endl;
                set_InflowVelocity(new_);
        }
        Mdouble get_InitialVelocity(){
                cerr << "WARNING : get_InitialVelocity(Mdouble) is a deprecated function, use get_InflowVelocity(Mdouble) instead." << endl;
                return get_InflowVelocity();
        }
        void set_InitialVelocityVariance(Mdouble new_){
                cerr << "WARNING : set_InitialVelocityVariance(Mdouble) is a deprecated function, use set_InflowVelocityVariance(Mdouble) instead." << endl;
                set_InflowVelocityVariance(new_);
        }
        Mdouble get_InitialVelocityVariance(){
                cerr << "WARNING : get_InitialVelocityVariance(Mdouble) is a deprecated function, use get_InflowVelocityVariance(Mdouble) instead." << 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(){cout<<"Chute set_dt"<<endl;set_dt(.02 * get_collision_time());}
        void set_dt(Mdouble dt){MD::set_dt(dt);}
        
        Particle* get_SmallestParticle();
        
        Particle* get_LargestParticle();
        
        Mdouble get_radius_of_smallest_particle();

protected:
        
        virtual bool IsInsertable(Particle &P);
        
        void add_particle(Particle &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_radius_of_largest_particle(){
                Mdouble max_rad=max(FixedParticleRadius,MaxInflowParticleRadius);
                for (vector<Particle*>::iterator it = get_ParticleHandler().begin(); it!=get_ParticleHandler().end(); ++it)
                        max_rad=max(max_rad,(*it)->get_Radius());
                return max_rad;

        }

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
        Particle P0; //<standard particle used for the inflow

private:

        bool is_periodic;
                
};




#endif