Una bola que sale por el borde de una mesa

Procedimiento numérico

Raíz de una ecuación trascendente.

Resolver por el procedimiento del punto medio la ecuación trascendente.

$μ_{s} (17 g \sin θ_{1} - 7 R ω_{0}^{2} - 10 g) = 2 g \cos θ_{1}$

public class Funcion extends Ecuacion{
    double mu;
    double w0;
    final double radio=1.0;
    public Funcion(double mu, double w0){
      this.mu=mu;
      this.w0=w0;
    }
    public double f(double x){
        double y=mu*(17*9.8*Math.sin(x)-7*radio*w0*w0-10*9.8)-2*9.8*Math.cos(x);
        return y;
    }
}

Ecuación diferencial de segundo orden

Primera etapa del movimiento de la bola

$\frac{d^{2} θ}{d t^{2}} = - \frac{5}{7} \frac{g}{R} \cos θ$

Se resuelve la ecuación diferencial por procedimientos numéricos con las siguientes condiciones iniciales: en el instante t=0, θ=π/2, dθ/dt=ω₀.

Se termina la primera etapa del movimiento en el instante t₁ cuando el c.m. de la bola forma un ángulo θ₁

Segunda etapa del movimiento: La bola desliza

Par describir el movimiento del c.m. de la bola hay que resolver la ecuación diferencial

$\frac{d^{2} ϕ}{d t^{2}} = - \frac{g}{R} (\cos ϕ - μ_{k} \sin ϕ) - μ_{k} {(\frac{d ϕ}{d t})}^{2}$

por procedimientos numéricos, con las siguientes condiciones iniciales: en el instante t=t₁, φ=θ₁, dφ/dt=(dθ/dt)₁

${(\frac{d θ}{d t})}_{1} = \sqrt{\frac{10}{7} \frac{g}{R} (1 - \sin θ_{1}) + ω_{0}^{2}}$

Concluye esta etapa del movimiento cuando el valor fuerza normal N

$N = m g \sin ϕ - m R {(\frac{d ϕ}{d t})}^{2}$

es nula.

Para describir el movimiento de rotación de la bola tenemos que resolver la ecuación diferencial de segundo orden

$I_{c} \frac{d^{2} θ}{d t^{2}} = - F_{r} R I_{c} = \frac{2}{5} m R^{2}$

con las siguientes condiciones iniciales: en el instante t=t₁, θ=θ₁, dθ/dt=(dθ/dt)_1.Donde

$F_{r} = m R \frac{d^{2} ϕ}{d t^{2}} + m g \cos ϕ$

La ecuación diferencial del movimiento del c.m. nos proporciona el valor de la fuerza de rozamiento F_r en el instante t.

Para resolver la ecuación diferencial del movimiento de rotación aplicamos el procedimiento poco peciso de Euler

public abstract class Estado {
	double t;
	double x;
	double vx;
public Estado(double t, double x, double vx) {
	this.t=t;
	this.x=x;
	this.vx=vx;
}
}

public abstract class RungeKutta {
	double h;
public RungeKutta(double h){
	this.h=h;
}
public void resolver(Estado e){
//variables auxiliares
	double k1, k2, k3, k4;
	double l1, l2, l3, l4;
	double q1, q2, q3, q4;
	double m1, m2, m3, m4;
//condiciones iniciales
	double x=e.x;
	double v=e.vx;
	double t=e.t;

	k1=h*v;
	l1=h*f(x, v, t);
	k2=h*(v+l1/2);
	l2=h*f(x+k1/2, v+l1/2, t+h/2);
	k3=h*(v+l2/2);
	l3=h*f(x+k2/2, v+l2/2, t+h/2);
	k4=h*(v+l3);
	l4=h*f(x+k3, v+l3, t+h);
//nuevo estado del sistema
	x+=(k1+2*k2+2*k3+k4)/6;
	v+=(l1+2*l2+2*l3+l4)/6;
//cambia el estado de la partícula
	e.x=x;
	e.vx=v;
	e.t=t+h;
}
abstract public double f(double x, double v, double t);
    abstract public double fNormal(double x, double v);
    abstract public double fRozamiento(double x, double v);
}

public class Sistema1 extends RungeKutta{
    final double radio=1.0;
    public Sistema1(double h){
      super(h);
    }
    public double f(double x, double v, double t){
         return (-5*9.8*Math.cos(x)/(7*radio));
    }
    public double fNormal(double x, double v){
        return(-radio*v*v+9.8*Math.sin(x));
    }
    public double fRozamiento(double x, double v){
        return(radio*f(x, 0.0, 0.0)+9.8*Math.cos(x));
    }
}

public class Sistema2 extends RungeKutta {
    final double radio=1.0;
    double mu;
    public Sistema2(double mu, double h){
      super(h);
      this.mu=mu;
    }
    public double f(double x, double v, double t){
         return (-9.8*(Math.cos(x)-mu*Math.sin(x))/radio-mu*v*v);
    }
    public double fNormal(double x, double v){
        return (-radio*v*v+9.8*Math.sin(x));
    }
    public double fRozamiento(double x, double v){
        return (radio*f(x, v, 0.0)+9.8*Math.cos(x));
    }

}

public class MiCanvas extends Canvas {
     final double radio=1.0;
     double xCM, yCM;
     final double dt=0.001;
     double t;
     int tipo=0;
     double angulo=Math.PI/2, vAngular;
     double mu=0.3;
     double angLimite;
     double x0, y0, v0x, v0y, angulo_0;
//objeto
   Estado estado=new Estado(0.0, 0.0, 0.0);
   RungeKutta sistema=null;
   Funcion f;


 void setNuevo(double vIni, double mu){
     this.mu=mu;
     estado=new Estado(0.0, Math.PI/2, -vIni/radio);
      xCM=0.0;
     yCM=0.0;
     t=0.0;
     tipo=1;
     f=new Funcion(mu, -vIni/radio);
     try{
        angLimite=f.puntoMedio(0.0, Math.PI/2);
     }catch(Exception e){
     }
     angulo=Math.PI/2;
     sistema=new Sistema1(dt);
     angulo_0=0;
 }

 void mover(){
     switch(tipo){
        case 1:
          sistema.resolver(estado);
          xCM=radio*Math.cos(estado.x);
          yCM=radio*Math.sin(estado.x)-radio;
          angulo=estado.x;
          if(estado.x<angLimite){
              sistema=new Sistema2(mu, dt);
               angulo=estado.x;
              vAngular=estado.v;
              tipo=2;
          }
          break;
        case 2:
          sistema.resolver(estado);
          xCM=radio*Math.cos(estado.x);
          yCM=radio*Math.sin(estado.x)-radio;
//método de Euler
          double acelAngular=-5*sistema.fRozamiento(estado.x, estado.v)/(2*radio);
          vAngular+=acelAngular*dt;
          angulo+=vAngular*dt;
          if(sistema.fNormal(estado.x, estado.v)<=0.0){
                angulo_0=angulo;
                v0x=-radio*estado.v*Math.sin(estado.x);
                v0y=-radio*estado.v*Math.cos(estado.x);
                x0=xCM;
                y0=yCM;
                tipo=3;
                t=0.0;
          }
          break;
        case 3:
            xCM=x0+v0x*t;
            yCM=y0-v0y*t-4.9*t*t;
            angulo=angulo_0+vAngular*t;
            break;
        default:
          break;
     }
    t+=dt;
 }