Update app.py

app.py

@@ -1,7 +1,7 @@
 """
-RNA Motif Multi-Structure Comparison Tool
-Streamlit app for comparing multiple RNA motif structures simultaneously
-Based on working pairwise alignment code
+RNA Motif Multi-Structure Comparison Tool - Pairwise Mode
+Streamlit app for comparing multiple RNA motif structures with separate reference and query sets
+Uses dropdown menu for residue configuration and default Backbone + Sugar atom selection
 """
 
 import streamlit as st
@@ -25,15 +25,20 @@ from rmsd_utils import (
 )
 
 # Import example data loader
-from example_data_loader import (
-    get_example_pdbs,
-    load_example_as_uploaded_file,
-    get_example_info
-)
+try:
+    from example_data_loader import (
+        get_example_pdbs,
+        load_example_as_uploaded_file,
+        get_example_info
+    )
+    EXAMPLES_AVAILABLE = True
+except ImportError:
+    EXAMPLES_AVAILABLE = False
+    st.warning("Example data loader not available. Please use 'Upload Files' mode.")
 
 # Page configuration
 st.set_page_config(
-    page_title="RNA Motif Multi-Structure Comparison",
+    page_title="RNA Motif Multi-Structure Comparison - Pairwise",
     page_icon="🧬",
     layout="wide",
     initial_sidebar_state="expanded"
@@ -226,7 +231,6 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 
-
 def save_uploaded_file(uploaded_file, directory):
     """Save an uploaded file to a temporary directory"""
     file_path = os.path.join(directory, uploaded_file.name)
@@ -236,7 +240,15 @@ def save_uploaded_file(uploaded_file, directory):
 
 
 def get_structure_info(pdb_path):
-    """Get information about a structure's residues."""
+    """
+    Get information about a structure's residues.
+    
+    Args:
+        pdb_path: Path to PDB file
+    
+    Returns:
+        List of dicts with residue info: [{index, resnum, resname, full_name}, ...]
+    """
     residues = parse_residue_atoms(pdb_path)
     
     structure_info = []
@@ -251,351 +263,468 @@ def get_structure_info(pdb_path):
     return structure_info
 
 
+def load_structure_data(uploaded_files, temp_dir):
+    """Load structure data from uploaded files"""
+    structure_data = []
+    
+    for uploaded_file in uploaded_files:
+        file_path = save_uploaded_file(uploaded_file, temp_dir)
+        residues = parse_residue_atoms(file_path)
+        
+        structure_data.append({
+            'name': uploaded_file.name,
+            'path': file_path,
+            'residues': residues,
+            'num_residues': len(residues)
+        })
+    
+    return structure_data
+
+
 def extract_window_coords(residues, window_indices):
-    """Extract coordinates for a specific window of residues."""
-    all_coords = []
+    """Extract coordinates for a window of residues - using Backbone + Sugar by default"""
+    coords_list = []
     for idx in window_indices:
-        if idx < len(residues):
-            residue = residues[idx]
-            backbone_coords = get_backbone_sugar_coords_from_residue(residue)
-            all_coords.extend(backbone_coords)
-            base_coords = get_base_coords_from_residue(residue)
-            all_coords.extend(base_coords)
-    
-    return np.asarray(all_coords)
+        res = residues[idx]
+        backbone_coords = get_backbone_sugar_coords_from_residue(res)
+        coords_list.extend(backbone_coords)
+    return np.array(coords_list)
 
 
-def generate_windows_from_selection(selected_indices, win_size, win_type):
-    """Generate windows from selected indices"""
-    if len(selected_indices) < win_size:
+def generate_windows_from_selection(selected_indices, window_size, window_type):
+    """Generate windows from selected residue indices"""
+    if len(selected_indices) < window_size:
         return []
     
-    if win_type == "contiguous":
-        windows = []
-        for i in range(len(selected_indices) - win_size + 1):
-            windows.append(selected_indices[i:i + win_size])
-        return windows
+    windows = []
+    if window_type == "contiguous":
+        for i in range(len(selected_indices) - window_size + 1):
+            windows.append(selected_indices[i:i+window_size])
     else:  # non-contiguous
-        return [list(combo) for combo in combinations(selected_indices, win_size)]
+        from itertools import combinations
+        windows = list(combinations(selected_indices, window_size))
+        windows = [list(w) for w in windows]
+    
+    return windows
 
 
 def main():
-    # Header
-    st.markdown('<p class="main-header">🧬 RNA Motif Multi-Structure Comparison</p>', unsafe_allow_html=True)
-    st.markdown('<p class="sub-header">Compare multiple RNA motifs simultaneously with window-based alignment</p>', unsafe_allow_html=True)
-    
-    # Sidebar
-    st.sidebar.header("⚙️ Configuration")
-    
-    # Step 1: File upload or Example data
-    st.sidebar.subheader("1️⃣ Load Structures")
-    
-    # Add tabs for Upload vs Examples
-    data_source = st.sidebar.radio(
-        "Data Source",
-        ["Upload Files", "Use Examples"],
-        key="data_source",
-        help="Choose to upload your own files or use example data"
-    )
+    st.markdown('<h1 class="main-header">🧬 RNA Motif Multi-Structure Comparison</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">Pairwise comparison: Reference structures vs Query structures</p>', unsafe_allow_html=True)
     
-    # Clear session state when data source changes
-    if 'previous_data_source' not in st.session_state:
-        st.session_state['previous_data_source'] = data_source
-    
-    if st.session_state['previous_data_source'] != data_source:
-        # Data source changed - clear all structure-related session state
-        if 'selections' in st.session_state:
-            del st.session_state['selections']
-        if 'auto_initialized' in st.session_state:
-            del st.session_state['auto_initialized']
-        if 'results' in st.session_state:
-            del st.session_state['results']
-        if 'structure_data' in st.session_state:
-            del st.session_state['structure_data']
-        if 'reference_name' in st.session_state:
-            del st.session_state['reference_name']
-        st.session_state['previous_data_source'] = data_source
-        st.sidebar.info("🔄 Switched data source - session cleared")
-    
-    uploaded_files = []
-    
-    if data_source == "Upload Files":
-        uploaded_files_raw = st.sidebar.file_uploader(
-            "Upload RNA Motif PDB files",
-            type=['pdb', 'PDB'],
-            accept_multiple_files=True,
-            key="structures",
-            help="Upload all RNA motif structures to compare"
+    # Create temporary directory
+    if 'temp_dir' not in st.session_state:
+        st.session_state['temp_dir'] = tempfile.mkdtemp()
+    temp_dir = st.session_state['temp_dir']
+    
+    # Initialize session state
+    if 'data_mode' not in st.session_state:
+        st.session_state['data_mode'] = 'upload'
+    if 'ref_selections' not in st.session_state:
+        st.session_state['ref_selections'] = {}
+    if 'query_selections' not in st.session_state:
+        st.session_state['query_selections'] = {}
+    
+    # Sidebar: Step 1 - Data Source Selection
+    st.sidebar.title("⚙️ Configuration")
+    st.sidebar.subheader("1️⃣ Data Source")
+    
+    # Check if examples are available
+    if EXAMPLES_AVAILABLE:
+        data_mode = st.sidebar.radio(
+            "Choose data source",
+            ["Upload Files", "Use Example Data"],
+            key="data_mode_radio",
+            help="Upload your own PDB files or use provided examples"
         )
-        if uploaded_files_raw:
-            uploaded_files = list(uploaded_files_raw)
+    else:
+        st.sidebar.info("ℹ️ Example data not available. Using upload mode.")
+        data_mode = "Upload Files"
+    
+    # Update data mode
+    if data_mode == "Upload Files":
+        st.session_state['data_mode'] = 'upload'
+        # Reset example initialization when switching to upload mode
+        if 'example_mode_initialized' in st.session_state:
+            del st.session_state['example_mode_initialized']
+    else:
+        st.session_state['data_mode'] = 'example'
     
-    else:  # Use Examples
-        # Check if data folder exists
-        data_folder = "data"
-        examples = get_example_pdbs(data_folder)
+    # Step 2: File Upload/Selection - SEPARATE FOR REFERENCE AND QUERY
+    st.sidebar.subheader("2️⃣ Structure Files")
+    
+    reference_files = []
+    query_files = []
+    
+    if st.session_state['data_mode'] == 'upload':
+        st.sidebar.markdown("**Upload Reference Structures**")
+        ref_uploaded = st.sidebar.file_uploader(
+            "Reference PDB files",
+            type=['pdb'],
+            accept_multiple_files=True,
+            key="ref_uploader",
+            help="Upload one or more reference structures (e.g., Pentaloop)"
+        )
+        
+        st.sidebar.markdown("**Upload Query Structures**")
+        query_uploaded = st.sidebar.file_uploader(
+            "Query PDB files",
+            type=['pdb'],
+            accept_multiple_files=True,
+            key="query_uploader",
+            help="Upload one or more query structures (e.g., Tetraloop)"
+        )
+        
+        reference_files = ref_uploaded if ref_uploaded else []
+        query_files = query_uploaded if query_uploaded else []
         
-        if not examples:
-            st.sidebar.warning(f"⚠️ No example files found in '{data_folder}/' folder")
-            st.sidebar.info("💡 Create a 'data/' folder and add .pdb files to use examples")
+    else:  # Example data mode
+        if not EXAMPLES_AVAILABLE:
+            st.sidebar.error("❌ Example data loader module not found")
+            reference_files = []
+            query_files = []
         else:
-            st.sidebar.success(f"📁 Found {len(examples)} example files")
-            
-            # Show example info in expander
-            with st.sidebar.expander("📋 View Example Files"):
-                example_info = get_example_info(data_folder)
-                for name, info in sorted(example_info.items()):
-                    if 'error' not in info:
-                        st.caption(f"**{name}**")
-                        st.caption(f"  └ {info['atoms']} atoms")
-            
-            # Multiselect for examples
-            selected_names = st.sidebar.multiselect(
-                "Select example PDB files",
-                options=sorted(examples.keys()),
-                default=sorted(examples.keys())[:3] if len(examples) >= 3 else sorted(examples.keys()),
-                help="Choose one or more example structures"
-            )
-            
-            if selected_names:
-                # Convert example files to uploaded file format
-                for name in selected_names:
-                    uploaded_files.append(load_example_as_uploaded_file(examples[name]))
+            try:
+                examples = get_example_pdbs()
                 
-                st.sidebar.success(f"✅ Loaded {len(uploaded_files)} example file(s)")
-    
-    if not uploaded_files:
-        st.info("👈 Please upload RNA motif PDB files or select examples to begin analysis")
-        with st.expander("ℹ️ About this tool"):
-            st.markdown("""
-            ### Multi-Structure RNA Motif Comparison
-            
-            This tool compares multiple RNA motif structures simultaneously using window-based alignment.
-            
-            **Workflow:**
-            1. Upload PDB structures or use examples
-            2. Structures ranked by length (shortest first)
-            3. Select residues for each structure via dropdown
-            4. Choose reference structure (default: shortest)
-            5. Configure window size and type
-            6. Run comparison - all structures aligned to reference
-            7. View all structures superimposed in 3D
-            
-            **Features:**
-            - Window-based comparison (contiguous or non-contiguous)
-            - Best match selection per structure
-            - Interactive 3D visualization with all structures
-            - Color-coded structures
-            - RMSD-based alignment quality
-            - Example data for testing
-            
-            **Using Examples:**
-            - Create a folder named `data/` in your app directory
-            - Add .pdb files to the data folder
-            - Select "Use Examples" to load them
-            """)
-        return
-    
-    # Create temporary directory
-    temp_dir = tempfile.mkdtemp()
-    
-    # Save uploaded files
-    for file in uploaded_files:
-        save_uploaded_file(file, temp_dir)
-    
-    # Step 2: Rank structures by length and create dropdown
-    #st.sidebar.markdown("---")
-    st.sidebar.subheader("2️⃣ Structure Selection")
-    
-    # Get structure sizes
-    structure_data = []
-    for file in uploaded_files:
-        file_path = os.path.join(temp_dir, file.name)
-        residues = parse_residue_atoms(file_path)
-        structure_data.append({
-            'file': file,
-            'name': file.name,
-            'path': file_path,
-            'num_residues': len(residues),
-            'residues': residues
-        })
-    
-    # Sort by number of residues (shortest first)
-    structure_data.sort(key=lambda x: x['num_residues'])
-    
-    # Display ranked structures
-    st.markdown("---")
-    st.subheader("📊 Uploaded Structures (Ranked by Length)")
-    
-    rank_df = pd.DataFrame([
-        {'Rank': i+1, 'Filename': s['name'], 'Residues': s['num_residues']}
-        for i, s in enumerate(structure_data)
-    ])
-    st.dataframe(rank_df, use_container_width=True)
-    
-    # Step 3: Atom selection for each structure using dropdown
-    st.markdown("---")
-    st.subheader("🔬 Configure Atom Selections")
-    
-    # Dropdown to select structure
-    selected_structure_name = st.selectbox(
-        "Select structure to configure (excluding two bases in 5' and 3' by default)",
-        options=[s['name'] for s in structure_data],
-        help="Choose a structure to configure its residue selection"
-    )
-    
-    # Initialize session state for selections
-    if 'selections' not in st.session_state:
-        st.session_state['selections'] = {}
-    
-    # Track current file names to detect if files changed
-    current_file_names = set([s['name'] for s in structure_data])
-    if 'current_files' not in st.session_state:
-        st.session_state['current_files'] = current_file_names
-    
-    # If file set changed, reset auto-initialization
-    if st.session_state['current_files'] != current_file_names:
-        st.session_state['current_files'] = current_file_names
-        if 'auto_initialized' in st.session_state:
-            del st.session_state['auto_initialized']
-        # Clear old selections that don't match current files
-        old_selections = set(st.session_state['selections'].keys())
-        for old_name in old_selections - current_file_names:
-            del st.session_state['selections'][old_name]
-    
-    # Auto-initialize selections for all structures (exclude first and last residue)
-    if 'auto_initialized' not in st.session_state:
-        for struct in structure_data:
+                if not examples or len(examples) == 0:
+                    st.sidebar.error("❌ No example data available. Please add PDB files to 'data/' folder")
+                    st.sidebar.info("💡 Create a 'data/' folder in the same directory as the app and add .pdb files")
+                    reference_files = []
+                    query_files = []
+                else:
+                    example_names = sorted(list(examples.keys()))
+                    
+                    # Auto-select examples when first switching to example mode
+                    if 'example_mode_initialized' not in st.session_state:
+                        st.session_state['example_mode_initialized'] = True
+                        # Auto-select first half as reference, second half as query
+                        mid_point = max(1, len(example_names) // 2)
+                        st.session_state['auto_ref_examples'] = example_names[:mid_point]
+                        st.session_state['auto_query_examples'] = example_names[mid_point:mid_point*2]
+                    
+                    st.sidebar.markdown("**Select Reference Examples**")
+                    ref_example_names = st.sidebar.multiselect(
+                        "Reference structures",
+                        options=example_names,
+                        default=st.session_state.get('auto_ref_examples', []),
+                        key="ref_examples",
+                        help="Select example reference structures"
+                    )
+                    
+                    if ref_example_names:
+                        st.sidebar.success(f"✅ {len(ref_example_names)} reference file(s) selected")
+                    
+                    st.sidebar.markdown("**Select Query Examples**")
+                    query_example_names = st.sidebar.multiselect(
+                        "Query structures",
+                        options=example_names,
+                        default=st.session_state.get('auto_query_examples', []),
+                        key="query_examples",
+                        help="Select example query structures"
+                    )
+                    
+                    if query_example_names:
+                        st.sidebar.success(f"✅ {len(query_example_names)} query file(s) selected")
+                    
+                    # Convert names to paths and load files
+                    try:
+                        reference_files = [load_example_as_uploaded_file(examples[name]) for name in ref_example_names]
+                        query_files = [load_example_as_uploaded_file(examples[name]) for name in query_example_names]
+                            
+                    except Exception as load_error:
+                        st.sidebar.error(f"Error loading files: {str(load_error)}")
+                        import traceback
+                        st.sidebar.code(traceback.format_exc())
+                        reference_files = []
+                        query_files = []
+            except Exception as e:
+                st.sidebar.error(f"❌ Error loading examples: {str(e)}")
+                import traceback
+                st.sidebar.code(traceback.format_exc())
+                reference_files = []
+                query_files = []
+    
+    # Show upload status
+    if reference_files and query_files:
+        st.sidebar.success(f"✅ {len(reference_files)} reference + {len(query_files)} query structures")
+    elif reference_files:
+        st.sidebar.info(f"ℹ️ {len(reference_files)} reference structures loaded")
+    elif query_files:
+        st.sidebar.info(f"ℹ️ {len(query_files)} query structures loaded")
+    else:
+        st.sidebar.warning("⚠️ Upload or select structures")
+    
+    # Load structure data
+    ref_structure_data = []
+    query_structure_data = []
+    
+    if reference_files:
+        ref_structure_data = load_structure_data(reference_files, temp_dir)
+    
+    if query_files:
+        query_structure_data = load_structure_data(query_files, temp_dir)
+    
+    # Track current files to reset selections if files change
+    current_ref_files = set([s['name'] for s in ref_structure_data])
+    current_query_files = set([s['name'] for s in query_structure_data])
+    
+    if 'current_ref_files' not in st.session_state:
+        st.session_state['current_ref_files'] = current_ref_files
+    if 'current_query_files' not in st.session_state:
+        st.session_state['current_query_files'] = current_query_files
+    
+    # Reset selections if files changed
+    if st.session_state['current_ref_files'] != current_ref_files:
+        st.session_state['current_ref_files'] = current_ref_files
+        st.session_state['ref_selections'] = {}
+        if 'ref_auto_initialized' in st.session_state:
+            del st.session_state['ref_auto_initialized']
+    
+    if st.session_state['current_query_files'] != current_query_files:
+        st.session_state['current_query_files'] = current_query_files
+        st.session_state['query_selections'] = {}
+        if 'query_auto_initialized' in st.session_state:
+            del st.session_state['query_auto_initialized']
+    
+    # Auto-initialize selections (exclude first and last residue by default)
+    if 'ref_auto_initialized' not in st.session_state and ref_structure_data:
+        for struct in ref_structure_data:
             num_res = struct['num_residues']
-            if num_res > 4:  # Need at least 5 residues to do 2 to len-2
-                # Auto-select from index 1 to index len-2 (which is residue 2 to residue len-1)
+            if num_res > 4:
                 auto_selection = list(range(1, num_res - 1))
-                st.session_state['selections'][struct['name']] = auto_selection
+                st.session_state['ref_selections'][struct['name']] = auto_selection
             else:
-                # For small structures, use all residues
-                st.session_state['selections'][struct['name']] = list(range(num_res))
-        st.session_state['auto_initialized'] = True
+                st.session_state['ref_selections'][struct['name']] = list(range(num_res))
+        st.session_state['ref_auto_initialized'] = True
     
-    # Find selected structure data
-    selected_struct = next((s for s in structure_data if s['name'] == selected_structure_name), None)
+    if 'query_auto_initialized' not in st.session_state and query_structure_data:
+        for struct in query_structure_data:
+            num_res = struct['num_residues']
+            if num_res > 4:
+                auto_selection = list(range(1, num_res - 1))
+                st.session_state['query_selections'][struct['name']] = auto_selection
+            else:
+                st.session_state['query_selections'][struct['name']] = list(range(num_res))
+        st.session_state['query_auto_initialized'] = True
     
-    if selected_struct:
-        st.markdown(f"### {selected_struct['name']} ({selected_struct['num_residues']} residues)")
-        
-        # Display residue table
-        structure_info = get_structure_info(selected_struct['path'])
-        info_df = pd.DataFrame(structure_info)[['index', 'resnum', 'resname']]
-        info_df.columns = ['Index (0-based)', 'Residue Number', 'Base Type']
-        info_df['Index (1-based)'] = info_df['Index (0-based)'] + 1
-        info_df = info_df[['Index (1-based)', 'Index (0-based)', 'Residue Number', 'Base Type']]
-        
-        with st.expander(f"📋 View Residue Table", expanded=False):
-            st.dataframe(info_df, use_container_width=True, height=min(300, len(structure_info) * 35 + 38))
-        
-        # Selection method
-        selection_method = st.radio(
-            f"Selection method for {selected_struct['name']}",
-            ["Select by range", "Select specific residues", "Use all residues"],
-            key=f"method_{selected_struct['name']}",
-            index = 1,
-            horizontal=True
-        )
-        
-        selected_indices = []
-        
-        if selection_method == "Select by range":
-            # Get current saved selection or auto-initialized values
-            current_selection = st.session_state['selections'].get(selected_struct['name'], [])
-            default_start = current_selection[0] + 2 if current_selection else 2
-            default_end = current_selection[-1] + 1 if current_selection else max(2, len(structure_info) - 2)
+    # Step 3: Configure Atom Selections in Main Area
+    st.markdown("---")
+    st.subheader("🔬 Configure Atom Selections")
+    st.info("ℹ️ **Atom Selection:** Backbone + Sugar (default)")
+    
+    # Create two columns for Reference and Query
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### 📋 Reference Structures")
+        if ref_structure_data:
+            selected_ref_name = st.selectbox(
+                "Select structure to configure (excluding two bases in 5' and 3' by default)",
+                options=[s['name'] for s in ref_structure_data],
+                key="ref_dropdown",
+                help="Choose a reference structure to configure its residue selection"
+            )
             
-            col1, col2 = st.columns(2)
-            with col1:
-                start_idx = st.number_input(
-                    "Start index (1-based)",
-                    min_value=1,
-                    max_value=len(structure_info),
-                    value=default_start,
-                    key=f"start_{selected_struct['name']}"
-                )
-            with col2:
-                end_idx = st.number_input(
-                    "End index (1-based, inclusive)",
-                    min_value=1,
-                    max_value=len(structure_info),
-                    value=default_end,
-                    key=f"end_{selected_struct['name']}"
-                )
+            selected_ref = next((s for s in ref_structure_data if s['name'] == selected_ref_name), None)
             
-            if start_idx <= end_idx:
-                selected_indices = list(range(start_idx - 1, end_idx))
-                st.success(f"✓ Selected residues: {[i+1 for i in selected_indices]}")
-            else:
-                st.error("Start index must be ≤ end index")
+            if selected_ref:
+                st.markdown(f"**{selected_ref['name']}** ({selected_ref['num_residues']} residues)")
                 
-        elif selection_method == "Select specific residues":
-            # Get current selection or default
-            current_selection = st.session_state['selections'].get(selected_struct['name'], [])
-            default_names = [structure_info[i]['full_name'] for i in range(2, len(structure_info)-2)] if current_selection else []
-            
-            
-            
-            selected_names = st.multiselect(
-                "Select residues",
-                options=[info['full_name'] for info in structure_info],
-                default=default_names,
-                key=f"specific_{selected_struct['name']}"
+                # Display residue table
+                structure_info = get_structure_info(selected_ref['path'])
+                info_df = pd.DataFrame(structure_info)[['index', 'resnum', 'resname']]
+                info_df.columns = ['Index (0-based)', 'Residue Number', 'Base Type']
+                info_df['Index (1-based)'] = info_df['Index (0-based)'] + 1
+                info_df = info_df[['Index (1-based)', 'Index (0-based)', 'Residue Number', 'Base Type']]
+                
+                with st.expander("📋 View Residue Table", expanded=False):
+                    st.dataframe(info_df, use_container_width=True, height=min(300, len(structure_info) * 35 + 38))
+                
+                # Selection method
+                selection_method = st.radio(
+                    f"Selection method for {selected_ref['name']}",
+                    ["Select by range", "Select specific residues", "Use all residues"],
+                    key=f"method_ref_{selected_ref['name']}",
+                    index=1,
+                    horizontal=True
+                )
+                
+                selected_indices = []
+                
+                if selection_method == "Select by range":
+                    current_selection = st.session_state['ref_selections'].get(selected_ref['name'], [])
+                    default_start = current_selection[0] + 2 if current_selection else 3
+                    default_end = current_selection[-1] + 1 if current_selection else max(2, len(structure_info) - 2)
+                    
+                    c1, c2 = st.columns(2)
+                    with c1:
+                        start_idx = st.number_input(
+                            "Start index (1-based)",
+                            min_value=1,
+                            max_value=len(structure_info),
+                            value=default_start,
+                            key=f"start_ref_{selected_ref['name']}"
+                        )
+                    with c2:
+                        end_idx = st.number_input(
+                            "End index (1-based, inclusive)",
+                            min_value=1,
+                            max_value=len(structure_info),
+                            value=default_end,
+                            key=f"end_ref_{selected_ref['name']}"
+                        )
+                    
+                    if start_idx <= end_idx:
+                        selected_indices = list(range(start_idx - 1, end_idx))
+                        st.success(f"✓ Selected residues: {[i+1 for i in selected_indices]}")
+                    else:
+                        st.error("Start index must be ≤ end index")
+                        
+                elif selection_method == "Select specific residues":
+                    current_selection = st.session_state['ref_selections'].get(selected_ref['name'], [])
+                    default_names = [structure_info[i]['full_name'] for i in current_selection] if current_selection else []
+                    
+                    selected_names = st.multiselect(
+                        "Select residues",
+                        options=[info['full_name'] for info in structure_info],
+                        default=[structure_info[i]['full_name'] for i in range(2, len(structure_info)-2)],
+                        key=f"specific_ref_{selected_ref['name']}"
+                    )
+                    
+                    name_to_idx = {info['full_name']: info['index'] for info in structure_info}
+                    selected_indices = [name_to_idx[name] for name in selected_names]
+                    selected_indices.sort()
+                    
+                    if selected_indices:
+                        st.success(f"✓ Selected {len(selected_indices)} residues: {[i+1 for i in selected_indices]}")
+                        
+                else:  # Use all residues
+                    selected_indices = list(range(len(structure_info)))
+                    st.info(f"✓ Using all {len(selected_indices)} residues")
+                
+                # Save button
+                if st.button(f"💾 Save Selection for {selected_ref['name']}", type="primary", key=f"save_ref_{selected_ref['name']}"):
+                    st.session_state['ref_selections'][selected_ref['name']] = selected_indices
+                    st.success(f"✅ Saved selection for {selected_ref['name']}")
+                
+                # Show current saved selection
+                if selected_ref['name'] in st.session_state['ref_selections']:
+                    saved_indices = st.session_state['ref_selections'][selected_ref['name']]
+                    st.info(f"**Current saved selection:** {len(saved_indices)} residues: {[i+1 for i in saved_indices]}")
+        else:
+            st.info("Upload reference structures to configure")
+    
+    with col2:
+        st.markdown("### 📋 Query Structures")
+        if query_structure_data:
+            selected_query_name = st.selectbox(
+                "Select structure to configure (excluding two bases in 5' and 3' by default)",
+                options=[s['name'] for s in query_structure_data],
+                key="query_dropdown",
+                help="Choose a query structure to configure its residue selection"
             )
             
-            name_to_idx = {info['full_name']: info['index'] for info in structure_info}
-            selected_indices = [name_to_idx[name] for name in selected_names]
-            selected_indices.sort()
+            selected_query = next((s for s in query_structure_data if s['name'] == selected_query_name), None)
             
-            if selected_indices:
-                st.success(f"✓ Selected {len(selected_indices)} residues: {[i+1 for i in selected_indices]}")
+            if selected_query:
+                st.markdown(f"**{selected_query['name']}** ({selected_query['num_residues']} residues)")
                 
-        else:  # Use all residues
-            selected_indices = list(range(len(structure_info)))
-            st.info(f"✓ Using all {len(selected_indices)} residues")
-        
-        # Save selection button
-        if st.button(f"💾 Save Selection for {selected_struct['name']}", type="primary"):
-            st.session_state['selections'][selected_struct['name']] = selected_indices
-            st.success(f"✅ Saved selection for {selected_struct['name']}")
-        
-        # Show current saved selections
-        if selected_struct['name'] in st.session_state['selections']:
-            saved_indices = st.session_state['selections'][selected_struct['name']]
-            st.info(f"**Current saved selection:** {len(saved_indices)} residues: {[i+1 for i in saved_indices]}")
-    
-    # Step 4: Reference structure selection
-    #st.sidebar.markdown("---")
-    st.sidebar.subheader("3️⃣ Reference Structure")
-    
-    # Default: shortest structure (first in sorted list)
-    default_ref = structure_data[0]['name']
-    
-    reference_structure_name = st.sidebar.selectbox(
-        "Select reference structure",
-        options=[s['name'] for s in structure_data],
-        index=0,
-        help="All other structures will be aligned to this reference (default: shortest)"
-    )
-    
-    ref_struct = next((s for s in structure_data if s['name'] == reference_structure_name), None)
-    if ref_struct:
-        st.sidebar.info(f"**Reference:** {ref_struct['name']} ({ref_struct['num_residues']} residues)")
+                # Display residue table
+                structure_info = get_structure_info(selected_query['path'])
+                info_df = pd.DataFrame(structure_info)[['index', 'resnum', 'resname']]
+                info_df.columns = ['Index (0-based)', 'Residue Number', 'Base Type']
+                info_df['Index (1-based)'] = info_df['Index (0-based)'] + 1
+                info_df = info_df[['Index (1-based)', 'Index (0-based)', 'Residue Number', 'Base Type']]
+                
+                with st.expander("📋 View Residue Table", expanded=False):
+                    st.dataframe(info_df, use_container_width=True, height=min(300, len(structure_info) * 35 + 38))
+                
+                # Selection method
+                selection_method = st.radio(
+                    f"Selection method for {selected_query['name']}",
+                    ["Select by range", "Select specific residues", "Use all residues"],
+                    key=f"method_query_{selected_query['name']}",
+                    index=1,
+                    horizontal=True
+                )
+                
+                selected_indices = []
+                
+                if selection_method == "Select by range":
+                    current_selection = st.session_state['query_selections'].get(selected_query['name'], [])
+                    default_start = current_selection[0] + 2 if current_selection else 3
+                    default_end = current_selection[-1] + 1 if current_selection else max(2, len(structure_info) - 2)
+                    
+                    c1, c2 = st.columns(2)
+                    with c1:
+                        start_idx = st.number_input(
+                            "Start index (1-based)",
+                            min_value=1,
+                            max_value=len(structure_info),
+                            value=default_start,
+                            key=f"start_query_{selected_query['name']}"
+                        )
+                    with c2:
+                        end_idx = st.number_input(
+                            "End index (1-based, inclusive)",
+                            min_value=1,
+                            max_value=len(structure_info),
+                            value=default_end,
+                            key=f"end_query_{selected_query['name']}"
+                        )
+                    
+                    if start_idx <= end_idx:
+                        selected_indices = list(range(start_idx - 1, end_idx))
+                        st.success(f"✓ Selected residues: {[i+1 for i in selected_indices]}")
+                    else:
+                        st.error("Start index must be ≤ end index")
+                        
+                elif selection_method == "Select specific residues":
+                    current_selection = st.session_state['query_selections'].get(selected_query['name'], [])
+                    default_names = [structure_info[i]['full_name'] for i in current_selection] if current_selection else []
+                    
+                    selected_names = st.multiselect(
+                        "Select residues",
+                        options=[info['full_name'] for info in structure_info],
+                        default=[structure_info[i]['full_name'] for i in range(2, len(structure_info)-2)],
+                        key=f"specific_query_{selected_query['name']}"
+                    )
+                    
+                    name_to_idx = {info['full_name']: info['index'] for info in structure_info}
+                    selected_indices = [name_to_idx[name] for name in selected_names]
+                    selected_indices.sort()
+                    
+                    if selected_indices:
+                        st.success(f"✓ Selected {len(selected_indices)} residues: {[i+1 for i in selected_indices]}")
+                        
+                else:  # Use all residues
+                    selected_indices = list(range(len(structure_info)))
+                    st.info(f"✓ Using all {len(selected_indices)} residues")
+                
+                # Save button
+                if st.button(f"💾 Save Selection for {selected_query['name']}", type="primary", key=f"save_query_{selected_query['name']}"):
+                    st.session_state['query_selections'][selected_query['name']] = selected_indices
+                    st.success(f"✅ Saved selection for {selected_query['name']}")
+                
+                # Show current saved selection
+                if selected_query['name'] in st.session_state['query_selections']:
+                    saved_indices = st.session_state['query_selections'][selected_query['name']]
+                    st.info(f"**Current saved selection:** {len(saved_indices)} residues: {[i+1 for i in saved_indices]}")
+        else:
+            st.info("Upload query structures to configure")
     
-    # Step 5: Window configuration
-    #st.sidebar.markdown("---")
-    st.sidebar.subheader("4️⃣ Window Configuration")
+    # Step 4: Window Configuration
+    st.sidebar.subheader("3️⃣ Window Configuration")
     
     # Check if all structures have selections
-    all_have_selections = all(s['name'] in st.session_state.get('selections', {}) for s in structure_data)
+    all_ref_have_selections = all(s['name'] in st.session_state['ref_selections'] for s in ref_structure_data)
+    all_query_have_selections = all(s['name'] in st.session_state['query_selections'] for s in query_structure_data)
     
-    if all_have_selections:
-        selections = st.session_state['selections']
-        min_selection_size = min(len(selections[s['name']]) for s in structure_data)
+    if all_ref_have_selections and all_query_have_selections and ref_structure_data and query_structure_data:
+        # Find minimum selection size
+        all_selections = list(st.session_state['ref_selections'].values()) + list(st.session_state['query_selections'].values())
+        min_selection_size = min(len(sel) for sel in all_selections)
         
         window_size = st.sidebar.number_input(
             "Window Size",
@@ -613,92 +742,83 @@ def main():
             help="Contiguous: sliding windows. Non-contiguous: all combinations"
         )
     else:
-        st.sidebar.warning("⚠️ Configure selections for all structures first")
+        st.sidebar.warning("⚠️ Configure selections first")
         window_size = 4
         window_type = "contiguous"
     
-    # Step 6: Run analysis
-    #st.sidebar.markdown("---")
-    st.sidebar.subheader("5️⃣ Run Analysis")
+    # Step 5: Run Analysis
+    st.sidebar.subheader("4️⃣ Run Analysis")
     
-    if st.sidebar.button("🚀 Run Multi-Structure Analysis", type="primary", disabled=not all_have_selections):
-        if not all_have_selections:
-            st.error("Please configure atom selections for all structures")
-            return
-        
-        # Get selections
-        selections = st.session_state['selections']
-        
-        # Find reference structure
-        ref_struct = next((s for s in structure_data if s['name'] == reference_structure_name), None)
-        ref_indices = selections[ref_struct['name']]
-        
-        # Generate reference windows
-        ref_windows = generate_windows_from_selection(ref_indices, window_size, window_type)
-        
-        if not ref_windows:
-            st.error(f"Reference structure needs at least {window_size} selected residues")
+    can_run = (all_ref_have_selections and all_query_have_selections and 
+               ref_structure_data and query_structure_data)
+    
+    if st.sidebar.button("🚀 Run Pairwise Analysis", type="primary", disabled=not can_run):
+        if not can_run:
+            st.error("Please upload and configure both reference and query structures")
             return
         
         # Run comparisons
         with st.spinner("Analyzing structures..."):
             results = []
             
-            # For each reference window
-            for ref_window in ref_windows:
-                # Extract reference coords
-                ref_coords = extract_window_coords(ref_struct['residues'], ref_window)
-                ref_com = calculate_COM(ref_coords)
-                ref_sequence = ''.join([ref_struct['residues'][i]['resname'] for i in ref_window])
+            # For each reference structure
+            for ref_struct in ref_structure_data:
+                ref_indices = st.session_state['ref_selections'][ref_struct['name']]
+                ref_windows = generate_windows_from_selection(ref_indices, window_size, window_type)
                 
-                # Compare against all other structures
-                for query_struct in structure_data:
-                    if query_struct['name'] == ref_struct['name']:
-                        continue  # Skip self-comparison
-                    
-                    query_indices = selections[query_struct['name']]
-                    query_windows = generate_windows_from_selection(query_indices, window_size, window_type)
+                if not ref_windows:
+                    continue
+                
+                # For each reference window
+                for ref_window in ref_windows:
+                    # Extract reference coords
+                    ref_coords = extract_window_coords(ref_struct['residues'], ref_window)
+                    ref_com = calculate_COM(ref_coords)
+                    ref_sequence = ''.join([ref_struct['residues'][i]['resname'] for i in ref_window])
                     
-                    for query_window in query_windows:
-                        # Extract query coords
-                        query_coords = extract_window_coords(query_struct['residues'], query_window)
-                        query_com = calculate_COM(query_coords)
-                        query_sequence = ''.join([query_struct['residues'][i]['resname'] for i in query_window])
-                        
-                        # Calculate RMSD
-                        U, RMSD = calculate_rotation_rmsd(ref_coords, query_coords, ref_com, query_com)
-                        
-                        if U is None or RMSD is None:
-                            RMSD = 999.0
-                            U = np.eye(3)
+                    # Compare against all query structures
+                    for query_struct in query_structure_data:
+                        query_indices = st.session_state['query_selections'][query_struct['name']]
+                        query_windows = generate_windows_from_selection(query_indices, window_size, window_type)
                         
-                        results.append({
-                            'Reference': ref_struct['name'],
-                            'Ref_Window': ref_window,
-                            'Ref_Sequence': ref_sequence,
-                            'Query': query_struct['name'],
-                            'Query_Window': query_window,
-                            'Query_Sequence': query_sequence,
-                            'RMSD': RMSD,
-                            'Rotation_Matrix': U,
-                            'Ref_COM': ref_com,
-                            'Query_COM': query_com,
-                            'Ref_Path': ref_struct['path'],
-                            'Query_Path': query_struct['path']
-                        })
+                        for query_window in query_windows:
+                            # Extract query coords
+                            query_coords = extract_window_coords(query_struct['residues'], query_window)
+                            query_com = calculate_COM(query_coords)
+                            query_sequence = ''.join([query_struct['residues'][i]['resname'] for i in query_window])
+                            
+                            # Calculate RMSD
+                            U, RMSD = calculate_rotation_rmsd(ref_coords, query_coords, ref_com, query_com)
+                            
+                            if U is None or RMSD is None:
+                                RMSD = 999.0
+                                U = np.eye(3)
+                            
+                            results.append({
+                                'Reference': ref_struct['name'],
+                                'Ref_Window': ref_window,
+                                'Ref_Sequence': ref_sequence,
+                                'Query': query_struct['name'],
+                                'Query_Window': query_window,
+                                'Query_Sequence': query_sequence,
+                                'RMSD': RMSD,
+                                'Rotation_Matrix': U,
+                                'Ref_COM': ref_com,
+                                'Query_COM': query_com,
+                                'Ref_Path': ref_struct['path'],
+                                'Query_Path': query_struct['path']
+                            })
             
             results_df = pd.DataFrame(results)
             st.session_state['results'] = results_df
-            st.session_state['structure_data'] = structure_data
-            st.session_state['reference_name'] = reference_structure_name
+            st.session_state['ref_structure_data'] = ref_structure_data
+            st.session_state['query_structure_data'] = query_structure_data
             
             st.success(f"✅ Analysis complete! {len(results_df)} comparisons performed.")
     
     # Display results
     if 'results' in st.session_state:
         results_df = st.session_state['results']
-        structure_data = st.session_state['structure_data']
-        reference_name = st.session_state['reference_name']
         
         st.markdown("---")
         st.subheader("📊 Results Summary")
@@ -719,49 +839,57 @@ def main():
         with col2:
             st.metric("Comparisons Below Threshold", f"{len(filtered_df)} / {len(results_df)}")
         
-        # Best match per structure
-        st.markdown("### 🏆 Best Match per Structure")
-        best_matches = results_df.loc[results_df.groupby('Query')['RMSD'].idxmin()]
+        # Best match per Reference-Query pair
+        st.markdown("### 🏆 Best Match per Reference-Query Pair")
         
-        best_display = best_matches[['Query', 'Query_Sequence', 'RMSD']].copy()
-        best_display['RMSD'] = best_display['RMSD'].round(3)
-        best_display.columns = ['Structure', 'Sequence', 'RMSD (Å)']
-        st.dataframe(best_display, use_container_width=True)
+        if len(filtered_df) > 0:
+            # Group by Reference and Query to find best match for each pair
+            best_matches = filtered_df.loc[filtered_df.groupby(['Reference', 'Query'])['RMSD'].idxmin()]
+            
+            best_display = best_matches[['Reference', 'Query', 'Ref_Sequence', 'Query_Sequence', 'RMSD']].copy()
+            best_display['RMSD'] = best_display['RMSD'].round(3)
+            best_display.columns = ['Reference', 'Query', 'Ref Sequence', 'Query Sequence', 'RMSD (Å)']
+            st.dataframe(best_display, use_container_width=True)
+        else:
+            st.warning("No matches found below threshold")
         
         # Full results
         with st.expander("📋 All Comparison Results"):
-            display_df = filtered_df[['Reference', 'Ref_Window', 'Ref_Sequence', 'Query', 'Query_Window', 'Query_Sequence', 'RMSD']].copy()
-            
-            # Format the window indices to be 1-based (more intuitive for users)
-            display_df['Ref_Residues'] = display_df['Ref_Window'].apply(lambda x: ','.join([str(i+1) for i in x]))
-            display_df['Query_Residues'] = display_df['Query_Window'].apply(lambda x: ','.join([str(i+1) for i in x]))
-            
-            # Reorder columns and drop the window lists
-            display_df = display_df[['Reference', 'Ref_Residues', 'Ref_Sequence', 'Query', 'Query_Residues', 'Query_Sequence', 'RMSD']]
-            display_df['RMSD'] = display_df['RMSD'].round(3)
-            display_df = display_df.sort_values('RMSD').reset_index(drop=True)
-            
-            # Rename columns for better display
-            display_df.columns = ['Reference', 'Ref_Indices', 'Ref_Sequence', 'Query', 'Query_Indices', 'Query_Sequence', 'RMSD']
-            
-            st.dataframe(display_df, use_container_width=True, height=300)
+            if len(filtered_df) > 0:
+                display_df = filtered_df[['Reference', 'Ref_Window', 'Ref_Sequence', 'Query', 'Query_Window', 'Query_Sequence', 'RMSD']].copy()
+                
+                # Format the window indices to be 1-based
+                display_df['Ref_Residues'] = display_df['Ref_Window'].apply(lambda x: ','.join([str(i+1) for i in x]))
+                display_df['Query_Residues'] = display_df['Query_Window'].apply(lambda x: ','.join([str(i+1) for i in x]))
+                
+                # Reorder columns
+                display_df = display_df[['Reference', 'Ref_Residues', 'Ref_Sequence', 'Query', 'Query_Residues', 'Query_Sequence', 'RMSD']]
+                display_df['RMSD'] = display_df['RMSD'].round(3)
+                display_df = display_df.sort_values('RMSD').reset_index(drop=True)
+                
+                # Rename columns for better display
+                display_df.columns = ['Reference', 'Ref_Indices', 'Ref_Sequence', 'Query', 'Query_Indices', 'Query_Sequence', 'RMSD (Å)']
+                
+                st.dataframe(display_df, use_container_width=True, height=400)
+            else:
+                st.info("No results to display")
         
         # Visualization
         st.markdown("---")
         st.subheader("🔬 3D Structure Visualization")
         
-        st.markdown("**Select a comparison to visualize:**")
-        
-        # Create dropdown options showing all comparisons
-        viz_options = []
-        for idx, row in filtered_df.iterrows():
-            ref_res_str = ','.join([str(i+1) for i in row['Ref_Window']])
-            query_res_str = ','.join([str(i+1) for i in row['Query_Window']])
-            option_text = f"{row['Reference']}[{ref_res_str}] ({row['Ref_Sequence']}) vs {row['Query']}[{query_res_str}] ({row['Query_Sequence']}) | RMSD: {row['RMSD']:.3f} Å"
-            viz_options.append((idx, option_text))
-        
-        if viz_options:
-            # Sort by RMSD (best first)
+        if len(filtered_df) > 0:
+            st.markdown("**Select a comparison to visualize:**")
+            
+            # Create dropdown options
+            viz_options = []
+            for idx, row in filtered_df.iterrows():
+                ref_res_str = ','.join([str(i+1) for i in row['Ref_Window']])
+                query_res_str = ','.join([str(i+1) for i in row['Query_Window']])
+                option_text = f"{row['Reference']}[{ref_res_str}] ({row['Ref_Sequence']}) vs {row['Query']}[{query_res_str}] ({row['Query_Sequence']}) | RMSD: {row['RMSD']:.3f} Å"
+                viz_options.append((idx, option_text))
+            
+            # Sort by RMSD
             viz_options.sort(key=lambda x: filtered_df.loc[x[0], 'RMSD'])
             
             selected_viz_idx = st.selectbox(
@@ -777,7 +905,7 @@ def main():
             # Import visualization function
             from visualization_multi import create_pairwise_visualization
             
-            # Create visualization for selected comparison
+            # Create visualization
             try:
                 viz_html = create_pairwise_visualization(
                     ref_path=selected_comparison['Ref_Path'],
@@ -800,6 +928,85 @@ def main():
                 st.code(traceback.format_exc())
         else:
             st.warning("No comparisons below RMSD threshold to visualize")
+        
+        # Export Results
+        st.markdown("---")
+        st.subheader("💾 Export Results")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("**Download Results Table**")
+            if len(filtered_df) > 0:
+                export_df = filtered_df[['Reference', 'Ref_Window', 'Ref_Sequence', 'Query', 'Query_Window', 'Query_Sequence', 'RMSD']].copy()
+                export_df['Ref_Residues'] = export_df['Ref_Window'].apply(lambda x: ','.join([str(i+1) for i in x]))
+                export_df['Query_Residues'] = export_df['Query_Window'].apply(lambda x: ','.join([str(i+1) for i in x]))
+                export_df = export_df[['Reference', 'Ref_Residues', 'Ref_Sequence', 'Query', 'Query_Residues', 'Query_Sequence', 'RMSD']]
+                export_df = export_df.sort_values('RMSD').reset_index(drop=True)
+                
+                csv = export_df.to_csv(index=False)
+                st.download_button(
+                    label="📥 Download Results (CSV)",
+                    data=csv,
+                    file_name="rna_pairwise_comparison_results.csv",
+                    mime="text/csv"
+                )
+            else:
+                st.info("No results to export")
+        
+        with col2:
+            st.markdown("**Download Aligned Structures**")
+            if len(filtered_df) > 0 and st.button("📦 Generate PDB Archive"):
+                with st.spinner("Creating archive..."):
+                    import zipfile
+                    from visualization_multi import extract_window_pdb, transform_pdb_string
+                    
+                    zip_buffer = io.BytesIO()
+                    
+                    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                        for idx, row in filtered_df.iterrows():
+                            comp_name = f"comp_{idx:03d}_rmsd_{row['RMSD']:.3f}"
+                            
+                            # Reference
+                            ref_pdb = extract_window_pdb(row['Ref_Path'], row['Ref_Window'])
+                            zip_file.writestr(f"{comp_name}/reference.pdb", ref_pdb)
+                            
+                            # Query original
+                            query_pdb = extract_window_pdb(row['Query_Path'], row['Query_Window'])
+                            zip_file.writestr(f"{comp_name}/query_original.pdb", query_pdb)
+                            
+                            # Query aligned
+                            query_aligned = transform_pdb_string(
+                                query_pdb,
+                                row['Rotation_Matrix'],
+                                row['Query_COM'],
+                                row['Ref_COM']
+                            )
+                            zip_file.writestr(f"{comp_name}/query_aligned.pdb", query_aligned)
+                            
+                            # README
+                            readme = f"""Comparison #{idx}
+RMSD: {row['RMSD']:.3f} Å
+Atom Selection: Backbone + Sugar (default)
+
+Reference: {row['Reference']}
+  Residues: {','.join([str(i+1) for i in row['Ref_Window']])}
+  Sequence: {row['Ref_Sequence']}
+
+Query: {row['Query']}
+  Residues: {','.join([str(i+1) for i in row['Query_Window']])}
+  Sequence: {row['Query_Sequence']}
+"""
+                            zip_file.writestr(f"{comp_name}/README.txt", readme)
+                    
+                    zip_buffer.seek(0)
+                    
+                    st.download_button(
+                        label="📥 Download ZIP",
+                        data=zip_buffer.getvalue(),
+                        file_name="aligned_structures.zip",
+                        mime="application/zip"
+                    )
 
 
 if __name__ == "__main__":