Integration of Aurora

app.py

@@ -12,7 +12,7 @@ from werkzeug.utils import secure_filename
 from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, send_file
 
 # Import our custom modules
-from data_processor import NetCDFProcessor, analyze_netcdf_file
+from data_processor import NetCDFProcessor, AuroraPredictionProcessor, analyze_netcdf_file
 from plot_generator import IndiaMapPlotter
 from interactive_plot_generator import InteractiveIndiaMapPlotter
 from cams_downloader import CAMSDownloader
@@ -830,39 +830,47 @@ def aurora_status():
 # Aurora ML Prediction Routes
 @app.route('/aurora_predict', methods=['GET', 'POST'])
 def aurora_predict():
-    """Aurora prediction form and handler"""
+    """Aurora prediction form and handler with enhanced step selection"""
     if not AURORA_AVAILABLE:
         flash('Aurora model is not available. Please install required dependencies.', 'error')
         return redirect(url_for('index'))
     
     if request.method == 'GET':
         current_date = datetime.now().strftime('%Y-%m-%d')
-        return render_template('aurora_predict.html', current_date=current_date)
+        # Get list of existing prediction runs
+        existing_runs = AuroraPipeline.list_prediction_runs() if hasattr(AuroraPipeline, 'list_prediction_runs') else []
+        return render_template('aurora_predict.html', 
+                               current_date=current_date,
+                               existing_runs=existing_runs)
     
     # POST: Run the pipeline
     date_str = request.form.get('date')
-    steps = int(request.form.get('steps', 2))  # Default to 2 steps for CPU-friendly execution
+    steps = int(request.form.get('steps', 2))  # Default to 2 steps
+    
+    # Validate steps (1-4 allowed, each representing 12 hours)
+    if steps < 1 or steps > 4:
+        flash('Number of steps must be between 1 and 4 (each step = 12 hours)', 'error')
+        return redirect(url_for('aurora_predict'))
     
     # Limit steps for local/CPU execution
     if hasattr(aurora_pipeline, 'cpu_only') and aurora_pipeline.cpu_only:
-        steps = min(steps, 2)  # Max 2 steps for CPU
-        if steps != int(request.form.get('steps', 2)):
+        max_cpu_steps = 2
+        if steps > max_cpu_steps:
+            steps = max_cpu_steps
             flash(f'Steps reduced to {steps} for CPU mode optimization', 'info')
     
     if not date_str:
         flash('Please select a valid date.', 'error')
         return redirect(url_for('aurora_predict'))
-    
-    cams_date = date_str
-    cams_time = "12:00"  # Always use 12:00 UTC for Aurora
 
     try:
-        print(f"🚀 Starting Aurora prediction pipeline for {cams_date}")
+        print(f"🚀 Starting Aurora prediction pipeline for {date_str}")
+        print(f"📊 Requested {steps} forward steps ({steps * 12} hours coverage)")
         
-        # 1. Download CAMS data for the selected date
-        print("📥 Step 1/5: Downloading CAMS atmospheric data...")
+        # 1. Download CAMS data for the selected date (if not already available)
+        print("📥 Step 1/5: Checking/downloading CAMS atmospheric data...")
         try:
-            zip_path = downloader.download_cams_data(cams_date)
+            zip_path = downloader.download_cams_data(date_str)
         except Exception as e:
             error_msg = f"Failed to download CAMS data: {str(e)}"
             if "error response" in str(e).lower():
@@ -886,23 +894,28 @@ def aurora_predict():
             print(f"❌ Extraction error: {traceback.format_exc()}")
             return redirect(url_for('aurora_predict'))
         
-        # 2. Run Aurora pipeline (batch creation, model, prediction, save NetCDF)
-        print("🔮 Step 2/5: Initializing Aurora ML pipeline...")
-        output_nc = f"predictions_{cams_date}_{cams_time.replace(':','')}.nc"
-        
-        print(f"🧠 Step 3/5: Loading Aurora model (this may take a few minutes)...")
-        print(f"⚡ Step 4/5: Running {steps} prediction steps...")
+        # 2. Run enhanced Aurora pipeline
+        print("🔮 Step 2/5: Running enhanced Aurora ML pipeline...")
         
         try:
-            predictions = aurora_pipeline.run_pipeline(
-                date_str=cams_date,
+            # Use the enhanced pipeline method
+            run_metadata = aurora_pipeline.run_aurora_prediction_pipeline(
+                date_str=date_str,
                 Batch=Batch,
                 Metadata=Metadata,
                 AuroraAirPollution=AuroraAirPollution,
                 rollout=rollout,
-                steps=steps,
-                output_path=Path('predictions') / output_nc
+                steps=steps
             )
+            
+            print("✅ Aurora predictions completed successfully")
+            
+            # Redirect to aurora variables page
+            run_dir_name = run_metadata['run_directory'].split('/')[-1]
+            
+            flash(f'🔮 Aurora predictions generated successfully for {date_str} ({steps} steps, {steps * 12}h coverage)', 'success')
+            return redirect(url_for('aurora_variables', run_dir=run_dir_name))
+            
         except Exception as e:
             error_msg = f"Aurora model execution failed: {str(e)}"
             if "map_location" in str(e):
@@ -914,12 +927,13 @@ def aurora_predict():
             flash(error_msg, 'error')
             print(f"❌ Aurora model error: {traceback.format_exc()}")
             return redirect(url_for('aurora_predict'))
-        
-        print("💾 Step 5/5: Saving results and preparing visualization...")
-        print(f"✅ Aurora predictions completed for {cams_date} 12:00 UTC")
-        
-        flash(f'🔮 Aurora predictions generated successfully for {cams_date} ({steps} steps)', 'success')
-        return redirect(url_for('visualize_prediction', filename=output_nc))
+    
+    except Exception as e:
+        # Catch-all for any other unexpected errors
+        error_msg = f'Unexpected error in Aurora pipeline: {str(e)}'
+        flash(error_msg, 'error')
+        print(f"❌ Unexpected Aurora pipeline error: {traceback.format_exc()}")
+        return redirect(url_for('aurora_predict'))
     
     except Exception as e:
         # Catch-all for any other unexpected errors
@@ -929,97 +943,319 @@ def aurora_predict():
         return redirect(url_for('aurora_predict'))
 
 
-@app.route('/visualize_prediction/<filename>', methods=['GET', 'POST'])
+@app.route('/visualize_prediction/<path:filename>', methods=['GET', 'POST'])
 def visualize_prediction(filename):
-    """Visualize or download Aurora prediction output with variable and step selection"""
-    file_path = Path('predictions') / filename
+    """Aurora prediction visualization with step, variable, and pressure level selection"""
+    # Handle both old and new filename formats
+    if filename.endswith('.nc'):
+        file_path = Path('predictions') / filename
+    else:
+        # Try to find the prediction file in the run directory
+        run_dir = Path('predictions') / filename
+        if run_dir.is_dir():
+            # Look for the .nc file in the directory
+            nc_files = list(run_dir.glob("*.nc"))
+            if nc_files:
+                file_path = nc_files[0]
+            else:
+                flash('No prediction file found in run directory', 'error')
+                return redirect(url_for('index'))
+        else:
+            file_path = Path('predictions') / filename
+    
     if not file_path.exists():
         flash('Prediction file not found', 'error')
         return redirect(url_for('index'))
 
-    ds = xr.open_dataset(file_path)
-    variables = list(ds.data_vars.keys())
-    steps = ds['step'].values if 'step' in ds else np.arange(ds[variables[0]].shape[0])
+    try:
+        ds = xr.open_dataset(file_path)
+        
+        # Get all variables and separate surface from atmospheric
+        all_variables = list(ds.data_vars.keys())
+        surface_vars = []
+        atmospheric_vars = []
+        
+        for var in all_variables:
+            if 'pressure_level' in ds[var].dims:
+                atmospheric_vars.append(var)
+            else:
+                surface_vars.append(var)
+        
+        # Get steps and pressure levels
+        steps = list(range(len(ds['step']))) if 'step' in ds else [0]
+        pressure_levels = list(ds['pressure_level'].values) if 'pressure_level' in ds else []
+        
+        # Handle form submission
+        if request.method == 'POST':
+            selected_step = int(request.form.get('step', 0))
+            var_name = request.form.get('variable')
+            pressure_level = request.form.get('pressure_level')
+            color_theme = request.form.get('color_theme', 'viridis')
+            plot_type = request.form.get('plot_type', 'static')
+        else:
+            selected_step = 0
+            var_name = surface_vars[0] if surface_vars else all_variables[0] if all_variables else None
+            pressure_level = None
+            color_theme = 'viridis'
+            plot_type = 'static'
+            
+        if not var_name or var_name not in all_variables:
+            flash('Invalid variable selected', 'error')
+            return redirect(url_for('index'))
 
-    # Handle form submission
-    if request.method == 'POST':
-        var_name = request.form.get('variable')
+        # Validate step
+        if selected_step < 0 or selected_step >= len(steps):
+            selected_step = 0
+
+        return render_template(
+            'aurora_variables.html',
+            filename=filename,
+            file_path=str(file_path),
+            surface_vars=surface_vars,
+            atmospheric_vars=atmospheric_vars,
+            steps=steps,
+            pressure_levels=pressure_levels,
+            selected_step=selected_step,
+            selected_variable=var_name,
+            selected_pressure_level=pressure_level,
+            color_theme=color_theme,
+            plot_type=plot_type,
+            color_themes=COLOR_THEMES
+        )
+            
+    except Exception as e:
+        flash(f'Error processing prediction file: {str(e)}', 'error')
+        print(f"❌ Prediction visualization error: {traceback.format_exc()}")
+        return redirect(url_for('index'))
+
+
+@app.route('/generate_aurora_plot', methods=['POST'])
+def generate_aurora_plot():
+    """Generate plot from Aurora prediction data"""
+    try:
+        file_path = request.form.get('file_path')
         step = int(request.form.get('step', 0))
+        var_name = request.form.get('variable')
+        pressure_level = request.form.get('pressure_level')
         color_theme = request.form.get('color_theme', 'viridis')
-    else:
-        var_name = variables[0]
-        step = 0
-        color_theme = 'viridis'
-
-    # Prepare data for plotting
-    data = ds[var_name].values
-    if data.ndim == 3:
-        data_to_plot = data[step]
-    elif data.ndim == 2:
-        data_to_plot = data
-    else:
-        flash('Prediction data shape not supported for plotting', 'error')
+        plot_type = request.form.get('plot_type', 'static')
+        
+        if not file_path or not var_name:
+            flash('Missing required parameters', 'error')
+            return redirect(url_for('index'))
+        
+        # Open dataset
+        ds = xr.open_dataset(file_path)
+        
+        # Get data for the selected variable and step
+        data = ds[var_name]
+        
+        # Handle different dimensions
+        if 'step' in data.dims:
+            data = data.isel(step=step)
+        
+        if pressure_level and 'pressure_level' in data.dims:
+            pressure_level = float(pressure_level)
+            data = data.sel(pressure_level=pressure_level, method='nearest')
+        
+        # Convert to numpy
+        data_to_plot = data.values
+        
+        # Get coordinates
+        lats = ds['lat'].values if 'lat' in ds else ds['latitude'].values
+        lons = ds['lon'].values if 'lon' in ds else ds['longitude'].values
+        
+        # Prepare metadata
+        from constants import NETCDF_VARIABLES
+        var_info = NETCDF_VARIABLES.get(var_name, {})
+        display_name = var_info.get('name', var_name)
+        units = ds[var_name].attrs.get('units', var_info.get('units', ''))
+        
+        hours_from_start = (step + 1) * 12
+        step_time_str = f"T+{hours_from_start}h (Step {step + 1})"
+        
+        metadata = {
+            'variable_name': var_name,
+            'display_name': display_name,
+            'units': units,
+            'lats': lats,
+            'lons': lons,
+            'pressure_level': pressure_level if pressure_level else None,
+            'timestamp_str': step_time_str,
+        }
+        
+        # Generate plot based on type
+        if plot_type == 'interactive':
+            # Generate interactive plot
+            plot_result = interactive_plotter.create_india_map(
+                data_to_plot,
+                metadata,
+                color_theme=color_theme,
+                save_plot=True,
+                custom_title=f"Aurora Prediction: {display_name} ({step_time_str})"
+            )
+            
+            if plot_result and plot_result.get('html_path'):
+                plot_filename = Path(plot_result['html_path']).name
+                return render_template(
+                    'interactive_plot.html',
+                    plot_filename=plot_filename,
+                    var_name=var_name,
+                    pressure_level=pressure_level,
+                    metadata=metadata
+                )
+        else:
+            # Generate static plot
+            plot_path = plotter.create_india_map(
+                data_to_plot,
+                metadata,
+                color_theme=color_theme,
+                save_plot=True,
+                custom_title=f"Aurora Prediction: {display_name} ({step_time_str})"
+            )
+            
+            if plot_path:
+                plot_filename = Path(plot_path).name
+                return render_template(
+                    'plot.html',
+                    plot_filename=plot_filename,
+                    var_name=var_name,
+                    pressure_level=pressure_level,
+                    metadata=metadata
+                )
+        
+        flash('Error generating plot', 'error')
+        return redirect(url_for('index'))
+        
+    except Exception as e:
+        flash(f'Error generating plot: {str(e)}', 'error')
+        print(f"❌ Plot generation error: {traceback.format_exc()}")
         return redirect(url_for('index'))
 
-    # Extract lat/lon
-    lats = ds['lat'].values if 'lat' in ds else ds['latitude'].values
-    lons = ds['lon'].values if 'lon' in ds else ds['longitude'].values
-
-    # Prepare metadata for plot
-    from constants import NETCDF_VARIABLES
-    var_info = NETCDF_VARIABLES.get(var_name, {})
-    display_name = var_info.get('name', var_name)
-    units = ds[var_name].attrs.get('units', var_info.get('units', ''))
-    # Use user-selected color theme, fallback to variable default, then viridis
-    if 'color_theme' not in locals():
-        color_theme = var_info.get('cmap', 'viridis')
-
-    metadata = {
-        'variable_name': var_name,
-        'display_name': display_name,
-        'units': units,
-        'lats': lats,
-        'lons': lons,
-        'pressure_level': None,
-        'timestamp_str': str(steps[step]) if len(steps) > step else '',
-    }
 
-    # Generate plot
-    plot_path = plotter.create_india_map(
-        data_to_plot,
-        metadata,
-        color_theme=color_theme,
-        save_plot=True,
-        custom_title=f"Aurora Prediction: {display_name} (step {step})"
-    )
+@app.route('/aurora_plot', methods=['POST'])
+def aurora_plot():
+    """Generate plot from Aurora prediction variables"""
+    if not AURORA_AVAILABLE:
+        flash('Aurora model is not available.', 'error')
+        return redirect(url_for('index'))
     
-    if plot_path:
-        plot_filename = Path(plot_path).name
-
-        # Provide download link for NetCDF
-        download_url = url_for('download_prediction_netcdf', filename=filename)
+    try:
+        run_dir = request.form.get('run_dir')
+        step = request.form.get('step')
+        variable = request.form.get('variable')
+        pressure_level = request.form.get('pressure_level')
+        color_theme = request.form.get('color_theme', 'viridis')
+        plot_type = request.form.get('plot_type', 'static')
+        
+        if not all([run_dir, step, variable]):
+            flash('Missing required parameters', 'error')
+            return redirect(url_for('aurora_variables', run_dir=run_dir))
+        
+        # Find the filename for this step
+        run_path = Path('predictions') / run_dir
+        step_files = list(run_path.glob(f'*_step{int(step):02d}_*.nc'))
+        
+        if not step_files:
+            flash(f'No file found for step {step}', 'error')
+            return redirect(url_for('aurora_variables', run_dir=run_dir))
+        
+        file_path = step_files[0]  # Take the first match
+        filename = file_path.name
+        
+        if not file_path.exists():
+            flash('Prediction file not found', 'error')
+            return redirect(url_for('aurora_variables', run_dir=run_dir))
+        
+        # Use Aurora prediction processor
+        processor = AuroraPredictionProcessor(str(file_path))
+        
+        try:
+            file_info = analyze_netcdf_file(str(file_path))
+            
+            var_info = file_info['detected_variables'].get(variable)
+            if not var_info:
+                flash('Variable not found in file', 'error')
+                return redirect(url_for('aurora_variables', run_dir=run_dir))
+            
+            # Extract data using Aurora processor with step=0 (single timestep files)
+            if var_info.get('type') == 'atmospheric' and pressure_level:
+                pressure_level = float(pressure_level)
+                data, metadata = processor.extract_variable_data(variable, pressure_level=pressure_level, step=0)
+            else:
+                data, metadata = processor.extract_variable_data(variable, step=0)
+            
 
-        return render_template(
-            'aurora_prediction_plot.html',
-            plot_filename=plot_filename,
-            var_name=var_name,
-            step=step,
-            variables=variables,
-            steps=range(len(steps)),
-            filename=filename,
-            download_url=download_url,
-            color_themes=COLOR_THEMES,
-            current_color_theme=color_theme
-        )
-    else:
-        flash('Error generating prediction plot', 'error')
+            
+            # Prepare plot_info for templates
+            plot_info = {
+                'variable': metadata.get('display_name', 'Unknown Variable'),
+                'units': metadata.get('units', ''),
+                'shape': str(data.shape),
+                'pressure_level': metadata.get('pressure_level'),
+                'color_theme': COLOR_THEMES.get(color_theme, color_theme),
+                'generated_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                'data_range': {
+                    'min': float(f"{data.min():.3f}") if hasattr(data, 'min') and data.min() is not None else 0,
+                    'max': float(f"{data.max():.3f}") if hasattr(data, 'max') and data.max() is not None else 0,
+                    'mean': float(f"{data.mean():.3f}") if hasattr(data, 'mean') and data.mean() is not None else 0
+                },
+                'timestamp': metadata.get('timestamp_str', 'Unknown Time'),
+                'source': metadata.get('source', 'Aurora Prediction')
+            }
+            
+            if plot_type == 'interactive':
+                plot_result = interactive_plotter.create_india_map(
+                    data, metadata, color_theme=color_theme, save_plot=True
+                )
+                if plot_result and plot_result.get('html_path'):
+                    plot_filename = Path(plot_result['html_path']).name
+                    return render_template('view_interactive.html', 
+                                         plot_filename=plot_filename,
+                                         metadata=metadata,
+                                         plot_info=plot_info)
+            else:
+                plot_path = plotter.create_india_map(
+                    data, metadata, color_theme=color_theme, save_plot=True
+                )
+                if plot_path:
+                    plot_filename = Path(plot_path).name
+                    return render_template('plot.html', 
+                                         plot_filename=plot_filename,
+                                         metadata=metadata,
+                                         plot_info=plot_info,
+                                         filename=filename)
+            
+            flash('Error generating plot', 'error')
+            return redirect(url_for('aurora_variables', run_dir=run_dir))
+            
+        finally:
+            processor.close()
+        
+    except Exception as e:
+        flash(f'Error generating Aurora plot: {str(e)}', 'error')
         return redirect(url_for('index'))
 
-
-@app.route('/download_prediction_netcdf/<filename>')
+@app.route('/download_prediction_netcdf/<path:filename>')
 def download_prediction_netcdf(filename):
     """Download the Aurora prediction NetCDF file"""
-    file_path = Path('predictions') / filename
+    # Handle both old and new filename formats
+    if filename.endswith('.nc'):
+        file_path = Path('predictions') / filename
+    else:
+        # Try to find the prediction file in the run directory
+        run_dir = Path('predictions') / filename
+        if run_dir.is_dir():
+            nc_files = list(run_dir.glob("*.nc"))
+            if nc_files:
+                file_path = nc_files[0]
+                filename = file_path.name
+            else:
+                flash('Prediction file not found', 'error')
+                return redirect(url_for('index'))
+        else:
+            file_path = Path('predictions') / filename
+    
     if not file_path.exists():
         flash('Prediction file not found', 'error')
         return redirect(url_for('index'))
@@ -1033,6 +1269,141 @@ def too_large(e):
     return redirect(url_for('index'))
 
 
+@app.route('/api/aurora_step_variables/<run_dir>/<int:step>')
+def get_aurora_step_variables(run_dir, step):
+    """Get variables and pressure levels for a specific Aurora prediction step"""
+    if not AURORA_AVAILABLE:
+        return jsonify({'error': 'Aurora model not available'}), 400
+    
+    try:
+        # Find the file for this step
+        run_path = Path('predictions') / run_dir
+        step_files = list(run_path.glob(f'*_step{step:02d}_*.nc'))
+        
+        if not step_files:
+            return jsonify({'error': f'No file found for step {step}'}), 404
+        
+        file_path = step_files[0]
+        
+        # Load and analyze the file using the same method as regular CAMS files
+        file_info = analyze_netcdf_file(str(file_path))
+        
+        if not file_info['success']:
+            return jsonify({'error': f'Failed to analyze file: {file_info.get("error", "Unknown error")}'}), 500
+        
+        surface_vars = []
+        atmos_vars = []
+        pressure_levels = []
+        
+        # Extract variables from detected_variables
+        for var_name, var_info in file_info['detected_variables'].items():
+            if var_info['type'] == 'surface':
+                surface_vars.append(var_name)
+            elif var_info['type'] == 'atmospheric':
+                atmos_vars.append(var_name)
+        
+        # Get pressure levels from the first atmospheric variable
+        ds = xr.open_dataset(file_path)
+        if 'pressure_level' in ds.coords:
+            pressure_levels = ds.pressure_level.values.tolist()
+        ds.close()
+        
+        return jsonify({
+            'surface_vars': surface_vars,
+            'atmos_vars': atmos_vars,
+            'pressure_levels': pressure_levels,
+            'filename': file_path.name
+        })
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/aurora_variables/<run_dir>')
+def aurora_variables(run_dir):
+    """Show Aurora prediction variables selection page similar to variables.html"""
+    if not AURORA_AVAILABLE:
+        flash('Aurora model is not available.', 'error')
+        return redirect(url_for('index'))
+    
+    try:
+        # Get prediction files from run directory
+        run_path = Path('predictions') / run_dir
+        if not run_path.exists():
+            flash(f'Prediction run not found: {run_path}', 'error')
+            return redirect(url_for('index'))
+        
+        # Find all prediction files in the directory
+        pred_files = sorted(run_path.glob('*.nc'))
+        if not pred_files:
+            flash('No prediction files found in run', 'error')
+            return redirect(url_for('index'))
+        
+        # Get step numbers and filenames
+        steps_data = []
+        for file_path in pred_files:
+            filename = file_path.name
+            # Extract step number from filename
+            if 'step' in filename:
+                try:
+                    step_part = filename.split('step')[1].split('_')[0]
+                    step_num = int(step_part)
+                    steps_data.append({
+                        'step': step_num,
+                        'filename': filename,
+                        'forecast_hours': step_num * 12
+                    })
+                except:
+                    pass
+        
+        steps_data.sort(key=lambda x: x['step'])
+        
+        # Get variables from the first file
+        first_file = pred_files[0]
+        ds = xr.open_dataset(first_file)
+        
+        # Separate surface and atmospheric variables
+        surface_vars = []
+        atmos_vars = []
+        pressure_levels = []
+        
+        for var_name in ds.data_vars:
+            if len(ds[var_name].dims) == 2:  # lat, lon
+                surface_vars.append(var_name)
+            elif len(ds[var_name].dims) == 3:  # pressure_level, lat, lon
+                atmos_vars.append(var_name)
+        
+        if 'pressure_level' in ds.coords:
+            pressure_levels = ds.pressure_level.values.tolist()
+        
+        ds.close()
+        
+        return render_template('aurora_variables.html',
+                             run_dir=run_dir,
+                             steps_data=steps_data,
+                             surface_vars=surface_vars,
+                             atmos_vars=atmos_vars,
+                             pressure_levels=pressure_levels,
+                             color_themes=COLOR_THEMES)
+                             
+    except Exception as e:
+        flash(f'Error loading Aurora variables: {str(e)}', 'error')
+        return redirect(url_for('index'))
+
+@app.route('/prediction_runs')
+def prediction_runs():
+    """Browse available Aurora prediction runs"""
+    if not AURORA_AVAILABLE:
+        flash('Aurora model is not available.', 'error')
+        return redirect(url_for('index'))
+    
+    try:
+        runs = AuroraPipeline.list_prediction_runs()
+        return render_template('prediction_runs.html', runs=runs)
+    except Exception as e:
+        flash(f'Error listing prediction runs: {str(e)}', 'error')
+        return redirect(url_for('index'))
+
+
 @app.errorhandler(404)
 def not_found(e):
     """Handle 404 errors"""
@@ -1059,4 +1430,4 @@ if __name__ == '__main__':
     print("🔧 CDS API Ready:", downloader.is_client_ready())
     
     # Run the Flask app
-    app.run(debug=True, host='0.0.0.0', port=port)
+    app.run(debug=False, host='0.0.0.0', port=port)

aurora_pipeline.py

@@ -4,33 +4,20 @@ import subprocess
 import os
 
 def get_freest_cuda_device_id():
-    """Get the freest CUDA device ID if available, otherwise return None for CPU mode"""
     try:
-        # Check if nvidia-smi exists first
         result = subprocess.run(
             ['nvidia-smi', '--query-gpu=memory.free', '--format=csv,nounits,noheader'],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding='utf-8'
+            stdout=subprocess.PIPE, encoding='utf-8'
         )
-        if result.returncode == 0:
-            memory_free = [int(x) for x in result.stdout.strip().split('\n')]
-            device_id = memory_free.index(max(memory_free))
-            print(f"🎮 GPU available - using device {device_id}")
-            return str(device_id)
-        else:
-            print("⚠️  nvidia-smi returned error, using CPU mode")
-            return None
-    except (FileNotFoundError, subprocess.SubprocessError, Exception) as e:
-        print(f"💻 No GPU detected, using CPU mode: {e}")
-        return None
-
-# Set CUDA_VISIBLE_DEVICES only if GPU is available
-gpu_device = get_freest_cuda_device_id()
-if gpu_device is not None:
-    os.environ["CUDA_VISIBLE_DEVICES"] = gpu_device
-else:
-    # Force CPU mode
-    os.environ["CUDA_VISIBLE_DEVICES"] = ""
-    print("🔧 Configured for CPU-only execution")
+        memory_free = [int(x) for x in result.stdout.strip().split('\n')]
+        device_id = memory_free.index(max(memory_free))
+        return str(device_id)
+    except Exception as e:
+        print(f"Could not query nvidia-smi, defaulting to 0. Error: {e}")
+        return "0"
+
+# Set CUDA_VISIBLE_DEVICES before importing torch
+os.environ["CUDA_VISIBLE_DEVICES"] = get_freest_cuda_device_id()
 
 
 import torch
@@ -57,35 +44,17 @@ class AuroraPipeline:
              device=None,
              cpu_only=False):
 
-        # Device selection with CPU fallback
-        if cpu_only or device == "cpu":
-            self.device = "cpu"
-            print("💻 Aurora configured for CPU-only execution")
-        elif device is None:
-            # Auto-detect: prefer CPU for local testing, GPU for production
-            if torch.cuda.is_available() and not cpu_only:
-                self.device = "cuda:0"
-                print(f"🎮 Aurora using GPU: {self.device}")
-            else:
-                self.device = "cpu"
-                print("💻 Aurora using CPU (GPU not available or CPU forced)")
-        else:
-            self.device = device
-            print(f"🔧 Aurora using specified device: {self.device}")
+        if device is None or device == "cuda":
+            # CUDA_VISIBLE_DEVICES is set, so use 'cuda:0'
+            device = "cuda:0" if torch.cuda.is_available() and not cpu_only else "cpu"
 
         self.extracted_dir = Path(extracted_dir)
         self.static_path = Path(static_path)
         self.model_ckpt = model_ckpt
         self.model_repo = model_repo
-        self.cpu_only = cpu_only or (self.device == "cpu")
-        
-        # Load static variables with error handling
-        try:
-            self.static_vars = self._load_static_vars()
-        except Exception as e:
-            print(f"⚠️  Warning: Could not load static variables: {e}")
-            self.static_vars = {}
-        
+        self.device = device
+        self.cpu_only = cpu_only or (device == "cpu")
+        self.static_vars = self._load_static_vars()
         self.model = None
 
     def _load_static_vars(self):
@@ -100,8 +69,15 @@ class AuroraPipeline:
             static_vars = pickle.load(f)
         return static_vars
 
-    def create_batch(self, date_str, Batch, Metadata):
-        """Create a batch for Aurora model from CAMS data"""
+    def create_batch(self, date_str, Batch, Metadata, time_index=1):
+        """Create a batch for Aurora model from CAMS data
+        
+        Args:
+            date_str: Date string (YYYY-MM-DD)
+            Batch: Aurora Batch class
+            Metadata: Aurora Metadata class
+            time_index: 0 for T-1 (first time), 1 for T (second time)
+        """
         surface_path = self.extracted_dir / f"{date_str}-cams-surface.nc"
         atmos_path = self.extracted_dir / f"{date_str}-cams-atmospheric.nc"
         if not surface_path.exists() or not atmos_path.exists():
@@ -110,9 +86,15 @@ class AuroraPipeline:
         surf_vars_ds = xr.open_dataset(surface_path, engine="netcdf4", decode_timedelta=True)
         atmos_vars_ds = xr.open_dataset(atmos_path, engine="netcdf4", decode_timedelta=True)
 
-        # Select zero-hour forecast
+        # Select zero-hour forecast but keep both time steps
         surf_vars_ds = surf_vars_ds.isel(forecast_period=0)
         atmos_vars_ds = atmos_vars_ds.isel(forecast_period=0)
+        
+        # Don't select time index - Aurora needs both T-1 and T as input
+        print(f"🕐 Using both time steps (T-1 and T) as input for Aurora")
+
+        # Get the time for metadata (use the specified time_index for metadata only)
+        selected_time = surf_vars_ds.forecast_reference_time.values[time_index].astype("datetime64[s]").tolist()
 
         batch = Batch(
             surf_vars={
@@ -145,19 +127,17 @@ class AuroraPipeline:
             metadata=Metadata(
                 lat=torch.from_numpy(atmos_vars_ds.latitude.values),
                 lon=torch.from_numpy(atmos_vars_ds.longitude.values),
-                time=(atmos_vars_ds.valid_time.values.astype("datetime64[s]").tolist()[-1],),
+                time=(selected_time,),
                 atmos_levels=tuple(int(level) for level in atmos_vars_ds.pressure_level.values),
             ),
         )
         return batch
     def load_model(self, AuroraAirPollution):
-        """Load Aurora model with CPU/GPU optimization"""
+        """Load Aurora model and move to device"""
         import gc
         
-        print(f"🔄 Loading Aurora model on {self.device}")
-        
-        # Memory check for GPU
-        if self.device != "cpu" and torch.cuda.is_available():
+        # Check memory BEFORE loading
+        if torch.cuda.is_available():
             print(f"📊 GPU Memory BEFORE loading model:")
             print(f"   Allocated: {torch.cuda.memory_allocated(0) / 1024**3:.2f} GB")
             print(f"   Reserved:  {torch.cuda.memory_reserved(0) / 1024**3:.2f} GB")
@@ -166,115 +146,209 @@ class AuroraPipeline:
         # Clear cache
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-        gc.collect()
+            gc.collect()
         
-        # Initialize model with CPU-friendly settings
-        if self.cpu_only:
-            print("💻 Initializing model for CPU execution...")
-            # Set CPU-friendly torch settings
-            torch.set_num_threads(2)  # Limit CPU threads for local testing
-            model = AuroraAirPollution()
-        else:
-            model = AuroraAirPollution()
+        model = AuroraAirPollution()
         
-        # Load checkpoint with device mapping
-        try:
-            if self.cpu_only:
-                print("📁 Loading checkpoint for CPU execution...")
-                # For CPU mode, we may need to handle device mapping differently
-                model.load_checkpoint(self.model_repo, self.model_ckpt)
-            else:
-                print("📁 Loading checkpoint for GPU execution...")
-                model.load_checkpoint(self.model_repo, self.model_ckpt)
-        except Exception as e:
-            print(f"⚠️  Checkpoint loading failed: {e}")
-            print("🔄 Trying alternative loading method...")
-            try:
-                # Alternative: try loading without any special parameters
-                model.load_checkpoint(self.model_repo, self.model_ckpt)
-                print("✅ Checkpoint loaded successfully with fallback method")
-            except Exception as e2:
-                print(f"❌ All loading methods failed: {e2}")
-                # Set device to CPU as last resort
-                self.device = "cpu"
-                self.cpu_only = True
-                raise RuntimeError(f"Failed to load Aurora model: {e2}")
+        # Check AFTER initialization but BEFORE loading checkpoint
+        if torch.cuda.is_available():
+            print(f"� GPU Memory AFTER model init:")
+            print(f"   Allocated: {torch.cuda.memory_allocated(0) / 1024**3:.2f} GB")
         
-        model.eval()
+        model.load_checkpoint(self.model_repo, self.model_ckpt)
         
-        # Move to device
+        # Check AFTER loading checkpoint
+        if torch.cuda.is_available():
+            print(f"📊 GPU Memory AFTER checkpoint load:")
+            print(f"   Allocated: {torch.cuda.memory_allocated(0) / 1024**3:.2f} GB")
+        
+        model.eval()
         model = model.to(self.device)
         
-        # Memory check after loading
-        if self.device != "cpu" and torch.cuda.is_available():
-            print(f"📊 GPU Memory AFTER model load:")
+        # Check AFTER moving to device
+        if torch.cuda.is_available():
+            print(f"📊 GPU Memory AFTER moving to device:")
             print(f"   Allocated: {torch.cuda.memory_allocated(0) / 1024**3:.2f} GB")
             print(f"   Reserved:  {torch.cuda.memory_reserved(0) / 1024**3:.2f} GB")
         
         self.model = model
-        print(f"✅ Aurora model loaded on {self.device}")
-        
-        if self.cpu_only:
-            print("⚠️  WARNING: CPU mode will be slower than GPU. Consider using fewer steps for faster inference.")
-        
+        print(f"✅ Model loaded on {self.device}")
         return model
 
     def predict(self, batch, rollout, steps=4):
-        """Run model prediction with CPU/GPU optimization"""
         if self.model is None:
             raise RuntimeError("Model not loaded. Call load_model() first.")
         
-        # Limit steps for CPU to avoid memory issues
-        if self.cpu_only and steps > 2:
-            print(f"⚠️  CPU mode: reducing steps from {steps} to 2 for memory efficiency")
-            steps = 2
-        
-        print(f"🔄 Running {steps} prediction steps on {self.device}...")
-        
         # Move batch to device
         batch = batch.to(self.device)
         
-        # CPU-friendly inference settings
-        if self.cpu_only:
-            torch.set_grad_enabled(False)  # Disable gradients for inference
-        
         with torch.inference_mode():
-            predictions = []
-            for step in range(steps):
-                print(f"   Step {step + 1}/{steps}...")
-                if step == 0:
-                    # First prediction from initial batch
-                    pred_generator = rollout(self.model, batch, steps=1)
-                    pred = next(pred_generator)
-                else:
-                    # Subsequent predictions from previous output
-                    pred_generator = rollout(self.model, pred, steps=1)
-                    pred = next(pred_generator)
-                
-                # Move to CPU immediately to save memory
-                predictions.append(pred.to("cpu"))
-                
-                # Clear GPU cache after each step if using GPU
-                if not self.cpu_only and torch.cuda.is_available():
-                    torch.cuda.empty_cache()
+            predictions = [pred.to("cpu") for pred in rollout(self.model, batch, steps=steps)]
         
-        print(f"✅ Completed {len(predictions)} prediction steps")
         return predictions
 
-    def save_predictions_to_netcdf(self, predictions, output_path):
-        """Save all prediction steps to a single NetCDF file compatible with visualization pipeline"""
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        print(f"💾 Saving {len(predictions)} prediction steps to {output_path}")
+    def save_predictions_to_netcdf(self, predictions, output_dir, date_str):
+        """Save each prediction step as separate NetCDF files in CAMS format"""
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
 
-        try:
-            # Try the new single-file method
-            return self._save_predictions_single_file(predictions, output_path)
-        except Exception as e:
-            print(f"⚠️  Single file method failed: {e}")
-            print(f"🔄 Falling back to original method...")
-            return self._save_predictions_original_method(predictions, output_path)
+        print(f"💾 Saving {len(predictions)} prediction steps as separate files")
+        
+        generation_date = datetime.now().strftime("%Y%m%d")
+        saved_files = []
+
+        for step_idx, pred in enumerate(predictions):
+            step_num = step_idx + 1
+            
+            # Create filename: predictiondate_step_generationdate.nc
+            filename = f"{date_str}_step{step_num:02d}_{generation_date}.nc"
+            file_path = output_dir / filename
+            
+            # Extract coordinates from first prediction
+            metadata = pred.metadata
+            lats = metadata.lat.cpu().numpy() if hasattr(metadata.lat, 'cpu') else metadata.lat.numpy()
+            lons = metadata.lon.cpu().numpy() if hasattr(metadata.lon, 'cpu') else metadata.lon.numpy()
+            
+            # Create CAMS-compatible coordinates and dimensions
+            # CAMS format uses: forecast_period, forecast_reference_time, latitude, longitude
+            coords = {
+                'forecast_period': ('forecast_period', [0]),  # Single forecast period
+                'forecast_reference_time': ('forecast_reference_time', [0, 1]),  # Two reference times (T-1, T)
+                'latitude': ('latitude', lats),
+                'longitude': ('longitude', lons)
+            }
+            
+            # Add valid_time variable (CAMS format)
+            data_vars = {
+                'valid_time': (['forecast_reference_time', 'forecast_period'], 
+                              np.array([[step_num * 12], [step_num * 12]]))  # Same forecast hours for both ref times
+            }
+            
+            # Add surface variables in CAMS format: (forecast_period, forecast_reference_time, latitude, longitude)
+            # Map Aurora variable names to CAMS variable names
+            aurora_to_cams_surface = {
+                '2t': 't2m',      # 2 metre temperature
+                '10u': 'u10',     # 10 metre U wind component  
+                '10v': 'v10',     # 10 metre V wind component
+                'msl': 'msl',     # Mean sea level pressure (same)
+                'pm1': 'pm1',     # PM1 (same)
+                'pm2p5': 'pm2p5', # PM2.5 (same)
+                'pm10': 'pm10',   # PM10 (same)
+                'tcco': 'tcco',   # Total column CO (same)
+                'tc_no': 'tc_no', # Total column NO (same)
+                'tcno2': 'tcno2', # Total column NO2 (same)
+                'gtco3': 'gtco3', # Total column O3 (same)
+                'tcso2': 'tcso2'  # Total column SO2 (same)
+            }
+            
+            for aurora_var, var_tensor in pred.surf_vars.items():
+                cams_var = aurora_to_cams_surface.get(aurora_var, aurora_var)  # Use CAMS name or fallback to Aurora name
+                
+                var_data = var_tensor.cpu().numpy() if hasattr(var_tensor, 'cpu') else var_tensor.numpy()
+                var_data = np.squeeze(var_data)
+                
+                # Ensure 2D for surface variables
+                if var_data.ndim > 2:
+                    while var_data.ndim > 2:
+                        var_data = var_data[0]
+                elif var_data.ndim < 2:
+                    raise ValueError(f"Surface variable {aurora_var} has insufficient dimensions: {var_data.shape}")
+                
+                # Expand to CAMS format: (1, 2, lat, lon) - same data for both forecast reference times
+                cams_data = np.broadcast_to(var_data[np.newaxis, np.newaxis, :, :], (1, 2, var_data.shape[0], var_data.shape[1]))
+                data_vars[cams_var] = (['forecast_period', 'forecast_reference_time', 'latitude', 'longitude'], cams_data)
+            
+            # Add atmospheric variables if present
+            # CAMS format: (forecast_period, forecast_reference_time, pressure_level, latitude, longitude)
+            # Map Aurora atmospheric variable names to CAMS names
+            aurora_to_cams_atmos = {
+                't': 't',     # Temperature (same)
+                'u': 'u',     # U wind component (same)
+                'v': 'v',     # V wind component (same)
+                'q': 'q',     # Specific humidity (same)
+                'z': 'z',     # Geopotential (same)
+                'co': 'co',   # Carbon monoxide (same)
+                'no': 'no',   # Nitrogen monoxide (same)
+                'no2': 'no2', # Nitrogen dioxide (same)
+                'go3': 'go3', # Ozone (same)
+                'so2': 'so2'  # Sulphur dioxide (same)
+            }
+            if hasattr(pred, 'atmos_vars') and pred.atmos_vars:
+                atmos_levels = list(metadata.atmos_levels) if hasattr(metadata, 'atmos_levels') else None
+                if atmos_levels:
+                    coords['pressure_level'] = ('pressure_level', atmos_levels)
+                    
+                    for aurora_var, var_tensor in pred.atmos_vars.items():
+                        cams_var = aurora_to_cams_atmos.get(aurora_var, aurora_var)  # Use CAMS name or fallback
+                        
+                        var_data = var_tensor.cpu().numpy() if hasattr(var_tensor, 'cpu') else var_tensor.numpy()
+                        var_data = np.squeeze(var_data)
+                        
+                        # Ensure 3D for atmospheric variables (pressure, lat, lon)
+                        if var_data.ndim > 3:
+                            while var_data.ndim > 3:
+                                var_data = var_data[0]
+                        elif var_data.ndim < 3:
+                            raise ValueError(f"Atmospheric variable {aurora_var} has insufficient dimensions: {var_data.shape}")
+                        
+                        # Expand to CAMS format: (1, 2, pressure, lat, lon) - same data for both forecast reference times
+                        cams_data = np.broadcast_to(var_data[np.newaxis, np.newaxis, :, :, :], 
+                                                  (1, 2, var_data.shape[0], var_data.shape[1], var_data.shape[2]))
+                        data_vars[cams_var] = (['forecast_period', 'forecast_reference_time', 'pressure_level', 'latitude', 'longitude'], cams_data)
+            
+            # Create dataset for this step
+            ds = xr.Dataset(data_vars, coords=coords)
+            
+            # Add attributes
+            ds.attrs.update({
+                'title': f'Aurora Air Pollution Prediction - Step {step_num}',
+                'source': 'Aurora model by Microsoft Research',
+                'prediction_date': date_str,
+                'step': step_num,
+                'forecast_hours': step_num * 12,
+                'generation_date': generation_date,
+                'creation_time': datetime.now().isoformat(),
+                'spatial_resolution': f"{abs(lons[1] - lons[0]):.3f} degrees"
+            })
+            
+            # Add variable attributes (using CAMS variable names)
+            var_attrs = {
+                't2m': {'long_name': '2 metre temperature', 'units': 'K'},
+                'u10': {'long_name': '10 metre U wind component', 'units': 'm s-1'},
+                'v10': {'long_name': '10 metre V wind component', 'units': 'm s-1'},
+                'msl': {'long_name': 'Mean sea level pressure', 'units': 'Pa'},
+                'pm1': {'long_name': 'Particulate matter d < 1 um', 'units': 'kg m-3'},
+                'pm2p5': {'long_name': 'Particulate matter d < 2.5 um', 'units': 'kg m-3'},
+                'pm10': {'long_name': 'Particulate matter d < 10 um', 'units': 'kg m-3'},
+                'tcco': {'long_name': 'Total column carbon monoxide', 'units': 'kg m-2'},
+                'tc_no': {'long_name': 'Total column nitrogen monoxide', 'units': 'kg m-2'},
+                'tcno2': {'long_name': 'Total column nitrogen dioxide', 'units': 'kg m-2'},
+                'gtco3': {'long_name': 'Total column ozone', 'units': 'kg m-2'},
+                'tcso2': {'long_name': 'Total column sulphur dioxide', 'units': 'kg m-2'},
+                # Atmospheric variables
+                't': {'long_name': 'Temperature', 'units': 'K'},
+                'u': {'long_name': 'U component of wind', 'units': 'm s-1'},
+                'v': {'long_name': 'V component of wind', 'units': 'm s-1'},
+                'q': {'long_name': 'Specific humidity', 'units': 'kg kg-1'},
+                'z': {'long_name': 'Geopotential', 'units': 'm2 s-2'},
+                'co': {'long_name': 'Carbon monoxide', 'units': 'kg kg-1'},
+                'no': {'long_name': 'Nitrogen monoxide', 'units': 'kg kg-1'},
+                'no2': {'long_name': 'Nitrogen dioxide', 'units': 'kg kg-1'},
+                'go3': {'long_name': 'Ozone', 'units': 'kg kg-1'},
+                'so2': {'long_name': 'Sulphur dioxide', 'units': 'kg kg-1'}
+            }
+            
+            for var_name, attrs in var_attrs.items():
+                if var_name in ds.data_vars:
+                    ds[var_name].attrs.update(attrs)
+            
+            # Save to NetCDF
+            ds.to_netcdf(file_path, format='NETCDF4')
+            saved_files.append(str(file_path))
+            print(f"   ✅ Step {step_num}: {filename}")
+        
+        print(f"✅ Saved {len(saved_files)} prediction files")
+        return saved_files
 
     def _save_predictions_single_file(self, predictions, output_path):
         """Save all prediction steps to a single NetCDF file (new method)"""
@@ -357,7 +431,7 @@ class AuroraPipeline:
 
                     # Stack along step dimension: (steps, levels, lat, lon)
                     arr = np.stack(var_data_list, axis=0)
-                    data_vars[f"{var}_atmos"] = (['step', 'pressure_level', 'lat', 'lon'], arr)
+                    data_vars[var] = (['step', 'pressure_level', 'lat', 'lon'], arr)
 
         # Create dataset
         ds = xr.Dataset(data_vars, coords=coords)
@@ -466,6 +540,91 @@ class AuroraPipeline:
             self.save_predictions_to_netcdf(predictions, output_path)
         return predictions
 
+    def run_aurora_prediction_pipeline(self, date_str, Batch, Metadata, AuroraAirPollution, rollout, steps=4, base_predictions_dir="predictions"):
+        """Enhanced Aurora prediction pipeline with organized storage"""
+        print(f"🚀 Starting Aurora prediction pipeline for {date_str}")
+        print(f"📊 Forward prediction steps: {steps} (covering {steps * 12} hours)")
+        
+        # Create organized directory structure
+        run_timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        run_dir = Path(base_predictions_dir) / f"{date_str}_run_{run_timestamp}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Load model once
+        print("🧠 Loading Aurora model...")
+        self.load_model(AuroraAirPollution)
+        
+        # Use the latest timestamp (index 1) for prediction
+        print("📥 Creating input batch for T (second time)...")
+        batch = self.create_batch(date_str, Batch, Metadata, time_index=1)
+        
+        # Run predictions
+        print(f"⚡ Running {steps} prediction steps...")
+        predictions = self.predict(batch, rollout, steps=steps)
+        
+        # Save predictions as separate files
+        saved_files = self.save_predictions_to_netcdf(predictions, run_dir, date_str)
+        
+        # Save metadata about the run
+        run_metadata = {
+            "date": date_str,
+            "run_timestamp": run_timestamp,
+            "steps": steps,
+            "time_coverage_hours": steps * 12,
+            "input_times": ["T-1", "T"],
+            "prediction_files": saved_files,
+            "run_directory": str(run_dir)
+        }
+        
+        metadata_file = run_dir / "run_metadata.json"
+        with open(metadata_file, 'w') as f:
+            import json
+            json.dump(run_metadata, f, indent=2)
+        
+        print(f"✅ Aurora prediction pipeline completed")
+        print(f"📁 Results saved to: {run_dir}")
+        print(f"📊 Coverage: {steps * 12} hours forward from {date_str}")
+        
+        return run_metadata
+
+    @staticmethod
+    def list_prediction_runs(base_predictions_dir="predictions"):
+        """List all available prediction runs with metadata"""
+        runs = []
+        predictions_path = Path(base_predictions_dir)
+        
+        if not predictions_path.exists():
+            return runs
+        
+        for run_dir in predictions_path.iterdir():
+            if run_dir.is_dir() and "_run_" in run_dir.name:
+                metadata_file = run_dir / "run_metadata.json"
+                
+                if metadata_file.exists():
+                    try:
+                        import json
+                        with open(metadata_file, 'r') as f:
+                            metadata = json.load(f)
+                        
+                        # Check if any prediction files exist (new format with separate step files)
+                        nc_files = list(run_dir.glob("*.nc"))
+                        has_predictions = len(nc_files) > 0
+                        
+                        # Add additional info
+                        metadata['available'] = has_predictions
+                        metadata['run_dir'] = str(run_dir)
+                        metadata['relative_path'] = run_dir.name
+                        metadata['prediction_files'] = [f.name for f in nc_files]
+                        metadata['num_files'] = len(nc_files)
+                        
+                        runs.append(metadata)
+                    except Exception as e:
+                        print(f"⚠️  Could not read metadata for {run_dir}: {e}")
+        
+        # Sort by run timestamp (newest first)
+        runs.sort(key=lambda x: x.get('run_timestamp', ''), reverse=True)
+        return runs
+
 # Example usage (not run on import)
 if __name__ == "__main__":
     pass

data_processor.py

@@ -12,6 +12,14 @@ import xarray as xr
 from pathlib import Path
 from datetime import datetime
 
+# India geographical bounds for coordinate trimming
+INDIA_BOUNDS = {
+    'lat_min': 6.0,    # Southern tip (including southern islands)
+    'lat_max': 38.0,   # Northern border (including Kashmir)
+    'lon_min': 68.0,   # Western border
+    'lon_max': 98.0    # Eastern border (including Andaman & Nicobar)
+}
+
 # Imports from our Modules
 from constants import NETCDF_VARIABLES, AIR_POLLUTION_VARIABLES, PRESSURE_LEVELS
 warnings.filterwarnings('ignore')
@@ -124,6 +132,12 @@ class NetCDFProcessor:
         
         for var_name in dataset.data_vars:
             var_name_lower = var_name.lower()
+            var_dims = list(dataset[var_name].dims)
+            
+            # Determine actual variable type based on dimensions (not just dictionary)
+            actual_var_type = 'surface'
+            if any(dim in ['level', 'plev', 'pressure_level', 'height'] for dim in [d.lower() for d in var_dims]):
+                actual_var_type = 'atmospheric'
             
             # Check exact matches first in NETCDF_VARIABLES
             if var_name in NETCDF_VARIABLES:
@@ -131,14 +145,18 @@ class NetCDFProcessor:
                 detected[var_name]['original_name'] = var_name
                 detected[var_name]['dataset_type'] = dataset_type
                 detected[var_name]['shape'] = dataset[var_name].shape
-                detected[var_name]['dims'] = list(dataset[var_name].dims)
+                detected[var_name]['dims'] = var_dims
+                # Override type based on actual dimensions
+                detected[var_name]['type'] = actual_var_type
                 
             elif var_name_lower in NETCDF_VARIABLES:
                 detected[var_name] = NETCDF_VARIABLES[var_name_lower].copy()
                 detected[var_name]['original_name'] = var_name
                 detected[var_name]['dataset_type'] = dataset_type
                 detected[var_name]['shape'] = dataset[var_name].shape
-                detected[var_name]['dims'] = list(dataset[var_name].dims)
+                detected[var_name]['dims'] = var_dims
+                # Override type based on actual dimensions
+                detected[var_name]['type'] = actual_var_type
                 
             else:
                 # Auto-detect unknown variables by examining their attributes
@@ -159,7 +177,9 @@ class NetCDFProcessor:
                         detected[var_name]['original_name'] = var_name
                         detected[var_name]['dataset_type'] = dataset_type
                         detected[var_name]['shape'] = dataset[var_name].shape
-                        detected[var_name]['dims'] = list(dataset[var_name].dims)
+                        detected[var_name]['dims'] = var_dims
+                        # Override type based on actual dimensions
+                        detected[var_name]['type'] = actual_var_type
                         if units != 'unknown':
                             detected[var_name]['units'] = units  # Use actual units from file
                         matched = True
@@ -167,16 +187,13 @@ class NetCDFProcessor:
                 
                 # If still no match, create a generic entry for any 2D+ variable
                 if not matched and len(dataset[var_name].dims) >= 2:
-                    # Check if it has lat/lon dimensions
-                    dims = list(dataset[var_name].dims)
+                    # Check if it has lat/lon dimensions  
                     has_spatial = any(dim in ['lat', 'lon', 'latitude', 'longitude', 'x', 'y'] 
-                                    for dim in [d.lower() for d in dims])
+                                    for dim in [d.lower() for d in var_dims])
                     
                     if has_spatial:
-                        # Determine variable type based on dimensions
-                        var_type = 'surface'
-                        if any(dim in ['level', 'plev', 'pressure', 'height'] for dim in [d.lower() for d in dims]):
-                            var_type = 'atmospheric'
+                        # Use the already determined variable type
+                        var_type = actual_var_type
                         
                         # Auto-determine color scheme based on variable name or units
                         cmap = 'viridis'  # default
@@ -200,7 +217,7 @@ class NetCDFProcessor:
                             'original_name': var_name,
                             'dataset_type': dataset_type,
                             'shape': dataset[var_name].shape,
-                            'dims': dims,
+                            'dims': var_dims,
                             'auto_detected': True  # Flag to indicate this was auto-detected
                         }
         
@@ -405,9 +422,7 @@ class NetCDFProcessor:
         Returns:
         tuple: (cropped_data, cropped_lats, cropped_lons)
         """
-        from constants import INDIA_BOUNDS
-        
-        # Define extended India bounds with some buffer
+        # Use same India bounds as Aurora processor for consistency
         lat_min = INDIA_BOUNDS['lat_min'] - 2  # 6-2 = 4°N
         lat_max = INDIA_BOUNDS['lat_max'] + 2  # 38+2 = 40°N  
         lon_min = INDIA_BOUNDS['lon_min'] - 2  # 68-2 = 66°E
@@ -529,6 +544,218 @@ class NetCDFProcessor:
             pass  # Dataset already closed or invalid
 
 
+class AuroraPredictionProcessor:
+    def __init__(self, file_path):
+        """
+        Initialize Aurora prediction processor for single NetCDF files with timestep data
+        
+        Parameters:
+        file_path (str): Path to Aurora prediction NetCDF file
+        """
+        self.file_path = Path(file_path)
+        self.dataset = None
+        self.detected_variables = {}
+    
+    def _trim_to_india_bounds(self, var, lats, lons):
+        """
+        Trim data and coordinates to India geographical bounds to reduce computation
+        
+        Parameters:
+        var (xarray.DataArray): Variable data
+        lats (numpy.ndarray): Latitude coordinates
+        lons (numpy.ndarray): Longitude coordinates
+        
+        Returns:
+        tuple: (trimmed_var, trimmed_lats, trimmed_lons)
+        """
+        # Find indices within India bounds
+        lat_mask = (lats >= INDIA_BOUNDS['lat_min']) & (lats <= INDIA_BOUNDS['lat_max'])
+        lon_mask = (lons >= INDIA_BOUNDS['lon_min']) & (lons <= INDIA_BOUNDS['lon_max'])
+        
+        lat_indices = np.where(lat_mask)[0]
+        lon_indices = np.where(lon_mask)[0]
+        
+        if len(lat_indices) == 0 or len(lon_indices) == 0:
+            # If no points in India bounds, return original data
+            return var, lats, lons
+        
+        # Get min/max indices for slicing
+        lat_start, lat_end = lat_indices[0], lat_indices[-1] + 1
+        lon_start, lon_end = lon_indices[0], lon_indices[-1] + 1
+        
+        # Trim coordinates
+        trimmed_lats = lats[lat_start:lat_end]
+        trimmed_lons = lons[lon_start:lon_end]
+        
+        # Trim data - handle different dimension orders
+        if var.ndim == 2:  # (lat, lon)
+            trimmed_var = var[lat_start:lat_end, lon_start:lon_end]
+        elif var.ndim == 3 and 'latitude' in var.dims and 'longitude' in var.dims:
+            # Find latitude and longitude dimension positions
+            lat_dim_pos = var.dims.index('latitude') if 'latitude' in var.dims else var.dims.index('lat')
+            lon_dim_pos = var.dims.index('longitude') if 'longitude' in var.dims else var.dims.index('lon')
+            
+            if lat_dim_pos == 1 and lon_dim_pos == 2:  # (time/level, lat, lon)
+                trimmed_var = var[:, lat_start:lat_end, lon_start:lon_end]
+            elif lat_dim_pos == 0 and lon_dim_pos == 1:  # (lat, lon, time/level)
+                trimmed_var = var[lat_start:lat_end, lon_start:lon_end, :]
+            else:
+                # Fall back to original if dimension order is unexpected
+                return var, lats, lons
+        else:
+            # For other dimensions or if trimming fails, return original
+            return var, lats, lons
+            
+        return trimmed_var, trimmed_lats, trimmed_lons
+        
+    def load_dataset(self):
+        """Load Aurora prediction NetCDF dataset"""
+        try:
+            self.dataset = xr.open_dataset(self.file_path)
+            return True
+        except Exception as e:
+            raise Exception(f"Error loading Aurora prediction dataset: {str(e)}")
+    
+    def extract_variable_data(self, variable_name, pressure_level=None, step=0):
+        """
+        Extract variable data from Aurora prediction file
+        
+        Parameters:
+        variable_name (str): Name of the variable to extract
+        pressure_level (float, optional): Pressure level for atmospheric variables
+        step (int): Time step index (default: 0)
+        
+        Returns:
+        tuple: (data_array, metadata_dict)
+        """
+        if self.dataset is None:
+            self.load_dataset()
+        
+        if variable_name not in self.dataset.data_vars:
+            raise ValueError(f"Variable '{variable_name}' not found in dataset")
+        
+        var = self.dataset[variable_name]
+        
+        # Handle Aurora-specific dimensions
+        # Aurora files have: (forecast_period, forecast_reference_time, [pressure_level], latitude, longitude)
+        
+        # First, squeeze singleton forecast_period dimension
+        if 'forecast_period' in var.dims and var.sizes['forecast_period'] == 1:
+            var = var.squeeze('forecast_period')
+        
+        # Handle forecast_reference_time - take the first one (index 0)
+        if 'forecast_reference_time' in var.dims:
+            var = var.isel(forecast_reference_time=0)
+        
+        # Handle step dimension if present (for backward compatibility)
+        if 'step' in var.dims:
+            if step >= var.sizes['step']:
+                raise ValueError(f"Step {step} not available. Dataset has {var.sizes['step']} steps.")
+            var = var.isel(step=step)
+        
+        # Handle pressure level dimension if present
+        if pressure_level is not None and 'pressure_level' in var.dims:
+            pressure_level = float(pressure_level)
+            # Find closest pressure level
+            available_levels = var.pressure_level.values
+            closest_idx = np.argmin(np.abs(available_levels - pressure_level))
+            actual_level = available_levels[closest_idx]
+            var = var.isel(pressure_level=closest_idx)
+            pressure_info = f"at {actual_level:.0f} hPa"
+        else:
+            pressure_info = None
+        
+        # Handle different coordinate naming conventions
+        if 'latitude' in self.dataset.coords:
+            lats = self.dataset['latitude'].values
+            lons = self.dataset['longitude'].values
+        else:
+            lats = self.dataset['lat'].values if 'lat' in self.dataset else self.dataset['latitude'].values
+            lons = self.dataset['lon'].values if 'lon' in self.dataset else self.dataset['longitude'].values
+        
+        # Trim data and coordinates to India bounds to reduce computation
+        var, lats, lons = self._trim_to_india_bounds(var, lats, lons)
+        
+        # Extract trimmed data
+        data_values = var.values
+        
+        # Get variable information
+        from constants import NETCDF_VARIABLES
+        var_info = NETCDF_VARIABLES.get(variable_name, {})
+        display_name = var_info.get('name', variable_name.replace('_', ' ').title())
+        units = var.attrs.get('units', var_info.get('units', ''))
+        
+        # Prepare metadata
+        metadata = {
+            'variable_name': variable_name,
+            'display_name': display_name,
+            'units': units,
+            'lats': lats,
+            'lons': lons,
+            'pressure_level': pressure_level if pressure_level else None,
+            'pressure_info': pressure_info,
+            'step': step,
+            'data_shape': data_values.shape,
+            'source': 'Aurora Prediction',
+            'file_path': str(self.file_path),
+        }
+        
+        # Add timestamp information 
+        # For Aurora predictions, step represents the forecast step (12-hour intervals)
+        hours_from_start = (step + 1) * 12  # Assuming 12-hour intervals
+        metadata['timestamp_str'] = f"T+{hours_from_start}h (Step {step + 1})"
+        
+        return data_values, metadata
+    
+    def get_available_variables(self):
+        """Get list of available variables categorized by type"""
+        if self.dataset is None:
+            self.load_dataset()
+        
+        surface_vars = []
+        atmospheric_vars = []
+        
+        for var_name in self.dataset.data_vars:
+            var = self.dataset[var_name]
+            # Check if variable has pressure level dimension
+            if 'pressure_level' in var.dims:
+                atmospheric_vars.append(var_name)
+            else:
+                surface_vars.append(var_name)
+        
+        return {
+            'surface_vars': surface_vars,
+            'atmospheric_vars': atmospheric_vars
+        }
+    
+    def get_available_pressure_levels(self):
+        """Get available pressure levels"""
+        if self.dataset is None:
+            self.load_dataset()
+        
+        if 'pressure_level' in self.dataset.coords:
+            return self.dataset.pressure_level.values.tolist()
+        return []
+    
+    def get_available_steps(self):
+        """Get available time steps"""
+        if self.dataset is None:
+            self.load_dataset()
+        
+        if 'step' in self.dataset.dims:
+            return list(range(self.dataset.sizes['step']))
+        return [0]
+    
+    def close(self):
+        """Close the dataset safely"""
+        try:
+            if self.dataset is not None:
+                self.dataset.close()
+                self.dataset = None
+        except (RuntimeError, OSError):
+            pass  # Dataset already closed or invalid
+
+
 def analyze_netcdf_file(file_path):
     """
     Analyze NetCDF file structure and return summary

interactive_plot_generator.py

@@ -378,6 +378,10 @@ class InteractiveIndiaMapPlotter:
     
     def _save_html_plot(self, fig, var_name, display_name, pressure_level, color_theme, time_stamp, config):
         """Save the interactive plot as HTML"""
+        # Handle None values with fallbacks
+        display_name = display_name or var_name or 'Unknown'
+        time_stamp = time_stamp or 'Unknown_Time'
+        
         safe_display_name = display_name.replace('/', '_').replace(' ', '_').replace('₂', '2').replace('₃', '3').replace('.', '_')
         safe_time_stamp = time_stamp.replace('-', '').replace(':', '').replace(' ', '_')
         

plot_generator.py

@@ -179,6 +179,10 @@ class IndiaMapPlotter:
         return "\n".join(stats_lines)
 
     def _save_plot(self, fig, var_name, display_name, pressure_level, color_theme, time_stamp):
+        # Handle None values with fallbacks
+        display_name = display_name or var_name or 'Unknown'
+        time_stamp = time_stamp or 'Unknown_Time'
+        
         safe_display_name = display_name.replace('/', '_').replace(' ', '_').replace('₂', '2').replace('₃', '3').replace('.', '_')
         safe_time_stamp = time_stamp.replace('-', '').replace(':', '').replace(' ', '_')
         filename_parts = [f"{safe_display_name}_India"]

templates/aurora_predict.html

@@ -292,12 +292,13 @@
 
         <div class="form-container">
             <div class="info-box">
-                <h3>🚀 About Aurora Predictions</h3>
+                                <h3>✨ Enhanced Aurora Features</h3>
                 <ul>
-                    <li><strong>AI-Powered Forecasting:</strong> Uses Microsoft's Aurora foundation model for atmospheric predictions</li>
-                    <li><strong>Multi-Step Forecasting:</strong> Generate predictions for up to 10 time steps ahead</li>
-                    <li><strong>Real CAMS Data:</strong> Downloads actual atmospheric data for the selected date</li>
-                    <li><strong>Multiple Variables:</strong> Predicts PM2.5, PM10, O₃, NO₂, CO, SO₂ and meteorological variables</li>
+                    <li><strong>Dual Time Input:</strong> Uses both T-1 (00:00) and T (12:00) timestamps for better accuracy</li>
+                    <li><strong>Forward Predictions:</strong> Generate 1-4 steps forward, each covering 12 hours</li>
+                    <li><strong>Organized Storage:</strong> Results saved in dated folders for easy management</li>
+                    <li><strong>Multiple Variables:</strong> Predicts PM1, PM2.5, PM10, O₃, NO₂, CO, SO₂ and meteorological variables</li>
+                    <li><strong>Enhanced Visualization:</strong> Step-by-step analysis with time progression</li>
                 </ul>
             </div>
 
@@ -307,6 +308,7 @@
                 <p><strong>GPU Mode:</strong> If CUDA GPU is available, Aurora will use it for faster predictions.</p>
                 <p><strong>Processing Time:</strong> CPU: 5-15 minutes per step | GPU: 1-3 minutes total</p>
                 <p><strong>Memory:</strong> CPU mode automatically limits to 2 steps to prevent memory issues.</p>
+                <p><strong>Coverage:</strong> Each step predicts 12 hours forward (max 48 hours with 4 steps).</p>
             </div>
 
             <form method="POST">
@@ -325,17 +327,16 @@
                 </div>
 
                 <div class="form-group">
-                    <label for="steps">🔢 Number of Forecast Steps:</label>
+                    <label for="steps">🔢 Number of Forward Prediction Steps:</label>
                     <select id="steps" name="steps" required>
-                        <option value="1">1 step (6 hours) - Fastest</option>
-                        <option value="2" selected>2 steps (12 hours) - CPU Friendly</option>
-                        <option value="4">4 steps (24 hours) - Standard</option>
-                        <option value="6">6 steps (36 hours) - GPU Recommended</option>
-                        <option value="8">8 steps (48 hours) - GPU Required</option>
-                        <option value="10">10 steps (60 hours) - GPU Required</option>
+                        <option value="1">1 step (12 hours forward) - Fastest</option>
+                        <option value="2" selected>2 steps (24 hours forward) - CPU Friendly</option>
+                        <option value="3">3 steps (36 hours forward) - Recommended</option>
+                        <option value="4">4 steps (48 hours forward) - Maximum</option>
                     </select>
                     <small style="color: #666; font-size: 14px;">
-                        Each step represents 6 hours. CPU mode automatically limits to 2 steps maximum.
+                        Each step represents 12 hours forward from the initial conditions. 
+                        Aurora uses T-1 (00:00) and T (12:00) as input, then predicts forward.
                     </small>
                 </div>
 

templates/aurora_prediction_plot.html

@@ -243,8 +243,8 @@
         </div>
 
         <div class="step-indicator">
-            <h3>📊 Current View: Step {{ step }} of {{ steps|length - 1 }}</h3>
-            <p>Forecast time: {{ (step * 6) }} hours ahead</p>
+            <h3>📊 Current View: Step {{ step + 1 }} of {{ max_steps }}</h3>
+            <p>Forecast time: T+{{ (step + 1) * 12 }}h ahead from initial conditions</p>
         </div>
 
         <form method="POST" id="predictionForm">
@@ -266,7 +266,7 @@
                         <select id="step" name="step">
                             {% for s in steps %}
                             <option value="{{ s }}" {% if s == step %}selected{% endif %}>
-                                Step {{ s }} ({{ s * 6 }}h ahead)
+                                Step {{ s + 1 }} (T+{{ (s + 1) * 12 }}h)
                             </option>
                             {% endfor %}
                         </select>

templates/aurora_variables.html

@@ -0,0 +1,393 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Aurora Prediction Variables - CAMS Air Pollution</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+            background: #f5f5f5;
+        }
+        .container {
+            background: white;
+            padding: 30px;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }
+        h1 { color: #2c3e50; text-align: center; margin-bottom: 30px; }
+        h2 { color: #34495e; border-bottom: 2px solid #9b59b6; padding-bottom: 10px; }
+        .method-section, .form-section {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            border-left: 4px solid #9b59b6;
+        }
+        .form-group {
+            margin-bottom: 15px;
+        }
+        label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: 600;
+            color: #2c3e50;
+        }
+        select {
+            width: 100%;
+            padding: 10px;
+            border: 2px solid #ddd;
+            border-radius: 5px;
+            font-size: 14px;
+        }
+        select:focus {
+            border-color: #9b59b6;
+            outline: none;
+        }
+        .btn {
+            background: #9b59b6;
+            color: white;
+            padding: 12px 24px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            font-weight: 600;
+            transition: all 0.3s;
+            text-decoration: none;
+            display: inline-block;
+            margin-right: 10px;
+            margin-bottom: 10px;
+        }
+        .btn:hover { background: #8e44ad; }
+        .btn:disabled { 
+            background: #ccc; 
+            cursor: not-allowed; 
+        }
+        .btn-secondary {
+            background: #6c757d;
+        }
+        .btn-secondary:hover {
+            background: #5a6268;
+        }
+        .btn-success {
+            background: #28a745;
+        }
+        .btn-success:hover {
+            background: #218838;
+        }
+        .step-selector {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+        .step-btn {
+            padding: 8px 16px;
+            border: 2px solid #ddd;
+            background: white;
+            border-radius: 5px;
+            cursor: pointer;
+            transition: all 0.3s;
+        }
+        .step-btn:hover {
+            border-color: #9b59b6;
+        }
+        .step-btn.active {
+            background: #9b59b6;
+            color: white;
+            border-color: #9b59b6;
+        }
+        .info-box {
+            background: #e8f4f8;
+            border: 1px solid #bee5eb;
+            border-radius: 5px;
+            padding: 15px;
+            margin-bottom: 20px;
+        }
+        .hidden-section {
+            display: none;
+        }
+        .loading {
+            text-align: center;
+            color: #666;
+            font-style: italic;
+        }
+        .back-link {
+            color: #9b59b6;
+            text-decoration: none;
+            font-weight: 600;
+            margin-bottom: 20px;
+            display: inline-block;
+        }
+        .back-link:hover {
+            text-decoration: underline;
+        }
+        .color-preview-section {
+            margin-top: 15px;
+        }
+        .color-gradient {
+            width: 100%;
+            height: 20px;
+            border-radius: 5px;
+            border: 1px solid #ddd;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <a href="{{ url_for('prediction_runs') }}" class="back-link">← Back to Prediction Runs</a>
+        
+        <h1>🔮 Aurora Prediction Variables</h1>
+        
+        <div class="info-box">
+            <strong>📁 Run Directory:</strong> {{ run_dir }}<br>
+            <strong>📊 Steps Available:</strong> {{ steps_data|length }} ({{ (steps_data|length * 12) }}h coverage)
+        </div>
+
+        <!-- Step 1: Step Selection -->
+        <div class="method-section">
+            <h2>⏰ Step 1: Select Prediction Step</h2>
+            <p>Choose which prediction time step to analyze:</p>
+            <div class="step-selector">
+                {% for step_data in steps_data %}
+                <div class="step-btn" onclick="selectStep({{ step_data.step }}, '{{ step_data.filename }}')">
+                    Step {{ step_data.step }}<br>
+                    <small>T+{{ step_data.forecast_hours }}h</small>
+                </div>
+                {% endfor %}
+            </div>
+        </div>
+
+        <!-- Step 2: Variable Selection (hidden until step selected) -->
+        <div id="variableSection" class="hidden-section">
+            <div class="form-section">
+                <h2>🧪 Step 2: Select Variable</h2>
+                <div id="variableLoading" class="loading">Loading variables...</div>
+                <div id="variableContent" class="hidden-section">
+                    <form method="POST" action="{{ url_for('aurora_plot') }}" id="plotForm">
+                        <input type="hidden" name="run_dir" value="{{ run_dir }}">
+                        <input type="hidden" name="step" id="selected_step" value="">
+                        
+                        <div class="form-group">
+                            <label for="variable">Choose Variable:</label>
+                            <select name="variable" id="variable" required onchange="handleVariableChange()">
+                                <option value="">-- Select a variable --</option>
+                            </select>
+                        </div>
+                        
+                        <!-- Step 3: Pressure Level (shown for atmospheric variables) -->
+                        <div id="pressureSection" class="hidden-section">
+                            <h2>📊 Step 3: Select Pressure Level</h2>
+                            <div class="form-group">
+                                <label for="pressure_level">Pressure Level (hPa):</label>
+                                <select name="pressure_level" id="pressure_level">
+                                </select>
+                            </div>
+                        </div>
+
+                        <!-- Step 4: Color Theme Selection -->
+                        <div id="plotOptionsSection" class="hidden-section">
+                            <h2>🎨 Step 4: Select Color Theme</h2>
+                            <div class="form-group">
+                                <label for="color_theme">Select Color Scheme:</label>
+                                <select name="color_theme" id="color_theme" onchange="updateColorPreview()">
+                                    {% for theme_id, theme_name in color_themes.items() %}
+                                    <option value="{{ theme_id }}" 
+                                            {% if theme_id == 'viridis' %}selected{% endif %}>
+                                        {{ theme_name }}
+                                    </option>
+                                    {% endfor %}
+                                </select>
+                            </div>
+                            
+                            <div class="color-preview-section">
+                                <p><strong>Preview:</strong> <span id="colorPreviewText">Viridis</span></p>
+                                <div class="color-gradient" id="colorPreview"></div>
+                            </div>
+                        </div>
+
+                            <!-- Step 5: Generate Plot -->
+                            <h2>📈 Step 5: Generate Plot</h2>
+                            <button type="submit" name="plot_type" value="static" class="btn" id="staticPlotBtn" disabled>
+                                📊 Generate Static Plot
+                            </button>
+                            <button type="submit" name="plot_type" value="interactive" class="btn btn-success" id="interactivePlotBtn" disabled>
+                                🌐 Generate Interactive Plot
+                            </button>
+                        </div>
+                    </form>
+                </div>
+            </div>
+        </div>
+
+        <!-- Download Section -->
+        <div class="method-section">
+            <h2>💾 Download Data</h2>
+            <a href="{{ url_for('download_prediction_netcdf', filename=run_dir) }}" class="btn btn-secondary">
+                📥 Download All Files
+            </a>
+        </div>
+    </div>
+
+    <script>
+        let currentStep = null;
+        let currentVariables = null;
+
+        function selectStep(step, filename) {
+            // Update UI
+            document.querySelectorAll('.step-btn').forEach(btn => btn.classList.remove('active'));
+            event.target.closest('.step-btn').classList.add('active');
+            
+            currentStep = step;
+            document.getElementById('selected_step').value = step;
+            
+            // Show variable section and loading
+            document.getElementById('variableSection').classList.remove('hidden-section');
+            document.getElementById('variableLoading').style.display = 'block';
+            document.getElementById('variableContent').classList.add('hidden-section');
+            
+            // Load variables for this step
+            fetch(`/api/aurora_step_variables/{{ run_dir }}/${step}`)
+                .then(response => response.json())
+                .then(data => {
+                    if (data.error) {
+                        alert('Error loading variables: ' + data.error);
+                        return;
+                    }
+                    
+                    currentVariables = data;
+                    populateVariables(data);
+                    
+                    // Hide loading, show content
+                    document.getElementById('variableLoading').style.display = 'none';
+                    document.getElementById('variableContent').classList.remove('hidden-section');
+                })
+                .catch(error => {
+                    console.error('Error:', error);
+                    alert('Error loading variables');
+                    document.getElementById('variableLoading').innerHTML = 'Error loading variables';
+                });
+        }
+
+        function populateVariables(data) {
+            const select = document.getElementById('variable');
+            select.innerHTML = '<option value="">-- Select a variable --</option>';
+            
+            if (data.surface_vars && data.surface_vars.length > 0) {
+                const surfaceGroup = document.createElement('optgroup');
+                surfaceGroup.label = 'Surface Variables';
+                data.surface_vars.forEach(varName => {
+                    const option = document.createElement('option');
+                    option.value = varName;
+                    option.textContent = `${varName} (Surface)`;
+                    option.dataset.type = 'surface';
+                    surfaceGroup.appendChild(option);
+                });
+                select.appendChild(surfaceGroup);
+            }
+            
+            if (data.atmos_vars && data.atmos_vars.length > 0) {
+                const atmosGroup = document.createElement('optgroup');
+                atmosGroup.label = 'Atmospheric Variables';
+                data.atmos_vars.forEach(varName => {
+                    const option = document.createElement('option');
+                    option.value = varName;
+                    option.textContent = `${varName} (Atmospheric)`;
+                    option.dataset.type = 'atmospheric';
+                    atmosGroup.appendChild(option);
+                });
+                select.appendChild(atmosGroup);
+            }
+            
+            // Populate pressure levels
+            const pressureSelect = document.getElementById('pressure_level');
+            pressureSelect.innerHTML = '';
+            if (data.pressure_levels && data.pressure_levels.length > 0) {
+                data.pressure_levels.forEach(level => {
+                    const option = document.createElement('option');
+                    option.value = level;
+                    option.textContent = `${level} hPa`;
+                    pressureSelect.appendChild(option);
+                });
+            }
+        }
+
+        function handleVariableChange() {
+            const select = document.getElementById('variable');
+            const selectedOption = select.options[select.selectedIndex];
+            
+            if (selectedOption.value) {
+                const isAtmospheric = selectedOption.dataset.type === 'atmospheric';
+                
+                // Show/hide pressure section
+                const pressureSection = document.getElementById('pressureSection');
+                if (isAtmospheric) {
+                    pressureSection.classList.remove('hidden-section');
+                } else {
+                    pressureSection.classList.add('hidden-section');
+                }
+                
+                // Show plot options
+                document.getElementById('plotOptionsSection').classList.remove('hidden-section');
+                
+                // Initialize color preview when plot options are shown
+                updateColorPreview();
+                
+                // Enable plot buttons
+                document.getElementById('staticPlotBtn').disabled = false;
+                document.getElementById('interactivePlotBtn').disabled = false;
+            } else {
+                // Hide sections if no variable selected
+                document.getElementById('pressureSection').classList.add('hidden-section');
+                document.getElementById('plotOptionsSection').classList.add('hidden-section');
+                
+                // Disable plot buttons
+                document.getElementById('staticPlotBtn').disabled = true;
+                document.getElementById('interactivePlotBtn').disabled = true;
+            }
+        }
+        
+        // Color theme preview
+        const colorMaps = {
+            'viridis': 'linear-gradient(to right, #440154, #414487, #2a788e, #22a884, #7ad151, #fde725)',
+            'plasma': 'linear-gradient(to right, #0d0887, #6a00a8, #b12a90, #e16462, #fca636, #f0f921)',
+            'YlOrRd': 'linear-gradient(to right, #ffffcc, #ffeda0, #fed976, #feb24c, #fd8d3c, #e31a1c)',
+            'Blues': 'linear-gradient(to right, #f7fbff, #deebf7, #c6dbef, #9ecae1, #6baed6, #2171b5)',
+            'Reds': 'linear-gradient(to right, #fff5f0, #fee0d2, #fcbba1, #fc9272, #fb6a4a, #de2d26)',
+            'Greens': 'linear-gradient(to right, #f7fcf5, #e5f5e0, #c7e9c0, #a1d99b, #74c476, #238b45)',
+            'Oranges': 'linear-gradient(to right, #fff5eb, #fee6ce, #fdd0a2, #fdae6b, #fd8d3c, #d94701)',
+            'Purples': 'linear-gradient(to right, #fcfbfd, #efedf5, #dadaeb, #bcbddc, #9e9ac8, #756bb1)',
+            'inferno': 'linear-gradient(to right, #000004, #420a68, #932667, #dd513a, #fca50a, #fcffa4)',
+            'magma': 'linear-gradient(to right, #000004, #3b0f70, #8c2981, #de4968, #fe9f6d, #fcfdbf)',
+            'cividis': 'linear-gradient(to right, #00224e, #123570, #3b496c, #575d6d, #707173, #8a8678)',
+            'coolwarm': 'linear-gradient(to right, #3b4cc0, #688aef, #b7d4f1, #f7f7f7, #f4b2a6, #dc7176, #a50026)',
+            'RdYlBu': 'linear-gradient(to right, #a50026, #d73027, #f46d43, #fdae61, #fee090, #e0f3f8, #abd9e9, #74add1, #4575b4, #313695)',
+            'Spectral': 'linear-gradient(to right, #9e0142, #d53e4f, #f46d43, #fdae61, #fee08b, #e6f598, #abdda4, #66c2a5, #3288bd, #5e4fa2)'
+        };
+        
+        function updateColorPreview() {
+            const theme = document.getElementById('color_theme').value;
+            const preview = document.getElementById('colorPreview');
+            const previewText = document.getElementById('colorPreviewText');
+            
+            previewText.textContent = document.getElementById('color_theme').selectedOptions[0].text;
+            
+            if (colorMaps[theme]) {
+                preview.style.background = colorMaps[theme];
+            } else {
+                preview.style.background = colorMaps['viridis'];
+            }
+        }
+        
+        // Initialize color preview when page loads
+        document.addEventListener('DOMContentLoaded', function() {
+            updateColorPreview();
+        });
+    </script>
+</body>
+</html>

templates/index.html

@@ -263,19 +263,25 @@
                 <p>Generate AI-powered air pollution forecasts using Microsoft's Aurora foundation model</p>
                 
                 <div style="background: #f8f9ff; padding: 15px; border-radius: 8px; margin: 15px 0; border: 2px solid #e3e7ff;">
-                    <p style="margin-bottom: 10px;"><strong>🚀 What is Aurora?</strong></p>
+                    <p style="margin-bottom: 10px;"><strong>🚀 Enhanced Aurora Features:</strong></p>
                     <ul style="margin-left: 20px; color: #666;">
-                        <li>Microsoft's state-of-the-art atmospheric foundation model</li>
-                        <li>Trained on massive amounts of global weather and atmospheric data</li>
-                        <li>Generates multi-step forecasts for air pollution and meteorology</li>
-                        <li>Provides predictions up to 60 hours ahead with 6-hour intervals</li>
+                        <li>Uses dual timestamps (T-1 and T) for improved prediction accuracy</li>
+                        <li>Forward predictions from 1-4 steps (12-48 hours coverage)</li>
+                        <li>Organized storage with run metadata and easy browsing</li>
+                        <li>Step-by-step visualization showing temporal evolution</li>
+                        <li>Full pollution suite: PM1, PM2.5, PM10, O₃, NO₂, CO, SO₂</li>
                     </ul>
                 </div>
                 
                 {% if aurora_available is defined and aurora_available %}
-                    <a href="{{ url_for('aurora_predict') }}" class="btn" style="background: linear-gradient(135deg, #9b59b6 0%, #8e44ad 100%);">
-                        🔮 Generate Aurora Predictions
-                    </a>
+                    <div style="display: flex; gap: 15px; flex-wrap: wrap;">
+                        <a href="{{ url_for('aurora_predict') }}" class="btn" style="background: linear-gradient(135deg, #9b59b6 0%, #8e44ad 100%);">
+                            🔮 Generate Aurora Predictions
+                        </a>
+                        <a href="{{ url_for('prediction_runs') }}" class="btn" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);">
+                            📊 Browse Existing Predictions
+                        </a>
+                    </div>
                 {% else %}
                     <button class="btn" disabled style="background: #bdc3c7; cursor: not-allowed;">
                         🔮 Aurora Model Not Available

templates/prediction_runs.html

@@ -0,0 +1,338 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Aurora Prediction Runs - CAMS Pollution Dashboard</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Arial', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            color: #333;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+
+        .header {
+            text-align: center;
+            margin-bottom: 40px;
+            color: white;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+
+        .header p {
+            font-size: 1.2em;
+            opacity: 0.9;
+        }
+
+        .back-link {
+            display: inline-block;
+            color: white;
+            text-decoration: none;
+            padding: 10px 20px;
+            background: rgba(255, 255, 255, 0.2);
+            border-radius: 25px;
+            margin-bottom: 30px;
+            transition: background 0.3s ease;
+        }
+
+        .back-link:hover {
+            background: rgba(255, 255, 255, 0.3);
+        }
+
+        .runs-container {
+            background: rgba(255, 255, 255, 0.95);
+            border-radius: 15px;
+            padding: 30px;
+            box-shadow: 0 15px 35px rgba(0, 0, 0, 0.1);
+            backdrop-filter: blur(10px);
+        }
+
+        .no-runs {
+            text-align: center;
+            padding: 60px 20px;
+            color: #666;
+        }
+
+        .no-runs h3 {
+            font-size: 1.5em;
+            margin-bottom: 15px;
+            color: #999;
+        }
+
+        .run-card {
+            background: #f8f9fa;
+            border-radius: 10px;
+            padding: 20px;
+            margin-bottom: 20px;
+            border-left: 5px solid #667eea;
+            transition: transform 0.2s ease, box-shadow 0.2s ease;
+        }
+
+        .run-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+        }
+
+        .run-header {
+            display: flex;
+            justify-content: between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .run-title {
+            font-size: 1.3em;
+            font-weight: bold;
+            color: #333;
+            margin-right: auto;
+        }
+
+        .run-status {
+            padding: 5px 15px;
+            border-radius: 20px;
+            font-size: 0.9em;
+            font-weight: bold;
+        }
+
+        .status-available {
+            background: #d4edda;
+            color: #155724;
+        }
+
+        .status-unavailable {
+            background: #f8d7da;
+            color: #721c24;
+        }
+
+        .run-details {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-bottom: 20px;
+        }
+
+        .detail-item {
+            display: flex;
+            align-items: center;
+            font-size: 0.95em;
+        }
+
+        .detail-icon {
+            margin-right: 8px;
+            font-size: 1.1em;
+        }
+
+        .detail-label {
+            font-weight: bold;
+            margin-right: 8px;
+            color: #555;
+        }
+
+        .detail-value {
+            color: #333;
+        }
+
+        .run-actions {
+            display: flex;
+            gap: 10px;
+            flex-wrap: wrap;
+        }
+
+        .btn {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 10px 20px;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            cursor: pointer;
+            text-decoration: none;
+            display: inline-block;
+            transition: transform 0.2s ease, box-shadow 0.2s ease;
+        }
+
+        .btn:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3);
+        }
+
+        .btn-secondary {
+            background: linear-gradient(135deg, #6c757d 0%, #495057 100%);
+        }
+
+        .btn:disabled {
+            background: #bdc3c7;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .summary-stats {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .stat-card {
+            background: white;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+
+        .stat-number {
+            font-size: 2em;
+            font-weight: bold;
+            color: #667eea;
+            display: block;
+        }
+
+        .stat-label {
+            color: #666;
+            font-size: 0.9em;
+            margin-top: 5px;
+        }
+
+        @media (max-width: 768px) {
+            .container {
+                padding: 10px;
+            }
+
+            .runs-container {
+                padding: 20px;
+            }
+
+            .run-details {
+                grid-template-columns: 1fr;
+            }
+
+            .run-actions {
+                flex-direction: column;
+            }
+
+            .btn {
+                text-align: center;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🔮 Aurora Prediction Runs</h1>
+            <p>Browse and manage your atmospheric prediction runs</p>
+        </div>
+
+        <a href="{{ url_for('index') }}" class="back-link">← Back to Dashboard</a>
+
+        <div class="runs-container">
+            {% if runs %}
+                <!-- Summary Statistics -->
+                <div class="summary-stats">
+                    <div class="stat-card">
+                        <span class="stat-number">{{ runs|length }}</span>
+                        <div class="stat-label">Total Runs</div>
+                    </div>
+                    <div class="stat-card">
+                        <span class="stat-number">{{ runs|selectattr("available")|list|length }}</span>
+                        <div class="stat-label">Available</div>
+                    </div>
+                    <div class="stat-card">
+                        <span class="stat-number">{{ (runs|map(attribute="steps")|sum) or 0 }}</span>
+                        <div class="stat-label">Total Steps</div>
+                    </div>
+                    <div class="stat-card">
+                        <span class="stat-number">{{ (runs|map(attribute="time_coverage_hours")|sum) or 0 }}h</span>
+                        <div class="stat-label">Total Coverage</div>
+                    </div>
+                </div>
+
+                <!-- Prediction Runs List -->
+                {% for run in runs %}
+                <div class="run-card">
+                    <div class="run-header">
+                        <div class="run-title">📅 {{ run.date }}</div>
+                        <div class="run-status {{ 'status-available' if run.available else 'status-unavailable' }}">
+                            {{ '✅ Available' if run.available else '❌ Missing' }}
+                        </div>
+                    </div>
+
+                    <div class="run-details">
+                        <div class="detail-item">
+                            <span class="detail-icon">🕐</span>
+                            <span class="detail-label">Run Time:</span>
+                            <span class="detail-value">{{ run.run_timestamp[:8] }} {{ run.run_timestamp[9:].replace('_', ':') }}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-icon">📊</span>
+                            <span class="detail-label">Steps:</span>
+                            <span class="detail-value">{{ run.steps }} steps</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-icon">⏱️</span>
+                            <span class="detail-label">Coverage:</span>
+                            <span class="detail-value">{{ run.time_coverage_hours }}h forward</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-icon">📥</span>
+                            <span class="detail-label">Input Times:</span>
+                            <span class="detail-value">{{ run.input_times|join(", ") }}</span>
+                        </div>
+                    </div>
+
+                    <div class="run-actions">
+                        {% if run.available %}
+                            <a href="{{ url_for('aurora_variables', run_dir=run.relative_path) }}" 
+                               class="btn">
+                                📊 View Variables
+                            </a>
+                            <a href="{{ url_for('download_prediction_netcdf', filename=run.relative_path) }}" 
+                               class="btn btn-secondary">
+                                💾 Download Files
+                            </a>
+                        {% else %}
+                            <button class="btn" disabled>
+                                ❌ File Not Available
+                            </button>
+                        {% endif %}
+                        
+                        <a href="{{ url_for('aurora_predict') }}" class="btn btn-secondary">
+                            🔄 Create New Run
+                        </a>
+                    </div>
+                </div>
+                {% endfor %}
+
+            {% else %}
+                <div class="no-runs">
+                    <h3>🔮 No Aurora Prediction Runs Found</h3>
+                    <p>You haven't created any Aurora predictions yet.</p>
+                    <p style="margin-top: 20px;">
+                        <a href="{{ url_for('aurora_predict') }}" class="btn">
+                            🚀 Create Your First Prediction
+                        </a>
+                    </p>
+                </div>
+            {% endif %}
+        </div>
+    </div>
+</body>
+</html>

test_aurora_fix.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick test for Aurora pipeline generator fix
-"""
-
-import sys
-import os
-sys.path.append('.')
-
-def test_aurora_fix():
-    """Test the Aurora pipeline generator fix"""
-    print("🧪 Testing Aurora Pipeline Generator Fix")
-    print("=" * 45)
-    
-    try:
-        from aurora_pipeline import AuroraPipeline
-        print("✅ Aurora pipeline imported successfully")
-        
-        # Initialize pipeline
-        pipeline = AuroraPipeline()
-        print("✅ Pipeline initialized")
-        
-        # Test with minimal configuration
-        date = '2022-10-14'
-        steps = 1
-        
-        print(f"\n🚀 Running test prediction:")
-        print(f"   📅 Date: {date}")
-        print(f"   🔄 Steps: {steps}")
-        
-        result = pipeline.run_pipeline(date, steps=steps)
-        
-        print("✅ SUCCESS! Aurora pipeline completed without errors")
-        
-        if isinstance(result, dict):
-            print(f"📊 Result contains: {list(result.keys())}")
-            
-            # Check if we have expected outputs
-            if 'air_pollution' in result:
-                pollution_data = result['air_pollution']
-                print(f"🌬️  Air pollution predictions: {pollution_data.shape if hasattr(pollution_data, 'shape') else type(pollution_data)}")
-            
-            if 'metadata' in result:
-                metadata = result['metadata']
-                print(f"📋 Metadata: {metadata}")
-                
-        print("\n🎉 Aurora pipeline is now working correctly!")
-        
-    except Exception as e:
-        print(f"❌ Error during test: {e}")
-        import traceback
-        print("\n🔍 Full traceback:")
-        traceback.print_exc()
-        
-        print("\n💡 Potential solutions:")
-        print("1. Check if CAMS data exists for the test date")
-        print("2. Verify Aurora model downloaded correctly")
-        print("3. Ensure all dependencies are installed")
-
-if __name__ == "__main__":
-    test_aurora_fix()

test_cpu_mode.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-"""
-CPU-friendly test for local development without GPU requirements
-"""
-
-def test_system_readiness():
-    """Test if the basic system is ready for local development"""
-    print("🔬 Testing System for Local Development")
-    print("=" * 50)
-    
-    issues = []
-    
-    # Test 1: Basic Python imports
-    try:
-        import sys
-        print(f"✅ Python version: {sys.version.split()[0]}")
-    except Exception as e:
-        issues.append(f"Python: {e}")
-    
-    # Test 2: Core dependencies
-    try:
-        import numpy as np
-        print(f"✅ NumPy: {np.__version__}")
-    except ImportError:
-        issues.append("NumPy not found")
-    
-    try:
-        import xarray as xr
-        print(f"✅ xarray: {xr.__version__}")
-    except ImportError:
-        issues.append("xarray not found")
-    
-    try:
-        import matplotlib
-        print(f"✅ Matplotlib: {matplotlib.__version__}")
-    except ImportError:
-        issues.append("Matplotlib not found")
-    
-    try:
-        import flask
-        print(f"✅ Flask: {flask.__version__}")
-    except ImportError:
-        issues.append("Flask not found")
-    
-    # Test 3: Optional Aurora dependencies
-    aurora_ready = True
-    try:
-        import torch
-        print(f"✅ PyTorch: {torch.__version__}")
-        print(f"   CUDA available: {torch.cuda.is_available()}")
-        print(f"   CPU cores: {torch.get_num_threads()}")
-    except ImportError:
-        print("⚠️  PyTorch not found (Aurora unavailable)")
-        aurora_ready = False
-    
-    try:
-        from huggingface_hub import hf_hub_download
-        print("✅ Hugging Face Hub available")
-    except ImportError:
-        print("⚠️  Hugging Face Hub not found (Aurora unavailable)")
-        aurora_ready = False
-    
-    # Test 4: Aurora model
-    try:
-        from aurora import Batch, Metadata, AuroraAirPollution, rollout
-        print("✅ Aurora model available")
-    except ImportError:
-        print("⚠️  Aurora model not found (predictions unavailable)")
-        aurora_ready = False
-    
-    # Test 5: Custom modules
-    try:
-        from data_processor import NetCDFProcessor
-        from plot_generator import IndiaMapPlotter
-        from constants import NETCDF_VARIABLES
-        print("✅ Custom modules loaded")
-    except ImportError as e:
-        issues.append(f"Custom modules: {e}")
-    
-    # Test 6: GPU vs CPU detection
-    gpu_info = "None"
-    try:
-        import subprocess
-        result = subprocess.run(['nvidia-smi', '--query-gpu=name', '--format=csv,noheader,nounits'], 
-                              capture_output=True, text=True, timeout=5)
-        if result.returncode == 0:
-            gpu_info = result.stdout.strip()
-            print(f"🎮 GPU detected: {gpu_info}")
-        else:
-            print("💻 No GPU detected (CPU mode)")
-    except:
-        print("💻 No GPU utilities found (CPU mode)")
-    
-    print("\n" + "=" * 50)
-    print("📊 System Assessment:")
-    
-    if issues:
-        print("❌ Critical Issues Found:")
-        for issue in issues:
-            print(f"   - {issue}")
-        print("\n🔧 Please install missing dependencies")
-    else:
-        print("✅ Core system ready!")
-        
-    if aurora_ready:
-        print("🔮 Aurora ML predictions: Available")
-        if "CPU mode" in gpu_info or gpu_info == "None":
-            print("💻 Recommended: Use CPU mode with max 2 steps")
-        else:
-            print("🎮 GPU available: Can use more prediction steps")
-    else:
-        print("⚠️  Aurora ML predictions: Not available")
-        print("   Install: torch, huggingface_hub, aurora-forecast")
-    
-    return len(issues) == 0
-
-if __name__ == "__main__":
-    success = test_system_readiness()
-    
-    if success:
-        print("\n🚀 Ready to run CAMS visualization system!")
-        print("💡 Start with: python app.py")
-    else:
-        print("\n❌ Please resolve issues before running the system")