Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import plotly.graph_objects as go | |
| from pymatgen.core import Structure | |
| from pymatgen.analysis.diffraction.xrd import XRDCalculator | |
| import tempfile # To create temporary files for download | |
| import os | |
| import traceback # For detailed error logging | |
| # Define the core processing function | |
| def generate_xrd_pattern(cif_file): | |
| """ | |
| Processes an uploaded CIF file, calculates the XRD pattern, | |
| and returns a Plotly figure, a Pandas DataFrame, and the path to a CSV file. | |
| Args: | |
| cif_file: A file object from Gradio's gr.File component. | |
| Returns: | |
| tuple: (plotly_fig, dataframe, csv_filepath) or (None, None, None) if processing fails. | |
| plotly_fig: A Plotly figure object. | |
| dataframe: A Pandas DataFrame containing the peak data. | |
| csv_filepath: Path to the generated temporary CSV file. | |
| """ | |
| if cif_file is None: | |
| # Return None for all outputs if no file is uploaded | |
| return None, None, None | |
| try: | |
| # Get the temporary path of the uploaded file | |
| cif_filepath = cif_file.name | |
| # 1. Load structure from CIF | |
| structure = Structure.from_file(cif_filepath) | |
| # 2. Calculate XRD pattern | |
| calculator = XRDCalculator() | |
| pattern = calculator.get_pattern(structure, two_theta_range=(10, 90)) # Adjust range if needed | |
| # 3. Prepare data for DataFrame and Plot | |
| miller_indices = [] | |
| for hkl_list in pattern.hkls: | |
| if hkl_list: | |
| # Format Miller indices: take the first set if multiple exist for a peak | |
| #h, k, l = hkl_list[0]['hkl'] | |
| # Use standard tuple representation for display | |
| miller_indices.append(str(tuple(hkl_list[0]['hkl']))) | |
| # Alternative concise string: miller_indices.append(f"({h}{k}{l})") | |
| else: | |
| miller_indices.append("N/A") | |
| # Round data for cleaner display | |
| two_theta_rounded = [round(x, 3) for x in pattern.x] | |
| intensity_rounded = [round(y, 3) for y in pattern.y] | |
| data = pd.DataFrame({ | |
| "2θ (°)": two_theta_rounded, | |
| "Intensity (norm)": intensity_rounded, # Assuming normalized intensity from pymatgen | |
| "Miller Indices (hkl)": miller_indices | |
| }) | |
| # --- Create Plotly Figure --- | |
| fig = go.Figure() | |
| fig.add_trace(go.Bar( | |
| x=data["2θ (°)"], | |
| y=data["Intensity (norm)"], | |
| hovertext=[f"2θ: {t:.3f}<br>Intensity: {i:.1f}<br>hkl: {m}" | |
| for t, i, m in zip(data["2θ (°)"], data["Intensity (norm)"], data["Miller Indices (hkl)"])], | |
| hoverinfo="text", # Show only the custom hover text | |
| width=0.1, # Slightly wider bars might look better | |
| marker_color="#4682B4", # SteelBlue color | |
| marker_line_width=0, | |
| name='Peaks' | |
| )) | |
| # Customize Layout | |
| max_intensity = data["Intensity (norm)"].max() if not data.empty else 100 | |
| min_2theta = data["2θ (°)"].min() if not data.empty else 10 | |
| max_2theta = data["2θ (°)"].max() if not data.empty else 90 | |
| fig.update_layout( | |
| title=dict(text=f"Simulated XRD Pattern: {structure.formula}", x=0.5, xanchor='center'), # Centered title | |
| xaxis_title="2θ (°)", | |
| yaxis_title="Intensity (Arb. Unit)", | |
| xaxis_title_font_size=16, | |
| yaxis_title_font_size=16, | |
| xaxis=dict( | |
| range=[min_2theta - 2, max_2theta + 2], # Slightly tighter range | |
| showline=True, linewidth=1.5, linecolor='black', mirror=True, | |
| ticks='outside', tickwidth=1.5, tickcolor='black', | |
| tickfont_size=12 | |
| ), | |
| yaxis=dict( | |
| range=[0, max_intensity * 1.05], | |
| showline=True, linewidth=1.5, linecolor='black', mirror=True, | |
| ticks='outside', tickwidth=1.5, tickcolor='black', | |
| tickfont_size=12 | |
| ), | |
| plot_bgcolor='white', | |
| paper_bgcolor='white', # Ensure background outside plot is also white | |
| bargap=0.9, # Adjust gap based on new width | |
| font=dict(family="Arial, sans-serif", size=12, color="black"), | |
| margin=dict(l=70, r=30, t=60, b=70), | |
| # Adjust height/width as needed, None allows more flexibility | |
| height=450, | |
| # width=None # Let Gradio manage width for responsiveness | |
| ) | |
| fig.update_xaxes(showgrid=False, zeroline=False) | |
| fig.update_yaxes(showgrid=False, zeroline=False) | |
| # --- Create CSV File --- | |
| with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv', newline='', encoding='utf-8') as temp_csv: | |
| data.to_csv(temp_csv.name, index=False) | |
| csv_filepath_out = temp_csv.name | |
| # Return figure, dataframe, and csv path | |
| return fig, data, csv_filepath_out | |
| except Exception as e: | |
| print(f"Error processing file: {e}") # Log error to console | |
| traceback.print_exc() # Print detailed traceback | |
| # Raise a Gradio error to display it in the UI | |
| raise gr.Error(f"Failed to process CIF file. Please ensure it's a valid CIF. Error: {str(e)}") | |
| # return None, None, None # Alternative: clear outputs | |
| # --- Build Gradio Interface --- | |
| # Use a theme for better aesthetics | |
| theme = gr.themes.Soft( | |
| primary_hue="sky", # Adjust colors if desired | |
| secondary_hue="blue", | |
| neutral_hue="slate" | |
| ) | |
| with gr.Blocks(theme=theme, title="XRD Pattern Generator") as demo: | |
| gr.Markdown( | |
| """ | |
| # XRD Pattern Simulator from CIF | |
| Upload a Crystallographic Information File (.cif) to generate its simulated | |
| X-ray Diffraction (XRD) pattern using [pymatgen](https://github.com/materialsproject/pymatgen). | |
| """ | |
| ) | |
| with gr.Row(): | |
| with gr.Column(scale=1): # Column for input | |
| cif_input = gr.File( | |
| label="Upload CIF File", | |
| file_types=[".cif"], | |
| type="filepath" # Use filepath directly | |
| ) | |
| gr.Markdown("*(Example source: [Crystallography Open Database](http://crystallography.net/cod/))*") | |
| with gr.Column(scale=3): # Column for outputs, make it wider | |
| with gr.Tabs(): | |
| with gr.TabItem("📊 XRD Plot"): | |
| # Wrap plot in a column/row to help with centering if needed, | |
| # but Plotly's layout(title_x=0.5) is the primary centering method for the title. | |
| # The plot component itself usually fills container width. | |
| plot_output = gr.Plot(label="XRD Pattern") # Label might be redundant with Tab title | |
| with gr.TabItem("📄 Peak Data Table"): | |
| dataframe_output = gr.DataFrame( | |
| label="Calculated Peak Data", | |
| headers=["2θ (°)", "Intensity (norm)", "Miller Indices (hkl)"], | |
| wrap=True, # Allow text wrapping for long indices | |
| #max_rows=15, # Limit initial display height | |
| #overflow_row_behaviour='paginate' # Add pagination if many rows | |
| ) | |
| with gr.TabItem("⬇️ Download Data"): | |
| csv_output = gr.File(label="Download Peak Data as CSV") | |
| gr.Markdown("Click the link above to download the full data.") | |
| # Clear outputs when input is cleared | |
| cif_input.clear( | |
| lambda: (None, None, None), | |
| inputs=[], | |
| outputs=[plot_output, dataframe_output, csv_output] | |
| ) | |
| # Connect the input changes to the processing function | |
| cif_input.change( | |
| fn=generate_xrd_pattern, | |
| inputs=cif_input, | |
| outputs=[plot_output, dataframe_output, csv_output], | |
| # show_progress="full" # Show progress indicator during calculation | |
| ) | |
| examples = gr.Examples( | |
| examples=[ | |
| ["example_cif/NaCl_1000041.cif"], | |
| ["example_cif/Al2O3_1000017.cif"], | |
| ], | |
| inputs=[cif_input], | |
| ) | |
| # --- Launch the App --- | |
| if __name__ == "__main__": | |
| demo.launch() | |
| # Add share=True for a public link: demo.launch(share=True) |