trapz --> trapezoid

docs/Tutorials/Dynamics/Coagulation/Coagulation_4_Compared.ipynb

@@ -389,7 +389,7 @@
     "\n",
     "    total_mass_pdf[i] = aerosol_pdf.particles[0].get_mass_concentration()\n",
     "    number_distribution_pdf[i, :] = aerosol_pdf.particles[0].get_concentration(clone=True)\n",
-    "    total_number_pdf[i] = np.trapz(number_distribution_pdf[i, :], radius_bins)"
+    "    total_number_pdf[i] = np.trapezoid(number_distribution_pdf[i, :], radius_bins)"
    ]
   },
   {

docs/Tutorials/Particle_Phase/Aerosol_Distributions.ipynb

@@ -189,8 +189,8 @@
    ],
    "source": [
     "# %%\n",
-    "single_mode_total_concentration = np.trapz(single_mode_distribution, x_values)\n",
-    "multi_mode_total_concentration = np.trapz(multi_mode_distribution, x_values)\n",
+    "single_mode_total_concentration = np.trapezoid(single_mode_distribution, x_values)\n",
+    "multi_mode_total_concentration = np.trapezoid(multi_mode_distribution, x_values)\n",
     "\n",
     "print(\n",
     "    f\"Total Concentration for Single Mode: {single_mode_total_concentration}\"\n",

docs/old-examples/distributions/notebooks/distribution_ambient.ipynb

@@ -206,10 +206,10 @@
         "coarse_mode_vol = np.zeros_like(time_array)\n",
         "\n",
         "def pdf_total(radius, pdf_distribution):\n",
-        "    return np.trapz(y=pdf_distribution, x=radius)\n",
+        "    return np.trapezoid(y=pdf_distribution, x=radius)\n",
         "\n",
         "def pdf_volume_total(radius, pdf_distribution):\n",
-        "    return np.trapz(y=pdf_distribution* 4/3 * np.pi * radius**3, x=radius)\n",
+        "    return np.trapezoid(y=pdf_distribution* 4/3 * np.pi * radius**3, x=radius)\n",
         "\n",
         "for i, value in enumerate(time_array):\n",
         "  fine_mode[i] = pdf_total(radius[0:split_index], solution.m[i, 0:split_index] )\n",

docs/old-examples/distributions/notebooks/distribution_statistics.ipynb

@@ -229,10 +229,10 @@
       ],
       "source": [
         "def pdf_total(radius, pdf_distribution):\n",
-        "    return np.trapz(y=pdf_distribution, x=radius)\n",
+        "    return np.trapezoid(y=pdf_distribution, x=radius)\n",
         "\n",
         "def pdf_volume_total(radius, pdf_distribution):\n",
-        "    return np.trapz(y=pdf_distribution* 4/3 * np.pi * radius**3, x=radius)\n",
+        "    return np.trapezoid(y=pdf_distribution* 4/3 * np.pi * radius**3, x=radius)\n",
         "\n",
         "print(f'Total number of the PDF, {pdf_total(default_distribution.particle_radius, default_distribution.particle_distribution())}')\n",
         "\n",

docs/old-examples/tour-(old)/part-tour.ipynb

@@ -102,7 +102,7 @@
     "One way to think about this is to integrate the curve, that yields exactly 1e5 /cc which is the total number concentration. Try it! (Copy the code block below and execute it after or before the next cell.)\n",
     "\n",
     "```python\n",
-    "np.trapz(part_dist.particle_distribution(), part_dist.particle_radius)\n",
+    "np.trapezoid(part_dist.particle_distribution(), part_dist.particle_radius)\n",
     "```"
    ]
   },
@@ -378,7 +378,7 @@
     "    x=part_dist.particle_radius,\n",
     "    y=r.coagulation_rate()*part_dist.particle_radius**3,\n",
     "    title=\"Particle coagulation net rate (volume)\",\n",
-    "    label=f\"Integral: {np.trapz(r.coagulation_rate()*part_dist.particle_radius**3, part_dist.particle_radius)}\"\n",
+    "    label=f\"Integral: {np.trapezoid(r.coagulation_rate()*part_dist.particle_radius**3, part_dist.particle_radius)}\"\n",
     ")"
    ]
   },

particula/data/process/lognormal_2mode.py

@@ -63,7 +63,7 @@ def cost_function(
     )
     # The volume distribution error
     total_number_dist_error = (
-        np.trapz(np.abs(concentration_pdf - concentration_pdf_guess), x_values)
+        np.trapezoid(np.abs(concentration_pdf - concentration_pdf_guess), x_values)
         ** 2
     )
 

particula/data/process/mie_bulk.py

@@ -177,15 +177,15 @@ def compute_bulk_optics(
         big_g = np.sum(g * q_sca * area_dist) / b_sca if b_sca != 0 else 0
         b_pr = b_ext - big_g * b_sca
     else:  # then pdf so the integral is used
-        b_ext = np.trapz(q_ext * area_dist, dp)
+        b_ext = np.trapezoid(q_ext * area_dist, dp)
         if extinction_only:
             return b_ext, None, None, None, None, None, None
-        b_sca = np.trapz(q_sca * area_dist, dp)
+        b_sca = np.trapezoid(q_sca * area_dist, dp)
         b_abs = b_ext - b_sca
-        b_back = np.trapz(q_back * area_dist, dp)
-        b_ratio = np.trapz(q_ratio * area_dist, dp)
+        b_back = np.trapezoid(q_back * area_dist, dp)
+        b_ratio = np.trapezoid(q_ratio * area_dist, dp)
         big_g = (
-            np.trapz(g * q_sca * area_dist, dp) / b_sca if b_sca != 0 else 0
+            np.trapezoid(g * q_sca * area_dist, dp) / b_sca if b_sca != 0 else 0
         )
         b_pr = b_ext - big_g * b_sca
     return b_ext, b_sca, b_abs, b_pr, b_back, b_ratio, big_g

particula/data/process/ml_analysis/generate_and_train_2mode_sizer.py

@@ -527,7 +527,7 @@ def lognormal_2mode_ml_guess(
     )
 
     # Integrate the concentration to get the total number of particles
-    total_particles = np.trapz(concentration_pdf, logspace_x)
+    total_particles = np.trapezoid(concentration_pdf, logspace_x)
     number_of_particles_guess = number_of_particles_guess * total_particles
 
     return (

particula/data/process/scattering_truncation.py

@@ -9,7 +9,7 @@
 
 from tqdm import tqdm
 import PyMieScatt as ps
-from scipy.integrate import trapezoid as trapz
+from scipy.integrate import trapezoid as trapezoid
 from particula.util import convert
 from particula.data.process import mie_angular, mie_bulk
 
@@ -137,7 +137,7 @@ def trunc_mono(
         )
 
     # Integrate the Mie scattering efficiency over all angles
-    q_mie = trapz((2 * su * np.sin(theta)) / size_param**2, theta)
+    q_mie = trapezoid((2 * su * np.sin(theta)) / size_param**2, theta)
 
     # Initialize arrays for z-axis positions, angles, and scattering
     # efficiencies
@@ -165,14 +165,14 @@ def trunc_mono(
         su_trunc, theta_trunc = get_truncated_scattering(
             su, theta, theta1[i], theta2[i]
         )
-        qsca_trunc[i] = trapz(
+        qsca_trunc[i] = trapezoid(
             (2 * su_trunc * np.sin(theta_trunc)) / size_param**2, theta_trunc
         )
 
     # Integrate scattering efficiencies over the z-axis to get total
     # efficiencies
-    trunc = trapz(qsca_trunc, z_axis)
-    ideal = trapz(qsca_ideal, z_axis)
+    trunc = trapezoid(qsca_trunc, z_axis)
+    ideal = trapezoid(qsca_ideal, z_axis)
 
     # Apply calibration factor to truncation correction if requested
     trunc_corr = (

particula/next/dynamics/coagulation/rate.py

@@ -86,7 +86,7 @@ def discrete_gain(
     dpi = (np.transpose(radius) ** 3 - dpd**3) ** (1 / 3)
 
     # Compute gain using numerical integration
-    gain = radius**2 * np.trapz(
+    gain = radius**2 * np.trapezoid(
         interp.ev(dpd, dpi) / dpi**2, dpd, axis=0)  # type: ignore
 
     # Convert back to original scale (from PDF to PMF)
@@ -114,7 +114,7 @@ def continuous_loss(
         physics, Chapter 13 Equations 13.61
     """
     # concentration (n,) and kernel (n,n)
-    return concentration * np.trapz(y=kernel * concentration, x=radius)
+    return concentration * np.trapezoid(y=kernel * concentration, x=radius)
 
 
 def continuous_gain(
@@ -154,7 +154,7 @@ def continuous_gain(
     dpd = np.linspace(0, radius / 2 ** (1 / 3), radius.size)  # type: ignore
     dpi = (np.transpose(radius) ** 3 - dpd**3) ** (1 / 3)
 
-    return radius**2 * np.trapz(
+    return radius**2 * np.trapezoid(
         interp.ev(dpd, dpi) / dpi**2,  # type: ignore
         dpd,
         axis=0  # type: ignore

particula/next/particles/properties/lognormal_size_distribution.py

@@ -56,7 +56,7 @@ def lognormal_pdf_distribution(
         scale=mode,
     )
 
-    area = np.trapz(distribution, x=x_values[:, np.newaxis], axis=0)
+    area = np.trapezoid(distribution, x=x_values[:, np.newaxis], axis=0)
     area[area == 0] = np.nan
 
     scaled_distribution = distribution * (number_of_particles / area)

particula/next/particles/properties/special_functions.py

@@ -57,12 +57,12 @@ def debye_function(
     """
     array = np.linspace(0, variable, integration_points)
     if n == 1:
-        integral = np.trapz(
+        integral = np.trapezoid(
             array[1:] / (np.exp(array[1:]) - 1), array[1:], axis=0
         )
         return integral / variable
 
-    integral = np.trapz(
+    integral = np.trapezoid(
         array[1:] ** n / (np.exp(array[1:]) - 1), array[1:], axis=0
     )
     return (n / variable**n) * integral

particula/tests/dynamics_test.py

@@ -44,15 +44,15 @@ def test_conservation():
     """
 
     assert (
-        np.trapz((solution.m[0, :]-solution.m[-1, :])*radius**3, radius) /
-        np.trapz((solution.m[0, :])*radius**3, radius)
+        np.trapezoid((solution.m[0, :]-solution.m[-1, :])*radius**3, radius) /
+        np.trapezoid((solution.m[0, :])*radius**3, radius)
         ==
         pytest.approx(0, abs=5e-3)
     )
 
     assert (
-        np.trapz((fine_sols.m[0, :]-fine_sols.m[-1, :])*radius**3, radius) /
-        np.trapz((fine_sols.m[0, :])*radius**3, radius)
+        np.trapezoid((fine_sols.m[0, :]-fine_sols.m[-1, :])*radius**3, radius) /
+        np.trapezoid((fine_sols.m[0, :])*radius**3, radius)
         ==
         pytest.approx(0, abs=5e-3)  # allow for 0.5% each direction (1% total)
     )

particula/tests/particle_test.py

@@ -73,7 +73,7 @@ def test_particle_distribution():
         for single mode and multi mode.
     """
     def pdf_total(radius, pdf_distribution):
-        return np.trapz(y=pdf_distribution, x=radius)
+        return np.trapezoid(y=pdf_distribution, x=radius)
 
     # single mode
     particle_distribution_1 = particle.ParticleDistribution(

particula/util/coagulation_rate.py

@@ -71,7 +71,7 @@ def coag_loss(self):
 
         nums, rads, kern = self.coag_prep()
 
-        return nums * np.trapz(kern * nums, rads)
+        return nums * np.trapezoid(kern * nums, rads)
 
     def coag_gain(self):
         """ Returns the coagulation gain rate
@@ -111,7 +111,7 @@ def coag_gain(self):
         dpd = np.linspace(0, rads.m / 2**(1 / 3), rads.m.size) * rads.u
         dpi = ((np.transpose(rads.m) * rads.u)**3 - dpd**3)**(1 / 3)
 
-        return rads**2 * np.trapz(
+        return rads**2 * np.trapezoid(
             interp.ev(dpd.m, dpi.m) * kern.u * nums.u * nums.u / dpi**2,
             dpd,
             axis=0

particula/util/debye_function.py

@@ -11,7 +11,7 @@ def df1(var):
     if isinstance(var, u.Quantity):
         var = var.m
     xvar = np.linspace(0, var, 1000)
-    return np.trapz(
+    return np.trapezoid(
         xvar[1:]/(np.exp(xvar[1:])-1),
         xvar[1:],
         axis=0

particula/util/stats.py

@@ -300,6 +300,6 @@ def distribution_integration(
     """
     if x_array is not None:
         # Perform PDF integration along the specified axis
-        return np.trapz(y=distribution, x=x_array, axis=axis)
+        return np.trapezoid(y=distribution, x=x_array, axis=axis)
     # Perform PMS integration
     return np.sum(distribution, axis=axis)

particula/util/tests/coagulation_rate_test.py

@@ -120,22 +120,22 @@ def test_mass():
     """ test mass conservation
     """
 
-    assert np.trapz((gain - loss)*rads**3, rads).u == u.s**-1
-    assert np.trapz((gain - loss)*rads**3, rads) <= 0.2 * u.s**-1
-    assert np.trapz(
+    assert np.trapezoid((gain - loss)*rads**3, rads).u == u.s**-1
+    assert np.trapezoid((gain - loss)*rads**3, rads) <= 0.2 * u.s**-1
+    assert np.trapezoid(
         (gain - loss).to(u.cm**-4/u.s)*rads**3, rads
     ).m == pytest.approx(0.0)
 
     assert (
-        np.absolute(np.trapz((gain - loss)*rads**3, rads))
+        np.absolute(np.trapezoid((gain - loss)*rads**3, rads))
         <=
-        0.005*np.trapz(gain*rads**3, rads)
+        0.005*np.trapezoid(gain*rads**3, rads)
     )
 
     assert (
-        np.absolute(np.trapz((gain - loss)*rads**3, rads))
+        np.absolute(np.trapezoid((gain - loss)*rads**3, rads))
         <=
-        0.005*np.trapz(loss*rads**3, rads)
+        0.005*np.trapezoid(loss*rads**3, rads)
     )
 
 
@@ -151,7 +151,7 @@ def test_res():
     """
 
     assert (
-        np.absolute(np.trapz((gain - loss)*rads**3, rads))
+        np.absolute(np.trapezoid((gain - loss)*rads**3, rads))
         >=
-        np.absolute(np.trapz((fine_gain - fine_loss)*fine_rads**3, fine_rads))
+        np.absolute(np.trapezoid((fine_gain - fine_loss)*fine_rads**3, fine_rads))
     )

particula/util/tests/distribution_discretization_test.py

@@ -18,7 +18,7 @@ def test_discretize():
         interval=spans, disttype="lognormal", gsigma=sigma, mode=modes
     ).size == spans.size
 
-    assert np.trapz(discretize(
+    assert np.trapezoid(discretize(
         interval=spans, disttype="lognormal", gsigma=sigma, mode=modes
     ), spans) == pytest.approx(1, rel=1e-5)
 
@@ -40,7 +40,7 @@ def test_multi_discretize():
         interval=spans, disttype="lognormal", gsigma=sigma, mode=modes
     ).size == spans.size
 
-    assert np.trapz(discretize(
+    assert np.trapezoid(discretize(
         interval=spans, disttype="lognormal", gsigma=sigma, mode=modes
     ), spans) == pytest.approx(1, rel=1e-5)
 

particula/util/tests/simple_solver_test.py

@@ -75,15 +75,15 @@ def test_conservation():
     """
 
     assert (
-        np.trapz((solution.m[0, :]-solution.m[-1, :])*radius**3, radius) /
-        np.trapz((solution.m[0, :])*radius**3, radius)
+        np.trapezoid((solution.m[0, :]-solution.m[-1, :])*radius**3, radius) /
+        np.trapezoid((solution.m[0, :])*radius**3, radius)
         ==
         pytest.approx(0, abs=1e-3)
     )
 
     assert (
-        np.trapz((fine_sols.m[0, :]-fine_sols.m[-1, :])*radius**3, radius) /
-        np.trapz((fine_sols.m[0, :])*radius**3, radius)
+        np.trapezoid((fine_sols.m[0, :]-fine_sols.m[-1, :])*radius**3, radius) /
+        np.trapezoid((fine_sols.m[0, :])*radius**3, radius)
         ==
         pytest.approx(0, abs=1e-3)
     )