PySDM 2.25__tar.gz → 2.27__tar.gz

{PySDM-2.25 → PySDM-2.27}/.github/workflows/tests+artifacts+pypi.yml

@@ -109,7 +109,7 @@ jobs:
         pylint --max-module-lines=550 --unsafe-load-any-extension=y --disable=fixme,too-many-function-args,unsubscriptable-object,consider-using-with,protected-access,too-many-statements,too-many-public-methods,too-many-branches,duplicate-code,invalid-name,missing-function-docstring,missing-module-docstring,missing-class-docstring,too-many-locals,too-many-instance-attributes,too-few-public-methods,too-many-arguments,c-extension-no-member $(git ls-files '*.py' | grep ^examples)
     - run: |
         # TODO #682
-        nbqa pylint --unsafe-load-any-extension=y --disable=fixme,duplicate-code,invalid-name,trailing-whitespace,line-too-long,missing-function-docstring,wrong-import-position,missing-module-docstring,wrong-import-order,ungrouped-imports,no-member,too-many-locals,redefined-outer-name,unnecessary-lambda-assignment $(git ls-files '*.ipynb')
+        nbqa pylint --unsafe-load-any-extension=y --disable=fixme,duplicate-code,invalid-name,trailing-whitespace,line-too-long,missing-function-docstring,wrong-import-position,missing-module-docstring,wrong-import-order,ungrouped-imports,no-member,too-many-locals,unnecessary-lambda-assignment $(git ls-files '*.ipynb')
 
   zenodo_json:
     runs-on: ubuntu-latest

{PySDM-2.25 → PySDM-2.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.25
+Version: 2.27
 Summary: 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
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors
@@ -21,8 +21,23 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
-Provides-Extra: tests
 License-File: LICENSE
+Requires-Dist: ThrustRTC==0.3.20
+Requires-Dist: CURandRTC>=0.1.2
+Requires-Dist: numba>=0.51.2
+Requires-Dist: numpy
+Requires-Dist: Pint
+Requires-Dist: chempy
+Requires-Dist: scipy
+Requires-Dist: pyevtk
+Provides-Extra: tests
+Requires-Dist: matplotlib; extra == "tests"
+Requires-Dist: jupyter-core<5.0.0; extra == "tests"
+Requires-Dist: ipywidgets!=8.0.3; extra == "tests"
+Requires-Dist: ghapi; extra == "tests"
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-timeout; extra == "tests"
+Requires-Dist: PyPartMC==0.6.3; extra == "tests"
 
 # PySDM
 
@@ -509,7 +524,7 @@ env = Parcel(
     dt=.25 * si.s,
     mass_of_dry_air=1e3 * si.kg,
     p0=1122 * si.hPa,
-    q0=20 * si.g / si.kg,
+    initial_water_vapour_mixing_ratio=20 * si.g / si.kg,
     T0=300 * si.K,
     w= 2.5 * si.m / si.s
 )
@@ -540,7 +555,7 @@ 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.WaterMixingRatio(name="liquid water mixing ratio", unit="g/kg", radius_range=cloud_range),
     products.ParcelDisplacement(name="z")
 ])
     
@@ -591,7 +606,7 @@ env = Parcel(pyargs( ...
     'dt', .25 * si.s, ...
     'mass_of_dry_air', 1e3 * si.kg, ...
     'p0', 1122 * si.hPa, ...
-    'q0', 20 * si.g / si.kg, ...
+    'initial_water_vapour_mixing_ratio', 20 * si.g / si.kg, ...
     'T0', 300 * si.K, ...
     'w', 2.5 * si.m / si.s ...
 ));
@@ -629,7 +644,7 @@ 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.WaterMixingRatio(pyargs('name', 'liquid water mixing ratio', 'unit', 'g/kg', 'radius_range', cloud_range)) ...
     products.ParcelDisplacement(pyargs('name', 'z')) ...
 }));
 
@@ -692,7 +707,7 @@ env = Parcel(
   dt=.25 * si.s,
   mass_of_dry_air=1e3 * si.kg,
   p0=1122 * si.hPa,
-  q0=20 * si.g / si.kg,
+  initial_water_vapour_mixing_ratio=20 * si.g / si.kg,
   T0=300 * si.K,
   w=2.5 * si.m / si.s
 )
@@ -724,7 +739,7 @@ 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.WaterMixingRatio(name='liquid water mixing ratio', unit='g/kg', radius_range=cloud_range),
   products.ParcelDisplacement(name='z')
 ])
 

{PySDM-2.25 → PySDM-2.27}/PySDM/__init__.py

@@ -2,7 +2,7 @@
 """
 PySDM offers a set of building blocks for development of atmospheric cloud
 simulation systems revolving around the particle-based microphysics modelling concept
-and the Super-Droplet Method algorithm ([Shima et al. 2009](http://doi.org/10.1002/qj.441))
+and the Super-Droplet Method algorithm ([Shima et al. 2009](https://doi.org/10.1002/qj.441))
 for numerically tackling the probabilistic representation of particle coagulation.
 
 For an overview of PySDM, see [Bartman, Arabas et al. 2021](https://arxiv.org/abs/2103.17238).
@@ -14,7 +14,7 @@ For details on PySDM dependencies and installation procedures, see project
 [README.md file](https://github.com/open-atmos/PySDM/blob/master/README.md)
 which also includes basic usage examples in **Python**, **Julia** and **Matlab**.
 
-A set of more elaborate examples engineered in Python and accompanied with Jupyter
+A set of more elaborate examples engineered in Python and accompanied by Jupyter
 notebooks are maintained in the
 [PySDM-examples package](https://github.com/open-atmos/PySDM-examples).
 
@@ -24,6 +24,7 @@ PySDM test-suite built using [pytest](https://docs.pytest.org/) is located in th
 
 from pkg_resources import DistributionNotFound, VersionConflict, get_distribution
 
+from . import environments, exporters, products
 from .builder import Builder
 from .formulae import Formulae
 from .particulator import Particulator

{PySDM-2.25 → PySDM-2.27}/PySDM/attributes/impl/mapper.py

@@ -20,6 +20,7 @@ from PySDM.attributes.physics import (
     Multiplicities,
     Radius,
     RelativeFallVelocity,
+    SquareRootOfRadius,
     Temperature,
     TerminalVelocity,
     Volume,
@@ -61,6 +62,7 @@ attributes = {
     "kappa times dry volume": lambda _, __: KappaTimesDryVolume,
     "kappa": lambda _, __: Kappa,
     "radius": lambda _, __: Radius,
+    "square root of radius": lambda _, __: SquareRootOfRadius,
     "area": lambda _, __: Area,
     "dry radius": lambda _, __: DryRadius,
     "terminal velocity": lambda _, __: TerminalVelocity,

{PySDM-2.25 → PySDM-2.27}/PySDM/attributes/physics/__init__.py

@@ -9,7 +9,7 @@ from .dry_volume import DryVolume
 from .equilibrium_supersaturation import EquilibriumSupersaturation
 from .heat import Heat
 from .multiplicities import Multiplicities
-from .radius import Radius
+from .radius import Radius, SquareRootOfRadius
 from .relative_fall_velocity import RelativeFallMomentum, RelativeFallVelocity
 from .temperature import Temperature
 from .terminal_velocity import TerminalVelocity

{PySDM-2.25 → PySDM-2.27}/PySDM/attributes/physics/radius.py

@@ -14,3 +14,18 @@ class Radius(DerivedAttribute):
         self.data.idx = self.volume.data.idx
         self.data.product(self.volume.get(), 1 / self.formulae.constants.PI_4_3)
         self.data **= 1 / 3
+
+
+class SquareRootOfRadius(DerivedAttribute):
+    def __init__(self, builder):
+        self.radius = builder.get_attribute("radius")
+
+        super().__init__(
+            builder,
+            name="square root of radius",
+            dependencies=(self.radius,),
+        )
+
+    def recalculate(self):
+        self.data.fill(self.radius.data)
+        self.data **= 0.5

{PySDM-2.25 → PySDM-2.27}/PySDM/backends/impl_numba/methods/collisions_methods.py

@@ -59,7 +59,7 @@ def coalesce(  # pylint: disable=too-many-arguments
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def breakup0_compute_mult_transfer(
+def compute_transfer_multiplicities(
     gamma, j, k, multiplicity, volume, fragment_size_i, max_multiplicity
 ):  # pylint: disable=too-many-arguments
     overflow_flag = False
@@ -91,7 +91,7 @@ def breakup0_compute_mult_transfer(
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def breakup1_update_mult_attributes(
+def get_new_multiplicities_and_update_attributes(
     j, k, attributes, multiplicity, take_from_j, new_mult_k
 ):  # pylint: disable=too-many-arguments
     for a in range(len(attributes)):
@@ -99,19 +99,20 @@ def breakup1_update_mult_attributes(
         attributes[a, k] += take_from_j * attributes[a, j]
         attributes[a, k] /= new_mult_k
 
-    if multiplicity[j] == take_from_j:
+    if multiplicity[j] > take_from_j:
+        nj = multiplicity[j] - take_from_j
+        nk = new_mult_k
+
+    else:  # take_from_j == multiplicity[j]
         nj = new_mult_k / 2
         nk = nj
         for a in range(len(attributes)):
             attributes[a, j] = attributes[a, k]
-    else:  # take_from_j < multiplicity[j]
-        nj = multiplicity[j] - take_from_j
-        nk = new_mult_k
     return nj, nk
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def breakup2_round_mults_to_ints(
+def round_multiplicities_to_ints_and_update_attributes(
     j,
     k,
     nj,
@@ -144,7 +145,7 @@ def break_up(  # pylint: disable=too-many-arguments,c,too-many-locals
     warn_overflows,
     volume,
 ):  # breakup0 guarantees take_from_j <= multiplicity[j]
-    take_from_j, new_mult_k, gamma_j_k, overflow_flag = breakup0_compute_mult_transfer(
+    take_from_j, new_mult_k, gamma_j_k, overflow_flag = compute_transfer_multiplicities(
         gamma[i],
         j,
         k,
@@ -156,7 +157,7 @@ def break_up(  # pylint: disable=too-many-arguments,c,too-many-locals
     gamma_deficit = gamma[i] - gamma_j_k
 
     # breakup1 also handles new_n[j] == 0 case via splitting
-    nj, nk = breakup1_update_mult_attributes(
+    nj, nk = get_new_multiplicities_and_update_attributes(
         j, k, attributes, multiplicity, take_from_j, new_mult_k
     )
 
@@ -164,7 +165,9 @@ def break_up(  # pylint: disable=too-many-arguments,c,too-many-locals
     atomic_add(breakup_rate_deficit, cid, gamma_deficit * multiplicity[k])
 
     # breakup2 also guarantees that no multiplicities are set to 0
-    breakup2_round_mults_to_ints(j, k, nj, nk, attributes, multiplicity)
+    round_multiplicities_to_ints_and_update_attributes(
+        j, k, nj, nk, attributes, multiplicity
+    )
     if overflow_flag and warn_overflows:
         warn("overflow", __file__)
 
@@ -207,7 +210,7 @@ def break_up_while(
                 new_mult_k,
                 gamma_j_k,
                 overflow_flag,
-            ) = breakup0_compute_mult_transfer(
+            ) = compute_transfer_multiplicities(
                 gamma_deficit,
                 j,
                 k,
@@ -217,13 +220,15 @@ def break_up_while(
                 max_multiplicity,
             )
 
-        nj, nk = breakup1_update_mult_attributes(
+        nj, nk = get_new_multiplicities_and_update_attributes(
             j, k, attributes, multiplicity, take_from_j, new_mult_k
         )
 
         atomic_add(breakup_rate, cid, gamma_j_k * multiplicity[k])
         gamma_deficit -= gamma_j_k
-        breakup2_round_mults_to_ints(j, k, nj, nk, attributes, multiplicity)
+        round_multiplicities_to_ints_and_update_attributes(
+            j, k, nj, nk, attributes, multiplicity
+        )
 
     atomic_add(breakup_rate_deficit, cid, gamma_deficit * multiplicity[k])
 

{PySDM-2.25 → PySDM-2.27}/PySDM/backends/impl_numba/methods/condensation_methods.py

@@ -28,11 +28,11 @@ class CondensationMethods(BackendMethods):
         idx,
         rhod,
         thd,
-        qv,
+        water_vapour_mixing_ratio,
         dv,
         prhod,
         pthd,
-        pqv,
+        predicted_water_vapour_mixing_ratio,
         kappa,
         f_org,
         rtol_x,
@@ -57,11 +57,11 @@ class CondensationMethods(BackendMethods):
             idx=idx.data,
             rhod=rhod.data,
             thd=thd.data,
-            qv=qv.data,
+            water_vapour_mixing_ratio=water_vapour_mixing_ratio.data,
             dv_mean=dv,
             prhod=prhod.data,
             pthd=pthd.data,
-            pqv=pqv.data,
+            predicted_water_vapour_mixing_ratio=predicted_water_vapour_mixing_ratio.data,
             kappa=kappa.data,
             f_org=f_org.data,
             rtol_x=rtol_x,
@@ -91,11 +91,11 @@ class CondensationMethods(BackendMethods):
         idx,
         rhod,
         thd,
-        qv,
+        water_vapour_mixing_ratio,
         dv_mean,
         prhod,
         pthd,
-        pqv,
+        predicted_water_vapour_mixing_ratio,
         kappa,
         f_org,
         rtol_x,
@@ -121,13 +121,16 @@ class CondensationMethods(BackendMethods):
                     continue
 
                 dthd_dt = (pthd[cell_id] - thd[cell_id]) / timestep
-                dqv_dt = (pqv[cell_id] - qv[cell_id]) / timestep
+                d_water_vapour_mixing_ratio__dt = (
+                    predicted_water_vapour_mixing_ratio[cell_id]
+                    - water_vapour_mixing_ratio[cell_id]
+                ) / timestep
                 drhod_dt = (prhod[cell_id] - rhod[cell_id]) / timestep
                 md = (prhod[cell_id] + rhod[cell_id]) / 2 * dv_mean
 
                 (
                     success_in_cell,
-                    qv_new,
+                    water_vapour_mixing_ratio_new,
                     thd_new,
                     substeps_hint,
                     n_activating,
@@ -143,10 +146,10 @@ class CondensationMethods(BackendMethods):
                     kappa,
                     f_org,
                     thd[cell_id],
-                    qv[cell_id],
+                    water_vapour_mixing_ratio[cell_id],
                     rhod[cell_id],
                     dthd_dt,
-                    dqv_dt,
+                    d_water_vapour_mixing_ratio__dt,
                     drhod_dt,
                     md,
                     rtol_x,
@@ -160,7 +163,9 @@ class CondensationMethods(BackendMethods):
                 counter_n_ripening[cell_id] = n_ripening
                 RH_max[cell_id] = RH_max_in_cell
                 success[cell_id] = success_in_cell
-                pqv[cell_id] = qv_new
+                predicted_water_vapour_mixing_ratio[
+                    cell_id
+                ] = water_vapour_mixing_ratio_new
                 pthd[cell_id] = thd_new
 
     @staticmethod
@@ -260,10 +265,10 @@ class CondensationMethods(BackendMethods):
             kappa,
             f_org,
             thd,
-            qv,
+            water_vapour_mixing_ratio,
             rhod,
             dthd_dt_pred,
-            dqv_dt_pred,
+            d_water_vapour_mixing_ratio__dt_predicted,
             drhod_dt,
             m_d,
             rtol_x,
@@ -279,12 +284,14 @@ class CondensationMethods(BackendMethods):
             for _ in range(n_substeps):
                 # note: no example yet showing that the trapezoidal scheme brings any improvement
                 thd += timestep * dthd_dt_pred / 2
-                qv += timestep * dqv_dt_pred / 2
+                water_vapour_mixing_ratio += (
+                    timestep * d_water_vapour_mixing_ratio__dt_predicted / 2
+                )
                 rhod += timestep * drhod_dt / 2
 
                 T = phys_T(rhod, thd)
-                p = phys_p(rhod, T, qv)
-                pv = phys_pv(p, qv)
+                p = phys_p(rhod, T, water_vapour_mixing_ratio)
+                pv = phys_pv(p, water_vapour_mixing_ratio)
                 lv = phys_lv(T)
                 pvs = phys_pvs_C(T - const.T0)
                 RH = pv / pvs
@@ -316,13 +323,20 @@ class CondensationMethods(BackendMethods):
                     rtol_x,
                 )
                 dml_dt = (ml_new - ml_old) / timestep
-                dqv_dt_corr = -dml_dt / m_d
+                d_water_vapour_mixing_ratio__dt_corrected = -dml_dt / m_d
                 dthd_dt_corr = phys_dthd_dt(
-                    rhod=rhod, thd=thd, T=T, dqv_dt=dqv_dt_corr, lv=lv
+                    rhod=rhod,
+                    thd=thd,
+                    T=T,
+                    d_water_vapour_mixing_ratio__dt=d_water_vapour_mixing_ratio__dt_corrected,
+                    lv=lv,
                 )
 
                 thd += timestep * (dthd_dt_pred / 2 + dthd_dt_corr)
-                qv += timestep * (dqv_dt_pred / 2 + dqv_dt_corr)
+                water_vapour_mixing_ratio += timestep * (
+                    d_water_vapour_mixing_ratio__dt_predicted / 2
+                    + d_water_vapour_mixing_ratio__dt_corrected
+                )
                 rhod += timestep * drhod_dt / 2
                 ml_old = ml_new
                 count_activating += n_activating
@@ -331,7 +345,7 @@ class CondensationMethods(BackendMethods):
                 RH_max = max(RH_max, RH)
                 success = success and success_within_substep
             return (
-                qv,
+                water_vapour_mixing_ratio,
                 thd,
                 count_activating,
                 count_deactivating,
@@ -664,10 +678,10 @@ class CondensationMethods(BackendMethods):
             kappa,
             f_org,
             thd,
-            qv,
+            water_vapour_mixing_ratio,
             rhod,
             dthd_dt,
-            dqv_dt,
+            d_water_vapour_mixing_ratio__dt,
             drhod_dt,
             m_d,
             rtol_x,
@@ -684,10 +698,10 @@ class CondensationMethods(BackendMethods):
                 kappa,
                 f_org,
                 thd,
-                qv,
+                water_vapour_mixing_ratio,
                 rhod,
                 dthd_dt,
-                dqv_dt,
+                d_water_vapour_mixing_ratio__dt,
                 drhod_dt,
                 m_d,
                 rtol_x,
@@ -697,7 +711,7 @@ class CondensationMethods(BackendMethods):
                 n_substeps, success = adapt_substeps(args, n_substeps, thd, rtol_thd)
             if success:
                 (
-                    qv,
+                    water_vapour_mixing_ratio,
                     thd,
                     n_activating,
                     n_deactivating,
@@ -709,7 +723,7 @@ class CondensationMethods(BackendMethods):
                 n_activating, n_deactivating, n_ripening, RH_max = -1, -1, -1, -1
             return (
                 success,
-                qv,
+                water_vapour_mixing_ratio,
                 thd,
                 n_substeps,
                 n_activating,

{PySDM-2.25 → PySDM-2.27}/PySDM/backends/impl_numba/methods/physics_methods.py

@@ -44,11 +44,15 @@ class PhysicsMethods(BackendMethods):
         self.critical_volume_body = critical_volume
 
         @numba.njit(**{**conf.JIT_FLAGS, "fastmath": self.formulae.fastmath})
-        def temperature_pressure_RH_body(*, rhod, thd, qv, T, p, RH):
+        def temperature_pressure_RH_body(
+            *, rhod, thd, water_vapour_mixing_ratio, T, p, RH
+        ):
             for i in prange(T.shape[0]):  # pylint: disable=not-an-iterable
                 T[i] = phys_T(rhod[i], thd[i])
-                p[i] = phys_p(rhod[i], T[i], qv[i])
-                RH[i] = phys_pv(p[i], qv[i]) / pvs_C(T[i] - const.T0)
+                p[i] = phys_p(rhod[i], T[i], water_vapour_mixing_ratio[i])
+                RH[i] = phys_pv(p[i], water_vapour_mixing_ratio[i]) / pvs_C(
+                    T[i] - const.T0
+                )
 
         self.temperature_pressure_RH_body = temperature_pressure_RH_body
 
@@ -65,18 +69,27 @@ class PhysicsMethods(BackendMethods):
         self.terminal_velocity_body = terminal_velocity_body
 
         @numba.njit(**{**conf.JIT_FLAGS, "fastmath": self.formulae.fastmath})
-        def a_w_ice_body(*, T_in, p_in, RH_in, qv_in, a_w_ice_out):
+        def a_w_ice_body(
+            *, T_in, p_in, RH_in, water_vapour_mixing_ratio_in, a_w_ice_out
+        ):
             for i in prange(T_in.shape[0]):  # pylint: disable=not-an-iterable
                 pvi = pvi_C(T_in[i] - const.T0)
-                pv = phys_pv(p_in[i], qv_in[i])
+                pv = phys_pv(p_in[i], water_vapour_mixing_ratio_in[i])
                 pvs = pv / RH_in[i]
                 a_w_ice_out[i] = pvi / pvs
 
         self.a_w_ice_body = a_w_ice_body
 
-    def temperature_pressure_RH(self, *, rhod, thd, qv, T, p, RH):
+    def temperature_pressure_RH(
+        self, *, rhod, thd, water_vapour_mixing_ratio, T, p, RH
+    ):
         self.temperature_pressure_RH_body(
-            rhod=rhod.data, thd=thd.data, qv=qv.data, T=T.data, p=p.data, RH=RH.data
+            rhod=rhod.data,
+            thd=thd.data,
+            water_vapour_mixing_ratio=water_vapour_mixing_ratio.data,
+            T=T.data,
+            p=p.data,
+            RH=RH.data,
         )
 
     def terminal_velocity(self, *, values, radius, k1, k2, k3, r1, r2):
@@ -98,11 +111,11 @@ class PhysicsMethods(BackendMethods):
             cell=cell.data,
         )
 
-    def a_w_ice(self, *, T, p, RH, qv, a_w_ice):
+    def a_w_ice(self, *, T, p, RH, water_vapour_mixing_ratio, a_w_ice):
         self.a_w_ice_body(
             T_in=T.data,
             p_in=p.data,
             RH_in=RH.data,
-            qv_in=qv.data,
+            water_vapour_mixing_ratio_in=water_vapour_mixing_ratio.data,
             a_w_ice_out=a_w_ice.data,
         )

{PySDM-2.25 → PySDM-2.27}/PySDM/backends/impl_numba/storage.py

@@ -193,3 +193,6 @@ class Storage(StorageBase):
             self.data[:] = other.data
         else:
             self.data[:] = other
+
+    def exp(self):
+        self.data[:] = np.exp(self.data)