Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import torch | |
| import numpy as np | |
| import tempfile | |
| import os | |
| from ase.io import read | |
| from ase import units | |
| from ase.optimize import LBFGS | |
| from ase.md.verlet import VelocityVerlet | |
| from ase.md.velocitydistribution import MaxwellBoltzmannDistribution | |
| from ase.io.trajectory import Trajectory | |
| import py3Dmol | |
| from orb_models.forcefield import pretrained | |
| from orb_models.forcefield.calculator import ORBCalculator | |
| # ----------------------------- | |
| # Global OrbMol model | |
| # ----------------------------- | |
| model_calc = None | |
| def load_orbmol_model(): | |
| """Load OrbMol model once""" | |
| global model_calc | |
| if model_calc is None: | |
| try: | |
| print("Loading OrbMol model...") | |
| orbff = pretrained.orb_v3_conservative_inf_omat( | |
| device="cpu", | |
| precision="float32-high" | |
| ) | |
| model_calc = ORBCalculator(orbff, device="cpu") | |
| print("✅ OrbMol model loaded successfully") | |
| except Exception as e: | |
| print(f"❌ Error loading model: {e}") | |
| model_calc = None | |
| return model_calc | |
| # ----------------------------- | |
| # Single-point calculation | |
| # ----------------------------- | |
| def predict_molecule(xyz_content, charge=0, spin_multiplicity=1): | |
| try: | |
| calc = load_orbmol_model() | |
| if calc is None: | |
| return "❌ Error: Could not load OrbMol model", "" | |
| if not xyz_content.strip(): | |
| return "❌ Error: Please enter XYZ coordinates", "" | |
| with tempfile.NamedTemporaryFile(mode='w', suffix='.xyz', delete=False) as f: | |
| f.write(xyz_content) | |
| xyz_file = f.name | |
| atoms = read(xyz_file) | |
| atoms.info = {"charge": int(charge), "spin": int(spin_multiplicity)} | |
| atoms.calc = calc | |
| energy = atoms.get_potential_energy() | |
| forces = atoms.get_forces() | |
| result = f"🔋 **Total Energy**: {energy:.6f} eV\n\n⚡ **Atomic Forces**:\n" | |
| for i, f in enumerate(forces): | |
| result += f"Atom {i+1}: [{f[0]:.4f}, {f[1]:.4f}, {f[2]:.4f}] eV/Å\n" | |
| max_force = np.max(np.linalg.norm(forces, axis=1)) | |
| result += f"\n📊 **Max Force**: {max_force:.4f} eV/Å" | |
| os.unlink(xyz_file) | |
| return result, "✅ Calculation completed with OrbMol" | |
| except Exception as e: | |
| return f"❌ Error during calculation: {str(e)}", "Error" | |
| # ----------------------------- | |
| # Trajectory → HTML for Gradio | |
| # ----------------------------- | |
| def traj_to_html(traj_file): | |
| traj = Trajectory(traj_file) | |
| view = py3Dmol.view(width=400, height=400) | |
| for atoms in traj: | |
| symbols = atoms.get_chemical_symbols() | |
| xyz = atoms.get_positions() | |
| mol = "" | |
| for s, (x, y, z) in zip(symbols, xyz): | |
| mol += f"{s} {x} {y} {z}\n" | |
| view.addModel(mol, "xyz") | |
| view.setStyle({"stick": {}}) | |
| view.zoomTo() | |
| view.animate({"loop": "forward"}) | |
| return view.render() # ✅ en Gradio funciona mejor que _make_html() | |
| # ----------------------------- | |
| # MD simulation | |
| # ----------------------------- | |
| def run_md(xyz_content, charge=0, spin_multiplicity=1, steps=100, temperature=300, timestep=1.0): | |
| try: | |
| calc = load_orbmol_model() | |
| if calc is None: | |
| return "❌ Error: Could not load OrbMol model", "" | |
| if not xyz_content.strip(): | |
| return "❌ Error: Please enter XYZ coordinates", "" | |
| with tempfile.NamedTemporaryFile(mode='w', suffix='.xyz', delete=False) as f: | |
| f.write(xyz_content) | |
| xyz_file = f.name | |
| atoms = read(xyz_file) | |
| atoms.info = {"charge": int(charge), "spin": int(spin_multiplicity)} | |
| atoms.calc = calc | |
| # Pre-relax | |
| opt = LBFGS(atoms) | |
| opt.run(fmax=0.05, steps=20) | |
| # Initialize velocities | |
| MaxwellBoltzmannDistribution(atoms, temperature_K=2 * temperature) | |
| # MD setup | |
| dyn = VelocityVerlet(atoms, timestep=timestep * units.fs) | |
| traj_file = tempfile.NamedTemporaryFile(suffix=".traj", delete=False) | |
| traj = Trajectory(traj_file.name, "w", atoms) | |
| dyn.attach(traj.write, interval=1) | |
| dyn.run(steps) | |
| html = traj_to_html(traj_file.name) | |
| os.unlink(xyz_file) | |
| return f"✅ MD completed: {steps} steps at {temperature} K", html | |
| except Exception as e: | |
| return f"❌ Error during MD simulation: {str(e)}", "" | |
| # ----------------------------- | |
| # Examples | |
| # ----------------------------- | |
| examples = [ | |
| ["""2 | |
| Hydrogen molecule | |
| H 0.0 0.0 0.0 | |
| H 0.0 0.0 0.74""", 0, 1], | |
| ["""3 | |
| Water molecule | |
| O 0.0000 0.0000 0.0000 | |
| H 0.7571 0.0000 0.5864 | |
| H -0.7571 0.0000 0.5864""", 0, 1], | |
| ["""5 | |
| Methane | |
| C 0.0000 0.0000 0.0000 | |
| H 1.0890 0.0000 0.0000 | |
| H -0.3630 1.0267 0.0000 | |
| H -0.3630 -0.5133 0.8887 | |
| H -0.3630 -0.5133 -0.8887""", 0, 1] | |
| ] | |
| # ----------------------------- | |
| # Gradio UI | |
| # ----------------------------- | |
| with gr.Blocks(theme=gr.themes.Ocean(), title="OrbMol + MD Demo") as demo: | |
| with gr.Tab("Single Point Energy"): | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| with gr.Column(variant="panel"): | |
| gr.Markdown("# OrbMol Demo - Quantum-Accurate Molecular Predictions") | |
| xyz_input = gr.Textbox( | |
| label="XYZ Coordinates", lines=12, | |
| placeholder="Paste XYZ here" | |
| ) | |
| with gr.Row(): | |
| charge_input = gr.Slider(value=0, label="Charge", minimum=-10, maximum=10, step=1) | |
| spin_input = gr.Slider(value=1, maximum=11, minimum=1, step=1, label="Spin Multiplicity") | |
| run_btn = gr.Button("Run OrbMol Prediction", variant="primary", size="lg") | |
| with gr.Column(variant="panel", min_width=500): | |
| gr.Markdown("## Results") | |
| results_output = gr.Textbox(label="Energy & Forces", lines=15, interactive=False) | |
| status_output = gr.Textbox(label="Status", interactive=False, max_lines=1) | |
| gr.Examples(examples=examples, inputs=[xyz_input, charge_input, spin_input]) | |
| run_btn.click( | |
| predict_molecule, | |
| inputs=[xyz_input, charge_input, spin_input], | |
| outputs=[results_output, status_output] | |
| ) | |
| with gr.Tab("Molecular Dynamics"): | |
| xyz_input_md = gr.Textbox(label="XYZ Coordinates", lines=12) | |
| charge_input_md = gr.Slider(value=0, minimum=-10, maximum=10, step=1, label="Charge") | |
| spin_input_md = gr.Slider(value=1, minimum=1, maximum=11, step=1, label="Spin Multiplicity") | |
| steps_input = gr.Slider(value=100, minimum=10, maximum=1000, step=10, label="Steps") | |
| temp_input = gr.Slider(value=300, minimum=10, maximum=1000, step=10, label="Temperature (K)") | |
| timestep_input = gr.Slider(value=1.0, minimum=0.1, maximum=5.0, step=0.1, label="Timestep (fs)") | |
| run_md_btn = gr.Button("Run MD Simulation", variant="primary") | |
| md_status = gr.Textbox(label="MD Status", lines=2) | |
| md_view = gr.HTML() | |
| run_md_btn.click( | |
| run_md, | |
| inputs=[xyz_input_md, charge_input_md, spin_input_md, steps_input, temp_input, timestep_input], | |
| outputs=[md_status, md_view], | |
| ) | |
| print("🚀 Starting OrbMol model loading...") | |
| load_orbmol_model() | |
| if __name__ == "__main__": | |
| demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True) | |