Simplify vortex using Evaluator trait

euler/src/lib.rs

@@ -7,9 +7,9 @@ use sbp::utils::Direction;
 use sbp::Float;
 
 pub mod eval;
-
+use eval::Evaluator;
 mod vortex;
-pub use vortex::{vortex, VortexParameters, Vortice};
+pub use vortex::{VortexParameters, Vortice};
 
 pub const GAMMA: Float = 1.4;
 
@@ -320,23 +320,8 @@ impl Field {
         time: Float,
         vortex_param: &VortexParameters,
     ) {
-        assert_eq!(x.shape(), y.shape());
-        assert_eq!(x.shape()[1], self.nx());
-        assert_eq!(x.shape()[0], self.ny());
-
         let (rho, rhou, rhov, e) = self.components_mut();
-        let n = rho.len();
-
-        vortex(
-            rho.into_shape((n,)).unwrap(),
-            rhou.into_shape((n,)).unwrap(),
-            rhov.into_shape((n,)).unwrap(),
-            e.into_shape((n,)).unwrap(),
-            x.into_shape((n,)).unwrap(),
-            y.into_shape((n,)).unwrap(),
-            time,
-            &vortex_param,
-        )
+        vortex_param.evaluate(time, x, y, rho, rhou, rhov, e)
     }
     fn iter(&self) -> impl ExactSizeIterator<Item = FieldValue> + '_ {
         let n = self.nx() * self.ny();
@@ -949,7 +934,7 @@ fn vortexify(
         fiter.next().unwrap(),
     );
     let (y, x) = yx;
-    vortex(rho, rhou, rhov, e, x, y, time, &vparams);
+    vparams.evaluate(time, x, y, rho, rhou, rhov, e)
 }
 
 #[allow(non_snake_case)]

euler/src/vortex.rs

@@ -20,26 +20,20 @@ pub struct VortexParameters {
     pub mach: Float,
 }
 
-#[allow(clippy::too_many_arguments)]
-#[allow(clippy::many_single_char_names)]
-pub fn vortex(
-    rho: ArrayViewMut1<Float>,
-    rhou: ArrayViewMut1<Float>,
-    rhov: ArrayViewMut1<Float>,
-    e: ArrayViewMut1<Float>,
-    x: ArrayView1<Float>,
-    y: ArrayView1<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,
-    vortex_param: &VortexParameters,
-) {
-    assert_eq!(rho.len(), rhou.len());
-    assert_eq!(rho.len(), rhov.len());
-    assert_eq!(rho.len(), e.len());
-    assert_eq!(rho.len(), x.len());
-    assert_eq!(rho.len(), y.len());
-    assert_eq!(x.shape(), y.shape());
-
-    let m = vortex_param.mach;
+        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 m = self.mach;
         let p_inf = 1.0 / (GAMMA * m * m);
 
         let rho_inf: Float = 1.0;
@@ -55,7 +49,7 @@ pub fn vortex(
                y in y)
         {
 
-        let mut iterator = vortex_param.vortices.iter();
+            let mut iterator = self.vortices.iter();
 
             match iterator.next() {
                 None => {
@@ -115,4 +109,5 @@ pub fn vortex(
                 *e += (p/(GAMMA - 1.0) + rho_vortice*(u*u + v*v)/2.0) - e_inf;
             }
         });
+    }
 }