DynamiSpectra 1.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

dynamispectra/FractionSS.py

@@ -0,0 +1,100 @@
+# analysis.py
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# State mapping
+STATE_MAPPING = {
+    'H': 1,  # α-Helix
+    'E': 2,  # β-Sheet
+    'C': 0,  # Loop/Coil
+    'T': 3,  # Turn
+    'S': 4,  # Bend
+    'G': 5,  # 3-Helix
+    '~': -1, # Undefined structure
+    'B': -1, # Treat as undefined structure
+}
+
+def load_data(file_path):
+    """Loads the data file."""
+    try:
+        df = pd.read_csv(file_path, header=None)
+        print("First few rows of the file:")
+        print(df.head())
+        return df
+    except Exception as e:
+        print(f"Error loading the file: {e}")
+        return None
+
+def calculate_fractions(df):
+    """Calculates the fractions of each conformation over time."""
+    time = []
+    helix_fraction = []
+    sheet_fraction = []
+    coil_fraction = []
+    turn_fraction = []
+    bend_fraction = []
+    three_helix_fraction = []
+
+    for index, row in df.iterrows():
+        sequence = row[0]
+        total_residues = len(sequence)
+
+        helix_count = sequence.count("H")
+        sheet_count = sequence.count("E")
+        coil_count = sequence.count("C")
+        turn_count = sequence.count("T")
+        bend_count = sequence.count("S")
+        three_helix_count = sequence.count("G")
+
+        helix_fraction.append(helix_count / total_residues)
+        sheet_fraction.append(sheet_count / total_residues)
+        coil_fraction.append(coil_count / total_residues)
+        turn_fraction.append(turn_count / total_residues)
+        bend_fraction.append(bend_count / total_residues)
+        three_helix_fraction.append(three_helix_count / total_residues)
+
+        time.append(index)
+
+    results_df = pd.DataFrame({
+        "Time": time,
+        "Helix Fraction": helix_fraction,
+        "Sheet Fraction": sheet_fraction,
+        "Coil Fraction": coil_fraction,
+        "Turn Fraction": turn_fraction,
+        "Bend Fraction": bend_fraction,
+        "3-Helix Fraction": three_helix_fraction
+    })
+
+    print("First few rows of the results:")
+    print(results_df.head())
+    return results_df
+
+def plot_results(results_df, title, output_png, output_tiff):
+    """Plots the results and saves the graphs."""
+    plt.figure(figsize=(7, 6))
+
+    plt.plot(results_df["Time"], results_df["Helix Fraction"], label="α-Helix", color="#6A9EDA", linewidth=2)
+    plt.plot(results_df["Time"], results_df["Sheet Fraction"], label="β-Sheet", color="#f2444d", linewidth=2)
+    plt.plot(results_df["Time"], results_df["Coil Fraction"], label="Loop/Coil", color="#4bab44", linewidth=2)
+    plt.plot(results_df["Time"], results_df["Turn Fraction"], label="Turn", color="#fc9e19", linewidth=2)
+    plt.plot(results_df["Time"], results_df["Bend Fraction"], label="Bend", color="#54b36a", linewidth=2)
+    plt.plot(results_df["Time"], results_df["3-Helix Fraction"], label="3-Helix", color="#c9824f", linewidth=2)
+
+    plt.xlabel("Frames")
+    plt.ylabel("Fraction of Residues")
+    plt.title(title)
+    plt.legend(loc="lower center", bbox_to_anchor=(0.5, -0.2), ncol=6, frameon=False, markerscale=2, handlelength=2, handleheight=2)
+    plt.grid(False)
+    plt.xlim(0, 10000)
+    plt.ylim(0, 0.85)
+
+    plt.savefig(output_png, dpi=300, bbox_inches='tight')
+    plt.savefig(output_tiff, dpi=300, bbox_inches='tight')
+    plt.show()
+
+def fractions_ss_analysis(file_path, output_png, output_tiff, title):
+    """Main function for secondary structure analysis."""
+    df = load_data(file_path)
+    if df is not None:
+        results_df = calculate_fractions(df)
+        plot_results(results_df, title, output_png, output_tiff)

dynamispectra/Hbond.py

@@ -0,0 +1,219 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.stats import gaussian_kde
+import os
+
+def read_hbond(file):
+    """
+    Reads hbond data from a .xvg file.
+
+    Parameters:
+    -----------
+    file : str
+        Path to the .xvg file.
+
+    Returns:
+    --------
+    times : numpy.ndarray
+        Array of simulation times.
+    hbonds : numpy.ndarray
+        Array of hbond values.
+    """
+    try:
+        print(f"Reading file: {file}")
+        
+        # Open the file and process line by line
+        times = []
+        hbonds = []
+        
+        with open(file, 'r') as f:
+            for line in f:
+                # Skip comment lines and empty lines
+                if line.startswith(('#', '@', ';')) or line.strip() == '':
+                    continue
+                
+                # Try to extract the first two numeric values from the line
+                try:
+                    values = line.split()
+                    # Check if there are at least two values in the line
+                    if len(values) >= 2:
+                        time, hbond = map(float, values[:2])  # Use the first two values
+                        times.append(time)
+                        hbonds.append(hbond)
+                except ValueError:
+                    # Skip lines that cannot be converted to numbers
+                    print(f"Error processing line: {line.strip()}")
+                    continue
+        
+        # Check if the data is valid
+        if len(times) == 0 or len(hbonds) == 0:
+            raise ValueError(f"File {file} does not contain valid data.")
+        
+        # Convert lists to numpy arrays
+        times = np.array(times)
+        hbonds = np.array(hbonds)
+        
+        return times, hbonds
+    
+    except Exception as e:
+        print(f"Error reading file {file}: {e}")
+        return None, None
+
+def check_simulation_times(*time_arrays):
+    r"""
+    Checks if simulation times are consistent across files.
+
+    Parameters:
+    -----------
+    \*time_arrays : list of numpy.ndarray
+        Arrays of times to compare.
+    """
+    for i in range(1, len(time_arrays)):
+        if not np.allclose(time_arrays[0], time_arrays[i]):
+            raise ValueError(f"Simulation times do not match between file 1 and file {i+1}")
+
+def plot_hbond(time_simulation1, mean_simulation1, std_simulation1,
+               time_simulation2, mean_simulation2, std_simulation2,
+               time_simulation3, mean_simulation3, std_simulation3,
+               output_folder):
+    """
+    Generates the hbond plot with mean and standard deviation for the groups provided.
+    """
+    # Create figure for the hbond plot
+    plt.figure(figsize=(7, 6))
+    plt.plot()
+
+    # Plot for simulation1 (if provided)
+    if time_simulation1 is not None:
+        plt.plot(time_simulation1, mean_simulation1, label='Simulation 1', color='#333333', linewidth=2)
+        plt.fill_between(time_simulation1, mean_simulation1 - std_simulation1, mean_simulation1 + std_simulation1, color='#333333', alpha=0.2)
+
+    # Plot for simulation2 (if provided)
+    if time_simulation2 is not None:
+        plt.plot(time_simulation2, mean_simulation2, label='Simulation 2', color='#6A9EDA', linewidth=2)
+        plt.fill_between(time_simulation2, mean_simulation2 - std_simulation2, mean_simulation2 + std_simulation2, color='#6A9EDA', alpha=0.2)
+
+    # Plot for simulation3 (if provided)
+    if time_simulation3 is not None:
+        plt.plot(time_simulation3, mean_simulation3, label='Simulation 3', color='#54b36a', linewidth=2)
+        plt.fill_between(time_simulation3, mean_simulation3 - std_simulation3, mean_simulation3 + std_simulation3, color='#54b36a', alpha=0.2)
+
+    # Configure the hbond plot
+    plt.xlabel('Time (ns)', fontsize=12)
+    plt.ylabel('H-bonds', fontsize=12)
+    plt.title('', fontsize=14)
+    plt.legend(frameon=False, loc='upper right', fontsize=10)
+    plt.tick_params(axis='both', which='major', labelsize=10)
+    plt.grid(False)
+
+    # Adjust x-axis limits to start at 0
+    plt.xlim(left=0)  # Set the minimum x-axis limit to 0
+    plt.xlim(right=100)
+    
+    # Adjust layout
+    plt.tight_layout()
+
+    # Save the hbond plot in TIFF and PNG formats
+    os.makedirs(output_folder, exist_ok=True)  # Create the folder if it doesn't exist
+
+    # Save as TIFF
+    plt.savefig(os.path.join(output_folder, 'hbond_plot.tiff'), format='tiff', dpi=300)
+    # Save as PNG
+    plt.savefig(os.path.join(output_folder, 'hbond_plot.png'), format='png', dpi=300)
+
+    # Show the hbond plot
+    plt.show()
+
+def plot_density(mean_simulation1, mean_simulation2, mean_simulation3, output_folder):
+    """
+    Generates the density plot for the groups provided.
+    """
+    # Create figure for the density plot
+    plt.figure(figsize=(6, 6))
+    plt.plot()
+
+    # Add KDE (Kernel Density Estimation) for each dataset (if provided)
+    if mean_simulation1 is not None:
+        kde_simulation1 = gaussian_kde(mean_simulation1)
+        x_vals = np.linspace(0, max(mean_simulation1), 1000)
+        plt.fill_between(x_vals, kde_simulation1(x_vals), color='#333333', alpha=0.5, label='Simulation 1')
+
+    if mean_simulation2 is not None:
+        kde_simulation2 = gaussian_kde(mean_simulation2)
+        x_vals = np.linspace(0, max(mean_simulation2), 1000)
+        plt.fill_between(x_vals, kde_simulation2(x_vals), color='#6A9EDA', alpha=0.6, label='Simulation 2')
+
+    if mean_simulation3 is not None:
+        kde_simulation3 = gaussian_kde(mean_simulation3)
+        x_vals = np.linspace(0, max(mean_simulation3), 1000)
+        plt.fill_between(x_vals, kde_simulation3(x_vals), color='#54b36a', alpha=0.5, label='Simulation 3')
+
+    # Configure the density plot
+    plt.xlabel('H-bonds', fontsize=12)
+    plt.ylabel('Density', fontsize=12)
+    plt.title('', fontsize=14)
+    plt.legend(frameon=False, loc='upper left', fontsize=10)
+    plt.tick_params(axis='both', which='major', labelsize=10)
+    plt.grid(False)
+    plt.tight_layout()
+
+    # Save the density plot in TIFF and PNG formats
+    # Save as TIFF
+    plt.savefig(os.path.join(output_folder, 'density_plot.tiff'), format='tiff', dpi=300)
+    # Save as PNG
+    plt.savefig(os.path.join(output_folder, 'density_plot.png'), format='png', dpi=300)
+
+    # Show the density plot
+    plt.show()
+
+def hbond_analysis(output_folder, *simulation_files_groups):
+    r"""
+    Main function to generate hbond analysis and plots.
+
+    Parameters:
+    -----------
+    output_folder : str
+        Output folder to save the plots.
+    \*simulation_files_groups : list of str
+        List of paths to .xvg files for each simulation group.
+        You can pass 1, 2, or 3 groups.
+    """
+    # Helper function to process a group of files
+    def process_group(file_paths):
+        times = []
+        hbonds = []
+        for file in file_paths:
+            time, hbond = read_hbond(file)
+            times.append(time)
+            hbonds.append(hbond)
+        check_simulation_times(*times)  # Check if times are consistent
+        mean_hbond = np.mean(hbonds, axis=0)  # Calculate mean
+        std_hbond = np.std(hbonds, axis=0)  # Calculate standard deviation
+        return times[0], mean_hbond, std_hbond
+    
+    # Process each group of files
+    results = []
+    for group in simulation_files_groups:
+        if group:  # Check if the list is not empty
+            time, mean, std = process_group(group)
+            results.append((time, mean, std))
+
+    # Generate plots based on the number of groups
+    if len(results) == 1:
+        # Plot for 1 group
+        plot_hbond(results[0][0], results[0][1], results[0][2], None, None, None, None, None, None, output_folder)
+        plot_density(results[0][1], None, None, output_folder)
+    elif len(results) == 2:
+        # Plot for 2 groups
+        plot_hbond(results[0][0], results[0][1], results[0][2],
+                   results[1][0], results[1][1], results[1][2],
+                   None, None, None, output_folder)
+        plot_density(results[0][1], results[1][1], None, output_folder)
+    elif len(results) == 3:
+        # Plot for 3 groups
+        plot_hbond(results[0][0], results[0][1], results[0][2],
+                   results[1][0], results[1][1], results[1][2],
+                   results[2][0], results[2][1], results[2][2], output_folder)
+        plot_density(results[0][1], results[1][1], results[2][1], output_folder)
+    else:
+        raise ValueError("You must provide at least one group of simulation files.")

dynamispectra/PCA.py

@@ -0,0 +1,118 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+
+def read_xvg(file_path):
+    """
+    Reads data from a .xvg file.
+
+    Parameters:
+    -----------
+    file_path : str
+        Path to the .xvg file.
+
+    Returns:
+    --------
+    data : numpy.ndarray
+        Array of numerical data from the .xvg file.
+    """
+    data = []
+    with open(file_path, "r") as file:
+        for line in file:
+            if not line.startswith(("#", "@")):  # Ignore headers and metadata
+                values = line.split()
+                data.append([float(values[0]), float(values[1])])  # PC1 and PC2
+    return np.array(data)
+
+def read_eigenvalues(eigenval_path):
+    """
+    Reads eigenvalues from a .xvg file.
+
+    Parameters:
+    -----------
+    eigenval_path : str
+        Path to the .xvg file containing eigenvalues.
+
+    Returns:
+    --------
+    eigenvalues : numpy.ndarray
+        Array of eigenvalues.
+    """
+    eigenvalues = []
+    with open(eigenval_path, "r") as file:
+        for line in file:
+            if not line.startswith(("#", "@")):
+                # Extract the second column (eigenvalues)
+                value = line.split()[1]
+                eigenvalues.append(float(value))
+    return np.array(eigenvalues)
+
+def plot_pca(pca_data, eigenvalues, output_folder, title="PCA"):
+    """
+    Generates the PCA plot.
+
+    Parameters:
+    -----------
+    pca_data : numpy.ndarray
+        Array of PCA data (PC1 and PC2).
+    eigenvalues : numpy.ndarray
+        Array of eigenvalues.
+    output_folder : str
+        Output folder to save the plot.
+    title : str, optional
+        Title of the plot.
+    """
+    # Calculate the explained variance in percentage
+    total_variance = np.sum(eigenvalues)
+    pc1_variance = (eigenvalues[0] / total_variance) * 100
+    pc2_variance = (eigenvalues[1] / total_variance) * 100
+
+    # Create the scatter plot (PC1 vs PC2)
+    plt.figure(figsize=(7, 6))
+    scatter = plt.scatter(
+        pca_data[:, 0], pca_data[:, 1], 
+        c=np.linspace(0, 1, len(pca_data)),  # Gradient of colors for points
+        cmap="viridis",  # Colormap to differentiate points
+        alpha=0.8, edgecolors='k', linewidths=0.8
+    )
+
+    # Update axis labels with explained variance
+    plt.xlabel(f"PC1 ({pc1_variance:.2f}%)")
+    plt.ylabel(f"PC2 ({pc2_variance:.2f}%)")
+    plt.title(title)
+
+    # Add color bar
+    plt.colorbar(scatter, label="Simulation times")
+    plt.grid(False)
+
+    # Save the plot as PNG with 300 DPI
+    os.makedirs(output_folder, exist_ok=True)  # Create the folder if it doesn't exist
+    output_path = os.path.join(output_folder, 'pca_plot.png')
+    plt.savefig(output_path, dpi=300)
+
+    # Show the plot
+    plt.show()
+
+def pca_analysis(pca_file_path, eigenval_path, output_folder, title="PCA"):
+    """
+    Main function to generate PCA analysis and plot.
+
+    Parameters:
+    -----------
+    pca_file_path : str
+        Path to the .xvg file containing PCA data.
+    eigenval_path : str
+        Path to the .xvg file containing eigenvalues.
+    output_folder : str
+        Output folder to save the plot.
+    title : str, optional
+        Title of the plot.
+    """
+    # Read PCA data
+    pca_data = read_xvg(pca_file_path)
+
+    # Read eigenvalues
+    eigenvalues = read_eigenvalues(eigenval_path)
+
+    # Generate the PCA plot
+    plot_pca(pca_data, eigenvalues, output_folder, title)

dynamispectra/RMSD.py

@@ -0,0 +1,218 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.stats import gaussian_kde
+import os
+
+def read_rmsd(file):
+    """
+    Reads RMSD data from a .xvg file.
+
+    Parameters:
+    -----------
+    file : str
+        Path to the .xvg file.
+
+    Returns:
+    --------
+    times : numpy.ndarray
+        Array of simulation times.
+    rmsd : numpy.ndarray
+        Array of RMSD values.
+    """
+    try:
+        print(f"Reading file: {file}")
+        
+        # Open the file and process line by line
+        times = []
+        rmsd = []
+        
+        with open(file, 'r') as f:
+            for line in f:
+                # Skip comment lines and empty lines
+                if line.startswith(('#', '@', ';')) or line.strip() == '':
+                    continue
+                
+                # Try to extract the first two numeric values from the line
+                try:
+                    values = line.split()
+                    # Check if there are at least two values in the line
+                    if len(values) >= 2:
+                        time, rmsd_val = map(float, values[:2])  # Use the first two values
+                        times.append(time)
+                        rmsd.append(rmsd_val)
+                except ValueError:
+                    # Skip lines that cannot be converted to numbers
+                    print(f"Error processing line: {line.strip()}")
+                    continue
+        
+        # Check if the data is valid
+        if len(times) == 0 or len(rmsd) == 0:
+            raise ValueError(f"File {file} does not contain valid data.")
+        
+        # Convert lists to numpy arrays
+        times = np.array(times)
+        rmsd = np.array(rmsd)
+        
+        return times, rmsd
+    
+    except Exception as e:
+        print(f"Error reading file {file}: {e}")
+        return None, None
+
+def check_simulation_times(*time_arrays):
+    r"""
+    Checks if simulation times are consistent across files.
+
+    Parameters:
+    -----------
+    \*time_arrays : list of numpy.ndarray
+        Arrays of times to compare.
+    """
+    for i in range(1, len(time_arrays)):
+        if not np.allclose(time_arrays[0], time_arrays[i]):
+            raise ValueError(f"Simulation times do not match between file 1 and file {i+1}")
+
+def plot_rmsd(time_simulation1, mean_simulation1, std_simulation1,
+              time_simulation2, mean_simulation2, std_simulation2,
+              time_simulation3, mean_simulation3, std_simulation3,
+              output_folder):
+    """
+    Generates the RMSD plot with mean and standard deviation for the groups provided.
+    """
+    # Create figure for the RMSD plot
+    plt.figure(figsize=(7, 6))
+    plt.plot()
+    # Plot for simulation1 (if provided)
+    if time_simulation1 is not None:
+        plt.plot(time_simulation1, mean_simulation1, label='Simulation 1', color='#333333', linewidth=2)
+        plt.fill_between(time_simulation1, mean_simulation1 - std_simulation1, mean_simulation1 + std_simulation1, color='#333333', alpha=0.2)
+
+    # Plot for simulation2 (if provided)
+    if time_simulation2 is not None:
+        plt.plot(time_simulation2, mean_simulation2, label='Simulation 2', color='#6A9EDA', linewidth=2)
+        plt.fill_between(time_simulation2, mean_simulation2 - std_simulation2, mean_simulation2 + std_simulation2, color='#6A9EDA', alpha=0.2)
+
+    # Plot for simulation3 (if provided)
+    if time_simulation3 is not None:
+        plt.plot(time_simulation3, mean_simulation3, label='Simulation 3', color='#54b36a', linewidth=2)
+        plt.fill_between(time_simulation3, mean_simulation3 - std_simulation3, mean_simulation3 + std_simulation3, color='#54b36a', alpha=0.2)
+
+    # Configure the RMSD plot
+    plt.xlabel('Time (ns)', fontsize=12)
+    plt.ylabel('RMSD (nm)', fontsize=12)
+    plt.title('', fontsize=14)
+    plt.legend(frameon=False, loc='lower right', fontsize=10)
+    plt.tick_params(axis='both', which='major', labelsize=10)
+    plt.grid(False)
+
+    # Adjust x-axis limits to start at 0
+    plt.xlim(left=0)  # Set the minimum x-axis limit to 0
+    plt.xlim(right=100)
+    
+    # Adjust layout
+    plt.tight_layout()
+
+    # Save the RMSD plot in TIFF and PNG formats
+    os.makedirs(output_folder, exist_ok=True)  # Create the folder if it doesn't exist
+
+    # Save as TIFF
+    plt.savefig(os.path.join(output_folder, 'rmsd_plot.tiff'), format='tiff', dpi=300)
+    # Save as PNG
+    plt.savefig(os.path.join(output_folder, 'rmsd_plot.png'), format='png', dpi=300)
+
+    # Show the RMSD plot
+    plt.show()
+
+def plot_density(mean_simulation1, mean_simulation2, mean_simulation3, output_folder):
+    """
+    Generates the density plot for the groups provided.
+    """
+    # Create figure for the density plot
+    plt.figure(figsize=(6, 6))
+    plt.plot()
+
+    # Add KDE (Kernel Density Estimation) for each dataset (if provided)
+    if mean_simulation1 is not None:
+        kde_simulation1 = gaussian_kde(mean_simulation1)
+        x_vals = np.linspace(0, max(mean_simulation1), 1000)
+        plt.fill_between(x_vals, kde_simulation1(x_vals), color='#333333', alpha=0.5, label='Simulation 1')
+
+    if mean_simulation2 is not None:
+        kde_simulation2 = gaussian_kde(mean_simulation2)
+        x_vals = np.linspace(0, max(mean_simulation2), 1000)
+        plt.fill_between(x_vals, kde_simulation2(x_vals), color='#6A9EDA', alpha=0.6, label='Simulation 2')
+
+    if mean_simulation3 is not None:
+        kde_simulation3 = gaussian_kde(mean_simulation3)
+        x_vals = np.linspace(0, max(mean_simulation3), 1000)
+        plt.fill_between(x_vals, kde_simulation3(x_vals), color='#54b36a', alpha=0.5, label='Simulation 3')
+
+    # Configure the density plot
+    plt.xlabel('RMSD (nm)', fontsize=12)
+    plt.ylabel('Density', fontsize=12)
+    plt.title('', fontsize=14)
+    plt.legend(frameon=False, loc='upper left', fontsize=10)
+    plt.tick_params(axis='both', which='major', labelsize=10)
+    plt.grid(False)
+    plt.tight_layout()
+
+    # Save the density plot in TIFF and PNG formats
+    # Save as TIFF
+    plt.savefig(os.path.join(output_folder, 'density_plot.tiff'), format='tiff', dpi=300)
+    # Save as PNG
+    plt.savefig(os.path.join(output_folder, 'density_plot.png'), format='png', dpi=300)
+
+    # Show the density plot
+    plt.show()
+
+def rmsd_analysis(output_folder, *simulation_files_groups):
+    r"""
+    Main function to generate RMSD analysis and plots.
+
+    Parameters:
+    -----------
+    output_folder : str
+        Output folder to save the plots.
+    \*simulation_files_groups : list of str
+        List of paths to .xvg files for each simulation group.
+        You can pass 1, 2, or 3 groups.
+    """
+    # Helper function to process a group of files
+    def process_group(file_paths):
+        times = []
+        rmsd = []
+        for file in file_paths:
+            time, rmsd_val = read_rmsd(file)
+            times.append(time)
+            rmsd.append(rmsd_val)
+        check_simulation_times(*times)  # Check if times are consistent
+        mean_rmsd = np.mean(rmsd, axis=0)  # Calculate mean
+        std_rmsd = np.std(rmsd, axis=0)  # Calculate standard deviation
+        return times[0], mean_rmsd, std_rmsd
+    
+    # Process each group of files
+    results = []
+    for group in simulation_files_groups:
+        if group:  # Check if the list is not empty
+            time, mean, std = process_group(group)
+            results.append((time, mean, std))
+
+    # Generate plots based on the number of groups
+    if len(results) == 1:
+        # Plot for 1 group
+        plot_rmsd(results[0][0], results[0][1], results[0][2], None, None, None, None, None, None, output_folder)
+        plot_density(results[0][1], None, None, output_folder)
+    elif len(results) == 2:
+        # Plot for 2 groups
+        plot_rmsd(results[0][0], results[0][1], results[0][2],
+                  results[1][0], results[1][1], results[1][2],
+                  None, None, None, output_folder)
+        plot_density(results[0][1], results[1][1], None, output_folder)
+    elif len(results) == 3:
+        # Plot for 3 groups
+        plot_rmsd(results[0][0], results[0][1], results[0][2],
+                  results[1][0], results[1][1], results[1][2],
+                  results[2][0], results[2][1], results[2][2], output_folder)
+        plot_density(results[0][1], results[1][1], results[2][1], output_folder)
+    else:
+        raise ValueError("You must provide at least one group of simulation files.")