init

.gitignore

@@ -0,0 +1,53 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+.venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Logs
+*.log
+nohup.out
+app.log
+
+# Gradio
+flagged/
+gradio_cached_examples/
+
+# Model cache
+.cache/
+*.pkl
+*.pth

README.md

@@ -12,3 +12,100 @@ short_description: Web-app and APIs to get NeuralFoil predictions
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# NeuralFoil Airfoil Predictor (Hugging Face Space)
+
+This Space wraps [NeuralFoil](https://github.com/peterdsharpe/NeuralFoil) in a Gradio UI.
+
+It runs a NeuralFoil surrogate model to estimate airfoil aerodynamics (CL, CD, CM, transition locations, and an analysis confidence metric) for a single operating point.
+
+NeuralFoil is a neural-network-based surrogate for XFoil.  
+Given an airfoil and operating conditions, it predicts aerodynamic coefficients and related quantities much faster than traditional CFD or XFoil.
+
+This Space only wraps that functionality and does **not** train any models itself.
+
+## Features
+
+- **Airfoil definition**
+  - By **name** via AeroSandbox (UIUC / NACA-style names, e.g. `naca4412`, `rae2822`, `clarky`)
+  - By **`.dat` file upload** (XFoil-style coordinate file)
+  - numpy coordinates
+
+- **Operating point inputs**
+  - Angle of attack **α [deg]**
+  - Reynolds number **Re [-]**
+  - NeuralFoil **model size** (`xxsmall` … `xxxlarge`)
+
+- **Outputs**
+  - Lift coefficient **CL**
+  - Drag coefficient **CD**
+  - Moment coefficient **CM**
+  - Transition locations: **Top_Xtr**, **Bot_Xtr** (if available)
+  - **analysis_confidence** + a crude textual interpretation
+  - Full raw NeuralFoil output JSON (for power users / debugging)
+
+
+## Running locally
+
+### Quick Start (if already set up)
+
+```bash
+./run.sh
+# or
+source venv/bin/activate && python app.py
+```
+
+### First Time Setup
+
+```bash
+# 1. Create virtual environment
+python3 -m venv venv
+
+# 2. Activate virtual environment
+source venv/bin/activate  # macOS/Linux
+# or
+venv\Scripts\activate     # Windows
+
+# 3. Install dependencies
+pip install --upgrade pip
+pip install -r requirements.txt
+
+# 4. Run the app
+python app.py
+```
+
+The app will start on `http://127.0.0.1:7860` (or next available port).
+
+See [SETUP.md](SETUP.md) for detailed setup instructions and troubleshooting.
+
+## License
+
+- NeuralFoil itself is MIT-licensed (see its own repository for details).
+- This Space is just a thin wrapper around NeuralFoil and AeroSandbox.
+
+## Citation
+
+If you use NeuralFoil in your research, please cite:
+Both the tool itself (this repository), which includes the pre-print publication:
+
+```bibtex
+@misc{neuralfoil,
+  author = {Peter Sharpe},
+  title = {{NeuralFoil}: An airfoil aerodynamics analysis tool using physics-informed machine learning},
+  year = {2023},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/peterdsharpe/NeuralFoil}},
+}
+```
+
+And the author's PhD thesis, which has an extended chapter that serves as the primary long-form documentation for the tool:
+
+```bibtex
+@phdthesis{aerosandbox_phd_thesis,
+   title = {Accelerating Practical Engineering Design Optimization with Computational Graph Transformations},
+   author = {Sharpe, Peter D.},
+   school = {Massachusetts Institute of Technology}, 
+   year = {2024},
+}
+```

app.py

@@ -0,0 +1,218 @@
+import gradio as gr
+import neuralfoil as nf
+import numpy as np
+import json
+from pathlib import Path
+
+def load_airfoil_from_dat(filepath):
+    """Load airfoil coordinates from a .dat file"""
+    with open(filepath, 'r') as f:
+        lines = f.readlines()
+    
+    # Skip the first line (airfoil name)
+    coords = []
+    for line in lines[1:]:
+        line = line.strip()
+        if line:
+            parts = line.split()
+            if len(parts) >= 2:
+                try:
+                    x, y = float(parts[0]), float(parts[1])
+                    coords.append([x, y])
+                except ValueError:
+                    continue
+    
+    return np.array(coords)
+
+def format_coordinates(coords_array):
+    """Format coordinates array as a string for display"""
+    if coords_array is None or len(coords_array) == 0:
+        return ""
+    
+    lines = []
+    for x, y in coords_array:
+        lines.append(f"{x:.6f}     {y:.6f}")
+    return "\n".join(lines)
+
+def parse_coordinates(coords_text):
+    """Parse coordinates from text input"""
+    lines = coords_text.strip().split('\n')
+    coords = []
+    
+    for line in lines:
+        line = line.strip()
+        if line:
+            parts = line.split()
+            if len(parts) >= 2:
+                try:
+                    x, y = float(parts[0]), float(parts[1])
+                    coords.append([x, y])
+                except ValueError:
+                    continue
+    
+    return np.array(coords)
+
+def run_neuralfoil_prediction(coords_text, alpha, reynolds, model_size):
+    """Run NeuralFoil prediction and return full JSON output"""
+    try:
+        # Parse coordinates
+        coords = parse_coordinates(coords_text)
+        
+        if len(coords) < 3:
+            return json.dumps({"error": "Invalid coordinates. Please provide at least 3 coordinate pairs."}, indent=2)
+        
+        # Run NeuralFoil analysis directly from coordinates
+        result = nf.get_aero_from_coordinates(
+            coordinates=coords,
+            alpha=alpha,
+            Re=reynolds,
+            model_size=model_size
+        )
+        print(result)
+        
+        # Convert result to a serializable dictionary
+        output = {}
+        
+        # Standard outputs
+        if hasattr(result, 'CL'):
+            output['CL'] = float(result.CL) if not np.isnan(result.CL) else None
+        if hasattr(result, 'CD'):
+            output['CD'] = float(result.CD) if not np.isnan(result.CD) else None
+        if hasattr(result, 'CM'):
+            output['CM'] = float(result.CM) if not np.isnan(result.CM) else None
+        
+        # Transition locations (if available)
+        if hasattr(result, 'Top_Xtr'):
+            output['Top_Xtr'] = float(result.Top_Xtr) if not np.isnan(result.Top_Xtr) else None
+        if hasattr(result, 'Bot_Xtr'):
+            output['Bot_Xtr'] = float(result.Bot_Xtr) if not np.isnan(result.Bot_Xtr) else None
+        
+        # Confidence metric
+        if hasattr(result, 'analysis_confidence'):
+            output['analysis_confidence'] = float(result.analysis_confidence) if not np.isnan(result.analysis_confidence) else None
+        
+        # Include all other attributes
+        for attr in dir(result):
+            if not attr.startswith('_') and attr not in output:
+                val = getattr(result, attr)
+                if isinstance(val, (int, float, str, bool)):
+                    output[attr] = val
+                elif isinstance(val, np.ndarray):
+                    output[attr] = val.tolist()
+        
+        # Add input parameters for reference
+        output['input_parameters'] = {
+            'alpha_deg': alpha,
+            'reynolds_number': reynolds,
+            'model_size': model_size,
+            'num_coordinates': len(coords)
+        }
+        
+        return json.dumps(output, indent=2)
+        
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+def load_example(example_name):
+    """Load an example airfoil"""
+    example_files = {
+        "NACA 4412": "examples/naca4412.dat",
+        "Clark Y": "examples/clarky.dat",
+        "RAE 2822": "examples/rae2822.dat"
+    }
+    
+    filepath = example_files.get(example_name)
+    if filepath and Path(filepath).exists():
+        coords = load_airfoil_from_dat(filepath)
+        return format_coordinates(coords)
+    return ""
+
+# Load default airfoil (NACA 4412)
+default_coords = format_coordinates(load_airfoil_from_dat("examples/naca4412.dat"))
+
+# Create Gradio interface
+with gr.Blocks(title="NeuralFoil Airfoil Predictor") as demo:
+    gr.Markdown("# NeuralFoil Airfoil Predictor")
+    gr.Markdown("""
+    This app uses [NeuralFoil](https://github.com/peterdsharpe/NeuralFoil) to predict airfoil aerodynamics.
+    
+    Provide airfoil coordinates (x, y pairs, one per line) and operating conditions to get predictions for CL, CD, CM, and more.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Airfoil Coordinates")
+            gr.Markdown("Enter x,y coordinate pairs (one per line). Coordinates should trace the airfoil from trailing edge, over the top, to leading edge, then back along the bottom.")
+            
+            coords_input = gr.Textbox(
+                label="Airfoil Coordinates",
+                value=default_coords,
+                lines=15,
+                max_lines=30,
+                placeholder="x     y\n1.0   0.0\n0.95  0.01\n..."
+            )
+            
+            gr.Markdown("### Load Example")
+            example_buttons = gr.Radio(
+                choices=["NACA 4412", "Clark Y", "RAE 2822"],
+                label="Example Airfoils",
+                value="NACA 4412"
+            )
+            
+            load_btn = gr.Button("Load Example")
+            
+            gr.Markdown("### Operating Conditions")
+            alpha_input = gr.Slider(
+                minimum=-10,
+                maximum=20,
+                value=5.0,
+                step=0.5,
+                label="Angle of Attack α [deg]"
+            )
+            
+            reynolds_input = gr.Number(
+                value=1e6,
+                label="Reynolds Number Re [-]"
+            )
+            
+            model_size_input = gr.Dropdown(
+                choices=["xxsmall", "xsmall", "small", "medium", "large", "xlarge", "xxlarge", "xxxlarge"],
+                value="large",
+                label="Model Size"
+            )
+            
+            predict_btn = gr.Button("Run Prediction", variant="primary")
+        
+        with gr.Column():
+            gr.Markdown("### Full NeuralFoil Output (JSON)")
+            output_json = gr.Textbox(
+                label="Prediction Results",
+                lines=25,
+                max_lines=40,
+                placeholder="Results will appear here..."
+            )
+    
+    # Event handlers
+    load_btn.click(
+        fn=load_example,
+        inputs=[example_buttons],
+        outputs=[coords_input]
+    )
+    
+    predict_btn.click(
+        fn=run_neuralfoil_prediction,
+        inputs=[coords_input, alpha_input, reynolds_input, model_size_input],
+        outputs=[output_json]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### About
+    
+    **NeuralFoil** is a neural-network-based surrogate for XFoil that predicts airfoil aerodynamics much faster than traditional CFD.
+    
+    **Citation**: If you use NeuralFoil, please cite the [GitHub repository](https://github.com/peterdsharpe/NeuralFoil) and Peter Sharpe's PhD thesis.
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

examples/clarky.dat

@@ -0,0 +1,36 @@
+CLARK Y
+     1.000000     0.000000
+     0.950000     0.009300
+     0.900000     0.017800
+     0.800000     0.032500
+     0.700000     0.044500
+     0.600000     0.053500
+     0.500000     0.059500
+     0.400000     0.061500
+     0.300000     0.059000
+     0.250000     0.056000
+     0.200000     0.051500
+     0.150000     0.045500
+     0.100000     0.037000
+     0.075000     0.031000
+     0.050000     0.024000
+     0.025000     0.015500
+     0.012500     0.010500
+     0.000000     0.000000
+     0.012500    -0.010500
+     0.025000    -0.015000
+     0.050000    -0.020000
+     0.075000    -0.023000
+     0.100000    -0.025000
+     0.150000    -0.026000
+     0.200000    -0.025500
+     0.250000    -0.024000
+     0.300000    -0.022000
+     0.400000    -0.017500
+     0.500000    -0.012500
+     0.600000    -0.008000
+     0.700000    -0.004500
+     0.800000    -0.002000
+     0.900000    -0.000500
+     0.950000    -0.000250
+     1.000000     0.000000

examples/naca4412.dat

@@ -0,0 +1,44 @@
+NACA 4412
+     1.000000     0.001260
+     0.950070     0.010760
+     0.900190     0.019440
+     0.850360     0.027380
+     0.800580     0.034640
+     0.750860     0.041260
+     0.701190     0.047300
+     0.651580     0.052790
+     0.602030     0.057770
+     0.552550     0.062270
+     0.503140     0.066310
+     0.453810     0.069910
+     0.404580     0.073080
+     0.355450     0.075820
+     0.306440     0.078120
+     0.257570     0.079970
+     0.208840     0.081330
+     0.160280     0.082160
+     0.111900     0.082400
+     0.063730     0.081950
+     0.015810     0.080630
+     0.000000     0.000000
+     0.034190    -0.059780
+     0.082600    -0.056500
+     0.131100    -0.052370
+     0.179720    -0.047770
+     0.228460    -0.042960
+     0.277320    -0.038070
+     0.326290    -0.033180
+     0.375360    -0.028360
+     0.424540    -0.023640
+     0.473810    -0.019070
+     0.523190    -0.014680
+     0.572640    -0.010500
+     0.622170    -0.006560
+     0.671770    -0.002890
+     0.721440     0.000510
+     0.771170     0.003630
+     0.820960     0.006480
+     0.870790     0.009060
+     0.920660     0.011360
+     0.970570     0.013400
+     1.000000     0.001260

examples/rae2822.dat

@@ -0,0 +1,48 @@
+RAE 2822
+     1.000000     0.000000
+     0.950000     0.005800
+     0.900000     0.011200
+     0.850000     0.016100
+     0.800000     0.020700
+     0.750000     0.024900
+     0.700000     0.028800
+     0.650000     0.032300
+     0.600000     0.035500
+     0.550000     0.038400
+     0.500000     0.040900
+     0.450000     0.043000
+     0.400000     0.044700
+     0.350000     0.045900
+     0.300000     0.046500
+     0.250000     0.046400
+     0.200000     0.045300
+     0.150000     0.042700
+     0.100000     0.037800
+     0.075000     0.034200
+     0.050000     0.029200
+     0.025000     0.021500
+     0.012500     0.015500
+     0.000000     0.000000
+     0.012500    -0.015500
+     0.025000    -0.021000
+     0.050000    -0.026500
+     0.075000    -0.029500
+     0.100000    -0.031500
+     0.150000    -0.033500
+     0.200000    -0.033500
+     0.250000    -0.032000
+     0.300000    -0.029500
+     0.350000    -0.026500
+     0.400000    -0.023000
+     0.450000    -0.019500
+     0.500000    -0.016000
+     0.550000    -0.012500
+     0.600000    -0.009500
+     0.650000    -0.006800
+     0.700000    -0.004500
+     0.750000    -0.002700
+     0.800000    -0.001300
+     0.850000    -0.000500
+     0.900000    -0.000100
+     0.950000     0.000000
+     1.000000     0.000000

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0,<4.45.0
+# huggingface-hub<1.0.0
+neuralfoil>=0.2.0
+aerosandbox>=4.0.0
+numpy>=1.24.0

run.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Simple script to run the NeuralFoil Gradio app
+
+echo "🚀 Starting NeuralFoil Airfoil Predictor..."
+echo ""
+
+# Check if virtual environment exists
+if [ ! -d "venv" ]; then
+    echo "❌ Virtual environment not found!"
+    echo "Please run: python3 -m venv venv && source venv/bin/activate && pip install -r requirements.txt"
+    exit 1
+fi
+
+# Activate virtual environment
+source venv/bin/activate
+
+# Check if dependencies are installed
+python -c "import gradio, neuralfoil" 2>/dev/null
+if [ $? -ne 0 ]; then
+    echo "❌ Dependencies not installed!"
+    echo "Please run: pip install -r requirements.txt"
+    exit 1
+fi
+
+echo "✅ Virtual environment activated"
+echo "✅ Dependencies found"
+echo ""
+echo "📊 Launching Gradio app..."
+echo "⏳ First startup may take 30-60 seconds..."
+echo ""
+
+# Run the app
+python app.py