Update src/streamlit_app.py

src/streamlit_app.py

@@ -615,7 +615,7 @@ st.set_page_config(
 
 # Title and description
 st.markdown('## MLIP Playground', unsafe_allow_html=True)
-st.write('#### Run, test and compare 22 state-of-the-art universal machine learning interatomic potentials (MLIPs) for atomistic simulations of molecules and materials')
+st.write('#### Run, test and compare 38 state-of-the-art universal machine learning interatomic potentials (MLIPs) for atomistic simulations of molecules and materials')
 st.markdown('Upload molecular structure files or select from predefined examples, then compute energies and forces using foundation models such as those from MACE or FairChem (Meta).', unsafe_allow_html=True)
 
 # Create a directory for sample structures if it doesn't exist
@@ -1604,6 +1604,69 @@ if atoms is not None:
                                 mime="chemical/x-xyz"
                             )
                         show_optimized_structure_download_button()
+                        # --- Energy vs. Optimization Cycles Plot ---
+                        @st.fragment
+                        def show_energy_plot(traj_filename):
+                            from ase.io import read
+                            import pandas as pd
+                            import plotly.express as px
+                            import os
+
+                            if os.path.exists(traj_filename):
+                                try:
+                                    trajectory = read(traj_filename, index=":")
+                                    
+                                    # Extract energy and step number
+                                    energies = [atoms.get_potential_energy() for atoms in trajectory]
+                                    steps = list(range(len(energies)))
+                                    
+                                    # Create a DataFrame for Plotly
+                                    data = {
+                                        "Optimization Cycle": steps,
+                                        "Energy (eV)": energies
+                                    }
+                                    df = pd.DataFrame(data)
+                                    
+                                    st.markdown("### Energy Profile During Optimization")
+
+                                    # Create the Plotly figure
+                                    fig = px.line(
+                                        df,
+                                        x="Optimization Cycle",
+                                        y="Energy (eV)",
+                                        markers=True,  # Show points for each step
+                                        title="Energy Convergence vs. Optimization Cycle",
+                                    )
+
+                                    # Enhance aesthetics
+                                    fig.update_layout(
+                                        xaxis_title="Optimization Cycle",
+                                        yaxis_title="Energy (eV)",
+                                        hovermode="x unified",
+                                        template="plotly_white", # Clean, professional look
+                                        font=dict(size=12),
+                                        title_x=0.5, # Center the title
+                                    )
+                                    
+                                    # Highlight the converged energy (optional: useful if the plot is zoomed out)
+                                    fig.add_hline(
+                                        y=energies[-1], 
+                                        line_dash="dot", 
+                                        line_color="red", 
+                                        annotation_text=f"Final Energy: {energies[-1]:.4f} eV",
+                                        annotation_position="bottom right"
+                                    )
+                                    
+                                    # Render the plot in Streamlit
+                                    st.plotly_chart(fig, use_container_width=True)
+
+                                except Exception as e:
+                                    st.error(f"Error generating energy plot: {e}")
+                            else:
+                                st.warning("Cannot generate energy plot: Trajectory file not found.")
+
+                        show_energy_plot(traj_filename)
+                        # --- End of Energy Plot Code ---
                         os.unlink(tmp_filepath_opt)
 
                         @st.fragment
@@ -2030,18 +2093,18 @@ with st.expander('ℹ️ About This App & Foundational MLIPs'):
     st.write("""
     **Test, compare, and benchmark universal machine learning interatomic potentials (MLIPs).**
     This application allows you to perform atomistic simulations using pre-trained foundational MLIPs 
-    from the MACE and FairChem (by Meta AI) libraries.
+    from the MACE, MatterSim (Microsoft), SevenNet, Orb (Orbital Materials) and FairChem (Meta AI) developers and researchers.
     
     **Features:**
-    - Upload structure files (XYZ, CIF, POSCAR, etc.) or use built-in examples.
-    - Select from various MACE and FairChem models.
-    - Calculate energies, forces, and perform geometry/cell optimizations.
-    - **New**: Calculate atomization energy (for molecules) or cohesive energy (for periodic systems).
-    - Visualize atomic structures in 3D and download results.
+    - Upload/Paste structure files (XYZ, CIF, POSCAR, etc.), import from Materials Project/PubChem or use built-in examples.
+    - Select from various MACE, ORB, SevenNet, MatterSim and FairChem models.
+    - Calculate energies, forces, cohesive/atomization energy, vibrational modes and perform geometry/cell optimizations.
+    - Visualize atomic structures in 3D and download results, optimized structures and optimization trajectories.
     
     **Quick Start:**
     1.  **Input**: Choose an input method in the sidebar (e.g., "Select Example").
-    2.  **Model**: Pick a model type (MACE/FairChem) and specific model. For FairChem UMA, select the appropriate task type (e.g., `omol` for molecules, `omat` for materials).
+    2.  **Model**: Pick a model type (MACE/FairChem/MatterSim/ORB/SevenNet) and specific model. For FairChem UMA, select the appropriate task type (e.g., `omol` for molecules, `omat` for materials). 
+    For models trained on OMOL25 dataset (whenever the model name contains `omol`) then the user also needs to provide a charge and spin multiplicity (`2S+1`) value. By default the charge is set to zero and spin multiplicity to 1 (S=0).
     3.  **Task**: Select a calculation task (e.g., "Energy Calculation", "Atomization/Cohesive Energy", "Geometry Optimization").
     4.  **Run**: Click "Run Calculation" and view the results.
 
@@ -2134,4 +2197,4 @@ with st.expander('🔧 Tech Stack & System Information'):
 
 st.markdown("---")
 st.markdown("Universal MLIP Playground App | Created with Streamlit, ASE, MACE, FairChem, SevenNet, ORB and ❤️")
-st.markdown("Developed by [Manas Sharma](https://manas.bragitoff.com/) in the groups of [Prof. Ananth Govind Rajan Group](https://www.agrgroup.org/) and [Prof. Sudeep Punnathanam](https://chemeng.iisc.ac.in/sudeep/) at  [IISc Bangalore](https://iisc.ac.in/)")
+st.markdown("Developed by [Dr. Manas Sharma](https://manas.bragitoff.com/) in the groups of [Prof. Ananth Govind Rajan Group](https://www.agrgroup.org/) and [Prof. Sudeep Punnathanam](https://chemeng.iisc.ac.in/sudeep/) at  [IISc Bangalore](https://iisc.ac.in/)")