BA Emilio Schmidt: Difference between revisions
(Viskosität) |
m (Implementierung in Python) |
||
Line 279: | Line 279: | ||
Von den beiden, | Von den beiden, | ||
== Implementierung in Python == | |||
Nachdem die Daten mittels der Bibliothek pyPLUTO geladen wurden, wurde zunächst ein Meshgrid für die Radien und die Winkel erstellt: | |||
\begin{python} | |||
RS, THETAS = np.meshgrid(D.x1, D.x2) | |||
\end{python} | |||
Hierbei wurde verwendet: | |||
\begin{python} | |||
D = pp.pload(500, w_dir="C:/Users/...") | |||
\end{python} | |||
Die oben beschriebenen Randbedingungen sind jedoch nicht in den Daten für Radien und den Winkeln bzw. für die jeweiligen Geschwindigkeitskomponenten enthalten. Daher müssen sie manuell in die Datensätze eingefügt werden. Dafür sorgt folgende Funktion: | |||
\begin{python} | |||
def before_first_value_line(array, value): | |||
new_arr = np.hstack( | |||
(np.full((array.shape[0], 1), value), | |||
array)) | |||
return new_arr | |||
\end{python} | |||
np.hstack() ist dabei eine Funktion, um zwei Arrays nebeneinander zu setzen, sodass zwei Arrays der Form | |||
Mit dieser Funktion lassen sich jetzt die Randbedingungen in die Datensätze einfügen: | |||
\begin{python} | |||
R = before_first_value_line(RS,1) | |||
THETA = THETAS | |||
VR = before_first_value_line(D.vx1.T,0) | |||
VTHETA = before_first_value_line(D.vx2.T,0) | |||
\end{python} | |||
Um nun | |||
\begin{python} | |||
def partial_derivative_dr(V, i, j): | |||
dvdr = np.gradient(V[i,:], RS[i,:]) | |||
return dvdr[j] | |||
\end{python} | |||
Dabei durchläuft der Index | |||
\begin{align*} | |||
\mu=\frac{\rho_{\text{ext}}v_{\text{ext}}L}{Re} | |||
\end{align*} | |||
Dabei ist | |||
\begin{align*} | |||
v_{\text{ext}}=Ma\cdot c_s | |||
\end{align*} | |||
Dabei sind | |||
\begin{align*} | |||
\mu=\frac{Ma R}{Re} | |||
\end{align*} | |||
Damit lässt sich eine Funktion definieren, die die dynamische Viskosität, für gegebene Machzahl, Reynoldszahl und gegebenen Radius bestimmt: | |||
\begin{python} | |||
def dynamic_viscosity(Ma, Re, R): | |||
mu = (Ma * np.min(R)) / Re | |||
return mu | |||
\end{python} | |||
Mit der dynamischen Viskosität und den eingefügten Randbedingungen lässt sich nun die Kraft | |||
\begin{python} | |||
def local_force(VR, VTHETA, i, j, Ma, Re, R, P): | |||
df = - P[i,j] * np.cos(THETA[i,j]) * np.sin(THETA[i,j]) | |||
df += dynamic_viscosity(Ma,Re,R) | |||
* (4/3) * partial_derivative_dr(VR,R,i,j) | |||
* np.cos(THETA[i,j]) * np.sin(THETA[i,j]) | |||
df += dynamic_viscosity(Ma,Re,R) | |||
* partial_derivative_dr(VTHETA,R,i,j) | |||
* np.sin(THETA[i,j]) ** 2 | |||
return df | |||
\end{python} | |||
Dabei ist | |||
\begin{python} | |||
def net_force(VR, VTHETA, j, Ma, Re, R, P): | |||
df_arr = np.zeros(len(THETA[:,0])) | |||
for i in np.arange(0,len(THETA[:,0])): | |||
df_arr[i] = local_force(VR, VTHETA, i, j, Ma, Re, R, P) | |||
f = 2 * np.pi * np.min(R) ** 2 * 2 * np.sum(df_arr) | |||
return df_arr | |||
\end{python} |
Revision as of 11:10, 26 April 2024
(Der Echtzeit-Previewer rendert leider keine Formeln. Am besten stets mit "edit source" statt dem visual "edit" arbeiten und bitte ausgiebig den Knopf "Show preview" benutzen anstatt zig mal abzuspeichern. Diskussionen sollten unter Discussion geführt werden. -- Lothar)
Stokes-Fluss um eine Kugel
Kraftberechnung
Dabei lautet der Spannungstensor (s. auch Wikipedia)
Kraftberechnung (Emilio)
Die Kraft, welche auf die umströmte Kugel wirkt, ist gegeben durch folgendes Oberflächenintegral:
Dabei gilt für ein Oberflächenelement
Einsetzen und weitere Berechnung in Kugelkoordinaten liefert:
Auswerten des Matrix-Vektor-Produktes liefert, dass nur die
Um nun die Integrale ausrechnen zu können, wird die explizite Form des Spannungstensors für dieses Problem benötigt. Im Allgemeinen ist der Spannungstensor für reale, newtonsche Fluide gegeben durch:
Mit der Volumenviskosität
Dabei ist
Für die Divergenz des Geschwindigkeitsfeldes gilt allgemein in Kugelkoordinaten:
Aufgrund dessen, dass das Fluid homogen einströmt und eine Kugel umströmt, hat das Geschwindigkeitsfeld um die Kugel Zylindersymmetrie. Daher fällt die azimutale Ableitung bei Betrachtung des Geschwindigkeitsfeldes um die Kugel weg. Außerdem folgt aus der vorgegebenen Anfangsbedingung, dass das Fluid entlang der z-Achse einströmt, zusammen mit der Kugelsymmetrie der Kugel, dass das Geschwindigkeitsfeld und auch sämtliche anderen relevanten Vektorfelder, die dieses Problem beschreiben, keine azimutale Komponente aufweisen können. Damit folgt für die Divergenz des Geschwindigkeitsfeldes:
Einsetzen in die
Die Ableitungen lassen sich zusätzlich mittels der Produktregel vereinfachen. Es folgt:
Die Verwendung der No-Slip-RB bedeutet, dass sowohl die normale als auch die tangentiale Komponente des Geschwindigkeitsvektors auf der Oberfläche eines festen Körpers verschwinden müssen. Damit folgt:
Außerdem impliziert das Verschwinden des Geschwindigkeitsvektors auf der Kugeloberfläche und dessen Kugelsymmetrie, dass zusätzlich die polaren Ableitungen auf der Oberfläche verschwinden:
Damit folgt für die
Für die
Einsetzen der jeweiligen Komponenten des Vektorgradienten und auswerten an der Kugeloberfläche liefert:
Mit den Randbedingungen folgt dann final für die
Für die
Die jeweiligen Komponenten des Vektorgradienten sind im Allgemeinen gegeben durch:
Analog zu oben fallen hier auch sowohl die azimutalen Komponenten als auch die azimutalen Ableitungen weg, weshalb für die
Einsetzen in das Integral zur Kraftberechnung und auswerten des Integrals über
Da im vorliegenden Problem insbesondere die Kraft auf die Kugel in
Aufgrund dessen, dass die
Für die Berechnung der jeweiligen Skalarprodukte ist es praktisch den Basisvektor
Damit folgt für
Die Kraft in
Auswerten der Integrale über
Analoges Vorgehen liefert für
Viskosität, dynamisch vs. kinematisch
Von den beiden,
Implementierung in Python
Nachdem die Daten mittels der Bibliothek pyPLUTO geladen wurden, wurde zunächst ein Meshgrid für die Radien und die Winkel erstellt:
Hierbei wurde verwendet:
Die oben beschriebenen Randbedingungen sind jedoch nicht in den Daten für Radien und den Winkeln bzw. für die jeweiligen Geschwindigkeitskomponenten enthalten. Daher müssen sie manuell in die Datensätze eingefügt werden. Dafür sorgt folgende Funktion: \begin{python} def before_first_value_line(array, value):
new_arr = np.hstack( (np.full((array.shape[0], 1), value), array)) return new_arr
\end{python}
np.hstack() ist dabei eine Funktion, um zwei Arrays nebeneinander zu setzen, sodass zwei Arrays der Form
R = before_first_value_line(RS,1) THETA = THETAS VR = before_first_value_line(D.vx1.T,0) VTHETA = before_first_value_line(D.vx2.T,0)
\end{python}
Um nun
dvdr = np.gradient(V[i,:], RS[i,:])
return dvdr[j] \end{python}
Dabei durchläuft der Index
Dabei ist
v_{\text{ext}}=Ma\cdot c_s
\end{align*}
Dabei sind
\mu=\frac{Ma R}{Re}
\end{align*}
Damit lässt sich eine Funktion definieren, die die dynamische Viskosität, für gegebene Machzahl, Reynoldszahl und gegebenen Radius bestimmt: \begin{python}
def dynamic_viscosity(Ma, Re, R): mu = (Ma * np.min(R)) / Re return mu
\end{python}
Mit der dynamischen Viskosität und den eingefügten Randbedingungen lässt sich nun die Kraft
def local_force(VR, VTHETA, i, j, Ma, Re, R, P): df = - P[i,j] * np.cos(THETA[i,j]) * np.sin(THETA[i,j]) df += dynamic_viscosity(Ma,Re,R) * (4/3) * partial_derivative_dr(VR,R,i,j) * np.cos(THETA[i,j]) * np.sin(THETA[i,j]) df += dynamic_viscosity(Ma,Re,R) * partial_derivative_dr(VTHETA,R,i,j) * np.sin(THETA[i,j]) ** 2 return df
\end{python}
Dabei ist
def net_force(VR, VTHETA, j, Ma, Re, R, P): df_arr = np.zeros(len(THETA[:,0])) for i in np.arange(0,len(THETA[:,0])): df_arr[i] = local_force(VR, VTHETA, i, j, Ma, Re, R, P) f = 2 * np.pi * np.min(R) ** 2 * 2 * np.sum(df_arr) return df_arr
\end{python}