import csv import os import re import sys import uuid from datetime import datetime from typing import List, Tuple from warnings import filterwarnings import h5py import matplotlib.pyplot as plt import numpy as np import pandas as pd import torch from ase import io from ase.atoms import Atoms from ase.geometry.analysis import Analysis from joblib import Parallel, delayed from sklearn.metrics import r2_score from tqdm import tqdm # Suppress warnings filterwarnings('ignore') # Function to find missing CSV files def find_missing_csv_files_v8(root_folder, model_name, results_folder): """ Combines all Data.csv files from .cif subdirectories under the given root folder. Generates a combined CSV and reports missing or unreadable files. Args: root_folder (str): The root directory containing subdirectories to scan. model_name (str): The name to use for the output files. Returns: Tuple: Combined DataFrame, missing CSV directories, and unreadable CSV directories. """ df_list = [] missing_csv_dirs = [] # Directories where Data.csv is missing unreadable_csv_dirs = [] # Directories with unreadable Data.csv successfully_read_csvs = [] # Paths of CSVs successfully read no_cif_folders = [] # Folders without .cif subdirectories hidden_folders = [] # Hidden folders all_cif_paths = [] # Track all .cif folders found for subdir in os.listdir(root_folder): subdir_path = os.path.join(root_folder, subdir) subdir_path = os.path.abspath(subdir_path) if subdir.startswith('.'): hidden_folders.append(subdir_path) continue if os.path.isdir(subdir_path): version_0_path = os.path.join(subdir_path, 'version_0') if os.path.isdir(version_0_path): cif_folders = [ f for f in os.listdir(version_0_path) if f.endswith('.cif') and os.path.isdir(os.path.join(version_0_path, f)) ] if cif_folders: for cif_folder in cif_folders: cif_folder_path = os.path.join(version_0_path, cif_folder) all_cif_paths.append(cif_folder_path) csv_path = os.path.join(cif_folder_path, 'Data.csv') if os.path.isfile(csv_path): try: df = pd.read_csv(csv_path) successfully_read_csvs.append(csv_path) df_list.append(df) except Exception as e: unreadable_csv_dirs.append(cif_folder_path) else: missing_csv_dirs.append(cif_folder_path) else: no_cif_folders.append(version_0_path) else: no_cif_folders.append(subdir_path) print("\n=== Detailed Path Analysis ===") print(f"Total .cif folders found: {len(all_cif_paths)}") print(f"Successfully read Data.csv: {len(successfully_read_csvs)}") print(f"Missing Data.csv: {len(missing_csv_dirs)}") print(f"Unreadable Data.csv: {len(unreadable_csv_dirs)}") if df_list: combined_df = pd.concat(df_list, ignore_index=True) combined_df.to_csv(f"{results_folder}/{model_name}/{model_name}.csv", index=False) with open(f"{results_folder}/{model_name}/fraction_complete_{model_name}.txt", 'w') as file: file.write(f"{results_folder}/{model_name}\t Total .cif folders found: {len(all_cif_paths)}" + f"\t\tSuccessfully read Data.csv: {len(successfully_read_csvs)}") return combined_df, missing_csv_dirs, unreadable_csv_dirs print("\nNo Data.csv files found in the specified folders.") return None, missing_csv_dirs, unreadable_csv_dirs # Function for plotting parity plots def plot_scatter(ax, mask, actual, predicted, parameter_name, color, marker, model_name, r2_dict): """ Creates a scatter plot comparing actual vs predicted values with an optional mask. Args: ax (matplotlib.axes.Axes): The axis to plot on. mask (np.ndarray): Mask to filter data. actual (np.ndarray): Actual values. predicted (np.ndarray): Predicted values. parameter_name (str): Name of the parameter being plotted. color (str): Color of the points. marker (str): Marker style. model_name (str): Name of the model. r2_dict (dict): Dictionary to store R2 values. Returns: Tuple: R2 score and indices of removed points. """ filtered_actual = actual[mask] filtered_predicted = predicted[mask] r2 = r2_score(filtered_predicted, filtered_actual) if len(filtered_actual) > 0 else np.nan r2_dict[parameter_name] = r2 ax.scatter(filtered_actual, filtered_predicted, label=f'{parameter_name}', color=color, marker=marker) max_val = max(max(filtered_actual), max(filtered_predicted)) if len(filtered_actual) > 0 else 1 ax.plot([0, max_val], [0, max_val], color='black', linestyle='--') return r2, np.where(mask == False) # Class for handling file operations class FileHandler: """ Handles file searching and reading operations. """ def __init__(self, root_folder: str, incoming_uuid: str): self.root_folder = root_folder self.uuid = incoming_uuid def find_xyz_files(self) -> List[Tuple[str, str]]: xyz_files = [] log_files = [] for subdir in os.listdir(self.root_folder): subdir_path = os.path.join(self.root_folder, subdir) if not os.path.isdir(subdir_path) or subdir.startswith("."): continue version_0_path = os.path.join(subdir_path, "version_0") if not os.path.isdir(version_0_path): continue for folder in os.listdir(version_0_path): folder_path = os.path.join(version_0_path, folder) if not os.path.isdir(folder_path) or not folder.endswith(".cif"): continue for file in os.listdir(folder_path): if file.endswith(".xyz") and not file.startswith("._"): system_name = folder.replace(".cif", "").replace(" ", "_") xyz_files.append((system_name, os.path.join(folder_path, file))) if file.endswith(".log") and not file.startswith("._"): system_name = folder.replace(".cif", "").replace(" ", "_") log_files.append((system_name, os.path.join(folder_path, file))) return xyz_files, log_files def safe_read_xyz(self, file_path: str) -> List[Atoms]: """ Safely reads an XYZ file. Args: file_path (str): Path to the XYZ file. Returns: List[Atoms]: List of atomic structures. """ try: # with open(file_path, "rb") as f: # content = f.read() # decoded_content = content.decode("utf-8", errors="ignore") # temp_file_name = f"./temp_file_dir/temporary_{self.uuid}.xyz" # with open(temp_file_name, "w") as temp_file: # temp_file.write(decoded_content) atoms = io.read(file_path, index=":") # os.remove(temp_file_name) return atoms except Exception as e: print(f"Error reading {file_path}: {e}") return [] @staticmethod def read_log_for_temperature(log_path: str) -> List[Tuple[float, float, float, float, float]]: """ Reads a log file to extract temperature and energy data. Args: log_path (str): Path to the log file. Returns: List[Tuple]: Extracted data. """ data = [] try: with open(log_path, 'r') as log_file: for line in log_file: match = re.match(r"(\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(\d+\.\d+)", line) if match: data.append(tuple(map(float, match.groups()))) except Exception as e: print(f"Error reading log file {log_path}: {e}") return data class PropertyCalculator: """Class for performing property calculations on atomic structures.""" @staticmethod def calculate_density(atoms: Atoms) -> float: """ Calculate the density of an atomic structure in g/cm³. Args: atoms (Atoms): The atomic structure to calculate the density for. Returns: float: The density in g/cm³. """ # Conversion constants amu_to_grams = 1.66053906660e-24 # Atomic mass unit to grams angstrom_to_cm = 1e-8 # Angstrom to centimeters # Calculate mass in grams mass_amu = atoms.get_masses().sum() mass_g = mass_amu * amu_to_grams # Calculate volume in cm³ volume_A3 = atoms.get_volume() volume_cm3 = volume_A3 * (angstrom_to_cm**3) # Return density return mass_g / volume_cm3 class XYZAnalyzer: """ Class for analyzing and processing XYZ and log files related to atomic structures. Generates plots for various properties like density, temperature, and energy. Attributes: root_folder (str): The root folder containing the input files. output_dir (str): The directory to save output plots and analysis results. file_handler (FileHandler): An instance of the FileHandler class to read files. calculator (PropertyCalculator): An instance of the PropertyCalculator class to calculate properties. """ def __init__(self, root_folder: str, output_dir: str): """ Initializes the XYZAnalyzer with the root folder and output directory. Args: root_folder (str): Path to the root folder containing XYZ and log files. output_dir (str): Path to the directory where results and plots will be saved. """ self.root_folder = root_folder self.output_dir = output_dir # Ensure the output directory exists if not os.path.exists(output_dir): os.makedirs(output_dir) # Initialize FileHandler and PropertyCalculator self.file_handler = FileHandler(root_folder) self.calculator = PropertyCalculator() def process_file(self, system_name: str, xyz_file_path: str, log_file_path: str) -> Tuple[List[float], List[np.ndarray], List[Tuple[float, float, float, float, float]]]: """ Process a single XYZ and log file to extract properties. Args: system_name (str): Name of the system being processed. xyz_file_path (str): Path to the XYZ file for the atomic structure. log_file_path (str): Path to the log file containing simulation data. Returns: Tuple: - List[float]: List of calculated densities. - List[np.ndarray]: List of lattice parameters for each structure. - List[Tuple[float, float, float, float, float]]: List of tuples containing time, temperature, total energy, potential energy, and kinetic energy. """ densities = [] lattice_params = [] time_temp_data = [] # Read the XYZ file and compute densities structures = self.file_handler.safe_read_xyz(xyz_file_path) # print(len(structures)) for structure in structures: try: # Calculate density for each structure densities.append(self.calculator.calculate_density(structure)) # Get lattice parameters lattice_params.append(structure.get_cell_lengths_and_angles()) except Exception as e: print(f"Error processing structure in {system_name}: {e}") # Read the log file and extract time, temperature, and energy data time_temp_data = self.file_handler.read_log_for_temperature(log_file_path) return densities, lattice_params, time_temp_data def analyze_and_plot(self): """ Analyze all XYZ and log files in the root folder and generate plots. - Generates plots for density evolution, temperature, and energies (Etot, Epot, Ekin) over time. - Skips systems where the temperature exceeds 3000K. """ # Find XYZ and log files xyz_files, log_files = self.file_handler.find_xyz_files() print(f"Found {len(xyz_files)} XYZ files and {len(log_files)} log files.") if not xyz_files or not log_files: print("No XYZ or Log files found!") return # Create subplots for density, temperature, and energies fig, (ax_density, ax_temp, ax_etot, ax_epot, ax_ekin) = plt.subplots(5, 1, figsize=(12, 30)) # Process each XYZ and log file pair for (system_name, xyz_file_path), (_, log_file_path) in zip(xyz_files, log_files): densities, _, time_temp_data = self.process_file(system_name, xyz_file_path, log_file_path) # Skip systems with temperature exceeding 3000K if any(temp_k > 3000 for _, temp_k, _, _, _ in time_temp_data): print(f"Skipping {system_name} due to temperature exceeding 3000K") continue # Extract time, temperature, and energy data time_steps, temperatures, etot_values, epot_values, ekin_values = zip(*time_temp_data) # Plot density evolution if densities: ax_density.plot(range(len(densities)), densities, label=system_name) # Plot temperature evolution ax_temp.plot(time_steps, temperatures, label=system_name) # Plot total energy (Etot) vs time ax_etot.plot(time_steps, etot_values, label=system_name) # Plot potential energy (Epot) vs time ax_epot.plot(time_steps, epot_values, label=system_name) # Plot kinetic energy (Ekin) vs time ax_ekin.plot(time_steps, ekin_values, label=system_name) # Set labels and titles for the subplots ax_density.set_xlabel("Timesteps") ax_density.set_ylabel("Density (g/cm³)") ax_density.set_title("Density Evolution") ax_temp.set_xlabel("Time (ps)") ax_temp.set_ylabel("Temperature (K)") ax_temp.set_title("Temperature Evolution") ax_etot.set_xlabel("Time (ps)") ax_etot.set_ylabel("Etot (eV)") ax_etot.set_title("Etot Evolution") ax_epot.set_xlabel("Time (ps)") ax_epot.set_ylabel("Epot (eV)") ax_epot.set_title("Epot Evolution") ax_ekin.set_xlabel("Time (ps)") ax_ekin.set_ylabel("Ekin (eV)") ax_ekin.set_title("Ekin Evolution") # Adjust layout and save the figure fig.tight_layout() fig.savefig(f"{self.output_dir}/energy_and_temperature.png", bbox_inches='tight') plt.show() def symmetricize_replicate(curr_atoms, max_atoms, box_lengths): """ Determine the replication factors needed to increase the number of atoms in the system to at least half of the target max_atoms while maintaining the symmetry of the cell. """ replication = [1, 1, 1] # Initial replication factors for each direction atom_count = curr_atoms lengths = box_lengths while atom_count < (max_atoms // 2): direction = np.argmin(box_lengths) # Choose the smallest direction to replicate replication[direction] += 1 # Increase replication factor for that direction lengths[direction] = box_lengths[direction] * replication[direction] atom_count = curr_atoms * replication[0] * replication[1] * replication[2] return replication, atom_count def replicate_system(atoms, replicate_factors): """ Replicates the given ASE Atoms object according to the specified replication factors (nx, ny, nz). """ nx, ny, nz = replicate_factors original_cell = atoms.get_cell() # Original cell parameters original_positions = atoms.get_positions() #@ original_cell # Convert positions to cartesian original_numbers = atoms.get_atomic_numbers() # Atomic numbers of the atoms x_cell, y_cell, z_cell = original_cell[0], original_cell[1], original_cell[2] new_numbers = [] for i in range(nx): for j in range(ny): for k in range(nz): new_numbers += [original_numbers] # Replicate positions along each direction pos_after_x = np.concatenate([original_positions + i * x_cell for i in range(nx)]) pos_after_y = np.concatenate([pos_after_x + i * y_cell for i in range(ny)]) pos_after_z = np.concatenate([pos_after_y + i * z_cell for i in range(nz)]) # New cell dimensions after replication new_cell = [nx * original_cell[0], ny * original_cell[1], nz * original_cell[2]] # Create a new Atoms object with the replicated structure new_atoms = Atoms( numbers=np.concatenate(new_numbers), positions=pos_after_z, cell=new_cell, pbc=atoms.get_pbc(), ) return new_atoms def min_height(cell_matrix): """ Calculate the perpendicular heights in three directions given a 3x3 cell matrix. The minimum height corresponds to the shortest height along the principal axes. """ a, b, c = cell_matrix[:, 0], cell_matrix[:, 1], cell_matrix[:, 2] volume = abs(np.dot(a, np.cross(b, c))) # Calculate the cross products for each pair of axes a_cross_b, b_cross_c, c_cross_a = ( np.linalg.norm(np.cross(a, b)), np.linalg.norm(np.cross(b, c)), np.linalg.norm(np.cross(c, a)), ) # Calculate the perpendicular heights height_a, height_b, height_c = ( abs(volume / a_cross_b), abs(volume / b_cross_c), abs(volume / c_cross_a), ) return min(height_a, height_b, height_c) def perturb_config(atoms, displacement_std=0.01): """ Perturb the atomic positions of the input ASE Atoms object by a Gaussian random displacement to simulate thermal fluctuations. """ positions = atoms.get_positions() displacements = np.random.normal(scale=displacement_std, size=positions.shape) # Gaussian noise new_positions = positions + displacements # Apply perturbations to positions # Create a copy of the atoms object with the perturbed positions new_perturbed_atoms = atoms.copy() new_perturbed_atoms.set_positions(new_positions) return new_perturbed_atoms def get_pairs(atoms): """ Generate all unique pairs of atomic types present in the system. """ Atom_types = np.unique(atoms.get_chemical_symbols()) # List unique atomic species Pairs = [] for i in range(len(Atom_types)): for j in range(i, len(Atom_types)): Pairs += [[Atom_types[i], Atom_types[j]]] return Pairs def getfirstpeaklength(r, rdf, r_max=6.0): """ Find the position of the first peak in the RDF (Radial Distribution Function) within a specified range (r_max). """ bin_size = (r[-1] - r[0]) / len(r) cut_index = int(r_max / bin_size) cut_index = min(cut_index, len(r)) Peak_index = np.argmax(rdf[:cut_index]) # Index of the first peak return Peak_index, r[Peak_index] # Return peak index and corresponding bond length def get_partial_rdfs(Traj, r_max=6.0, dr=0.01): """ Compute the partial radial distribution functions (RDFs) for all pairs of elements in the trajectory. """ rmax = min(r_max, min_height(Traj[0].get_cell()) / 2.7) analysis = Analysis(Traj) # Initialize RDF analysis dr = dr nbins = int(rmax / dr) # Number of bins in the RDF calculation pairs_list = get_pairs(Traj[0]) # List of element pairs to compute RDFs Pair_rdfs = dict() for pair in pairs_list: rdf = analysis.get_rdf( rmax=rmax, nbins=nbins, imageIdx=None, elements=pair, return_dists=True ) x = rdf[0][1] y = np.array([rdf[k][0] for k in range(len(rdf))]).mean(axis=0) Pair_rdfs["-".join(pair)] = [x, y] return Pair_rdfs def get_partial_rdfs_smoothened( inp_atoms, perturb=10, noise_std=0.01, max_atoms=300, r_max=6.0, dr=0.01 ): """ Compute smoothened partial RDFs by perturbing the input atoms and replicating the system to a target size. """ atoms = inp_atoms.copy() replication_factors, _ = symmetricize_replicate( len(atoms), max_atoms=max_atoms, box_lengths=atoms.get_cell_lengths_and_angles()[:3], ) atoms = replicate_system(atoms, replication_factors) # Perturb the system multiple times to smoothen the RDF Traj = [perturb_config(atoms, noise_std) for k in range(perturb)] return get_partial_rdfs(Traj, r_max=r_max, dr=dr) def get_bond_lengths_noise( inp_atoms, perturb=10, noise_std=0.01, max_atoms=300, r_max=6.0, dr=0.01 ): """ Get the bond lengths by computing the first peak in the RDF after perturbing the system. """ Pair_rdfs = get_partial_rdfs_smoothened( inp_atoms, perturb=perturb, noise_std=noise_std, max_atoms=max_atoms, r_max=r_max, dr=dr, ) Bond_lengths = dict() for key in Pair_rdfs: r, rdf = Pair_rdfs[key] Bond_lengths[key] = getfirstpeaklength(r, rdf)[1] # Get bond length at the first peak return Bond_lengths, Pair_rdfs def get_bond_lengths_TrajAvg(Traj, r_max=6.0, dr=0.01): """ Compute the bond lengths from the average RDF of a trajectory. """ Pair_rdfs = get_partial_rdfs(Traj, r_max=r_max, dr=dr) Bond_lengths = dict() for key in Pair_rdfs: r, rdf = Pair_rdfs[key] Bond_lengths[key] = getfirstpeaklength(r, rdf)[1] return Bond_lengths, Pair_rdfs def get_initial_rdf( inp_atoms, perturb=10, noise_std=0.01, max_atoms=300, replicate=False, Structid=0, r_max=6.0, dr=0.01, ): """ Compute the initial RDF for a given input atoms object with optional perturbations and replication. """ atoms = inp_atoms.copy() if replicate: replication_factors, size = symmetricize_replicate( len(atoms), max_atoms=max_atoms, box_lengths=atoms.get_cell_lengths_and_angles()[:3], ) atoms = replicate_system(atoms, replication_factors) rmax = min(r_max, min_height(atoms.get_cell()) / 2.7) # Ensure r_max doesn't exceed the cell height analysis = Analysis([perturb_config(atoms, noise_std) for k in range(perturb)]) dr = dr nbins = int(rmax / dr) # Number of bins for RDF calculation rdf = analysis.get_rdf( rmax=rmax, nbins=nbins, imageIdx=None, elements=None, return_dists=True ) x = rdf[0][1] y = np.array([rdf[k][0] for k in range(len(rdf))]).mean(axis=0) return x, y def get_rdf(Traj, r_max=6.0, dr=0.01): """ Compute the radial distribution function (RDF) for a given trajectory. """ rmax = min(r_max, min_height(Traj[0].get_cell()) / 2.7) analysis = Analysis(Traj) dr = dr nbins = int(rmax / dr) rdf = analysis.get_rdf( rmax=rmax, nbins=nbins, imageIdx=None, elements=None, return_dists=True ) x = rdf[0][1] y = np.array([rdf[k][0] for k in range(len(rdf))]).mean(axis=0) return x, y def process_file(file_handler, calculator, system_name: str, xyz_file_path: str, log_file_path: str): """Process a single XYZ and log file to extract properties.""" densities = [] lattice_params = [] temperature = [] rdf_error = [] # Will store RDF values for each window bond_error = dict() time_temp_data = [] # Read the XYZ file and compute densities structures = file_handler.safe_read_xyz(xyz_file_path) if not structures: return [], [], [], [], {}, [] # Calculate initial RDF _, initial_rdf = get_initial_rdf( structures[0], perturb=20, noise_std=0.05, max_atoms=200, replicate=True ) # Calculate initial partial_rdf initial_bond_lengths, Initial_Pair_rdfs = get_bond_lengths_noise( structures[0], perturb=20, noise_std=0.05, max_atoms=200, r_max=6.0 ) counter = 0 window_size = 100 # Size of the trajectory window for RDF calculation for structure in structures: try: densities.append(calculator.calculate_density(structure)) lattice_params.append(structure.get_cell_lengths_and_angles()) temperature.append(structure.get_temperature()) if (counter + 1) % window_size == 0: window_start = max(0, counter - window_size + 1) window_structures = structures[window_start:counter + 1] r, current_rdf = get_rdf(window_structures, r_max=6.0) min_len = min(len(current_rdf), len(initial_rdf)) current_rdf = current_rdf[:min_len] initial_rdf_ = initial_rdf[:min_len] error_rdf = ( 100 * (((current_rdf - initial_rdf_) ** 2).sum()) / (((initial_rdf_) ** 2).sum()) ) rdf_error.append(error_rdf) curr_bond_lengths, Pair_rdfs = get_bond_lengths_TrajAvg( window_structures, r_max=6.0 ) for key in curr_bond_lengths.keys(): if key in Initial_Pair_rdfs: r, initial_rdf = Initial_Pair_rdfs[key] r, rdf = Pair_rdfs[key] RDF_len = min(len(rdf), len(initial_rdf)) r = r[:RDF_len] rdf = rdf[:RDF_len] initial_rdf_ = initial_rdf[:RDF_len] pair_error = ( 100 * (((rdf - initial_rdf_) ** 2).sum()) / (((initial_rdf_) ** 2).sum()) ) if key not in bond_error: bond_error[key] = [] bond_error[key].append(pair_error) except Exception as e: print(f"Error processing structure {counter} in {system_name}: {e}") counter += 1 time_temp_data = file_handler.read_log_for_temperature(log_file_path) return densities, lattice_params, temperature, rdf_error, time_temp_data, bond_error def save_bond_errors_to_txt(file_name, bond_error): """Save bond errors to a text file.""" with open(file_name, mode='w') as file: for bond, errors in bond_error.items(): file.write(f"Bond: {bond}\n") file.write("Errors:\n") file.write(", ".join(map(str, errors)) + "\n") file.write("\n") def save_to_csv(file_name, data): """Save data to a CSV file.""" with open(file_name, mode='w', newline='') as file: writer = csv.writer(file) if isinstance(data[0], (list, tuple)): writer.writerow([f"Column {i+1}" for i in range(len(data[0]))]) writer.writerows(data)