PyCosmoMMF 0.4.0__tar.gz → 0.6.0__tar.gz

{pycosmommf-0.4.0 → pycosmommf-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pycosmommf
-Version: 0.4.0
+Version: 0.6.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.4.0 → pycosmommf-0.6.0}/src/pycosmommf/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)

{pycosmommf-0.4.0 → pycosmommf-0.6.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.4.0 → pycosmommf-0.6.0}/src/pycosmommf/tagging.py

@@ -18,7 +18,7 @@ def make_the_clusbool(delta, max_sigs, Δ):  # pragma: no cover
 
     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
@@ -75,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
 
@@ -98,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))
@@ -111,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
@@ -144,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
@@ -170,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)
@@ -185,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)
@@ -204,47 +206,47 @@ def calc_structure_bools(
         print("     Cluster Boolean Filter Report    ")
         print("---------------------------------------\n")
 
-        volume_fraction = np.sum(clusbool) / N_cells
-        mass_fraction = np.sum(delta[clusbool]) / np.sum(delta)
+        volume_fraction_clus = np.sum(clusbool) / N_cells
+        mass_fraction_clus = np.sum(density_cube[clusbool]) / np.sum(density_cube)
 
         print("Signature Threshold of Clusters:", cluster_thresh)
-        print("Volume Fraction of Clusters:", volume_fraction)
-        print("Mass Fraction of Clusters:", mass_fraction)
+        print("Volume Fraction of Clusters:", volume_fraction_clus)
+        print("Mass Fraction of Clusters:", mass_fraction_clus)
         print("")
 
         print("---------------------------------------")
         print("     Filament Boolean Filter Report    ")
         print("---------------------------------------\n")
 
-        volume_fraction = np.sum(filbool) / N_cells
-        mass_fraction = np.sum(delta[filbool]) / np.sum(delta)
+        volume_fraction_fil = np.sum(filbool) / N_cells
+        mass_fraction_fil = np.sum(density_cube[filbool]) / np.sum(density_cube)
 
         print("Signature Threshold of Filaments:", filament_thresh)
-        print("Volume Fraction of Filaments:", volume_fraction)
-        print("Mass Fraction of Filaments:", mass_fraction)
+        print("Volume Fraction of Filaments:", volume_fraction_fil)
+        print("Mass Fraction of Filaments:", mass_fraction_fil)
         print("")
 
         print("---------------------------------------")
         print("       Wall Boolean Filter Report      ")
         print("---------------------------------------\n")
 
-        volume_fraction = np.sum(wallbool) / N_cells
-        mass_fraction = np.sum(delta[wallbool]) / np.sum(delta)
+        volume_fraction_wall = np.sum(wallbool) / N_cells
+        mass_fraction_wall = np.sum(density_cube[wallbool]) / np.sum(density_cube)
 
         print("Signature Threshold of Walls:", wall_thresh)
-        print("Volume Fraction of Walls:", volume_fraction)
-        print("Mass Fraction of Walls:", mass_fraction)
+        print("Volume Fraction of Walls:", volume_fraction_wall)
+        print("Mass Fraction of Walls:", mass_fraction_wall)
         print("")
 
         print("---------------------------------------")
         print("       Void Boolean Filter Report      ")
         print("---------------------------------------\n")
 
-        volume_fraction = np.sum(voidbool) / N_cells
-        mass_fraction = np.sum(delta[voidbool]) / np.sum(delta)
+        volume_fraction_void = np.sum(voidbool) / N_cells
+        mass_fraction_void = np.sum(density_cube[voidbool]) / np.sum(density_cube)
 
-        print("Volume Fraction of Voids:", volume_fraction)
-        print("Mass Fraction of Voids:", mass_fraction)
+        print("Volume Fraction of Voids:", volume_fraction_void)
+        print("Mass Fraction of Voids:", mass_fraction_void)
         print("\n---------------------------------------\n")
 
         summary_data = {
@@ -252,8 +254,22 @@ def calc_structure_bools(
             "f_vir_clus": f_vir_clus,
             "S_fil": S_fil,
             "dM2_fil": dM2_fil,
+            "S_fil_thresh": filament_thresh,
             "S_wall": S_wall,
             "dM2_wall": dM2_wall,
+            "S_wall_thresh": wall_thresh,
+            "mass_fractions": [
+                mass_fraction_clus,
+                mass_fraction_fil,
+                mass_fraction_wall,
+                mass_fraction_void,
+            ],
+            "volume_fractions": [
+                volume_fraction_clus,
+                volume_fraction_fil,
+                volume_fraction_wall,
+                volume_fraction_void,
+            ],
         }
 
         return clusbool, filbool, wallbool, voidbool, summary_data

{pycosmommf-0.4.0 → pycosmommf-0.6.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)