def state(n: np.ndarray, intensive: dict, extensive: dict, cell_id, cell_origin, position_in_cell,
particles) -> TestableState:
assert StateFactory.check_args(n, intensive, extensive)
sd_num = len(n)
attributes, keys = StateFactory.init_attributes_and_keys(particles, intensive, extensive, sd_num)
state = TestableState(n, attributes, keys, cell_id, cell_origin, position_in_cell, particles)
state.recalculate_cell_id()
return state
def state(n: np.ndarray, intensive: dict, extensive: dict, cell_id, cell_origin, position_in_cell,
particles) -> TestableState:
assert StateFactory.check_args(n, intensive, extensive)
sd_num = len(n)
attributes, keys, intensive_start = StateFactory.init_attributes_and_keys(particles, intensive, extensive, sd_num)
if particles.mesh is not None:
cell_start = np.empty(particles.mesh.n_cell + 1, dtype=int)
else:
cell_start = np.empty(0)
state = TestableState(n, attributes, keys, intensive_start,
cell_id, cell_start, cell_origin, position_in_cell, particles)
state.recalculate_cell_id()
return state
def test_calculate_displacement(self):
# Arrange
n = np.ones(1)
grid = (1, 1)
particles = DummyParticles(Default, n_sd=len(n))
particles.set_mesh(grid)
a = .1
b = .2
w = .25
particles.set_environment(
DummyEnvironment, ((np.array([[a, b]]).T, np.array([[0, 0]])), ))
positions = Default.from_ndarray(np.array([[w, 0]]))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
particles.state = StateFactory.state(n=n,
intensive={},
extensive={},
cell_id=cell_id,
cell_origin=cell_origin,
position_in_cell=position_in_cell,
particles=particles)
sut = Advection(particles=particles, scheme='FTFS')
# Act
sut.calculate_displacement(sut.displacement, sut.courant,
particles.state.cell_origin,
particles.state.position_in_cell)
# Assert
np.testing.assert_equal(sut.displacement[0, 0], (1 - w) * a + w * b)
def test_boundary_condition(self):
# Arrange
n = np.ones(1)
grid = (1, 1)
particles = DummyParticles(Default, n_sd=len(n))
particles.set_mesh(grid)
particles.set_environment(
DummyEnvironment, ((np.array([[0, 0]]).T, np.array([[0, 0]])), ))
droplet_id = 0
positions = Default.from_ndarray(np.array([[0, 0]]))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
particles.state = StateFactory.state(n=n,
intensive={},
extensive={},
cell_id=cell_id,
cell_origin=cell_origin,
position_in_cell=position_in_cell,
particles=particles)
sut = Advection(particles=particles)
state = particles.state
state.cell_origin[droplet_id, 0] = 1.1
state.cell_origin[droplet_id, 1] = 1.2
# Act
sut.boundary_condition(state.cell_origin)
# Assert
assert state.cell_origin[droplet_id, 0] == 0
assert state.cell_origin[droplet_id, 1] == 0
def test_update_position(self):
# Arrange
n = np.ones(1)
grid = (1, 1)
particles = DummyParticles(Default, n_sd=len(n))
particles.set_mesh(grid)
particles.set_environment(
DummyEnvironment, ((np.array([[0, 0]]).T, np.array([[0, 0]])), ))
droplet_id = 0
px = .1
py = .2
positions = Default.from_ndarray(np.array([[px, py]]))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
particles.state = StateFactory.state(n=n,
intensive={},
extensive={},
cell_id=cell_id,
cell_origin=cell_origin,
position_in_cell=position_in_cell,
particles=particles)
sut = Advection(particles=particles)
sut.displacement[droplet_id, 0] = .1
sut.displacement[droplet_id, 1] = .2
# Act
sut.update_position(particles.state.position_in_cell, sut.displacement)
# Assert
for d in range(2):
assert particles.state.position_in_cell[droplet_id, d] == (
positions[droplet_id, d] + sut.displacement[droplet_id, d])
def test_boundary_condition(self):
# Arrange
n = np.ones(1, dtype=np.int64)
grid = (1, 1)
particles = DummyParticles(Default, n_sd=len(n), dt=1)
particles.set_mesh(grid)
particles.set_environment(
DummyEnvironment, ((np.array([[0, 0]]).T, np.array([[0, 0]])), ))
positions = Default.from_ndarray(np.array([[0, 0]]))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
particles.state = StateFactory.state(n=n,
intensive={},
extensive={},
cell_id=cell_id,
cell_origin=cell_origin,
position_in_cell=position_in_cell,
particles=particles)
sut = Displacement(particles=particles, sedimentation=True)
particles.set_terminal_velocity(ConstantTerminalVelocity)
# Act
sut()
# Assert
assert particles.state.SD_num == 0
def create_state_2d(self, extensive, intensive, spatial_discretisation,
spectral_discretisation, spectrum_per_mass_of_dry_air,
r_range, kappa, radius_threshold):
assert_not_none(self.particles.mesh, self.particles.environment)
assert_none(self.particles.state)
with np.errstate(all='raise'):
positions = spatial_discretisation(self.particles.mesh.grid,
self.particles.n_sd)
cell_id, cell_origin, position_in_cell = self.particles.mesh.cellular_attributes(
positions)
r_dry, n_per_kg = spectral_discretisation(
self.particles.n_sd, spectrum_per_mass_of_dry_air, r_range)
r_wet = r_wet_init(r_dry, self.particles.environment, cell_id,
kappa)
n_per_m3 = n_init(n_per_kg, self.particles.environment,
self.particles.mesh, cell_id)
n = discretise_n(n_per_m3)
extensive['volume'] = phys.volume(radius=r_wet)
extensive['dry volume'] = phys.volume(radius=r_dry)
self.particles.state = StateFactory.state(n, intensive, extensive,
cell_id, cell_origin,
position_in_cell,
self.particles)
for product in [
TotalParticleConcentration(self.particles),
TotalParticleSpecificConcentration(self.particles),
AerosolConcentration(self.particles, radius_threshold),
AerosolSpecificConcentration(self.particles, radius_threshold),
ParticleMeanRadius(self.particles),
SuperDropletCount(self.particles)
]:
self.register_product(product)
def create_state_0d(self, n, extensive, intensive):
n = discretise_n(n)
assert_not_none(self.particles.mesh)
assert_none(self.particles.state)
cell_id = np.zeros_like(n, dtype=np.int64)
self.particles.state = StateFactory.state(n=n,
intensive=intensive,
extensive=extensive,
cell_id=cell_id,
cell_origin=None,
position_in_cell=None,
particles=self.particles)
def create_state_2d(self, extensive, intensive, spatial_discretisation, spectral_discretisation,
spectrum_per_mass_of_dry_air, r_range, kappa):
assert_not_none(self.mesh, self.environment)
assert_none(self.state)
with np.errstate(all='raise'):
positions = spatial_discretisation(self.mesh.grid, self.n_sd)
cell_id, cell_origin, position_in_cell = self.mesh.cellular_attributes(positions)
r_dry, n_per_kg = spectral_discretisation(self.n_sd, spectrum_per_mass_of_dry_air, r_range)
r_wet = r_wet_init(r_dry, self.environment, cell_id, kappa)
n_per_m3 = n_init(n_per_kg, self, cell_id)
n = discretise_n(n_per_m3)
extensive['volume'] = phys.volume(radius=r_wet)
extensive['dry volume'] = phys.volume(radius=r_dry)
self.state = StateFactory.state(n, intensive, extensive, cell_id, cell_origin, position_in_cell, self)
def test_advection(self):
n = np.ones(1)
grid = (3, 3)
particles = DummyParticles(Default, n_sd=len(n))
particles.set_mesh(grid)
particles.set_environment(DummyEnvironment, ((np.ones(
(4, 3)), np.zeros((3, 4))), ))
positions = Default.from_ndarray(np.array([[1.5, 1.5]]))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
particles.state = StateFactory.state(n=n,
intensive={},
extensive={},
cell_id=cell_id,
cell_origin=cell_origin,
position_in_cell=position_in_cell,
particles=particles)
sut = Advection(particles=particles)
sut()
np.testing.assert_array_equal(particles.state.cell_origin[0, :],
np.array([2, 1]))
def test_single_cell(self):
# Arrange
n = np.ones(1)
grid = (1, 1)
particles = DummyParticles(Default, n_sd=len(n))
particles.set_mesh(grid)
particles.set_environment(
DummyEnvironment,
((np.array([[.1, .2]]).T, np.array([[.3, .4]])), ))
positions = Default.from_ndarray(np.array([[0.5, 0.5]]))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
particles.state = StateFactory.state(n=n,
intensive={},
extensive={},
cell_id=cell_id,
cell_origin=cell_origin,
position_in_cell=position_in_cell,
particles=particles)
sut = Advection(particles=particles)
# Act
sut()
