Un disco rodante
Se supone que el disco es infinitamente delgado, en contacto con el suelo a solo 1 punto, y está rodando sin deslizar el suelo. Vea la imagen anterior.
Modelamos el disco rodante de tres maneras diferentes, para mostrar más de la funcionalidad de este módulo.
- Un disco rodante, con el método de Kane
- Un disco rodante, con el método y las fuerzas de restricción de Kane
- Un disco rodante que usa el método de LaGrange
Un disco rodante, con el método de Kane
Aquí se forma la definición de la cinemática del disco rodante desde el contacto Apunte hacia arriba, eliminando la necesidad de introducir velocidades generalizadas. Solo 3 Se necesitan como variables de configuración y tres velocidades para describir este sistema, a lo largo de con la masa y el radio del disco, y la gravedad local (tenga en cuenta que la masa Abandonar).
>>from sympy import symbols, sin, cos, tan
>>from sympy.physics.mechanics import *
>>q1, q2, q3, u1, u2, u3 = dynamicsymbols('q1 q2 q3 u1 u2 u3')
>>q1d, q2d, q3d, u1d, u2d, u3d = dynamicsymbols('q1 q2 q3 u1 u2 u3', 1)
>>r, m, g = symbols('r m g')
>>mechanics_printing(pretty_print=False)
Las cinemáticas están formadas por una serie de rotaciones simples. Cada rotación simple crea un nuevo cuadro, y la siguiente rotación se define mediante la base del nuevo cuadro vectores. Este ejemplo utiliza una serie 3-1-2 de rotaciones, o serie Z, X, Y de rotaciones. La velocidad angular para esto se define utilizando la base del segundo cuadro (el marco delgado); Es por esta razón que definimos marcos intermedios, en lugar de usar una orientación del cuerpo y tres.
>>N = ReferenceFrame('N')
>>Y = N.orientnew('Y', 'Axis', [q1, N.z])
>>L = Y.orientnew('L', 'Axis', [q2, Y.x])
>>R = L.orientnew('R', 'Axis', [q3, L.y])
>>w_R_N_qd = R.ang_vel_in(N)
>>R.set_ang_vel(N, u1 * L.x + u2 * L.y + u3 * L.z)
Esta es la cinemática traslacional. Creamos un punto sin velocidad en n; Este es el punto de contacto entre el disco y la tierra. Siguiente que formamos El vector de posición desde el punto de contacto al centro de masa del disco. Finalmente formamos la velocidad y la aceleración del disco.
>>C = Point('C')
>>C.set_vel(N, 0)
>>Dmc = C.locatenew('Dmc', r * L.z)
>>Dmc.v2pt_theory(C, N, R) >>r*u2*L.x - r*u1*L.y
Esta es una forma simple de formar la inercia diádica. La inercia del disco lo hace no cambiar dentro del marco delgado a medida que el disco rueda; Esto hará que sean más simples ecuaciones al final.
>>I = inertia(L, m / 4 * r**2, m / 2 * r**2, m / 4 * r**2)
>>mprint(I) >>m*r**2/4*(L.x|L.x) + m*r**2/2*(L.y|L.y) + m*r**2/4*(L.z|L.z)
Ecuaciones diferenciales cinemáticas; Cómo el tiempo de coordenada generalizada Los derivados se relacionan con velocidades generalizadas.
>>kd = [dot(R.ang_vel_in(N) - w_R_N_qd, uv) for uv in L]
Creación de la lista de fuerza; Es la fuerza gravitacional en el centro de la masa de el disco. Luego creamos el disco asignando un punto al centro de masa atributo, un marco de referencia al atributo de cuadro, y masa e inercia. Entonces Formamos la lista del cuerpo.
>>ForceList = [(Dmc, - m * g * Y.z)]
>>BodyD = RigidBody('BodyD', Dmc, R, m, (I, Dmc))
>>BodyList = [BodyD]
Finalmente formamos las ecuaciones de movimiento, usando los mismos pasos que hicimos antes. Especificar marco inercial, suministrar coordenadas y velocidades generalizadas, suministro Diccionario de ecuación diferencial cinemática, calcule FR de la lista de fuerza y Fr* Desde la lista del cuerpo, calcule la matriz de masa y los términos de forzamiento, luego resuelva para los puntos U (derivados de tiempo de las velocidades generalizadas).
>>KM = KanesMethod(N, q_ind=[q1, q2, q3], u_ind=[u1, u2, u3], kd_eqs=kd)
>>(fr, frstar) = KM.kanes_equations(BodyList, ForceList)
>>MM = KM.mass_matrix
>>forcing = KM.forcing
>>rhs = MM.inv() * forcing
>>kdd = KM.kindiffdict()
>>rhs = rhs.subs(kdd)
>>rhs.simplify()
>>mprint(rhs) >>Matrix([ >>[(4*g*sin(q2) + 6*r*u2*u3 - r*u3**2*tan(q2))/(5*r)], >>[ -2*u1*u3/3], >>[ (-2*u2 + u3*tan(q2))*u1]])
Un disco rodante, con el método y las fuerzas de restricción de Kane
Ahora volveremos a visitar el ejemplo del disco rodante, excepto que esta vez estamos trayendo Las fuerzas no contributivas (restricción) como evidencia. Ver [Kane1985] para un Explicación más completa de esto. Aquí, encenderemos la automática Simplificación realizada al realizar operaciones vectoriales. Hace que las salidas sean más agradables para Pequeños problemas, pero pueden hacer que las operaciones vectoriales más grandes cuelguen.
>>from sympy import symbols, sin, cos, tan
>>from sympy.physics.mechanics import *
>>mechanics_printing(pretty_print=False)
>>q1, q2, q3, u1, u2, u3 = dynamicsymbols('q1 q2 q3 u1 u2 u3')
>>q1d, q2d, q3d, u1d, u2d, u3d = dynamicsymbols('q1 q2 q3 u1 u2 u3', 1)
>>r, m, g = symbols('r m g')
Estas dos líneas introducen las cantidades adicionales necesarias para encontrar la restricción. efectivo.
>>u4, u5, u6, f1, f2, f3 = dynamicsymbols('u4 u5 u6 f1 f2 f3')
La mayor parte del código principal es el mismo que antes.
>>N = ReferenceFrame('N')
>>Y = N.orientnew('Y', 'Axis', [q1, N.z])
>>L = Y.orientnew('L', 'Axis', [q2, Y.x])
>>R = L.orientnew('R', 'Axis', [q3, L.y])
>>w_R_N_qd = R.ang_vel_in(N)
>>R.set_ang_vel(N, u1 * L.x + u2 * L.y + u3 * L.z)
La definición de rodar sin deslizamiento requiere que la velocidad del El punto de contacto es cero; como parte de poner en evidencia las fuerzas de restricción, Tenemos que introducir velocidades en este punto, que por definición siempre serán cero. Son normales al suelo, a lo largo del camino que el disco está rodando, y a lo largo del suelo en una dirección perpendicular.
>>C = Point('C')
>>C.set_vel(N, u4 * L.x + u5 * cross(Y.z, L.x) + u6 * Y.z)
>>Dmc = C.locatenew('Dmc', r * L.z)
>>vel = Dmc.v2pt_theory(C, N, R)
>>I = inertia(L, m / 4 * r**2, m / 2 * r**2, m / 4 * r**2)
>>kd = [dot(R.ang_vel_in(N) - w_R_N_qd, uv) for uv in L]
Al igual que presentamos anteriormente tres velocidades como parte de este proceso, también introducir tres fuerzas; están en la misma dirección que las velocidades y Representar las fuerzas de restricción en esas direcciones.
>>ForceList = [(Dmc, - m * g * Y.z), (C, f1 * L.x + f2 * cross(Y.z, L.x) + f3 * Y.z)]
>>BodyD = RigidBody('BodyD', Dmc, R, m, (I, Dmc))
>>BodyList = [BodyD]
>>KM = KanesMethod(N, q_ind=[q1, q2, q3], u_ind=[u1, u2, u3], kd_eqs=kd,
u_auxiliary=[u4, u5, u6])
>>(fr, frstar) = KM.kanes_equations(BodyList, ForceList)
>>MM = KM.mass_matrix
>>forcing = KM.forcing
>>rhs = MM.inv() * forcing
>>kdd = KM.kindiffdict()
>>rhs = rhs.subs(kdd)
>>rhs.simplify()
>>mprint(rhs) >>Matrix([ >>[(4*g*sin(q2) + 6*r*u2*u3 - r*u3**2*tan(q2))/(5*r)], >>[ -2*u1*u3/3], >>[ (-2*u2 + u3*tan(q2))*u1]])
>>from sympy import trigsimp, signsimp, collect, factor_terms
>>def simplify_auxiliary_eqs(w):
>> return signsimp(trigsimp(collect(collect(factor_terms(w), f2), m*r)))
>>mprint(KM.auxiliary_eqs.applyfunc(simplify_auxiliary_eqs)) >>Matrix([ >>[ -m*r*(u1*u3 + u2') + f1], >>[-m*r*u1**2*sin(q2) - m*r*u2*u3/cos(q2) + m*r*cos(q2)*u1' + f2], >>[ -g*m + m*r*(u1**2*cos(q2) + sin(q2)*u1') + f3]])
Un disco rodante que usa el método de LaGrange
Aquí el disco rodante se forma desde el punto de contacto, eliminando el Necesito introducir velocidades generalizadas. Solo 3 configuración y 3 Se necesitan variables de velocidad para describir este sistema, junto con el Misa y radio del disco, y la gravedad local.
>>from sympy import symbols, cos, sin
>>from sympy.physics.mechanics import *
>>mechanics_printing(pretty_print=False)
>>q1, q2, q3 = dynamicsymbols('q1 q2 q3')
>>q1d, q2d, q3d = dynamicsymbols('q1 q2 q3', 1)
>>r, m, g = symbols('r m g')
Las cinemáticas están formadas por una serie de rotaciones simples. Cada uno simple La rotación crea un nuevo marco, y la siguiente rotación está definida por el nuevo Vectores de base del marco. Este ejemplo utiliza una serie de rotaciones 3-1-2, o La serie de rotaciones Z, X, Y. La velocidad angular para esto se define usando La base del segundo cuadro (el marco delgado).
>>N = ReferenceFrame('N')
>>Y = N.orientnew('Y', 'Axis', [q1, N.z])
>>L = Y.orientnew('L', 'Axis', [q2, Y.x])
>>R = L.orientnew('R', 'Axis', [q3, L.y])
Esta es la cinemática traslacional. Creamos un punto sin velocidad en n; Este es el punto de contacto entre el disco y la tierra. Siguiente que formamos El vector de posición desde el punto de contacto al centro de masa del disco. Finalmente formamos la velocidad y la aceleración del disco.
>>C = Point('C')
>>C.set_vel(N, 0)
>>Dmc = C.locatenew('Dmc', r * L.z)
>>Dmc.v2pt_theory(C, N, R) >>r*(sin(q2)*q1' + q3')*L.x - r*q2'*L.y
Formando la inercia diádica.
>>I = inertia(L, m / 4 * r**2, m / 2 * r**2, m / 4 * r**2)
>>mprint(I) >>m*r**2/4*(L.x|L.x) + m*r**2/2*(L.y|L.y) + m*r**2/4*(L.z|L.z)
>>BodyD = RigidBody('BodyD', Dmc, R, m, (I, Dmc))
Luego establecemos la energía potencial y determinamos el lagrangiano del rodamiento. desct.
>>BodyD.potential_energy = - m * g * r * cos(q2)
>>Lag = Lagrangian(N, BodyD)
Entonces las ecuaciones de movimiento se generan inicializando el
LagrangesMethod objeto. Finalmente resolvemos para el generalizado
aceleraciones (q puntos dobles) con el rhs método.
>>q = [q1, q2, q3]
>>l = LagrangesMethod(Lag, q)
>>le = l.form_lagranges_equations()
>>le.simplify(); le >>Matrix([ [m*r**2*(6*sin(q2)*q3'' + 5*sin(2*q2)*q1'*q2' + 6*cos(q2)*q2'*q3' - 5*cos(2*q2)*q1''/2 + 7*q1''/2)/4], [ m*r*(4*g*sin(q2) - 5*r*sin(2*q2)*q1'**2/2 - 6*r*cos(q2)*q1'*q3' + 5*r*q2'')/4], [ 3*m*r**2*(sin(q2)*q1'' + cos(q2)*q1'*q2' + q3'')/2]])
lrhs = l.rhs(); lrhs.simplify(); lrhs Matrix([ [ q1'], [ q2'], [ q3'], [ -2*(2*tan(q2)*q1' + 3*q3'/cos(q2))*q2'], [-4*g*sin(q2)/(5*r) + sin(2*q2)*q1'**2/2 + 6*cos(q2)*q1'*q3'/5], [ (-5*cos(q2)*q1' + 6*tan(q2)*q3' + 4*q1'/cos(q2))*q2']])
No hay comentarios.:
Publicar un comentario