The course is based on applications of the analytical mechanics in analysis of different type of oscillators. Concepts are sorted in
the order of increasing degree of complexity. Generation of solutions of the problems is powered by dynamical systems implemented in the
DynPy library for Python language. In order to use the source code, the installation of attached DynPy library is required.
DynPy library
Download PDF with solution of the problem.
Display the source code
1. Single degree of freedom systems
Simple harmonic oscillator
The simplest example showing the response of undamped single degree of freedom system. It's an elementary example allowing to
understand the vocabulary used in applied dynamics, which will be helpful in analysis of more complex concepts.
from dynpy.models.mechanics.trolley import SpringMassSystem
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = SpringMassSystem().from_reference_data()
display('Data assumed for the calculations is the following:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
Engine mount
Case of vibrations forced by a force with harmonic component coming from rotational motion of unbalanced mass. Concept shows actual engineering
problem occuring in rotating machinery design.
from dynpy.models.mechanics.engine import EngineVerticalSpringGravity
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = EngineVerticalSpringGravity().get_constant_velocity()
display('Data assumed fot calculations is the following:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Funfdamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
Pendulum
The simplest example of vibration of generalized coordinate defined by an angle. Totally basic concept in inderstanding of the behaviour of
bodies lifted by cranes or other elements suspended by ropes or cables.
from dynpy.models.mechanics.pendulum import Pendulum
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = Pendulum().from_reference_data()
display('Do obliczeń przyjęto:')
display(dynsys._given_data)
# Wyświetlenie schematu
display(dynsys.preview())
# Energia kinetyczna
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Energia potencjalna
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Potencjał dyssypacyjny
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagranżjan ukladu
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Równania ruchu
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Macierz bezwładnosci
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Macierz sztywności
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Macierz tłumienia
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Macierz fundamentalna
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Wielomian charakterystyczny
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# Rozwiązania ogólne
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Rozwiązania szczególne
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
2. Damped single degree of freedom systems
Blower toothed belt tensioner
Example showing influence of damping on the response of the system to a harmonic excitation presented on the model of belt tensioner used
in belt drives. The understading of operation of such device and influence of vibrations on it's performance plays a key role in belt drives
and belt transmition design.
from dynpy.models.mechanics.tensioner import DampedBlowerToothedBelt
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = DampedBlowerToothedBelt().from_reference_data()
display('Data assumed for the calculations:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagranian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
Damped engie mount
Example allowing anlysis of damping influence of previously analyzed system. In reality purely undamped systems do not exist, so investigation of
known system in which damping is introduced may be helpful in understanding of the overall concept od damping.
from dynpy.models.mechanics.engine import DampedEngineVerticalSpringGravity
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = DampedEngineVerticalSpringGravity().get_constant_velocity()
display('Data ssumed for calculations:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
3. Multi degree of freedom systems
Tuned mass damper
Example showing the possibility of change in natural frequency of the system, by introduction of additional degree of of freedom.
Solutions known as TMD are often applied in buildings or bridges in order the reduce the danger coming from the resonance phenomenon.
from dynpy.models.mechanics.engine import EngineWithTMD
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = EngineWithTMD().from_reference_data()
display('Data assumed for calculations:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
Vehicle suspension
Analysis of the model with both linear and angular displacement. Model respresents simplified dynamics of the vehicle suspension. There are many possible ways to
model such system and many possibilities to design a vehicle suspension as well. In this case it's modeled by two simple columns represented by springs.
from dynpy.models.mechanics.vehicle import UndampedSymmetricalVehicleSuspension
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = UndampedSymmetricalVehicleSuspension().from_reference_data()
display('Data assumed for calculations:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damped matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
4. Damped multi degree of freedom systems
Damped vehicle suspension
Known model of vehicle suspension extented by influence of viscous damping. In comparison with previously analyzed case, this approach
is much closer to a physical model of actual suspension equipped with shock absorbers.
from dynpy.models.mechanics.vehicle import DampedSymmetricalVehicleSuspension
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = DampedSymmetricalVehicleSuspension().from_reference_data()
display('Data assumed for calculations:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinematic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
Bridge span lateral dynamics
Model representing approximated dynamics of bridge spans and their relative motion in response to the harmonic excitation. Constructions of this type
are designed in a way which gives the elements some freedom of motion. Model assembled with trolleys, springs and dampers respresnts the dynamics of such
motion.
from dynpy.models.mechanics.trolleys import ForcedDampedTrolleysWithSprings
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = ForcedDampedTrolleysWithSprings().from_reference_data()
display('Data assumed for calculations:')
display(dynsys._given_data)
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
5. Nonlinear systems
Disc with nonlinear spring
System performing nonlinear vibrations, additionally introdcing motion by rolling. Analysis of this system introduces the concept of spring with nonlinear
characteristic, which is often used in nonlinear systems modeling.
from dynpy.models.mechanics.disk import DiskWithNonlinearSpring
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Class instance assignment
dynsys = DiskWithNonlinearSpring()
# Displaying the scheme
display(dynsys.preview())
# Kinetic energy
Ek = Symbol('E_k', positive=True)
Ek_eq = Eq(Ek, dynsys._kinetic_energy, evaluate=False)
display(Ek_eq)
# Potential energy
Ep = Symbol('E_p', positive=True)
Ep_eq = Eq(Ep, dynsys._potential_energy, evaluate=False)
display(Ep_eq)
# Dissipative potential
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys._dissipative_potential, evaluate=False)
display(D_eq)
# Lagrangian of the system
L = Symbol('L', positive=True)
L_eq = Eq(L, dynsys.lagrangian(), evaluate=False)
display(L_eq)
# Equations of motion
eoms_eq = Eq(dynsys._eoms[0], 0)
display(eoms_eq)
# Inertia matrix
M = Symbol('M', positive=True)
M_eq = Eq(M, dynsys.inertia_matrix(), evaluate=False)
display(M_eq)
# Stiffness matrix
K = Symbol('K', positive=True)
K_eq = Eq(K, dynsys.stiffness_matrix(), evaluate=False)
display(K_eq)
# Damping matrix
D = Symbol('D', positive=True)
D_eq = Eq(D, dynsys.damping_matrix(), evaluate=False)
display(D_eq)
# Fundamental matrix
A = Symbol('A', positive=True)
A_eq = Eq(A, dynsys.fundamental_matrix(), evaluate=False)
display(A_eq)
# Characteristic polynomial
Delta = Symbol('Delta', positive=True)
Delta_eq = Eq(Delta, dynsys.fundamental_matrix().det().expand().simplify().simplify().expand(), evaluate=False)
display(Delta_eq)
# General solution
gen_sol = dynsys._ode_system.general_solution.as_eq_list()
display(gen_sol[0])
display(gen_sol[1])
# Steady solution
steady_sol = dynsys._ode_system.steady_solution.as_eq_list()
display(steady_sol[0])
display(steady_sol[1])
Inverted pendulum
Inverted pendulum is a widely applied benchmark for control systems. Analysis allows to understand conpept of linearization and terms such as
stable and unstable equilibrium points of the system.
