PySDM-examples 2.118__tar.gz → 2.120__tar.gz

{pysdm_examples-2.118 → pysdm_examples-2.120}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pysdm-examples
-Version: 2.118
+Version: 2.120
 Summary: PySDM usage examples reproducing results from literature and depicting how to use PySDM from Python Jupyter notebooks
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors
@@ -77,7 +77,7 @@ The 2D prescribed-flow framework used here can be traced back to the work of
     implementation of the <a href="https://doi.org/10.1002/fld.1071">MPDATA numerical scheme of Smolarkiewicz (e.g., 2006)</a>.
   An animation depicting PySDM simulation capturing <mark>aerosol collisional processing</mark> by warm rain is shown below:
 
-![animation](https://github.com/open-atmos/PySDM/wiki/files/kinematic_2D_example.gif)
+<source src="https://github.com/open-atmos/PySDM/releases/download/tip/docs_intro_animation_ubuntu-24.04.mp4" type="video/mp4">
 
 Example notebooks:
 - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Arabas_et_al_2015.html">Arabas_et_al_2015</a>

{pysdm_examples-2.118 → pysdm_examples-2.120}/PySDM_examples/Pyrcel/simulation.py

@@ -91,7 +91,9 @@ class Simulation(BasicSimulation):
                 attr[drop_id].append(attr_data[drop_id])
         super()._save(output)
 
-    def run(self):
+    def run(self, observers=()):
+        for observer in observers:
+            self.particulator.observers.append(observer)
         output_products = super()._run(
             self.settings.nt, self.settings.steps_per_output_interval
         )

pysdm_examples-2.120/PySDM_examples/utils/pvanim.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env pvpython
+import argparse
+from collections import namedtuple
+import pathlib
+
+from paraview import simple as pvs  # pylint: disable=import-error
+
+pvs._DisableFirstRenderCameraReset()
+
+
+def cli_using_argparse(argp):
+    argp.add_argument("product_path", help="path to pvd products file")
+    argp.add_argument("attributes_path", help=" path to pvd attributes file")
+    argp.add_argument("output_path", help="path where to write output files")
+    argp.add_argument(
+        "--multiplicity_preset",
+        default="Inferno (matplotlib)",
+        help="Preset for multiplicity",
+    )
+    argp.add_argument(
+        "--multiplicity_logscale",
+        action="store_false",
+        help="Use log scale for multiplicity",
+    )
+    argp.add_argument(
+        "--effectiveradius_preset",
+        default="Black, Blue and White",
+        help="Preset for effectiveradius",
+    )
+    argp.add_argument(
+        "--effectiveradius_logscale",
+        action="store_false",
+        help="Use log scale for effectiveradius",
+    )
+    argp.add_argument(
+        "--effectiveradius_nan_color",
+        nargs=3,
+        type=float,
+        default=[0.666, 0.333, 1.0],
+        help="Nan color in RGB format for effectiveradius",
+    )
+    argp.add_argument(
+        "--sd_products_opacity", type=float, default=0.9, help="Opacity for sd_products"
+    )
+    argp.add_argument(
+        "--calculator1_opacity",
+        type=float,
+        default=0.19,
+        help="Opacity for calculator1",
+    )
+    argp.add_argument(
+        "--sd_attributes_opacity",
+        type=float,
+        default=0.77,
+        help="Opacity for sd_attributes",
+    )
+    argp.add_argument(
+        "--animationframename",
+        type=str,
+        help="Name of the file with animation last frame",
+    )
+    argp.add_argument(
+        "--animationname",
+        type=str,
+        help="Name of the file with animation",
+    )
+    argp.add_argument(
+        "--framerate", type=int, help="Number of frame rates.", default=15
+    )
+
+
+ap = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+cli_using_argparse(ap)
+
+args = ap.parse_args()
+sd_productspvd = pvs.OpenDataFile(args.product_path)
+sd_attributespvd = pvs.OpenDataFile(args.attributes_path)
+
+
+setup = {
+    "renderView1": pvs.GetActiveViewOrCreate("RenderView"),
+    "sd_attributespvdDisplay": pvs.GetDisplayProperties(
+        sd_attributespvd, view=pvs.GetActiveViewOrCreate("RenderView")
+    ),
+    "effectiveradiusLUT": pvs.GetColorTransferFunction("effectiveradius"),
+    "sd_productspvdDisplay": pvs.GetDisplayProperties(
+        sd_productspvd, view=pvs.GetActiveViewOrCreate("RenderView")
+    ),
+}
+
+setup = namedtuple("Setup", setup.keys())(**setup)
+
+setup.effectiveradiusLUT.RescaleTransferFunction(0.1380997175392798, 207.7063518856934)
+
+setup.renderView1.Update()
+
+
+def create_new_calculator(
+    calcinput,
+    representation,
+    function,
+    color_by1,
+    color_by2,
+    color_by3,
+    scalar_coloring=False,
+    hide=False,
+    *,
+    y,
+    registrationame,
+):
+    calculator = pvs.Calculator(registrationName=registrationame, Input=calcinput)
+    display = pvs.Show(calculator, y.renderView1, representation)
+    calculator.Function = function
+    y.renderView1.Update()
+    if scalar_coloring is True:
+        pvs.ColorBy(display, (color_by1, color_by2, color_by3))
+    if hide is True:
+        pvs.Hide(calculator, y.renderView1)
+    return y.renderView1.Update()
+
+
+def scalar_bar(name, *, y, erLUT):
+    calculator1Display = pvs.Show(
+        calculator1, y.renderView1, "UnstructuredGridRepresentation"
+    )
+    calculator1Display.SetScalarBarVisibility(y.renderView1, True)
+    scalarBar = pvs.GetScalarBar(erLUT.effectiveradiusLUT, y.renderView1)
+    scalarBar.ComponentTitle = ""
+    scalarBar.Title = name
+    y.renderView1.Update()
+
+
+def create_glyph(
+    registration_name, put, scale_array1, scale_array2, color_by=False, *, y
+):
+    glyph = pvs.Glyph(registrationName=registration_name, Input=put, GlyphType="Arrow")
+    glyphDisplay = pvs.Show(glyph, y.renderView1, "GeometryRepresentation")
+    glyphDisplay.Representation = "Surface"
+    glyph.ScaleArray = [scale_array1, scale_array2]
+    glyph.ScaleFactor = 100
+    glyphDisplay.SetScalarBarVisibility(y.renderView1, True)
+    if color_by is True:
+        glyphDisplay.ColorArrayName = ["POINTS", ""]
+        pvs.ColorBy(glyphDisplay, None)
+    y.renderView1.Update()
+
+
+def apply_presets_logscale_opacity_and_update(*, y, attdisplay, erLUT, proddisplay):
+    multiplicityLUT = pvs.GetColorTransferFunction("multiplicity")
+    multiplicityLUT.RescaleTransferFunction(19951.0, 50461190157.0)
+    calculator1Display = pvs.Show(
+        calculator1, y.renderView1, "UnstructuredGridRepresentation"
+    )
+    multiplicityLUT.ApplyPreset(args.multiplicity_preset, True)
+    if args.multiplicity_logscale:
+        multiplicityLUT.MapControlPointsToLogSpace()
+        multiplicityLUT.UseLogScale = 1
+    else:
+        multiplicityLUT.MapControlPointsToLinearSpace()
+        multiplicityLUT.UseLogScale = 0
+
+    erLUT.effectiveradiusLUT.ApplyPreset(args.effectiveradius_preset, True)
+    if args.effectiveradius_logscale:
+        erLUT.effectiveradiusLUT.MapControlPointsToLogSpace()
+        erLUT.effectiveradiusLUT.UseLogScale = 1
+    else:
+        erLUT.effectiveradiusLUT.MapControlPointsToLinearSpace()
+        erLUT.effectiveradiusLUT.UseLogScale = 0
+
+    erLUT.effectiveradiusLUT.NanColor = args.effectiveradius_nan_color
+
+    proddisplay.sd_productspvdDisplay.SetRepresentationType("Surface With Edges")
+    proddisplay.sd_productspvdDisplay.Opacity = args.sd_products_opacity
+    calculator1Display.Opacity = args.calculator1_opacity
+    attdisplay.sd_attributespvdDisplay.Opacity = args.sd_attributes_opacity
+
+    y.renderView1.Update()
+
+
+def get_layout(*, y):
+    layout1 = pvs.GetLayout()
+    layout1.SetSize(1205, 739)
+    y.renderView1.Update()
+
+
+def set_current_camera_placement(*, y):
+    y.renderView1.InteractionMode = "2D"
+    y.renderView1.CameraPosition = [
+        836.5045867211775,
+        677.8909274570431,
+        -4098.0762113533165,
+    ]
+    y.renderView1.CameraFocalPoint = [836.5045867211775, 677.8909274570431, 0.0]
+    y.renderView1.CameraViewUp = [1.0, 0.0, 0.0]
+    y.renderView1.CameraParallelScale = 1060.6601717798205
+    y.renderView1.Update()
+
+
+def axes_settings(*, view):
+    view.ViewSize = [2000, 800]
+    view.Background = [1, 1, 1]
+    view.CenterAxesVisibility = True
+    view.OrientationAxesVisibility = True
+    axesGrid = view.AxesGrid
+    axesGrid.Visibility = True
+    axesGrid.XTitle = "Z [m]"
+    axesGrid.YTitle = "X [m]"
+
+    axesGrid.XAxisUseCustomLabels = True
+    axesGrid.XAxisLabels = [300, 600, 900, 1200]
+    axesGrid.YAxisUseCustomLabels = True
+    axesGrid.YAxisLabels = [300, 600, 900, 1200]
+
+    axesGrid.XTitleFontSize = 30
+    axesGrid.XLabelFontSize = 30
+    axesGrid.YTitleFontSize = 30
+    axesGrid.YLabelFontSize = 30
+
+    axesGrid.XTitleColor = [1.0, 1.0, 1.0]
+    axesGrid.XLabelColor = [1.0, 1.0, 1.0]
+    axesGrid.YTitleColor = [1.0, 1.0, 1.0]
+    axesGrid.YLabelColor = [1.0, 1.0, 1.0]
+    axesGrid.GridColor = [0.1, 0.1, 0.1]
+    view.CenterAxesVisibility = False
+    view.Update()
+
+
+def time_annotation(*, y):
+    time = pvs.AnnotateTimeFilter(
+        guiName="AnnotateTimeFilter1", Format="Time:{time:f}s"
+    )
+    pvs.Show(time, y.renderView1)
+    y.renderView1.Update()
+
+
+def text(text_in, position_y, *, view):
+    sentence = pvs.Text()
+    sentence.Text = text_in
+    textDisplay = pvs.Show(sentence, view)
+    textDisplay.Color = [1.0, 1.0, 1.0]
+    textDisplay.WindowLocation = "Any Location"
+    textDisplay.FontSize = 16
+    textDisplay.Position = [0.01, position_y]
+
+
+def last_anim_frame(animation_frame_name):
+    time_steps = sd_productspvd.TimestepValues
+    last_time = time_steps[len(time_steps) - 1]
+    setup.renderView1.ViewTime = last_time
+    for reader in (sd_productspvd,):
+        reader.UpdatePipeline(last_time)
+        pvs.ExportView(
+            filename=str(pathlib.Path(args.output_path) / animation_frame_name),
+            view=setup.renderView1,
+            Rasterize3Dgeometry=False,
+            GL2PSdepthsortmethod="BSP sorting (slow, best)",
+        )
+    pvs.RenderAllViews()
+
+
+calculator1 = create_new_calculator(
+    sd_attributespvd,
+    "UnstructuredGridRepresentation",
+    '"relative fall velocity"*(-iHat)',
+    "None",
+    "None",
+    "None",
+    y=setup,
+    registrationame="Calculator1",
+)
+scalar_bar("effective radius [um]", y=setup, erLUT=setup)
+create_glyph("Glyph1", calculator1, "POINTS", "relative fall velocity", y=setup)
+calculator2 = create_new_calculator(
+    sd_productspvd,
+    "StructuredGridRepresentation",
+    "cx*jHat+cy*iHat",
+    "CELLS",
+    "Result",
+    "Magnitude",
+    True,
+    True,
+    y=setup,
+    registrationame="Calculator2",
+)
+apply_presets_logscale_opacity_and_update(
+    y=setup, attdisplay=setup, erLUT=setup, proddisplay=setup
+)
+create_glyph("Glyph2", calculator2, "CELLS", "Result", True, y=setup)
+get_layout(y=setup)
+set_current_camera_placement(y=setup)
+axes_settings(view=setup.renderView1)
+time_annotation(y=setup)
+text("Arrows scale with Courant number C=u*Δt/Δx,", 0.7, view=setup.renderView1)
+text("reflecting the grid spacing Δx and Δy.", 0.65, view=setup.renderView1)
+last_anim_frame(animation_frame_name=args.animationframename)
+scene = pvs.GetAnimationScene()
+scene.UpdateAnimationUsingDataTimeSteps()
+pvs.Render(setup.renderView1)
+pvs.SaveAnimation(
+    str(pathlib.Path(args.output_path) / args.animationname),
+    setup.renderView1,
+    FrameRate=args.framerate,
+)
+pvs.RenderAllViews()

{pysdm_examples-2.118 → pysdm_examples-2.120}/docs/pysdm_examples_landing.md

@@ -41,7 +41,7 @@ The 2D prescribed-flow framework used here can be traced back to the work of
     implementation of the <a href="https://doi.org/10.1002/fld.1071">MPDATA numerical scheme of Smolarkiewicz (e.g., 2006)</a>.
   An animation depicting PySDM simulation capturing <mark>aerosol collisional processing</mark> by warm rain is shown below:
 
-![animation](https://github.com/open-atmos/PySDM/wiki/files/kinematic_2D_example.gif)
+<source src="https://github.com/open-atmos/PySDM/releases/download/tip/docs_intro_animation_ubuntu-24.04.mp4" type="video/mp4">
 
 Example notebooks:
 - `PySDM_examples.Arabas_et_al_2015`

{pysdm_examples-2.118 → pysdm_examples-2.120}/pyproject.toml

@@ -4,4 +4,4 @@ local_scheme = "no-local-version"
 version_scheme = "post-release"
 
 [build-system]
-requires = ['setuptools==76.0.0', 'setuptools-scm==8.2.1']
+requires = ['setuptools==80.7.1', 'setuptools-scm==8.3.1']

{pysdm_examples-2.118 → pysdm_examples-2.120}/pysdm_examples.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pysdm-examples
-Version: 2.118
+Version: 2.120
 Summary: PySDM usage examples reproducing results from literature and depicting how to use PySDM from Python Jupyter notebooks
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors
@@ -77,7 +77,7 @@ The 2D prescribed-flow framework used here can be traced back to the work of
     implementation of the <a href="https://doi.org/10.1002/fld.1071">MPDATA numerical scheme of Smolarkiewicz (e.g., 2006)</a>.
   An animation depicting PySDM simulation capturing <mark>aerosol collisional processing</mark> by warm rain is shown below:
 
-![animation](https://github.com/open-atmos/PySDM/wiki/files/kinematic_2D_example.gif)
+<source src="https://github.com/open-atmos/PySDM/releases/download/tip/docs_intro_animation_ubuntu-24.04.mp4" type="video/mp4">
 
 Example notebooks:
 - <a href="https://open-atmos.github.io/PySDM/PySDM_examples/Arabas_et_al_2015.html">Arabas_et_al_2015</a>

{pysdm_examples-2.118 → pysdm_examples-2.120}/pysdm_examples.egg-info/SOURCES.txt

@@ -94,8 +94,6 @@ PySDM_examples/Pyrcel/__init__.py
 PySDM_examples/Pyrcel/profile_plotter.py
 PySDM_examples/Pyrcel/settings.py
 PySDM_examples/Pyrcel/simulation.py
-PySDM_examples/Pyrcel/tutorial_settings.py
-PySDM_examples/Pyrcel/tutorial_simulation.py
 PySDM_examples/Rozanski_and_Sonntag_1982/__init__.py
 PySDM_examples/Rozanski_and_Sonntag_1982/multibox.py
 PySDM_examples/Shima_et_al_2009/__init__.py
@@ -158,6 +156,7 @@ PySDM_examples/utils/__init__.py
 PySDM_examples/utils/basic_simulation.py
 PySDM_examples/utils/dummy_controller.py
 PySDM_examples/utils/progbar_controller.py
+PySDM_examples/utils/pvanim.py
 PySDM_examples/utils/read_vtk_1d.py
 PySDM_examples/utils/widgets/__init__.py
 PySDM_examples/utils/widgets/freezer.py

pysdm_examples-2.118/PySDM_examples/Pyrcel/tutorial_settings.py

@@ -1,65 +0,0 @@
-from typing import Dict
-
-import numpy as np
-from pystrict import strict
-
-from PySDM import Formulae
-from PySDM.initialisation.impl.spectrum import Spectrum
-
-
-@strict
-class Settings:
-    def __init__(
-        self,
-        dz: float,
-        n_sd_per_mode: tuple,
-        aerosol_modes_by_kappa: Dict[float, Spectrum],
-        vertical_velocity: float,
-        initial_temperature: float,
-        initial_pressure: float,
-        initial_relative_humidity: float,
-        displacement: float,
-        formulae: Formulae,
-    ):
-        self.formulae = formulae
-        self.n_sd_per_mode = n_sd_per_mode
-        self.aerosol_modes_by_kappa = aerosol_modes_by_kappa
-
-        const = self.formulae.constants
-        self.vertical_velocity = vertical_velocity
-        self.initial_pressure = initial_pressure
-        self.initial_temperature = initial_temperature
-        pv0 = initial_relative_humidity * formulae.saturation_vapour_pressure.pvs_water(
-            initial_temperature
-        )
-        self.initial_vapour_mixing_ratio = const.eps * pv0 / (initial_pressure - pv0)
-        self.t_max = displacement / vertical_velocity
-        self.timestep = dz / vertical_velocity
-        self.output_interval = self.timestep
-
-    @property
-    def initial_air_density(self):
-        const = self.formulae.constants
-        dry_air_density = (
-            self.formulae.trivia.p_d(
-                self.initial_pressure, self.initial_vapour_mixing_ratio
-            )
-            / self.initial_temperature
-            / const.Rd
-        )
-        return dry_air_density * (1 + self.initial_vapour_mixing_ratio)
-
-    @property
-    def nt(self) -> int:
-        nt = self.t_max / self.timestep
-        nt_int = round(nt)
-        np.testing.assert_almost_equal(nt, nt_int)
-        return nt_int
-
-    @property
-    def steps_per_output_interval(self) -> int:
-        return int(self.output_interval / self.timestep)
-
-    @property
-    def output_steps(self) -> np.ndarray:
-        return np.arange(0, self.nt + 1, self.steps_per_output_interval)

pysdm_examples-2.118/PySDM_examples/Pyrcel/tutorial_simulation.py

@@ -1,90 +0,0 @@
-import numpy as np
-from PySDM_examples.utils import BasicSimulation
-
-from PySDM import Builder
-from PySDM.backends import CPU
-from PySDM.backends.impl_numba.test_helpers import scipy_ode_condensation_solver
-from PySDM.dynamics import AmbientThermodynamics, Condensation
-from PySDM.environments import Parcel
-from PySDM.initialisation import equilibrate_wet_radii
-from PySDM.initialisation.sampling.spectral_sampling import ConstantMultiplicity
-from PySDM.physics import si
-
-
-class Simulation(BasicSimulation):
-    def __init__(
-        self, settings, products=None, scipy_solver=False, rtol_thd=1e-10, rtol_x=1e-10
-    ):
-        env = Parcel(
-            dt=settings.timestep,
-            p0=settings.initial_pressure,
-            initial_water_vapour_mixing_ratio=settings.initial_vapour_mixing_ratio,
-            T0=settings.initial_temperature,
-            w=settings.vertical_velocity,
-            mass_of_dry_air=44 * si.kg,
-        )
-        n_sd = sum(settings.n_sd_per_mode)
-        builder = Builder(n_sd=n_sd, backend=CPU(formulae=settings.formulae))
-        builder.set_environment(env)
-        builder.add_dynamic(AmbientThermodynamics())
-        builder.add_dynamic(Condensation(rtol_thd=rtol_thd, rtol_x=rtol_x))
-
-        volume = env.mass_of_dry_air / settings.initial_air_density
-        attributes = {
-            k: np.empty(0) for k in ("dry volume", "kappa times dry volume", "n")
-        }
-        for i, (kappa, spectrum) in enumerate(settings.aerosol_modes_by_kappa.items()):
-            sampling = ConstantMultiplicity(spectrum)
-            r_dry, n_per_volume = sampling.sample(settings.n_sd_per_mode[i])
-            v_dry = settings.formulae.trivia.volume(radius=r_dry)
-            attributes["n"] = np.append(attributes["n"], n_per_volume * volume)
-            attributes["dry volume"] = np.append(attributes["dry volume"], v_dry)
-            attributes["kappa times dry volume"] = np.append(
-                attributes["kappa times dry volume"], v_dry * kappa
-            )
-        r_wet = equilibrate_wet_radii(
-            r_dry=settings.formulae.trivia.radius(volume=attributes["dry volume"]),
-            environment=env,
-            kappa_times_dry_volume=attributes["kappa times dry volume"],
-        )
-        attributes["volume"] = settings.formulae.trivia.volume(radius=r_wet)
-
-        super().__init__(
-            particulator=builder.build(attributes=attributes, products=products)
-        )
-        if scipy_solver:
-            scipy_ode_condensation_solver.patch_particulator(self.particulator)
-
-        self.output_attributes = {
-            "volume": tuple([] for _ in range(self.particulator.n_sd))
-        }
-        self.settings = settings
-
-        self.__sanity_checks(attributes, volume)
-
-    def __sanity_checks(self, attributes, volume):
-        for attribute in attributes.values():
-            assert attribute.shape[0] == self.particulator.n_sd
-        np.testing.assert_approx_equal(
-            sum(attributes["multiplicity"]) / volume,
-            sum(
-                mode.norm_factor
-                for mode in self.settings.aerosol_modes_by_kappa.values()
-            ),
-            significant=4,
-        )
-
-    def _save(self, output):
-        for key, attr in self.output_attributes.items():
-            attr_data = self.particulator.attributes[key].to_ndarray()
-            for drop_id in range(self.particulator.n_sd):
-                attr[drop_id].append(attr_data[drop_id])
-        super()._save(output)
-
-    def run(self, observers=()):
-        for observer in observers:
-            self.particulator.observers.append(observer)
-        output_products = super()._run(
-            self.settings.nt, self.settings.steps_per_output_interval
-        )
-        return {"products": output_products, "attributes": self.output_attributes}