---
## 01. Ecuaciones de Poisson y Laplace

Eduard Larrañaga (ealarranaga@unal.edu.co)

---

### Resumen

Se presenta el método de solución de la ecuación de Poisson o Laplace con los métodos de diferencias finitas y algunos de los métodos de relajación.

---

---

## PDEs Elípticas. La Ecuación de Poisson

Una de las Ecuaciones Diferenciales Parciales elípticas maá utilizada en la astrofísica es la **ecuación de Poisson**, la cual describe la gravedad Newtoniana y también la electrostática,

\begin{equation}
\nabla^2 \phi = \rho \,\,.
\end{equation}

En esta ecuación $\phi = \phi(x,y,z)$ es la función que se quiere encontrar (puede representar el potencial gravitacional o el potencial electrostático) y $\rho = \rho(x,y,z)$ es una función escalar de la posición. Los problemas elípticos pueden ser lineales ($\rho$ no depende de $\phi$ o sus derivadas) o no-lineales ($\rho$ depende de $\phi$ o de sus derivadas). Cuando $\rho=0$, la ecuación de Poisson se denomina **ecuación de Laplace**.

$\nabla^2$ representa el operador diferencial de Laplace,

\begin{equation}
\nabla^2 = \frac{\partial^2}{\partial x^2} + \frac{\partial^2}{\partial y^2} + \frac{\partial^2}{\partial z^2}
\end{equation}

---

## Método de Diferencias Finitas en 2-dimensiones

Una técnica fundamental para resolver este tipo de ecuaciones diferenciales son las diferencias finitas. Para ilustrarlo, consideraremos un problema de valor de frontera en dos dimensiones. Así la ecuación diferencial tomará la forma

\begin{equation}
\nabla^2 \phi = \frac{\partial^2 \phi}{\partial x^2} + \frac{\partial^2 \phi}{\partial y^2}  = \rho (x,y).
\end{equation}

Como ya se ha discutido, en el método de diferencias finitas se divide el espacio en una malla discreta. En este caso utilizaremos una malla rectangular de coordenadas cartesianas en cuya frontera se conoce el valor de la función $\phi$ (condiciones de frontera) y en cuyo interior se quiere encontrar la solución.

Supondremos que la region bidimensional es un rectangulo que se dividirá utilizando $M+1$ nodos en la dirección-x y $N+1$ nodos en la dirección-y, para un total de $(M+1) \times (N+1)$ nodos en total. Los valores discretos de la coordenada x se denotarán como $x_i$ con $i=0,1,2,...,M$ mientras que los valores discretos de la coordenada y se denotarán como $y_j$ con $j=0,1,2,...,N$. El valor de la función $\phi$ en el punto $(x_i,y_j)$ se denotará como $\phi(x_i, y_j) = \phi_{i,j}$

Supondremos también que las condiciones de frontera serán:

- $\phi(x_0,y_j) = \phi_{0j} = A_{j}$
- $\phi(x_M,y_j) = \phi_{Mj} = B_{j}$
- $\phi(x_i,y_0) = \phi_{i0} = C_{i}$
- $\phi(x_i,y_N) = \phi_{iN} = D_{i}$

Luego de definir la malla de discretización, el siguiente paso es discretizar los operadores diferenciales. En este caso, se trabajará con las segundas derivadas aproximadas como diferencias centradas,

\begin{align}
\frac{\partial^2}{\partial x^2} = &\frac{\phi(x+\Delta x,y) - 2\phi(x,y) + \phi(x- \Delta x,y)}{\Delta x^2}\\
\frac{\partial^2}{\partial y^2} = &\frac{\phi(x,y+\Delta y) - 2\phi(x,y) + \phi(x,y- \Delta y)}{\Delta y^2}.
\end{align}

Utilizando el mismo tamaño de la malla  en las dos direcciones, $\Delta x = \Delta y = h$, el operador Laplaciano aplicado a la función $\phi$ en la ecuación se convierte en

\begin{align}
\nabla^2 \phi = \frac{\phi(x+h,y) - 2\phi(x,y) + \phi(x-h,y)}{h^2} + \frac{\phi(x,y+h) - 2\phi(x,y) + \phi(x,y-h)}{h^2} = &\rho (x,y)\\
\frac{\phi(x+h,y) - 2\phi(x,y) + \phi(x-h,y) + \phi(x,y+h) - 2\phi(x,y) + \phi(x,y-h)}{h^2} = &\rho (x,y)\\
\phi(x+h,y)  + \phi(x-h,y) + \phi(x,y+h)  + \phi(x,y-h) - 4\phi(x,y) = & h^2 \rho (x,y)
\end{align}

La información que presenta el lado izquierdo de esta ecuación se puede entender notando que se suman los valores de la ufunción $\phi$ en los cuatro nodos inmediatamente adyacentes a $(x,y)$ y se resta 4 veces el valor en $(x,y)$. Esto se suele representar gráficamente como un "stencil" o patrón en la forma

Este patrón determina la ecuación iterativa de diferencias finitas resultante:

\begin{equation}
\phi(x_{i+1},y_i)  + \phi(x_{i-1},y_i) + \phi(x_i,y_{i+1})  + \phi(x_i,y_{i-1}) - 4\phi(x_i,y_i) =  h^2 \rho (x_i,y_i)
\end{equation}

y su vez esta, relación podrá ser escrita como un conjunto de ecuaciones algebraicas lineales acopladas con la forma

\begin{equation}
\mathcal{M} \Phi = R
\end{equation}

donde se ha construido el vector $((M+1)+(N+1))$ dimensional

\begin{equation}
\Phi =
\begin{pmatrix}
\phi_{0,0}\\ \phi_{1,0} \\ \phi_{2,0}\\ \vdots \\ \phi_{M,0} \\ \phi_{0,1}\\ \vdots \\ \phi_{M,1}\\ \vdots \\ \vdots \\ \phi_{0,N}\\ \vdots \\ \phi_{M,N}
\end{pmatrix}
\end{equation}

---
### Ejemplo

Para ilustrar la construcción del sistema lineal, considere el siguiente problema simple:

Queremos resolver la ecuación de Poisson en la región $0\leq x \leq 1$, $0\leq y \leq 1$ con $\rho (x,y) = 2y$. Las condiciones de frontera (Dirichlet) serán

\begin{cases}
\phi(x,0) = &0\\
\phi(0,y) = &0\\
\phi(1,y) = &y\\
\phi(x,1) = &x.
\end{cases}

Para solucionar el problema utilizaremos una malla de discretización con $h=\frac{1}{3}$ en ambas direcciones (claramente con este valor tan grande para el espacio entre nodos no se obtendrá un resultado mu preciso!).
De esta forma, la malla tendrá $4 \times 4$ nodos localizados en las coordenadas

\begin{align}
x_i = &(x_0, x_1, x_2, x_3) = \left( 0, \frac{1}{3}, \frac{2}{3}, 1 \right)\\
y_i = &(y_0, y_1, y_2, y_3) = \left( 0, \frac{1}{3}, \frac{2}{3}, 1 \right)
\end{align}

y la función $\phi$ se discretizará con 16 valores, $\phi_{0,0}, \phi_{1,0}, \phi_{2,0}, ...$ .

Las condiciones de frontera serán

\begin{align}
\phi_{0,0} = & \phi_{1,0} = \phi_{2,0} = \phi_{3,0} = 0\\
\phi_{0,1} = & \phi_{0,2} = \phi_{0,3} = 0 \\
\phi_{3,1} = &  \frac{1}{3}\\
\phi_{3,2} = &  \frac{2}{3}\\
\phi_{3,3} = & 1 \\
\phi_{1,3} = &  \frac{1}{3}\\
\phi_{2,3} = &  \frac{2}{3}.
\end{align}

se puede observar que los valores independientes impuestos por las condiciones de frontera son 12 y los valores que se quieren encontrar para $\phi$ son solamente 4: $\phi_{1,1}, \phi_{1,2}, \phi_{2,1}, \phi_{2,2}$.

Utilizando el stencil

\begin{equation}
\phi(x_{i+1},y_i)  + \phi(x_{i-1},y_i) + \phi(x_i,y_{i+1})  + \phi(x_i,y_{i-1}) - 4\phi(x_i,y_i) =  h^2 \rho (x_i,y_i)
\end{equation}

se construye el sistema lineal en la forma

\begin{equation}
\begin{pmatrix}
1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 & 1 & -4 & 1 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 1 & 0 & 0 & 1 & -4 & 1 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & -4 & 1 & 0 & 0 & 1 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & -4 & 1 & 0 & 0 & 1 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\
\end{pmatrix}
\begin{pmatrix}
\phi_{0,0}\\ \phi_{1,0} \\ \phi_{2,0} \\ \phi_{3,0} \\
\phi_{0,1}\\ \phi_{1,1} \\ \phi_{2,1} \\ \phi_{3,1} \\
\phi_{0,2}\\ \phi_{1,2} \\ \phi_{2,2} \\ \phi_{3,2} \\
\phi_{0,3}\\ \phi_{1,3} \\ \phi_{2,3} \\ \phi_{3,3}
\end{pmatrix}=
\begin{pmatrix}
0\\ 0 \\ 0 \\ 0 \\
0\\ \frac{2}{27} \\ \frac{2}{27} \\ \frac{1}{3} \\
0\\ \frac{4}{27} \\ \frac{4}{27} \\ \frac{2}{3} \\
0\\ \frac{1}{3} \\ \frac{2}{3} \\ 1
\end{pmatrix}
\end{equation}

Este sistema puede resolverse manualmente debido a que solo se tienen 4 valores de la función $\phi$ por obtener. También es posible encontrar la solución utilizando la función [numpy.linalg.solve( )](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html).

Los valores encontrados para la función $\phi$ son
\begin{align}
\phi_{1,1} = & 0.0648\\
\phi_{2,1} = & 0.1759\\
\phi_{1,2} = & 0.1574\\
\phi_{2,2} = & 0.3796
\end{align}

Aún cuando este método es fácilmente aplicable y rápido en el ejemplo presentado, cuando se trabaja un problema de la vida real, con un número grande de nodos, la solución del sistema de ecuaciones lineales puede necesitar un tiempo de computo muy largo. Si la discretización se realiza con $N$ puntos, la matriz $\phi_{i,j}$ tendrá $N^2$ elementos y el número de operaciones requerido para solucionar el sistema lineal correspondiente sera $\mathcal{O}(N^3)$. En el caso de $N=100$ esto significa un numero de operaciones del orden de $10^6$.

---

## Métodos de Relajación

Otra clase de algoritmos para la solución de la ecuación de Poisson son los denominados métodos de relajación. En estos, se comienza el proceso con un ansatz inicial que luego se modifica mediante iteraciones para ir acercandose a la solución verdadera.

### Método de Jacobi

Este es el método mas simple de todos y se puede resumir en los siguientes pasos:

1. Se inicializa la matriz $\phi_{i,j}$ con un ansatz inicial
2. Se aplican las condiciones de frontera
3. Para cada punto interior en la malla se calcula la cantidad
\begin{equation}
\phi^*_{i,j} = \frac{1}{4} \left( \phi_{i+1,j} + \phi_{i-1,j} + \phi_{i,j+1} + \phi_{i,j-1} - h^2\rho_{i,j}\right)
\end{equation}

4. Para cada punto interior se reemplaza $\phi_{i,j}$ por $\phi^*_{i,j}$
5. Se vuelve al paso 2 hasta que la diferencia entre las dos aproximaciones mas recientes sea más pequeña que una tolerancia predeterminada.

A pesar de que el método de Jacobi es rápido y fácil de implementar, puede tener una lenta convergencia, especialmente para un gran número de nodos.

### Método de Gauss-Seidel

Este método es similar al de Jacobi, excepto porque los pasos 3. y 4. descritos arriba se combinan de tal forma que $\phi_{i,j}$ se reemplaza por $\phi^*_{i,j}$ inmediatamente se calcula. Con esta pequeña modificación se logra mejorar el tiempo de calculo y adicionalmente se necesita menos espacio de memoria para almacenar los calculos intermedios.

### Método de Sobre-Relajación Sucesiva ( Succesive Over-Relaxation: SOR)

Otra modificación posible para los métodos anteriores corresponde a cambiar la actualización con la forma

\begin{equation}
\phi^*_{i,j} = (1-\omega) \phi_{i,j} + \frac{1}{4} \omega \left( \phi_{i+1,j} + \phi_{i-1,j} + \phi_{i,j+1} + \phi_{i,j-1} - h^2\rho_{i,j}\right)
\end{equation}

donde $\omega$ es un parametro de relajación. El valor $\omega = 1$ recupera el método de Gauss-Seidel, valores $\omega<1$ produce  *sub-relajación* (i.e. se mantiene una proción de la solución anterior) y un valor $\omega >1$ produce *sobre-relajación* (la nueva solución se mueve lejos de la anterior solución que en el modelo de Gauss-Seidel).

El valor más apropiado para $\omega$ depende del problema particular que se esta resolviendo. Sin embargo, valores en el rango $1.2 \leq \omega \leq 1.4$ suele dar muy buenos resultados. El método SOR requiere de menos iteraciones que los métodos de Jacobi y de Gauss-Seidel y en general se puede considerar como el más practico de todos, aunque es importante recalcar que la convergencia de la solución también depende del ansatz inicial elegido.

```python

```

12. PDE III. Ecuaciones de Poisson y Laplace /01. Ecuaciones de Poisson y Laplace.ipynb


Határozzuk meg az alábbi ábrán látható tartó súlypontvonalának eltolódását leíró $v\left(x\right)$ függvényt végeselemes módszer használatával, síkbeli egyenes gerendalemek alkalmazásával.
Vizsgáljuk meg a végeselemes megoldással kapott hajlítónyomatéki igénybevétel hibáját az egyes szakaszokon.
Határozzuk meg az $x = a/2$ keresztmetszetben a hajlítónyomatéki igénybevétel nagyságát 2, illetve 3 síkbeli egyenes gerendaelem alkalmazásával.
A tartók két különböző átmérőjű ($d_1 = 2d$, illetve $d_2 = d$) kör keresztmetszetű tartókból
vannak összeépítve.
A tartók anyaga lineárisan rugalmas, homogén, izotrop. A $d_1$ átmérőjű rész rugalmassági modulusza $E$, míg a $d_2$ átmérővel rendelkező részé $4E$.

```python
import sympy as sp
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

sp.init_printing()
```

```python
ro, xi, L, A, I, E = sp.symbols("rho, xi L A I E")
```

```python
Nv = 1/8*sp.Matrix([2*(1-xi)**2*(2+xi),
                 L*(1-xi)**2*(1+xi),
                 2*(1+xi)**2*(2-xi),
                 L*(1+xi)**2*(xi-1)])
Nv
```

```python
Nfi=sp.diff(Nv,xi)*(2/L)
sp.simplify((1/L)**(-1)*Nfi)
```

```python
Bv=sp.diff(Nv,xi,2)*(2/L)**2
sp.simplify((1/L**2)**(-1)*Bv)
```

```python
KeBEAM1D = I*E*sp.integrate(Bv*(Bv.T),(xi,-1,1))*L/2
(I*E/L**3)**(-1)*KeBEAM1D
```

```python
MeBEAM1D = A*ro*sp.integrate(Nv*(Nv.T),(xi,-1,1))*L/2
print((A*ro*L/420)**(-1)*MeBEAM1D)
```

    Matrix([[156.000000000000, 22.0*L, 54.0000000000000, -13.0*L], [22.0*L, 4.0*L**2, 13.0*L, -3.0*L**2], [54.0000000000000, 13.0*L, 156.000000000000, -22.0*L], [-13.0*L, -3.0*L**2, -22.0*L, 4.0*L**2]])

```python
def Nvfgv(xi,L):
    return np.array([1/4*(1-xi)**2*(2+xi),
                 L/8*(1-xi)**2*(1+xi),
                 1/4*(1+xi)**2*(2-xi),
                 L/8*(1+xi)**2*(xi-1)])
```

```python
def Nfifgv(xi,L):
    return np.multiply(1/L,np.array([1.5*xi**2-1.5,
                     L*(0.75*xi+0.25)*(xi-1),
                     -1.5*xi**2+1.5,
                     L*(0.75*xi-0.25)*(xi+1)]))
```

```python
def KeBEAM1D(I,E,L):
    return np.multiply(I*E/L**3, np.array([[12,   6*L,    -12,  6*L],
                                           [6*L,  4*L**2, -6*L, 2*L**2],
                                           [-12,  -6*L,    12,  -6*L],
                                           [6*L, 2*L**2, -6*L, 4*L**2]]))
```

```python
def MeBEAM1D(A,ro,L):
    return np.multiply(A*ro*L/420, np.array([
        [156, 22*L, 54, -13*L],
        [22*L, 4*L**2, 13*L, -3*L**2],
        [54, 13*L, 156, -22*L],
        [-13*L, -3*L**2, -22*L, 4*L**2]]))
```

```python
L1 = 200e-3
L2 = 600e-3
L3 = 300e-3

d1 = 20e-3
d2 = 30e-3
d3 = 20e-3
d4 = 300e-3

s1 = 10e3
s2 = 1000e3
s3 = 2500e3

m = 0.5
E = 200e9
ro = 7850
```

```python
I1 = (d1)**4*np.pi/64
I2 = (d2)**4*np.pi/64
I3 = (d3)**4*np.pi/64

A1 = (d1)**2*np.pi/4
A2 = (d2)**2*np.pi/4
A3 = (d3)**2*np.pi/4

Ke1 = KeBEAM1D(I1,E,L1)
Ke2 = KeBEAM1D(I2,E,L2)
Ke3 = KeBEAM1D(I3,E,L3)

Me1 = MeBEAM1D(A1,ro,L1)
Me2 = MeBEAM1D(A2,ro,L2)
Me3 = MeBEAM1D(A3,ro,L3)

thetaz = 1/4*m*(d4/2)**2
```

```python
elemSZF = np.array([[1,2,3,4],[3,4,5,6],[5,6,7,8]]) - 1
```

```python
KG=np.zeros((8,8))
MG=np.zeros((8,8))
```

```python
eind=0
KG[np.ix_(elemSZF[eind],elemSZF[eind])]+=Ke1
MG[np.ix_(elemSZF[eind],elemSZF[eind])]+=Me1
```

```python
eind=1
KG[np.ix_(elemSZF[eind],elemSZF[eind])]+=Ke2
MG[np.ix_(elemSZF[eind],elemSZF[eind])]+=Me2
```

```python
eind=2
KG[np.ix_(elemSZF[eind],elemSZF[eind])]+=Ke3
MG[np.ix_(elemSZF[eind],elemSZF[eind])]+=Me3
```

```python
KG[elemSZF[0][0],elemSZF[0][0]]+=s1
KG[elemSZF[0][2],elemSZF[0][2]]+=s2
KG[elemSZF[1][2],elemSZF[1][2]]+=s3
```

```python
MG[elemSZF[2][2],elemSZF[2][2]] += m
MG[elemSZF[2][3],elemSZF[2][3]] += thetaz
```

```python
fixSZF=np.array([])
```

```python
szabadSZF=[i for i in range(0,8) if i not in fixSZF]
szabadSZF
```

```python
KK = KG[np.ix_(szabadSZF,szabadSZF)]
MK = MG[np.ix_(szabadSZF,szabadSZF)]
```

```python
sajatErtek, sajatVektor = np.linalg.eig(np.linalg.solve(MK,KK))
np.sqrt(sajatErtek)
```

    array([ 26458.01845952,   7429.77280567,   4367.3802812 ,   2525.46582768,
             1682.73657981,   1012.43565175,    715.60241866,    374.06415577])

```python
UG1 = np.zeros(8)
UG1[np.ix_(szabadSZF)] = sajatVektor[:,-1]

UG2 = np.zeros(8)
UG2[np.ix_(szabadSZF)] = sajatVektor[:,-2]

UG3 = np.zeros(8)
UG3[np.ix_(szabadSZF)] = sajatVektor[:,-3]
```

# Eredmények ábrázolása

```python
xiLista = np.linspace(-1,1,num = 10)
cspxKRD=[[0,L1],[L1,L1+L2],[L1+L2,L1+L2+L3]]
cspxKRD
```

```python
x1Lista=[(cspxKRD[0][1]-cspxKRD[0][0])/2*(xi+1) + cspxKRD[0][0] for xi in xiLista]
x2Lista=[(cspxKRD[1][1]-cspxKRD[1][0])/2*(xi+1) + cspxKRD[1][0] for xi in xiLista]
x3Lista=[(cspxKRD[2][1]-cspxKRD[2][0])/2*(xi+1) + cspxKRD[2][0] for xi in xiLista]
xLista = np.concatenate((x1Lista,x2Lista,x3Lista))
```

```python
v1Lista = [np.dot(Nvfgv(xi,L1),UG1[elemSZF[0]]) for xi in xiLista]
v2Lista = [np.dot(Nvfgv(xi,L2),UG1[elemSZF[1]]) for xi in xiLista]
v3Lista = [np.dot(Nvfgv(xi,L3),UG1[elemSZF[2]]) for xi in xiLista]
vLista = np.concatenate((v1Lista,v2Lista,v3Lista))
```

```python
figv = plt.figure(num = 1, figsize=(16/2.54,10/2.54))
axv = figv.add_subplot(111)

axv.plot(xLista,vLista)

plt.xlabel(r"$x \, \left[\mathrm{m}\right]$")
plt.ylabel(r"$v \, \left[\mathrm{m}\right]$")

plt.grid()
plt.legend()
plt.show()
```

```python
v1Lista = [np.dot(Nvfgv(xi,L1),UG2[elemSZF[0]]) for xi in xiLista]
v2Lista = [np.dot(Nvfgv(xi,L2),UG2[elemSZF[1]]) for xi in xiLista]
v3Lista = [np.dot(Nvfgv(xi,L3),UG2[elemSZF[2]]) for xi in xiLista]
vLista = np.concatenate((v1Lista,v2Lista,v3Lista))
```

```python
figv = plt.figure(num = 2, figsize=(16/2.54,10/2.54))
axv = figv.add_subplot(111)

axv.plot(xLista,vLista)

plt.xlabel(r"$x \, \left[\mathrm{m}\right]$")
plt.ylabel(r"$v \, \left[\mathrm{m}\right]$")

plt.grid()
plt.legend()
plt.show()
```

```python
v1Lista = [np.dot(Nvfgv(xi,L1),UG3[elemSZF[0]]) for xi in xiLista]
v2Lista = [np.dot(Nvfgv(xi,L2),UG3[elemSZF[1]]) for xi in xiLista]
v3Lista = [np.dot(Nvfgv(xi,L3),UG3[elemSZF[2]]) for xi in xiLista]
vLista = np.concatenate((v1Lista,v2Lista,v3Lista))
```

```python
figv = plt.figure(num = 3, figsize=(16/2.54,10/2.54))
axv = figv.add_subplot(111)

axv.plot(xLista,vLista)

plt.xlabel(r"$x \, \left[\mathrm{m}\right]$")
plt.ylabel(r"$v \, \left[\mathrm{m}\right]$")

plt.grid()
plt.legend()
plt.show()
```