115 lines
3.7 KiB
Rust
115 lines
3.7 KiB
Rust
use super::*;
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
|
|
pub struct Vortice {
|
|
pub x0: Float,
|
|
pub y0: Float,
|
|
pub rstar: Float,
|
|
pub eps: Float,
|
|
}
|
|
|
|
#[cfg(feature = "serde1")]
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Clone, Debug)]
|
|
#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
|
|
pub struct VortexParameters {
|
|
// The limit of 5 vortices can be bumped if needed...
|
|
pub vortices: ArrayVec<Vortice, 5>,
|
|
pub mach: Float,
|
|
}
|
|
|
|
impl<D: Dimension> eval::Evaluator<D> for VortexParameters {
|
|
#[allow(clippy::too_many_arguments)]
|
|
#[allow(clippy::many_single_char_names)]
|
|
fn evaluate(
|
|
&self,
|
|
time: Float,
|
|
x: ArrayView<Float, D>,
|
|
y: ArrayView<Float, D>,
|
|
rho: ArrayViewMut<Float, D>,
|
|
rhou: ArrayViewMut<Float, D>,
|
|
rhov: ArrayViewMut<Float, D>,
|
|
e: ArrayViewMut<Float, D>,
|
|
) {
|
|
let gamma = *GAMMA.get().expect("GAMMA is not defined");
|
|
let m = self.mach;
|
|
let p_inf = 1.0 / (gamma * m * m);
|
|
|
|
let rho_inf: Float = 1.0;
|
|
let u_inf: Float = 1.0;
|
|
let v_inf: Float = 0.0;
|
|
let e_inf = p_inf / (gamma - 1.0) + rho_inf * (u_inf.powi(2) + v_inf.powi(2)) / 2.0;
|
|
|
|
azip!((rho in rho,
|
|
rhou in rhou,
|
|
rhov in rhov,
|
|
e in e,
|
|
x in x,
|
|
y in y)
|
|
{
|
|
|
|
let mut iterator = self.vortices.iter();
|
|
|
|
match iterator.next() {
|
|
None => {
|
|
*rho = rho_inf;
|
|
*rhou = rho_inf*u_inf;
|
|
*rhou = rho_inf*v_inf;
|
|
*e = e_inf;
|
|
return;
|
|
},
|
|
Some(vortice) => {
|
|
use sbp::consts::PI;
|
|
|
|
let rstar = vortice.rstar;
|
|
let eps = vortice.eps;
|
|
|
|
let dx = (x - vortice.x0) - time;
|
|
let dy = y - vortice.y0;
|
|
let f = (1.0 - (dx*dx + dy*dy))/(rstar*rstar);
|
|
|
|
*rho = Float::powf(1.0 - eps*eps*(gamma - 1.0)*m*m/(8.0*PI*PI*p_inf*rstar*rstar)*f.exp(), 1.0/(gamma - 1.0));
|
|
assert!(*rho > 0.0);
|
|
let p = Float::powf(*rho, gamma)*p_inf;
|
|
let u = 1.0 - eps*dy/(2.0*PI*p_inf.sqrt()*rstar*rstar)*(f/2.0).exp();
|
|
let v = eps*dx/(2.0*PI*p_inf.sqrt()*rstar*rstar)*(f/2.0).exp();
|
|
|
|
assert!(p > 0.0);
|
|
|
|
assert!(*rho > 0.0);
|
|
*rhou = *rho*u;
|
|
*rhov = *rho*v;
|
|
*e = p/(gamma - 1.0) + *rho*(u*u + v*v)/2.0;
|
|
}
|
|
}
|
|
|
|
for vortice in iterator {
|
|
use sbp::consts::PI;
|
|
|
|
let rstar = vortice.rstar;
|
|
let eps = vortice.eps;
|
|
|
|
let dx = (x - vortice.x0) - time;
|
|
let dy = y - vortice.y0;
|
|
let f = (1.0 - (dx*dx + dy*dy))/(rstar*rstar);
|
|
|
|
let rho_vortice = Float::powf(1.0 - eps*eps*(gamma - 1.0)*m*m/(8.0*PI*PI*p_inf*rstar*rstar)*f.exp(), 1.0/(gamma - 1.0));
|
|
let p = Float::powf(rho_vortice, gamma)*p_inf;
|
|
let u = 1.0 - eps*dy/(2.0*PI*p_inf.sqrt()*rstar*rstar)*(f/2.0).exp();
|
|
let v = eps*dx/(2.0*PI*p_inf.sqrt()*rstar*rstar)*(f/2.0).exp();
|
|
|
|
assert!(rho_vortice > 0.0);
|
|
assert!(p > 0.0);
|
|
|
|
*rho += rho_vortice - rho_inf;
|
|
assert!(*rho > 0.0);
|
|
*rhou += rho_vortice*u - rho_inf*u_inf;
|
|
*rhov += rho_vortice*v - rho_inf*v_inf;
|
|
*e += (p/(gamma - 1.0) + rho_vortice*(u*u + v*v)/2.0) - e_inf;
|
|
}
|
|
});
|
|
}
|
|
}
|