Update app.py

app.py

@@ -17,63 +17,45 @@ except ImportError as e:
     MOLECULE3D_AVAILABLE = False
     print(f"❌ gradio_molecule3d import failed: {e}")
 
-# ==== Debug function ====
-def debug_pdb_creation(traj_path):
-    """Debug PDB creation step by step"""
-    print(f"\n=== DEBUG PDB CREATION ===")
-    print(f"Input trajectory: {traj_path}")
-    print(f"Trajectory exists: {os.path.exists(traj_path) if traj_path else False}")
-    
-    if not traj_path or not os.path.exists(traj_path):
-        return None, "No trajectory file"
-    
+# ==== PDB creation for Molecule3D ====
+def create_pdb_for_molecule3d(atoms):
+    """Create a PDB file specifically for Molecule3D viewer"""
     try:
-        # Step 1: Read trajectory
-        traj = Trajectory(traj_path)
-        print(f"Trajectory frames: {len(traj)}")
-        
-        if len(traj) == 0:
-            return None, "Empty trajectory"
-        
-        # Step 2: Get atoms
-        atoms = traj[-1]
-        print(f"Atoms count: {len(atoms)}")
-        print(f"Chemical symbols: {atoms.get_chemical_symbols()[:5]}...")  # First 5
-        
-        # Step 3: Create cache directory
-        cache_dir = os.path.join(tempfile.gettempdir(), "gradio_cache")
+        # Create gradio cache directory  
+        cache_dir = os.path.join(tempfile.gettempdir(), "gradio")
         os.makedirs(cache_dir, exist_ok=True)
         print(f"Cache directory: {cache_dir}")
-        print(f"Cache dir exists: {os.path.exists(cache_dir)}")
         
-        # Step 4: Create unique filename
-        unique_id = hashlib.md5(str(traj_path).encode()).hexdigest()[:12]
-        pdb_filename = f"mol_{unique_id}.pdb"
+        # Create unique filename based on atomic positions
+        pos_hash = hashlib.md5(atoms.get_positions().tobytes()).hexdigest()[:12]
+        pdb_filename = f"mol_{pos_hash}.pdb"
         pdb_path = os.path.join(cache_dir, pdb_filename)
-        print(f"Target PDB path: {pdb_path}")
+        print(f"Creating PDB: {pdb_path}")
         
-        # Step 5: Write PDB
+        # Write PDB file using ASE
         write(pdb_path, atoms, format='pdb')
-        print(f"PDB written, exists: {os.path.exists(pdb_path)}")
         
+        # Verify file was created and has content
         if os.path.exists(pdb_path):
             file_size = os.path.getsize(pdb_path)
-            print(f"PDB file size: {file_size} bytes")
+            print(f"PDB created successfully: {file_size} bytes")
             
-            # Read first few lines
+            # Read and log first few lines for verification
             with open(pdb_path, 'r') as f:
-                first_lines = f.read(300)
-                print(f"PDB content preview:\n{first_lines}")
+                first_lines = f.read(200)
+                print(f"PDB preview: {first_lines[:100]}...")
             
-            return pdb_path, f"Success: {file_size} bytes"
-        else:
-            return None, "PDB file not created"
+            if file_size > 0:
+                return pdb_path
+        
+        print("PDB file was not created or is empty")
+        return None
             
     except Exception as e:
-        print(f"Exception in debug_pdb_creation: {e}")
+        print(f"Error creating PDB for Molecule3D: {e}")
         import traceback
         traceback.print_exc()
-        return None, f"Error: {e}"
+        return None
 
 # ==== Simple molecule viewer using HTML + 3Dmol.js ====
 def create_simple_molecule_viewer(atoms_or_pdb_path, viewer_id="mol_viewer"):
@@ -177,6 +159,33 @@ def _load_orbmol_calc():
         _MODEL_CALC = ORBCalculator(orbff, device="cpu")
     return _MODEL_CALC
 
+def create_pdb_for_molecule3d(atoms):
+    """Create a PDB file specifically for Molecule3D viewer"""
+    try:
+        # Create gradio cache directory
+        cache_dir = os.path.join(tempfile.gettempdir(), "gradio")
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        # Create unique filename
+        unique_id = hashlib.md5(str(atoms.get_positions().tostring()).encode()).hexdigest()[:12]
+        pdb_filename = f"mol_{unique_id}.pdb"
+        pdb_path = os.path.join(cache_dir, pdb_filename)
+        
+        # Write PDB file
+        write(pdb_path, atoms, format='pdb')
+        
+        # Verify file was created
+        if os.path.exists(pdb_path) and os.path.getsize(pdb_path) > 0:
+            print(f"✅ PDB created for Molecule3D: {pdb_path} ({os.path.getsize(pdb_path)} bytes)")
+            return pdb_path
+        else:
+            print("❌ PDB file was not created properly")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Error creating PDB: {e}")
+        return None
+
 def predict_molecule(structure_file, charge=0, spin_multiplicity=1):
     """Single Point Energy + fuerzas (OrbMol)"""
     try:
@@ -205,18 +214,25 @@ def predict_molecule(structure_file, charge=0, spin_multiplicity=1):
         max_force = float(np.max(np.linalg.norm(forces, axis=1)))
         lines += ["", f"Max Force: {max_force:.4f} eV/Å"]
 
-        # Debug info
-        debug_info = f"Molecule: {len(atoms)} atoms, symbols: {', '.join(set(atoms.get_chemical_symbols()))}"
+        # Create debug info
+        symbols = atoms.get_chemical_symbols()
+        debug_info = f"Molecule: {len(atoms)} atoms\nElements: {', '.join(set(symbols))}\nFormula: {''.join(sorted(symbols))}"
         
         # Create viewer
         if MOLECULE3D_AVAILABLE:
-            pdb_path, debug_msg = debug_pdb_creation(None)  # We'll create from atoms directly
-            return "\n".join(lines), "Calculation completed with OrbMol", debug_info + f"\nDebug: {debug_msg}", pdb_path
+            pdb_path = create_pdb_for_molecule3d(atoms)
+            if pdb_path:
+                debug_info += f"\nPDB created: ✅ {os.path.basename(pdb_path)}"
+            else:
+                debug_info += f"\nPDB creation: ❌ Failed"
+            return "\n".join(lines), "Calculation completed with OrbMol", debug_info, pdb_path
         else:
             html_viewer = create_simple_molecule_viewer(atoms, f"spe_viewer_{hash(file_path) % 10000}")
             return "\n".join(lines), "Calculation completed with OrbMol", debug_info, html_viewer
     except Exception as e:
         error_msg = f"Error during calculation: {e}"
+        import traceback
+        traceback.print_exc()
         return error_msg, "Error", str(e), None if MOLECULE3D_AVAILABLE else ""
 
 # ==== Simulaciones ====
@@ -248,9 +264,26 @@ def md_wrapper(structure_file, charge, spin, steps, tempK, timestep_fs, ensemble
         print(f"MD completed, trajectory: {traj_path}")
         
         if MOLECULE3D_AVAILABLE:
-            pdb_path, debug_msg = debug_pdb_creation(traj_path)
-            debug_info = f"Trajectory: {traj_path}\nDebug: {debug_msg}"
-            return (status, traj_path, log_text, script_text, explanation, pdb_path, debug_info)
+            # Read last frame from trajectory
+            try:
+                traj = Trajectory(traj_path)
+                last_atoms = traj[-1]
+                print(f"Read trajectory: {len(traj)} frames, last frame has {len(last_atoms)} atoms")
+                
+                pdb_path = create_pdb_for_molecule3d(last_atoms)
+                
+                debug_info = f"Trajectory: {len(traj)} frames\nLast frame: {len(last_atoms)} atoms"
+                if pdb_path:
+                    debug_info += f"\nPDB: ✅ {os.path.basename(pdb_path)}"
+                else:
+                    debug_info += f"\nPDB: ❌ Creation failed"
+                    
+                return (status, traj_path, log_text, script_text, explanation, pdb_path, debug_info)
+                
+            except Exception as traj_error:
+                print(f"Error reading trajectory: {traj_error}")
+                debug_info = f"Trajectory error: {traj_error}"
+                return (status, traj_path, log_text, script_text, explanation, None, debug_info)
         else:
             # Create HTML viewer from last frame
             traj = Trajectory(traj_path)