Data

Tools

Indexes

Applications

Experiments

Open Source Science

https://github.com/cambridge-iccs/pysdm

Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab

https://github.com/cambridge-iccs/pysdm

Science Score: 23.0%

This score indicates how likely this project is to be science-related based on various indicators:

  • ○
    CITATION.cff file
  • ○
    codemeta.json file
  • ○
    .zenodo.json file
  • ✓
    DOI references
    Found 7 DOI reference(s) in README
  • ✓
    Academic publication links
    Links to: wiley.com, joss.theoj.org, zenodo.org
  • ○
    Academic email domains
  • ○
    Institutional organization owner
  • ○
    JOSS paper metadata
  • ○
    Scientific vocabulary similarity
    Low similarity (4.6%) to scientific vocabulary
Last synced: 10 months ago · JSON representation

Repository

Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab

Basic Info
  • Host: GitHub
  • Owner: Cambridge-ICCS
  • License: gpl-3.0
  • Default Branch: main
  • Homepage:
  • Size: 18 MB
Statistics
  • Stars: 0
  • Watchers: 0
  • Forks: 0
  • Open Issues: 1
  • Releases: 0
Fork of open-atmos/PySDM
Created almost 3 years ago · Last pushed almost 3 years ago
Metadata Files
Readme License

README.md

PySDM

Python 3 LLVM CUDA Linux OK macOS OK Windows OK Jupyter Maintenance OpenHub status DOI
EU Funding PL Funding US Funding

License: GPL v3

Github Actions Build Status Appveyor Build status Coverage Status
PyPI version API docs

PySDM is a package for simulating the dynamics of population of particles. It is intended to serve as a building block for simulation systems modelling fluid flows involving a dispersed phase, with PySDM being responsible for representation of the dispersed phase. Currently, the development is focused on atmospheric cloud physics applications, in particular on modelling the dynamics of particles immersed in moist air using the particle-based (a.k.a. super-droplet) approach to represent aerosol/cloud/rain microphysics. The package features a Pythonic high-performance implementation of the Super-Droplet Method (SDM) Monte-Carlo algorithm for representing collisional growth (Shima et al. 2009), hence the name.

There is a growing set of example Jupyter notebooks exemplifying how to perform various types of calculations and simulations using PySDM. Most of the example notebooks reproduce resutls and plot from literature, see below for a list of examples and links to the notebooks (which can be either executed or viewed "in the cloud").

PySDM has two alternative parallel number-crunching backends available: multi-threaded CPU backend based on Numba and GPU-resident backend built on top of ThrustRTC. The Numba backend (aliased CPU) features multi-threaded parallelism for multi-core CPUs, it uses the just-in-time compilation technique based on the LLVM infrastructure. The ThrustRTC backend (aliased GPU) offers GPU-resident operation of PySDM leveraging the SIMT parallelisation model. Using the GPU backend requires nVidia hardware and CUDA driver.

For an overview of PySDM features (and the preferred way to cite PySDM in papers), please refer to our JOSS paper: - Bartman et al. 2022 (PySDM v1). - de Jong et al. 2023 (PySDM v2). For a list of talks and other materials on PySDM, see the project wiki.

A pdoc-generated documentation of PySDM public API is maintained at: https://open-atmos.github.io/PySDM

Example Jupyter notebooks (reproducing results from literature):

See PySDM-examples README.

animation

Dependencies and Installation

PySDM dependencies are: Numpy, Numba, SciPy, Pint, chempy, pyevtk, ThrustRTC and CURandRTC.

To install PySDM using pip, use: pip install PySDM (or pip install git+https://github.com/open-atmos/PySDM.git to get updates beyond the latest release).

Conda users may use pip as well, see the Installing non-conda packages section in the conda docs. Dependencies of PySDM are available at the following conda channels: - numba: numba - conda-forge: pyevtk, pint and - fyplus: ThrustRTC, CURandRTC - bjodah: chempy - nvidia: cudatoolkit

For development purposes, we suggest cloning the repository and installing it using pip -e. Test-time dependencies can be installed with pip -e .[tests].

PySDM examples constitute the PySDM-examples package. The examples have additional dependencies listed in PySDM_examples package setup.py file. Running the example Jupyter notebooks requires the PySDM_examples package to be installed. The suggested install and launch steps are: git clone https://github.com/open-atmos/PySDM.git cd examples pip install -e . jupyter-notebook Alternatively, one can also install the examples package from pypi.org by using pip install PySDM-examples (note that this does not apply to notebooks itself, only the supporting .py files).

Hello-world coalescence example in Python, Julia and Matlab

In order to depict the PySDM API with a practical example, the following listings provide sample code roughly reproducing the Figure 2 from Shima et al. 2009 paper using PySDM from Python, Julia and Matlab. It is a Coalescence-only set-up in which the initial particle size spectrum is Exponential and is deterministically sampled to match the condition of each super-droplet having equal initial multiplicity:

Julia (click to expand)

```Julia using Pkg Pkg.add("PyCall") Pkg.add("Plots") Pkg.add("PlotlyJS")

using PyCall si = pyimport("PySDM.physics").si ConstantMultiplicity = pyimport("PySDM.initialisation.sampling.spectral_sampling").ConstantMultiplicity Exponential = pyimport("PySDM.initialisation.spectra").Exponential

nsd = 2^15 initialspectrum = Exponential(normfactor=8.39e12, scale=1.19e5 * si.um^3) attributes = Dict() attributes["volume"], attributes["n"] = ConstantMultiplicity(spectrum=initialspectrum).sample(n_sd) ```

Matlab (click to expand)

```Matlab si = py.importlib.importmodule('PySDM.physics').si; ConstantMultiplicity = py.importlib.importmodule('PySDM.initialisation.sampling.spectralsampling').ConstantMultiplicity; Exponential = py.importlib.importmodule('PySDM.initialisation.spectra').Exponential;

nsd = 2^15; initialspectrum = Exponential(pyargs(... 'normfactor', 8.39e12, ... 'scale', 1.19e5 * si.um ^ 3 ... )); tmp = ConstantMultiplicity(initialspectrum).sample(int32(n_sd)); attributes = py.dict(pyargs('volume', tmp{1}, 'n', tmp{2})); ```

Python (click to expand)

```Python from PySDM.physics import si from PySDM.initialisation.sampling.spectral_sampling import ConstantMultiplicity from PySDM.initialisation.spectra.exponential import Exponential

nsd = 2 ** 15 initialspectrum = Exponential(normfactor=8.39e12, scale=1.19e5 * si.um ** 3) attributes = {} attributes['volume'], attributes['n'] = ConstantMultiplicity(initialspectrum).sample(n_sd) ```

The key element of the PySDM interface is the Particulator class instances of which are used to manage the system state and control the simulation. Instantiation of the Particulator class is handled by the Builder as exemplified below:

Julia (click to expand)

```Julia Builder = pyimport("PySDM").Builder Box = pyimport("PySDM.environments").Box Coalescence = pyimport("PySDM.dynamics").Coalescence Golovin = pyimport("PySDM.dynamics.collisions.collision_kernels").Golovin CPU = pyimport("PySDM.backends").CPU ParticleVolumeVersusRadiusLogarithmSpectrum = pyimport("PySDM.products").ParticleVolumeVersusRadiusLogarithmSpectrum

radiusbinsedges = 10 .^ range(log10(10si.um), log10(5e3si.um), length=32)

builder = Builder(nsd=nsd, backend=CPU()) builder.setenvironment(Box(dt=1 * si.s, dv=1e6 * si.m^3)) builder.adddynamic(Coalescence(collisionkernel=Golovin(b=1.5e3 / si.s))) products = [ParticleVolumeVersusRadiusLogarithmSpectrum(radiusbinsedges=radiusbins_edges, name="dv/dlnr")] particulator = builder.build(attributes, products) ```

Matlab (click to expand)

```Matlab Builder = py.importlib.importmodule('PySDM').Builder; Box = py.importlib.importmodule('PySDM.environments').Box; Coalescence = py.importlib.importmodule('PySDM.dynamics').Coalescence; Golovin = py.importlib.importmodule('PySDM.dynamics.collisions.collisionkernels').Golovin; CPU = py.importlib.importmodule('PySDM.backends').CPU; ParticleVolumeVersusRadiusLogarithmSpectrum = py.importlib.import_module('PySDM.products').ParticleVolumeVersusRadiusLogarithmSpectrum;

radiusbinsedges = logspace(log10(10 * si.um), log10(5e3 * si.um), 32);

builder = Builder(pyargs('nsd', int32(nsd), 'backend', CPU())); builder.setenvironment(Box(pyargs('dt', 1 * si.s, 'dv', 1e6 * si.m ^ 3))); builder.adddynamic(Coalescence(pyargs('collisionkernel', Golovin(1.5e3 / si.s)))); products = py.list({ ParticleVolumeVersusRadiusLogarithmSpectrum(pyargs( ... 'radiusbinsedges', py.numpy.array(radiusbins_edges), ... 'name', 'dv/dlnr' ... )) }); particulator = builder.build(attributes, products); ```

Python (click to expand)

```Python import numpy as np from PySDM import Builder from PySDM.environments import Box from PySDM.dynamics import Coalescence from PySDM.dynamics.collisions.collision_kernels import Golovin from PySDM.backends import CPU from PySDM.products import ParticleVolumeVersusRadiusLogarithmSpectrum

radiusbinsedges = np.logspace(np.log10(10 * si.um), np.log10(5e3 * si.um), num=32)

builder = Builder(nsd=nsd, backend=CPU()) builder.setenvironment(Box(dt=1 * si.s, dv=1e6 * si.m ** 3)) builder.adddynamic(Coalescence(collisionkernel=Golovin(b=1.5e3 / si.s))) products = [ParticleVolumeVersusRadiusLogarithmSpectrum(radiusbinsedges=radiusbins_edges, name='dv/dlnr')] particulator = builder.build(attributes, products) ```

The backend argument may be set to CPU or GPU what translates to choosing the multi-threaded backend or the GPU-resident computation mode, respectively. The employed Box environment corresponds to a zero-dimensional framework (particle positions are not considered). The vectors of particle multiplicities n and particle volumes v are used to initialise super-droplet attributes. The Coalescence Monte-Carlo algorithm (Super Droplet Method) is registered as the only dynamic in the system. Finally, the build() method is used to obtain an instance of Particulator which can then be used to control time-stepping and access simulation state.

The run(nt) method advances the simulation by nt timesteps. In the listing below, its usage is interleaved with plotting logic which displays a histogram of particle mass distribution at selected timesteps:

Julia (click to expand)

```Julia rhow = pyimport("PySDM.physics.constantsdefaults").rho_w using Plots; plotlyjs()

for step = 0:1200:3600 particulator.run(step - particulator.nsteps) plot!( radiusbinsedges[1:end-1] / si.um, particulator.products["dv/dlnr"].get()[:] * rhow / si.g, linetype=:steppost, xaxis=:log, xlabel="particle radius [µm]", ylabel="dm/dlnr [g/m^3/(unit dr/r)]", label="t = $step s" )
end savefig("plot.svg") ```

Matlab (click to expand)

```Matlab rhow = py.importlib.importmodule('PySDM.physics.constantsdefaults').rhow;

for step = 0:1200:3600 particulator.run(int32(step - particulator.nsteps)); x = radiusbinsedges / si.um; y = particulator.products{"dv/dlnr"}.get() * rhow / si.g; stairs(... x(1:end-1), ... double(py.array.array('d',py.numpy.nditer(y))), ... 'DisplayName', sprintf("t = %d s", step) ... ); hold on end hold off set(gca,'XScale','log'); xlabel('particle radius [µm]') ylabel("dm/dlnr [g/m^3/(unit dr/r)]") legend() ```

Python (click to expand)

```Python from PySDM.physics.constantsdefaults import rhow from matplotlib import pyplot

for step in [0, 1200, 2400, 3600]: particulator.run(step - particulator.nsteps) pyplot.step(x=radiusbinsedges[:-1] / si.um, y=particulator.products['dv/dlnr'].get()[0] * rhow / si.g, where='post', label=f"t = {step}s")

pyplot.xscale('log') pyplot.xlabel('particle radius [µm]') pyplot.ylabel("dm/dlnr [g/m$^3$/(unit dr/r)]") pyplot.legend() pyplot.savefig('readme.png') ```

The resultant plot (generated with the Python code) looks as follows:

plot

Hello-world condensation example in Python, Julia and Matlab

In the following example, a condensation-only setup is used with the adiabatic Parcel environment. An initial Lognormal spectrum of dry aerosol particles is first initialised to equilibrium wet size for the given initial humidity. Subsequent particle growth due to Condensation of water vapour (coupled with the release of latent heat) causes a subset of particles to activate into cloud droplets. Results of the simulation are plotted against vertical ParcelDisplacement and depict the evolution of PeakSupersaturation, EffectiveRadius, ParticleConcentration and the WaterMixingRatio.

Julia (click to expand) ```Julia using PyCall using Plots; plotlyjs() si = pyimport("PySDM.physics").si spectral_sampling = pyimport("PySDM.initialisation.sampling").spectral_sampling discretise_multiplicities = pyimport("PySDM.initialisation").discretise_multiplicities Lognormal = pyimport("PySDM.initialisation.spectra").Lognormal equilibrate_wet_radii = pyimport("PySDM.initialisation").equilibrate_wet_radii CPU = pyimport("PySDM.backends").CPU AmbientThermodynamics = pyimport("PySDM.dynamics").AmbientThermodynamics Condensation = pyimport("PySDM.dynamics").Condensation Parcel = pyimport("PySDM.environments").Parcel Builder = pyimport("PySDM").Builder Formulae = pyimport("PySDM").Formulae products = pyimport("PySDM.products") env = Parcel( dt=.25 * si.s, mass_of_dry_air=1e3 * si.kg, p0=1122 * si.hPa, q0=20 * si.g / si.kg, T0=300 * si.K, w= 2.5 * si.m / si.s ) spectrum = Lognormal(norm_factor=1e4/si.mg, m_mode=50*si.nm, s_geom=1.4) kappa = .5 * si.dimensionless cloud_range = (.5 * si.um, 25 * si.um) output_interval = 4 output_points = 40 n_sd = 256 formulae = Formulae() builder = Builder(backend=CPU(formulae), n_sd=n_sd) builder.set_environment(env) builder.add_dynamic(AmbientThermodynamics()) builder.add_dynamic(Condensation()) r_dry, specific_concentration = spectral_sampling.Logarithmic(spectrum).sample(n_sd) v_dry = formulae.trivia.volume(radius=r_dry) r_wet = equilibrate_wet_radii(r_dry=r_dry, environment=env, kappa_times_dry_volume=kappa * v_dry) attributes = Dict() attributes["n"] = discretise_multiplicities(specific_concentration * env.mass_of_dry_air) attributes["dry volume"] = v_dry attributes["kappa times dry volume"] = kappa * v_dry attributes["volume"] = formulae.trivia.volume(radius=r_wet) particulator = builder.build(attributes, products=[ products.PeakSupersaturation(name="S_max", unit="%"), products.EffectiveRadius(name="r_eff", unit="um", radius_range=cloud_range), products.ParticleConcentration(name="n_c_cm3", unit="cm^-3", radius_range=cloud_range), products.WaterMixingRatio(name="ql", unit="g/kg", radius_range=cloud_range), products.ParcelDisplacement(name="z") ]) cell_id=1 output = Dict() for (_, product) in particulator.products output[product.name] = Array{Float32}(undef, output_points+1) output[product.name][1] = product.get()[cell_id] end for step = 2:output_points+1 particulator.run(steps=output_interval) for (_, product) in particulator.products output[product.name][step] = product.get()[cell_id] end end plots = [] ylbl = particulator.products["z"].unit for (_, product) in particulator.products if product.name != "z" append!(plots, [plot(output[product.name], output["z"], ylabel=ylbl, xlabel=product.unit, title=product.name)]) end global ylbl = "" end plot(plots..., layout=(1, length(output)-1)) savefig("parcel.svg") ```
Matlab (click to expand) ```Matlab si = py.importlib.import_module('PySDM.physics').si; spectral_sampling = py.importlib.import_module('PySDM.initialisation.sampling').spectral_sampling; discretise_multiplicities = py.importlib.import_module('PySDM.initialisation').discretise_multiplicities; Lognormal = py.importlib.import_module('PySDM.initialisation.spectra').Lognormal; equilibrate_wet_radii = py.importlib.import_module('PySDM.initialisation').equilibrate_wet_radii; CPU = py.importlib.import_module('PySDM.backends').CPU; AmbientThermodynamics = py.importlib.import_module('PySDM.dynamics').AmbientThermodynamics; Condensation = py.importlib.import_module('PySDM.dynamics').Condensation; Parcel = py.importlib.import_module('PySDM.environments').Parcel; Builder = py.importlib.import_module('PySDM').Builder; Formulae = py.importlib.import_module('PySDM').Formulae; products = py.importlib.import_module('PySDM.products'); env = Parcel(pyargs( ... 'dt', .25 * si.s, ... 'mass_of_dry_air', 1e3 * si.kg, ... 'p0', 1122 * si.hPa, ... 'q0', 20 * si.g / si.kg, ... 'T0', 300 * si.K, ... 'w', 2.5 * si.m / si.s ... )); spectrum = Lognormal(pyargs('norm_factor', 1e4/si.mg, 'm_mode', 50 * si.nm, 's_geom', 1.4)); kappa = .5; cloud_range = py.tuple({.5 * si.um, 25 * si.um}); output_interval = 4; output_points = 40; n_sd = 256; formulae = Formulae(); builder = Builder(pyargs('backend', CPU(formulae), 'n_sd', int32(n_sd))); builder.set_environment(env); builder.add_dynamic(AmbientThermodynamics()); builder.add_dynamic(Condensation()); tmp = spectral_sampling.Logarithmic(spectrum).sample(int32(n_sd)); r_dry = tmp{1}; v_dry = formulae.trivia.volume(pyargs('radius', r_dry)); specific_concentration = tmp{2}; r_wet = equilibrate_wet_radii(pyargs(... 'r_dry', r_dry, ... 'environment', env, ... 'kappa_times_dry_volume', kappa * v_dry... )); attributes = py.dict(pyargs( ... 'n', discretise_multiplicities(specific_concentration * env.mass_of_dry_air), ... 'dry volume', v_dry, ... 'kappa times dry volume', kappa * v_dry, ... 'volume', formulae.trivia.volume(pyargs('radius', r_wet)) ... )); particulator = builder.build(attributes, py.list({ ... products.PeakSupersaturation(pyargs('name', 'S_max', 'unit', '%')), ... products.EffectiveRadius(pyargs('name', 'r_eff', 'unit', 'um', 'radius_range', cloud_range)), ... products.ParticleConcentration(pyargs('name', 'n_c_cm3', 'unit', 'cm^-3', 'radius_range', cloud_range)), ... products.WaterMixingRatio(pyargs('name', 'ql', 'unit', 'g/kg', 'radius_range', cloud_range)) ... products.ParcelDisplacement(pyargs('name', 'z')) ... })); cell_id = int32(0); output_size = [output_points+1, length(py.list(particulator.products.keys()))]; output_types = repelem({'double'}, output_size(2)); output_names = [cellfun(@string, cell(py.list(particulator.products.keys())))]; output = table(... 'Size', output_size, ... 'VariableTypes', output_types, ... 'VariableNames', output_names ... ); for pykey = py.list(keys(particulator.products)) get = py.getattr(particulator.products{pykey{1}}.get(), '__getitem__'); key = string(pykey{1}); output{1, key} = get(cell_id); end for i=2:output_points+1 particulator.run(pyargs('steps', int32(output_interval))); for pykey = py.list(keys(particulator.products)) get = py.getattr(particulator.products{pykey{1}}.get(), '__getitem__'); key = string(pykey{1}); output{i, key} = get(cell_id); end end i=1; for pykey = py.list(keys(particulator.products)) product = particulator.products{pykey{1}}; if string(product.name) ~= "z" subplot(1, width(output)-1, i); plot(output{:, string(pykey{1})}, output.z, '-o'); title(string(product.name), 'Interpreter', 'none'); xlabel(string(product.unit)); end if i == 1 ylabel(string(particulator.products{"z"}.unit)); end i=i+1; end saveas(gcf, "parcel.png"); ```
Python (click to expand) ```Python from matplotlib import pyplot from PySDM.physics import si from PySDM.initialisation import discretise_multiplicities, equilibrate_wet_radii from PySDM.initialisation.spectra import Lognormal from PySDM.initialisation.sampling import spectral_sampling from PySDM.backends import CPU from PySDM.dynamics import AmbientThermodynamics, Condensation from PySDM.environments import Parcel from PySDM import Builder, Formulae, products env = Parcel( dt=.25 * si.s, mass_of_dry_air=1e3 * si.kg, p0=1122 * si.hPa, q0=20 * si.g / si.kg, T0=300 * si.K, w=2.5 * si.m / si.s ) spectrum = Lognormal(norm_factor=1e4 / si.mg, m_mode=50 * si.nm, s_geom=1.5) kappa = .5 * si.dimensionless cloud_range = (.5 * si.um, 25 * si.um) output_interval = 4 output_points = 40 n_sd = 256 formulae = Formulae() builder = Builder(backend=CPU(formulae), n_sd=n_sd) builder.set_environment(env) builder.add_dynamic(AmbientThermodynamics()) builder.add_dynamic(Condensation()) r_dry, specific_concentration = spectral_sampling.Logarithmic(spectrum).sample(n_sd) v_dry = formulae.trivia.volume(radius=r_dry) r_wet = equilibrate_wet_radii(r_dry=r_dry, environment=env, kappa_times_dry_volume=kappa * v_dry) attributes = { 'n': discretise_multiplicities(specific_concentration * env.mass_of_dry_air), 'dry volume': v_dry, 'kappa times dry volume': kappa * v_dry, 'volume': formulae.trivia.volume(radius=r_wet) } particulator = builder.build(attributes, products=[ products.PeakSupersaturation(name='S_max', unit='%'), products.EffectiveRadius(name='r_eff', unit='um', radius_range=cloud_range), products.ParticleConcentration(name='n_c_cm3', unit='cm^-3', radius_range=cloud_range), products.WaterMixingRatio(name='ql', unit='g/kg', radius_range=cloud_range), products.ParcelDisplacement(name='z') ]) cell_id = 0 output = {product.name: [product.get()[cell_id]] for product in particulator.products.values()} for step in range(output_points): particulator.run(steps=output_interval) for product in particulator.products.values(): output[product.name].append(product.get()[cell_id]) fig, axs = pyplot.subplots(1, len(particulator.products) - 1, sharey="all") for i, (key, product) in enumerate(particulator.products.items()): if key != 'z': axs[i].plot(output[key], output['z'], marker='.') axs[i].set_title(product.name) axs[i].set_xlabel(product.unit) axs[i].grid() axs[0].set_ylabel(particulator.products['z'].unit) pyplot.savefig('parcel.svg') ```

The resultant plot (generated with the Matlab code) looks as follows:

plot

Contributing, reporting issues, seeking support

Our technologicial stack:

Python 3 Numba LLVM CUDA NumPy pytest
Colab Codecov PyPI GithubActions Jupyter PyCharm

Submitting new code to the project, please preferably use GitHub pull requests - it helps to keep record of code authorship, track and archive the code review workflow and allows to benefit from the continuous integration setup which automates execution of tests with the newly added code.

Code contributions are assumed to imply transfer of copyright. Should there be a need to make an exception, please indicate it when creating a pull request or contributing code in any other way. In any case, the license of the contributed code must be compatible with GPL v3.

Developing the code, we follow The Way of Python and the KISS principle. The codebase has greatly benefited from PyCharm code inspections and Pylint, Black and isort code analysis (which are all part of the CI workflows).

We also use pre-commit hooks. In our case, the hooks modify files and re-format them. The pre-commit hooks can be run locally, and then the resultant changes need to be staged before committing. To set up the hooks locally, install pre-commit via pip install pre-commit and set up the git hooks via pre-commit install (this needs to be done every time you clone the project). To run all pre-commit hooks, run pre-commit run --all-files. The .pre-commit-config.yaml file can be modified in case new hooks are to be added or existing ones need to be altered.

Further hints addressed at PySDM developers are maintained in the open-atmos/python-dev-hints Wiki.

Issues regarding any incorrect, unintuitive or undocumented bahaviour of PySDM are best to be reported on the GitHub issue tracker. Feature requests are recorded in the "Ideas..." PySDM wiki page.

We encourage to use the GitHub Discussions feature (rather than the issue tracker) for seeking support in understanding, using and extending PySDM code.

We look forward to your contributions and feedback.

Credits:

The development and maintenance of PySDM is led by Sylwester Arabas. Piotr Bartman had been the architect and main developer of technological solutions in PySDM. The suite of examples shipped with PySDM includes contributions from researchers from Jagiellonian University departments of computer science, physics and chemistry; and from Caltech's Climate Modelling Alliance.

Development of PySDM had been initially supported by the EU through a grant of the Foundation for Polish Science) (POIR.04.04.00-00-5E1C/18) realised at the Jagiellonian University. The immersion freezing support in PySDM is developed with support from the US Department of Energy Atmospheric System Research programme through a grant realised at the University of Illinois at Urbana-Champaign.

copyright: Jagiellonian University
licence: GPL v3

Related resources and open-source projects

SDM patents (some expired, some withdrawn):

  • https://patents.google.com/patent/US7756693B2
  • https://patents.google.com/patent/EP1847939A3
  • https://patents.google.com/patent/JP4742387B2
  • https://patents.google.com/patent/CN101059821B

Other SDM implementations:

  • SCALE-SDM (Fortran):
    https://github.com/Shima-Lab/SCALE-SDMBOMEXSato2018/blob/master/contrib/SDM/sdm_coalescence.f90
  • Pencil Code (Fortran):
    https://github.com/pencil-code/pencil-code/blob/master/src/particles_coagulation.f90
  • PALM LES (Fortran):
    https://palm.muk.uni-hannover.de/trac/browser/palm/trunk/SOURCE/lagrangianparticlemodel_mod.f90
  • libcloudph++ (C++):
    https://github.com/igfuw/libcloudphxx/blob/master/src/impl/particlesimplcoal.ipp
  • LCM1D (Python)
    https://github.com/SimonUnterstrasser/ColumnModel
  • superdroplet (Cython/Numba/C++11/Fortran 2008/Julia)
    https://github.com/darothen/superdroplet
  • NTLP (FORTRAN)
    https://github.com/Folca/NTLP/blob/SuperDroplet/les.F

non-SDM probabilistic particle-based coagulation solvers

  • PartMC (Fortran):
    https://github.com/compdyn/partmc

Python models with discrete-particle (moving-sectional) representation of particle size spectrum

  • pyrcel: https://github.com/darothen/pyrcel
  • PyBox: https://github.com/loftytopping/PyBox
  • py-cloud-parcel-model: https://github.com/emmasimp/py-cloud-parcel-model

Owner

  • Name: Institute of Computing for Climate Science
  • Login: Cambridge-ICCS
  • Kind: organization

Institute of Computing for Climate Science at the University of Cambridge

GitHub Events

Total
Last Year

Dependencies

.github/workflows/cancel.yml actions
  • styfle/cancel-workflow-action 0.9.1 composite
.github/workflows/joss.yml actions
  • actions/checkout v2 composite
  • actions/upload-artifact v1 composite
  • docker://openjournals/paperdraft latest composite
.github/workflows/joss_paper.yml actions
  • actions/checkout v2 composite
  • actions/setup-python v1 composite
.github/workflows/readme_snippets.yml actions
  • actions/checkout v2 composite
  • actions/setup-python v1 composite
  • eine/tip master composite
  • julia-actions/setup-julia v1 composite
  • matlab-actions/run-command v0 composite
  • matlab-actions/setup-matlab v0 composite
.github/workflows/stale.yml actions
  • actions/stale v3 composite
.github/workflows/tests+artifacts+pypi.yml actions
  • JamesIves/github-pages-deploy-action 4.1.1 composite
  • actions/checkout master composite
  • actions/checkout v2 composite
  • actions/setup-python master composite
  • actions/setup-python v1 composite
  • actions/setup-python v2 composite
  • codecov/codecov-action v2 composite
  • notiz-dev/github-action-json-property release composite
  • pypa/gh-action-pypi-publish unstable/v1 composite
.binder/requirements.txt pypi
  • PySDM-examples *
examples/setup.py pypi
  • PyMPDATA *
  • PySDM *
  • ghapi *
  • ipywidgets *
  • joblib *
  • matplotlib *
  • open-atmos-jupyter-utils *
  • pystrict *
  • seaborn *
setup.py pypi
  • CURandRTC *
  • Pint *
  • ThrustRTC ==0.3.20
  • chempy *
  • numba *
  • numpy *
  • pyevtk *
  • scipy *