Switch orbital rendering to Plotly isosurface for visible HOMO visualization

app.py

@@ -195,115 +195,79 @@ def name_to_3d_molecule(name: str, show_orbitals: bool = False) -> tuple:
             try:
                 import numpy as np
                 from pyscf import gto, scf
-                
-                # Build PySCF molecule object
+
+                # Build PySCF molecule object (Angstrom units)
                 pyscf_elements = [atom.GetSymbol() for atom in mol.GetAtoms()]
                 pyscf_coords = []
                 for i in range(mol.GetNumAtoms()):
                     pos = conf.GetAtomPosition(i)
-                    # Convert to Angstrom (PySCF uses Angstrom)
                     pyscf_coords.append([pos.x, pos.y, pos.z])
-                
+
                 pyscf_atoms = [(elem, coord) for elem, coord in zip(pyscf_elements, pyscf_coords)]
-                
-                # Create PySCF molecule with minimal basis
+
                 pyscf_mole = gto.Mole()
                 pyscf_mole.atom = pyscf_atoms
                 pyscf_mole.basis = 'sto-3g'
                 pyscf_mole.unit = 'A'
                 pyscf_mole.verbose = 0
                 pyscf_mole.build()
-                
-                # Run Hartree-Fock calculation (faster than DFT)
+
+                # Run Hartree-Fock for frontier orbitals
                 mf = scf.RHF(pyscf_mole)
                 mf.verbose = 0
                 mf.kernel()
-                
-                # Get HOMO and LUMO indices
+
                 n_electrons = pyscf_mole.nelectron
-                n_occ = n_electrons // 2
+                n_occ = max(1, n_electrons // 2)
                 homo_idx = n_occ - 1
-                lumo_idx = n_occ
-                
-                # Create a coarser grid for visualization
+
+                # Define sampling grid around molecule
                 margin = 2.5
-                grid_size = 30
-                
+                grid_size = 32
+
                 x_coords_np = np.array(x_coords)
                 y_coords_np = np.array(y_coords)
                 z_coords_np = np.array(z_coords)
-                
+
                 x_min, x_max = x_coords_np.min() - margin, x_coords_np.max() + margin
                 y_min, y_max = y_coords_np.min() - margin, y_coords_np.max() + margin
                 z_min, z_max = z_coords_np.min() - margin, z_coords_np.max() + margin
-                
+
                 x_grid = np.linspace(x_min, x_max, grid_size)
                 y_grid = np.linspace(y_min, y_max, grid_size)
                 z_grid = np.linspace(z_min, z_max, grid_size)
-                
-                coords_grid = np.array(np.meshgrid(x_grid, y_grid, z_grid, indexing='ij'))
-                grid_points = coords_grid.reshape(3, -1).T
-                
-                # Evaluate HOMO orbital on grid
+
+                grid_x, grid_y, grid_z = np.meshgrid(x_grid, y_grid, z_grid, indexing='ij')
+                grid_points = np.column_stack((grid_x.ravel(), grid_y.ravel(), grid_z.ravel()))
+
+                # Evaluate HOMO on grid
                 ao_value = pyscf_mole.eval_gto('GTOval_sph', grid_points)
                 mo_coeff = mf.mo_coeff[:, homo_idx]
                 homo_values = np.dot(ao_value, mo_coeff)
-                homo_grid = homo_values.reshape(grid_size, grid_size, grid_size)
-                
-                # Create isosurfaces using marching cubes
-                try:
-                    from skimage import measure
-                    
-                    # HOMO positive isosurface
-                    iso_val = 0.03
-                    if np.abs(homo_grid).max() > iso_val:
-                        verts, faces, _, _ = measure.marching_cubes(homo_grid, level=iso_val)
-                        
-                        # Scale vertices to actual coordinates
-                        verts_scaled = np.zeros_like(verts)
-                        verts_scaled[:, 0] = x_min + verts[:, 0] * (x_max - x_min) / (grid_size - 1)
-                        verts_scaled[:, 1] = y_min + verts[:, 1] * (y_max - y_min) / (grid_size - 1)
-                        verts_scaled[:, 2] = z_min + verts[:, 2] * (z_max - z_min) / (grid_size - 1)
-                        
-                        homo_pos_trace = go.Mesh3d(
-                            x=verts_scaled[:, 0],
-                            y=verts_scaled[:, 1],
-                            z=verts_scaled[:, 2],
-                            i=faces[:, 0],
-                            j=faces[:, 1],
-                            k=faces[:, 2],
-                            color='lightblue',
-                            opacity=0.4,
-                            name='HOMO (+)',
-                            hoverinfo='name'
-                        )
-                        data_traces.append(homo_pos_trace)
-                        
-                        # HOMO negative isosurface
-                        verts_neg, faces_neg, _, _ = measure.marching_cubes(homo_grid, level=-iso_val)
-                        
-                        verts_neg_scaled = np.zeros_like(verts_neg)
-                        verts_neg_scaled[:, 0] = x_min + verts_neg[:, 0] * (x_max - x_min) / (grid_size - 1)
-                        verts_neg_scaled[:, 1] = y_min + verts_neg[:, 1] * (y_max - y_min) / (grid_size - 1)
-                        verts_neg_scaled[:, 2] = z_min + verts_neg[:, 2] * (z_max - z_min) / (grid_size - 1)
-                        
-                        homo_neg_trace = go.Mesh3d(
-                            x=verts_neg_scaled[:, 0],
-                            y=verts_neg_scaled[:, 1],
-                            z=verts_neg_scaled[:, 2],
-                            i=faces_neg[:, 0],
-                            j=faces_neg[:, 1],
-                            k=faces_neg[:, 2],
-                            color='salmon',
-                            opacity=0.4,
-                            name='HOMO (-)',
-                            hoverinfo='name'
-                        )
-                        data_traces.append(homo_neg_trace)
-                        
-                except Exception as e:
-                    print(f"Isosurface generation failed: {e}")
-                    
+
+                # Skip if orbital is negligible (e.g., calculation failure)
+                if np.allclose(homo_values, 0):
+                    raise RuntimeError("HOMO values are all zero; orbital visualization unavailable")
+
+                iso_val = 0.03 * np.max(np.abs(homo_values))
+                iso_val = max(iso_val, 0.02)
+
+                orbital_trace = go.Isosurface(
+                    x=grid_points[:, 0],
+                    y=grid_points[:, 1],
+                    z=grid_points[:, 2],
+                    value=homo_values,
+                    isomin=-iso_val,
+                    isomax=iso_val,
+                    colorscale=[[0.0, '#ff6f69'], [0.5, '#ffffff'], [1.0, '#2176ff']],
+                    surface_count=2,
+                    opacity=0.45,
+                    caps=dict(x_show=False, y_show=False, z_show=False),
+                    name='HOMO orbital',
+                    showscale=False
+                )
+                data_traces.append(orbital_trace)
+
             except Exception as e:
                 print(f"Orbital calculation failed: {e}")
                 import traceback