Drgania mechaniczne

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ń.

PDF

 
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.

PDF

 
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.

PDF

 
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.

PDF

 
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.

PDF

 
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.

PDF

 
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.

PDF

 
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.

PDF

 
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.

PDF

 
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

PDF

 
from dynpy.models.mechanics.disk import DiskWithNonlinearSpring
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()


# Stworzenie instancji klasy
dynsys = DiskWithNonlinearSpring()

# 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])

Odwrócone whadło

Przykład szeroko stosowanego zagadnienia w teorii regulacji. Odwrócone wahadło jest często wykorzystywanym benchmarkiemm dla systemów automatyki.

PDF

 
from dynpy.models.mechanics.pendulum import KinematicallyExcitedInvertedPendulum
from sympy import *
from sympy.physics.mechanics import init_vprinting
init_vprinting()


# Stworzenie instancji klasy
dynsys = KinematicallyExcitedInvertedPendulum().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])