Skip to content

Add Jupyter notebook and parametrize example input files #2

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
yannrichet-asnr merged 3 commits into from
Nov 28, 2025
Merged

Add Jupyter notebook and parametrize example input files #2

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
de6bb01
Initial plan
Copilot Nov 28, 2025
33dfc19
Add Jupyter notebook and parametrize input files with multiple variab…
Copilot Nov 28, 2025
1fad030
Fix shell variable injection vulnerability in calculator script
Copilot Nov 28, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 15 additions & 7 deletions .fz/calculators/Model.sh
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,19 +28,27 @@ fi
PID_FILE=$PWD/PID
echo $$ >> $PID_FILE

# Mock calculation: extract the value from the input file and write to output
# Mock calculation: extract values from the input file and compute a result
# This simulates a real calculation that produces an output file
# Replace this section with actual calls to your simulation code

echo "Running mock calculation on $input..."

# Extract variable value from input (looking for "value = X" pattern)
value=$(grep -E '^value\s*=' "$input" | sed 's/.*=\s*//' | tr -d '[:space:]')
# Extract variable values from input (looking for "var = X" pattern)
x=$(grep -E '^x\s*=' "$input" | sed 's/.*=\s*//' | tr -d '[:space:]')
y=$(grep -E '^y\s*=' "$input" | sed 's/.*=\s*//' | tr -d '[:space:]')
z=$(grep -E '^z\s*=' "$input" | sed 's/.*=\s*//' | tr -d '[:space:]')

if [ -n "$value" ]; then
# Mock computation: just return the value (or compute something from it)
result=$value
echo "Input value: $value"
# Fallback to 'value' for backwards compatibility
if [ -z "$x" ]; then
x=$(grep -E '^value\s*=' "$input" | sed 's/.*=\s*//' | tr -d '[:space:]')
fi

if [ -n "$x" ]; then
# Mock computation: compute result = x + y + z (or just x if y,z not present)
# Using awk with -v for safe variable passing
result=$(awk -v x="${x:-0}" -v y="${y:-0}" -v z="${z:-0}" 'BEGIN { print (x+0) + (y+0) + (z+0) }')
echo "Input values: x=$x, y=${y:-0}, z=${z:-0}"
echo "Result: $result"
echo "$result" > output.txt
echo "Calculation completed successfully."
Expand Down
15 changes: 10 additions & 5 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,18 +31,20 @@ pip install git+https://github.com/Funz/fz.git
```python
import fz

# Example: Run calculation with varying x value
# Example: Run calculation with varying parameters
results = fz.fzr(
input_path="examples/Model/input.txt",
input_variables={
"x": [1.0, 2.0, 3.0, 4.0, 5.0]
"x": [1.0, 2.0, 3.0, 4.0, 5.0],
"y": [1.0, 2.0],
"z": [0.5]
},
model="Model",
calculators="localhost_Model",
results_dir="my_results"
)

print(results[['x', 'result']])
print(results[['x', 'y', 'z', 'result']])
```

### Directory Structure
Expand All @@ -69,11 +71,14 @@ your_project/
# Example input file for Model plugin
# Variables are defined using ${variable_name} syntax

value = ${x}
# Input parameters
x = ${x}
y = ${y}
z = ${z}
```

In this example:
- `${x}` is a variable parameter that will be substituted by fz
- `${x}`, `${y}`, and `${z}` are variable parameters that will be substituted by fz
- Lines starting with `#` are comments

## Creating Your Own Plugin
Expand Down
322 changes: 322 additions & 0 deletions example_usage.ipynb
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,322 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# fz-Model Plugin Example Usage\n",
"\n",
"This notebook demonstrates how to use the fz-Model plugin template.\n",
"\n",
"The examples cover:\n",
"1. Installing dependencies (fz framework and fz-Model plugin)\n",
"2. Downloading example input files\n",
"3. Parsing input files to identify variables\n",
"4. Compiling input files with specific parameter values\n",
"5. Running calculations with the mock calculator\n",
"6. Performing parametric studies\n",
"\n",
"**Note:** This is a template plugin with a mock calculator. Replace the calculator script with calls to your actual simulation code."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup: Install Dependencies\n",
"\n",
"First, install the Funz framework and the fz-Model plugin."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Install fz framework from GitHub\n",
"%pip install -q git+https://github.com/Funz/fz.git\n",
"\n",
"# Install fz-Model plugin\n",
"import fz\n",
"fz.install(\"Model\")\n",
"\n",
"print(\"✓ Dependencies installed successfully!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup: Download Example Files\n",
"\n",
"Download the example input files from the GitHub repository."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import urllib.request\n",
"\n",
"# Create directory for examples\n",
"os.makedirs(\"Model\", exist_ok=True)\n",
"\n",
"# Base URL for raw GitHub content\n",
"base_url = \"https://raw.githubusercontent.com/Funz/fz-Model/main/examples\"\n",
"\n",
"# Download example files\n",
"files_to_download = [\n",
" (\"Model/input.txt\", f\"{base_url}/Model/input.txt\"),\n",
"]\n",
"\n",
"print(\"Downloading example files...\")\n",
"for local_path, url in files_to_download:\n",
" try:\n",
" urllib.request.urlretrieve(url, local_path)\n",
" print(f\" ✓ Downloaded: {local_path}\")\n",
" except Exception as e:\n",
" print(f\" ✗ Failed to download {local_path}: {e}\")\n",
"\n",
"print(\"\\n✓ Example files ready!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Import Required Libraries"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import fz\n",
"import os\n",
"import tempfile\n",
"\n",
"print(f\"fz version: {fz.__version__ if hasattr(fz, '__version__') else 'unknown'}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example 1: Parse Input File for Variables\n",
"\n",
"Use `fz.fzi()` to identify variables in an input file."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Parse the input file to find variables\n",
"variables = fz.fzi(\n",
" \"Model/input.txt\",\n",
" \"Model\"\n",
")\n",
"\n",
"print(f\"Variables found in input.txt: {list(variables.keys())}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example 2: Compile Input Files\n",
"\n",
"Use `fz.fzc()` to compile input files with specific parameter values. This substitutes variables with actual values."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create temporary directory for compiled files\n",
"with tempfile.TemporaryDirectory() as tmpdir:\n",
" # Compile input with specific values\n",
" fz.fzc(\n",
" \"Model/input.txt\",\n",
" {\"x\": 3.14, \"y\": 2.0, \"z\": 1.5},\n",
" \"Model\",\n",
" output_dir=tmpdir\n",
" )\n",
" \n",
" # Show compiled file\n",
" # Find the compiled file (it may be in a subdirectory)\n",
" for root, dirs, files in os.walk(tmpdir):\n",
" for f in files:\n",
" if f == \"input.txt\":\n",
" compiled_file = os.path.join(root, f)\n",
" print(f\"Compiled file content (x=3.14, y=2.0, z=1.5):\")\n",
" print(\"=\" * 70)\n",
" with open(compiled_file, 'r') as file:\n",
" print(file.read())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example 3: Run a Basic Calculation\n",
"\n",
"Run a simple calculation using the mock calculator.\n",
"\n",
"**Note:** This uses the template's mock calculator which simply returns the input value. Replace the calculator script with your actual simulation code for real calculations."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define parameter values\n",
"input_variables = {\n",
" \"x\": [1.0, 2.0, 3.0, 4.0, 5.0]\n",
"}\n",
"\n",
"try:\n",
" # Run parametric calculation\n",
" results = fz.fzr(\n",
" input_path=\"Model/input.txt\",\n",
" input_variables=input_variables,\n",
" model=\"Model\",\n",
" calculators=\"localhost_Model\",\n",
" results_dir=\"results/basic_study\"\n",
" )\n",
" \n",
" # Display results\n",
" print(\"\\nResults:\")\n",
" print(\"=\" * 70)\n",
" print(results[['x', 'result', 'status']])\n",
" \n",
"except Exception as e:\n",
" print(f\"\\nError running calculation: {e}\")\n",
" print(\"Note: Make sure the calculator script is properly configured.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example 4: Multi-Parameter Study\n",
"\n",
"Demonstrate a parametric study with multiple variables."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"# Define multiple parameters\n",
"input_variables = {\n",
" \"x\": np.linspace(1.0, 5.0, 5).tolist(),\n",
" \"y\": [1.0, 2.0],\n",
" \"z\": [0.5]\n",
"}\n",
"\n",
"print(f\"Running parametric study...\")\n",
"print(f\" x values: {input_variables['x']}\")\n",
"print(f\" y values: {input_variables['y']}\")\n",
"print(f\" z values: {input_variables['z']}\")\n",
"\n",
"try:\n",
" # Run parametric calculation\n",
" results = fz.fzr(\n",
" input_path=\"Model/input.txt\",\n",
" input_variables=input_variables,\n",
" model=\"Model\",\n",
" calculators=\"localhost_Model\",\n",
" results_dir=\"results/multi_param_study\"\n",
" )\n",
" \n",
" # Display results\n",
" print(\"\\nResults:\")\n",
" print(\"=\" * 70)\n",
" print(results)\n",
" \n",
"except Exception as e:\n",
" print(f\"\\nError running parametric study: {e}\")\n",
" print(\"Note: Make sure the calculator script is properly configured.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example 5: Visualization\n",
"\n",
"If you have results, you can visualize them using matplotlib."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"# Example visualization (using mock data if real results aren't available)\n",
"try:\n",
" # Use actual results if available\n",
" if 'results' in dir() and results is not None:\n",
" x_values = results['x'].values\n",
" result_values = results['result'].values\n",
" else:\n",
" # Use mock data for demonstration\n",
" x_values = [1.0, 2.0, 3.0, 4.0, 5.0]\n",
" result_values = [1.0, 2.0, 3.0, 4.0, 5.0] # Mock: result = x\n",
" \n",
" plt.figure(figsize=(10, 6))\n",
" plt.plot(x_values, result_values, 'o-', linewidth=2, markersize=8)\n",
" plt.xlabel('x', fontsize=12)\n",
" plt.ylabel('result', fontsize=12)\n",
" plt.title('Parametric Study Results', fontsize=14, fontweight='bold')\n",
" plt.grid(True, alpha=0.3)\n",
" plt.tight_layout()\n",
" plt.show()\n",
" \n",
"except Exception as e:\n",
" print(f\"Visualization error: {e}\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Loading