BA Emilio Schmidt
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
Natürliche Einheiten
Aus den vier System-Parametern
"zähe" Einheiten
Damit ist der Satz
"träge" Einheiten
Damit ist der Satz
NB: Die Zahlenwerte der einheitenbildenden Parameter sind 1 und sollten auch im Code so gewählt werden.
Viskosität, dynamisch vs. kinematisch
Von den beiden,
Die Viskosität wird in der Funktion Visc_nu()
in visc_nu.c berechnet, ein Aufruf pro Zelle. Trotz der Namen nu1
(Scherv.) und nu2
(Volumenv.) handelt es sich um die dynamischen Viskositäten. Beim Vorgeben von v[RHO]
) also gar nicht auftauchen. Verwendet man obige "zähe Einheiten", so wird die Funktion besonders einfach:
void Visc_nu(double *v, double x1, double x2, double x3, double *nu1, double *nu2)
/* ... */
{
*nu1 = 1.0; *nu2 = 0.0;
}
Analytische Lösung
Mit
Entgegen "der" Intuition resultiert daraus
Jenseits von Stokes: Oseen-Fluss
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:
RS, THETAS = np.meshgrid(D.x1, D.x2)
Hierbei wurde verwendet:
D = pp.pload(500, w_dir="C:/Users/...")
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:
def before_first_value_line(array, value):
new_arr = np.hstack((np.full((array.shape[0], 1), value), array))
return new_arr
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:
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)
Um nun
def partial_derivative_dr(V, R, i, j):
dvdr = np.gradient(V[i,:], R[i,:])
return dvdr[j]
Dabei durchläuft der Index
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]) * np.pi / (len(THETA[:,0]))
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]) * np.pi / (len(THETA[:,0]))
df += dynamic_viscosity(Ma,Re,R) * partial_derivative_dr(VTHETA,R,i,j) * np.sin(THETA[i,j]) ** 2 * np.pi / (len(THETA[:,0]))
return df
Dabei ist np.pi / (len(THETA[:,0]))
entspricht hierbei dem
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 f