I can't draw water molecule but giving up for now

app.py

@@ -52,6 +52,21 @@ import subprocess
 import sys
 import json
 import os
+import logging
+
+# 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('app_molecule.log')  # This will output to file
+                   ])
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)  # Ensure logger itself is at DEBUG level
+
+# Force all handlers to DEBUG level
+for handler in logger.handlers:
+    handler.setLevel(logging.DEBUG)
 
 def install_dependencies():
     """Install required packages from requirements.txt."""
@@ -304,22 +319,28 @@ def create_interface():
         def update_molecule_info(molecule_choice):
             """Update description and scale range when molecule is selected."""
             try:
+                logger.info(f"Updating molecule info for: {molecule_choice}")
                 mol_data = molecules[molecule_choice]
                 
                 # Format parameters display
                 params_html = format_molecule_params(mol_data)
+                logger.debug(f"Generated parameter HTML for {molecule_choice}")
                 
                 # Get scale range values with defaults
                 min_scale = mol_data.get('scale_range', {}).get('min', 0.1)
                 max_scale = mol_data.get('scale_range', {}).get('max', 3.0)
                 default_scale = mol_data.get('default_scale', 1.0)
                 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
+                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:
-                    print(f"No molecule visualization created for {molecule_choice}", file=sys.stderr)
+                    logger.error(f"No molecule visualization created for {molecule_choice}")
                     mol_list = []
+                else:
+                    logger.info(f"Successfully created visualization with {len(mol_list)} molecules")
                 
                 return [
                     params_html,  # Update params display
@@ -332,7 +353,7 @@ def create_interface():
                     mol_list  # Update 3D view
                 ]
             except Exception as e:
-                print(f"Error updating molecule info: {e}", file=sys.stderr)
+                logger.error(f"Error updating molecule info: {str(e)}", exc_info=True)
                 return [
                     "<div>Error loading molecule parameters</div>",
                     gr.update(

history.md

@@ -1,5 +1,19 @@
 # Development History
 
+## 2024-01-06 (Update 10)
+- Extensive debugging of molecule visualization issues:
+  * Added comprehensive logging to track molecule creation and visualization
+  * Modified RDKit molecule creation to handle hydrogens explicitly
+  * Attempted multiple approaches for H2O and H2 creation:
+    - Direct SMILES parsing
+    - RWMol with explicit atom and bond creation
+    - Geometry template-based coordinate generation
+  * Added proper valence calculation and sanitization
+  * Added explicit bond creation and verification
+  * Issue remains unresolved: H-containing molecules (H2, H2O, etc.) fail to display
+  * Non-H molecules (CO, N2) display correctly
+  * Next steps: Consider alternative visualization approaches or different molecule viewer component
+
 ## 2024-03-20
 - Split VQE simulation into two steps:
   * Added "Generate Hamiltonian" button to first compute and display Hamiltonian parameters

molecules.json

@@ -2,7 +2,7 @@
     "H2": {
         "name": "Hydrogen molecule",
         "formula": "H₂",
-        "smiles": "[H][H]",
+        "smiles": "[HH]",
         "basis": "sto-3g",
         "multiplicity": 1,
         "charge": 0,

visualization.py

@@ -12,8 +12,18 @@ 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
+                   ])
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
+logger.setLevel(logging.DEBUG)  # Ensure logger itself is at DEBUG level
+
+# Force all handlers to DEBUG level
+for handler in logger.handlers:
+    handler.setLevel(logging.DEBUG)
 
 def format_molecule_params(molecule_data: dict) -> str:
     """
@@ -153,48 +163,140 @@ 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":
-            mol = Chem.MolFromSmiles("[H][H]")
-            if mol is None:
-                mol = Chem.MolFromSmiles("[HH]")  # Alternative SMILES for H2
+            logger.debug("Creating H2 molecule")
+            # Create H2 using RWMol for explicit control
+            mol = Chem.RWMol()
+            h1 = mol.AddAtom(Chem.Atom(1))  # Add first H atom
+            h2 = mol.AddAtom(Chem.Atom(1))  # Add second H atom
+            mol.AddBond(h1, h2, Chem.BondType.SINGLE)  # Add single bond
+            mol = mol.GetMol()
+            Chem.SanitizeMol(mol)
+            logger.debug(f"H2 creation result: {mol is not None}")
+            
         elif molecule_id == "H2O":
-            mol = Chem.MolFromSmiles("O")
-            mol = Chem.AddHs(mol)
+            logger.debug("Creating H2O molecule")
+            # Create H2O using RWMol for explicit control
+            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)
+            
+            h1 = mol.AddAtom(Chem.Atom(1))  # First hydrogen
+            h1_atom = mol.GetAtomWithIdx(h1)
+            h1_atom.SetFormalCharge(0)
+            h1_atom.SetNoImplicit(True)
+            
+            h2 = mol.AddAtom(Chem.Atom(1))  # Second hydrogen
+            h2_atom = mol.GetAtomWithIdx(h2)
+            h2_atom.SetFormalCharge(0)
+            h2_atom.SetNoImplicit(True)
+            
+            # Add bonds
+            mol.AddBond(o, h1, Chem.BondType.SINGLE)
+            mol.AddBond(o, h2, Chem.BondType.SINGLE)
+            
+            # Convert to immutable molecule and sanitize
+            mol = mol.GetMol()
+            Chem.SanitizeMol(mol)
+            logger.debug(f"H2O creation result: {mol is not None}")
+            
         else:
             # Create molecule using SMILES
+            logger.debug(f"Creating molecule from SMILES: {molecule_data['smiles']}")
             mol = Chem.MolFromSmiles(molecule_data['smiles'])
-            if mol is None:
-                logger.error(f"Could not create molecule from SMILES: {molecule_data['smiles']}")
-                return None
-            mol = Chem.AddHs(mol)
+            logger.debug(f"Initial molecule creation result: {mol is not None}")
+            if mol is not None:
+                logger.debug("Adding hydrogens to molecule")
+                mol = Chem.AddHs(mol)
+                Chem.SanitizeMol(mol)
+                logger.debug(f"Molecule with hydrogens result: {mol is not None}")
         
         if mol is None:
             logger.error(f"Failed to create molecule 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"Explicit Hs={atom.GetNumExplicitHs()}, " +
+                        f"Implicit Hs={atom.GetNumImplicitHs()}, " +
+                        f"Valence={atom.GetTotalValence()}")
+        
+        # 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:
-            AllChem.EmbedMolecule(mol, randomSeed=42)
+            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, (_, 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: {result}")  # 0 means success, -1 means failure
+            
+            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}")
             
-            # Scale the molecule coordinates
-            conf = mol.GetConformer()
-            positions = conf.GetPositions()
-            centroid = np.mean(positions, axis=0)
+            if result == -1:
+                logger.error("Failed to generate 3D coordinates")
+                return None
             
-            for i in range(mol.GetNumAtoms()):
-                pos = positions[i]
-                scaled_pos = centroid + (pos - centroid) * scale_factor
-                conf.SetAtomPosition(i, scaled_pos)
+            # 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)
+            
             return [mol]  # Return the molecule as a list as expected by MolGallery3D
             
         except Exception as e:
-            logger.error(f"Failed to generate 3D coordinates: {e}")
+            logger.error(f"Failed to generate 3D coordinates: {e}", exc_info=True)
             return None
         
     except Exception as e:
-        logger.error(f"Failed to create molecule viewer: {e}")
+        logger.error(f"Failed to create molecule viewer: {e}", exc_info=True)
         return None