Merge pull request #20 from EMSL-Computing/joss-edits

Joss edits complete

Author: maruti-iitm

examples/example_7_flow_2d_pinn_on_XCT.ipynb

@@ -236,7 +236,9 @@
    ],
    "source": [
     "# Plot for the Boundary conditions and collocation for training \n",
-    "x_b1, y_b1, bc_1, x_b2, y_b2, bc_2, x_b3, y_b3, bc_3, x_b4, y_b4, bc_4, x_c, y_c, conds, colloc = generate_BCs_and_colloc_xct(X, Y, norm_P1, norm_P2, dP_dy1, dP_dy2) \n",
+    "x_b1, y_b1, bc_1, x_b2, y_b2, bc_2, x_b3, y_b3, bc_3, x_b4, y_b4, bc_4, x_c, y_c, conds, colloc = generate_BCs_and_colloc_xct(X, Y, norm_P1, \n",
+    "                                                                                                                              norm_P2, dP_dy1, \n",
+    "                                                                                                                              dP_dy2) \n",
     "plot_boundary_conditions(x_b1, y_b1, bc_1*max_P, x_b2, y_b2, bc_2*max_P, x_b3, y_b3, bc_3*max_P, x_b4, y_b4, bc_4*max_P, x_c, y_c, results_dir)"
    ]
   },
@@ -310,7 +312,17 @@
     "print('-------------------------------------------------------')\n",
     "\n",
     "# PINN training\n",
-    "best_params, best_loss, all_losses, all_epochs = train_PINN(params, epochs, optimizer, loss_fun, colloc, conds, norm_coeff, hidden_layers, hidden_nodes, lr, results_dir)"
+    "best_params, best_loss, all_losses, all_epochs = train_PINN(params, \n",
+    "                                                            epochs, \n",
+    "                                                            optimizer, \n",
+    "                                                            loss_fun, \n",
+    "                                                            colloc, \n",
+    "                                                            conds, \n",
+    "                                                            norm_coeff, \n",
+    "                                                            hidden_layers, \n",
+    "                                                            hidden_nodes, \n",
+    "                                                            lr, \n",
+    "                                                            results_dir)"
    ]
   },
   {

src/pore2chip/metrics.py

@@ -1,7 +1,7 @@
 import numpy as np
 from skimage.measure import label, regionprops
 import feret
-from porespy import networks, networks, filters
+from porespy import networks, networks, filters, metrics
 import openpnm as op
 import copy
 from skimage.segmentation import watershed
@@ -118,12 +118,12 @@ def extract_diameters2(img_list, voxel_size=1, sigma_val=0.4):
     sigma = sigma_val
     dt = spim.distance_transform_edt(input=img_list)
     dt1 = spim.gaussian_filter(input=dt, sigma=sigma)
-    peaks = ps.filters.find_peaks(dt=dt)
+    peaks = filters.find_peaks(dt=dt)
 
     #print('Initial number of peaks: ', spim.label(peaks)[1])
-    peaks = ps.filters.trim_saddle_points(peaks=peaks, dt=dt1)
+    peaks = filters.trim_saddle_points(peaks=peaks, dt=dt1)
     #print('Peaks after trimming saddle points: ', spim.label(peaks)[1])
-    peaks = ps.filters.trim_nearby_peaks(peaks=peaks, dt=dt)
+    peaks = filters.trim_nearby_peaks(peaks=peaks, dt=dt)
     peaks, N = spim.label(peaks)
     #print('Peaks after trimming nearby peaks: ', N)
 

tests/test_metrics.py

@@ -2,6 +2,7 @@
 import os
 import time
 import numpy as np
+import porespy as ps  # ✅ Add this line to fix the NameError
 from skimage.draw import ellipse
 from pathlib import Path
 from porespy.generators import cylinders

tests/test_train_pinn.py

@@ -36,36 +36,36 @@ class TestTrainPINN(unittest.TestCase):
     - Different optimizers and loss functions: Ensures the function works correctly with various optimizers and loss functions.
     - Multiple layers and nodes: Tests the function with different feed-forward neural network architectures.
     """
-
+    
     def setUp(self):
         """
         Sets up the test environment and initializes common test parameters.
-        The `setUp` method is called before every test function in this class.
-        It initializes the parameters, optimizer, and other inputs used by
-        the `train_PINN` function.
+        Ensures `weights` and `colloc` are not equal to test loss properly.
         """
-        # Initialize common test parameters
+        # Initialize weights and collocation points to be different
         self.params = [{
             'weights': jnp.array([1.0, 2.0]),  # Initial weights
-            'biases': jnp.array([0.5])  # Initial biases
+            'biases': jnp.array([0.5])
         }]
-        self.epochs = 100  # Number of training epochs
-        self.optimizer = optax.adam(
-            0.001)  # Adam optimizer with learning rate 0.001
+        self.colloc = jnp.array([3.0, -1.0])  # Different from weights to ensure meaningful loss
+        assert not jnp.array_equal(self.params[0]['weights'], self.colloc), \
+            "Initial weights and collocation points should not be equal."
+    
+        self.epochs = 100
+        self.optimizer = optax.adam(0.1)
         self.loss_fun = lambda params, colloc, conds, norm_coeff: jnp.mean(
-            (params[0]['weights'] - colloc)**2)  # Simple loss function
-        self.colloc = jnp.array([1.0, 2.0])  # Collocation points
-        self.conds = [jnp.array([1.0, 2.0])]  # Boundary conditions
-        self.norm_coeff = jnp.array([1.0])  # Normalization coefficient
-        self.hidden_layers = 2  # Number of hidden layers in the neural network
-        self.hidden_nodes = 10  # Number of hidden nodes for each layer
-        self.lr = 0.001  # Learning rate for the optimizer
-        self.results_dir = './results/'  # Results directory to save the .pkl file
-
-        # Create results directory if it doesn't exist
+            (params[0]['weights'] - colloc) ** 2)
+        self.conds = [jnp.array([1.0, 2.0])]
+        self.norm_coeff = jnp.array([1.0])
+        self.hidden_layers = 2
+        self.hidden_nodes = 10
+        self.lr = 0.001
+        self.results_dir = './results/'
+    
         if not os.path.exists(self.results_dir):
             os.makedirs(self.results_dir)
 
+
     def test_train_PINN_output(self):
         """
         Test the output of the `train_PINN` function.
@@ -296,14 +296,19 @@ def test_train_PINN_multiple_layers_nodes(self):
                     best_params)  # Ensure best_params is not None
                 self.assertLessEqual(best_loss,
                                      float('inf'))  # Ensure loss is finite
+                
+                
 
 
-def main():
-    """
-    Run the unit tests when script is executed `python test_train_pinn.py`.
-    """
+if __name__ == '__main__':
+    # Option 1: Run through standard unittest (preserves CLI usability)
     unittest.main()
 
-
-if __name__ == '__main__':
-    main()
+    # Option 2: Also make individual test methods REPL-executable
+    print("\nManual REPL-friendly execution of each test case:")
+    t = TestTrainPINN()
+    t.setUp()
+    for item in dir(t):
+        if item.startswith('test_'):
+            print(f'\nRunning test: {item}')
+            getattr(t, item)()