def test_export(backend_class, tmp_path): # Arrange settings = Settings() settings.simulation_time = settings.dt settings.output_interval = settings.dt storage = Storage() simulator = Simulation(settings, storage, SpinUp=SpinUp, backend_class=backend_class) _, temp_file = tempfile.mkstemp(dir=tmp_path, suffix='.nc') sut = NetCDFExporter(storage, settings, simulator, temp_file) vtk_exporter = VTKExporter(path=tmp_path) simulator.reinit() simulator.run(vtk_exporter=vtk_exporter) vtk_exporter.write_pvd() # Act sut.run(controller=DummyController()) # Assert filenames_list = os.listdir(os.path.join(tmp_path, 'output')) assert len(list(filter(lambda x: x.endswith('.pvd'), filenames_list))) > 0 assert len(list(filter(lambda x: x.endswith('.vts'), filenames_list))) > 0 assert len(list(filter(lambda x: x.endswith('.vtu'), filenames_list))) > 0
def test_spin_up(backend, fastmath, plot=False): # Arrange settings = Settings(fastmath=fastmath) settings.dt = .5 * si.second settings.grid = (3, 25) settings.simulation_time = 20 * settings.dt settings.output_interval = 1 * settings.dt storage = DummyStorage() simulation = Simulation(settings, storage, SpinUp=SpinUp, backend=backend) simulation.reinit() # Act simulation.run() # Plot if plot: levels = np.arange(settings.grid[1]) for step, datum in enumerate(storage.profiles): pyplot.plot(datum["qv_env"], levels, label=str(step)) pyplot.legend() pyplot.show() # Assert step_num = len(storage.profiles) - 1 for step in range(step_num): next = storage.profiles[step + 1]["qv_env"] prev = storage.profiles[step]["qv_env"] eps = 1e-3 assert ((prev + eps) >= next).all() assert storage.profiles[step_num]["qv_env"][-1] < 7.1
def test_just_do_it(): settings = ColdCumulus() settings.kappa = 0 for process in settings.processes.keys(): settings.processes[process] = False settings.processes['particle advection'] += 1 settings.processes['fluid advection'] += 1 simulation = Simulation(settings, Storage(), None) simulation.reinit() simulation.run(controller=FlowFieldAsserts(simulation))
def main(): settings = Settings(Formulae()) settings.n_sd_per_gridbox = 25 settings.grid = (25, 25) settings.simulation_time = 5400 * si.second storage = Storage() simulation = Simulation(settings, storage, SpinUp) simulation.reinit() simulation.run() temp_file = TemporaryFile(".nc") exporter = NetCDFExporter(storage, settings, simulation, temp_file.absolute_path) exporter.run(controller=DummyController())
def test_freezing(singular): # Arrange settings = Settings( Formulae(seed=44, condensation_coordinate='VolumeLogarithm', fastmath=True, freezing_temperature_spectrum='Niemand_et_al_2012', heterogeneous_ice_nucleation_rate='ABIFM', constants={ 'NIEMAND_A': -0.517, 'NIEMAND_B': 8.934, 'ABIFM_M': 28.13797, 'ABIFM_C': -2.92414 })) settings.dt = .5 * si.second settings.grid = (5, 15) settings.n_sd_per_gridbox = 64 settings.simulation_time = 100 * settings.dt settings.spin_up_time = 10 * settings.dt settings.output_interval = settings.dt # settings.simulation_time settings.processes['freezing'] = True settings.processes['coalescence'] = False settings.freezing_singular = singular settings.th_std0 -= 35 * si.K settings.qv0 -= 7.15 * si.g / si.kg storage = DummyStorage() simulation = Simulation(settings, storage, SpinUp=SpinUp, backend_class=CPU) simulation.reinit() # Act simulation.run() # Assert assert (simulation.products['ice water content'].get() > 0).any()
def main(): settings = Settings(Formulae()) settings.grid = (25, 25) settings.simulation_time = settings.dt * 100 settings.output_interval = settings.dt * 10 settings.processes = { "particle advection": True, "fluid advection": True, "coalescence": True, "condensation": False, "sedimentation": True, "freezing": False, } n_sd = range(14, 16, 1) times = {} backends = [(CPU, "sync"), (CPU, "async")] if GPU.ENABLE: backends.append((GPU, "async")) for backend, mode in backends: if backend is CPU: PySDM.backends.impl_numba.conf.NUMBA_PARALLEL = mode reload_cpu_backend() key = f"{backend} (mode={mode})" times[key] = [] for sd in n_sd: settings.n_sd_per_gridbox = sd storage = Storage() simulation = Simulation(settings, storage, None, backend) simulation.reinit(products=[WallTime()]) simulation.run() times[key].append(storage.load("wall time")[-1]) for parallelization, t in times.items(): plt.plot(n_sd, t, label=parallelization) plt.legend() plt.loglog() plt.savefig("benchmark.pdf", format="pdf")
def test_environment(): # Arrange settings = Settings() settings.simulation_time = -1 * settings.dt simulation = Simulation(settings, None, SpinUp=SpinUp) simulation.reinit() # Act simulation.run() rhod = simulation.particulator.environment["rhod"].to_ndarray().reshape( settings.grid) # Assert - same in all columns for column in range(settings.grid[0]): np.testing.assert_array_equal(rhod[column, :], rhod[0, :]) # Assert - decreasing with altitude rhod_below = 2 * si.kilograms / si.metre**3 for level in range(settings.grid[1]): rhod_above = rhod[0, level] assert rhod_above < rhod_below rhod_below = rhod_above
def test_initialisation(backend, plot=False): settings = Settings() settings.simulation_time = -1 * settings.dt settings.grid = (10, 5) settings.n_sd_per_gridbox = 5000 simulation = Simulation(settings, None, SpinUp=SpinUp, backend=backend) n_levels = settings.grid[1] n_cell = int(np.prod(np.array(settings.grid))) n_moments = 1 r_bins = settings.r_bins_edges histogram_dry = np.empty((len(r_bins) - 1, n_levels)) histogram_wet = np.empty_like(histogram_dry) moment_0 = backend.Storage.empty(n_cell, dtype=int) moments = backend.Storage.empty((n_moments, n_cell), dtype=float) tmp = np.empty(n_cell) simulation.reinit() # Act (moments) simulation.run() particulator = simulation.particulator environment = simulation.particulator.environment rhod = environment["rhod"].to_ndarray().reshape(settings.grid).mean(axis=0) v_bins = settings.formulae.trivia.volume(settings.r_bins_edges) for i in range(len(histogram_dry)): particulator.attributes.moments(moment_0, moments, specs={}, attr_name='dry volume', attr_range=(v_bins[i], v_bins[i + 1])) moment_0.download(tmp) histogram_dry[i, :] = tmp.reshape(settings.grid).sum( axis=0) / (particulator.mesh.dv * settings.grid[0]) particulator.attributes.moments(moment_0, moments, specs={}, attr_name='volume', attr_range=(v_bins[i], v_bins[i + 1])) moment_0.download(tmp) histogram_wet[i, :] = tmp.reshape(settings.grid).sum( axis=0) / (particulator.mesh.dv * settings.grid[0]) # Plot if plot: for level in range(0, n_levels): color = str(.75 * (level / (n_levels - 1))) pyplot.step(r_bins[:-1] * si.metres / si.micrometres, histogram_dry[:, level] / si.metre**3 * si.centimetre**3, where='post', color=color, label="level " + str(level)) pyplot.step(r_bins[:-1] * si.metres / si.micrometres, histogram_wet[:, level] / si.metre**3 * si.centimetre**3, where='post', color=color, linestyle='--') pyplot.grid() pyplot.xscale('log') pyplot.xlabel('particle radius [µm]') pyplot.ylabel('concentration per bin [cm^{-3}]') pyplot.legend() pyplot.show() # Assert - total number for level in reversed(range(n_levels)): mass_conc_dry = np.sum(histogram_dry[:, level]) / rhod[level] mass_conc_wet = np.sum(histogram_wet[:, level]) / rhod[level] mass_conc_STP = settings.spectrum_per_mass_of_dry_air.norm_factor assert .5 * mass_conc_STP < mass_conc_dry < 1.5 * mass_conc_STP np.testing.assert_approx_equal(mass_conc_dry, mass_conc_wet, significant=5) # Assert - decreasing number density total_above = 0 for level in reversed(range(n_levels)): total_below = np.sum(histogram_dry[:, level]) # TODO #607 # assert total_below > total_above total_above = total_below