PyCosmoMMF 0.3.0__tar.gz → 0.5.0__tar.gz

{pycosmommf-0.3.0 → pycosmommf-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pycosmommf
-Version: 0.3.0
+Version: 0.5.0
 Summary: A package for identifying structures in the cosmic web.
 Project-URL: Homepage, https://github.com/James11222/pycosmommf
 Project-URL: Bug Tracker, https://github.com/James11222/pycosmommf/issues
@@ -26,6 +26,7 @@ License: Copyright 2024 James Sunseri
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
+License-File: LICENSE
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{pycosmommf-0.3.0 → pycosmommf-0.5.0}/src/pycosmommf/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

{pycosmommf-0.3.0 → pycosmommf-0.5.0}/src/pycosmommf/signatures.py

@@ -99,7 +99,7 @@ def maximum_signature(Rs, field, alg="NEXUSPLUS", eps=1e-8):
     sigmax : 4D array
         The maximum signatures.
     """
-    if alg not in ["NEXUS", "NEXUSPLUS"]:
+    if alg not in ["NEXUS", "NEXUSPLUS"]:  # pragma: no cover
         msg = "alg must be either 'NEXUS' or 'NEXUSPLUS'"
         raise ValueError(msg)
 

{pycosmommf-0.3.0 → pycosmommf-0.5.0}/src/pycosmommf/tagging.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-import functools
-
+import numba as nb
 import numpy as np
 import skimage.measure
 
+jit_compiler = nb.njit(parallel=True, fastmath=True)
+
 
 def make_the_clusbool(delta, max_sigs, Δ):  # pragma: no cover
     """
@@ -16,43 +17,57 @@ def make_the_clusbool(delta, max_sigs, Δ):  # pragma: no cover
     change in virialization fraction as a function of 𝒮_cluster.
 
     Arguments:
-
-    delta - [3D Float Array] - delta refers to the δ delta.
+    ----------------
+    delta - [3D Float Array] - delta refers to the δ field.
     max_sigs - [4D Float Array] - the maximum signatures array from CosmoMMF.maximum_signature()
     verbose - [Boolean] - a flag to allow the function to be more helpful and verbose.
     Δ - [Int] - The overdensity parameter threshold for determining virialization. This
     parameter comes from a paper by Gunn & Gott on spherical collapse. Commonly
     used values that are physically motivated can be 370, 200, or 500 (for R_200 or R_500).
+
+    Returns:
+    ----------------
+    clusbool - [3D Boolean Array] - a boolean filter that selects only the clusters in a given cosmological δ field.
+    S_th - [Float] - the threshold value for 𝒮_cluster.
+    signature_thresholds - [1D Float Array] - an array of threshold values for 𝒮_cluster.
+    virialized_fractions - [1D Float Array] - an array of virialized fractions as a function of 𝒮_cluster.
     """
 
     signature_thresholds = np.geomspace(0.1, 30, 10)  # hard coded for now
     virialized_fractions = np.zeros_like(signature_thresholds)
 
-    def check_virialized(j, delta, clumps, Δ):
-        δ_ave = np.mean(delta[clumps == j])
-        return int(δ_ave > Δ)
+    @jit_compiler
+    def calc_virialized_fraction(clumps):
+        nx, ny, nz = clumps.shape
+
+        total_clumps_detected = np.max(clumps)
+        summed_overdensity_per_clump = np.zeros(total_clumps_detected)
+        num_cells_per_clump = np.zeros(total_clumps_detected)
+
+        for i in nb.prange(nx):
+            for j in range(ny):
+                for k in range(nz):
+                    if clumps[i, j, k] != 0:
+                        clump_id = int(
+                            clumps[i, j, k]
+                        )  # clump_id is the clump number ranging from 1 to total_clumps_detected
+                        summed_overdensity_per_clump[clump_id - 1] += delta[i, j, k]
+                        num_cells_per_clump[clump_id - 1] += 1
+
+        return summed_overdensity_per_clump / num_cells_per_clump
 
     for i, S_th in enumerate(signature_thresholds):
         # Identify Clumps with S > S_th
         _clusbool = max_sigs[:, :, :, 0] > S_th
+
         clumps = skimage.measure.label(
-            _clusbool
+            _clusbool.astype(int)
         )  # an array where 0 is background and 1, 2, 3, ... are the clumps
-        total_clumps_detected = np.max(clumps)
-
-        num_clumps_virialized = np.sum(
-            list(
-                map(
-                    functools.partial(
-                        check_virialized, delta=delta, clumps=clumps, Δ=Δ
-                    ),
-                    range(1, total_clumps_detected + 1),
-                )
-            )
-        )  # number of clumps that are virialized
+        averaged_overdensity_per_clump = calc_virialized_fraction(clumps)
 
-        # Calculate the number of virialized clumps
-        virialized_fractions[i] = num_clumps_virialized / total_clumps_detected
+        virialized_fractions[i] = np.sum(averaged_overdensity_per_clump > Δ) / np.max(
+            clumps
+        )
 
     S_th = signature_thresholds[np.abs(virialized_fractions - 0.5).argmin()]
     clusbool = max_sigs[:, :, :, 0] > S_th
@@ -60,14 +75,14 @@ def make_the_clusbool(delta, max_sigs, Δ):  # pragma: no cover
     return clusbool, S_th, signature_thresholds, virialized_fractions
 
 
-def calc_mass_change(sig_vec, delta_vec, Smin, Smax):
+def calc_mass_change(sig_vec, density_vec, Smin, Smax):
     """
     Calculate the mass change curve for a given structure type.
 
     Arguments:
     -----------
         sig_vec - [1D Float Array] - the signature values for a given structure type
-        delta_vec - [1D Float Array] - the delta values for a given structure type
+        density_vec - [1D Float Array] - the density values for a given structure type
         Smin - [Float] - the minimum signature value
         Smax - [Float] - the maximum signature value
 
@@ -83,7 +98,7 @@ def calc_mass_change(sig_vec, delta_vec, Smin, Smax):
     # Sum up all the mass in a structure type as a function of log(𝒮)
     for i in range(len(M)):
         filter = sig_vec > 10 ** log10S[i]
-        M[i] = np.sum(delta_vec[filter])
+        M[i] = np.sum(density_vec[filter])
 
     # Compute the derivative |dM^2/dlog(𝒮)|
     ΔM_2 = np.abs(np.diff(M**2) / np.diff(log10S))
@@ -96,14 +111,14 @@ def calc_mass_change(sig_vec, delta_vec, Smin, Smax):
 
 
 def calc_structure_bools(
-    delta, max_sigs, verbose, clusbool=None, Smin=-3, Smax=2, Δ=370
+    density_cube, max_sigs, verbose, clusbool=None, Smin=-3, Smax=2, Δ=370
 ):
     """
     Calculate the boolean filters for clusters, filaments, walls, and voids.
 
     Arguments:
     -----------
-        delta - [3D Float Array] - the δ delta
+        density_cube - [3D Float Array] - the δ+1 density_cube
         max_sigs - [4D Float Array] - the maximum signatures array from CosmoMMF.maximum_signature()
         verbose - [Boolean] - a flag to allow the function to be more helpful and verbose.
         clusbool - [3D Boolean Array] - the cluster boolean filter
@@ -129,15 +144,15 @@ def calc_structure_bools(
 
     """
 
-    N_cells = np.prod(delta.shape)
+    N_cells = np.prod(density_cube.shape)
 
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     #                 Step 1. Create Cluster Boolean Filter
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-    if clusbool is None:
+    if clusbool is None:  # pragma: no cover
         clusbool, cluster_thresh, S_clus, f_vir_clus = make_the_clusbool(
-            delta, max_sigs, Δ
+            density_cube - 1.0, max_sigs, Δ
         )
     else:
         cluster_thresh = None
@@ -155,10 +170,12 @@ def calc_structure_bools(
     # Isolate Valid Filaments (not clusters)
     not_clus_flat = np.reshape(clusbool == False, N_cells)  # noqa: E712
     filament_valid = filament_signature[not_clus_flat]
-    flat_delta_valid = np.reshape(delta, N_cells)[not_clus_flat]
+    flat_density_cube_valid = np.reshape(density_cube, N_cells)[not_clus_flat]
 
     # Compute Mass Change Curves and Find Filament Threshold
-    S_fil, dM2_fil = calc_mass_change(filament_valid, flat_delta_valid, Smin, Smax)
+    S_fil, dM2_fil = calc_mass_change(
+        filament_valid, flat_density_cube_valid, Smin, Smax
+    )
     ind = np.argmax(dM2_fil)
     filament_thresh = S_fil[ind]
     filbool = (max_sigs[:, :, :, 1] > filament_thresh) & (~clusbool)
@@ -170,10 +187,10 @@ def calc_structure_bools(
     # Isolate Valid Walls (not clusters or filaments)
     wall_valid_filt = (not_clus_flat) & (filament_signature < filament_thresh)
     wall_valid = wall_signature[wall_valid_filt]
-    wall_delta_valid = np.reshape(delta, N_cells)[wall_valid_filt]
+    wall_density_cube_valid = np.reshape(density_cube, N_cells)[wall_valid_filt]
 
     # Compute Mass Change Curves and Find Wall Threshold
-    S_wall, dM2_wall = calc_mass_change(wall_valid, wall_delta_valid, Smin, Smax)
+    S_wall, dM2_wall = calc_mass_change(wall_valid, wall_density_cube_valid, Smin, Smax)
     ind = np.argmax(dM2_wall)
     wall_thresh = S_wall[ind]
     wallbool = (max_sigs[:, :, :, 2] > wall_thresh) & ~(filbool | clusbool)
@@ -190,7 +207,7 @@ def calc_structure_bools(
         print("---------------------------------------\n")
 
         volume_fraction = np.sum(clusbool) / N_cells
-        mass_fraction = np.sum(delta[clusbool]) / np.sum(delta)
+        mass_fraction = np.sum(density_cube[clusbool]) / np.sum(density_cube)
 
         print("Signature Threshold of Clusters:", cluster_thresh)
         print("Volume Fraction of Clusters:", volume_fraction)
@@ -202,7 +219,7 @@ def calc_structure_bools(
         print("---------------------------------------\n")
 
         volume_fraction = np.sum(filbool) / N_cells
-        mass_fraction = np.sum(delta[filbool]) / np.sum(delta)
+        mass_fraction = np.sum(density_cube[filbool]) / np.sum(density_cube)
 
         print("Signature Threshold of Filaments:", filament_thresh)
         print("Volume Fraction of Filaments:", volume_fraction)
@@ -214,7 +231,7 @@ def calc_structure_bools(
         print("---------------------------------------\n")
 
         volume_fraction = np.sum(wallbool) / N_cells
-        mass_fraction = np.sum(delta[wallbool]) / np.sum(delta)
+        mass_fraction = np.sum(density_cube[wallbool]) / np.sum(density_cube)
 
         print("Signature Threshold of Walls:", wall_thresh)
         print("Volume Fraction of Walls:", volume_fraction)
@@ -226,7 +243,7 @@ def calc_structure_bools(
         print("---------------------------------------\n")
 
         volume_fraction = np.sum(voidbool) / N_cells
-        mass_fraction = np.sum(delta[voidbool]) / np.sum(delta)
+        mass_fraction = np.sum(density_cube[voidbool]) / np.sum(density_cube)
 
         print("Volume Fraction of Voids:", volume_fraction)
         print("Mass Fraction of Voids:", mass_fraction)

{pycosmommf-0.3.0 → pycosmommf-0.5.0}/tests/test_integration.py

@@ -30,7 +30,7 @@ def test_calc_structure_bools():
         np.roll(m.sphere(32, 2), -10, axis=0) + np.roll(m.sphere(32, 2), 10, axis=0)
     ) >= 1
     clusbool, filbool, wallbool, voidbool, summary_stats = m.calc_structure_bools(
-        delta=field,
+        field,
         max_sigs=sigs,
         verbose=True,
         clusbool=clusbool,
@@ -42,3 +42,18 @@ def test_calc_structure_bools():
     assert filbool.shape == (32, 32, 32)
     assert wallbool.shape == (32, 32, 32)
     assert voidbool.shape == (32, 32, 32)
+    assert type(summary_stats) is dict
+
+    clusbool, filbool, wallbool, voidbool = m.calc_structure_bools(
+        field,
+        max_sigs=sigs,
+        verbose=False,
+        clusbool=clusbool,
+        Smin=-3,
+        Smax=2,
+        Δ=370,
+    )
+    assert clusbool.shape == (32, 32, 32)
+    assert filbool.shape == (32, 32, 32)
+    assert wallbool.shape == (32, 32, 32)
+    assert voidbool.shape == (32, 32, 32)