Kurs opiera się na wykorzystaniu metod mechaniki analitycznej do analizy różnego typu oscylatorów.
Zagadnienia uszeregowane są w kolejności od najmniejszego do największego stopnia skomplikowania.
By skorzystać z udostępnionych kodów niezbędne jest pobranie biblioteki dynpy dostępnej w przycisku poniżej. Wybrany kod należy następnie wkleić do projektu Jupyter Notebook.
Biblioteka dynpy
Pobierz PDF z rozwiązanym zadaniem
Wyświelt kod źródłowy
1. Układy o jednym stopniu swobody
Prosty oscylator harmoniczny
Najprostszy przykład pokazujący odpowiedź układu nietłumionego o jednym stopniu swobody. Jest to elementarny przykład
pozwalający zrozumieć terminoglogię używaną w stosowanej dynamice, co będzie pomocne w analizie bardziej skomplikowanych zagadnień.
from dynpy.models.mechanics.trolley import SpringMassSystem
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = SpringMassSystem().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])
Mocowanie silnika
Przykład drgań wymuszonych przez harmoniczną siłę pochodzącą od ruchu obrotowego niezbalansowanej masy. Zagadnienie przedstawia
faktyczny inżynierski problem występujący przy projektowaniu maszyn z elemenatami obrotowymi.
from dynpy.models.mechanics.engine import EngineVerticalSpringGravity
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = EngineVerticalSpringGravity().get_constant_velocity()
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])
Wahadło
Najprostszy przykład drgań współrzędnej uogólnionej zdefiniowanej przez kąt. Zupełnie podstawowe zagadnienie w zrozummieniu zachowania
ciał podnoszonych za pomocą dźwigów, czy innych elementów podwieszanych za pomocą lin lub kabli.
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. Tłumione układy o jednym stopniu swobody
Napinacz paska zębatego
Przykład pokazujący wpływ tłumienia na odpowiedź układu na wymuszenie harmoniczne zaprezentowane na modelu napinacza z napędu pasowego.
Samo zrozumienie działania urządzenia i wpływu drgań na jego pracę jest kluczowe w projektowaniu napędów, lub przekładni pasowych.
from dynpy.models.mechanics.tensioner import DampedBlowerToothedBelt
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = DampedBlowerToothedBelt().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])
Tłumione mocowanie silnika
Przykład dający możliwość analizy wpływu tłumienia na analizowany wcześniej układ. W rzeczywistości układy z zerowym tłumieniem praktycznie nie istnieją,
więc porównanie zachowania znanego układu w którym tłumienie jest obecne może znacznie pomóc zrozumieć to zjawisko.
from dynpy.models.mechanics.engine import DampedEngineVerticalSpringGravity
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = DampedEngineVerticalSpringGravity().get_constant_velocity()
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])
3. Układy o wielu stopniach swobody
Masowy tłumik drgań
Przykład pokazujący możliwość zmiany częstości własnej drgań poprzez dołożenie dodatkowego stopnia swobody. Rozwiązania typu TMD
często stosowane są w budynkach lub mostach w celu zmniejszenia niebezpieczeństwa wynikającego ze zjawiska rezonansu.
from dynpy.models.mechanics.engine import EngineWithTMD
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = EngineWithTMD().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])
Zawieszenie samochodowe
Analiza układu przemieszczającego się zarówno kątowo jak i liniowo. Model odzwierciedla uproszczoną dynamikę zawieszenia pojazdu. Sposobów na zamodelowanie
tego układu jest wiele tak, jak wiele jest możliwych konstrukcji zawieszenia. W tym przypadku to dwie proste kolumny zamodelowane jako sprężyna.
from dynpy.models.mechanics.vehicle import UndampedSymmetricalVehicleSuspension
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = UndampedSymmetricalVehicleSuspension().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])
4. Układy tłumione o wielu stopniach swobody
Tłumione zawieszenie samochodowe
Znany model zawieszenia pojazdu rozszerzony o wpływ tłumienia wiskotycznego. W porównaniu do rozważanego wcześniej przypadku,
dużo lepiej odzwierciedla pracę faktycznego zawieszenia wyposażonego w amortyzatory.
from dynpy.models.mechanics.vehicle import DampedSymmetricalVehicleSuspension
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = DampedSymmetricalVehicleSuspension().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])
Dynamika konstrukcji mostu
Model odzwierciedlający przybliżoną dynamikę przęseł mostu i ich względnego ruchu w odpowiedzi na wymuszenie harmoniczne. Tego typu budwole
projektowane są w sposób dający elementom pewną swobodę ruchu. Model skonstruowany za pomocą wózków, sprężyn i tłumików, odzwierciedla
dynamikę takiego ruchu.
from dynpy.models.mechanics.trolleys import ForcedDampedTrolleysWithSprings
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()
# Stworzenie instancji klasy
dynsys = ForcedDampedTrolleysWithSprings().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])
5. Układy nieliniowe
Dysk z nielionową spręzyną
Przykład charkteryzujący się sztywnością definiowaną przez nielionową funkcję współrzędnej uogólnionej. Pokazuje zastosowanie szeregu Taylora do linearyzacji funkcji
