Sympy: Mecanica, Ejemplo de oscilador con un pendulo

 

Oscilador Duffing con un péndulo

En este ejemplo demostramos el uso de la funcionalidad proporcionada en sympy.physics.mechanics para derivar las ecuaciones de movimiento para un sistema que consiste en un oscilador con un péndulo. Este ejemplo está inspirado en el Documento [P.Brzeskia2012] Sección 2. 

  

El sistema se modelará con las ecuaciones de LaGrange. M, es masa del oscilador de duffing, m, es masa del péndulo,  l, es longitud del péndulo. k1 y k2,  son lineales y partes no lineales de la rigidez de la primavera, y c1, es un coeficiente de amortiguación viscoso del oscilador de duffing.  

>>import sympy as sm
>>import sympy.physics.mechanics as me
>>me.init_vprinting()

Definir variables 

>>M, m, l, k1, k2, c1, g, h, w, d, r = sm.symbols('M, m, l, k1, k2, c1, g, h, w, d, r')

>>q1, q2 = me.dynamicsymbols('q1 q2')

>>q1d = me.dynamicsymbols('q1', 1)

• h: altura del oscilador de Duffin

• w: ancho del oscilador de Duffin

• d: Profundidad del oscilador Duffing 
• r: Radio del enorme bob del péndulo  
• q1: Coordenada generalizada que representa la posición del oscilador de Duffing  
• q2: Coordenada generalizada que representa el ángulo del péndulo  

Definir cinemática

Defina todos los marcos y puntos de referencia.

>>N = me.ReferenceFrame('N')

>>B = N.orientnew('B', 'axis', (q2, N.z))

La velocidad angular del péndulo en el marco de referencia es:

>>B.ang_vel_in(N)
>>q2'(t) n_z

Las ubicaciones y las velocidades del bloque de osciladores de Duffing y el péndulo son:

>>O = me.Point('O')

>>block_point = O.locatenew('block', q1 * N.y)

>>pendulum_point = block_point.locatenew('pendulum', l * B.y)

O es un punto fijo en el marco de referencia inercial.

>>O.set_vel(N, 0)

>>block_point.set_vel(N, q1d * N.y)

>>pendulum_point.v2pt_theory(block_point, N, B)
>>q1'(t) n_y + -l*q2'(t) b_x

Definir inercia y cuerpos rígidos. Aquí, asumimos un péndulo simple que consiste en un bob de masa m colgando de una cadena de longitud sin masa l y fijado en un punto de pivote (bloqueo del oscilador de duffing).

>>I_block = M / 12 * me.inertia(N, h**2 + d**2, w**2 + d**2, w**2 + h**2)

>>I_pendulum = 2*m*r**2/5*me.inertia(B, 1, 0, 1)

>>block_body = me.RigidBody('block', block_point, N, M, (I_block, block_point))

>>pendulum_body = me.RigidBody('pendulum', pendulum_point, B, m, (I_pendulum, pendulum_point))

Definir fuerzas

Calculamos las fuerzas que actúan sobre el sistema. En este ejemplo, establecemos la energía potencial en cero en el lagrangiano e incluimos el Fuerzas conservadoras (gravedad y resorte de muescas) en las cargas.

>>path = me.LinearPathway(O, block_point)

>>spring = me.DuffingSpring(k1, k2, path, 0)

>>damper = me.LinearDamper(c1, path)

>>loads = spring.to_loads() + damper.to_loads()

>>bodies = [block_body, pendulum_body]

>>for body in bodies:

>>    loads.append(me.Force(body, body.mass * g * N.y))

>>loads
            /      _____           3/2\                  /        _____           3/2\
      |     /   2       /  2\   |                  |       /   2       /  2\   |
      \k1*\/  q1   + k2*\q1 /   /*q1               \- k1*\/  q1   - k2*\q1 /   /*q1
 [(O, ------------------------------ n_y), (block, -------------------------------- n_y), (O, c1*q1'(t) n_y), (block, -c1*q1'(t) n_y), (block, M*g n_y), (pendulum, g*m n_y)]
                    _____                                         _____
                   /   2                                         /   2
                 \/  q1                                        \/  q1

 

 

Método de LaGrange

Con la configuración del problema, se puede calcular el Lagrangiano y se forman las ecuaciones de movimiento.

L = me.Lagrangian(N, block_body, pendulum_body)

L
         2      2       2     / 2       2                                     2\
 M*q1'(t)    m*r *q2'(t)    m*\l *q2'(t)  - 2*l*sin(q2)*q1'(t)*q2'(t) + q1'(t) /
 --------- + ------------ + ----------------------------------------------------
     2            5                                  2

LM = me.LagrangesMethod(L, [q1, q2], bodies=bodies, forcelist=loads, frame=N)

sm.simplify(LM.form_lagranges_equations())
 [                                       /                                    2          \   /          2\   ]
 [-M*g + M*q1''(t) + c1*q1'(t) - g*m - m*\l*sin(q2)*q2''(t) + l*cos(q2)*q2'(t)  - q1''(t)/ + \k1 + k2*q1 /*q1]
 [                                                                                                           ]
 [                     /                   2                                    2        \                   ]
 [                   m*\5*g*l*sin(q2) + 5*l *q2''(t) - 5*l*sin(q2)*q1''(t) + 2*r *q2''(t)/                   ]
 [                   ---------------------------------------------------------------------                   ] 
 [                                                     5                                        

Sympy: Mas herramientas

 

Sobre

Sympy es una biblioteca de Python para las matemáticas simbólicas. Su objetivo es convertirse en un sistema de álgebra de computadora (CAS) con todas las funciones mientras mantiene el código como Simple posible para ser comprensible y fácilmente extensible. Sympy está escrito completamente en Python. 

Por qué Sympy

Sympy es ...

• GRATIS: Licenciado bajo BSD, Sympy es libre tanto como en el habla como en la cerveza.
• Basado en Python: Sympy está escrito completamente en Python y usa Python para su lenguaje.
• Ligero: Sympy solo depende de MPMath , una biblioteca de Python pura para arbitrary aritmética de punto flotante, lo que hace que sea fácil de usar.
• Una biblioteca: más allá del uso como una herramienta interactiva, Sympy se puede integrar en otras aplicaciones y extenderse con funciones personalizadas. 

 

Proyectos utilizando Sympy

Esta es una lista (incompleta) de proyectos que usan Sympy. Si usa Sympy en Su proyecto, háganos saber en nuestra lista de correo , para que podamos agregar su Proyecto aquí también.

• Cadabra : Álgebra tensor y (cuántica) Sistema de teoría de campo que usa Sympy para álgebra escalar.
• Chempy : Un paquete útil para la química escrita en Python.
• Devito : Un DSL simbólico y un compilador justo a tiempo para Cálculo de plantilla de alto rendimiento.
• Einsteinpy : Un paquete de pitón para simbólicos y numéricos Relatividad general.
• Galdebra : Álgebra geométrica (anteriormente Sympy.galgebra).
• Proyecto de expresión de látex : Tipo de látex fácil de expresiones algebraicas en simbólico Formulario con sustitución automática y cálculo de resultados).
• Lcapy : Paquete experimental de Python para la enseñanza del circuito lineal análisis.
• Octsympy : Un paquete simbólico para octava usando Sympy.
• Optlang : Un paquete de Python para resolver la optimización matemática problemas.
• Pydy : Dinámica multibuerpo en Python.
• Pyneqsys : Resolver sistemas definidos simbólicamente de ecuaciones no lineales numéricamente.
• Pyodesys : Integración numérica directa de los sistemas ODE de Pitón.
• Pytorch Torchinductor : Torchinductor usa Sympy para admitir formas y pasos dinámicos.
• QMCPACK : Quantum Monte Carlo en C ++. Sympy se usa para generar valores de referencia para pruebas unitarias y alguna generación de código.
• Programación cuántica en Python : Ascilador armónico simple Quantum 1D y mapeo cuántico Puerta.
• Sagemath : Sistema de matemáticas de código abierto que Incluye Sympy.
• Scikit-Fdiff : Diferencias finitas discretización.
• Sfepy : Elementos finitos simples en Python.
• Spyder : El entorno de desarrollo científico de Python, una pitón equivalente a rstudio o matlab; El soporte completo de Sympy se puede habilitar en Spyder Consolas Ipython .
• Modelado estadístico simbólico : Agregar operaciones estadísticas a modelos físicos complejos.
• Symjit : Un compilador liviano justo a tiempo (JIT) para expresiones de Sympy.
• YT : Paquete de Python para analizar y visualizar datos volumétricos ( unyt , el YT Sistema de unidades, usa Sympy).

 

 

MatplotLib: Guia de inicio rapido para Dummies

 

Guía de inicio rápido

Este tutorial cubre algunos patrones de uso básicos y las mejores prácticas para ayudarlo a comenzar con matplotlib.

>>import matplotlib.pyplot as plt
>>import numpy as np

Un ejemplo simple

Matplotlib grafica sus datos sobre FigureS (por ejemplo, Windows, Jupyter widgets, etc.), cada uno de los cuales puede contener uno o más Axes, un área donde se pueden especificar los puntos en términos de coordenadas XY (o theta-r en una trama polar, xyz en una trama 3D, etc.). La forma más simple de Crear una figura con un hachas está usando pyplot.subplots. Entonces podemos usar Axes.plot para dibujar algunos datos sobre los ejes y show para mostrar la figura:

>>fig, ax = plt.subplots()             # Create a figure containing a single Axes.
>>ax.plot([1, 2, 3, 4], [1, 4, 2, 3])  # Plot some data on the Axes.
>>plt.show()                           # Show the figure.

Dependiendo del entorno en el que esté trabajando, plt.show() se puede dejar afuera. Este es, por ejemplo, el caso con Jupyter Notebooks, que Muestre automáticamente todas las figuras creadas en una celda de código. 

Partes de una figura

Aquí están los componentes de una figura matplotlib. 

 

 

Figure

Toda la figura . La figura mantiene pista de todo el niño Axes, un grupo de Artistas 'especiales' (títulos, leyendas de figuras, barras de colores, etc.), y Incluso subfiguras anidadas.

Por lo general, creará una nueva figura a través de una de las siguientes Funciones:

>>fig = plt.figure()             # an empty figure with no Axes
>>fig, ax = plt.subplots()       # a figure with a single Axes
>>fig, axs = plt.subplots(2, 2)  # a figure with a 2x2 grid of Axes
>># a figure with one Axes on the left, and two on the right:
>>fig, axs = plt.subplot_mosaic([['left', 'right_top'],
                               ['left', 'right_bottom']])

subplots()y subplot_mosaic son las funciones de conveniencia que también crean objetos de ejes dentro de la figura, pero también puede Agregue manualmente los ejes más adelante.

Para obtener más información sobre las cifras, incluida la panorámica y el zoom, consulte Introducción a las figuras .

Axes

Un hacha es un artista adjunto a una figura que contiene una región para trazar datos, y generalmente incluye dos (o tres en el caso de 3D) Axis Objetos (tenga en cuenta la diferencia entre ejes y eje ) que proporcionan garrapatas y etiquetas de tick a Proporcionar escalas para los datos en los ejes. Cada Axes también tiene un título (Establecer vía set_title()), un X-Label (establecido a través de set_xlabel()), y un conjunto de etiquetas y a través de set_ylabel()).

El Axes Los métodos son la interfaz principal para configurar La mayoría de las partes de su gráfica (agregando datos, controlando las escalas del eje y límites, agregar etiquetas, etc.). 

 

Axis

Estos objetos establecen la escala y los límites y generan garrapatas (las marcas en el eje) y ticklabels (cadenas etiquetando las garrapatas). La ubicación de las garrapatas está determinado por un Locator objeto y el Las cadenas de ticklabel están formateadas por un Formatter. El combinación de lo correcto Locatory Formatter Da muy bien Control sobre las ubicaciones y las etiquetas de las garrapatas.

 

Artist

Básicamente, todo lo visible en la figura es un artista (incluso Figure, Axes, y Axis objetos). Esto incluye Text objetos, Line2D objetos, collections objetos, Patch objetos, etc. Cuando se representa la figura, todo el Los artistas se sienten atraídos por el lienzo . La mayoría de los artistas están atados a un ejes; semejante Un artista no puede ser compartido por múltiples ejes, ni moverse de uno a otro.

 
Tipos de entradas para trazar funciones

Las funciones de trazado esperan numpy.array o numpy.ma.masked_array como entrada u objetos que se pueden pasar a numpy.asarray. Clases que son similares a las matrices ('como una matriz') como pandas objetos de datos y numpy.matrix Puede que no funcione según lo previsto. Convención común es convertirlos en numpy.array Objetos antes de trazar. Por ejemplo, para convertir un numpy.matrix

>>b = np.matrix([[1, 2], [3, 4]])

>>b_asarray = np.asarray(b)

 La mayoría de los métodos también analizarán un objeto indexable de cadenas como un dict , un matriz numpy estructurada , o un pandas.DataFrame. Matplotlib te permite para proporcionar el data argumento de palabras clave y generar tramas que pasan el cadenas correspondientes a las x e y variables 

>>np.random.seed(19680801)  # seed the random number generator.

>>data = {'a': np.arange(50),

        'c': np.random.randint(0, 50, 50),

        'd': np.random.randn(50)}

>>data['b'] = data['a'] + 10 * np.random.randn(50)

>>data['d'] = np.abs(data['d']) * 100

>>fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')

>>ax.scatter('a', 'b', c='c', s='d', data=data)

>>ax.set_xlabel('entry a')

>>ax.set_ylabel('entry b')