LD-FPG-main/conditional_generation/chebnet_conditional_setup.py

################################################################################
# %% Imports
################################################################################
import os
import sys
import json
import yaml
import argparse
import logging
import h5py
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import math
import time
import random
import mdtraj as md
from typing import Dict, List, Optional, Tuple, Any

from torch_geometric.data import Data
from torch_geometric.loader import DataLoader
from torch_geometric.nn import ChebConv, global_mean_pool
from torch_cluster import knn_graph
from sklearn.model_selection import train_test_split
from sklearn.neighbors import NearestNeighbors # New dependency

# (NEW) Local flag to control output verbosity
DISABLE_DETAILED_OUTPUTS = True # Set to True to skip non-essential file exports


################################################################################
# (A) Argument Parsing
################################################################################
parser = argparse.ArgumentParser(
    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
)
parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
args = parser.parse_args()

################################################################################
# (B) Pre-Logging Config Load
################################################################################
LOG_FILE_DEFAULT = "logfile_multi_system.log"
log_file_path = LOG_FILE_DEFAULT
try:
    with open(args.config, "r") as f:
        temp_config = yaml.safe_load(f)
        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
except Exception as e:
    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")

################################################################################
# (C) Logging Setup
################################################################################
logger = logging.getLogger("ProteinReconstruction")
logger.setLevel(logging.DEBUG if args.debug else logging.INFO)

if not logger.handlers:
    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
    try:
        fh = logging.FileHandler(log_file_path, mode="w")
        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
        fh.setFormatter(formatter)
        logger.addHandler(fh)
    except IOError as e:
        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
    ch = logging.StreamHandler(sys.stdout)
    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
    ch.setFormatter(formatter)
    logger.addHandler(ch)

logger.info(f"Logger initialized. Log file: {log_file_path}")
if args.debug: logger.debug("Debug mode is ON.")

################################################################################
# (D) Device Setup (Global)
################################################################################
device_name = "cpu"
if torch.cuda.is_available():
    try:
        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
        device_name = f"cuda:{cuda_device_index}"
        torch.cuda.get_device_name(cuda_device_index)
    except Exception:
        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
        if torch.cuda.is_available(): device_name = "cuda:0"
global_device = torch.device(device_name)
logger.info(f"Initial device check: {global_device}")


################################################################################
# (E) Utility Functions
################################################################################

# --- PDB Parsing ---
def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
    chain_map = {}; chain_idx_counter = 0
    try:
        with open(filename, 'r') as pdb_file:
            for line in pdb_file:
                if not line.startswith("ATOM  "): continue
                alt_loc = line[16].strip()
                if alt_loc not in ['', 'A']: continue

                atom_serial = int(line[6:11])
                if atom_serial in processed_atom_indices: continue
                processed_atom_indices.add(atom_serial)

                atom_name = line[12:16].strip()
                res_name = line[17:20].strip()
                chain_id_char = line[21].strip()
                if chain_id_char not in chain_map:
                    chain_map[chain_id_char] = chain_idx_counter
                    chain_idx_counter += 1
                chain_id_int = chain_map[chain_id_char]

                res_seq = int(line[22:26])
                orig_res_id = f"{chain_id_int}:{res_name}:{res_seq}"
                category = "backbone" if atom_name in backbone_atoms else "sidechain"

                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
                if atom_name == 'CA': ca_indices[res_seq] = atom_serial

    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
    return {}, atoms_in_order, ca_indices

def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int], Dict]:
    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
    new_res_dict, orig_atom_map = {}, {}
    next_new_res_id, next_new_atom_index = 0, 0
    orig_res_map = {}
    
    # Preserve original residue order
    seen_res_order = {}
    res_order_counter = 0
    for r_id, _, _, _ in atoms_in_order:
        if r_id not in seen_res_order:
            seen_res_order[r_id] = res_order_counter
            res_order_counter += 1

    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
    sortable.sort()

    for _, serial, r_id, cat, name in sortable:
        if r_id not in orig_res_map:
            orig_res_map[r_id] = next_new_res_id
            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
            next_new_res_id += 1
        
        new_res_id = orig_res_map[r_id]
        new_res_dict[new_res_id][cat].append(next_new_atom_index)
        orig_atom_map[serial] = next_new_atom_index
        next_new_atom_index += 1

    # Map original CA serial numbers to the new, renumbered 0-based indices
    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
    
    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
    return new_res_dict, orig_atom_map, {}, new_ca_indices, orig_res_map


def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
    bb_idx, sc_idx = [], []
    for res_id in sorted(renumbered_dict.keys()):
        bb_idx.extend(renumbered_dict[res_id]["backbone"])
        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)

# --- JSON Loading ---
def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger, max_frames: Optional[int] = None) -> Tuple[List[torch.Tensor], int]:
    logger.info(f"Loading coordinates from JSON: {json_file}")
    try:
        with open(json_file, "r") as f: data = json.load(f)
    except (FileNotFoundError, json.JSONDecodeError) as e:
        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
    
    try:
        keys_int = sorted([int(k) for k in data.keys()])
        keys_str = [str(k) for k in keys_int]
        if not keys_str: logger.error("No residue data in JSON."); return [], -1
        
        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
        n_frames_total = len(frame_data)
        if n_frames_total == 0: logger.warning("JSON contains 0 frames."); return [], 0

        frame_indices_to_load = range(n_frames_total)
        if max_frames is not None and max_frames > 0 and max_frames < n_frames_total:
            logger.info(f"Randomly sampling {max_frames} frames out of {n_frames_total} available.")
            frame_indices_to_load = sorted(random.sample(range(n_frames_total), max_frames))
        else:
            logger.info(f"Loading all {n_frames_total} available frames.")

        coords_frames, n_atoms_check = [], -1
        for frame_idx in frame_indices_to_load:
            frame_coords_np = []
            current_atoms = 0
            for res_key in keys_str:
                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
                frame_coords_np.append(coords)
                current_atoms += coords.shape[0]

            if n_atoms_check == -1:
                n_atoms_check = current_atoms
                logger.info(f"System has {n_atoms_check} atoms and {len(frame_indices_to_load)} frames will be loaded.")
            elif current_atoms != n_atoms_check:
                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
            
            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))

        return coords_frames, n_atoms_check
    except Exception as e:
        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1

# --- Alignment ---
def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)

def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
    C = torch.bmm(Q_c.transpose(1, 2), P_c)
    try: V, S, Wt = torch.linalg.svd(C)
    except Exception as e:
        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)

def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
    if not coords: logger.warning("Coordinate list empty."); return []
    ref = coords[0].to(device)
    aligned = [coords[0].cpu()]
    n_frames = len(coords) -1
    for i, frame in enumerate(coords[1:], 1):
        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
        aligned.append(aligned_dev.cpu())
    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
    return aligned

# --- ROBUST ALIGNMENT UTILITIES for MULTI-SYSTEM ---
def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
        raise ValueError("Input coordinates must be 2D arrays.")

    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
    
    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
    
    ref_indices, target_indices = [], []
    for i, target_idx in enumerate(indices1.flatten()):
        # *** PATCH 1: Correctly index the result from kneighbors ***
        if indices2[target_idx, 0] == i:
            ref_indices.append(i)
            target_indices.append(target_idx)
            
    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
    if not ref_indices:
        logger.error("No mutual nearest neighbors found. Cannot align structures.")
        return torch.tensor([]), torch.tensor([])
        
    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)

def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
                  logger: logging.Logger) -> torch.Tensor:
    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
    device = structure_to_align.device

    P_core = reference_structure[core_indices_reference].to(device)
    Q_core = structure_to_align[core_indices_to_align].to(device)
    
    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
    
    centroid_Q_core = compute_centroid(Q_core)
    structure_to_align_centered = structure_to_align - centroid_Q_core
    
    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
    
    centroid_P_core = compute_centroid(P_core)
    aligned_structure = structure_to_align_rotated + centroid_P_core
    
    return aligned_structure

# --- Graph Dataset ---
def build_graph_dataset(aligned_coords_list: List[torch.Tensor], unaligned_coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
    dataset = []
    n_frames = len(aligned_coords_list)
    logger.debug(f"[Graph Build] Building dataset for system {system_id} with {n_frames} frames. First frame coord shape: {aligned_coords_list[0].shape}")
    for i, (aligned_coords_cpu, unaligned_coords_cpu) in enumerate(zip(aligned_coords_list, unaligned_coords_list)):
        coords_dev = aligned_coords_cpu.to(device)
        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
        if logger.isEnabledFor(logging.DEBUG) and i == 0:
            logger.debug(f"[Graph Build] Frame 0: coords_cpu shape: {aligned_coords_cpu.shape}, edge_index shape: {edge_idx.shape}")
        data = Data(x=aligned_coords_cpu, edge_index=edge_idx.cpu(), y=aligned_coords_cpu, y_unaligned=unaligned_coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
        dataset.append(data)
    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
    return dataset

# --- Dihedral Utilities ---
@torch.jit.script
def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)

def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
    if logger.isEnabledFor(logging.DEBUG):
        logger.debug(f"[Dihedral Calc] Input coords shape: {coords.shape}")
    for name, angle_info in info.items():
        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
        if indices is not None and res_idx is not None and indices[0].numel() > 0:
            try:
                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
                max_atom_idx_needed = max(i.max() for i in idx_dev)
                if max_atom_idx_needed >= N_atoms:
                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
                    continue
                
                a,b,c,d = (coords[:, i, :] for i in idx_dev)
                values = compute_dihedral(a,b,c,d)
                if logger.isEnabledFor(logging.DEBUG):
                    logger.debug(f"[Dihedral Calc] Angle '{name}': computed values shape: {values.shape}, scatter indices shape: {res_idx_dev.shape}")
                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
        all_angles[name] = angles_out
    return all_angles


def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
    eps=1e-10
    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
    p_dist = p_hist / (p_hist.sum() + eps)
    t_dist = t_hist / (t_hist.sum() + eps)
    m_dist = 0.5 * (p_dist + t_dist)
    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))

# --- Data Augmentation Utilities ---
def calculate_ca_rmsd(coords1: torch.Tensor, coords2: torch.Tensor, ca_indices: torch.Tensor) -> torch.Tensor:
    """Calculates C-alpha RMSD between two coordinate tensors."""
    ca_coords1 = coords1[ca_indices]
    ca_coords2 = coords2[ca_indices]
    return torch.sqrt(torch.mean((ca_coords1 - ca_coords2) ** 2))

def find_optimal_sigma(X_ref: torch.Tensor, ca_indices: torch.Tensor, target_rmsd: float, logger: logging.Logger, 
                       initial_sigma: float = 0.5, tolerance: float = 0.1, max_iter: int = 10) -> float:
    """
    Finds the optimal sigma for noise generation to meet a target C-alpha RMSD
    by directly comparing the noisy structure to the reference, without model inference.
    """
    sigma = initial_sigma
    X_ref_ca = X_ref[ca_indices].cpu() # Work with C-alpha atoms on CPU for simplicity

    logger.info(f"[Sigma Calibration] Starting calibration for target RMSD {target_rmsd:.3f} Å")
    for i in range(max_iter):
        # Generate one noisy sample by adding noise to a CLONE of the reference
        noise = torch.randn_like(X_ref) * sigma
        X_noisy = X_ref.clone() + noise
        X_noisy_ca = X_noisy[ca_indices].cpu()
        
        # Calculate C-alpha RMSD against the original, unmodified reference
        current_rmsd = torch.sqrt(torch.mean((X_ref_ca - X_noisy_ca) ** 2)).item()
        
        logger.debug(f"[Sigma Calibration] Iter {i+1}/{max_iter}: sigma={sigma:.4f}, current_rmsd={current_rmsd:.4f} Å")

        if abs(current_rmsd - target_rmsd) < tolerance:
            logger.info(f"[Sigma Calibration] Success! Final sigma={sigma:.4f} yields RMSD={current_rmsd:.4f} Å (within tolerance {tolerance:.3f} Å)")
            return sigma
        
        # Adjust sigma proportionally
        # Add a small epsilon to avoid division by zero if current_rmsd is 0
        sigma = sigma * (target_rmsd / (current_rmsd + 1e-6))

    logger.warning(f"[Sigma Calibration] Failed to converge within {max_iter} iterations. Using final sigma={sigma:.4f} (yielded RMSD={current_rmsd:.4f} Å)")
    return sigma

def run_dssp_analysis(pdb_path: str, orig_res_map: Dict[str, int], logger: logging.Logger) -> Dict[int, str]:
    """
    Runs DSSP analysis on a PDB file and maps the results to 0-based residue indices.
    """
    try:
        traj = md.load(pdb_path)
        ss_raw = md.compute_dssp(traj, simplified=True)
        ss_first_frame = ss_raw[0]
        
        ss_map = {}
        # MDTraj provides 1-based residue indices in its topology
        for res_md in traj.topology.residues:
            # res_md.resSeq is the original 1-based residue number from the PDB
            # res_md.index is the 0-based index within mdtraj
            
            # Construct the original residue ID string using the integer chain index to match parse_pdb
            orig_res_id = f"{res_md.chain.index}:{res_md.name}:{res_md.resSeq}"
            
            if orig_res_id in orig_res_map:
                internal_res_idx = orig_res_map[orig_res_id]
                ss_code = ss_first_frame[res_md.index]
                simplified_code = 'H' if ss_code == 'H' else 'L'
                ss_map[internal_res_idx] = simplified_code
                
        logger.info(f"Successfully ran DSSP and mapped {len(ss_map)} residues.")
        return ss_map
    except Exception as e:
        logger.error(f"Failed to run DSSP analysis on {pdb_path}: {e}", exc_info=True)
        return {}

def get_deletable_segments(ss_map: Dict[int, str], total_residues: int, logger: logging.Logger) -> List[List[int]]:
    """
    Identifies contiguous segments of residues that are candidates for deletion.
    A segment is a candidate if it is a loop ('L') or a helix ('H') adjacent to a loop.
    Excludes segments containing the first two or last two residues.
    """
    if not ss_map:
        logger.warning("Secondary structure map is empty. No deletable segments can be identified.")
        return []

    # Identify all loop residues
    loop_residues = {res_idx for res_idx, code in ss_map.items() if code == 'L'}
    
    deletable_residues = set()
    for res_idx, code in ss_map.items():
        # Rule: A residue is deletable if it's a loop
        if code == 'L':
            deletable_residues.add(res_idx)
        # Rule: A residue is deletable if it's a helix adjacent to a loop
        elif code == 'H':
            is_adjacent_to_loop = (res_idx - 1 in loop_residues) or (res_idx + 1 in loop_residues)
            if is_adjacent_to_loop:
                deletable_residues.add(res_idx)

    # Safety Rule: Exclude the first two and last two residues of the entire chain
    protected_residues = {0, 1, total_residues - 2, total_residues - 1}
    eligible_residues = sorted(list(deletable_residues - protected_residues))
    
    if not eligible_residues:
        logger.warning("No eligible residues for deletion after applying safety rules.")
        return []

    # Group eligible residues into contiguous segments
    segments = []
    if eligible_residues:
        current_segment = [eligible_residues[0]]
        for i in range(1, len(eligible_residues)):
            if eligible_residues[i] == eligible_residues[i-1] + 1:
                current_segment.append(eligible_residues[i])
            else:
                segments.append(current_segment)
                current_segment = [eligible_residues[i]]
        segments.append(current_segment)
        
    logger.info(f"Identified {len(segments)} deletable segments from {len(eligible_residues)} eligible residues.")
    return segments

# --- Checkpoint Utilities & MSE Utilities ---
def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")

def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
    start_epoch = 0
    if os.path.isfile(filename):
        logger.info(f"Loading checkpoint: '{filename}'")
        try:
            ckpt = torch.load(filename, map_location=device)
            start_epoch = ckpt.get("epoch", 0)
            model.load_state_dict(ckpt["model_state_dict"])
            if optimizer and "optimizer_state_dict" in ckpt:
                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
                for state in optimizer.state.values():
                    for k, v in state.items():
                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
            model.to(device)
            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
        except Exception as e:
            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
            start_epoch = 0
    else:
        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
    model.to(device)
    return model, optimizer, start_epoch

def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
    crit = nn.MSELoss()
    all_mse = crit(pred, target)
    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
    return all_mse, bb_mse, sc_mse

################################################################################
# (F) Model Definitions
################################################################################

# --- HNO Encoder ---
class HNO(nn.Module):
    def __init__(self, hidden_dim, K):
        super().__init__()
        self._debug_logged_train = False
        self.conv1 = ChebConv(3, hidden_dim, K=K)
        self.bano1 = nn.BatchNorm1d(hidden_dim)
        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
        self.bano2 = nn.BatchNorm1d(hidden_dim)
        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
        self.bano3 = nn.BatchNorm1d(hidden_dim)
        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head

    def forward(self, x, edge_index):
        x = x.float()
        x_in = x
        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
        x = self.bano3(F.relu(self.conv3(x, edge_index)))
        x = self.conv4(x, edge_index)
        x_rep = F.normalize(x, p=2.0, dim=1)
        x_recon = self.mlpRep(x_rep)
        
        if self.training and not self._debug_logged_train and logger.isEnabledFor(logging.DEBUG):
             logger.debug(f"[HNO Train Fwd] Input shape: {x_in.shape}, Edge index shape: {edge_index.shape}")
             logger.debug(f"[HNO Train Fwd] Output shapes: Rep={x_rep.shape}, Recon={x_recon.shape}")
             self._debug_logged_train = True
        return x_recon

    def forward_representation(self, x, edge_index):
        x = x.float()
        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
        x = self.bano3(F.relu(self.conv3(x, edge_index)))
        x = self.conv4(x, edge_index)
        return F.normalize(x, p=2.0, dim=1)

# --- ROBUST Decoder2 Model (CORRECTED LOGIC) ---
class ProteinStateReconstructor2D(nn.Module):
    """
    Size-agnostic decoder. For each graph, it pools the dynamic embedding to a
    fixed size using AdaptiveAvgPool2d, flattens it, and concatenates this
    global dynamic vector to the static (z_ref) conditioner for each node.
    """
    def __init__(self, node_emb_dim: int, cond_emb_dim: int,
                 output_height: int, output_width: int,
                 mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
        super().__init__()
        self.logger = logger
        self._logged_fwd = False
        self.node_emb_dim = node_emb_dim

        # 1. Define the 2D pooling layer
        self.pool_layer = nn.AdaptiveAvgPool2d((output_height, output_width))
        pooled_dim = output_height * output_width

        # 2. Define the final MLP input dimension
        # It's the static conditioner + the flattened, pooled dynamic embedding
        mlp_in_dim = cond_emb_dim + pooled_dim

        # 3. Build the MLP
        layers = []
        in_d = mlp_in_dim
        for i in range(mlp_layers - 1):
            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
            in_d = mlp_h_dim
        layers.append(nn.Linear(in_d, 3))
        self.decoder_mlp = nn.Sequential(*layers)

        self.logger.info(f"Initialized Decoder2 (Corrected). Pool size: ({output_height}, {output_width}). MLP Input Dim: {mlp_in_dim}")

    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
            self.logger.debug(f"[Decoder Fwd Start] Input x shape: {x.shape}, conditioner_z_ref shape: {conditioner_z_ref.shape}")

        # Since graphs in the batch have different sizes, we must loop.
        pooled_vectors = []
        for i in range(batch.max().item() + 1):
            # a. Get the dynamic embedding for the current graph
            graph_mask = (batch == i)
            x_graph = x[graph_mask] # Shape: [n_nodes_in_graph, node_emb_dim]
            n_nodes, n_emb = x_graph.shape

            # b. Reshape for 2D pooling: [B, C, H, W] -> [1, 1, n_nodes, n_emb]
            x_graph_4d = x_graph.unsqueeze(0).unsqueeze(0)

            # c. Apply pooling and flatten
            pooled_graph = self.pool_layer(x_graph_4d)
            flattened_pooled = pooled_graph.view(1, -1) # Shape: [1, pooled_dim]
            pooled_vectors.append(flattened_pooled)

        # d. Combine pooled vectors for the whole batch
        batch_pooled = torch.cat(pooled_vectors, dim=0) # Shape: [num_graphs, pooled_dim]

        # e. Broadcast the correct pooled vector to each node in its respective graph
        pooled_per_node = batch_pooled[batch] # Shape: [total_nodes, pooled_dim]

        # f. Concatenate the static conditioner with the broadcasted pooled vector
        mlp_input = torch.cat([conditioner_z_ref, pooled_per_node], dim=1)

        # g. Predict coordinates
        pred_coords = self.decoder_mlp(mlp_input)

        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
            self.logger.debug(f"[Decoder Fwd Pools] Pooled vector shape (per graph): {pooled_vectors[0].shape}")
            self.logger.debug(f"[Decoder Fwd Pools] Broadcasted pooled shape: {pooled_per_node.shape}")
            self.logger.debug(f"[Decoder Fwd End] mlp_input shape: {mlp_input.shape}, Final output pred_coords shape: {pred_coords.shape}")
            self._logged_fwd = True

        return pred_coords

################################################################################
# (G) Training Functions
################################################################################

# --- Train HNO ---
def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
    model=model.to(dev)
    params = list(filter(lambda p: p.requires_grad, model.parameters()))
    opt = torch.optim.Adam(params, lr=lr) if params else None
    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
    
    if start_ep >= N_epochs:
        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
        return model

    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
    for ep in range(start_ep, N_epochs):
        model.train()
        total_loss = 0.0
        for i, data in enumerate(tr_loader):
            data=data.to(dev)
            if ep == start_ep and i == 0 and logger.isEnabledFor(logging.DEBUG):
                logger.debug(f"[HNO Batching] Batch contains {data.num_graphs} graphs.")
                logger.debug(f"[HNO Batching] data.x shape: {data.x.shape}")
                logger.debug(f"[HNO Batching] data.ptr: {data.ptr}")
                logger.debug(f"[HNO Batching] Total nodes in batch: {data.num_nodes}")
                logger.debug(f"[HNO Batching] System IDs in batch: {data.system_id.squeeze().tolist()}")

            opt.zero_grad(set_to_none=True)
            pred = model(data.x, data.edge_index)
            loss = F.mse_loss(pred, data.y)
            loss.backward()
            opt.step()
            total_loss += loss.item()
        avg_tr_loss = total_loss / len(tr_loader)
        
        model.eval()
        total_val_loss = 0.0
        with torch.no_grad():
            for data in te_loader:
                data=data.to(dev)
                pred=model(data.x, data.edge_index)
                total_val_loss += F.mse_loss(pred, data.y).item()
        avg_te_loss = total_val_loss / len(te_loader)

        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
        
        ep_num = ep + 1
        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
    
    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
    return model

# --- ROBUST Train Decoder2 ---
def train_decoder2_model(
    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
    all_conditioners: Dict[int, torch.Tensor],
    all_z_ref_ensembles: Dict[int, torch.Tensor],
    use_z_ref_ensemble: bool,
    all_sys_info: Dict[int, Any],
    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
):
    model = model.to(dev)
    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)

    if use_z_ref_ensemble:
        logger.info("Decoder training with augmented 'z_ref_ensemble' as conditioner.")
        if not all_z_ref_ensembles:
            logger.error("`use_z_ref_ensemble` is true, but the ensemble dictionary is empty. Aborting.")
            return model
    else:
        logger.info("Decoder training with clean 'z_ref' as conditioner.")

    if start_ep >= N_epochs:
        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
        return model
        
    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")

    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
    for ep in range(start_ep, N_epochs):
        model.train()
        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
        
        for i, data in enumerate(tr_loader):
            data = data.to(dev)
            opt.zero_grad(set_to_none=True)
            
            # --- Assemble Batch-Specific Conditioners ---
            cond_list = []
            for j in range(data.num_graphs):
                sid = data.system_id[j].item()
                num_nodes = data.ptr[j+1] - data.ptr[j]

                if use_z_ref_ensemble:
                    # Check if an ensemble exists for this specific system
                    if sid in all_z_ref_ensembles:
                        # If yes, sample from it (this is a base system with noise aug)
                        ensemble = all_z_ref_ensembles[sid]
                        rand_idx = torch.randint(0, ensemble.shape[0], (1,)).item()
                        cond = ensemble[rand_idx].to(dev)
                        if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG):
                            logger.debug(f"[Decoder Verify] Graph {j} (SID: {sid}) is using RANDOM conditioner from its ensemble.")
                    else:
                        # If no, fall back to the single z_ref (this is a variant)
                        cond = all_conditioners[sid].to(dev)
                        if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG):
                            logger.debug(f"[Decoder Verify] Graph {j} (SID: {sid}) is a variant, using FIXED conditioner.")
                else:
                    # Use the clean, single z_ref if ensemble mode is off entirely
                    cond = all_conditioners[sid].to(dev)
                    if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG):
                        logger.debug(f"[Decoder Verify] Graph {j} (SID: {sid}) is using the FIXED conditioner (ensemble mode off).")

                if cond.shape[0] != num_nodes:
                    raise ValueError(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
                cond_list.append(cond)
            conditioners_for_batch = torch.cat(cond_list, dim=0)

            # --- Forward Pass ---
            pred = model(data.x, data.batch, conditioners_for_batch)
            
            # --- ROBUST Loss Calculation (Graph by Graph) ---
            total_loss = torch.tensor(0.0, device=dev)
            for j in range(data.num_graphs):
                graph_start, graph_end = data.ptr[j], data.ptr[j+1]
                sid = data.system_id[j].item()

                pred_graph = pred[graph_start:graph_end]
                target_graph = data.y[graph_start:graph_end]
                
                if i == 0 and j < 2 and logger.isEnabledFor(logging.DEBUG): # Log first 2 graphs of first batch
                    logger.debug(f"[Decoder Loss Loop] Graph {j}, SID {sid}: pred_graph shape: {pred_graph.shape}, target_graph shape: {target_graph.shape}")

                # Coordinate Loss for this graph
                bb_idx = all_sys_info[sid]['bb_idx_local']
                sc_idx = all_sys_info[sid]['sc_idx_local']
                
                coord_mse_graph, _, _ = compute_bb_sc_mse(pred_graph, target_graph, bb_idx, sc_idx, logger)
                total_loss += base_w * coord_mse_graph
                tr_metrics['coord'] += coord_mse_graph.item()

                # Dihedral Loss for this graph
                if use_di and sid in all_di_info:
                    pred_3d = pred_graph.unsqueeze(0) # Add batch dim
                    target_3d = target_graph.unsqueeze(0)
                    
                    pred_a = compute_all_dihedrals_vectorized(pred_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
                    true_a = compute_all_dihedrals_vectorized(target_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
                    
                    di_div_loss_graph = torch.tensor(0.0, device=dev)
                    di_mse_loss_graph = torch.tensor(0.0, device=dev)
                    for name in pred_a:
                        pa, ta = pred_a[name], true_a[name]
                        if pa.numel() > 0:
                             di_div_loss_graph += comp_div(pa, ta)
                             di_mse_loss_graph += F.mse_loss(pa, ta)
                    
                    total_loss += l_div * di_div_loss_graph + l_mse * di_mse_loss_graph
                    tr_metrics['di_div'] += di_div_loss_graph.item()
                    tr_metrics['di_mse'] += di_mse_loss_graph.item()

            # Average loss over the number of graphs in the batch
            avg_batch_loss = total_loss / data.num_graphs
            tr_metrics['total'] += avg_batch_loss.item()
            
            avg_batch_loss.backward()
            opt.step()
        
        # Log training stats (validation loop omitted for brevity but should be added)
        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
        
        ep_num = ep + 1
        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
            
    logger.info("Finished Decoder2 training.")
    return model


################################################################################
# (H) Final Data Export Function
################################################################################
@torch.no_grad()
def export_final_outputs_multi(
    hno: 'HNO',
    dec2: 'ProteinStateReconstructor2D',
    full_dset: List['Data'],
    dec_in_dset: List['Data'],
    all_conditioners: Dict[int, torch.Tensor],
    all_sys_info: Dict[int, Any],
    all_X_refs: Dict[int, torch.Tensor],
    all_X_ref_ensembles: Dict[int, torch.Tensor],
    all_z_ref_ensembles: Dict[int, torch.Tensor],
    struct_dir: str,
    latent_dir: str,
    dev: torch.device,
    logger: logging.Logger
):
    """
    Exports final ground truth, reconstructions, and embeddings for all systems
    to HDF5 files, with data for each system stored in a separate group.
    Also saves the reference conditioners (z_ref and X_ref) and their ensembles.
    """
    logger.info("--- Stage 5: Starting Final Data Export ---")
    hno.eval()
    dec2.eval()

    # 1. Initialize data storage
    outputs_by_sid = {
        sid: {'gt_aligned': [], 'gt_unaligned': [], 'hno_rec': [], 'full_rec': [], 'hno_emb': [], 'pooled_emb': []}
        for sid in all_sys_info.keys()
    }

    # 2. Loop through datasets and perform inference
    logger.info("Running inference on all frames...")
    full_loader = DataLoader(full_dset, batch_size=32, shuffle=False)
    dec_in_loader = DataLoader(dec_in_dset, batch_size=32, shuffle=False)

    # Store intermediate results to avoid recomputing embeddings
    temp_embs = {}

    with torch.no_grad():
        # First, get all HNO reconstructions and embeddings
        for i, data in enumerate(full_loader):
            data = data.to(dev)
            hno_recon = hno(data.x, data.edge_index)
            hno_embedding = hno.forward_representation(data.x, data.edge_index)
            
            for j in range(data.num_graphs):
                sid = data.system_id[j].item()
                start, end = data.ptr[j], data.ptr[j+1]
                
                outputs_by_sid[sid]['gt_aligned'].append(data.y[start:end].cpu())
                outputs_by_sid[sid]['gt_unaligned'].append(data.y_unaligned[start:end].cpu())
                outputs_by_sid[sid]['hno_rec'].append(hno_recon[start:end].cpu())
                outputs_by_sid[sid]['hno_emb'].append(hno_embedding[start:end].cpu())
                
                # Store for decoder pass
                if sid not in temp_embs: temp_embs[sid] = []
                temp_embs[sid].append(hno_embedding[start:end])


        # Second, get all Decoder reconstructions and pooled embeddings
        for i, emb_data in enumerate(dec_in_loader):
            emb_data = emb_data.to(dev)
            
            # Assemble conditioners for the batch
            cond_list = [all_conditioners[sid.item()].to(dev) for sid in emb_data.system_id]
            conditioner = torch.cat(cond_list, dim=0)

            # Decoder forward pass
            full_recon = dec2(emb_data.x, emb_data.batch, conditioner)

            # Pooled embedding logic (replicated from decoder's forward)
            pooled_vectors = []
            for j in range(emb_data.num_graphs):
                graph_mask = (emb_data.batch == j)
                x_graph = emb_data.x[graph_mask]
                
                x_graph_4d = x_graph.unsqueeze(0).unsqueeze(0)
                pooled_graph = dec2.pool_layer(x_graph_4d)
                flattened_pooled = pooled_graph.view(1, -1)
                pooled_vectors.append(flattened_pooled)
            
            batch_pooled = torch.cat(pooled_vectors, dim=0)

            # Split results and store
            for j in range(emb_data.num_graphs):
                sid = emb_data.system_id[j].item()
                start, end = emb_data.ptr[j], emb_data.ptr[j+1]
                
                outputs_by_sid[sid]['full_rec'].append(full_recon[start:end].cpu())
                outputs_by_sid[sid]['pooled_emb'].append(batch_pooled[j].cpu())


    # 3. Write stacked data to HDF5 files
    logger.info("Writing exported data to HDF5 files...")
    os.makedirs(struct_dir, exist_ok=True)
    os.makedirs(latent_dir, exist_ok=True)

    # Define output files
    coord_files = {
        'gt_aligned': os.path.join(struct_dir, 'gt_coords_aligned.h5'),
        'gt_unaligned': os.path.join(struct_dir, 'gt_coords_unaligned.h5'),
        'hno_rec': os.path.join(struct_dir, 'hno_reconstructed_coords.h5'),
        'full_rec': os.path.join(struct_dir, 'full_reconstructed_coords.h5')
    }
    emb_files = {
        'hno_emb': os.path.join(latent_dir, 'hno_embeddings.h5'),
        'pooled_emb': os.path.join(latent_dir, 'pooled_embeddings.h5')
    }

    # Write coordinate data
    if not DISABLE_DETAILED_OUTPUTS:
        for key, path in coord_files.items():
            with h5py.File(path, 'w') as f:
                logger.debug(f"Writing to {path}")
                for sid, data in outputs_by_sid.items():
                    if data[key]:
                        stacked_data = torch.stack(data[key]).numpy()
                        grp = f.create_group(f"system_{sid}")
                        grp.create_dataset("coords", data=stacked_data, compression="gzip")
                        logger.debug(f"  - Wrote system_{sid}/coords with shape {stacked_data.shape}")
    else:
        logger.info("Skipping export of all coordinate files in `structure_dir` due to local setting.")

    # Write embedding data
    for key, path in emb_files.items():
        if DISABLE_DETAILED_OUTPUTS and key == 'hno_emb':
            logger.info(f"Skipping export of {path} due to local setting.")
            continue
        with h5py.File(path, 'w') as f:
            logger.debug(f"Writing to {path}")
            for sid, data in outputs_by_sid.items():
                if data[key]:
                    stacked_data = torch.stack(data[key]).numpy()
                    grp = f.create_group(f"system_{sid}")
                    grp.create_dataset("embeddings", data=stacked_data, compression="gzip")
                    logger.debug(f"  - Wrote system_{sid}/embeddings with shape {stacked_data.shape}")

    # --- Modified logic to save reference conditioners and ensembles ---
    ref_cond_path = os.path.join(latent_dir, 'reference_conditioners.h5')
    logger.info(f"Writing reference conditioners and ensembles to {ref_cond_path}")
    with h5py.File(ref_cond_path, 'w') as f:
        for sid, z_ref in all_conditioners.items():
            if sid in all_X_refs:
                grp = f.create_group(f"system_{sid}")
                grp.create_dataset("z_ref", data=z_ref.numpy(), compression="gzip")
                grp.create_dataset("X_ref", data=all_X_refs[sid].numpy(), compression="gzip")
                logger.debug(f"  - Wrote system_{sid}/z_ref with shape {z_ref.shape}")
                logger.debug(f"  - Wrote system_{sid}/X_ref with shape {all_X_refs[sid].shape}")

                # Save ensembles if they exist for this system
                if sid in all_X_ref_ensembles and sid in all_z_ref_ensembles:
                    x_ensemble = all_X_ref_ensembles[sid].numpy()
                    z_ensemble = all_z_ref_ensembles[sid].numpy()
                    grp.create_dataset("X_ref_ensemble", data=x_ensemble, compression="gzip")
                    grp.create_dataset("z_ref_ensemble", data=z_ensemble, compression="gzip")
                    logger.debug(f"  - Wrote system_{sid}/X_ref_ensemble with shape {x_ensemble.shape}")
                    logger.debug(f"  - Wrote system_{sid}/z_ref_ensemble with shape {z_ensemble.shape}")
            else:
                logger.warning(f"Could not find X_ref for system {sid}. Skipping save for this system in reference_conditioners.h5")

    logger.info("--- Finished Final Data Export ---")


################################################################################
# (I) Main Execution Function
################################################################################
def main():
    start_time = time.time()
    logger.info("================ Script Starting (Multi-System Version) ================")
    global global_device
    
    with open(args.config, "r") as f: config = yaml.safe_load(f)
    logger.info("Successfully loaded configuration.")
    
    force_cpu = config.get("force_cpu", False)
    device = torch.device("cpu") if force_cpu else global_device
    pin_mem = (device.type == "cuda")
    num_workers = config.get("num_workers", 0)
    
    hno_cfg = config["hno_encoder"]
    dec2_cfg = config["decoder2"]
    d2s = config["decoder2_settings"]
    di_cfg = config.get("dihedral_loss", {})
    
    # Get structural augmentation config
    struct_aug_cfg = config.get("structural_augmentation", {"enabled": False})
    aug_cfg = config.get("data_augmentation", {}) # For noise-based augmentation

    out_cfg = config["output_directories"]
    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]

    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
    
    base_systems_data = []
    systems_to_process_configs = config["data"]["systems"]
    
    exec_settings = config.get("execution_settings", {})
    limit_systems = exec_settings.get("limit_systems")
    max_frames = exec_settings.get("max_frames_per_system")

    if limit_systems is not None and isinstance(limit_systems, int) and limit_systems > 0:
        systems_to_process_configs = systems_to_process_configs[:limit_systems]
        logger.info(f"[INFO] Limiting run to the first {limit_systems} systems as specified in the config.")

    for i, system_config in enumerate(systems_to_process_configs):
        sid = i
        pdb_p = system_config["pdb_path"]
        json_p = system_config["json_path"]
        logger.info(f"--- Loading Base System ID {sid}: {os.path.basename(pdb_p)} ---")

        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger, max_frames=max_frames)
        if not coords_list:
            logger.warning(f"Skipping system {sid} due to no coordinates.")
            continue
        
        base_systems_data.append({
            "pdb_path": pdb_p,
            "atoms_ord": atoms_ord,
            "ca_serial_map": ca_serial_map,
            "coords_list": coords_list,
            "is_variant": False,
            "base_sid": sid
        })

    # --- NEW Stage 1.5: Structural Augmentation ---
    final_systems_to_process = list(base_systems_data) # Start with original systems

    if struct_aug_cfg.get("enabled", False):
        logger.info("--- Stage 1.5: Starting Structural Augmentation ---")
        variants_per_system = struct_aug_cfg.get("variants_per_system", 5)
        
        for base_system_data in base_systems_data:
            base_sid = base_system_data["base_sid"]
            pdb_path = base_system_data["pdb_path"]
            logger.info(f"--- Generating variants for Base System ID {base_sid} ---")

            # 1. Get mappings for the original, undamaged system
            renum_d_orig, _, _, _, orig_res_map = renumber_atoms_and_residues(
                base_system_data["atoms_ord"], base_system_data["ca_serial_map"]
            )
            total_residues = len(renum_d_orig)

            # 2. Perform SS analysis
            ss_map = run_dssp_analysis(pdb_path, orig_res_map, logger)
            if not ss_map:
                logger.warning(f"Cannot generate variants for SID {base_sid} due to DSSP failure.")
                continue

            # 3. Identify deletable segments
            deletable_segments = get_deletable_segments(ss_map, total_residues, logger)
            if not deletable_segments:
                logger.warning(f"No deletable segments found for SID {base_sid}. Skipping variant generation.")
                continue

            # 4. Generate damaged variants
            for i in range(variants_per_system):
                logger.debug(f"Creating variant {i+1}/{variants_per_system} for SID {base_sid}")
                
                # a. Randomly select a segment and deletion length
                segment_to_delete_from = random.choice(deletable_segments)
                max_len = min(len(segment_to_delete_from), 6)
                if max_len < 2: continue # Skip if the segment is too short
                
                deletion_len = random.randint(2, max_len)
                start_idx_in_segment = random.randint(0, len(segment_to_delete_from) - deletion_len)
                
                residues_to_delete = set(segment_to_delete_from[start_idx_in_segment : start_idx_in_segment + deletion_len])
                
                # b. Identify all atoms belonging to the residues to be deleted
                atom_indices_to_delete = set()
                for res_idx in residues_to_delete:
                    atom_indices_to_delete.update(renum_d_orig[res_idx]["backbone"])
                    atom_indices_to_delete.update(renum_d_orig[res_idx]["sidechain"])

                # c. Create new damaged data
                original_atoms_ord = base_system_data["atoms_ord"]
                
                # We need a map from the original 0-based index to the atom tuple
                idx_to_atom_tuple = {idx: atom_tuple for idx, atom_tuple in enumerate(original_atoms_ord)}

                atoms_ord_damaged = [
                    atom_tuple for idx, atom_tuple in idx_to_atom_tuple.items() 
                    if idx not in atom_indices_to_delete
                ]

                coords_list_damaged = []
                original_coords_list = base_system_data["coords_list"]
                
                # Create a keep_mask for atom indices
                keep_indices = sorted(list(set(range(len(original_atoms_ord))) - atom_indices_to_delete))
                keep_mask = torch.tensor(keep_indices, dtype=torch.long)

                for frame_coords in original_coords_list:
                    coords_list_damaged.append(frame_coords[keep_mask])

                final_systems_to_process.append({
                    "pdb_path": pdb_path, # For reference, not reparsing
                    "atoms_ord": atoms_ord_damaged,
                    "ca_serial_map": base_system_data["ca_serial_map"], # Will be filtered by renumbering
                    "coords_list": coords_list_damaged,
                    "is_variant": True,
                    "base_sid": base_sid
                })
        logger.info(f"Finished augmentation. Total systems to process: {len(final_systems_to_process)}")


    # --- Stage 2: Final Data Processing and Graph Building ---
    full_dset = []
    all_sys_info = {}
    all_X_refs = {}
    canonical_ref_coords = None
    canonical_ref_ca_indices = None
    
    # This loop now processes both original and variant systems
    for i, system_data in enumerate(final_systems_to_process):
        sid = i # Each system, original or variant, gets a new unique ID
        
        log_prefix = f"Variant of {system_data['base_sid']}" if system_data['is_variant'] else f"Base System {system_data['base_sid']}"
        logger.info(f"--- Processing Final System ID {sid} ({log_prefix}) ---")

        # CRUCIAL: Re-run renumbering and indexing for every system
        renum_d, _, _, ca_indices_new, _ = renumber_atoms_and_residues(system_data["atoms_ord"], system_data["ca_serial_map"])
        bb_idx, sc_idx = get_global_indices(renum_d)
        
        coords_list = system_data["coords_list"]
        n_atoms = coords_list[0].shape[0]
        unaligned_coords_list = [c.clone() for c in coords_list]
        
        all_sys_info[sid] = {
            'n_atoms': n_atoms,
            'ca_indices': torch.tensor(ca_indices_new, dtype=torch.long),
            'bb_idx_local': bb_idx,
            'sc_idx_local': sc_idx,
            'n_res': len(renum_d),
            'is_variant': system_data['is_variant'],
            'base_sid_ref': system_data['base_sid']
        }

        aligned_coords_list = []
        if sid == 0: # The first system is always the canonical reference
            logger.info(f"System {sid} is the canonical reference.")
            canonical_ref_coords = coords_list[0].clone()
            all_X_refs[sid] = canonical_ref_coords.clone()
            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
        else:
            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
            target_ref_coords = coords_list[0]
            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
            
            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
                target_ref_coords[target_ca_indices].numpy(),
                logger
            )
            
            aligned_target_ref_frame = align_by_core(
                target_ref_coords, target_ca_indices[core_target_idx],
                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
                logger
            )
            
            all_X_refs[sid] = aligned_target_ref_frame.cpu().clone()
            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)

        system_dset = build_graph_dataset(aligned_coords_list, unaligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
        full_dset.extend(system_dset)

    logger.info(f"--- Finished data processing. Total frames in dataset: {len(full_dset)} ---")

    # --- Stage 3: Training Shared HNO Encoder ---
    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
    hno_model.eval()

    # --- Stage 4: Preparing Decoder Input Dataset & Conditioners ---
    dec_in_dset = []
    all_conditioners = {}
    all_X_ref_ensembles = {} # Legacy from noise augmentation, can be removed if not used
    all_z_ref_ensembles = {} # Legacy from noise augmentation, can be removed if not used
    
    with torch.no_grad():
        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
        for batch in infer_load:
            batch = batch.to(device)
            emb = hno_model.forward_representation(batch.x, batch.edge_index)
            split_sizes = (batch.ptr[1:] - batch.ptr[:-1]).tolist()
            emb_list = torch.split(emb, split_sizes)
            y_list = torch.split(batch.y, split_sizes)
            
            for j in range(len(emb_list)):
                dec_in_dset.append(Data(x=emb_list[j].cpu(), y=y_list[j].cpu(), system_id=batch.system_id[j].cpu().reshape(1)))
    
    if d2s['conditioner_mode'] == 'z_ref':
        for sid in all_sys_info.keys():
            ref_coords = all_X_refs[sid].to(device)
            edge_index_ref = knn_graph(ref_coords, k=config["graph"]["knn_value"], loop=False, batch=None)
            with torch.no_grad():
                z_ref = hno_model.forward_representation(ref_coords, edge_index_ref)
                all_conditioners[sid] = z_ref.cpu()
        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
    else:
        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")

    # --- Stage 4.5: Noise-based Data Augmentation (applied to all systems) ---
    if aug_cfg.get("enabled", False):
        logger.info("--- Stage 4.5: Starting Noise-Based Data Augmentation for ALL systems (base and variants) ---")
        ensemble_size = aug_cfg.get("ensemble_size", 100)
        target_rmsd = aug_cfg.get("target_ca_rmsd", 1.0)
        
        for sid, X_ref in all_X_refs.items():
            logger.info(f"--- Augmenting data with noise for System ID {sid} ---")
            ca_indices = all_sys_info[sid]['ca_indices']
            
            optimal_sigma = find_optimal_sigma(
                X_ref, ca_indices, target_rmsd, logger
            )

            X_ref_ensemble_list = []
            for _ in range(ensemble_size):
                noise = torch.randn_like(X_ref) * optimal_sigma
                X_noisy = X_ref.clone() + noise
                X_ref_ensemble_list.append(X_noisy)
            
            X_ref_ensemble_tensor = torch.stack(X_ref_ensemble_list)
            all_X_ref_ensembles[sid] = X_ref_ensemble_tensor.cpu()
            logger.info(f"Generated X_ref_ensemble for SID {sid} with shape {X_ref_ensemble_tensor.shape}")

            z_ref_ensemble_list = []
            with torch.no_grad():
                for i in range(ensemble_size):
                    noisy_struct = X_ref_ensemble_tensor[i].to(device)
                    edge_index_noisy = knn_graph(noisy_struct, k=config["graph"]["knn_value"], loop=False, batch=None)
                    z_ref_single = hno_model.forward_representation(noisy_struct, edge_index_noisy)
                    z_ref_ensemble_list.append(z_ref_single.cpu())

            z_ref_ensemble_tensor = torch.stack(z_ref_ensemble_list)
            all_z_ref_ensembles[sid] = z_ref_ensemble_tensor
            logger.info(f"Generated z_ref_ensemble for SID {sid} with shape {z_ref_ensemble_tensor.shape}")

    # --- Stage 5: Decoder2 Setup & Training ---
    all_di_info = {}
    use_di_train = di_cfg.get("use_dihedral_loss", False)
    if use_di_train:
        logger.info("Dihedral loss is configured but parsing logic is not implemented in this version.")

    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
    
    dec2_model = ProteinStateReconstructor2D(
        node_emb_dim=hno_cfg['hidden_dim'],
        cond_emb_dim=hno_cfg['hidden_dim'],
        output_height=d2s['output_height'],
        output_width=d2s['output_width'],
        mlp_h_dim=d2s['mlp_hidden_dim'],
        mlp_layers=d2s['num_hidden_layers'],
        logger=logger
    )
    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
    dec2_model = train_decoder2_model(
        model=dec2_model, tr_loader=load_tr_dec, te_loader=load_te_dec,
        all_conditioners=all_conditioners,
        all_z_ref_ensembles=all_z_ref_ensembles, # Pass empty dict, not used by this aug
        use_z_ref_ensemble=dec2_cfg.get('use_z_ref_ensemble', False),
        all_sys_info=all_sys_info,
        N_epochs=dec2_cfg['num_epochs'], lr=dec2_cfg['learning_rate'],
        ckpt=dec2_ckpt, save_int=dec2_cfg['save_interval'],
        dev=device, logger=logger,
        base_w=dec2_cfg['base_loss_weight'],
        use_di=use_di_train, all_di_info=all_di_info,
        div_t=di_cfg.get('divergence_type', 'JS'),
        l_div=di_cfg.get('lambda_divergence', 0.0),
        l_mse=di_cfg.get('lambda_torsion_mse', 0.0)
    )

    # --- Stage 6: Final Export ---
    export_final_outputs_multi(
        hno=hno_model,
        dec2=dec2_model,
        full_dset=full_dset,
        dec_in_dset=dec_in_dset,
        all_conditioners=all_conditioners,
        all_sys_info=all_sys_info,
        all_X_refs=all_X_refs,
        all_X_ref_ensembles=all_X_ref_ensembles, # Pass empty dict
        all_z_ref_ensembles=all_z_ref_ensembles, # Pass empty dict
        struct_dir=out_cfg['structure_dir'],
        latent_dir=out_cfg['latent_dir'],
        dev=device,
        logger=logger
    )

    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")

################################################################################
# (J) Script Entry Point
################################################################################
if __name__ == "__main__":
    main()