removed RDkit and molgallery for display no going back and just using plotly by hand

app.py

@@ -57,6 +57,11 @@ import json
 import os
 import logging
 from logging.handlers import RotatingFileHandler
+import gradio as gr
+import numpy as np
+from quantum_utils import run_vqe_simulation
+from visualization import plot_convergence, create_molecule_viewer, format_molecule_params
+import plotly.graph_objects as go
 
 # Configure logging
 os.makedirs('logs', exist_ok=True)
@@ -134,13 +139,10 @@ def load_molecules():
         return {}
 
 # Now import the rest of the modules
-import gradio as gr
+print("about to import numpy and quantum_utils", file=sys.stderr, flush=True)
 import numpy as np
 from quantum_utils import run_vqe_simulation
 from visualization import plot_convergence, create_molecule_viewer, format_molecule_params
-from gradio_molgallery3d import MolGallery3D
-
-#Todo later add this working client stuff to fix timeouts client = Client("your-space", headers={"X-IP-Token": request.headers['x-ip-token']})
 
 # Add immediate logging
 print("Imported all modules successfully", file=sys.stderr, flush=True)
@@ -207,15 +209,12 @@ def create_interface():
     
     def set_client_for_session(request: gr.Request):
         """Initialize client with user's IP token to handle rate limiting."""
-        # from https://www.gradio.app/docs/python-client/using-zero-gpu-spaces
         try:
-            x_ip_token = request.headers['x-ip-token'] # 
+            x_ip_token = request.headers['x-ip-token']
             return Client("A19grey/Cuda-Quantum-Molecular-Playground", headers={"x-ip-token": x_ip_token})
         except Exception as e:
             logger.error(f"Error setting client: {e}")
             return None
-      
-    
 
     # Load available molecules
     molecules = load_molecules()
@@ -246,23 +245,20 @@ def create_interface():
         *Inspired by the [NVIDIA CUDA-Q VQE Example](https://nvidia.github.io/cuda-quantum/latest/applications/python/vqe_advanced.html)*
         """)
         
-        client = gr.State() # added this to fix timeouts - https://www.gradio.app/docs/python-client/using-zero-gpu-spaces
-
-        state = gr.State({})  # Store current molecule data
+        client = gr.State()
+        state = gr.State({})
         
         # Top section: 3 columns
         with gr.Row():
             with gr.Column(scale=1):
-                # Molecule selection controls
                 molecule_choice = gr.Dropdown(
                     choices=list(molecules.keys()),
-                    value=None,  # Start with no selection
+                    value=None,
                     label="Select Molecule",
                     interactive=True,
                     allow_custom_value=False
                 )
                 
-                # Get scale range from selected molecule
                 default_molecule = molecules[list(molecules.keys())[0]]
                 scale_factor = gr.Slider(
                     minimum=default_molecule['scale_range']['min'],
@@ -274,19 +270,15 @@ def create_interface():
                 )
             
             with gr.Column(scale=1):
-                # Molecule parameters display
                 params_display = gr.HTML(
                     label="Molecule Parameters",
                     value="<div>Select a molecule to view its parameters</div>"
                 )
             
             with gr.Column(scale=1):
-                # 3D Molecule Viewer (starts empty)
-                molecule_viz = MolGallery3D(
-                    columns=1,
-                    height=400,  # Reduced height to match other elements
+                molecule_viz = gr.Plot(
                     label="3D Molecule Viewer",
-                    automatic_rotation=True
+                    show_label=True
                 )
         
         # Middle section: Buttons and results in 2 columns
@@ -463,24 +455,22 @@ def create_interface():
                 step_size = mol_data.get('scale_range', {}).get('step', 0.05)
                 logger.debug(f"Scale parameters - min: {min_scale}, max: {max_scale}, default: {default_scale}")
                 
-                # Create molecule visualization
+                # Create molecule visualization using Plotly
                 logger.info(f"Creating molecule visualization for {molecule_choice}")
-                mol_list = create_molecule_viewer(molecule_choice, default_scale)
-                if mol_list is None or not mol_list:
+                mol_plot = create_molecule_viewer(molecule_choice, default_scale)
+                if mol_plot is None:
                     logger.error(f"No molecule visualization created for {molecule_choice}")
-                    mol_list = []
-                else:
-                    logger.info(f"Successfully created visualization with {len(mol_list)} molecules")
+                    mol_plot = go.Figure()  # Empty figure as fallback
                 
                 return [
-                    params_html,  # Update params display
-                    gr.update(    # Update slider
+                    params_html,
+                    gr.update(
                         minimum=min_scale,
                         maximum=max_scale,
                         value=default_scale,
                         step=step_size
                     ),
-                    mol_list  # Update 3D view
+                    mol_plot
                 ]
             except Exception as e:
                 logger.error(f"Error updating molecule info: {str(e)}", exc_info=True)
@@ -492,7 +482,7 @@ def create_interface():
                         value=1.0,
                         step=0.05
                     ),
-                    []  # Empty list for molecule visualization
+                    go.Figure()  # Empty figure as fallback
                 ]
         
         # Update parameters and 3D view when molecule changes

molecules.json

@@ -48,7 +48,104 @@
         ],
         "description": "Triatomic water molecule with bent geometry. Scale factor affects the overall size of the molecule."
     },
-    "CH4": {
+    "BeH2": {
+      "name": "Beryllium Hydride",
+      "enabled": 1,
+      "formula": "BeH₂",
+      "smiles": "[BeH2]",
+      "basis": "sto-3g",
+      "multiplicity": 1,
+      "charge": 0,
+      "spatial_orbitals": 7,
+      "electron_count": 4,
+      "default_scale": 1.0,
+      "GPU_time": 90,
+      "iterations": 20,
+      "scale_range": {
+        "min": 0.5,
+        "max": 2.0,
+        "step": 0.05
+      },
+      "geometry_template": [
+        ["Be", [0.0, 0.0, 0.0]],
+        ["H", [1.33, 0.0, 0.0]],
+        ["H", [-1.33, 0.0, 0.0]]
+      ],
+      "description": "Linear beryllium hydride molecule with two hydrogen atoms symmetrically bonded. Scale factor affects the bond length."
+    },
+    "NH": {
+      "name": "Nitrogen Monohydride",
+      "enabled": 1,
+      "formula": "NH",
+      "smiles": "[NH]",
+      "basis": "sto-3g",
+      "multiplicity": 2,
+      "charge": 0,
+      "spatial_orbitals": 6,
+      "electron_count": 8,
+      "default_scale": 1.0,
+      "GPU_time": 90,
+      "iterations": 20,
+      "scale_range": {
+        "min": 0.5,
+        "max": 2.5,
+        "step": 0.05
+      },
+      "geometry_template": [
+        ["N", [0.0, 0.0, 0.0]],
+        ["H", [1.03, 0.0, 0.0]]
+      ],
+      "description": "Diatomic nitrogen monohydride molecule, important in radical chemistry. Scale factor affects bond length."
+    },
+    "HF": {
+      "name": "Hydrogen Fluoride",
+      "enabled": 1,
+      "formula": "HF",
+      "smiles": "[FH]",
+      "basis": "sto-3g",
+      "multiplicity": 1,
+      "charge": 0,
+      "spatial_orbitals": 5,
+      "electron_count": 10,
+      "default_scale": 1.0,
+      "GPU_time": 90,
+      "iterations": 20,
+      "scale_range": {
+        "min": 0.5,
+        "max": 2.0,
+        "step": 0.05
+      },
+      "geometry_template": [
+        ["H", [0.0, 0.0, 0.0]],
+        ["F", [0.92, 0.0, 0.0]]
+      ],
+      "description": "Diatomic hydrogen fluoride molecule, a simple polar molecule with strong dipole interactions. Scale factor affects bond length."
+    },
+    "LiH": {
+      "name": "Lithium Hydride",
+      "enabled": 1,
+      "formula": "LiH",
+      "smiles": "[LiH]",
+      "basis": "sto-3g",
+      "multiplicity": 1,
+      "charge": 0,
+      "spatial_orbitals": 4,
+      "electron_count": 4,
+      "default_scale": 1.0,
+      "GPU_time": 90,
+      "iterations": 20,
+      "scale_range": {
+        "min": 0.5,
+        "max": 2.5,
+        "step": 0.05
+      },
+      "geometry_template": [
+        ["Li", [0.0, 0.0, 0.0]],
+        ["H", [1.6, 0.0, 0.0]]
+      ],
+      "description": "Diatomic lithium hydride molecule with ionic bonding properties. Scale factor affects bond length."
+    }
+    ,"CH4": {
         "name": "Methane",
         "enabled": 0,
         "formula": "CH₄",
@@ -77,7 +174,7 @@
     },
     "CO": {
         "name": "Carbon monoxide",
-        "enabled": 1,
+        "enabled": 0,
         "formula": "CO",
         "smiles": "[C-]#[O+]",
         "basis": "sto-3g",
@@ -101,7 +198,7 @@
     },
     "N2": {
         "name": "Nitrogen molecule",
-        "enabled": 1,
+        "enabled": 0,
         "formula": "N₂",
         "smiles": "N#N",
         "basis": "sto-3g",

requirements.txt

@@ -6,15 +6,13 @@ numpy==1.24.3
 scipy==1.10.1
 
 # Gradio and visualization components
-# gradio==4.44.1
-# gradio_client
-gradio_molgallery3d>=0.0.4
+gradio==4.44.1
+gradio_client
 
 # Plotting and visualization libraries
 plotly==5.18.0
 bokeh==3.2.2
 matplotlib==3.7.1
-rdkit==2023.09.1
 
 # ASE for molecular geometry handling
 ase==3.22.1

visualization.py

@@ -1,29 +1,70 @@
 """
 visualization.py
-Routines for plotting VQE results and molecular visualization using Plotly and MolGallery3D
+Routines for plotting VQE results and molecular visualization using Plotly
 """
 
 import plotly.graph_objects as go
 import numpy as np
 import logging
-from rdkit import Chem
-from rdkit.Chem import AllChem
-from gradio_molgallery3d import MolGallery3D
 import json
 
 # Configure logging
-logging.basicConfig(level=logging.DEBUG,
-                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-                   handlers=[
-                       logging.StreamHandler(),  # This will output to console
-                       logging.FileHandler('molecule_creation.log')  # This will output to file
-                   ])
+# Set root logger to DEBUG level
+logging.getLogger().setLevel(logging.DEBUG)
+
+# Configure module logger
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)  # Ensure logger itself is at DEBUG level
+logger.setLevel(logging.DEBUG)
+
+# Create handlers with DEBUG level
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+file_handler = logging.FileHandler('molecule_creation.log')
+file_handler.setLevel(logging.DEBUG)
+
+# Create and set formatter
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+console_handler.setFormatter(formatter)
+file_handler.setFormatter(formatter)
+
+# Add handlers to logger
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+# Atom display properties
+ATOM_COLORS = {
+    'H': '#E8E8E8',   # Light gray - more visible than pure white
+    'Be': '#42F5EC',  # Bright turquoise - stands out nicely
+    'Li': '#FF34B3',  # Hot pink - distinctive
+    'B': '#FFB347',   # Pastel orange
+    'C': '#808080',   # Classic gray for carbon
+    'N': '#4169E1',   # Royal blue - richer than pure blue
+    'O': '#FF4500',   # Orange red - more distinctive than pure red
+    'F': '#DAA520',   # Goldenrod - warmer than yellow
+    'Na': '#9370DB',  # Medium purple - softer than bright purple
+    'Mg': '#98FB98',  # Pale green - distinctive from beryllium
+    'Al': '#DDA0DD'   # Plum - distinctive pink/purple
+}
 
-# Force all handlers to DEBUG level
-for handler in logger.handlers:
-    handler.setLevel(logging.DEBUG)
+# Bond display properties
+BOND_STYLE = dict(
+    color='#2F4F4F',  # Dark slate gray - better contrast
+    width=8           # Thicker bonds
+)
+
+ATOM_SIZES = {
+    'H': 12,    # Smaller for hydrogen
+    'Be': 20,   # Medium for beryllium
+    'Li': 20,   # Medium for lithium
+    'B': 20,    # Medium for boron
+    'C': 16,    # Medium for carbon
+    'N': 16,    # Medium for nitrogen
+    'O': 16,    # Medium for oxygen
+    'F': 16,    # Medium for fluorine
+    'Na': 24,   # Larger for sodium
+    'Mg': 24,   # Larger for magnesium
+    'Al': 20    # Medium for aluminum
+}
 
 def format_molecule_params(molecule_data: dict) -> str:
     """
@@ -82,7 +123,6 @@ def plot_convergence(results):
     # Handle both dictionary entries and direct energy values
     for i, entry in enumerate(history):
         if isinstance(entry, dict):
-            # Handle dictionary format
             try:
                 iterations.append(entry.get('iteration', i))
                 energies.append(entry['energy'])
@@ -90,7 +130,6 @@ def plot_convergence(results):
                 logger.warning(f"Skipping invalid entry {i}: {str(e)}")
                 continue
         else:
-            # Handle direct energy values
             try:
                 iterations.append(i)
                 energies.append(float(entry))
@@ -146,16 +185,16 @@ def plot_convergence(results):
     
     return fig
 
-def create_molecule_viewer(molecule_id: str, scale_factor: float) -> MolGallery3D:
+def create_molecule_viewer(molecule_id: str, scale_factor: float) -> go.Figure:
     """
-    Create a 3D visualization of the molecule using MolGallery3D and RDKit.
-    For better visualization, hydrogen atoms are replaced with nitrogen atoms in the display only.
-    The actual quantum calculations still use the real molecule structure.
-    Atoms are displayed as spheres with explicit bonds between them.
+    Create a 3D visualization of the molecule using Plotly.
+    Uses geometry templates from molecules.json for accurate atomic positions.
     
     Args:
         molecule_id: Molecule identifier (e.g., "H2")
         scale_factor: Bond length scaling factor (1.0 = original size)
+    Returns:
+        Plotly Figure object with 3D molecule visualization
     """
     logger.info(f"Creating 3D view for {molecule_id} with scale_factor={scale_factor}")
     
@@ -169,147 +208,83 @@ def create_molecule_viewer(molecule_id: str, scale_factor: float) -> MolGallery3
             return None
         
         molecule_data = molecules[molecule_id]
-        logger.debug(f"Molecule data loaded: {molecule_data}")
-        
-        # Special handling for different molecules
-        mol = None
-        if molecule_id == "H2":
-            logger.debug("Creating H2 molecule (visualized as N2)")
-            # Create N2 for visualization instead of H2
-            mol = Chem.RWMol()
-            n1 = mol.AddAtom(Chem.Atom(7))  # Add first N atom
-            n2 = mol.AddAtom(Chem.Atom(7))  # Add second N atom
-            mol.AddBond(n1, n2, Chem.BondType.SINGLE)  # Add single bond
-            mol = mol.GetMol()
-            Chem.SanitizeMol(mol)
-            logger.debug(f"N2 (for H2 viz) creation result: {mol is not None}")
-            
-        elif molecule_id == "H2O":
-            logger.debug("Creating H2O molecule (visualized with N instead of H)")
-            # Create H2O using RWMol but with N instead of H
-            mol = Chem.RWMol()
-            
-            # Add atoms with explicit valence
-            o = mol.AddAtom(Chem.Atom(8))  # Oxygen
-            oxygen = mol.GetAtomWithIdx(o)
-            oxygen.SetFormalCharge(0)
-            oxygen.SetNoImplicit(True)
-            
-            n1 = mol.AddAtom(Chem.Atom(7))  # First nitrogen (replacing H)
-            n1_atom = mol.GetAtomWithIdx(n1)
-            n1_atom.SetFormalCharge(0)
-            n1_atom.SetNoImplicit(True)
-            
-            n2 = mol.AddAtom(Chem.Atom(7))  # Second nitrogen (replacing H)
-            n2_atom = mol.GetAtomWithIdx(n2)
-            n2_atom.SetFormalCharge(0)
-            n2_atom.SetNoImplicit(True)
-            
-            # Add bonds
-            mol.AddBond(o, n1, Chem.BondType.SINGLE)
-            mol.AddBond(o, n2, Chem.BondType.SINGLE)
-            
-            # Convert to immutable molecule and sanitize
-            mol = mol.GetMol()
-            Chem.SanitizeMol(mol)
-            logger.debug(f"H2O (with N) creation result: {mol is not None}")
-            
-        else:
-            # For other molecules, create from SMILES but replace H with N
-            logger.debug(f"Creating molecule from SMILES: {molecule_data['smiles']}")
-            mol = Chem.MolFromSmiles(molecule_data['smiles'])
-            logger.debug(f"Initial molecule creation result: {mol is not None}")
-            if mol is not None:
-                # Replace explicit hydrogens with nitrogen
-                mol = Chem.RWMol(mol)
-                for atom in mol.GetAtoms():
-                    if atom.GetSymbol() == 'H':
-                        atom.SetAtomicNum(7)  # Change to nitrogen
-                mol = mol.GetMol()
-                Chem.SanitizeMol(mol)
-                logger.debug(f"Molecule with N replacing H result: {mol is not None}")
-        
-        if mol is None:
-            logger.error(f"Failed to create molecule for {molecule_id}")
+        if 'geometry_template' not in molecule_data:
+            logger.error(f"No geometry template found for {molecule_id}")
             return None
             
-        logger.debug(f"Molecule created with {mol.GetNumAtoms()} atoms")
-        for atom in mol.GetAtoms():
-            # Calculate valence before checking hydrogens
-            atom.UpdatePropertyCache()
-            logger.debug(f"Atom {atom.GetIdx()}: Symbol={atom.GetSymbol()}, " +
-                        f"Valence={atom.GetTotalValence()}")
+        geometry = molecule_data['geometry_template']
         
-        # Log bond information
-        logger.debug(f"Number of bonds: {mol.GetNumBonds()}")
-        for bond in mol.GetBonds():
-            logger.debug(f"Bond between {bond.GetBeginAtom().GetSymbol()}{bond.GetBeginAtomIdx()} and " +
-                        f"{bond.GetEndAtom().GetSymbol()}{bond.GetEndAtomIdx()}, type: {bond.GetBondType()}")
-            
-        # Generate 3D coordinates with distance matrix
-        try:
-            logger.debug("Attempting to generate 3D coordinates")
-            # Use geometry template if available
-            if 'geometry_template' in molecule_data:
-                logger.debug("Using geometry template for 3D coordinates")
-                conf = Chem.Conformer(mol.GetNumAtoms())
-                for i, (atom_symbol, coords) in enumerate(molecule_data['geometry_template']):
-                    # Scale coordinates by the scale factor
-                    scaled_coords = np.array(coords) * scale_factor
-                    conf.SetAtomPosition(i, scaled_coords)
-                mol.AddConformer(conf)
-                result = 0  # Template-based embedding always succeeds
-            else:
-                result = AllChem.EmbedMolecule(mol, randomSeed=42)
-                
-            logger.debug(f"3D coordinate generation result (0=success, -1=failure): {result}")
-            
-            if result == -1:
-                logger.debug("Standard embedding failed, trying with ETKDGv2")
-                params = AllChem.ETKDGv2()
-                result = AllChem.EmbedMolecule(mol, params, randomSeed=42)
-                logger.debug(f"ETKDGv2 embedding result: {result}")
-            
-            if result == -1:
-                logger.error("Failed to generate 3D coordinates")
-                return None
-            
-            # Scale the molecule coordinates if not using template
-            if 'geometry_template' not in molecule_data:
-                conf = mol.GetConformer()
-                positions = conf.GetPositions()
-                logger.debug(f"Generated 3D coordinates:\n{positions}")
-                centroid = np.mean(positions, axis=0)
-                logger.debug(f"Molecule centroid: {centroid}")
-                
-                for i in range(mol.GetNumAtoms()):
-                    pos = positions[i]
-                    scaled_pos = centroid + (pos - centroid) * scale_factor
-                    conf.SetAtomPosition(i, scaled_pos)
-                    logger.debug(f"Atom {i} ({mol.GetAtomWithIdx(i).GetSymbol()}) scaled position: {scaled_pos}")
-            
-            logger.info(f"Successfully created 3D coordinates for {molecule_id}")
-            
-            # Verify final state
-            logger.debug("Final molecule state:")
-            logger.debug(f"Number of atoms: {mol.GetNumAtoms()}")
-            logger.debug(f"Number of bonds: {mol.GetNumBonds()}")
-            logger.debug(f"Has conformer: {mol.GetNumConformers() > 0}")
-            
-            # Final sanitization check
-            Chem.SanitizeMol(mol)
-            
-            # Set RDKit display properties for ball-and-stick appearance
-            for atom in mol.GetAtoms():
-                atom.SetProp('molAtomMapNumber', str(atom.GetIdx()))  # This helps with atom visibility
-            
-            # Return the molecule as a list as expected by MolGallery3D
-            return [mol]
+        # Extract atomic positions and symbols
+        symbols = [atom[0] for atom in geometry]
+        positions = np.array([atom[1] for atom in geometry]) * scale_factor
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add atoms as spheres
+        for symbol, pos in zip(symbols, positions):
+            color = ATOM_COLORS.get(symbol, '#808080')  # Default gray if not specified
+            size = ATOM_SIZES.get(symbol, 20)  # Default size if not specified
             
-        except Exception as e:
-            logger.error(f"Failed to generate 3D coordinates: {e}", exc_info=True)
-            return None
+            fig.add_trace(go.Scatter3d(
+                x=[pos[0]],
+                y=[pos[1]],
+                z=[pos[2]],
+                mode='markers+text',
+                marker=dict(
+                    size=size,
+                    color=color,
+                    symbol='circle',
+                    line=dict(color='black', width=1)
+                ),
+                text=[symbol],
+                textposition='middle center',
+                name=symbol,
+                hoverinfo='name',
+                showlegend=False
+            ))
         
+        # Add bonds between atoms
+        for i in range(len(symbols)):
+            for j in range(i + 1, len(symbols)):
+                # Calculate distance between atoms
+                dist = np.linalg.norm(positions[i] - positions[j])
+                # Add bond if atoms are close enough (adjust threshold as needed)
+                if dist < 2.5 * scale_factor:  # Typical bond length is ~1-1.5 Å
+                    # Create line between atoms
+                    fig.add_trace(go.Scatter3d(
+                        x=[positions[i][0], positions[j][0]],
+                        y=[positions[i][1], positions[j][1]],
+                        z=[positions[i][2], positions[j][2]],
+                        mode='lines',
+                        line=BOND_STYLE,
+                        hoverinfo='none',
+                        showlegend=False
+                    ))
+        
+        # Update layout for better visualization
+        fig.update_layout(
+            scene=dict(
+                aspectmode='data',  # Preserve actual molecular geometry
+                xaxis=dict(showspikes=False, showbackground=False, showticklabels=False, title=''),
+                yaxis=dict(showspikes=False, showbackground=False, showticklabels=False, title=''),
+                zaxis=dict(showspikes=False, showbackground=False, showticklabels=False, title=''),
+                camera=dict(
+                    up=dict(x=0, y=1, z=0),
+                    center=dict(x=0, y=0, z=0),
+                    eye=dict(x=1.5, y=1.5, z=1.5)
+                )
+            ),
+            margin=dict(l=0, r=0, t=0, b=0),
+            showlegend=False,
+            width=400,
+            height=400,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)'
+        )
+        
+        return fig
+            
     except Exception as e:
         logger.error(f"Failed to create molecule viewer: {e}", exc_info=True)
         return None