Kurs z mechaniki ogólnej dostarcza zestaw materiałów w formie plików PDF oraz kodów w pythonie, obejmujących tematykę każdego działu. 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
Powyższe zadanie stanowi szczegółową analizę jednorodnej, cienkiej płyty o kształcie koła. Prezentuje ono metodykę wyznaczania momentu bezwładności tego obiektu.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate,
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from fractions import Fraction
// Biblioteka symboli
m=Symbol('m',real=True)
dm=Symbol('dm',real=True)
v=Symbol('v',real=True)
r=Symbol('r',real=True)
R=Symbol('R',real=True)
h=Symbol('h',real=True)
z=Symbol('z',real=True)
Ixy=Symbol('Ixy',real=True)
Iz=Symbol('Iz',real=True)
Io=Symbol('Io',real=True)
dv=Symbol('dv',real=True)
a=Symbol('a',real=True)
dz=Symbol('dz',real=True)
Ioxy=Symbol('Ioxy',real=True)
Ioxz=Symbol('Ioxz',real=True)
Ioyz=Symbol('Ioyz',real=True)
Ix=Symbol('Ix',real=True)
Iy=Symbol('Iy',real=True)
da=Symbol('da',real=True)
a=Symbol('a',real=True)
dr=Symbol('dr',real=True)
Całka_wew=Symbol('Calka_wew',real=True)
// Wzory potrzebne do wykonania zadania
display(ReportText('Momenty bezwładnosci względem osi:'))
display(SympyFormula(Eq(Ix, Integral(z**2+y**2, (m,m)))))
display(SympyFormula(Eq(Iy, Integral(x**2+z**2, (m,m)))))
display(SympyFormula(Eq(Iz, Integral(x**2+y**2, (m,m)))))
display(ReportText('Reguła Pappus-Guldinus dla objętości obracanego obiektu:'))
display(SympyFormula(Eq(v, Integral(2*pi*r, (a,a)))))
// Obliczenia
equation_1 = Eq(Iz, Integral(z**2+y**2, (m,m)))
display(SympyFormula(equation_1))
equation_2 = Eq(Iz, rho*Integral(z**2+y**2, (v,v)))
display(SympyFormula(equation_2))
equation_3 = Eq(Iz, rho*Integral(z**2+y**2, (v,v)))
display(SympyFormula(equation_3))
equation_4= Eq(Iz, rho*Integral(r**2,(v,v)))
display(SympyFormula(equation_4))
equation_5= Eq(dv, 2*pi*r*dr)
display(SympyFormula(equation_5))
equation_6= Eq(Iz, rho*Integral(r**2*2*pi*r,(r,0,R)))
display(SympyFormula(equation_6))
n_sol_2= solve(equation_6,Iz)
n_eq_2=Eq(Iz,n_sol_2[0])
display(SympyFormula(n_eq_2))
To zadanie stanowi szczegółową analizę jednorodnego walca, prezentując metodologię obliczania momentu bezwładności tego obiektu.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate,
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from fractions import Fraction
// Biblioteka symboli
m=Symbol('m',real=True)
dm=Symbol('dm',real=True)
v=Symbol('v',real=True)
r=Symbol('r',real=True)
R=Symbol('R',real=True)
h=Symbol('h',real=True)
z=Symbol('z',real=True)
Ixy=Symbol('Ixy',real=True)
Iz=Symbol('Iz',real=True)
Io=Symbol('Io',real=True)
dv=Symbol('dv',real=True)
a=Symbol('a',real=True)
dz=Symbol('dz',real=True)
x=Symbol('x',real=True)
y=Symbol('y',real=True)
dR=Symbol('dR',real=True)
Io=Symbol('Io',real=True)
// Wzory potrzebne do wykonania zadania
equation = Eq(rho, m/v)
equation_1 = Eq(v, pi * R**2 * h)
equation_2 = Eq(rho, m/(pi * r**2 * h))
display(SympyFormula(equation))
display(SympyFormula(equation_1))
display(SympyFormula(equation_2))
equation_3 = Eq(Iz, Integral(x**2+y**2, (m,m)))
display(SympyFormula(equation_3))
display(ReportText('z poprzedniej zależności:'))
equation_4 = Eq(Iz, rho*Integral(x**2+y**2, (v,v)))
display(SympyFormula(equation_4))
// Obliczenia
equation_5 = Eq(Iz, rho*Integral(R**2*2*pi*R*h, (R,0,r)))
display(SympyFormula(equation_5))
n_sol_1= solve(equation_1,Iz)
n_eq_1=Eq(Iz,n_sol_1[0])
display(SympyFormula(n_eq_1))
equation_6 = Eq(Iz,n_eq_1.rhs*m/(pi * r**2 * h*rho))
display(SympyFormula(equation_6))
equation_7 = Eq(Io, Ixy+Iz)
display(SympyFormula(equation_7))
equation_8 = Eq(Ixy, Integral(z**2, (m,m)))
display(SympyFormula(equation_8))
equation_9 = Eq(Ixy, rho*Integral(z**2, (v,v)))
display(SympyFormula(equation_9))
equation_10 = Eq(dv, a*dz)
equation_11 = Eq(a, pi*r**2)
display(SympyFormula(equation_10))
display(SympyFormula(equation_11))
equation_12 = Eq(Ixy, rho*Integral(z**2*pi*r**2, (z,0,h)))
display(SympyFormula(equation_12))
n_sol_2= solve(equation_12,Ixy)
n_eq_2=Eq(Ixy,n_sol_2[0])
display(SympyFormula(n_eq_2))
equation_13 = Eq(Ixy,n_eq_2.rhs*m/(pi * r**2 * h*rho))
display(SympyFormula(equation_13))
equation_14 = Eq(Io, equation_13.rhs + equation_6.rhs)
display(SympyFormula(equation_14))
Przykład ten skutecznie opisuje metodę obliczania momentów bezwładności brył obrotowych poprzez identyfikację istniejących zależności, które pozwalają na usprawnienie procesu obliczeń.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate,
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from fractions import Fraction
// Biblioteka symboli
m=Symbol('m',real=True)
dm=Symbol('dm',real=True)
v=Symbol('v',real=True)
r=Symbol('r',real=True)
R=Symbol('R',real=True)
h=Symbol('h',real=True)
z=Symbol('z',real=True)
Ioxy=Symbol('Ioxy',real=True)
Iz=Symbol('Iz',real=True)
Ic=Symbol('Ic',real=True)
dv=Symbol('dv',real=True)
a=Symbol('a',real=True)
dz=Symbol('dz',real=True)
Ioxy=Symbol('Ioxy',real=True)
Ioxz=Symbol('Ioxz',real=True)
Ioyz=Symbol('Ioyz',real=True)
Ix=Symbol('Ix',real=True)
Iy=Symbol('Iy',real=True)
da=Symbol('da',real=True)
a=Symbol('a',real=True)
Ip=Symbol('Ip',real=True)
Io=Symbol('Io',real=True)
Ic=Symbol('Ic',real=True)
Ixy=Symbol('Ixy',real=True)
// Wzory potrzebne do wykonania zadania
display(ReportText('Momenty bezwładnosci względem płaszczyzn'))
display(SympyFormula(Eq(Ioxy, Integral(z**2, (m,m)))))
display(SympyFormula(Eq(Ioxz, Integral(y**2, (m,m)))))
display(SympyFormula(Eq(Ioyz, Integral(x**2, (m,m)))))
display(ReportText('Momenty bezwładnosci względem osi:'))
display(SympyFormula(Eq(Ix, Integral(z**2+y**2, (m,m)))))
display(SympyFormula(Eq(Iy, Integral(x**2+z**2, (m,m)))))
display(SympyFormula(Eq(Iz, Integral(x**2+y**2, (m,m)))))
display(ReportText('Momenty bezwładnosci względem środka układu:'))
display(SympyFormula(Eq(Io, Integral(x**2+y**2+z**2, (m,m)))))
display(ReportText('Reguła Pappus-Guldinus dla objętości obracanego obiektu:'))
display(SympyFormula(Eq(v, Integral(2*pi*r, (a,a)))))
display(ReportText('Teoria Steinera:'))
display(SympyFormula(Eq(Ip, Ic+m*r**2)))
// Obliczenia
equation = Eq(rho, m/v)
equation_1 = Eq(v, Fraction(1, 3) * pi * r**2 * h)
equation_2 = Eq(rho, m / (Fraction(1, 3) * pi * r**2 * h))
display(SympyFormula(equation))
display(SympyFormula(equation_1))
display(SympyFormula(equation_2))
equation_3 = Eq(Ioxy, Integral(z**2, (m,m)))
display(SympyFormula(equation_3))
equation_4 = Eq(Ioxy, rho*Integral(z**2, (v,v)))
display(SympyFormula(equation_4))
equation_5 = Eq(Iz, Integral(x**2+y**2, (m,m)))
display(SympyFormula(equation_5))
equation_6 = Eq(Ioxy, rho*Integral(x**2+y**2, (v,v)))
display(SympyFormula(equation_6))
equation_7 = Eq(Ixy, Integral(z**2, (m,m)))
display(SympyFormula(equation_7))
equation_8 = Eq(Ixy, rho*Integral(z**2, (v,v)))
display(SympyFormula(equation_8))
equation_9 = Eq(dv, a*dz)
equation_10 = Eq(a, pi*R**2)
display(SympyFormula(equation_9))
display(SympyFormula(equation_10))
equation_11 = Eq(r/h, R/z)
n_sol= solve(equation_11,R)
n_eq=Eq(R,n_sol[0])
display(SympyFormula(equation_11))
display(SympyFormula(n_eq))
equation_12 = Eq(a, pi*((r*z)/h)**2)
equation_13 = Eq(dv, (pi*((r*z)/h)**2)*dz)
display(SympyFormula(equation_12))
display(SympyFormula(equation_13))
equation_14 = Eq(Ixy, rho*Integral(z**2*(pi*((r*z)/h)**2), (z,0,h)))
display(SympyFormula(equation_14))
n_sol_1= solve(equation_14,Ixy)
n_eq_1=Eq(Ixy,n_sol_1[0])
display(SympyFormula(n_eq_1))
equation_15 = Eq(Io, Ixy+Iz)
display(SympyFormula(equation_15))
equation_16 = Eq(Iz, Integral(x**2+y**2, (m,m)))
display(SympyFormula(equation_16))
equation_17 = Eq(Iz, rho*Integral(x**2+y**2, (v,v)))
display(SympyFormula(equation_17))
equation_18 = Eq(Iz, rho*Integral(r**2, (v,v)))
display(SympyFormula(equation_18))
equation_19= Eq(Iz, rho*Integral(Integral(R**2*2*pi*R,(R,0,R)), (h,0,h)))
display(SympyFormula(equation_19))
equation_20 = Eq(Iz, rho * Integral((Integral(R**2*2*pi*R, (R, 0, r*z/h))), (h, 0, h)))
display(SympyFormula(equation_20))
equation_21 = Eq(Całka_wew, rho *(Integral(R**2*2*pi*R, (R, 0, r*z/h))))
display(SympyFormula(equation_21))
n_sol_2= solve(equation_13,Całka_wew)
n_eq_2=Eq(c,n_sol_2[0])
equation_22 = Eq(Iz, rho *(Integral(n_eq_2.rhs, (z, 0, h))))
display(SympyFormula(equation_22))
n_sol_3= solve(equation_22,Iz)
n_eq_3=Eq(Iz,n_sol_3[0])
display(SympyFormula(n_eq_3))
equation_23 = Eq(Io, n_eq_3.rhs + n_eq_1.rhs)
display(SympyFormula(equation_23))
Analiza klasycznego zadania z dziedziny statyki, dotyczącego problemu tarcia między obiektem ograniczonym dwoma płaskimi powierzchniami, przedstawia metodologię rozwiązywania układów statycznych.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate,
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from fractions import Fraction
// Biblioteka symboli
r=Symbol('r',positive=True)
P=Symbol('P',real=True)
a=Symbol('a',positive=True)
b=Symbol('b',positive=True)
h=Symbol('h',positive=True)
l=Symbol('l',positive=True)
mi=Symbol('mu',positive=True)
N1=Symbol('N_1',real=True)
N2=Symbol('N_2',real=True)
T=Symbol('T',real=True)
T1=Symbol('T_1',real=True)
T2=Symbol('T_2',real=True)
Fx=Symbol('F_x',real=True)
Fy=Symbol('F_y',real=True)
Mo=Symbol('M_o',real=True)
N=Symbol('N',real=True)
Ma=Symbol('M_A',real=True)
M=Symbol('M',real=True)
alfa=Symbol('alpha',real=True)
Mh=Symbol('M_h',real=True)
F=Symbol('F')
s=Symbol('Sigma')
FAB=Symbol('F_AB')
Q=Symbol('Q')
// Wzory potrzebne do wykonania zadania
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym:'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Trzecia zasada dynamiki Newtona: Jeżeli ciało A działa na ciało B pewną siłą, to ciało B działa na ciało A siłą równą co do wartości bezwzględnej i o tym samym kierunku, ale o przeciwnym zwrocie:'))
display(SympyFormula(Eq(FAB,-FAB)))
display(ReportText('Przekształcenie siły tarcia z użyciem współczynnika tarcia:'))
Friction=Eq(T, mi*N)
display(SympyFormula(Friction))
// Obliczenia
equation_1 = Eq(Fx, 0)
display(SympyFormula(equation_1))
equation_2 = Eq(0, N1+T2*sin(alfa)-N2*cos(alfa))
display(SympyFormula(equation_2))
equation_3 = Eq(Fy, 0)
display(SympyFormula(equation_3))
equation_4 = Eq(0, -Q+T1+T2*cos(alfa)+N2*sin(alfa))
display(SympyFormula(equation_4))
equation_5 = Eq(Mo, 0)
display(SympyFormula(equation_5))
equation_6 = Eq(0, T1*r-T2*r)
display(SympyFormula(equation_6))
equation_7 = Eq(Fx, 0)
display(SympyFormula(equation_7))
equation_8 = Eq(0, -P+N2*cos(alfa)-T2*sin(alfa))
display(SympyFormula(equation_8))
equation_9 = Eq(Fy, 0)
display(SympyFormula(equation_9))
equation_10 = Eq(0, -T2*cos(alfa)-N2*sin(alfa))
display(SympyFormula(equation_10))
equation_11 = Eq(Ma, 0)
display(SympyFormula(equation_11))
equation_12 = Eq(0, N2*r*cot(alfa)-P*l*cos(alfa))
display(SympyFormula(equation_12))
equation_13 = Eq(0, N2*r*cot(alfa)-P*l*cos(alfa))
display(SympyFormula(equation_1))
n_sol_1= solve(equation_13,P)
n_eq_1=Eq(P,n_sol_1[0])
display(SympyFormula(n_eq_1))
equation_14 = Eq(Fx, 0)
display(SympyFormula(equation_14))
equation_15 = Eq(0, N1+T2*sin(alfa)-N2*cos(alfa))
display(SympyFormula(equation_15))
equation_16 = Eq(Mo, 0)
display(SympyFormula(equation_16))
equation_17 = Eq(0, T1*r-T2*r)
display(SympyFormula(equation_17))
equation_18 = Eq(T1, T2)
display(SympyFormula(equation_18))
equation_19 = Eq(mi*N1, T2)
display(SympyFormula(equation_19))
equation_20 = Eq(0, N1+mi*N1*sin(alfa)-N2*cos(alfa))
display(SympyFormula(equation_20))
n_sol_2= solve(equation_20,N1)
n_eq_2=Eq(N1,n_sol_2[0])
display(SympyFormula(n_eq_2))
equation_21 = Eq(Fy, 0)
display(SympyFormula(equation_21))
equation_22 = Eq(0, -Q+T1+T2*cos(alfa)+N2*sin(alfa))
display(SympyFormula(equation_22))
equation_23 = Eq(0, -Q+mi*n_eq_2.rhs+mi*n_eq_2.rhs*cos(alfa)+N2*sin(alfa))
display(SympyFormula(equation_23))
equation_24 = Eq(0, N2*(mi*cos(alfa)**2/(mi*sin(alfa)+1)+sin(alfa)+mi*cos(alfa)/(mi*sin(alfa)+1))-Q)
display(SympyFormula(equation_24))
ins = (mi*cos(alfa)**2/(mi*sin(alfa)+1)+sin(alfa)+mi*cos(alfa)/(mi*sin(alfa)+1))
equation_25 = Eq(N2, Q/ins)
display(SympyFormula(equation_25))
eq = simplify(equation_25)
display(SympyFormula(eq))
Typowe zadanie dla dzieziny statyki opisujące zjawisko tarcia między dwoma stykającymi się obiektami, prezentuje metodologię rozwiązywania układów statycznych.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate,
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from fractions import Fraction
// Biblioteka symboli
G=Symbol('G',real=True)
Q=Symbol('Q',real=True)
P=Symbol('P',real=True)
N_1=Symbol('N_1',real=True)
N_2=Symbol('N_2',real=True)
N_3=Symbol('N_3',real=True)
Ff_1=Symbol('Ff_1',real=True)
Ff_2=Symbol('Ff_2',real=True)
Ff_3=Symbol('Ff_3',real=True)
F_x=Symbol('Fx',real=True)
F_y=Symbol('Fy',real=True)
Sigma=Symbol('\\Sigma',real=True)
Ans=Symbol('P',real=True)
mu=Symbol('mu',real=True)
sumX = Symbol('\\Sigma F_x',real=True)
sumY = Symbol('\\Sigma F_y',real=True)
// Obliczenia
equation = Eq(sumX, -Ff_1 - N_3 + P)
equation_1 = Eq(sumY, Ff_3 + N_1 - G)
display(SympyFormula(equation))
display(SympyFormula(equation_1))
equation_3 = Eq(sumX, N_3 - N_2*sin(alpha) - Ff_2*cos(alpha))
equation_4 = Eq(sumY, N_2*cos(alpha) - Q - Ff_3 - Ff_2*sin(alpha))
display(SympyFormula(equation_3))
display(SympyFormula(equation_4))
equation_5 = Eq(P, Ff_1 + N_3)
display(SympyFormula(equation_5))
equation_6 = Eq(Ff_1, mu*N_1)
equation_7 = Eq(Ff_2, mu*N_2)
equation_8 = Eq(Ff_3, mu*N_3)
display(SympyFormula(equation_6))
display(SympyFormula(equation_7))
display(SympyFormula(equation_8))
equation_9 = Eq(N_1, G-mu*N_3)
display(SympyFormula(equation_9))
equation_10 = Eq(P, mu*(G-mu*N_3)+N_3)
equation_11 = Eq(P, N_3*(1-mu**2)+G*mu)
display(SympyFormula(equation_10))
display(SympyFormula(equation_11))
equation_12 = Eq(N_3, N_2*sin(alpha)+N_2*mu*sin(alpha))
equation_13 = Eq(N_3, N_2*(sin(alpha)+mu*sin(alpha)))
display(SympyFormula(equation_14))
display(SympyFormula(equation_15))
equation_14 = Eq(0, N_2*cos(alpha)-Q-N_3*mu-N_2*mu*sin(alpha))
equation_15 = Eq(0, N_2*(cos(alpha)-mu*sin(alpha))-Q-N_3*mu)
equation_16 = Eq(0, N_2*(cos(alpha)-mu*sin(alpha))-Q-N_2*mu*(sin(alpha)+mu*cos(alpha)))
equation_17 = Eq(Q, N_2*(cos(alpha)-mu*sin(alpha))-N_2*(mu*sin(alpha)+mu**2*cos(alpha)))
equation_18 = Eq(Q, N_2*(cos(alpha)-2*mu*sin(alpha)-mu**2*cos(alpha)))
equation_19 = Eq(N_2, Q/(cos(alpha)-2*mu*sin(alpha)-mu**2*cos(alpha)))
display(SympyFormula(equation_14))
display(SympyFormula(equation_15))
display(SympyFormula(equation_16))
display(SympyFormula(equation_17))
display(SympyFormula(equation_18))
display(SympyFormula(equation_19))
equation_20 = Eq(N_3, Q/(cos(alpha)-2*mu*sin(alpha)-mu**2*cos(alpha))*(sin(alpha)+mu*sin(alpha)))
display(SympyFormula(equation_20))
equation_21 = Eq(P, Q/(cos(alpha)-2*mu*sin(alpha)-mu**2*cos(alpha))*(sin(alpha)+mu*sin(alpha))*((1-mu**2))+G*mu)
display(SympyFormula(equation_21))
eq_final = StrictGreaterThan(P, Q/(cos(alpha)-2*mu*sin(alpha)-mu**2*cos(alpha))*(sin(alpha)+mu*sin(alpha))*((1-mu**2))+G*mu)
display(SympyFormula(eq_final))
Zadanie koncentrujące się na zjawisku tarcia tocznego między dwoma kołami a powierzchnią, prezentuje metodologię rozwiązywania układów statycznych.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate,
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from fractions import Fraction
// Biblioteka symboli
r=Symbol('r',positive=True)
P=Symbol('P',real=True)
a=Symbol('a',positive=True)
b=Symbol('b',positive=True)
h=Symbol('h',positive=True)
l=Symbol('l',positive=True)
mi=Symbol('mu',positive=True)
N1=Symbol('N_1',real=True)
N2=Symbol('N_2',real=True)
N3=Symbol('N_3',real=True)
N4=Symbol('N_4',real=True)
R1=Symbol('R_1',real=True)
R2=Symbol('R_2',real=True)
T=Symbol('T',real=True)
T1=Symbol('T_1',real=True)
T2=Symbol('T_2',real=True)
Fx=Symbol('F_x',real=True)
Fy=Symbol('F_y',real=True)
Mo=Symbol('M_o',real=True)
Ma=Symbol('M_A',real=True)
f1=Symbol('f_1',real=True)
f2=Symbol('f_2',real=True)
f4=Symbol('f_4',real=True)
N=Symbol('N',real=True)
Ma=Symbol('M_A',real=True)
M=Symbol('M',real=True)
alfa=Symbol('alpha',real=True)
Mh=Symbol('M_h',real=True)
F=Symbol('F')
s=Symbol('Sigma')
FAB=Symbol('F_AB')
Q=Symbol('Q')
// Wzory potrzebne do wykonania zadania
intro=Section('Wzory niezbędne do wykonania zadania:')
CurrentContainer(intro)
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym:'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Trzecia zasada dynamiki Newtona: Jeżeli ciało A działa na ciało B pewną siłą, to ciało B działa na ciało A siłą równą co do wartości bezwzględnej i o tym samym kierunku, ale o przeciwnym zwrocie:'))
display(SympyFormula(Eq(FAB,-FAB)))
display(ReportText('Reguła działania tarcia tocznego: podczas toczenia kontakt między ciałami nie jest punktowy a zachodzi na pewnej powierzchni, w praktyce oznacza to że przesuwamy siłę reakcji o odległość f'))
display(ReportText('Przekształcenie siły tarcia z użyciem współczynnika tarcia:'))
Friction=Eq(T, mi*N)
display(SympyFormula(Friction))
// Obliczenia
equation_1 = Eq(Fx, 0)
display(SympyFormula(equation_1))
equation_2 = Eq(0,-P+R1+R2)
display(SympyFormula(equation_2))
equation_3 = Eq(Fy, 0)
display(SympyFormula(equation_3))
equation_4 = Eq(0, -Q+N3+N4)
display(SympyFormula(equation_4))
equation_5 = Eq(Fx, 0)
display(SympyFormula(equation_5))
equation_6 = Eq(0,R1-T1)
display(SympyFormula(equation_6))
equation_7 = Eq(Fy, 0)
display(SympyFormula(equation_7))
equation_8 = Eq(0, N1-N3)
display(SympyFormula(equation_8))
equation_9 = Eq(Fx, 0)
display(SympyFormula(equation_9))
equation_10 = Eq(0,R2-T2)
display(SympyFormula(equation_10))
equation_11 = Eq(Fy, 0)
display(SympyFormula(equation_11))
equation_12 = Eq(0, N2-N4)
display(SympyFormula(equation_12))
equation_13 = Eq(P,R1+R2)
display(SympyFormula(equation_13))
equation_14 = Eq(T1,R1)
display(SympyFormula(equation_14))
equation_15 = Eq(T2,R2)
display(SympyFormula(equation_15))
equation_16 = Eq(P,T1+T2)
display(SympyFormula(equation_16))
equation_17 = Eq(P,mi*N1+mi*N2)
display(SympyFormula(equation_17))
equation_18 = Eq(Ma, 0)
display(SympyFormula(equation_18))
equation_19 = Eq(0,-N4*(a+b-f4)+Q*a)
display(SympyFormula(equation_19))
equation_20 = Eq(f4,f2)
display(SympyFormula(equation_20))
equation_21 = Eq(0,-N2*(a+b-f2)+Q*a)
display(SympyFormula(equation_21))
n_sol_1= solve(equation_21,N2)
n_eq_1=Eq(N2,n_sol_1[0])
display(SympyFormula(n_eq_1))
equation_22 = Eq(0, -Q+n_eq_1.rhs+N3)
display(SympyFormula(equation_22))
equation_23 = Eq(0, -Q+n_eq_1.rhs+N1)
display(SympyFormula(equation_23))
n_sol_2= solve(equation_23,N1)
n_eq_2=Eq(N1,n_sol_2[0])
display(SympyFormula(n_eq_2))
equation_24 = StrictGreaterThan(P,mi*n_eq_1.rhs+mi*n_eq_2.rhs)
display(SympyFormula(equation_24))
Zadanie z dziedziny statyki, skupiające się na analizie zjawiska tarcia występującego między dwoma ciałami, przedstawia metodologię rozwiązywania układów statycznych.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from sympy import S
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate, TechThriveMechanicalCase
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
// Biblioteka symboli
r=Symbol('r',positive=True)
P=Symbol('P',real=True)
a=Symbol('a',positive=True)
b=Symbol('b',positive=True)
h=Symbol('h',positive=True)
mi=Symbol('mu',positive=True)
S1=Symbol('S_1',real=True)
S2=Symbol('S_2',real=True)
Ma=Symbol('M_A',real=True)
M=Symbol('M',real=True)
alfa=Symbol('alpha',real=True)
Mh=Symbol('M_h',real=True)
F=Symbol('F')
s=Symbol('Sigma')
// Wzory potrzebne do wykonania zadania
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym.'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Wzór niezbędny do rozwiązania zadania z tarciem opasania, jeżeli:'))
belt=StrictGreaterThan(S1,S2)
display(SympyFormula(belt))
display(ReportText('To:'))
display(SympyFormula(Eq(S1,S2*exp(mi*alfa))))
// Dane
unit_dict = {
h: ureg.meter,
P: ureg.newton,
r: ureg.meter,
a: ureg.meter,
b: ureg.meter
}
LatexDataFrame.set_default_units(unit_dict)
dane={r: 0.3, P:20, b:1.2, a:0.1, h: 0.05, mi:0.4, alfa:3*pi/2}
display(ReportText('Obliczyć moment hamowania hamulca taśmowego pokazanego na rysunku, jeżeli:'))
display(
LatexDataFrame.formatted(
data=dane,
index=['Wartość']).applymap(lambda x: f'${latex(x)}$').rename_axis(
'Parametr',
axis=1).reported(caption='Dane przyjęte do zadania'))
// Obliczenia
eq_e=Eq(S1,S2*exp(mi*alfa))
display(SympyFormula(eq_e))
eq_ma_sub=eq_ma.subs(S1,eq_e.rhs)
display(SympyFormula(eq_ma_sub))
s2_sol=solve(eq_ma_sub,S2)
s2=Eq(S2,s2_sol[0])
display(SympyFormula(s2))
s2_sub=s2.subs(dane).subs(pi,3.14).n(3)
display(SympyFormula(s2_sub))
display(SympyFormula(eq_e))
s1=eq_e.subs(dane).subs(S2,s2_sub.rhs).subs(pi,3.14).n(3)
display(SympyFormula(s1))
eq_mh=Eq(Mh,(S1-S2)*r)
eq_mh_sub=eq_mh.subs(dane_s).subs(r,0.3)
display(SympyFormula(eq_mh))
display(SympyFormula(eq_mh_sub))
Zadanie prezentuje schemat zachowania jednego z podstawowych systemów mechanicznych. Przeprowadzona analiza pozwala na zrozumienie zachowania tego obiektu oraz wyznaczenie kluczowych parametrów, takich jak przyśpieszenie i prędkość.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from sympy import S
from dynpy.models.mechanics.engine import *
from dynpy.models.mechanics.projectile import *
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate, TechThriveMechanicalCase
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
// Biblioteka symboli
l=Symbol('l',positive=True)
xa = dynamicsymbols('x_A')
ya = dynamicsymbols('y_A')
xb = dynamicsymbols('x_B')
yb = dynamicsymbols('y_B')
xm = dynamicsymbols('x_M')
ym = dynamicsymbols('y_M')
x=dynamicsymbols('x')
y=dynamicsymbols('y')
vb=Symbol('v_b',real=True)
va=Symbol('v_a',real=True)
vax=Symbol('v_ax',real=True)
vay=Symbol('v_ay',real=True)
vm=Symbol('v_m',real=True)
amt=Symbol('a_mt',real=True)
amn=Symbol('a_mn',real=True)
am=Symbol('a_m',real=True)
omg=Symbol('omega',positive=True)
omg2=Symbol('omega_2',positive=True)
t=Symbol('t')
s=Symbol('Sigma')
m=Symbol('m')
F=Symbol('F')
Fa=Symbol('F_A')
Fr=Symbol('F_R')
alfa=Symbol('alpha')
// Wzory potrzebne do wykonania zadania
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym.'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Druga zasada dynamiki Newtona: Jeżeli na ciało działa stała siła wypadkowa, to ciało porusza się ruchem jednostajnie przyspieszonym z przyspieszeniem wprost proporcjonalnym do działającej siły, a odwrotnie proporcjonalnym do masy ciała.'))
display(SympyFormula(Eq(m*x.diff(t,2),s*F)))
display(SympyFormula(Eq(m*y.diff(t,2),s*F)))
display(ReportText('Trzecia zasada dynamiki Newtona: Oddziaływanie dwóch ciał jest zawsze wzajemne. Jeżeli jedno ciało działa na drugie pewną siłą, to drugie działa na ciało pierwsze siłą taką samą co do wartości i kierunku, a o zwrocie przeciwnym.'))
display(SympyFormula(Eq(Fa,-Fr)))
display(Markdown('''Kroki postępowania:
- Ułożenie równań ruchu punktu $A$
- Ułożenie równań ruchu punktu $B$
- Wyznaczenie prędkosci i przyspieszenia punktu $M$
'''))
// Obliczenia
xa_eq=Eq(xa,l*cos(omg*t))
ya_eq=Eq(ya,l*sin(omg*t))
display(ReportText(f'Równanie ruchu punktu $A$ względem osi $x$ ({AutoMarker(xa_eq)}) '))
display(SympyFormula(xa_eq))
display(ReportText(f'Równanie ruchu punktu $A$ względem osi $y$ ({AutoMarker(ya_eq)}) '))
display(SympyFormula(ya_eq))
v_ax=Eq(vax,xa_eq.rhs.diff(t))
display(ReportText(f'Prędkosć punktu $A$ względem osi $x$ ({AutoMarker(v_ax)}) '))
display(SympyFormula(v_ax))
v_ay=Eq(vay,ya_eq.rhs.diff(t))
v_ax=Eq(vax,xa_eq.rhs.diff(t))
display(ReportText(f'Prędkosć punktu $A$ względem osi $y$ ({AutoMarker(v_ay)}) '))
display(SympyFormula(v_ay))
v_a=Eq(va,sqrt(v_ay.rhs**2 + v_ax.rhs**2).simplify())
display(ReportText(f'Wypadkowa prędkosć punktu $A$: ({AutoMarker(v_a)}) '))
display(SympyFormula(v_a))
xb_eq=Eq(xb,l*cos(omg*t)+xa_eq.rhs)
yb_eq=Eq(yb,0)
display(ReportText(f'Równanie ruchu punktu $B$ względem osi $x$ ({AutoMarker(xb_eq)}) '))
display(SympyFormula(xb_eq))
display(ReportText(f'Równanie ruchu punktu $B$ względem osi $y$ ({AutoMarker(yb_eq)}) '))
display(SympyFormula(yb_eq))
v_b=Eq(vb,xb_eq.rhs.diff(t))
display(ReportText(f'Wypadkowa prędkosć punktu $B$: ({AutoMarker(v_b)}) '))
display(SympyFormula(v_b))
omg2_eq=Eq(v_b.rhs, v_a.rhs + omg2*l)
display(ReportText(f'Z zależnosci między prędkosciami punktów możemy stwierdzić że: ({AutoMarker(omg2_eq)}) '))
display(SympyFormula(omg2_eq))
omg2_sol=solve(omg2_eq,omg2)
omg_2=Eq(omg2,omg2_sol[0])
display(ReportText(f'A następnie wyliczyć: ({AutoMarker(omg_2)}) '))
display(SympyFormula(omg_2))
vm_eq=Eq(vm,v_b.rhs+omg_2.rhs*l/2)
display(ReportText(f'Po wyliczeniu tej wartosci bez problemu możemy wyliczyć prędkosć punktu $M$: ({AutoMarker(vm_eq)}) '))
display(SympyFormula(vm_eq))
amt_eq=Eq(amt,vm_eq.rhs.diff(t))
display(ReportText(f'Aby policzyć przyspieszenie naszego punktu, policzymy przyspieszenie styczne oraz normalne a następnie dzięki nim obliczymy przyspieszenie wypadkowe: ({AutoMarker(amt_eq)}) '))
display(SympyFormula(amt_eq))
amn_eq=Eq(amn,vm_eq.rhs**2/(l/2))
display(SympyFormula(amn_eq))
am_eq=Eq(am,sqrt(amt_eq.rhs**2 + amn_eq.rhs**2))
display(ReportText(f'Nasze ostateczne przyspieszenie wynosi: ({AutoMarker(am_eq)}) '))
display(SympyFormula(am_eq))
To zadanie obejmuje zagadnienia z dziedziny dynamiki. Dzięki dogłębnej analizie, pomaga zrozumieć, w jaki sposób zachowuje się dany mechanizm oraz jak można wykorzystać jego właściwości.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from sympy import S
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate, TechThriveMechanicalCase
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
from dynpy.models.mechanics.disk import*
// Biblioteka symboli
l1=Symbol('l_1',positive=True)
l2=Symbol('l_2',positive=True)
l3=Symbol('l_3',positive=True)
r=Symbol('r',positive=True)
x1=dynamicsymbols('x_1')
x2=dynamicsymbols('x_2')
S1=Symbol('S_1',real=True)
S2=Symbol('S_2',real=True)
S3=Symbol('S_3',real=True)
S4=Symbol('S_4',real=True)
S5=Symbol('S_5',real=True)
t=Symbol('t')
x=dynamicsymbols('x')
y=dynamicsymbols('y')
G=Symbol('G',real=True)
Q=Symbol('Q',real=True)
S=Symbol('S',real=True)
s=Symbol('Sigma')
m=Symbol('m')
F=Symbol('F')
Fa=Symbol('F_A')
Fr=Symbol('F_R')
// Wzory potrzebne do wykonania zadania
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym.'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Druga zasada dynamiki Newtona: Jeżeli na ciało działa stała siła wypadkowa, to ciało porusza się ruchem jednostajnie przyspieszonym z przyspieszeniem wprost proporcjonalnym do działającej siły, a odwrotnie proporcjonalnym do masy ciała.'))
display(SympyFormula(Eq(m*x.diff(t,2),s*F)))
display(SympyFormula(Eq(m*y.diff(t,2),s*F)))
display(ReportText('Trzecia zasada dynamiki Newtona: Oddziaływanie dwóch ciał jest zawsze wzajemne. Jeżeli jedno ciało działa na drugie pewną siłą, to drugie działa na ciało pierwsze siłą taką samą co do wartości i kierunku, a o zwrocie przeciwnym.'))
display(SympyFormula(Eq(Fa,-Fr)))
display(Markdown('''Do prawidłowego wykonania zadania należy przyjąć następujące kroki:
- Zauważyć zależnosci wynikające z długosci nieroziągliwej nici
- Stworzyć wykres rozkładu sił
- Ułożyć równania ruchu oraz równania momentów sił
- Obliczenie prędkosci obu ciał jako funkcje czasu
- Obliczenie siłę napięcia nici
'''))
// Obliczenia
display(ReportText('Pierwszym krokiem jest przeanalizowanie jak działa mechanizm podany w zadaniu:'))
Picture._default_width = NoEscape('0.6\\columnwidth')
obraze = Picture('./images/Blety_13.png')
display(obraze)
nic_1=l1+l2+l3+(2*pi*r)
display(ReportText('Z powyższego obrazka widzimy, że łączna długosc nici przed wprawieniem mechanizmu w ruch (fragmenty opasające koło oraz fragmenty oznaczone symbolem $l$) to:'))
Picture._default_width = NoEscape('0.6\\columnwidth')
obraz = Picture('./images/Blety_14.png')
display(obraz)
display(ReportText('Natomiast po rozpoczęciu ruchu:'))
nic_2=l1+l2+l3+2*x1+x2+2*pi*r
display(ReportText('Równanie długosci nici mozna zapisac nastepujaco:'))
display(SympyFormula(nic_2))
display(ReportText('Z tresci zadania wiemy, że dlugosc nici sie nie zmienia, stąd:'))
nic_eq=Eq(nic_1,nic_2)
display(SympyFormula(nic_eq))
display(ReportText('Następnie upraszczając:'))
x2_sol=solve(nic_eq,x2)
x2_eq=Eq(x2,x2_sol[0])
display(SympyFormula(x2_eq))
display(ReportText('Stąd wiemy, że:'))
x_diff=Eq(x2.diff(t,2),-2*x1.diff(t,2))
display(SympyFormula(x_diff))
c1_eq=Eq(Q-S1,Q/g*x1.diff(t,2))
c2_eq=Eq(G-S4,G/g*x2.diff(t,2))
rr1_eq=Eq(S1,S2+S3)
rr2_eq=Eq(S5,S2+S3)
m1_eq=Eq(0,S2*r-S3*r)
m2_eq=Eq(0,S4*r-S3*r)
display(ReportText('Równania ruchu wyprowadzone z drugiego prawa dynamiki Newtona. \n Dla pierwszego ciężarka :'))
display(SympyFormula(c1_eq))
display(ReportText('Dla drugiego ciężarka :'))
display(SympyFormula(c2_eq))
display(ReportText('Dodatkowo:'))
display(SympyFormula(rr1_eq))
display(SympyFormula(rr2_eq))
display(ReportText('Równanie dla momentów sił (suma momentów sił jest równa $0$, gdyż nie występuje poslizg). Względem srodka pierwszego bloczka :'))
display(SympyFormula(m1_eq))
display(ReportText('Względem srodka drugiego bloczka :'))
display(SympyFormula(m2_eq))
display(ReportText('Z tego wynika, że :'))
s2_sol=solve(m1_eq,S2)
s2_eq=Eq(S2,s2_sol[0])
display(SympyFormula(s2_eq))
s3_sol=solve(m2_eq,S3)
s3_eq=Eq(S3,s3_sol[0])
display(SympyFormula(s3_eq))
display(ReportText(f'Aby uproscic obliczenia przyjmiemy te równe sobie wartosci jako $S$. Należy jedynie policzyć ${latex(S1)}$ :'))
display(SympyFormula(rr1_eq))
s1_eq=rr1_eq.subs(S2,S).subs(S3,S)
display(SympyFormula(s1_eq))
display(ReportText('Do policzenia prędkosci po obydwu osiach potrzebne nam są te 3 równania z podstawionymi odpowiendimi wartosciami $S$ :'))
display(SympyFormula(x_diff))
rrq=c1_eq.subs(S1,s1_eq.rhs)
rrg=c2_eq.subs(S4,S)
display(SympyFormula(rrq))
display(SympyFormula(rrg))
display(ReportText('Za pomocą pierwszego równania podstawić do równania trzeciego :'))
rrg_sub=rrg.subs(x2.diff(t,2),x_diff.rhs)
display(SympyFormula(rrg_sub))
display(ReportText('Następnie dla uproszczenia rachunków należy pomnożyć obie strony równania przez $-2$ :'))
rrg_eq=Eq(rrg_sub.lhs*(-2),rrg_sub.rhs*-2)
display(SympyFormula(rrg_eq))
display(ReportText('Dodając równania stronami :'))
r_eq=Eq(rrq.lhs+rrg_eq.lhs,rrq.rhs+rrg_eq.rhs)
display(SympyFormula(r_eq))
r_eq_sol=solve(r_eq,x1.diff(t,2))
x1_eq=Eq(x1.diff(t,2),r_eq_sol[0])
display(SympyFormula(x1_eq))
x1_sol=Eq(x1.diff(t),x1_eq.rhs*t)
display(ReportText('Z racji, że prawa strona równania to stała, aby scałkować wystarczy prawą stronę pomnożyć przez $t$ :'))
display(SympyFormula(x1_sol))
display(ReportText('Wiemy też, że :'))
display(SympyFormula(x_diff))
display(ReportText('Co odnosi się także do pierwszej pochodnej i z tego wyliczymy :'))
x2_sol=Eq(x2.diff(t),x1_sol.rhs*-2)
display(SympyFormula(x2_sol))
odesys=ODESystem(odes=Matrix([x1_eq.lhs-x1_eq.rhs]), dvars=Matrix([x1]), ode_order=2)
display(odesys)
display(ReportText('Do policzenia siły napięcia potrzebne nam są te 2 równania :'))
display(ReportText('Do policzenia siły napięcia potrzebne nam są te 2 równania :'))
display(SympyFormula(x1_eq))
display(SympyFormula(rrq))
display(ReportText('Należy podstawić pierwsze równanie do drugiego :'))
s_eq=rrq.subs(x1.diff(t,2),x1_eq.rhs)
display(SympyFormula(s_eq))
display(ReportText('Teraz jedynie wyliczyć z tego $S$ :'))
s_sol=solve(s_eq,S)
s_val=Eq(S,s_sol[0])
display(SympyFormula(s_val))
Klasyczne zadanie z działu dynamiki, rozwiązanie opisuje siłę potrzebną do wepchnięcia obiektu na górę równi pochyłej
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from sympy import S
from dynpy.models.mechanics.engine import *
from dynpy.models.mechanics.projectile import *
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
// Biblioteka symboli
g=Symbol('g',positive=True)
v0=Symbol('v_0',real=True)
h=Symbol('h',real=True)
tw=Symbol('t')
m=Symbol('m',real=True)
mi=Symbol('mu',real=True)
F=Symbol('F',real=True)
alfa=Symbol('alpha',real=True)
N=Symbol('N',real=True)
x = dynamicsymbols('x')
y = dynamicsymbols('y')
vp=Symbol('v_p',real=True)
tp=Symbol('t_p',real=True)
s=Symbol('Sigma')
Fa=Symbol('F_A')
Fr=Symbol('F_R')
// Wzory potrzebne do wykonania zadania
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym.'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Druga zasada dynamiki Newtona: Jeżeli na ciało działa stała siła wypadkowa, to ciało porusza się ruchem jednostajnie przyspieszonym z przyspieszeniem wprost proporcjonalnym do działającej siły, a odwrotnie proporcjonalnym do masy ciała.'))
display(SympyFormula(Eq(m*x.diff(t,2),s*F)))
display(SympyFormula(Eq(m*y.diff(t,2),s*F)))
display(ReportText('Trzecia zasada dynamiki Newtona: Oddziaływanie dwóch ciał jest zawsze wzajemne. Jeżeli jedno ciało działa na drugie pewną siłą, to drugie działa na ciało pierwsze siłą taką samą co do wartości i kierunku, a o zwrocie przeciwnym.'))
display(SympyFormula(Eq(Fa,-Fr)))
// Obliczenia
display(ReportText('Najpierw układamy równania ruchu dla wspołrzędnych $x$ i $y$'))
rr1=Eq(m*(x.diff(t,2)),F-mi*N-m*g*sin(alfa))
rr2=Eq(m*y.diff(t,2),N-m*g*cos(alfa))
display(SympyFormula(rr1))
display(SympyFormula(rr2))
display(ReportText('Czas lotu może być wyznaczony ze swobodnego spadku ze względu na pominiecie oporów ruchu.'))
h_eq=Eq(h,(g*t**2/2))
t_sol=solve(h_eq,tw)
t_eq=Eq(t,t_sol[1])
display(SympyFormula(t_eq))
beq=Eq(b,v0*t_eq.rhs)
beq
v0_sol=Eq(v0,solve(beq,v0)[0])
display(SympyFormula(v0_sol))
yeq=Eq(h,rr2.rhs/m*tp)
yeq
tp_solution=solve(yeq.subs(N,m*g*sin(alfa)),tp)[0]
display(SympyFormula(tp_solution))
v0eq=Eq(v0,vp-mi*m*g*tw)
v0eq
vp_sol=Eq(vp,solve(v0eq,vp)[0])
vp_sol_sub=vp_sol.subs(v0,v0_sol.rhs).subs(tw,tp_solution)
display(SympyFormula(vp_sol_sub))
display(ReportText('Rozwiązanie końcowe przedstawione w postaci siły.'))
vpeq=Eq(vp,(rr1.rhs)/m*tp_solution)
display(vpeq)
f_sol=solve(vpeq,F)[0]
f_eq=Eq(F,f_sol.subs(N,m*g*cos(alfa)).subs(tw,tp_solution))
f_eq_sub=f_eq.subs(vp,vp_sol_sub.rhs).expand().simplify()
display(SympyFormula(f_eq_sub))
Zadanie przedstawia związek między ruchem obrotowym wirnika pralki a ruchem liniowym obudowy. Analiza ma na celu wyznaczenie równiania przemieszczenia obudowy.
// Importy
from sympy import*
from sympy.physics.mechanics import dynamicsymbols, init_vprinting
from sympy.abc import*
init_vprinting()
from sympy import S
from dynpy.models.mechanics.engine import *
from dynpy.models.mechanics.projectile import *
from dynpy.solvers.linear import ODESystem
import pandas as pd
from pylatex import Document, Section, Subsection, Itemize, Package, HorizontalSpace, Description, Marker, Command
from pylatex.section import Paragraph, Chapter
from pylatex.utils import italic, NoEscape
from dynpy.utilities.adaptable import *
from dynpy.utilities.templates.document import BeamerTemplate, TechThriveMechanicalCase
from dynpy.utilities.templates.tikz import TikzCaSCStandalone
from dynpy.utilities.report import ReportText, Markdown, Picture, SympyFormula, Frame, ObjectCode, Block, AlertBlock, ExampleBlock
from dynpy.utilities.report import (SystemDynamicsAnalyzer, DataPlot, AccelerationComparison, FFTComparison, ReportEntry, SimulationalBlock, ReportText, SimulationFFT, DataStorage, Markdown, SummaryTable, SympyFormula, SymbolsDescription, DescriptionsRegistry, ObjectCode,CurrentContainer)
// Biblioteka symboli
m1=Symbol('m_1',positive=True)
m2=Symbol('m_2',positive=True)
e=Symbol('e',positive=True)
g=Symbol('g',positive=True)
omg=Symbol('omega',positive=True)
t=Symbol('t')
x=dynamicsymbols('x')
y=dynamicsymbols('y')
Fc=Symbol('F_c',positive=True)
R=Symbol('R',positive=True)
k=Symbol('k',positive=True)
Fs=Symbol('F_s',positive=True)
s=Symbol('Sigma')
m=Symbol('m')
F=Symbol('F')
Fa=Symbol('F_A')
Fr=Symbol('F_R')
// Wzory potrzebne do wykonania zadania
display(ReportText('Pierwsza zasada dynamiki Newtona: Jeżeli na dane ciało nie działają żadne inne ciała, lub działania innych ciał równoważą się, to ciało pozostaje w spoczynku lub porusza się ruchem jednostajnym prostoliniowym.'))
display(SympyFormula(Eq(s*F,0)))
display(ReportText('Druga zasada dynamiki Newtona: Jeżeli na ciało działa stała siła wypadkowa, to ciało porusza się ruchem jednostajnie przyspieszonym z przyspieszeniem wprost proporcjonalnym do działającej siły, a odwrotnie proporcjonalnym do masy ciała.'))
display(SympyFormula(Eq(m*x.diff(t,2),s*F)))
display(SympyFormula(Eq(m*y.diff(t,2),s*F)))
display(ReportText('Trzecia zasada dynamiki Newtona: Oddziaływanie dwóch ciał jest zawsze wzajemne. Jeżeli jedno ciało działa na drugie pewną siłą, to drugie działa na ciało pierwsze siłą taką samą co do wartości i kierunku, a o zwrocie przeciwnym.'))
display(SympyFormula(Eq(Fa,-Fr)))
display(Markdown('''Do prawidłowego wykonania zadania należy przyjąć następujące kroki:
- Rozrysowanie rozkładu sił działających na system
- Korzystając z drugiego prawa dynamiki Newtona napisać równania ruchu systemu po osi $x$ i $y$
- Obliczyć siłę reakcji od podłoża
- Obliczenie prędkosci kątowej dla jakiej pralka oderwie się od ziemi
- Policzyć poziomy ruch obudowy pralki
'''))
// Obliczenia
eq_x=Eq(m1*x.diff(t,2),Fc*cos(omg*t)-(k*x)-m2*x.diff(t,2)).subs(Fc, m1*e*omg**2)
display(ReportText('Równania ruchu wyprowadzone z drugiego prawa dynamiki Newtona. \n Względem osi x:'))
display(SympyFormula(eq_x))
eq_y=Eq(m1*y.diff(t,2), R-g*(m1+m2)+Fc*sin(omg*t)).subs(Fc, m2*e*omg**2)
display(ReportText('Równanie ruchu względem osi y '))
display(SympyFormula(eq_y))
eq_r=eq_y.subs(y.diff(t,2),0).subs(sin(omg*t),1)
eq_r_sol=solve(eq_r,R)
eq_r_sol[0]
graph_dict={omg: sqrt((m2/e)), g:10, e:2, m1:40, m2: 25}
eq_r_sin=eq_y.subs(y.diff(t,2),0)
eq_r_sol_sin=solve(eq_r_sin,R)
display(ReportText('W zadaniu proszą nas o policzenie 3 wartosci, w tym celu podzielimy tę sekcję na 3 podsekcje, a aby stworzyć wykresy, przyjmiemy sobie następujące wartosci dla znanych nam zmiennych/stałych'))
display(
LatexDataFrame.formatted(
data=graph_dict,
index=['Wartość']).applymap(lambda x: f'${latex(x)}$').rename_axis(
'Parametr',
axis=1).reported(caption='Dane przyjęte do stworzenia wykresów'))
display(ReportText('Przyspieszenie po osi y jest równe 0, stąd możemy wyliczyć siłę reakcji od podłoża:'))
display(SympyFormula(Eq(R,eq_r_sol_sin[0])))
r_eq=Eq(R,eq_r_sol[0])
display(ReportText(f'W celu dalszych obliczeń, czyli obliczenia prędkosci kątowej potrzebnej do oderwania się pralki od ziemi, należy przyjąc najwyższe połozenie punktu ${latex(m2)}$, czyli wartosć kąta ${latex(pi/2)}$, a co za tym idzie, przyjąc wartosć sinusa jako $1$.({AutoMarker(r_eq)})'))
display(SympyFormula(r_eq))
r_eq_num=eq_r_sol_sin[0].subs(graph_dict).subs(graph_dict)
display(ReportText(f'Podstawiając przyjęte wczesniej dane otrzymujemy:({AutoMarker(Eq(R,r_eq_num))})'))
display(SympyFormula(Eq(R,r_eq_num)))
display(ReportText('Mając takie równanie możemy stworzyć wykres siły reakcji w zależnosci od czasu:'))
t_list=np.linspace(0.0001,10,200)
r_list=[float(r_eq_num.subs(t,t_sub).n(5)) for t_sub in t_list]
tab_sol=TimeDataFrame(data={t:t_list,R:r_list,})
tab_sol_new= TimeDataFrame(tab_sol.set_index(t))
table=tab_sol_new.to_latex_dataframe()
graph1 = table.to_pylatex_tikz().in_figure()
display(graph1)
eq_r_sol_sin[0]
omg_sol=solve(r_eq,omg)
omg_eq=Eq(omg,omg_sol[0])
omg_eq1=omg_eq.subs(R,0)
display(ReportText(f'W tej częsci zadania kluczowe jest, aby korzystając z trzeciego prawa dynamiki Newtona zauważyć, że warunkiem na oderwanie się pralki od podłoża jest siła reakcji równa 0. Na tej podstawie możemy bez problemu wyliczyć prędkosc kątową potrzebną do spełnienia tego warunku:({AutoMarker(omg_eq1)})'))
display(SympyFormula(omg_eq1))
display(ReportText('Następnie podstawiając znane nam dane, możemy stworzyć wykres, z którego możemy odczytać, że nasza pralka odrywa się od podłoża, a następnie znowu opada i tak w kółko'))
r1_list=[float(eq_r_sol_sin[0].subs(omg, omg_eq1.rhs).subs(graph_dict).subs(t,t_sub).n(5)) for t_sub in t_list]
tabsol=TimeDataFrame(data={t:t_list,R:r1_list,})
tabsol_new= TimeDataFrame(tabsol.set_index(t))
table=tabsol_new.to_latex_dataframe()
graph2 = table.to_pylatex_tikz().in_figure()
display(graph2)
display(ReportText(f'Aby wykonać takie obliczenie wystarczy rozwiązać rownanie ruchu względem osi $x$: ({AutoMarker(eq_x)})'))
display(SympyFormula(eq_x))
odesys=ODESystem(odes=Matrix([eq_x.lhs-eq_x.rhs]), dvars=Matrix([x]), ode_order=2)
display(ReportText('Równanie jednorodne:'))
display(SympyFormula(Eq(Symbol('x_g'),odesys.general_solution[0])))
display(ReportText('Równanie szczególne:'))
display(SympyFormula(Eq(Symbol('x_s'),odesys.steady_solution[0])))
display(ReportText('Ostateczne równanie ruchu po osi $x$:'))
display(SympyFormula(Eq(x,odesys.solution.with_ics([0.0,0.0])[0],evaluate=False)))