more tests

sbp/tests/convergence.rs

@@ -42,14 +42,13 @@ fn run_with_size<SBP: sbp::operators::UpwindOperator>(size: usize) -> Float {
     verifield.h2_err::<SBP>(sys.field())
 }
 
-#[test]
-fn convergence() {
+fn convergence<SBP: sbp::operators::UpwindOperator>() {
     let sizes = [25, 35, 50, 71, 100, 150, 200];
     let mut prev: Option<(usize, Float)> = None;
     println!("Size\tError(h2)\tq");
     for size in &sizes {
         print!("{:3}x{:3}", size, size);
-        let e = run_with_size::<sbp::operators::Upwind4>(*size);
+        let e = run_with_size::<SBP>(*size);
         print!("\t{:.10}", e);
         if let Some(prev) = prev.take() {
             let m0 = size * size;
@@ -65,5 +64,14 @@ fn convergence() {
         println!();
         prev = Some((*size, e));
     }
-    panic!();
+}
+
+#[test]
+fn convergence_upwind4() {
+    convergence::<sbp::operators::Upwind4>();
+}
+
+#[test]
+fn convergence_upwind9() {
+    convergence::<sbp::operators::Upwind9>();
 }

sbp/tests/single_period.rs

@@ -0,0 +1,47 @@
+#![cfg(feature = "expensive_tests")]
+use ndarray::prelude::*;
+use sbp::euler::*;
+use sbp::Float;
+
+#[test]
+#[ignore]
+fn single_period_upwind4() {
+    let nx = 100;
+    let ny = 100;
+
+    let x = Array1::linspace(-5.0, 5.0, nx);
+    let y = Array1::linspace(-5.0, 5.0, ny);
+
+    let x = x.broadcast((ny, nx)).unwrap().to_owned();
+    let y = y
+        .reversed_axes()
+        .broadcast((nx, ny))
+        .unwrap()
+        .reversed_axes()
+        .to_owned();
+
+    let vortex_params = VortexParameters {
+        x0: -1.0,
+        y0: 0.0,
+        mach: 0.5,
+        rstar: 0.5,
+        eps: 1.0,
+    };
+
+    let mut sys = System::<sbp::operators::Upwind4>::new(x, y);
+    sys.vortex(0.0, vortex_params);
+
+    let time = 10.0;
+    let dt = 0.2 * Float::min(1.0 / (nx - 1) as Float, 1.0 / (ny - 1) as Float);
+
+    let nsteps = (time / dt) as usize;
+    for _ in 0..nsteps {
+        sys.advance_upwind(dt);
+    }
+
+    let mut verifield = Field::new(ny, nx);
+    verifield.vortex(sys.x(), sys.y(), nsteps as Float * dt - 10.0, vortex_params);
+
+    let err = verifield.h2_err::<sbp::operators::Upwind4>(sys.field());
+    panic!("{}", err);
+}