fem_ue2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieses Programm stellt ein FEM einen graden Stabes dar, der entlag seiner Ausdehnung belastet wird.\n",
    "Der Stab ist dabei in eine drei Teilstäbe unterteilt, die jeweils ihre eigenen Eigenschaften haben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für die Verarbeitung der Matrizien nutze ich numpy. Numpy ist eine Python Bibliothek die zum großen Teil in C geschrieben ist und somit die Rechnenleistung effiziernter nutzt. \n",
    "Bitte den Block zur installertion des Paketes nur ausführen, wenn noch keine Installation vorliegt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pip install numpy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im Folgenden definiere ich die Parameter für die Aufgabenstellung. \n",
    "\n",
    "L_n  < >  Längen der Teilstäbe.\n",
    "\n",
    "A    < >  Querschnittsfläche der Teilstäbe.\n",
    "\n",
    "E    < >  Elastitizitätsmodul der Teilstäbe.\n",
    "\n",
    "n_e  < >  Anzahl der Teilstäbe. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_n = [L_1, L_2, L_3] = [0.4, 0.3, 0.2]     \n",
    "A_n = [A_1, A_2, A_3] = [2.0, 1.0, 0.5]\n",
    "E_n = [E_1, E_2, E_3] = [200.0, 100.0, 50.0]\n",
    "n_e = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zwei weitere Parameter ergeben sich direkt aus den gegebenen Größen.\n",
    "\n",
    "n_k < > Anzahl der Knoten\n",
    "\n",
    "L_sum < > Die Gesamtlänge des Stabes\n",
    "\n",
    "k_n < > Koordinaten der Knoten\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_k = n_e + 1\n",
    "L_sum = sum(L_n)\n",
    "k_n = []\n",
    "for i in range(n_e):\n",
    "    k_n.append(sum(L_n[0:i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun stellen wir die Steifigkeitsmatrix auf.  \n",
    "$$ \n",
    "K  = \\frac{A \\cdot E}{ \\frac{L}{n_e}} \\begin{bmatrix}\n",
    "1 & -1 \\\\\n",
    "-1 & 1\n",
    "\\end{bmatrix}\n",
    "\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1000. -1000.]\n",
      " [-1000.  1000.]]\n",
      "[[ 333.33333333 -333.33333333]\n",
      " [-333.33333333  333.33333333]]\n",
      "[[ 125. -125.]\n",
      " [-125.  125.]]\n",
      "[array([[ 1000., -1000.],\n",
      "       [-1000.,  1000.]]), array([[ 333.33333333, -333.33333333],\n",
      "       [-333.33333333,  333.33333333]]), array([[ 125., -125.],\n",
      "       [-125.,  125.]])]\n"
     ]
    }
   ],
   "source": [
    "K_local = []\n",
    "for L, A, E in zip(L_n, A_n, E_n):\n",
    "    K_l = (A*E/L)* np.array([[1, -1], [-1, 1]])\n",
    "    print(K_l)\n",
    "    K_local.append(K_l)\n",
    "print(K_local)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die globale Steifigkeitsmatrix setzt sich aus den Steifigekeitsmatrizen der Knoten zusammen. \n",
    "Der ausdruck i:i+2 und i:i+2 ist daafür verantwortlich, dass sich die jeweiligen Matrizen auf einer Diagonalen in der allgeimnen Matrix wiederfinden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1000.         -1000.             0.             0.        ]\n",
      " [-1000.          1333.33333333  -333.33333333     0.        ]\n",
      " [    0.          -333.33333333   458.33333333  -125.        ]\n",
      " [    0.             0.          -125.           125.        ]]\n"
     ]
    }
   ],
   "source": [
    "K = np.zeros((n_k, n_k))\n",
    "for i, K_l in enumerate(K_local):\n",
    "    K[i:i+2, i:i+2] += K_l\n",
    "print(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun gestalte ich einen Lastvektor.np.zero gibt dabei einen Voktor voller Nullen zurück. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "F = np.zeros(n_k)\n",
    "F[-1] = 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun legen wir die Anfangsbedingungen fest. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "K[0,:] = 0  # Erste Zeile wird gleich null gesetzt\n",
    "K[:,0] = 0  # Erste Spalte wird gleich null gesetzt\n",
    "K[0,0] = 1  # Erstes Element wird gleich eins gesetzt, somit bleibt matrix invertiertbar\n",
    "F[0] = 0    # Keine Kraft wirkt am ersten Knoten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bevor ich das Gleichungssystem löse, lasse ich die Matrix und den Vektor ausgeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Globale Steifigkeitsmatrix K:\n",
      "[[ 1.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00]\n",
      " [ 0.00000000e+00  1.33333333e+03 -3.33333333e+02  0.00000000e+00]\n",
      " [ 0.00000000e+00 -3.33333333e+02  4.58333333e+02 -1.25000000e+02]\n",
      " [ 0.00000000e+00  0.00000000e+00 -1.25000000e+02  1.25000000e+02]]\n",
      "\n",
      "Lastvektor F:\n",
      "[ 0.  0.  0. 10.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Globale Steifigkeitsmatrix K:\")\n",
    "print(K)\n",
    "print(\"\\nLastvektor F:\")\n",
    "print(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nun Lösen wir das Gleichungssystem und geben die Lösung aus.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.   0.01 0.04 0.12]\n"
     ]
    }
   ],
   "source": [
    "dis  = np.linalg.solve(K, F)\n",
    "print(dis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}