ddon-efish 1.0.0__tar.gz

ddon_efish-1.0.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: ddon-efish
+Version: 1.0.0
+Summary: Lightweight local inference package for Decoder-DeepONet (DDON) EFISH electric-field reconstruction.
+Project-URL: Homepage, https://github.com/ozzzzj/Decoder-DeepONet
+Project-URL: Web App, https://ozzzzj.github.io/Decoder-DeepONet/
+Project-URL: Paper, https://doi.org/10.1088/1361-6595/ae413f
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy<3
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: scipy>=1.9
+
+# Decoder-DeepONet (DDON)
+Model and code of Decoder DeepONet (DDON) for Electric field reconstruction from EFISH measurements. This model is specifically designed for vertically polarized EFISH signals (for a vertically
+polarized probe beam). <br>
+
+To use the model and code, please cite: <br>
+
+''Yang, Z., Sugeng, E.S., Alicherif, M. and Chng, T.L., 2026. An interpretable operator-learning model for electric field profile reconstruction in discharges based on the EFISH method. Plasma Sources Science and Technology, 35(2), p.025035.'' <br>
+
+The related paper and analysis are available at the DOI 10.1088/1361-6595/ae413f. <br>
+
+**Note** Scripts and model will be available soon...  <br>
+
+## Environment recommended (model trained on):
+- Python 3.10.15
+- TensorFlow-gpu 2.10.1
+
+## Main user file:
+1. 'DeepONet_Resnet_Exp.py' % for script use
+2. 'DeepONet_Resnet_Exp.ipynb' % for jupyter editor use
+
+## Script files:
+1. 'self_layers.py' %to import some self-defined layers
+2. 'PINN_Model_Predict.py' % run the model, output MATLAB .mat file, visualize the prediction
+3. 'self_Predict_ModelResult.py' % child file of the 'PINN_Model_Predict.py', including necessary code for Efield prediction
+
+## Model file (DDON) and model description
+- Please download the DDON model via the release page for use (put it under the dir model log) or via: <br>
+  https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON/20260520_model_Batsize-512.h5
+
+## Instructions to use the model for Efield prediction:
+1. To use the model, please first interpolate the EFISH file to the following grid via MATLAB:
+   $z/z_R = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 \, 24:2:50]$; <br>
+   or <br>
+   $z/z_R = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]$; <br>
+   
+   **Note**: The first grid point is recommended and should be tried first, as it may always show good predictions; otherwise, try the second to see if better results can be gotten. <br>
+
+2. Then further normalize the $z/z_R$ by dividing $z_\mathrm{scale} = 50$, then the input grid should be:<br>
+   $z^\prime = z/z_R/50 = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 24:2:50]/50$; <br>
+   or <br>
+   $z^\prime = z/z_R/50 = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]/50$; <br>
+   
+   **Note 1**: $z^\prime \in [-1,1]$; crop the input EFISH profile if the normalized and scaled range (z/z_R/50) goes beyond this range. <br>
+   **Note 2**: The sampling grid outside your experiment range could be set to zero, as the DDON accepts zero input outside the key feature range. For how to quantify the key range, please refer to our paper. Please ensure the input range is at least 4.2*FWHM of your input EFISH profile (normalized), although sometimes a smaller sampling range than this criterion also works. <br>
+
+3. Normalize the measured EFISH profile (along the laser propagation axis, $z$) by its maximum:
+   $P_\mathrm{norm}(z) = P(z)/P_\mathrm{max}$
+
+4. Estimate the phase mismatch value $u$ through the wave-factor mismatch $\Delta k$ and Rayleigh range $z_\mathrm{R}$, and normalize it as input: <br>
+   $u^\prime$ = $\Delta k \cdot z_\mathrm{R}$/-0.068. <br>
+   **Note**: -0.068 is the max $u$ value from the training dataset. <br>
+
+5. Import the MAT file as structure files and obtain the prediction. Or you can modify the code to fit your data structure as well.
+   
+   The MAT file structure is as follows:<br>
+   
+   <table>
+  <tr>
+    <td rowspan="3"><code>Profile_Px</code></td>
+    <td>$P_x$</td>
+    <td>$[z, P_x]$ (experimentally measured EFISH and normalized $z'$; dim: [109,2])</td>
+  </tr>
+  <tr>
+    <td>$u$</td>
+    <td>The phase mismatch value along $z$; dim: [109,1]</td>
+  </tr>
+  <tr>
+    <td>$E_x$</td>
+    <td>The electric field value along $z$; dim: [109,1]</td>
+  </tr>
+</table>## Choose how to use DDON
+
+### 1. Online Web App — no installation
+
+Run DDON directly in a web browser:
+
+**[Launch the DDON E-field Reconstruction Web App](https://ozzzzj.github.io/Decoder-DeepONet/)**
+
+The web app supports preprocessed CSV and MATLAB MAT inputs and performs inference locally in the browser using ONNX Runtime Web.
+
+### 2. Local Packaged Inference — lightweight ONNX Runtime
+
+For local prediction without installing TensorFlow, install this repository as a Python package:
+
+```bash
+pip install .
+```
+
+Python interface:
+
+```python
+from ddon import DDON
+
+model = DDON()
+E = model.predict(values, u=-0.35)
+```
+
+Command-line interface:
+
+```bash
+ddon predict Efish_vertical.mat -o prediction.csv
+```
+
+For MATLAB MAT input, `Profile_Px.Px` and `Profile_Px.u` are read automatically. CSV/TXT input can be used with `--u`:
+
+```bash
+ddon predict input.csv --u -0.35 -o prediction.mat
+```
+
+The ONNX model is downloaded automatically on first use and cached locally. This mode requires only NumPy, SciPy, and ONNX Runtime.
+
+### 3. Full Python Research Code — To be released
+
+The full TensorFlow research implementation, including the original prediction, evaluation, and analysis workflow, is not included in the current public release and will be released separately in the future.
+
+
+## Environment recommended (model trained on):
+- Python 3.10.15
+- TensorFlow-gpu 2.10.1
+
+## Main user file:
+1. 'DeepONet_Resnet_Exp.py' % for script use
+2. 'DeepONet_Resnet_Exp.ipynb' % for jupyter editor use
+
+## Script files:
+1. 'self_layers.py' %to import some self-defined layers
+2. 'PINN_Model_Predict.py' % run the model, output MATLAB .mat file, visualize the prediction
+3. 'self_Predict_ModelResult.py' % child file of the 'PINN_Model_Predict.py', including necessary code for Efield prediction
+
+## Model file (DDON) and model description
+- Please download the DDON model via the release page for use (put it under the dir model log) or via: <br>
+  https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON/20260520_model_Batsize-512.h5
+
+## Instructions to use the model for Efield prediction:
+1. To use the model, please first interpolate the EFISH file to the following grid via MATLAB:
+   $z/z_R = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 \, 24:2:50]$; <br>
+   or <br>
+   $z/z_R = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]$; <br>
+   
+   **Note**: The first grid point is recommended and should be tried first, as it may always show good predictions; otherwise, try the second to see if better results can be gotten. <br>
+
+2. Then further normalize the $z/z_R$ by dividing $z_\mathrm{scale} = 50$, then the input grid should be:<br>
+   $z^\prime = z/z_R/50 = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 24:2:50]/50$; <br>
+   or <br>
+   $z^\prime = z/z_R/50 = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]/50$; <br>
+   
+   **Note 1**: $z^\prime \in [-1,1]$; crop the input EFISH profile if the normalized and scaled range (z/z_R/50) goes beyond this range. <br>
+   **Note 2**: The sampling grid outside your experiment range could be set to zero, as the DDON accepts zero input outside the key feature range. For how to quantify the key range, please refer to our paper. Please ensure the input range is at least 4.2*FWHM of your input EFISH profile (normalized), although sometimes a smaller sampling range than this criterion also works. <br>
+
+3. Normalize the measured EFISH profile (along the laser propagation axis, $z$) by its maximum:
+   $P_\mathrm{norm}(z) = P(z)/P_\mathrm{max}$
+
+4. Estimate the phase mismatch value $u$ through the wave-factor mismatch $\Delta k$ and Rayleigh range $z_\mathrm{R}$, and normalize it as input: <br>
+   $u^\prime$ = $\Delta k \cdot z_\mathrm{R}$/-0.068. <br>
+   **Note**: -0.068 is the max $u$ value from the training dataset. <br>
+
+5. Import the MAT file as structure files and obtain the prediction. Or you can modify the code to fit your data structure as well.
+   
+   The MAT file structure is as follows:<br>
+   
+   <table>
+  <tr>
+    <td rowspan="3"><code>Profile_Px</code></td>
+    <td>$P_x$</td>
+    <td>$[z, P_x]$ (experimentally measured EFISH and normalized $z'$; dim: [109,2])</td>
+  </tr>
+  <tr>
+    <td>$u$</td>
+    <td>The phase mismatch value along $z$; dim: [109,1]</td>
+  </tr>
+  <tr>
+    <td>$E_x$</td>
+    <td>The electric field value along $z$; dim: [109,1]</td>
+  </tr>
+</table>

ddon_efish-1.0.0/README.md

@@ -0,0 +1,175 @@
+# Decoder-DeepONet (DDON)
+Model and code of Decoder DeepONet (DDON) for Electric field reconstruction from EFISH measurements. This model is specifically designed for vertically polarized EFISH signals (for a vertically
+polarized probe beam). <br>
+
+To use the model and code, please cite: <br>
+
+''Yang, Z., Sugeng, E.S., Alicherif, M. and Chng, T.L., 2026. An interpretable operator-learning model for electric field profile reconstruction in discharges based on the EFISH method. Plasma Sources Science and Technology, 35(2), p.025035.'' <br>
+
+The related paper and analysis are available at the DOI 10.1088/1361-6595/ae413f. <br>
+
+**Note** Scripts and model will be available soon...  <br>
+
+## Environment recommended (model trained on):
+- Python 3.10.15
+- TensorFlow-gpu 2.10.1
+
+## Main user file:
+1. 'DeepONet_Resnet_Exp.py' % for script use
+2. 'DeepONet_Resnet_Exp.ipynb' % for jupyter editor use
+
+## Script files:
+1. 'self_layers.py' %to import some self-defined layers
+2. 'PINN_Model_Predict.py' % run the model, output MATLAB .mat file, visualize the prediction
+3. 'self_Predict_ModelResult.py' % child file of the 'PINN_Model_Predict.py', including necessary code for Efield prediction
+
+## Model file (DDON) and model description
+- Please download the DDON model via the release page for use (put it under the dir model log) or via: <br>
+  https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON/20260520_model_Batsize-512.h5
+
+## Instructions to use the model for Efield prediction:
+1. To use the model, please first interpolate the EFISH file to the following grid via MATLAB:
+   $z/z_R = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 \, 24:2:50]$; <br>
+   or <br>
+   $z/z_R = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]$; <br>
+   
+   **Note**: The first grid point is recommended and should be tried first, as it may always show good predictions; otherwise, try the second to see if better results can be gotten. <br>
+
+2. Then further normalize the $z/z_R$ by dividing $z_\mathrm{scale} = 50$, then the input grid should be:<br>
+   $z^\prime = z/z_R/50 = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 24:2:50]/50$; <br>
+   or <br>
+   $z^\prime = z/z_R/50 = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]/50$; <br>
+   
+   **Note 1**: $z^\prime \in [-1,1]$; crop the input EFISH profile if the normalized and scaled range (z/z_R/50) goes beyond this range. <br>
+   **Note 2**: The sampling grid outside your experiment range could be set to zero, as the DDON accepts zero input outside the key feature range. For how to quantify the key range, please refer to our paper. Please ensure the input range is at least 4.2*FWHM of your input EFISH profile (normalized), although sometimes a smaller sampling range than this criterion also works. <br>
+
+3. Normalize the measured EFISH profile (along the laser propagation axis, $z$) by its maximum:
+   $P_\mathrm{norm}(z) = P(z)/P_\mathrm{max}$
+
+4. Estimate the phase mismatch value $u$ through the wave-factor mismatch $\Delta k$ and Rayleigh range $z_\mathrm{R}$, and normalize it as input: <br>
+   $u^\prime$ = $\Delta k \cdot z_\mathrm{R}$/-0.068. <br>
+   **Note**: -0.068 is the max $u$ value from the training dataset. <br>
+
+5. Import the MAT file as structure files and obtain the prediction. Or you can modify the code to fit your data structure as well.
+   
+   The MAT file structure is as follows:<br>
+   
+   <table>
+  <tr>
+    <td rowspan="3"><code>Profile_Px</code></td>
+    <td>$P_x$</td>
+    <td>$[z, P_x]$ (experimentally measured EFISH and normalized $z'$; dim: [109,2])</td>
+  </tr>
+  <tr>
+    <td>$u$</td>
+    <td>The phase mismatch value along $z$; dim: [109,1]</td>
+  </tr>
+  <tr>
+    <td>$E_x$</td>
+    <td>The electric field value along $z$; dim: [109,1]</td>
+  </tr>
+</table>## Choose how to use DDON
+
+### 1. Online Web App — no installation
+
+Run DDON directly in a web browser:
+
+**[Launch the DDON E-field Reconstruction Web App](https://ozzzzj.github.io/Decoder-DeepONet/)**
+
+The web app supports preprocessed CSV and MATLAB MAT inputs and performs inference locally in the browser using ONNX Runtime Web.
+
+### 2. Local Packaged Inference — lightweight ONNX Runtime
+
+For local prediction without installing TensorFlow, install this repository as a Python package:
+
+```bash
+pip install .
+```
+
+Python interface:
+
+```python
+from ddon import DDON
+
+model = DDON()
+E = model.predict(values, u=-0.35)
+```
+
+Command-line interface:
+
+```bash
+ddon predict Efish_vertical.mat -o prediction.csv
+```
+
+For MATLAB MAT input, `Profile_Px.Px` and `Profile_Px.u` are read automatically. CSV/TXT input can be used with `--u`:
+
+```bash
+ddon predict input.csv --u -0.35 -o prediction.mat
+```
+
+The ONNX model is downloaded automatically on first use and cached locally. This mode requires only NumPy, SciPy, and ONNX Runtime.
+
+### 3. Full Python Research Code — To be released
+
+The full TensorFlow research implementation, including the original prediction, evaluation, and analysis workflow, is not included in the current public release and will be released separately in the future.
+
+
+## Environment recommended (model trained on):
+- Python 3.10.15
+- TensorFlow-gpu 2.10.1
+
+## Main user file:
+1. 'DeepONet_Resnet_Exp.py' % for script use
+2. 'DeepONet_Resnet_Exp.ipynb' % for jupyter editor use
+
+## Script files:
+1. 'self_layers.py' %to import some self-defined layers
+2. 'PINN_Model_Predict.py' % run the model, output MATLAB .mat file, visualize the prediction
+3. 'self_Predict_ModelResult.py' % child file of the 'PINN_Model_Predict.py', including necessary code for Efield prediction
+
+## Model file (DDON) and model description
+- Please download the DDON model via the release page for use (put it under the dir model log) or via: <br>
+  https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON/20260520_model_Batsize-512.h5
+
+## Instructions to use the model for Efield prediction:
+1. To use the model, please first interpolate the EFISH file to the following grid via MATLAB:
+   $z/z_R = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 \, 24:2:50]$; <br>
+   or <br>
+   $z/z_R = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]$; <br>
+   
+   **Note**: The first grid point is recommended and should be tried first, as it may always show good predictions; otherwise, try the second to see if better results can be gotten. <br>
+
+2. Then further normalize the $z/z_R$ by dividing $z_\mathrm{scale} = 50$, then the input grid should be:<br>
+   $z^\prime = z/z_R/50 = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 24:2:50]/50$; <br>
+   or <br>
+   $z^\prime = z/z_R/50 = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]/50$; <br>
+   
+   **Note 1**: $z^\prime \in [-1,1]$; crop the input EFISH profile if the normalized and scaled range (z/z_R/50) goes beyond this range. <br>
+   **Note 2**: The sampling grid outside your experiment range could be set to zero, as the DDON accepts zero input outside the key feature range. For how to quantify the key range, please refer to our paper. Please ensure the input range is at least 4.2*FWHM of your input EFISH profile (normalized), although sometimes a smaller sampling range than this criterion also works. <br>
+
+3. Normalize the measured EFISH profile (along the laser propagation axis, $z$) by its maximum:
+   $P_\mathrm{norm}(z) = P(z)/P_\mathrm{max}$
+
+4. Estimate the phase mismatch value $u$ through the wave-factor mismatch $\Delta k$ and Rayleigh range $z_\mathrm{R}$, and normalize it as input: <br>
+   $u^\prime$ = $\Delta k \cdot z_\mathrm{R}$/-0.068. <br>
+   **Note**: -0.068 is the max $u$ value from the training dataset. <br>
+
+5. Import the MAT file as structure files and obtain the prediction. Or you can modify the code to fit your data structure as well.
+   
+   The MAT file structure is as follows:<br>
+   
+   <table>
+  <tr>
+    <td rowspan="3"><code>Profile_Px</code></td>
+    <td>$P_x$</td>
+    <td>$[z, P_x]$ (experimentally measured EFISH and normalized $z'$; dim: [109,2])</td>
+  </tr>
+  <tr>
+    <td>$u$</td>
+    <td>The phase mismatch value along $z$; dim: [109,1]</td>
+  </tr>
+  <tr>
+    <td>$E_x$</td>
+    <td>The electric field value along $z$; dim: [109,1]</td>
+  </tr>
+</table>

ddon_efish-1.0.0/ddon/__init__.py

@@ -0,0 +1,3 @@
+from .predictor import DDON
+
+__all__ = ["DDON"]

ddon_efish-1.0.0/ddon/cli.py

@@ -0,0 +1,42 @@
+import argparse
+
+from .io import load_input, save_output
+from .predictor import DDON
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="ddon",
+        description="Local DDON electric-field reconstruction.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    predict = sub.add_parser("predict", help="Run DDON inference.")
+    predict.add_argument("input", help="Input .mat, .csv, or .txt file.")
+    predict.add_argument(
+        "--u",
+        type=float,
+        default=None,
+        help="Raw u value. Required for CSV/TXT; MAT reads Profile_Px.u automatically.",
+    )
+    predict.add_argument(
+        "-o", "--output", default="ddon_prediction.csv",
+        help="Output .csv or .mat file.",
+    )
+    predict.add_argument("--model", default=None, help="Optional local DDON.onnx path.")
+
+    args = parser.parse_args()
+
+    values, file_u, y_true = load_input(args.input)
+    u = args.u if args.u is not None else file_u
+    if u is None:
+        parser.error("--u is required when input does not contain Profile_Px.u")
+
+    model = DDON(model_path=args.model)
+    efield = model.predict(values, u)
+    save_output(args.output, values[:, 0], efield, y_true)
+    print(f"Saved prediction to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

ddon_efish-1.0.0/ddon/io.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+import numpy as np
+from scipy.io import loadmat, savemat
+
+
+def load_input(path):
+    path = Path(path)
+    suffix = path.suffix.lower()
+
+    if suffix == ".mat":
+        mat = loadmat(path, squeeze_me=True, struct_as_record=False)
+        if "Profile_Px" not in mat:
+            raise ValueError("MAT file must contain Profile_Px.")
+        profile = mat["Profile_Px"]
+        values = np.asarray(profile.Px, dtype=np.float32)
+        u = float(np.asarray(profile.u).reshape(-1)[0])
+        y_true = None
+        if hasattr(profile, "Ex"):
+            ex = np.asarray(profile.Ex).squeeze()
+            if ex.size == 109:
+                y_true = ex.reshape(109)
+        return values, u, y_true
+
+    if suffix in {".csv", ".txt"}:
+        values = np.loadtxt(path, delimiter="," if suffix == ".csv" else None)
+        return np.asarray(values, dtype=np.float32), None, None
+
+    raise ValueError("Supported input formats are .mat, .csv, and .txt.")
+
+
+def save_output(path, z, efield, y_true=None):
+    path = Path(path)
+    suffix = path.suffix.lower()
+    z = np.asarray(z).reshape(-1)
+    efield = np.asarray(efield).reshape(-1)
+
+    if suffix == ".mat":
+        data = {"z": z, "efield": efield}
+        if y_true is not None:
+            data["Ex"] = np.asarray(y_true).reshape(-1)
+        savemat(path, data)
+        return
+
+    if suffix == ".csv":
+        cols = [z, efield]
+        header = "z,efield"
+        if y_true is not None:
+            cols.append(np.asarray(y_true).reshape(-1))
+            header += ",Ex"
+        np.savetxt(path, np.column_stack(cols), delimiter=",", header=header, comments="")
+        return
+
+    raise ValueError("Output file must end in .csv or .mat.")

ddon_efish-1.0.0/ddon/predictor.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+from urllib.request import urlretrieve
+
+import numpy as np
+import onnxruntime as ort
+
+
+MODEL_URL = "https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON-WEB/DDON.onnx"
+U_SCALE = -1.0
+EXPECTED_POINTS = 109
+
+
+class DDON:
+    """Lightweight local DDON inference using ONNX Runtime."""
+
+    def __init__(self, model_path=None):
+        if model_path is None:
+            model_path = Path.home() / ".ddon" / "DDON.onnx"
+        self.model_path = Path(model_path)
+        if not self.model_path.exists():
+            self.model_path.parent.mkdir(parents=True, exist_ok=True)
+            print(f"Downloading DDON model to {self.model_path}")
+            urlretrieve(MODEL_URL, self.model_path)
+
+        self.session = ort.InferenceSession(
+            str(self.model_path),
+            providers=["CPUExecutionProvider"],
+        )
+
+    def predict(self, values, u):
+        values = np.asarray(values, dtype=np.float32)
+        if values.shape != (EXPECTED_POINTS, 2):
+            raise ValueError(
+                f"values must have shape ({EXPECTED_POINTS}, 2); got {values.shape}"
+            )
+        if not np.all(np.isfinite(values)):
+            raise ValueError("values contains NaN or infinite values")
+
+        raw_u = float(np.asarray(u).reshape(-1)[0])
+        if not np.isfinite(raw_u):
+            raise ValueError("u must be finite")
+
+        values_input = values.reshape(1, EXPECTED_POINTS, 2)
+        u_input = np.asarray([[raw_u / U_SCALE]], dtype=np.float32)
+
+        inputs = self.session.get_inputs()
+        outputs = self.session.run(
+            None,
+            {
+                inputs[0].name: values_input,
+                inputs[1].name: u_input,
+            },
+        )
+        return np.asarray(outputs[0]).squeeze().reshape(EXPECTED_POINTS)

ddon_efish-1.0.0/ddon_efish.egg-info/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: ddon-efish
+Version: 1.0.0
+Summary: Lightweight local inference package for Decoder-DeepONet (DDON) EFISH electric-field reconstruction.
+Project-URL: Homepage, https://github.com/ozzzzj/Decoder-DeepONet
+Project-URL: Web App, https://ozzzzj.github.io/Decoder-DeepONet/
+Project-URL: Paper, https://doi.org/10.1088/1361-6595/ae413f
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy<3
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: scipy>=1.9
+
+# Decoder-DeepONet (DDON)
+Model and code of Decoder DeepONet (DDON) for Electric field reconstruction from EFISH measurements. This model is specifically designed for vertically polarized EFISH signals (for a vertically
+polarized probe beam). <br>
+
+To use the model and code, please cite: <br>
+
+''Yang, Z., Sugeng, E.S., Alicherif, M. and Chng, T.L., 2026. An interpretable operator-learning model for electric field profile reconstruction in discharges based on the EFISH method. Plasma Sources Science and Technology, 35(2), p.025035.'' <br>
+
+The related paper and analysis are available at the DOI 10.1088/1361-6595/ae413f. <br>
+
+**Note** Scripts and model will be available soon...  <br>
+
+## Environment recommended (model trained on):
+- Python 3.10.15
+- TensorFlow-gpu 2.10.1
+
+## Main user file:
+1. 'DeepONet_Resnet_Exp.py' % for script use
+2. 'DeepONet_Resnet_Exp.ipynb' % for jupyter editor use
+
+## Script files:
+1. 'self_layers.py' %to import some self-defined layers
+2. 'PINN_Model_Predict.py' % run the model, output MATLAB .mat file, visualize the prediction
+3. 'self_Predict_ModelResult.py' % child file of the 'PINN_Model_Predict.py', including necessary code for Efield prediction
+
+## Model file (DDON) and model description
+- Please download the DDON model via the release page for use (put it under the dir model log) or via: <br>
+  https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON/20260520_model_Batsize-512.h5
+
+## Instructions to use the model for Efield prediction:
+1. To use the model, please first interpolate the EFISH file to the following grid via MATLAB:
+   $z/z_R = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 \, 24:2:50]$; <br>
+   or <br>
+   $z/z_R = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]$; <br>
+   
+   **Note**: The first grid point is recommended and should be tried first, as it may always show good predictions; otherwise, try the second to see if better results can be gotten. <br>
+
+2. Then further normalize the $z/z_R$ by dividing $z_\mathrm{scale} = 50$, then the input grid should be:<br>
+   $z^\prime = z/z_R/50 = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 24:2:50]/50$; <br>
+   or <br>
+   $z^\prime = z/z_R/50 = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]/50$; <br>
+   
+   **Note 1**: $z^\prime \in [-1,1]$; crop the input EFISH profile if the normalized and scaled range (z/z_R/50) goes beyond this range. <br>
+   **Note 2**: The sampling grid outside your experiment range could be set to zero, as the DDON accepts zero input outside the key feature range. For how to quantify the key range, please refer to our paper. Please ensure the input range is at least 4.2*FWHM of your input EFISH profile (normalized), although sometimes a smaller sampling range than this criterion also works. <br>
+
+3. Normalize the measured EFISH profile (along the laser propagation axis, $z$) by its maximum:
+   $P_\mathrm{norm}(z) = P(z)/P_\mathrm{max}$
+
+4. Estimate the phase mismatch value $u$ through the wave-factor mismatch $\Delta k$ and Rayleigh range $z_\mathrm{R}$, and normalize it as input: <br>
+   $u^\prime$ = $\Delta k \cdot z_\mathrm{R}$/-0.068. <br>
+   **Note**: -0.068 is the max $u$ value from the training dataset. <br>
+
+5. Import the MAT file as structure files and obtain the prediction. Or you can modify the code to fit your data structure as well.
+   
+   The MAT file structure is as follows:<br>
+   
+   <table>
+  <tr>
+    <td rowspan="3"><code>Profile_Px</code></td>
+    <td>$P_x$</td>
+    <td>$[z, P_x]$ (experimentally measured EFISH and normalized $z'$; dim: [109,2])</td>
+  </tr>
+  <tr>
+    <td>$u$</td>
+    <td>The phase mismatch value along $z$; dim: [109,1]</td>
+  </tr>
+  <tr>
+    <td>$E_x$</td>
+    <td>The electric field value along $z$; dim: [109,1]</td>
+  </tr>
+</table>## Choose how to use DDON
+
+### 1. Online Web App — no installation
+
+Run DDON directly in a web browser:
+
+**[Launch the DDON E-field Reconstruction Web App](https://ozzzzj.github.io/Decoder-DeepONet/)**
+
+The web app supports preprocessed CSV and MATLAB MAT inputs and performs inference locally in the browser using ONNX Runtime Web.
+
+### 2. Local Packaged Inference — lightweight ONNX Runtime
+
+For local prediction without installing TensorFlow, install this repository as a Python package:
+
+```bash
+pip install .
+```
+
+Python interface:
+
+```python
+from ddon import DDON
+
+model = DDON()
+E = model.predict(values, u=-0.35)
+```
+
+Command-line interface:
+
+```bash
+ddon predict Efish_vertical.mat -o prediction.csv
+```
+
+For MATLAB MAT input, `Profile_Px.Px` and `Profile_Px.u` are read automatically. CSV/TXT input can be used with `--u`:
+
+```bash
+ddon predict input.csv --u -0.35 -o prediction.mat
+```
+
+The ONNX model is downloaded automatically on first use and cached locally. This mode requires only NumPy, SciPy, and ONNX Runtime.
+
+### 3. Full Python Research Code — To be released
+
+The full TensorFlow research implementation, including the original prediction, evaluation, and analysis workflow, is not included in the current public release and will be released separately in the future.
+
+
+## Environment recommended (model trained on):
+- Python 3.10.15
+- TensorFlow-gpu 2.10.1
+
+## Main user file:
+1. 'DeepONet_Resnet_Exp.py' % for script use
+2. 'DeepONet_Resnet_Exp.ipynb' % for jupyter editor use
+
+## Script files:
+1. 'self_layers.py' %to import some self-defined layers
+2. 'PINN_Model_Predict.py' % run the model, output MATLAB .mat file, visualize the prediction
+3. 'self_Predict_ModelResult.py' % child file of the 'PINN_Model_Predict.py', including necessary code for Efield prediction
+
+## Model file (DDON) and model description
+- Please download the DDON model via the release page for use (put it under the dir model log) or via: <br>
+  https://github.com/ozzzzj/Decoder-DeepONet/releases/download/DDON/20260520_model_Batsize-512.h5
+
+## Instructions to use the model for Efield prediction:
+1. To use the model, please first interpolate the EFISH file to the following grid via MATLAB:
+   $z/z_R = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 \, 24:2:50]$; <br>
+   or <br>
+   $z/z_R = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]$; <br>
+   
+   **Note**: The first grid point is recommended and should be tried first, as it may always show good predictions; otherwise, try the second to see if better results can be gotten. <br>
+
+2. Then further normalize the $z/z_R$ by dividing $z_\mathrm{scale} = 50$, then the input grid should be:<br>
+   $z^\prime = z/z_R/50 = [-50:2:-24 \, -22:1:-16 \, -15:0.5:-1.5 \, -1:0.2:1 \, 1.5:0.5:15 \, 16:1:22 24:2:50]/50$; <br>
+   or <br>
+   $z^\prime = z/z_R/50 = [-50:1:-2 \, -1:0.2:1 \, 2:1:50]/50$; <br>
+   
+   **Note 1**: $z^\prime \in [-1,1]$; crop the input EFISH profile if the normalized and scaled range (z/z_R/50) goes beyond this range. <br>
+   **Note 2**: The sampling grid outside your experiment range could be set to zero, as the DDON accepts zero input outside the key feature range. For how to quantify the key range, please refer to our paper. Please ensure the input range is at least 4.2*FWHM of your input EFISH profile (normalized), although sometimes a smaller sampling range than this criterion also works. <br>
+
+3. Normalize the measured EFISH profile (along the laser propagation axis, $z$) by its maximum:
+   $P_\mathrm{norm}(z) = P(z)/P_\mathrm{max}$
+
+4. Estimate the phase mismatch value $u$ through the wave-factor mismatch $\Delta k$ and Rayleigh range $z_\mathrm{R}$, and normalize it as input: <br>
+   $u^\prime$ = $\Delta k \cdot z_\mathrm{R}$/-0.068. <br>
+   **Note**: -0.068 is the max $u$ value from the training dataset. <br>
+
+5. Import the MAT file as structure files and obtain the prediction. Or you can modify the code to fit your data structure as well.
+   
+   The MAT file structure is as follows:<br>
+   
+   <table>
+  <tr>
+    <td rowspan="3"><code>Profile_Px</code></td>
+    <td>$P_x$</td>
+    <td>$[z, P_x]$ (experimentally measured EFISH and normalized $z'$; dim: [109,2])</td>
+  </tr>
+  <tr>
+    <td>$u$</td>
+    <td>The phase mismatch value along $z$; dim: [109,1]</td>
+  </tr>
+  <tr>
+    <td>$E_x$</td>
+    <td>The electric field value along $z$; dim: [109,1]</td>
+  </tr>
+</table>

ddon_efish-1.0.0/ddon_efish.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+ddon/__init__.py
+ddon/cli.py
+ddon/io.py
+ddon/predictor.py
+ddon_efish.egg-info/PKG-INFO
+ddon_efish.egg-info/SOURCES.txt
+ddon_efish.egg-info/dependency_links.txt
+ddon_efish.egg-info/entry_points.txt
+ddon_efish.egg-info/requires.txt
+ddon_efish.egg-info/top_level.txt

ddon_efish-1.0.0/ddon_efish.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ddon_efish-1.0.0/ddon_efish.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ddon = ddon.cli:main

ddon_efish-1.0.0/ddon_efish.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy<3
+onnxruntime>=1.17
+scipy>=1.9

ddon_efish-1.0.0/ddon_efish.egg-info/top_level.txt

@@ -0,0 +1 @@
+ddon

ddon_efish-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ddon-efish"
+version = "1.0.0"
+description = "Lightweight local inference package for Decoder-DeepONet (DDON) EFISH electric-field reconstruction."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+  "numpy<3",
+  "onnxruntime>=1.17",
+  "scipy>=1.9"
+]
+
+[project.scripts]
+ddon = "ddon.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["ddon*"]
+
+[project.urls]
+Homepage = "https://github.com/ozzzzj/Decoder-DeepONet"
+"Web App" = "https://ozzzzj.github.io/Decoder-DeepONet/"
+Paper = "https://doi.org/10.1088/1361-6595/ae413f"

ddon_efish-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+