silicon 512x512 uniform random

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/masks/sample_100.0_percent_coarse_J=9_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0acd32b99c7188ffb30eacfc6f0f0eae72734665c91e0c57c01f389ab059aaed
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/masks/sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08d975fc0f430ce90488355ee474486f5d1297752c07c066c192f72ab4bf1089
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/masks/sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2c33b815ead366cccd98fd520b879483a0b19ace29667ad87884d00c2dbf65a
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/masks/sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9b0b77268fde8e3b49b46cb93a062ec73658f446500e7042217adf95c66767e
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/metrics.csv

@@ -0,0 +1,4 @@
+sampling_percentage,  coarse_J,  mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon
+80.0,  7,  0.0008673915290273726,  29.5692138671875,  0.8141728043556213,  0.992389976978302,  7.899784395704046e-05,  39.97521209716797,  0.9804431796073914,  0.999309241771698
+50.0,  7,  0.0022277969401329756,  25.472606658935547,  0.637307345867157,  0.9803352952003479,  0.0003110810066573322,  34.02263259887695,  0.9316715002059937,  0.9972780346870422
+20.0,  7,  0.0034481799229979515,  23.575464248657227,  0.5139636993408203,  0.969394326210022,  0.0007311280351132154,  30.311429977416992,  0.8477615118026733,  0.9935988187789917

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_100.0_percent_coarse_J=9_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f83d638995382e7b541b73da293948e7be8c5f30e642ab39562832921bc5741
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34538441d5307eaf5c0f50fd9ba63aa90912a588f72f1e10ddbbab0a9f8d1cb0
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d2f3a32d6cf09fc15b0e9835e3663a8eedc92d173f28fe78017768d0051d2a6
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ab529e3a5d7d0dda42328376fbd1d88244f963b7014cbf591ca4f8459409734
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/spgl1_factor=1/metrics.csv

@@ -0,0 +1,4 @@
+sampling_percentage,  coarse_J,  mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon
+80.0,  7,  0.0008673915290273726,  29.5692138671875,  0.8141728043556213,  0.992389976978302,  0.00043301511323079467,  32.586334228515625,  0.8907831311225891,  0.996208906173706
+50.0,  7,  0.0022277969401329756,  25.472606658935547,  0.637307345867157,  0.9803352952003479,  0.0012727321591228247,  27.903993606567383,  0.7090804576873779,  0.9888210296630859
+20.0,  7,  0.0034481799229979515,  23.575464248657227,  0.5139636993408203,  0.969394326210022,  0.002841492183506489,  24.4158992767334,  0.4880824089050293,  0.974962592124939

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_100.0_percent_coarse_J=9_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb7bb08b29c60ffab15f09da07e7c4a0150b8f617ed66db2da36d75037e9f1d2
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6cb0fd15ad31f532208bae4903400151cd6bbb2c4f6c6be7ba1a87fdea94b8af
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:403079cfeb96486acd1df703ea8b1fa4cbdd10f5e27a4a250606e8931f13f387
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5094faab95d48ddbf299cfc24e00b0f55efa166b7348e960ef819d090c7cf08b
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/zero_filled/example_silicon_512x512_sample_100.0_percent_coarse_J=9_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e63752867153095c1a2e937e9bfe34b40bb8006b0908cd314a7639bdb693d2
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/zero_filled/example_silicon_512x512_sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60b06251f9de3c10b8f3723e25e731de0f1b12fd272e039d718065fc1d8307b6
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/zero_filled/example_silicon_512x512_sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a380f8b3a8c3f77aa954b7ef1795e27ed551032bc052dbfae40fa9aea9717a64
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_0/zero_filled/example_silicon_512x512_sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab5187aa42cd0d9085b55b956ee74b514b1ff054edc2e24995a8262d2aac6680
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/masks/sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4acce3a8feeba48165975775895a66cfffd5136a09279ede4c1e99eea216598b
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/masks/sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb873154bcfce551b83c390f8d318cef112e6732f7006e3b97777c3b03ddca15
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/masks/sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d7d554a34b647b514646bbf2076dab0f1b90c6f8a1465a283bf876ea55bda2a
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/photocurrent_mapping copy.py

@@ -0,0 +1,881 @@
+# %% [markdown]
+# # Plug-and-play ADMM for Photocurrent Mapping image reconstruction
+#
+# This notebook demonstrates Plug-and-Play (PnP) ADMM image reconstruction for
+# Photocurrent Mapping (PCM) data.
+#
+# Starting from a high-resolution current map of a CIGS solar cell, subsampled
+# PCM measurements are simulated using the `PhotocurrentMapOp` operator. Several
+# reconstruction methods are then compared:
+#
+# - Zero-filled pseudo-inverse reconstruction.
+# - Two compressed sensing baselines with a wavelet sparsity prior:
+#   FISTA with an $\ell_1$ penalty and SPGL1.
+# - PnP-ADMM with a pre-trained DRUNet denoiser as prior.
+#
+# The goal is not to optimise performance, but to illustrate how
+# classical sparse reconstruction methods and PnP can be combined with the LION
+# operators for PCM.
+
+
+# %% [markdown]
+# ## Setup
+
+# %% [markdown]
+# ### Device configuration
+#
+# Set the default device to a GPU if available. If multiple GPUs are present,
+# the desired GPU index can be specified here.
+
+# %%
+from __future__ import annotations
+from calendar import c
+from operator import inv
+
+from cv2 import add, log
+import test
+import torch
+from wandb import init
+
+device = torch.device("mps" if torch.backends.mps.is_available() else "cuda:0" if torch.cuda.is_available() else "cpu")
+torch.set_default_device(device)
+
+# %% [markdown]
+# ### Imports
+#
+# Import the required libraries, including LION operators and reconstruction algorithms for PCM.
+
+# %%
+from datetime import datetime
+from pathlib import Path
+from typing import Callable, Iterable
+
+import deepinv
+import matplotlib
+import matplotlib.pyplot as plt
+from matplotlib.colors import ListedColormap
+import numpy as np
+from jaxtyping import Float
+from torchmetrics.image import PeakSignalNoiseRatio, StructuralSimilarityIndexMeasure
+from functools import partial
+from tqdm import tqdm as std_tqdm
+
+from LION.classical_algorithms.fista import fista_l1
+from LION.classical_algorithms.spgl1_torch import spgl1_torch
+from LION.operators.Wavelet2D import Wavelet2D
+from LION.operators.CompositeOp import CompositeOp
+from LION.operators.DebiasOp import debias_ls
+
+# LION imports
+from LION.operators.PhotocurrentMapOp import PhotocurrentMapOp
+from LION.operators.uniform_random_sample import uniform_random_sample
+from LION.operators.multilevel_sample import multilevel_sample
+from LION.reconstructors.PnP import PnP
+
+# from LION.utils.scale import choose_measurement_scale_factor
+
+from plot_helper import PlotHelper
+
+
+# Use tqdm with dynamic column width that adapts to the terminal width
+tqdm = partial(std_tqdm, dynamic_ncols=True)
+tqdm_no_leave = partial(std_tqdm, dynamic_ncols=True, leave=False)
+
+GrayscaleImage2D = Float[torch.Tensor, "height width"]
+Measurement1D = Float[torch.Tensor, "num_measurements"]
+
+# %% [markdown]
+# ### Define the data file paths
+#
+# The example uses a single $256 \times 256$ current map of a CIGS solar cell
+# stored as a NumPy array. This image will serve as the ground truth in the
+# experiments.
+
+# %%
+data_dir = Path("data/photocurrent_data")
+# data_dir = Path("your/path/to/photocurrent_data")
+
+assert data_dir.exists(), f"Data directory {data_dir} does not exist."
+
+# These images are provided with pixels in range [0, 1]
+# data_name, zoom, loc, loc1, loc2, roi = "CIGS_256x256", 2.5, "center left", 3, 4, (110, 210, 40, 40)  # (x, y, w, h)  with y increasing downwards
+# data_name, zoom, loc, loc1, loc2, roi = "silicon_256x256", 2.5, "lower right", 2, 1, (194, 1, 60, 60)  # (x, y, w, h)  with y increasing downwards
+data_name, zoom, loc, loc1, loc2, roi = "silicon_512x512", 3, "lower right", 2, 1, (400, 5, 100, 100)  # (x, y, w, h)  with y increasing downwards
+# data_name, zoom, loc, loc1, loc2, roi = "organic_256x256", 2.5, "lower left", 2, 1, (70, 5, 50, 50)  # (x, y, w, h)  with y increasing downwards
+# data_name, zoom, loc, loc1, loc2, roi = "perovskite_256x256", 2.5, "upper left", 3, 4, (90, 190, 50, 50)  # (x, y, w, h)  with y increasing downwards
+data_name = "example_" + data_name  # prefix with "example_"
+is_out_of_distribution = False
+clim = (0.0, 1.0)
+inverses_sign = False
+# R_high, R_low = 1.0, 0.0  # default for normalized images
+is_out_of_distribution = False
+factor = 1  # no scaling for normalized images
+
+# # This sample was provided in image form at 512x512 resolution but the pixels are real measured current values
+# data_name, zoom, loc, loc1, loc2, roi = "Si_256_512x512", 2.5, "lower left", 2, 1, (160, 60, 120, 120)
+# clim = (0.0, 3e-5)
+# inverses_sign = True
+# R_high = 1e-4
+# R_low = -5e-6
+# factor = 1e5  # to scale up the photocurrent values for better numerical stability in SPGL1
+
+# # This sample was provided in image form at 512x512 resolution but the pixels are real measured current values
+# data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_512x512", 2.5, "lower right", 2, 1, (322, 85, 100, 100)
+# clim = (0.0, 1.5e-5)
+# inverses_sign = True
+# R_high = 2e-5
+# R_low = -2e-6
+# factor = 1e5  # to scale up the photocurrent values for better numerical stability in SPGL1
+
+if "256x256" in data_name:
+    J_order = 8  # J=8 => 2^8=256
+elif "512x512" in data_name:
+    J_order = 9  # J=9 => 2^9=512
+else:
+    raise ValueError(f"Unknown data_name {data_name}, cannot determine order_size.")
+
+# # # This is the same data as Si_256_512x512 but provided as measurement data and only up to 256x256 resolution
+# data_name, zoom, loc, loc1, loc2, roi = "Si_256_measurement_data", 2, "lower left", 2, 1, (80, 30, 60, 60)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_256_hadamard_measurement_vector", 2, "lower left", 2, 1, (80, 30, 60, 60)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_256_reconstructed_image", 2, "lower left", 2, 1, (80, 30, 60, 60)
+# clim = (0.0, 1e-6)
+# R_high = 1e-6
+# R_low = -1e-6
+# factor = 1e7  # to scale up the photocurrent values for better numerical stability in SPGL1
+# J_order = 8  # 2^8 x 2^8 = 256 x 256
+
+# # # This is the same data as Si_2_256_512x512 but provided as measurement data and only up to 256x256 resolution
+# data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_measurement_data", 2, "lower left", 2, 1, (32, 42, 50, 50)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_hadamard_measurement_vector", 2, "lower left", 2, 1, (32, 42, 50, 50)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_reconstructed_image", 2, "lower left", 2, 1, (32, 42, 50, 50)
+# clim = (0.0, 4e-7)
+# R_high = 1e-6
+# R_low = -1e-6
+# factor = 1e7  # to scale up the photocurrent values for better numerical stability in SPGL1
+# J_order = 8  # 2^8 x 2^8 = 256 x 256
+
+# scale_eps = 1e-12
+# is_out_of_distribution = True
+# inverses_sign = True
+
+tests_scale_ground_truth = False
+
+data_filename = f"{data_name}.npy"
+print("Loading data file:", data_filename)
+assert (data_dir / data_filename).exists(), f"Data {data_filename} not found in {data_dir}."
+
+# data_type = "original_measurement_data"
+# data_type = "hadamard_measurement_vector"
+data_type = "image"
+print(f"The type of raw data is: {data_type}")
+
+noise_seed = 42
+noise_std = 0  # No noise
+# noise_std = 0.05  # standard deviation of additive homoscedastic Gaussian white noise added to measurements
+
+num_trials = 10
+num_trials_skip = 1
+
+runs_pnp_admm = True
+# pnp_admm_iters = 1
+# pnp_admm_iters = 20
+pnp_admm_iters = 50
+# pnp_admm_iters = 100
+# pnp_admm_iters = 150
+# pnp_admm_eta = 0.00001  # Undersampling artifacts may remain if eta is too small
+# pnp_admm_eta = 0.00005  # Could still work
+# pnp_admm_eta = 0.0001  # Could still work
+# pnp_admm_eta = 0.001
+# pnp_admm_eta = 0.005
+pnp_admm_eta = 0.01  # Generally good
+# pnp_admm_eta = 0.02
+# pnp_admm_eta = 0.03
+# pnp_admm_eta = 0.04
+# pnp_admm_eta = 0.05
+# pnp_admm_eta = 0.1
+# pnp_admm_eta = 1
+# pnp_admm_eta = 10
+# pnp_admm_eta = 20
+# pnp_admm_eta = 50
+# pnp_admm_eta = 100  # Got nan for 100% sampling?
+cg_iters = 20
+# cg_iters = 50
+cg_eps = 1e-20  # No real change compared to default, CG usually terminates quickly especially when measurements are small
+# drunet_sigma = 0.01  # noise level for DRUNet denoiser
+# drunet_sigma = 0.02  # noise level for DRUNet denoiser
+drunet_sigma = 0.05  # noise level for DRUNet denoiser
+# drunet_sigma = 0.1  # noise level for DRUNet denoiser
+
+runs_fista_l1 = False
+
+runs_spgl1 = True
+
+# randomizing_scheme = "multilevel"
+randomizing_scheme = "uniform"
+
+cmap_max = 0.8  # take only the lower 0-80% of afmhot, reduce brightness
+# cmap_max = 0.9  # take only the lower 0-90% of afmhot to avoid the white top
+# cmap_max = 1.0  # take all of afmhot
+adds_insets = True
+# adds_insets = False
+plot_helper = PlotHelper(
+    roi=roi,
+    zoom=zoom,
+    loc=loc,
+    show_rect=True,
+    cmap=ListedColormap(matplotlib.colormaps['afmhot'](np.linspace(
+        0.0,
+        cmap_max,
+        256,
+    ))),
+    clim=clim,
+    loc1=loc1,
+    loc2=loc2
+)
+
+# %% [markdown]
+# Define a general function to run the photocurrent mapping reconstruction using a reconstruction method.
+#
+# The helper function `run_pcm_demo`:
+#
+# - Builds the PCM operator and simulates subsampled measurements.
+# - Computes the zero-filled pseudo-inverse reconstruction.
+# - Runs a chosen reconstruction method given by `recon_fn`.
+# - Reports PSNR and SSIM for both reconstructions, displays and saves the images.
+
+
+# %% mystnb={"code_prompt_show": "Show utility details"} tags=["hide-cell"]
+def show_images_with_inset(
+    images: list[torch.Tensor],
+    fig_filepath: Path,
+    plot_helper: PlotHelper,
+    titles: list[str] | None = None,
+    suptitle: str | None = None,
+    adds_insets: bool = True,
+) -> None:
+    """Plot images."""
+    n_images = len(images)
+    fig, axes = plt.subplots(1, n_images, squeeze=False, figsize=(n_images * 4, 4))
+
+    for i in range(n_images):
+        img_np = images[i].squeeze().cpu().numpy()
+        ax: plt.Axes = axes[0][i]
+        if adds_insets:
+            plot_helper.add_zoom_inset(ax, img_np)
+        else:
+            ax.imshow(img_np, cmap=plot_helper.cmap, clim=plot_helper.clim)
+        ax.axis("off")
+        if titles:
+            ax.set_title(titles[i], fontsize=10)
+    if suptitle:
+        fig.subplots_adjust(bottom=0.18)
+        fig.text(0.5, 0.02, suptitle, ha="center", va="bottom", fontsize=16)
+    fig.savefig(fig_filepath, dpi=150)
+    plt.close(fig)
+
+
+def make_csv(method_name: str, log_dir: Path | str) -> None:
+    log_dir = Path(log_dir) / method_name
+    log_dir.mkdir(parents=True, exist_ok=True)
+    csv_path = log_dir / "metrics.csv"
+    with csv_path.open("w") as f:
+        f.write(
+            "sampling_percentage,  coarse_J,  "
+            "mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  "
+            "mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon\n"
+        )
+
+
+# %%
+def run_pcm_demo(
+    recon_description: str,
+    recon_fn: Callable[[PhotocurrentMapOp, Measurement1D, GrayscaleImage2D], GrayscaleImage2D],
+    ground_truth_image: GrayscaleImage2D,
+    method_name: str,
+    image_name: str,
+    J: int,  # image size will be 2^J x 2^J
+    sampling_ratio: float,
+    coarse_J: int,
+    measurement_vector: Measurement1D | None = None,
+    log_dir: Path | str = ".",
+    device: torch.device | str = "cuda:0",
+    seed: int = 0,
+):
+    zero_filled_dir = Path(log_dir) / "zero_filled"
+    zero_filled_dir.mkdir(parents=True, exist_ok=True)
+    masks_dir = Path(log_dir) / "masks"
+    masks_dir.mkdir(parents=True, exist_ok=True)
+
+    log_dir = Path(log_dir) / method_name
+    log_dir.mkdir(parents=True, exist_ok=True)
+    N = 1 << J
+    im_tensor = ground_truth_image.unsqueeze(0).unsqueeze(0)  # (1,1,H,W)
+
+    sampling_percentage = sampling_ratio * 100
+    in_order_measurements_percentage = (1 << (2 * coarse_J)) / (N * N) * 100
+    print()
+    print(f"Sampling rate: {sampling_percentage}%")
+    print(f"Coarse levels to keep: {coarse_J} ({in_order_measurements_percentage}%)")
+
+    rng = np.random.default_rng(seed)
+    num_samples = int(sampling_ratio * N * N)
+    if randomizing_scheme == "multilevel":
+        sampled_indices = multilevel_sample(
+            J=J, num_samples=num_samples, coarse_J=coarse_J, alpha=1.0, rng=rng
+        )
+    elif randomizing_scheme == "uniform":
+        sampled_indices = uniform_random_sample(
+            J=J, num_samples=num_samples, coarse_J=coarse_J, rng=rng
+        )
+    else:
+        raise ValueError(f"Unknown sampling_scheme {randomizing_scheme}.")
+    pcm_op = PhotocurrentMapOp(J=J, sampled_indices=sampled_indices, device=device)
+
+    if measurement_vector is not None:
+        print(f"Using provided measurement vector with shape {measurement_vector.shape}.")
+        y_subsampled_tensor_noiseless = measurement_vector[sampled_indices]
+    else:
+        y_subsampled_tensor_noiseless = pcm_op(im_tensor)
+
+    y_subsampled_tensor = y_subsampled_tensor_noiseless  # No noise
+
+    # noise_rng = torch.Generator(device=device)
+    # noise_rng.manual_seed(noise_seed)
+    # homoscedastic_noise = y_subsampled_tensor_noiseless.normal_(
+    #     mean=0.0, std=noise_std, generator=noise_rng
+    # )
+    # noise = homoscedastic_noise
+    # noise = torch.zeros_like(y_subsampled_tensor_noiseless)
+    # assert torch.equal(noise, torch.zeros_like(noise)), "Noise is not zero!"
+
+    # y_subsampled_tensor = y_subsampled_tensor_noiseless + noise
+
+    zero_filled_recon_tensor = (
+        pcm_op.pseudo_inv(y_subsampled_tensor).unsqueeze(0).unsqueeze(0)
+    )
+
+    recon_tensor = (
+        recon_fn(
+            pcm_op=pcm_op,
+            pcm_measurement=y_subsampled_tensor,
+            initial_image=zero_filled_recon_tensor.squeeze(),
+        )
+        .unsqueeze(0)
+        .unsqueeze(0)
+    )
+
+    data_range = (im_tensor.max() - im_tensor.min()).item()
+    psnr = PeakSignalNoiseRatio(data_range=data_range).to(device)
+    ssim = StructuralSimilarityIndexMeasure(data_range=data_range).to(device)
+
+    psnr_zero_filled = psnr(zero_filled_recon_tensor, im_tensor)
+    psnr_recon = psnr(recon_tensor, im_tensor)
+
+    ssim_zero_filled = ssim(zero_filled_recon_tensor, im_tensor)
+    ssim_recon = ssim(recon_tensor, im_tensor)
+
+    mse_zero_filled = torch.mean((zero_filled_recon_tensor - im_tensor) ** 2).item()
+    mse_recon = torch.mean((recon_tensor - im_tensor) ** 2).item()
+
+    pearson_corr_zero_filled = torch.corrcoef(torch.stack([zero_filled_recon_tensor.flatten(), im_tensor.flatten()]))[0,1].item()
+    pearson_corr_recon = torch.corrcoef(torch.stack([recon_tensor.flatten(), im_tensor.flatten()]))[0,1].item()
+
+    csv_path = log_dir / "metrics.csv"
+    with csv_path.open("a") as f:
+        f.write(
+            f"{sampling_percentage},  {coarse_J},  "
+            f"{mse_zero_filled},  {psnr_zero_filled},  {ssim_zero_filled},  {pearson_corr_zero_filled},  "
+            f"{mse_recon},  {psnr_recon},  {ssim_recon},  {pearson_corr_recon}\n"
+        )
+
+    filename = f"{image_name}_{method_name}_sample_{sampling_percentage}_percent_coarse_J={coarse_J}_{randomizing_scheme}_random"
+    zero_filled_filename = f"{image_name}_sample_{sampling_percentage}_percent_coarse_J={coarse_J}_{randomizing_scheme}_random"
+    recons_dir = log_dir / "recons"
+    recons_dir.mkdir(parents=True, exist_ok=True)
+    np.save(zero_filled_dir / f"{zero_filled_filename}.npy", zero_filled_recon_tensor.squeeze().cpu().numpy())
+    np.save(recons_dir / f"{filename}.npy", recon_tensor.squeeze().cpu().numpy())
+
+    mask_of_masks_np = np.zeros(N * N, dtype=bool)
+    mask_of_masks_np[sampled_indices] = True
+    np.save(masks_dir / f"sample_{sampling_percentage}_percent_coarse_J={coarse_J}_{randomizing_scheme}_random.npy", mask_of_masks_np.reshape(N, N))
+
+    images_dir = log_dir / "images"
+    images_dir.mkdir(parents=True, exist_ok=True)
+
+    show_images_with_inset(
+        [im_tensor, zero_filled_recon_tensor, recon_tensor],
+        fig_filepath=images_dir / f"{filename}.png",
+        plot_helper=plot_helper,
+        titles=[
+            "Original Image",
+            f"Inverse WHT (Zero-filled)\nPSNR: {psnr_zero_filled:.2f} dB, SSIM: {ssim_zero_filled:.4f}\nMSE: {mse_zero_filled:.3e}, Pearson Corr.: {pearson_corr_zero_filled:.4f}",
+            f"{recon_description}\nPSNR: {psnr_recon:.2f} dB, SSIM: {ssim_recon:.4f}\nMSE: {mse_recon:.3e}, Pearson Corr.: {pearson_corr_recon:.4f}",
+        ],
+        suptitle=(
+            f"PCM Reconstructions, J={J} ({N}x{N} image)\n"
+            + f"Sample {sampling_percentage:.2f}%, keep {coarse_J} coarse levels ({in_order_measurements_percentage}% here), the rest: {randomizing_scheme} random"
+        ),
+        adds_insets=adds_insets,
+    )
+
+# %%
+denoiser_DRUNet = deepinv.models.DRUNet(
+    pretrained="download", in_channels=1, out_channels=1, device=device
+)
+
+def run_pnp_admm(
+    pcm_op: PhotocurrentMapOp, pcm_measurement: Measurement1D, initial_image: GrayscaleImage2D
+) -> GrayscaleImage2D:
+    admm_iterations = pnp_admm_iters
+    admm_eta = pnp_admm_eta
+    cg_max_iter = cg_iters
+    _cg_eps = cg_eps
+    cg_rel_tol = 0.0
+
+    # print(
+    #     f"Running PnP-ADMM reconstruction: {admm_iterations} iterations, cg_max_iter={cg_max_iter}..."
+    # )
+
+    if is_out_of_distribution:
+        a = max(R_high - R_low, scale_eps)
+
+    # pcm_measurement = (pcm_measurement - R_low) / a if is_out_of_distribution else pcm_measurement
+
+    def denoiser_fn(x: GrayscaleImage2D) -> GrayscaleImage2D:
+        with torch.no_grad():
+            model_input = (x - R_low) / a if is_out_of_distribution else x
+            model_output = (
+                denoiser_DRUNet(model_input.unsqueeze(0).unsqueeze(0), sigma=drunet_sigma)
+                .squeeze(0)
+                .squeeze(0)
+            )
+            model_output = a * model_output + R_low if is_out_of_distribution else model_output
+            return model_output
+
+    pnp = PnP(physics=pcm_op, prior_fn=denoiser_fn, default_algorithm="ADMM")
+    recon = pnp.admm_algorithm(
+        measurement=pcm_measurement,
+        eta=admm_eta,
+        max_iter=admm_iterations,
+        cg_max_iter=cg_max_iter,
+        cg_eps=_cg_eps,
+        cg_rel_tol=cg_rel_tol,
+        prog_bar=tqdm,
+        # cg_prog_bar=tqdm,
+    )
+    # recon = pnp.forward_backward_splitting(
+    #     sino=pcm_measurement,
+    # )
+
+    return recon
+    # return a * recon + R_low if is_out_of_distribution else recon
+
+
+
+
+# %%
+def run_fista_l1(
+    pcm_op: PhotocurrentMapOp, pcm_measurement: Measurement1D, initial_image: GrayscaleImage2D
+) -> GrayscaleImage2D:
+
+    lam = 10  # Good for Daubechies 4 wavelet transform
+    # max_iter = 300
+    max_iter = 100
+    tol = 1e-5
+
+    debias_max_iter = 10
+    debias_support_tol = 1e-5
+    debias_tol = 1e-7
+
+    height, width = pcm_op.domain_shape
+    # Wavelet transform Psi
+    wavelet = Wavelet2D((height, width), wavelet_name="db4", device=device)
+    # Composite operator A = Phi Psi^{-1}
+    A_op = CompositeOp(wavelet, pcm_op, device=device)
+
+    # print("Running FISTA reconstruction: " f"{max_iter} iterations, lambda={lam}...")
+    w_hat = fista_l1(
+        op=A_op,
+        y=pcm_measurement,
+        lam=lam,
+        max_iter=max_iter,
+        tol=tol,
+        L=None,
+        verbose=False,
+        prog_bar=tqdm,
+    )
+
+    # Optional debiasing
+    # print(f"Running debiasing: {debias_max_iter} iterations...")
+    w_debias = debias_ls(
+        op=A_op,
+        y=pcm_measurement,
+        w=w_hat,
+        support_tol=debias_support_tol,
+        max_iter=debias_max_iter,
+        tol=debias_tol,
+        prog_bar=tqdm,
+    )
+
+    # Current map reconstruction
+    cs_result_tensor = wavelet.inverse(w_debias)
+
+    return cs_result_tensor
+
+
+
+# %%
+def run_spgl1(
+    pcm_op: PhotocurrentMapOp, pcm_measurement: Measurement1D, initial_image: GrayscaleImage2D
+) -> GrayscaleImage2D:
+
+    # max_iter = 1000
+    # max_iter = 200
+    max_iter = 100
+    # opt_tol = 1e-4
+    # bp_tol = 1e-6
+    # opt_tol = 1e-5
+    # bp_tol = 1e-7
+
+    debias_max_iter = 10
+    # debias_max_iter = 100
+    debias_support_tol = 1e-5
+    # debias_support_tol = 1e-6
+    # debias_support_tol = 1e-7
+    debias_tol = 1e-7
+
+    height, width = pcm_op.domain_shape
+    # Wavelet transform Psi
+    wavelet = Wavelet2D((height, width), wavelet_name="db4", device=device)
+    # Composite operator A = Phi Psi^{-1}
+    A_op = CompositeOp(wavelet, pcm_op, device=device)
+
+    # rhs_l2_norm = torch.linalg.norm(pcm_measurement).item()
+    # # relative_feasibility_tolerance = 1e-6
+    # relative_feasibility_tolerance = 1e-9
+    # absolute_feasibility_tolerance = relative_feasibility_tolerance * rhs_l2_norm
+
+    pcm_measurement = pcm_measurement * factor  # scale up
+
+    # print("Running SPGL1 reconstruction: " f"{max_iter} iterations ...")
+    w_hat, _ = spgl1_torch(
+        op=A_op,
+        y=pcm_measurement,
+        iter_lim=max_iter,
+        # opt_tol=absolute_feasibility_tolerance,
+        # bp_tol=relative_feasibility_tolerance,
+        verbosity=0,
+        # opt_tol=opt_tol,
+        # bp_tol=bp_tol,
+    )
+    # Optional debiasing
+    # print(f"Running debiasing: {debias_max_iter} iterations...")
+    w_debias = debias_ls(
+        op=A_op,
+        y=pcm_measurement,
+        w=w_hat,
+        support_tol=debias_support_tol,
+        max_iter=debias_max_iter,
+        tol=debias_tol,
+        prog_bar=tqdm,
+    )
+
+    # Current map reconstruction
+    cs_result_tensor = wavelet.inverse(w_debias)
+
+    cs_result_tensor = cs_result_tensor / factor  # scale back down
+
+    return cs_result_tensor
+
+
+def make_test_cases() -> list[tuple[float, int]]:
+    min_coarse_J = 0
+    # min_coarse_J = 5
+    # min_coarse_J = J_order - 3  # keep 1.5625% of in-order measurements at least
+    # (sampling_ratio, coarse_J)
+    test_cases = []
+    num_pixels = 1 << (2 * J_order)  # N*N
+    # for sampling_ in range(0, 9, 1):
+    #     sampling_ratio = (sampling_ + 1) / 100.0  # from 0.01 to 0.09
+    #     num_samples = int(sampling_ratio * num_pixels)
+    #     for coarse_J in range(min_coarse_J, J_order):  # from 0 to J_order-1 (not including J_order because that is 100% sampling)
+    #         if coarse_J > 0:
+    #             prev_num_coarse_samples = 1 << (2 * (coarse_J - 1))
+    #             if prev_num_coarse_samples >= num_samples:
+    #                 continue
+    #         test_cases.append((sampling_ratio, coarse_J))
+    for sampling_ratio in [0.2, 0.5, 0.8]:
+    # for sampling_ in range(1, 10, 1):
+        # sampling_ratio = sampling_ / 10.0  # from 0.1 to 0.9
+        test_cases.append((sampling_ratio, J_order - 2))  # keep the first J-2 coarse levels, i.e. 6.25% in-order measurements
+        num_samples = int(sampling_ratio * num_pixels)
+        # for coarse_J in range(min_coarse_J, J_order):  # from 0 to J_order-1 (not including J_order because that is 100% sampling)
+        #     if coarse_J > 0:
+        #         prev_num_coarse_samples = 1 << (2 * (coarse_J - 1))
+        #         if prev_num_coarse_samples >= num_samples:
+        #             continue
+        #     test_cases.append((sampling_ratio, coarse_J))
+    # test_cases.append((1.0, J_order))  # 100% sampling
+
+    # # sampling_ratios = [0.1]
+    # sampling_ratios = [0.2]
+    # # # sampling_ratios = [0.25]
+    # # sampling_ratios = [0.5]
+    # # # sampling_ratios = [0.7]
+    # # # coarse_Js = [5]  # keep 2^{coarse_J} x 2^{coarse_J} in-order measurements
+    # # # coarse_Js = [7]  # keep 2^{coarse_J} x 2^{coarse_J} in-order measurements
+    # coarse_Js = list(range(0, J_order))
+    # test_cases = []
+    # test_cases += [
+    #     (sampling_ratio, coarse_J)
+    #     for sampling_ratio in sampling_ratios
+    #     for coarse_J in coarse_Js
+    # ]
+    # test_cases = [
+    # #     (0.3, 3),
+    #     # (0.2, 2),
+    #     (0.2, 6),
+    #     # (0.2, 8),
+    #     # (0.2, 7),
+    #     # (0.5, 6),
+    #     # (0.8, 6),
+    #     # (1.0, 6),
+    #     # (1.0, 7),
+    #     # (0.1, 8),
+    # ]
+
+    # test_cases = test_cases[80:]
+
+    test_cases.reverse()
+
+    return test_cases
+
+
+def run_experiments():
+    raw_data: GrayscaleImage2D | Measurement1D = np.load(data_dir / data_filename)
+    print(f"Raw data shape: {raw_data.shape}")
+    print(f"J_order: {J_order}")
+
+    if data_type == "image":
+        ground_truth_image: GrayscaleImage2D = torch.tensor(raw_data, dtype=torch.float32, device=device)
+        if inverses_sign:
+            ground_truth_image = -ground_truth_image
+        J_data = int(np.log2(ground_truth_image.shape[0]))
+        assert J_data == J_order, f"Data J ({J_data}) does not match expected J_order ({J_order})."
+        print(f"Ground truth image shape: {ground_truth_image.shape}")
+        measurement_vector = None
+    elif data_type == "hadamard_measurement_vector":
+        # Reconstruct the image from the Hadamard measurement vector
+        J_data = int(np.log2(raw_data.shape[0]) / 2)
+        assert J_data == J_order, f"Data J ({J_data}) does not match expected J_order ({J_order})."
+        measurement_vector = torch.tensor(raw_data, dtype=torch.float32, device=device)
+        if inverses_sign:
+            measurement_vector = -measurement_vector
+
+        index_of_max = torch.argmax(measurement_vector).item()
+        index_of_min = torch.argmin(measurement_vector).item()
+        print(f"Max value in measurement vector: {measurement_vector[index_of_max].item()} at index {index_of_max}")
+        print(f"Min value in measurement vector: {measurement_vector[index_of_min].item()} at index {index_of_min}")
+        exit()
+
+        pcm_op_full = PhotocurrentMapOp(J=J_order, device=device)
+        with torch.no_grad():
+            ground_truth_image = pcm_op_full.pseudo_inv(measurement_vector)
+        print(f"Reconstructed ground truth image shape from Hadamard measurement vector: {ground_truth_image.shape}")
+
+    elif data_type == "original_measurement_data":
+        # Make a 1D array with num_lines//2 elements,
+        # where each element is the sum of the measured current multiplied by the pattern index sign.
+        num_measurements = raw_data.shape[0]
+        assert num_measurements % 2 == 0, "Number of measurements should be even."
+
+        if inverses_sign:
+            raw_data[:, 1] = -raw_data[:, 1]
+
+        index_of_max_raw = np.argmax(raw_data[:, 1])
+        index_of_min_raw = np.argmin(raw_data[:, 1])
+        min_raw_value = raw_data[index_of_min_raw, 1]
+        max_raw_value = raw_data[index_of_max_raw, 1]
+        print(f"Max value in original measurement data: {max_raw_value} at index {index_of_max_raw}")
+        print(f"Min value in original measurement data: {min_raw_value} at index {index_of_min_raw}")
+        # exit()
+
+        sign_vector = np.round(np.sign(raw_data[:, 0]))
+        sign_vector[:2] = [1.0, -1.0]  # Ensure the first two patterns are +0 and -0
+
+        measurement_vector = torch.tensor((raw_data[:, 1] * sign_vector).reshape(-1, 2).sum(axis=1), dtype=torch.float32, device=device)
+
+        # index_of_max = torch.argmax(measurement_vector).item()
+        # index_of_min = torch.argmin(measurement_vector).item()
+        # min_value = measurement_vector[index_of_min].item()
+        # max_value = measurement_vector[index_of_max].item()
+        # print(f"Max value in measurement vector: {max_value} at index {index_of_max}")
+        # print(f"Min value in measurement vector: {min_value} at index {index_of_min}")
+        # exit()
+
+        pcm_op_full = PhotocurrentMapOp(J=J_order, device=device)
+        print(f"pcm_op_full domain shape: {pcm_op_full.domain_shape}, range shape: {pcm_op_full.range_shape}")
+        with torch.no_grad():
+            ground_truth_image = pcm_op_full.pseudo_inv(measurement_vector)
+        print(f"Reconstructed ground truth image shape from original measurement data: {ground_truth_image.shape}")
+
+    if tests_scale_ground_truth:
+        gt_min, gt_max = ground_truth_image.min().item(), ground_truth_image.max().item()
+        ground_truth_image = (ground_truth_image - gt_min) / (gt_max - gt_min)
+        print(f"Normalized ground truth image to [0, 1]. Min: {ground_truth_image.min().item()}, Max: {ground_truth_image.max().item()}")
+        measurement_vector = None
+
+    test_cases = make_test_cases()
+    # print(f"Total number of test cases: {len(test_cases)}")
+    # print(test_cases)
+    # for sampling_ratio, coarse_J in test_cases:
+    #     sampling_percentage = sampling_ratio * 100
+    #     coarse_percentage = (1<<(2*coarse_J))/(1<<(2*J_order))*100
+    #     print(f"Sampling: {sampling_percentage}%, coarse_J: {coarse_J} ({coarse_percentage}%)")
+    #     assert sampling_percentage >= coarse_percentage, (
+    #         "Sampling percentage must be larger than or equal to coarse percentage. "
+    #         f"Got sampling {sampling_percentage}% and coarse {coarse_percentage}%."
+    #     )
+    # return
+
+    # ### Set a directory to save logs and results
+    #
+    # Each run is stored in a separate subdirectory named with the current date and
+    # time, which makes it easier to keep track of different experiments.
+
+    current_datetime_str = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_log_dir = Path("pcm_demo_output") / f"{current_datetime_str}_{data_name}_{randomizing_scheme}_{num_trials}_trials"
+    experiment_log_dir.mkdir(parents=True, exist_ok=True)
+
+    for i_seed in tqdm(range(num_trials_skip, num_trials), desc="Running trials"):
+        print(f"\n=== Trial {i_seed} ===")
+        log_dir = experiment_log_dir / f"trial_{i_seed}"
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        # %% [markdown]
+        # ## First experiment: PnP-ADMM
+        #
+        # In this section the PCM PnP-ADMM algorithm is tested on the CIGS data.
+
+        # %% [markdown]
+        # Define the prior function using a pre-trained DRUNet denoiser and the
+        # corresponding Plug-and-Play ADMM solver.
+        #
+        # DRUNet is a deep convolutional denoiser proposed by:
+        #
+        # > Kai Zhang, Yawei Li, Wangmeng Zuo, Lei Zhang, Luc Van Gool, and
+        # > Radu Timofte, "Plug-and-Play Image Restoration with Deep Denoiser Prior,"
+        # > IEEE Transactions on Pattern Analysis and Machine Intelligence, 44(10),
+        # > 6360–6376, 2022.
+        #
+        # In the PnP-ADMM framework, the proximal step of a regulariser is replaced by
+        # an off-the-shelf denoiser. Here DRUNet acts as a powerful learned prior for
+        # the PCM inverse problem, while the data fidelity term is handled by ADMM.
+
+        # %%
+        if runs_pnp_admm:
+            method_name = f"pnp_admm_iters={pnp_admm_iters}_eta={pnp_admm_eta}_cg_iters={cg_iters}_drunet_sigma={drunet_sigma}"
+            make_csv(method_name=method_name, log_dir=log_dir)
+            # for delta_divided_by, subtract_from_J in tqdm(test_cases, desc="Running PnP-ADMM experiments"):
+            for sampling_ratio, coarse_J in tqdm(test_cases, desc="Running PnP-ADMM experiments"):
+                run_pcm_demo(
+                    recon_description=f"PnP-ADMM ({pnp_admm_iters} iters, η={pnp_admm_eta}, cg_iters={cg_iters}, σ={drunet_sigma})",
+                    recon_fn=run_pnp_admm,
+                    ground_truth_image=ground_truth_image,
+                    method_name=method_name,
+                    image_name=data_name,
+                    J=J_order,  # image size is 2^J x 2^J
+                    sampling_ratio=sampling_ratio,
+                    coarse_J=coarse_J,
+                    log_dir=log_dir,
+                    device=device,
+                    seed=i_seed,
+                )
+
+
+        # %% [markdown]
+        # The code above runs the PnP-ADMM reconstruction and compares it to the
+        # zero-filled pseudo-inverse.
+        #
+        # Although PnP-ADMM substantially improves PSNR and SSIM, it can smooth out
+        # fine-scale structures. In the context of defect detection, these small
+        # features can be crucial, so high PSNR and SSIM alone are not sufficient to
+        # guarantee that the reconstruction is fit for purpose.
+        #
+        # In the next sections, two compressed sensing baselines with a wavelet
+        # sparsity prior are explored and compared to the PnP-ADMM result.
+
+
+        # %% [markdown]
+        # ## Compressed sensing baseline: FISTA with wavelet sparsity
+        #
+        # This section applies FISTA with an $\ell_1$-penalty on wavelet coefficients
+        # as a classical compressed sensing baseline.
+        #
+        # Let $\Phi$ denote the PCM forward operator and $\Psi$ a 2D wavelet
+        # transform with inverse $\Psi^{-1}$. The composite operator
+        # $A = \Phi \Psi^{-1}$ acts on wavelet coefficients $w$.
+        # FISTA approximately solves the standard $\ell_1$-regularised problem
+        #
+        # $$
+        # \min_w \frac{1}{2} \lVert A w - y \rVert_2^2
+        #     + \lambda \lVert w \rVert_1,
+        # $$
+        #
+        # and the final current map is obtained as $x = \Psi^{-1} w$.
+        #
+        # An optional debiasing step is included at the end to reduce the bias induced
+        # by the $\ell_1$ penalty on the active support.
+
+        # %%
+        if runs_fista_l1:
+            make_csv(method_name="fista_l1", log_dir=log_dir)
+            for sampling_ratio, coarse_J in tqdm(test_cases, desc="Running FISTA-L1 experiments"):
+                run_pcm_demo(
+                    recon_description="FISTA-L1",
+                    recon_fn=run_fista_l1,
+                    ground_truth_image=ground_truth_image,
+                    method_name="fista_l1",
+                    image_name=data_name,
+                    J=J_order,  # image size is 2^J x 2^J
+                    sampling_ratio=sampling_ratio,
+                    coarse_J=coarse_J,
+                    log_dir=log_dir,
+                    device=device,
+                    seed=i_seed,
+                )
+
+        # %% [markdown]
+        # ## Compressed sensing baseline: SPGL1 with wavelet sparsity
+        #
+        # This section applies the SPGL1 algorithm as a second compressed sensing
+        # baseline, again using a wavelet sparsity prior in the same setting
+        # $A = \Phi \Psi^{-1}$.
+        #
+        # SPGL1 is a spectral projected gradient method that efficiently solves
+        # large-scale $\ell_1$-regularised problems and basis pursuit denoising
+        # formulations. In this example it is run with default parameters suitable
+        # for the PCM problem size, followed by the same optional debiasing step
+        # used for FISTA.
+
+        # %%
+        if runs_spgl1:
+            method_name = f"spgl1_factor={factor}"
+            make_csv(method_name=method_name, log_dir=log_dir)
+            for sampling_ratio, coarse_J in tqdm(test_cases, desc="Running SPGL1 experiments"):
+                run_pcm_demo(
+                    recon_description="SPGL1",
+                    recon_fn=run_spgl1,
+                    ground_truth_image=ground_truth_image,
+                    method_name=method_name,
+                    image_name=data_name,
+                    J=J_order,  # image size is 2^J x 2^J
+                    sampling_ratio=sampling_ratio,
+                    coarse_J=coarse_J,
+                    log_dir=log_dir,
+                    device=device,
+                    seed=i_seed,
+                )
+
+if __name__ == "__main__":
+    run_experiments()

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/metrics.csv

@@ -0,0 +1,4 @@
+sampling_percentage,  coarse_J,  mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon
+80.0,  7,  0.00089330377522856,  29.44137191772461,  0.8160672187805176,  0.9921615719795227,  7.7854871051386e-05,  40.03850555419922,  0.9805998802185059,  0.9993190765380859
+50.0,  7,  0.002207003301009536,  25.513336181640625,  0.6699858903884888,  0.9805208444595337,  0.000306389934848994,  34.08861541748047,  0.9312506914138794,  0.9973183870315552
+20.0,  7,  0.0034744185395538807,  23.542543411254883,  0.5567121505737305,  0.969157874584198,  0.0007404985371977091,  30.256122589111328,  0.846380352973938,  0.9935111403465271

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1fbc46b05eb8c2af209ddd74209333e9abc5c7fc15239bf5ed3789a4d1d83c2
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a03ee5e92c7510e3d9f4d39a7bf6cede467f646238b77546f8ac719b861efbf
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/example_silicon_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab11461ca892bc554195f2acd605c9e0ba6b837293bf16c616658c9e28ae40ff
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/spgl1_factor=1/metrics.csv

@@ -0,0 +1,4 @@
+sampling_percentage,  coarse_J,  mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon
+80.0,  7,  0.00089330377522856,  29.44137191772461,  0.8160672187805176,  0.9921615719795227,  0.00044409645488485694,  32.47658920288086,  0.8919059634208679,  0.9961116313934326
+50.0,  7,  0.002207003301009536,  25.513336181640625,  0.6699858903884888,  0.9805208444595337,  0.0012489010114222765,  27.986083984375,  0.7376909255981445,  0.9890313744544983
+20.0,  7,  0.0034744185395538807,  23.542543411254883,  0.5567121505737305,  0.969157874584198,  0.002771863015368581,  24.52364730834961,  0.5300854444503784,  0.9755349159240723

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9aa9ed8132726ac1e72b9dda9fd6687f978b4bbeb3f08523172d41d8bec316f3
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d90fa5a5a2db15f3755a27821f4b55b93856dcf3ec97b2f43c362adfc0c539ed
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/spgl1_factor=1/recons/example_silicon_512x512_spgl1_factor=1_sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1b1114d095e4e11e84ffab9d32400797d616676cab7ab89e041494129b49d7a
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/zero_filled/example_silicon_512x512_sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ade341d17c4c3d47c12ea919580d446c9a87e708dd3ebacec773d4e1823d683
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/zero_filled/example_silicon_512x512_sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c9484c2f9174bc8bfc6b7336b2c2774aab61e812a834532ba99300b5b5516a5
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_1/zero_filled/example_silicon_512x512_sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50280ac8c6e3418812a8b62cd8425a3f6d39ad3dec4c3a69ad5683dde26688c6
+size 1048704

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_2/masks/sample_20.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fc3e1df96f6c935bbb8305a01b0e6173e368f98caa2d071654b26da301a2106
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_2/masks/sample_50.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c28a9b7f3a07f5bbfab5192a2a87a230b52aaeb2cac49b8bd753e712bdbf289
+size 262272

20260118_034512_example_silicon_512x512_uniform_10_trials_pnp_and_spgl1/trial_2/masks/sample_80.0_percent_coarse_J=7_uniform_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a36a26bd969324f93ffb98364706e3d28b6950778faeb6bd9150e40ea7747cd9
+size 262272