```python
import sympy as sp
import numpy as np

sp.init_printing()
```


```python
xi, L, A, E = sp.symbols("xi L A E")
Nue = sp.Matrix([(1-xi)/2, (1+xi)/2])
Nue
```


```python
Bue=sp.diff(Nue,xi)*2/L
Bue
```


```python
KeTRUSS1D = sp.lambdify((A,E,L),A*E*sp.integrate(Bue*(Bue.T),(xi,-1,1))*L/2)
print(KeTRUSS1D(A,E,L))
```

    [[A*E/L -A*E/L]
     [-A*E/L A*E/L]]




Adatok megadása


```python
A1=50
A2=20

E1=100e3
E2=200e3


L=2e3

FT=60e3
```

Elem-csomópont összerendelések tárolása az `en` mátrixban


```python
en=np.array([
    [1,3],
    [2,3],
    [3,4],
    [3,5]]) - 1
```

Elemi merevségi mátrixok


```python
Ke1 = KeTRUSS1D(A1,E1,L)
Ke2 = KeTRUSS1D(A1,E1,L)
Ke3 = KeTRUSS1D(A1,E1,L)
Ke4 = KeTRUSS1D(A2,E2,2*L)
```

Globális merevségi mátrix megadása során első lépésben egy zérus elemekkel
kitöltött mátrixot hozunk létre, majd a megfelelő helyekre betesszül az
egyes elemem merevségi mátrixainak elemeit.


```python
KG=np.zeros((5,5))
KG
```




    array([[ 0.,  0.,  0.,  0.,  0.],
           [ 0.,  0.,  0.,  0.,  0.],
           [ 0.,  0.,  0.,  0.,  0.],
           [ 0.,  0.,  0.,  0.,  0.],
           [ 0.,  0.,  0.,  0.,  0.]])



Egy lehetséges leprogramozása ennek az alábbiakban látható,
ahol felhasználjuk az elem-csomópont összerendlés mátrixot:

[np.ix_](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ix_.html)

Az 1-es elem merevségi mátrixának elhelyezése
a globális merevségi mátrixban:


```python
elemSzam=1
KG[np.ix_(en[elemSzam-1],en[elemSzam-1])] += Ke1
KG
```




    array([[ 2500.,     0., -2500.,     0.,     0.],
           [    0.,     0.,     0.,     0.,     0.],
           [-2500.,     0.,  2500.,     0.,     0.],
           [    0.,     0.,     0.,     0.,     0.],
           [    0.,     0.,     0.,     0.,     0.]])



Az 2-es elem merevségi mátrixának elhelyezése
a globális merevségi mátrixban:


```python
elemSzam=2
KG[np.ix_(en[elemSzam-1],en[elemSzam-1])] += Ke2
KG
```




    array([[ 2500.,     0., -2500.,     0.,     0.],
           [    0.,  2500., -2500.,     0.,     0.],
           [-2500., -2500.,  5000.,     0.,     0.],
           [    0.,     0.,     0.,     0.,     0.],
           [    0.,     0.,     0.,     0.,     0.]])



Az 3-es elem merevségi mátrixának elhelyezése
a globális merevségi mátrixban:


```python
elemSzam=3
KG[np.ix_(en[elemSzam-1],en[elemSzam-1])] += Ke3
KG
```




    array([[ 2500.,     0., -2500.,     0.,     0.],
           [    0.,  2500., -2500.,     0.,     0.],
           [-2500., -2500.,  7500., -2500.,     0.],
           [    0.,     0., -2500.,  2500.,     0.],
           [    0.,     0.,     0.,     0.,     0.]])



Az 4-es elem merevségi mátrixának elhelyezése
a globális merevségi mátrixban:


```python
elemSzam=4
KG[np.ix_(en[elemSzam-1],en[elemSzam-1])] += Ke4
KG
```




    array([[ 2500.,     0., -2500.,     0.,     0.],
           [    0.,  2500., -2500.,     0.,     0.],
           [-2500., -2500.,  8500., -2500., -1000.],
           [    0.,     0., -2500.,  2500.,     0.],
           [    0.,     0., -1000.,     0.,  1000.]])



Tehát a globális merevségi mátrix:


```python
KG
```




    array([[ 2500.,     0., -2500.,     0.,     0.],
           [    0.,  2500., -2500.,     0.,     0.],
           [-2500., -2500.,  8500., -2500., -1000.],
           [    0.,     0., -2500.,  2500.,     0.],
           [    0.,     0., -1000.,     0.,  1000.]])



A globális tehervektor:


```python
FG = np.zeros(5)
FG[2 - 1] += FT
```

A kondenzált merevségi mátrixot és a kondenzált tehervektort megkapjuk a kényszerekkel ellátott szabadságfokokhoz tartozó sorok és oszlopok törlésével:

(megtartjuk a maradék részt)


```python
szabad = [1,2]
```

A kondenzált merevségi mátrixot megkapjuk az **első** és **második** sorok/oszlopok megtartásával:


```python
print(np.ix_(szabad,szabad))
```

    (array([[1],
           [2]]), array([[1, 2]]))



```python
KGkond = KG[np.ix_(szabad,szabad)]
KGkond
```




    array([[ 2500., -2500.],
           [-2500.,  8500.]])



A kondezált tehervektort megkapjuk az **első** és **második** sor megtartásával:


```python
FGkond = FG[np.ix_(szabad)]
FGkond
```




    array([ 60000.,      0.])




```python
# a teljes lineáris egyenletrendszer alulhatározott (~0-val osztás)
np.linalg.solve(KG,FG)
```




    array([ -3.10899383e+17,  -3.10899383e+17,  -3.10899383e+17,
            -3.10899383e+17,  -3.10899383e+17])



Megoldás az ismeretlen elmozdulásokra


```python
Umego = np.linalg.solve(KGkond,FGkond)
Umego
```




    array([ 34.,  10.])



Tehát a teljes globális csomóponti elmozdulásvektor:


```python
UG = np.zeros(5)
UG[np.ix_(szabad)] += Umego
UG
```




    array([  0.,  34.,  10.,   0.,   0.])



Eredmények megjelenítése

[matplotlib.patches](https://matplotlib.org/api/patches_api.html)


```python
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
```


```python
nagy = 50
R = 300

plt.figure()
ax = plt.gca()
ax.set_xticklabels([])
ax.set_yticklabels([])
## eredeti konfiguráció
# rudak
ax.add_patch(mpatches.Rectangle((-L-R/2,-L),R,L,
                                fc = (1,1,1,1),ec = (0.5,0.5,0.5,1), ls = "--", lw = 2))
ax.add_patch(mpatches.Rectangle((-L-R/2,-2*L),R,L,
                                fc = (1,1,1,1),ec = (0.5,0.5,0.5,1), ls = "--", lw = 2))
ax.add_patch(mpatches.Rectangle((L-R/2,-L),R,L,
                                fc = (1,1,1,1),ec = (0.5,0.5,0.5,1), ls = "--", lw = 2))
ax.add_patch(mpatches.Rectangle((L-R/2,-3*L),R,2*L,
                                fc = (1,1,1,1),ec = (0.5,0.5,0.5,1), ls = "--", lw = 2))
# # csomópontok
ax.add_patch(mpatches.Circle((L,0),R,
                             fc = (1,1,1,1),ec = (0.5,0.5,0.5,1),ls = "--", lw = 2))
ax.add_patch(mpatches.Rectangle((-1.5*L,-L - R/2), 3*L, R,
                                fc = (1,1,1,1),ec = (0.5,0.5,0.5,1),ls = "--", lw = 2))

## elmozdult állapot
# rudak
ax.add_patch(mpatches.Rectangle((-L-R/2,-L + nagy*UG[2]),R,L + nagy*(UG[0] - UG[2]),
                                fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Rectangle((-L-R/2,-2*L + nagy*UG[3]),R,L + nagy*(UG[2] - UG[3]),
                                fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Rectangle((L-R/2,-L + nagy*UG[2]),R,L + nagy*(UG[1] - UG[2]),
                                fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Rectangle((L-R/2,-L -2*L + nagy*UG[4]),R,2*L + nagy*(UG[2] - UG[4]),
                                fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))

# csomópontok
ax.add_patch(mpatches.Circle((-L,0+nagy*UG[0]),R,
                             fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Circle((L,nagy*UG[1]),R,
                             fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Rectangle((-1.5*L,-L - R/2 + nagy*UG[2]),3*L,R,
                                fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Circle((-L,-L-L),R,
                             fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
ax.add_patch(mpatches.Circle((L,-L - 2*L),R,
                             fc = (1,1,1,1),ec = (0,0,0,1), lw = 2))
# terhelés
ax.add_patch(mpatches.Arrow(L,nagy*UG[1],0,3*R,
                            fc = (1,0,0,1),ec = (1,0,0,1), lw = 1, width = 2*R))
plt.axis("equal")
plt.show()
```

A teljes csomóponti terhelésvektor 
$\mathbf{F}_\mathrm{TOT} = \mathbf{F}_\mathrm{REAK} + \mathbf{F}_\mathrm{KÜL}$:


```python
FTOT = np.dot(KG,UG)
FTOT
```




    array([-25000.,  60000.,      0., -25000., -10000.])




```python
FREAK = FTOT - FG
FREAK
```




    array([-25000.,      0.,      0., -25000., -10000.])



Az egyes elemekhez tartozó lokális elmozdulásvektorok:


```python
Ue1 = UG[en[0]]
Ue1
```




    array([  0.,  10.])




```python
Ue2 = UG[en[1]]
Ue2
```




    array([ 34.,  10.])




```python
Ue3 = UG[en[2]]
Ue3
```




    array([ 10.,   0.])




```python
Ue4 = UG[en[3]]
Ue4
```




    array([ 10.,   0.])



Az egyes elemekhez tartozó lokális tehervektor:


```python
Fe1 = np.dot(Ke1,Ue1)
Fe1
```




    array([-25000.,  25000.])




```python
Fe2 = np.dot(Ke2,Ue2)
Fe2
```




    array([ 60000., -60000.])




```python
Fe3 = np.dot(Ke3,Ue3)
Fe3
```




    array([ 25000., -25000.])




```python
Fe4 = np.dot(Ke4,Ue4)
Fe4
```




    array([ 10000., -10000.])



Tehát a normál igénybevételek:


```python
N1 = Fe1[0]
N1
```


```python
N2 = Fe2[0]
N2
```


```python
N3 = Fe3[0]
N3
```


```python
N4 = Fe4[0]
N4
```

Vagyis mindegyik rúd nyomó igénybevétel alatt van.

A rudakban ébredő feszültség:


```python
sig1 = N1/A1
sig1
```


```python
sig2 = N2/A1
sig2
```


```python
sig3 = N3/A1
sig3
```


```python
sig4 = N3/A2
sig4
```

A rudak alapváltozásai:


```python
eps1 = sig1/E1
eps1
```


```python
eps2 = sig2/E1
eps2
```


```python
eps3 = sig3/E1
eps3
```


```python
eps4 = sig4/E2
eps4
```

10e6f2936e96a0c207a2c1d8b04f9339dd7b01a2
ipynb
Jupyter Notebook
03/03_02.ipynb
TamasPoloskei/BME-VEMA
542725bf78e9ad0962018c1cf9ff40c860f8e1f0
MIT
03/03_02.ipynb
TamasPoloskei/BME-VEMA
542725bf78e9ad0962018c1cf9ff40c860f8e1f0
MIT
2018-11-20T14:17:52.000Z
2018-11-20T14:17:52.000Z
03/03_02.ipynb
TamasPoloskei/BME-VEMA
542725bf78e9ad0962018c1cf9ff40c860f8e1f0
MIT
Qwen/Qwen-72B
1. YES
2. YES