diff --git a/test/data_for_test.py b/test/data_for_test.py index 9e62317061554bc5de818673987fcdb11b256121..483d50b65f311b8cabea7497b1b1626590b62032 100644 --- a/test/data_for_test.py +++ b/test/data_for_test.py @@ -31,23 +31,35 @@ class WindowData: ndim = ref.gas.ndim dirs = ref.gas.dirs - def __init__(self, states_str, direction, window_metrics): + def __init__(self, states, direction, window_metrics): self.direction = self.dirs[direction] self.dir_internal = self.direction-1 - # FIXME: Move array_from_string stuff outside WindowResults - # -- just pass an array & have external utilities that generate - # Riemann, sine wave, etc. initial conditions - self.state_pair = u.transposed_array_from_string(states_str) - self.states = u.expand_to_n(self.state_pair, 6) + self.states = states + self.metrics, self.jacobians = window_metrics - # FIXME: these should be generalized fluxes - # FIXME: make a clear distinction between fluxes in physical and - # generalized coordinates - self.fluxes = ref.pointwise_fluxes( - self.states)[:,:,self.dir_internal].T.copy(order="F") + self.fluxes = ref.pointwise_fluxes(self.states) + self.generalized_fluxes = np.array([np.dot(flux, metrics/jacobian) + for flux, metrics, jacobian + in zip(self.fluxes, self.metrics, self.jacobians)] + )[:,:,self.dir_internal].T.copy(order="F") - self.metrics, self.jacobians = window_metrics + +@pytest.fixture(scope="session") +def states_generator(): + def states(states_str): + if states_str == "sine": + rho = np.sin(0.01*np.arange(6)+1.55) + vel = np.repeat(np.array([1.0, 2.0, 3.0])[None,:], 6, axis=0) + pressure = np.repeat(3.2, 6) + return u.transposed_array([ref.gas.conserved(r, v, p) + for r, v, p + in zip(rho, vel, pressure)]) + else: + state_pair = u.transposed_array_from_string(states_str) + return u.expand_to_n(state_pair, 6) + + return states @pytest.fixture(scope="session") @@ -68,6 +80,9 @@ def metrics_generator(): @pytest.fixture(scope="session", params=[ + ("sine", "x", "uniform"), + ("sine", "y", "uniform"), + ("sine", "z", "uniform"), ("1 1 1 1 5.5,1 1 1 1 5.5", "x", "uniform"), ("1 1 1 1 5.5,1 1 1 1 5.5", "y", "uniform"), ("1 1 1 1 5.5,1 1 1 1 5.5", "z", "uniform"), @@ -84,12 +99,14 @@ def metrics_generator(): ("1 -2 -3 -1 11,2 -8 -12 -4 64", "y", "uniform"), ("1 -3 -1 -2 11,2 -12 -4 -8 64", "z", "uniform") ]) -def window_data(request, metrics_generator): +def window_data(request, states_generator, metrics_generator): states_str = request.param[0] dir_str = request.param[1] metric_str = request.param[2] - return WindowData(states_str, dir_str, metrics_generator(metric_str)) + return WindowData(states_generator(states_str), + dir_str, + metrics_generator(metric_str)) class PairData: @@ -100,11 +117,7 @@ class PairData: self.dir_internal = data.dir_internal self.state_pair = data.states[:,2:4] - - # FIXME: these should be generalized fluxes - # FIXME: make a clear distinction between fluxes in physical and - # generalized coordinates - self.flux_pair = data.fluxes[:,2:4] + self.generalized_flux_pair = data.generalized_fluxes[:,2:4] weighted_metric_slice = data.metrics[2:4]/data.jacobians[2:4,None,None] self.frozen_metrics = np.mean(weighted_metric_slice, axis=0) diff --git a/test/ideal_gas.py b/test/ideal_gas.py index 0be569fef27f36ab0a3dbc5ec0b15033a84eea09..85aa4b737a985ef7c0b83d1cec7fa9c9ca59d41a 100644 --- a/test/ideal_gas.py +++ b/test/ideal_gas.py @@ -47,13 +47,12 @@ def energy(state): return state[ndim+1] -def kinetic_energy(state): - vel = velocity(state) - return 0.5*rho(state)*np.dot(vel, vel) +def kinetic_energy(rho, vel): + return 0.5*rho*np.dot(vel, vel) def internal_energy(state): - return energy(state) - kinetic_energy(state) + return energy(state) - kinetic_energy(rho(state), velocity(state)) def pressure(state): @@ -75,3 +74,14 @@ def flux(state): result[ndim+1,i] += vel[i]*p return result + + +def conserved(rho, vel, p): + def energy(rho, vel, p): + return p/(gamma - 1) + kinetic_energy(rho, vel) + + state = np.empty(nvars) + state[0] = rho + state[1:nvars-1] = rho*vel + state[nvars-1] = energy(rho, vel, p) + return state diff --git a/test/test_eigensystem.py b/test/test_eigensystem.py index c077e6822beaf2c035da81eb92c11d161a2c915c..8c1ba9369290ae16a5245a886c6c64af49874b01 100644 --- a/test/test_eigensystem.py +++ b/test/test_eigensystem.py @@ -35,7 +35,8 @@ import pytest import utilities as u import weno_reference_implementation as ref -from data_for_test import pair_data, window_data, metrics_generator +from data_for_test import ( + pair_data, window_data, states_generator, metrics_generator) def test_roe_uniform_grid_ideal_gas(queue, pair_data): @@ -68,7 +69,7 @@ def test_roe_uniform_grid_ideal_gas(queue, pair_data): lam = lam_dev.get() check_roe_identity(data.state_pair, R, R_inv) - check_roe_property(data.state_pair, data.flux_pair, R, R_inv, lam) + check_roe_property(data.state_pair, data.generalized_flux_pair, R, R_inv, lam) @pytest.mark.parametrize("lam_pointwise_str,lam_roe_str,lam_expected_str", [ diff --git a/test/test_flux_window_ops.py b/test/test_flux_window_ops.py index 0f4742a4822cc5e977cb7cc64fca43d05d0834be..4bdb27ec925db6dda7cb451d36c812c528b3a4f4 100644 --- a/test/test_flux_window_ops.py +++ b/test/test_flux_window_ops.py @@ -35,7 +35,8 @@ import pytest import utilities as u import weno_reference_implementation as ref -from data_for_test import PairData, window_data, metrics_generator +from data_for_test import ( + PairData, window_data, states_generator, metrics_generator) class WindowResults: @@ -48,7 +49,6 @@ class WindowResults: self.dir_internal = data.dir_internal self.states = data.states - self.fluxes = data.fluxes self.state_pair = pair.state_pair self.metrics = data.metrics @@ -58,6 +58,10 @@ class WindowResults: self.frozen_jacobian = pair.frozen_jacobian self.combined_frozen_metric = pair.combined_frozen_metrics[self.dir_internal] + self.generalized_fluxes = data.generalized_fluxes + self.generalized_fluxes_frozen = np.array([np.dot(flux, self.frozen_metrics) + for flux in data.fluxes])[:,:,self.dir_internal].T.copy(order="F") + self.lam_pointwise = ref.lambda_pointwise( self.states, self.metrics, self.dir_internal) self.R, self.R_inv, self.lam_roe = ref.roe_eigensystem( @@ -77,7 +81,7 @@ class WindowResults: self.weno_weights_neg = ref.weno_weights( self.oscillation_neg, self.combined_frozen_metric) - self.consistent = ref.consistent_part(self.fluxes) + self.consistent = ref.consistent_part(self.generalized_fluxes) self.dissipation_pos = ref.dissipation_part( self.R, self.char_fluxes_pos, self.weno_weights_pos, 1) self.dissipation_neg = ref.dissipation_part( @@ -115,7 +119,7 @@ def test_flux_splitting(queue, window_results): prg(queue, nvars=data.nvars, generalized_states_frozen=data.states, - generalized_fluxes_frozen=data.fluxes, + generalized_fluxes_frozen=data.generalized_fluxes_frozen, R_inv=data.R_inv, wavespeeds=data.wavespeeds, characteristic_fluxes_pos=fluxes_pos_dev, @@ -133,7 +137,7 @@ def test_weno_flux(queue, window_results): flux_dev = u.empty_array_on_device(queue, data.nvars) prg(queue, nvars=data.nvars, - generalized_fluxes=data.fluxes, + generalized_fluxes=data.generalized_fluxes, characteristic_fluxes_pos=data.char_fluxes_pos, characteristic_fluxes_neg=data.char_fluxes_neg, combined_frozen_metric=data.combined_frozen_metric, @@ -152,7 +156,7 @@ def test_consistent_part(queue, window_results): consistent_dev = u.empty_array_on_device(queue, data.nvars) prg(queue, nvars=data.nvars, - generalized_fluxes=data.fluxes, + generalized_fluxes=data.generalized_fluxes, consistent=consistent_dev) u.compare_arrays(consistent_dev.get(), data.consistent)