scripts/preprocess_dataset.py

import os
import numpy as np
import pandas as pd
import torch
import json

import sys
# Add project root to path
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)

import pdbutils
import cifutils
from na_data_utils import PDBDataset

# Load the parameters file.
params_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "preprocess_dataset.json")
params = json.load(open(params_path))

# Load constants from the parameters file.
na_side_chain_atoms_len = len(['N9', 'C8', 'C7', 'N7', 'C6', 'N6', 'O6', 'C5', 'C4', 'N4', 'O4', 'N3', 'C2', 'N2', 'O2', 'N1'])
residue_cutoff = params["BATCH_TOKENS"]
num_neighbors = params["NUM_NEIGHBORS"]
interface_distance_cutoff = 5.0 # distance for interface in angstroms

if params["ATOMS_TO_LOAD"] == "backbone":
    atom_list_to_save = ['N', 'CA', 'C', 'O', #protein atoms
                         'OP1', 'OP2', 'P', "O5'", "C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "O2'", "C1'" #nucleic acid atoms
                        ]
elif params["ATOMS_TO_LOAD"] == "all":
    atom_list_to_save = ['N', 'CA', 'C', 'CB', 'O', 'CG', 'CG1', 'CG2', 'OG', 'OG1', 'SG', 'CD', 'CD1', 'CD2', 'ND1', 'ND2', 'OD1', 'OD2', 'SD', 'CE', 'CE1', 'CE2', 'CE3', 'NE', 'NE1', 'NE2', 'OE1', 'OE2', 'CH2', 'NH1', 'NH2', 'OH', 'CZ', 'CZ2', 'CZ3', 'NZ', 'OXT', #protein atoms
                         'OP1', 'OP2', 'P', "O5'", "C5'", "C4'", "O4'", "C3'", "O3'", "C2'", "O2'", "C1'", 'N9', 'C8', 'C7', 'N7', 'C6', 'N6', 'O6', 'C5', 'C4', 'N4', 'O4', 'N3', 'C2', 'N2', 'O2', 'N1' #nucleic acid atoms
                        ]

# Create the parsers and dataset.
cif_parser = cifutils.CIFParser(skip_res=params["EXCLUDE_RES"], 
                                randomize_nmr_model=params["RANDOMIZE_NMR_MODEL"])
pdb_parser = pdbutils.PDBParser()

pdb_dataset = PDBDataset(cif_parser=cif_parser,
                         pdb_parser=pdb_parser,
                         atom_list_to_save=atom_list_to_save,
                         parse_protein=params["PARSE_PROTEIN"],
                         parse_dna=params["PARSE_DNA"],
                         parse_rna=params["PARSE_RNA"],
                         parse_rna_as_dna=params["PARSE_RNA_AS_DNA"],
                         na_shared_tokens=params["NA_SHARED_TOKENS"],
                         protein_backbone_occ_cutoff=params["PROTEIN_BACKBONE_OCC_CUTOFF"],
                         protein_side_chain_occ_cutoff=params["PROTEIN_SIDE_CHAIN_OCC_CUTOFF"],
                         dna_backbone_occ_cutoff=params["DNA_BACKBONE_OCC_CUTOFF"],
                         dna_side_chain_occ_cutoff=params["DNA_SIDE_CHAIN_OCC_CUTOFF"],
                         rna_backbone_occ_cutoff=params["RNA_BACKBONE_OCC_CUTOFF"],
                         rna_side_chain_occ_cutoff=params["RNA_SIDE_CHAIN_OCC_CUTOFF"],
                         crop_large_structures=params["CROP_LARGE_STRUCTURES"],
                         batch_tokens=params["BATCH_TOKENS"],
                         na_ref_atom=params["NA_REF_ATOM"]
                        )

# Create a mask for the side chain atoms.
side_chain_mask = np.zeros(len(pdb_dataset.atom_dict), dtype = np.int32) # [N]
for atom_name in pdb_dataset.atom_dict:
    if (atom_name not in pdb_dataset.protein_backbone_list) and \
       (atom_name not in pdb_dataset.dna_backbone_list) and \
       (atom_name not in pdb_dataset.rna_backbone_list):
        side_chain_mask[pdb_dataset.atom_dict[atom_name]] = 1

side_chain_pairwise_mask = side_chain_mask[:, None] * side_chain_mask[None, :] # [N, N]

def write_text_file(path, contents):
    with open(path, mode = "wt") as f:
        f.write(contents)

class HB_data:
    # Class modified from Andrew Favor.

    # amino acid type to integer
    num2aa=[
        'ALA','ARG','ASN','ASP','CYS',
        'GLN','GLU','GLY','HIS','ILE',
        'LEU','LYS','MET','PHE','PRO',
        'SER','THR','TRP','TYR','VAL',
        'UNK','MAS',
        ' DA',' DC',' DG',' DT', ' DX',
        ' RA',' RC',' RG',' RU', ' RX',
        'HIS_D', # only used for cart_bonded
        'Al', 'As', 'Au', 'B',
        'Be', 'Br', 'C', 'Ca', 'Cl',
        'Co', 'Cr', 'Cu', 'F', 'Fe',
        'Hg', 'I', 'Ir', 'K', 'Li', 'Mg',
        'Mn', 'Mo', 'N', 'Ni', 'O',
        'Os', 'P', 'Pb', 'Pd', 'Pr',
        'Pt', 'Re', 'Rh', 'Ru', 'S',
        'Sb', 'Se', 'Si', 'Sn', 'Tb',
        'Te', 'U', 'W', 'V', 'Y', 'Zn',
        'ATM'
    ]
    aa2num= {x:i for i,x in enumerate(num2aa)}
    aa2num['MEN'] = 20
    aa2num_stripped = {x.strip():i for i,x in enumerate(num2aa)}
    aa2num_stripped['MEN'] = 20
    
    # full sc atom representation
    NTOTAL = 36
    aa2long=[
        (" N  "," CA "," C  "," O  "," CB ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","3HB ",  None,  None,  None,  None,  None,  None,  None,  None), #0  ala
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD "," NE "," CZ "," NH1"," NH2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HG ","2HG ","1HD ","2HD "," HE ","1HH1","2HH1","1HH2","2HH2"), #1  arg
        (" N  "," CA "," C  "," O  "," CB "," CG "," OD1"," ND2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HD2","2HD2",  None,  None,  None,  None,  None,  None,  None), #2  asn
        (" N  "," CA "," C  "," O  "," CB "," CG "," OD1"," OD2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ",  None,  None,  None,  None,  None,  None,  None,  None,  None), #3  asp
        (" N  "," CA "," C  "," O  "," CB "," SG ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB "," HG ",  None,  None,  None,  None,  None,  None,  None,  None), #4  cys
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD "," OE1"," NE2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HG ","2HG ","1HE2","2HE2",  None,  None,  None,  None,  None), #5  gln
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD "," OE1"," OE2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HG ","2HG ",  None,  None,  None,  None,  None,  None,  None), #6  glu
        (" N  "," CA "," C  "," O  ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  ","1HA ","2HA ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None), #7  gly
        (" N  "," CA "," C  "," O  "," CB "," CG "," ND1"," CD2"," CE1"," NE2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","2HD ","1HE ","2HE ",  None,  None,  None,  None,  None,  None), #8  his
        (" N  "," CA "," C  "," O  "," CB "," CG1"," CG2"," CD1",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA "," HB ","1HG2","2HG2","3HG2","1HG1","2HG1","1HD1","2HD1","3HD1",  None,  None), #9  ile
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD1"," CD2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB "," HG ","1HD1","2HD1","3HD1","1HD2","2HD2","3HD2",  None,  None), #10 leu
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD "," CE "," NZ ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HG ","2HG ","1HD ","2HD ","1HE ","2HE ","1HZ ","2HZ ","3HZ "), #11 lys
        (" N  "," CA "," C  "," O  "," CB "," CG "," SD "," CE ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HG ","2HG ","1HE ","2HE ","3HE ",  None,  None,  None,  None), #12 met
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD1"," CD2"," CE1"," CE2"," CZ ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HD ","2HD ","1HE ","2HE "," HZ ",  None,  None,  None,  None), #13 phe
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," HA ","1HB ","2HB ","1HG ","2HG ","1HD ","2HD ",  None,  None,  None,  None,  None,  None), #14 pro
        (" N  "," CA "," C  "," O  "," CB "," OG ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HG "," HA ","1HB ","2HB ",  None,  None,  None,  None,  None,  None,  None,  None), #15 ser
        (" N  "," CA "," C  "," O  "," CB "," OG1"," CG2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HG1"," HA "," HB ","1HG2","2HG2","3HG2",  None,  None,  None,  None,  None,  None), #16 thr
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD1"," CD2"," NE1"," CE2"," CE3"," CZ2"," CZ3"," CH2",  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HD ","1HE "," HZ2"," HH2"," HZ3"," HE3",  None,  None,  None), #17 trp
        (" N  "," CA "," C  "," O  "," CB "," CG "," CD1"," CD2"," CE1"," CE2"," CZ "," OH ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","1HD ","1HE ","2HE ","2HD "," HH ",  None,  None,  None,  None), #18 tyr
        (" N  "," CA "," C  "," O  "," CB "," CG1"," CG2",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA "," HB ","1HG1","2HG1","3HG1","1HG2","2HG2","3HG2",  None,  None,  None,  None), #19 val
        (" N  "," CA "," C  "," O  "," CB ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","3HB ",  None,  None,  None,  None,  None,  None,  None,  None), #20 unk
        (" N  "," CA "," C  "," O  "," CB ",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","3HB ",  None,  None,  None,  None,  None,  None,  None,  None), #21 mask

        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," N9 "," C4 "," N3 "," C2 "," N1 "," C6 "," C5 "," N7 "," C8 "," N6 ",  None,  None,"H5''"," H5'"," H4'"," H3'","H2''"," H2'"," H1'"," H2 "," H61"," H62"," H8 ",  None,  None), #22  DA
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," N1 "," C2 "," O2 "," N3 "," C4 "," N4 "," C5 "," C6 ",  None,  None,  None,  None,"H5''"," H5'"," H4'"," H3'","H2''"," H2'"," H1'"," H42"," H41"," H5 "," H6 ",  None,  None), #23  DC
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," N9 "," C4 "," N3 "," C2 "," N1 "," C6 "," C5 "," N7 "," C8 "," N2 "," O6 ",  None,"H5''"," H5'"," H4'"," H3'","H2''"," H2'"," H1'"," H1 "," H22"," H21"," H8 ",  None,  None), #24  DG
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," N1 "," C2 "," O2 "," N3 "," C4 "," O4 "," C5 "," C7 "," C6 ",  None,  None,  None,"H5''"," H5'"," H4'"," H3'","H2''"," H2'"," H1'"," H3 "," H71"," H72"," H73"," H6 ",  None), #25  DT
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,"H5''"," H5'"," H4'"," H3'","H2''"," H2'"," H1'",  None,  None,  None,  None,  None,  None), #26  DX (unk DNA)
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," O2'"," N1 "," C2 "," N3 "," C4 "," C5 "," C6 "," N6 "," N7 "," C8 "," N9 ",  None," H5'","H5''"," H4'"," H3'"," H2'","HO2'"," H1'"," H2 "," H61"," H62"," H8 ",  None,  None), #27   A
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," O2'"," N1 "," C2 "," O2 "," N3 "," C4 "," N4 "," C5 "," C6 ",  None,  None,  None," H5'","H5''"," H4'"," H3'"," H2'","HO2'"," H1'"," H42"," H41"," H5 "," H6 ",  None,  None), #28   C
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," O2'"," N1 "," C2 "," N2 "," N3 "," C4 "," C5 "," C6 "," O6 "," N7 "," C8 "," N9 "," H5'","H5''"," H4'"," H3'"," H2'","HO2'"," H1'"," H1 "," H22"," H21"," H8 ",  None,  None), #29   G
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," O2'"," N1 "," C2 "," O2 "," N3 "," C4 "," O4 "," C5 "," C6 ",  None,  None,  None," H5'","H5''"," H4'"," H3'"," H2'","HO2'"," H1'"," H3 "," H5 "," H6 ",  None,  None,  None), #30   U
        (" O4'"," C1'"," C2'"," OP1"," P  "," OP2"," O5'"," C5'"," C4'"," C3'"," O3'"," O2'",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H5'","H5''"," H4'"," H3'"," H2'","HO2'"," H1'",  None,  None,  None,  None,  None,  None), #31  RX (unk RNA)

        (" N  "," CA "," C  "," O  "," CB "," CG "," NE2"," CD2"," CE1"," ND1",  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None,  None," H  "," HA ","1HB ","2HB ","2HD ","1HE ","1HD ",  None,  None,  None,  None,  None,  None), #-1 his_d
    ]
    aa2long_stripped = []
    for aa_tuple in aa2long:
        aa_tuple_stripped = tuple(map(lambda atom_name: atom_name.strip() if atom_name is not None else atom_name, aa_tuple))
        aa2long_stripped.append(aa_tuple_stripped)

    def __init__(self, seq, xyz, idx=None, **kwargs):
        # Required parameters
        self.seq = seq
        self.xyz = xyz
        
        if not idx:
            self.idx = torch.arange(len(seq))

        # Optional parameters with default values
        self.incl_protein = kwargs.get('incl_protein', True)
        self.eps = kwargs.get('eps', 1e-8)
        # self.use_eigennormals = kwargs.get('use_eigennormals', True)
        # self.use_all_base_atoms_for_MBD = kwargs.get('use_all_base_atoms_for_MBD', False)
        self.edges_to_compute = kwargs.get('edges_to_compute', ['S']) # list base edges to compute, if we want to analyze WC/Hoog/etc
        self.perp_base_edge = kwargs.get('perp_base_edge', 'S') # edge orthogonal to x- and z-directions in base frames (which is generally the sugar edge)

        self.hbond_da_upper = kwargs.get('hbond_da_upper', 3.9) 
        self.hbond_ha_upper = kwargs.get('hbond_ha_upper', 2.5)

        self.seq_cutoff = kwargs.get('seq_cutoff', 2)
        
        compute_local_base_params    = kwargs.get('compute_local_base_params', False)
        compute_pairwise_base_params = kwargs.get('compute_pairwise_base_params', False)
        compute_paired_bases         = kwargs.get('compute_paired_bases', False)
        compute_helical_params       = kwargs.get('compute_helical_params', False)


        
        self.base_geometry_limits = {}
        self.base_geometry_limits['D_ij'] = kwargs.get('D_ij_limit', 20.0)
        self.base_geometry_limits['H_ij'] = kwargs.get('H_ij_limit', 1.5)
        self.base_geometry_limits['P_ij'] = kwargs.get('P_ij_limit', np.pi/5)
        self.base_geometry_limits['B_ij'] = kwargs.get('B_ij_limit', np.pi/5)
        
        # self.base_geometry_limits['O_ij'] = kwargs.get('O_ij_limit', 1.5) # Not used right now, currently allow all values of opening
        self.bp_val_cutoff= kwargs.get('bp_val_cutoff', 0.5) # minimum basepairing score for using a pair when computing helical params
        
        
        
        self.hbond_same_coeff = kwargs.get('hbond_same_coeff', 0.0)
        self.hbond_diff_coeff = kwargs.get('hbond_diff_coeff', 1.0)
        self.min_hbonds_for_bp = kwargs.get('min_hbonds_for_bp', 2.0)
        self.bp_hbond_coeff  = kwargs.get('bp_hbond_coeff', 8.0)

        self.clamp_pairwise_params  = kwargs.get('clamp_pairwise_params', False)
        
        # Initialize computed attributes
        self._init_hb_chemdata()
        self._compute_initial_values()
        self._compute_hbnets(store_hb_data_dict=kwargs.get('store_hb_data_dict', False))
        
        # For now only doing for NA:
        if self.is_na.sum() > 0: # Only compute nucleic params when there are nucleics in the structure
            self._init_nuc_chemdata()
            self._edges_to_compute = list(set(self.edges_to_compute) | {self.perp_base_edge})  # Must compute this base-edge
            self._compute_local_base_params() # Define canonical base-frames for the specified edges
                
            if compute_pairwise_base_params or compute_paired_bases:
                self._compute_pairwise_base_params() # Compute pairwise geometric parameters between bases
                self._compute_paired_bases() # Classify bases using H-bond count and pairwise base geometry filters
            
            if compute_helical_params:
                self._compute_helical_params() # In progress...

    def _compute_initial_values(self):
        self.len_s = int(self.seq.shape[0])
        self.sel = torch.arange(self.len_s)
        self.seq_neighbors = torch.le(torch.abs(self.sel[:, None] - self.sel[None, :]), self.seq_cutoff)
        self.is_protein = torch.logical_and((0 <= self.seq), (self.seq <= 21))
        self.is_dna = torch.logical_and((22 <= self.seq), (self.seq <= 25))
        self.is_rna = torch.logical_and((27 <= self.seq), (self.seq <= 30))
        self.is_na = torch.logical_or(self.is_dna, self.is_rna)

        self.na_inds = [i for i,is_na_i in enumerate(self.is_na) if is_na_i]
        self.na_tensor_inds = {na_i:i for i,na_i in enumerate(self.na_inds)}
        
        frame_xyz = self.xyz[:,1,:]
        padded_centers = torch.cat([frame_xyz[:1], frame_xyz[:], frame_xyz[-1:]])
        
        self.D_ij_vec = frame_xyz.unsqueeze(0) - frame_xyz.unsqueeze(1) # pairwise displacement vector between frame centers
        self.D_ij = self.D_ij_vec.norm(dim=-1)
        self.M_i = ((padded_centers[1:-1] - padded_centers[:-2]) + (padded_centers[2:] - padded_centers[1:-1])) / 2 # average direction vector from consecutive frames in backbone
        self.M_i_doublet = padded_centers[1:] - padded_centers[:-1]
        
    def _compute_hbnets(self, store_hb_data_dict=False):
        
        # Distance between frames is between lower and upper bounds:
        D_ij_filter = (self.D_ij <= self.base_geometry_limits['D_ij'])
        
        # neighbor filter for all polymer types:
        neighbor_inds = torch.triu(D_ij_filter.bool(),diagonal=1).nonzero(as_tuple=True)
        
        pairwise_indices = list(zip(neighbor_inds[0].tolist(), neighbor_inds[1].tolist()))
        bp_pred_summation = torch.zeros_like(self.D_ij)

        # self.hb_data_dict = {i:{j:[] for j in range(self.len_s)} for i in range(self.len_s) }
        hb_data_dict = {i:{j:{} for j in range(self.len_s)} for i in range(self.len_s) }


        self.hbond_summation = torch.zeros_like(D_ij_filter, dtype=torch.float)

        for i,j in pairwise_indices:
            for a_i, is_donor_i in zip(self.hbond_atoms[HB_data.num2aa[self.seq[i]]]['names'],self.hbond_atoms[HB_data.num2aa[self.seq[i]]]['donor']):
                for a_j, is_donor_j in zip(self.hbond_atoms[HB_data.num2aa[self.seq[j]]]['names'],self.hbond_atoms[HB_data.num2aa[self.seq[j]]]['donor']):
                    atom_pair = f"{a_i}-{a_j}" # avoid duplicate counting for atom pairs
                    if (is_donor_i+is_donor_j)==1 and (atom_pair not in hb_data_dict[i][j].keys()):
                        

                        a_i_ind = HB_data.aa2long[self.seq[i]].index(a_i)
                        a_j_ind = HB_data.aa2long[self.seq[j]].index(a_j)

                        # Create vector between donor and acceptor atoms
                        d_ijk_vec = self.xyz[i,a_i_ind] - self.xyz[j,a_j_ind]
                        d_ijk_vec_norm = d_ijk_vec/d_ijk_vec.norm(dim=-1)

                        # Create vector giving direction to donor and acceptor along sidechain covalent bond:
                        a_i_vec = torch.cat(
                            [(self.xyz[i,a_i_ind]-self.xyz[i,HB_data.aa2long[self.seq[i]].index(r_i)])[:,None] for r_i in self.rear_atoms[HB_data.num2aa[self.seq[i]]][a_i]], 
                            dim=1).mean(dim=1)
                        a_i_vec_norm = a_i_vec/(a_i_vec.norm(dim=-1) + self.eps)

                        a_j_vec = torch.cat(
                            [(self.xyz[j,a_j_ind]-self.xyz[j,HB_data.aa2long[self.seq[j]].index(r_j)])[:,None] for r_j in self.rear_atoms[HB_data.num2aa[self.seq[j]]][a_j]], 
                            dim=1).mean(dim=1)
                        a_j_vec_norm = a_j_vec/(a_j_vec.norm(dim=-1) + self.eps)


                        num_rear_i = len(self.rear_atoms[HB_data.num2aa[self.seq[i]]][a_i])
                        element_i = ''.join([_ for _ in a_i if _.isalpha()])[0]
                        ideal_angle_i = self.ideal_angle_dict[element_i][num_rear_i]

                        num_rear_j = len(self.rear_atoms[HB_data.num2aa[self.seq[j]]][a_j])
                        element_j = ''.join([_ for _ in a_j if _.isalpha()])[0]
                        ideal_angle_j = self.ideal_angle_dict[element_j][num_rear_j]

                        ideal_angle_h = torch.tensor((is_donor_i*ideal_angle_i) + (is_donor_j*ideal_angle_j))

                        xyz_d_ijk = (  is_donor_i   * self.xyz[i,a_i_ind] ) + (  is_donor_j   * self.xyz[j,a_j_ind] )
                        xyz_a_ijk = ((1-is_donor_i) * self.xyz[i,a_i_ind] ) + ((1-is_donor_j) * self.xyz[j,a_j_ind] )

                        # (1, rd): vector pointing to donor atom from rear atom(s):
                        rd_ijk_vec = (is_donor_i * a_i_vec_norm) + (is_donor_j * a_j_vec_norm)
                        rd_ijk_vec_norm = rd_ijk_vec/(rd_ijk_vec.norm(dim=-1) + self.eps)

                        # (2, da): vector pointing from donor atom to acceptor atom, approximately in direction of the hydrogen:
                        da_ijk_vec = xyz_a_ijk - xyz_d_ijk
                        da_ijk_vec_norm = da_ijk_vec/(da_ijk_vec.norm(dim=-1) + self.eps)

                        # (3, ar): vector pointing to acceptor atom from rear atom(s):
                        ar_ijk_vec = ((is_donor_i-1)*a_i_vec_norm) +  ((is_donor_j-1)*a_j_vec_norm)
                        ar_ijk_vec_norm = ar_ijk_vec/(ar_ijk_vec.norm(dim=-1) + self.eps)


                        norm_vec = torch.cross(-rd_ijk_vec_norm, da_ijk_vec_norm, dim=-1)
                        norm_unit = norm_vec / (norm_vec.norm() + self.eps)  # Avoid divide-by-zero
                        perp_vec = torch.cross(norm_unit, -rd_ijk_vec_norm, dim=-1)
                        perp_unit = perp_vec / (perp_vec.norm() + self.eps)


                        # (4, dh): predicted ideal angle pointing from donor atom to hydrogen atom:
                        dh_ijk_vec = (torch.sin(ideal_angle_h) * perp_unit) - (torch.cos(ideal_angle_h) * rd_ijk_vec_norm)
                        dh_ijk_vec_norm = dh_ijk_vec / (dh_ijk_vec.norm() + self.eps) # norm actually matters here, because Donor -> H distance is exactly 1A.
                        ideal_xyz_h_ijk = xyz_d_ijk + dh_ijk_vec_norm # Compute ideal hydrogen placement

                        # (5, ha): vector pointing from ideal hydrogen to acceptor atom
                        ha_ijk_vec = xyz_a_ijk - ideal_xyz_h_ijk
                        ha_ijk_vec_norm = ha_ijk_vec / (ha_ijk_vec.norm() + self.eps)


                        t_rdh = torch.acos( ( -rd_ijk_vec_norm * dh_ijk_vec_norm ).sum(dim=-1) )
                        t_rda = torch.acos( ( -rd_ijk_vec_norm * da_ijk_vec_norm ).sum(dim=-1) )
                        t_dha = torch.acos( ( -dh_ijk_vec_norm * ha_ijk_vec_norm ).sum(dim=-1) )
                        t_dar = torch.acos( ( -da_ijk_vec_norm * ar_ijk_vec_norm ).sum(dim=-1) )
                        t_har = torch.acos( ( -ha_ijk_vec_norm * ar_ijk_vec_norm ).sum(dim=-1) )


                        da_ijk = da_ijk_vec.norm(dim=-1)
                        ha_ijk = ha_ijk_vec.norm(dim=-1)

                        hbond_da_filter = ( da_ijk <= self.hbond_da_upper )
                        hbond_ha_filter = ( ha_ijk <= self.hbond_ha_upper ) # SHOULD BE MOST IMPORTANT
                        
                        hbond_t_rda_filter = ( t_rda >= 5*np.pi/9 ) #   cutoff (100 degrees) proposed by:   https://pmc.ncbi.nlm.nih.gov/articles/PMC8261469/
                        hbond_t_dar_filter = ( t_dar >= 5*np.pi/9 ) #   similar logic to above
                        hbond_t_dha_filter = ( t_dha >= np.pi/2   ) #   could also increase this one maybe
                        
                        bond_prob_ij = (hbond_ha_filter * hbond_da_filter * hbond_t_rda_filter * hbond_t_dar_filter).float()

                        self.hbond_summation[i,j] += bond_prob_ij
                        self.hbond_summation[j,i] += bond_prob_ij
                        
                        hb_data_dict[i][j][atom_pair] = {'d': da_ijk, 'l': ha_ijk, "t_rdh": t_rdh, "t_rda": t_rda, "t_dha": t_dha, "t_dar": t_dar, "t_har": t_har, 'atoms': atom_pair, "bonded": bond_prob_ij, }
                        hb_data_dict[j][i][atom_pair] = {'d': da_ijk, 'l': ha_ijk, "t_rdh": t_rdh, "t_rda": t_rda, "t_dha": t_dha, "t_dar": t_dar, "t_har": t_har, 'atoms': atom_pair, "bonded": bond_prob_ij, }

        if store_hb_data_dict:
            self.hb_data_dict = hb_data_dict
                        
    def _compute_local_base_params(self):
        """
        local base params , based on interaction-edges

        """
        xyz_na = self.xyz[self.is_na]
        seq_na = self.seq[self.is_na]
        

        """
        (1). Compute base normals and correct orientation based on backbone direction.
        """
        base_atom_xyz = torch.stack([xyz_na[i,self.ring_atom_inds[HB_data.num2aa[s_i]],:] for i,s_i in enumerate(seq_na)] )
        base_atom_centers = torch.mean(base_atom_xyz, dim=1)
            
        centered_points = base_atom_xyz - base_atom_centers.unsqueeze(1)
        cov_matrix = torch.einsum('bij,bik->bjk', centered_points, centered_points) / (centered_points.shape[1] - 1)
        eigenvalues, eigenvectors = torch.linalg.eigh(cov_matrix)
        
        # Keep N_i local, since we will only need Z_i after this function
        N_i = eigenvectors[:, :, 0] / eigenvectors[:, :, 0].norm(dim=1, keepdim=True) 

        # Correct base normals to point in direction of backbone 5' -> 3' by projecting backbone vec M_i onto this unit Z_i vector to flip direction if necessary
        self.Z_i = N_i * torch.sum(self.M_i[self.is_na] * N_i, dim=-1, keepdim=True)
        self.Z_i = self.Z_i / (torch.norm(self.Z_i, dim=-1, keepdim=True) + self.eps)
        
        """
        (2). Compute the desired edge-vectors for the bases (watson-crick, hoogstein, sugar, etc)
            * W edge: N1 of purine, N3  of pyrimidine
            * H edge: N7 of purine, C5  of pyrimidine
            * S edge: N3 of purine, C1' of pyrimidine
            * B (pseudo)-edge: connects C1' to first base-atom (N1 or N3?)
        """
        # Compute X and Y vectors for edges of interest:
        self.edge_X_vecs, self.edge_Y_vecs = {}, {}
        for edge in self.edges_to_compute:
            self.edge_X_vecs[edge]     = torch.stack([xyz_na[i,self.vec_atom_inds[HB_data.num2aa[s_i]][f'{edge}_stop'],:] - xyz_na[i,self.vec_atom_inds[HB_data.num2aa[s_i]][f'{edge}_start'],:] for i, s_i in  enumerate(seq_na)])
            self.edge_X_vecs[edge]     = self.edge_X_vecs[edge] / (torch.norm(self.edge_X_vecs[edge], dim=-1, keepdim=True) + self.eps)
            
            # self.edge_Y_vecs[edge]     = torch.cross(self.edge_X_vecs[edge], N_i, dim=-1)
            self.edge_Y_vecs[edge]     = torch.cross(self.edge_X_vecs[edge], self.Z_i, dim=-1)
            self.edge_Y_vecs[edge]     = self.edge_Y_vecs[edge] / (torch.norm(self.edge_Y_vecs[edge], dim=-1, keepdim=True) + self.eps)
        
        """
        (3).  Define canonical base frames in terms of one specific edge.
              The sugar edge generally works best here, as it most often points towards binding partner 
              (orthogonal to both major groove and helical axis)
        """
        
        self.X_i = torch.cross(self.Z_i, self.edge_X_vecs[self.perp_base_edge], dim=-1)
        self.X_i = self.X_i / (torch.norm(self.X_i, dim=-1, keepdim=True) + self.eps)

        self.Y_i = torch.cross(self.X_i, self.Z_i, dim=-1)
        self.Y_i = self.Y_i / (torch.norm(self.Y_i, dim=-1, keepdim=True) + self.eps)
        self.base_atom_centers = base_atom_centers
        
    def _compute_pairwise_base_params(self):
        
        D_ij_vec_na = self.D_ij_vec[torch.arange(self.is_na.sum()).unsqueeze(1), torch.arange(self.is_na.sum())]
        base_D_ij_vec = self.base_atom_centers.unsqueeze(0) - self.base_atom_centers.unsqueeze(1)
        
        # stack mean Z-direction vectors for parallel (0) and antiparallel (1) orientations in zeroth-axis:
        Z_ij_oris = 0.5*torch.stack((self.Z_i.unsqueeze(1) + self.Z_i.unsqueeze(0), self.Z_i.unsqueeze(1) - self.Z_i.unsqueeze(0) ), dim=0)

        # Check which are parallel or antiparallel:
        bases_are_antiparallel = (Z_ij_oris[1].norm(dim=-1) > Z_ij_oris[0].norm(dim=-1)).long()

        # Extract mean Z-direction based on maximum shared direction between planes of base i and j:
        Z_ij = Z_ij_oris[bases_are_antiparallel, torch.arange(self.is_na.sum()).unsqueeze(1), torch.arange(self.is_na.sum())]
        Z_ij = Z_ij / (torch.norm(Z_ij, dim=-1, keepdim=True) + self.eps)
        
        Y_ij = D_ij_vec_na / (torch.norm(D_ij_vec_na, dim=-1, keepdim=True) + self.eps)
        X_ij = torch.cross(Z_ij, Y_ij, dim=-1)

        X_ij = X_ij / (torch.norm(X_ij, dim=-1, keepdim=True) + self.eps)
        
        self.H_ij = torch.sum(base_D_ij_vec * Z_ij, dim=-1)
        self.H_ij_vec = self.H_ij[...,None] * Z_ij

        # Opening: angle between local x_i and x_j within global X_ij-Y_ij plane:
        proj_X_i_XY = ((self.X_i[:, None, :] * X_ij).sum(dim=-1, keepdim=True) * X_ij) + ((self.X_i[:, None, :] * Y_ij).sum(dim=-1, keepdim=True) * Y_ij)
        proj_X_i_XY_norm = proj_X_i_XY / (torch.norm(proj_X_i_XY, dim=-1, keepdim=True) + self.eps)
        cos_opening = (proj_X_i_XY_norm * proj_X_i_XY_norm.transpose(1,0)).sum(dim=-1)
        if self.clamp_pairwise_params:
            cos_opening = torch.clamp(cos_opening, -1.0, 1.0)
        O_ij = torch.acos(cos_opening)

        # Buckle: angle between local z_i and z_j within global Y_ij-Z_ij plane:
        proj_Z_i_YZ = ((self.Z_i[:, None, :] * Y_ij).sum(dim=-1, keepdim=True) * Y_ij) + ((self.Z_i[:, None, :] * Z_ij).sum(dim=-1, keepdim=True) * Z_ij)    
        proj_Z_i_YZ_norm = proj_Z_i_YZ / (torch.norm(proj_Z_i_YZ, dim=-1, keepdim=True) + self.eps)
        cos_buckle = (proj_Z_i_YZ_norm * -proj_Z_i_YZ_norm.transpose(1,0)).sum(dim=-1)
        if self.clamp_pairwise_params:
            cos_buckle = torch.clamp(cos_buckle, -1.0, 1.0)
        cos_buckle = torch.clamp(cos_buckle, -1.0, 1.0)
        B_ij = torch.acos(cos_buckle)

        # Propeller: angle between local z_i and z_j within global Z_ij-X_ij plane:
        proj_Z_i_ZX = ((self.Z_i[:, None, :] * Z_ij).sum(dim=-1, keepdim=True) * Z_ij) + ((self.Z_i[:, None, :] * X_ij).sum(dim=-1, keepdim=True) * X_ij)    
        proj_Z_i_ZX_norm = proj_Z_i_ZX / (torch.norm(proj_Z_i_ZX, dim=-1, keepdim=True) + self.eps)
        cos_propeller = (proj_Z_i_ZX_norm * -proj_Z_i_ZX_norm.transpose(1,0)).sum(dim=-1)
        if self.clamp_pairwise_params:
            cos_propeller = torch.clamp(cos_propeller, -1.0, 1.0)
        P_ij = torch.acos(cos_propeller)
        
        # Local frame components for sidechains:
        self.X_ij = X_ij
        self.Y_ij = Y_ij
        self.Z_ij = Z_ij
        
        # pairwise base parameters:
        self.O_ij = O_ij
        self.B_ij = B_ij
        self.P_ij = P_ij
        self.bases_are_antiparallel = bases_are_antiparallel

    def _compute_paired_bases(self):
        
        # Compute baseline bp probability based on hydrogen bond count
        bp_preds = torch.sigmoid(self.bp_hbond_coeff * (self.hbond_summation - (self.min_hbonds_for_bp - 1))) # offset by 1 for midpoint
        
        # basepair-specific filters:
        both_nucleic_filter = self.is_na[:,None] * self.is_na[None,:]
        
        # Frame distance filter, already taken care of
        # D_ij_filter = (self.D_ij_vec.norm(dim=-1) < self.base_geometry_limits['D_ij']) 
        # Rise between base-planes is within lower and upper bounds
        # H_ij_filter = (self.H_ij.norm(dim=-1) > -self.base_geometry_limits['H_ij']) & (self.H_ij.norm(dim=-1) < self.base_geometry_limits['H_ij']) 
        H_ij_filter = (self.H_ij >= -self.base_geometry_limits['H_ij']) & (self.H_ij <= self.base_geometry_limits['H_ij']) 
        # H_ij_filter = (self.H_ij.T >= -self.base_geometry_limits['H_ij']) & (self.H_ij.T <= self.base_geometry_limits['H_ij']) 
        # Buckle between bases is either lower than lower bound or higher than upper bound (stay close to 0 or pi):
        B_ij_filter = (self.B_ij <= (np.pi - self.base_geometry_limits['B_ij'])) | (self.B_ij >= self.base_geometry_limits['B_ij'])
        # Propeller between bases is either lower than lower bound or higher than upper bound (stay close to 0 or pi):
        P_ij_filter = (self.P_ij <= (np.pi - self.base_geometry_limits['P_ij'])) | (self.P_ij >= self.base_geometry_limits['P_ij'])
        
        
        # combine for full basepair filter:
        bp_geom_filter = torch.zeros(self.len_s, self.len_s, dtype=torch.bool)
        bp_geom_filter[torch.outer(self.is_na, self.is_na)] = (H_ij_filter * B_ij_filter * P_ij_filter).flatten()
        # bp_geom_filter[torch.outer(self.is_na, self.is_na)] = (              B_ij_filter * P_ij_filter).flatten()
        # bp_geom_filter[torch.outer(self.is_na, self.is_na)] = (H_ij_filter *               P_ij_filter).flatten()
        # bp_geom_filter[torch.outer(self.is_na, self.is_na)] = (H_ij_filter * B_ij_filter              ).flatten()
        self.basepairs_ij = both_nucleic_filter * bp_geom_filter * bp_preds

    def _compute_helical_params(self):
        
        len_na = self.Z_i.shape[0] # Do I need this?
        nucleic_frames = self.xyz[self.is_na, 1, :]
        doublet_inds = [(i,j) for (i,j) in zip(range(0,len_na-1),range(1,len_na))]
        
        
        Zm_i = torch.zeros_like(self.Z_i)
        Zh_i = torch.zeros_like(self.Z_i)
        
        # Local doublet step params
        tilt_i          = torch.zeros(len_na)
        roll_i          = torch.zeros(len_na)
        twist_i         = torch.zeros(len_na)
        shift_i         = torch.zeros(len_na)
        slide_i         = torch.zeros(len_na)
        rise_i          = torch.zeros(len_na)
        
        
        # Local helical parameters
        inclination_i   = torch.zeros(len_na)
        tip_i           = torch.zeros(len_na)
        helical_twist_i = torch.zeros(len_na)
        x_disp_i        = torch.zeros(len_na)
        y_disp_i        = torch.zeros(len_na)
        helical_rise_i  = torch.zeros(len_na)
        
        # avg_factor = torch.zeros_like(self.Z_i[:,0])
        avg_factor = torch.zeros(len_na)
        for i,j in doublet_inds:
            avg_factor[i] += 1.0
            avg_factor[j] += 1.0
        
        
        basepaired_inds = (self.basepairs_ij >= self.bp_val_cutoff).bool().nonzero(as_tuple=True)
        
        pairwise_indices = list(zip(basepaired_inds[0].tolist(), basepaired_inds[1].tolist()))
        
        # partner_info_dict = {i:{'partner_ind':[], 'orientation':[], 'num_hbonds':[], 'bp_score': []} for i in range(len_na)}
        partner_info_dict = {i:{'partner_ind':[], 'orientation':[], 'num_hbonds':[], 'bp_score': []} for i in self.na_inds}
        
        for i, j in pairwise_indices:
            _i,_j = self.na_tensor_inds[i], self.na_tensor_inds[j]
            partner_info_dict[i]['partner_ind'].append(j)
            partner_info_dict[i]['orientation'].append(self.bases_are_antiparallel[_i,_j])
            partner_info_dict[i]['num_hbonds'].append(self.hbond_summation[_i,_j])
            partner_info_dict[i]['bp_score'].append(self.basepairs_ij[_i,_j])
            
                


        # TO DO: sort partner_info_dict[i]['partner_ind'] list by: first by orientation, then by num_hbonds
        # If we don't do the sorting, no need to compile these lists in the dict. Can just index directly from precomputed values.
        # for i in partner_info_dict.keys():
        for i_1, i_2 in doublet_inds:

            partners_i_1 = [self.na_tensor_inds[_] for _ in partner_info_dict[self.na_inds[i_1]]['partner_ind']]
            partners_i_2 = [self.na_tensor_inds[_] for _ in partner_info_dict[self.na_inds[i_2]]['partner_ind']]

                
            # set_trace()
            # j_1 = partners_i_1[0] # index-[0] is just a placeholder for later iteration
            # j_2 = partners_i_2[0] # index-[0] is just a placeholder for later iteration
            num_partners_i_1 = len(partners_i_1) # later change to be length of iterable
            num_partners_i_2 = len(partners_i_2) # later change to be length of iterable
            for j_1 in partners_i_1:
                # _j_1 = self.na_tensor_inds[j_1]
                for j_2 in partners_i_2:
                    X_1 = self.X_ij[i_1,j_1]
                    Y_1 = self.Y_ij[i_1,j_1]
                    X_2 = self.X_ij[i_2,j_2]
                    Y_2 = self.Y_ij[i_2,j_2]

                    Xp = X_2 + X_1
                    Xn = X_2 - X_1
                    Yp = Y_2 + Y_1
                    Yn = Y_2 - Y_1
                    
                    M_12 = 0.5*((nucleic_frames[i_2]+nucleic_frames[j_2]) - (nucleic_frames[i_1]+nucleic_frames[j_1]))

                    Zm = torch.cross(Xp, Yp, dim=-1) / ((Xp.norm(dim=-1) * Yp.norm(dim=-1)) + self.eps)
                    Zh = torch.cross(Xn, Yn, dim=-1) / ((Xn.norm(dim=-1) * Yn.norm(dim=-1)) + self.eps)

                    Zm_i[i_1] += Zm / (avg_factor[i_1]+self.eps)
                    Zh_i[i_1] += Zh / (avg_factor[i_1]+self.eps)

                    Zm_i[i_2] += Zm / (avg_factor[i_2]+self.eps)
                    Zh_i[i_2] += Zh / (avg_factor[i_2]+self.eps)


                    tilt_ij  = -torch.arcsin(torch.sum(Zm * X_1 , dim=-1))
                    roll_ij  =  torch.arcsin(torch.sum(Zm * Y_1 , dim=-1))
                    twist_ij = torch.arccos(torch.sum(torch.cross(X_1 , Zm, dim=-1) * torch.cross(X_2 , Zm, dim=-1), dim=-1))
                    shift_ij = torch.sum(M_12 * (Xp / (torch.norm(Xp, dim=-1)+self.eps)), dim=-1)
                    slide_ij = torch.sum(M_12 * (Yp / (torch.norm(Yp, dim=-1)+self.eps)), dim=-1)
                    rise_ij  = torch.sum(M_12 * Zm , dim=-1)

                    inclination_ij    =  torch.arcsin(torch.sum(Zh * X_1 , dim=-1))
                    tip_ij            = -torch.arcsin(torch.sum(Zh * Y_1 , dim=-1))
                    helical_twist_ij  = -torch.arccos(torch.sum(torch.cross(X_1 , Zh, dim=-1) * torch.cross(X_2 , Zh, dim=-1), dim=-1))
                    x_disp_ij         =  torch.sum(M_12 * Xn / (torch.norm(Xn, dim=-1)+self.eps), dim=-1)
                    y_disp_ij         =  torch.sum(M_12 * Yn / (torch.norm(Yn, dim=-1)+self.eps), dim=-1)
                    helical_rise_ij   = -torch.sum(M_12 * Zh, dim=-1)

                    # NEXT JUST ADD THESE PARAMS TO SOME PRE-INITIALIZED TENSOR AND DIVIDE BY AVG_FACTOR TO AVERAGE:
                    # For doublet position-1:
                    avg_factor[i_1] += 1.0
                    tilt_i[i_1] +=           tilt_ij          
                    roll_i[i_1] +=           roll_ij          
                    twist_i[i_1] +=          twist_ij         
                    shift_i[i_1] +=          shift_ij         
                    slide_i[i_1] +=          slide_ij         
                    rise_i[i_1] +=           rise_ij          
                    inclination_i[i_1] +=    inclination_ij   
                    tip_i[i_1] +=            tip_ij           
                    helical_twist_i[i_1] +=  helical_twist_ij 
                    x_disp_i[i_1] +=         x_disp_ij        
                    y_disp_i[i_1] +=         y_disp_ij        
                    helical_rise_i[i_1] +=   helical_rise_ij  

                    # For doublet position-2:
                    avg_factor[i_2] += 1.0
                    tilt_i[i_2] +=           tilt_ij          
                    roll_i[i_2] +=           roll_ij          
                    twist_i[i_2] +=          twist_ij         
                    shift_i[i_2] +=          shift_ij         
                    slide_i[i_2] +=          slide_ij         
                    rise_i[i_2] +=           rise_ij          
                    inclination_i[i_2] +=    inclination_ij   
                    tip_i[i_2] +=            tip_ij           
                    helical_twist_i[i_2] +=  helical_twist_ij 
                    x_disp_i[i_2] +=         x_disp_ij        
                    y_disp_i[i_2] +=         y_disp_ij        
                    helical_rise_i[i_2] +=   helical_rise_ij  


                self.tilt_i          = tilt_i / (avg_factor + self.eps)
                self.roll_i          = roll_i / (avg_factor + self.eps)
                self.twist_i         = twist_i / (avg_factor + self.eps)
                self.shift_i         = shift_i / (avg_factor + self.eps)
                self.slide_i         = slide_i / (avg_factor + self.eps)
                self.rise_i          = rise_i / (avg_factor + self.eps)
                self.inclination_i   = inclination_i / (avg_factor + self.eps)
                self.tip_i           = tip_i / (avg_factor + self.eps)
                self.helical_twist_i = helical_twist_i / (avg_factor + self.eps)
                self.x_disp_i        = x_disp_i / (avg_factor + self.eps)
                self.y_disp_i        = y_disp_i / (avg_factor + self.eps)
                self.helical_rise_i  = helical_rise_i / (avg_factor + self.eps)

    def _init_hb_chemdata(self):



        #     RESIDUE   |       DONORS        |     ACCEPTORS     
        self.hbond_atoms = {
            "ALA": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "ARG": {"names":[" NH1"," NH2"                                           ],
                    "donor":[   1  ,   1                                             ]},
            "ASN": {"names":[" ND2",               " OD1"                            ],
                    "donor":[   1  ,                  0                              ]},
            "ASP": {"names":[" OD2",               " OD1"," OD2"                     ],
                    "donor":[   1  ,                  0  ,   0                       ]},
            "CYS": {"names":[" SG "                                                  ],
                    "donor":[   1                                                    ]},
            "GLN": {"names":[" NE2",               " OE1"                            ],
                    "donor":[   1  ,                  0                              ]},
            "GLU": {"names":[" OE2",               " OE1"," OE2"                     ],
                    "donor":[   1  ,                  0  ,   0                       ]},
            "GLY": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "HIS": {"names":[" ND1"," NE2",        " ND1"," NE2"                     ],
                    "donor":[   1  ,   1  ,           0  ,   0                       ]},
            "ILE": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "LEU": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "LYS": {"names":[" NZ "                                                  ],
                    "donor":[   1                                                    ]},
            "MET": {"names":[                      " SD "                            ],
                    "donor":[                         0                              ]},
            "PHE": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "PRO": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "SER": {"names":[" OG "                                                  ],
                    "donor":[   1                                                    ]},
            "THR": {"names":[" OG1"                                                  ],
                    "donor":[   1                                                    ]},
            "TRP": {"names":[                      " NE1"                            ],
                    "donor":[                         0                              ]},
            "TYR": {"names":[" OH "                                                  ],
                    "donor":[   1                                                    ]},
            "VAL": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "UNK": {"names":[                                                        ],
                    "donor":[                                                        ]},
            "MAS": {"names":[                                                        ],
                    "donor":[                                                        ]},
            " DA": {"names":[" N6 ",               " N1 "," N3 "," N7 "              ],
                    "donor":[   1  ,                  0  ,   0  ,   0                ]},
            " DG": {"names":[" N1 "," N2 "," N7 ", " O6 "," N1 "," N3 "," N7 "       ],
                    "donor":[   1  ,   1  ,   1  ,    0  ,   0  ,   0  ,   0         ]},
            " DC": {"names":[" N4 "," N3 ",        " O2 "," N3 "                     ],
                    "donor":[   1  ,   1  ,           0  ,   0                       ]},
            " DT": {"names":[" N3 ",               " O2 "," O4 "                     ],
                    "donor":[   1  ,                  0  ,   0                       ]},
            " DX": {"names":[                                                        ],
                    "donor":[                                                        ]},
            " RA": {"names":[" O2'"," N6 ",        " N1 "," N3 "," N7 "              ],
                    "donor":[    1 ,   1  ,           0  ,   0  ,   0                ]},
            " RG": {"names":[" O2'"," N1 "," N2 "," N7 ", " O6 "," N1 "," N3 "," N7 "],
                    "donor":[    1 ,   1  ,   1  ,   1  ,    0  ,   0  ,   0  ,   0  ]},
            " RC": {"names":[" O2'"," N4 "," N3 ",        " O2 "," N3 "              ],
                    "donor":[    1 ,   1  ,   1  ,           0  ,   0                ]},
            " RU": {"names":[" O2'"," N3 ",               " O2 "," O4 "              ],
                    "donor":[    1 ,    1 ,                  0  ,   0                ]},
            " RX": {"names":[" O2'",                                                 ],
                    "donor":[    1 ,                                                 ]},
        }



        # define atoms behind all donors/acceptors/tip-atoms so that we can use them to draw a vector giving the direction of [rear-atoms] -> [tip-atoms] 
        self.rear_atoms = {
            "ALA": {},
            "ARG": {" NH1":[" CZ "], " NH2":[" CZ "],},
            "ASN": {" OD1":[" CG "], " ND2":[" CG "],},
            "ASP": {" OD1":[" CG "], " OD2":[" CG "],},
            "CYS": {" SG ":[" CB "],},
            "GLN": {" OE1":[" CD "], " NE2":[" CD "],},
            "GLU": {" OE1":[" CD "], " OE2":[" CD "],},
            "GLY": {},
            "HIS": {" ND1":[" CG "," CE1"], " NE2":[" CD2"," CE1"],},
            "ILE": {},
            "LEU": {},
            "LYS": {" NZ ":[" CE "],},
            "MET": {" SD ":[" CG "," CE "],},
            "PHE": {},
            "PRO": {},
            "SER": {" OG ":[" CB "],},
            "THR": {" OG1":[" CB "],},
            "TRP": {" NE1":[" CD1"," CE2"],},
            "TYR": {" OH ":[" CZ "],},
            "VAL": {},
            "UNK": {},
            "MAS": {},
            " DA": {" N6 ":[" C6 ",], " N1 ":[" C2 "," C6 "], " N3 ":[" C2 "," C4 "], " N7 ":[" C5 "," C8 "],},
            " DG": {" N1 ":[" C2 "," C6 "], " N2 ":[" C2 ",], " N7 ":[" C5 "," C8 "], " O6 ":[" C6 ",], " N3 ":[" C2 "," C4 "], " N7 ":[" C5 "," C8 "],},
            " DC": {" N4 ":[" C4 ",], " N3 ":[" C2 "," C5 "], " O2 ":[" C2 ",],},
            " DT": {" N3 ":[" C2 "," C4 "], " O2 ":[" C2 ",], " O4 ":[" C4 ",],},
            " DX": {},
            " RA": {" O2'":[" C2'",],  " N6 ":[" C6 ",], " N1 ":[" C2 "," C6 "], " N3 ":[" C2 "," C4 "], " N7 ":[" C5 "," C8 "],},
            " RG": {" O2'":[" C2'",],  " N1 ":[" C2 "," C6 "], " N2 ":[" C2 ",], " N7 ":[" C5 "," C8 "], " O6 ":[" C6 ",], " N3 ":[" C2 "," C4 "], " N7 ":[" C5 "," C8 "],},
            " RC": {" O2'":[" C2'",],  " N4 ":[" C4 ",], " N3 ":[" C2 "," C5 "], " O2 ":[" C2 ",],},
            " RU": {" O2'":[" C2'",],  " N3 ":[" C2 "," C4 "], " O2 ":[" C2 ",], " O4 ":[" C4 ",],},
            " RX": {" O2'":[" C2'",], },
        }



        self.ideal_angle_dict = {
            'O': {
                1: 109.5*(np.pi/180),
                2: 180.0*(np.pi/180)},
            'N': {
                1: 120.0*(np.pi/180),
                2: 180.0*(np.pi/180)},
            'S': { # TO DO: CHECK IF BOND ANGLES ARE CORRECT!
                1: 109.5*(np.pi/180),
                2: 180.0*(np.pi/180)},
            'P': { # TO DO: CHECK IF BOND ANGLES ARE CORRECT!
                1: 120.0*(np.pi/180),
                2: 180.0*(np.pi/180)},
        }


    def _init_nuc_chemdata(self):

        self.nuc_resi_3letter = [" DA"," DG"," DC"," DT"," RA"," RG"," RC"," RU"]

        # Vectors between atom pairs that define each interaction edge of each base
        self.vec_atom_dict = {
            " DA": {"W_start":" N1 ","W_stop":" N6 ", "H_start":" N7 ","H_stop":" N6 ", "S_start":" C1'","S_stop":" N3 ", "B_start":" C1'","B_stop":" N9 " },
            " DG": {"W_start":" N1 ","W_stop":" O6 ", "H_start":" N7 ","H_stop":" O6 ", "S_start":" C1'","S_stop":" N3 ", "B_start":" C1'","B_stop":" N9 " },
            " DC": {"W_start":" N3 ","W_stop":" N4 ", "H_start":" C5 ","H_stop":" N4 ", "S_start":" C1'","S_stop":" O2 ", "B_start":" C1'","B_stop":" N1 " },
            " DT": {"W_start":" N3 ","W_stop":" O4 ", "H_start":" C5 ","H_stop":" O4 ", "S_start":" C1'","S_stop":" O2 ", "B_start":" C1'","B_stop":" N1 " },
            " RA": {"W_start":" N1 ","W_stop":" N6 ", "H_start":" N7 ","H_stop":" N6 ", "S_start":" C1'","S_stop":" N3 ", "B_start":" C1'","B_stop":" N9 " },
            " RG": {"W_start":" N1 ","W_stop":" O6 ", "H_start":" N7 ","H_stop":" O6 ", "S_start":" C1'","S_stop":" N3 ", "B_start":" C1'","B_stop":" N9 " },
            " RC": {"W_start":" N3 ","W_stop":" N4 ", "H_start":" C5 ","H_stop":" N4 ", "S_start":" C1'","S_stop":" O2 ", "B_start":" C1'","B_stop":" N1 " },
            " RU": {"W_start":" N3 ","W_stop":" O4 ", "H_start":" C5 ","H_stop":" O4 ", "S_start":" C1'","S_stop":" O2 ", "B_start":" C1'","B_stop":" N1 " },
        }

        self.vec_atom_inds = {s_i: {k_ij: HB_data.aa2long[HB_data.aa2num[s_i]].index(a_ij) for k_ij, a_ij in self.vec_atom_dict[s_i].items() } for s_i in self.nuc_resi_3letter}

        self.edge_to_ind = {'W':0 , 'H':1 , 'S':2 ,'B':3}
        self.ring_atom_list = [" N1 "," C2 "," N3 "," C4 "," C6 "," C5 "]
        self.ring_atom_inds = {s_i: [HB_data.aa2long[HB_data.aa2num[s_i]].index(a_ij)  for a_ij in self.ring_atom_list ] for s_i in self.nuc_resi_3letter}

def convert_mpnn_representation(S, X, X_m, rna_mask):
    """
    Given a sequence, atom coordinates, and atom mask in the NA-MPNN format,
    output the sequence, atom coordinates, and atom mask in an RFaa-like format.

    Arguments:
        S (np.int32 np.ndarray): an L length array representing the sequence of 
            the biomolecular assembly.
        X (np.float32 np.ndarray): an L x num_atom_types x 3 array representing
            the coordinates of each atom for each residue in the biomolecular
            assembly.
        X_m (np.int32 np.ndarray): an L x num_atom_types x 3 array mask that is
            1 if the corresponding atom in the specified residue was loaded
            and 0 otherwise.
        rna_mask (np.int32 np.ndarray): an L length array mask representing
            whether the residue is an RNA residue.
    
    Returns:
        S_rfaa (np.int32 np.ndarray): an L length array representing the 
            sequence of the biomolecular assembly in the RFaa format.
        X_rfaa (np.float32 np.ndarray): an L x num_atom_types x 3 array 
            representing the coordinates of each atom for each residue in the 
            biomolecular assembly in the RFaa format.
    """
    atom_idx_to_name = {atom_idx:atom_name for (atom_name, atom_idx) in pdb_dataset.atom_dict.items()}

    # Convert the sequence to the RFaa format, being aware of the possible
    # shared token representation of NA-MPNN.
    S_rfaa = []
    for i in range(S.shape[0]):
        restype_int = S[i]

        restype = pdb_dataset.int_to_restype[restype_int]

        if rna_mask[i]:
            # Handle the case when shared nucleic acid tokens are used. If 
            # shared tokens are not used, the RNA tokens still need to be
            # converted to the RFaa notation.
            if restype == "DA" or restype == "A":
                restype_rfaa = "RA"
            elif restype == "DC" or restype == "C":
                restype_rfaa = "RC"
            elif restype == "DG" or restype == "G":
                restype_rfaa = "RG"
            elif restype == "DT" or restype == "U":
                restype_rfaa = "RU"
            elif restype == "DX" or restype == "RX":
                restype_rfaa = "RX"
            else:
                raise Exception("RNA restype not recognized.")
        else:
            restype_rfaa = restype
            
        restype_int_rfaa = HB_data.aa2num_stripped[restype_rfaa]
        
        S_rfaa.append(restype_int_rfaa)
    
    S_rfaa = np.array(S_rfaa, dtype = np.int64)

    # Convert the atom coordinates to the RFaa format.
    X_rfaa = np.zeros((X.shape[0], HB_data.NTOTAL, 3), dtype = np.float32)
    for i in range(X.shape[0]):
        restype_int_rfaa = S_rfaa[i]
        for atom_idx in range(X.shape[1]):
            if X_m[i, atom_idx] == 1:
                atom_type = atom_idx_to_name[atom_idx]

                # Don't load any atoms beyond backbone for UNK, DX, RX.
                if (HB_data.num2aa[restype_int_rfaa] in ["UNK", " DX", " RX"]) and \
                   (atom_type not in HB_data.aa2long_stripped[restype_int_rfaa]):
                    continue

                # There are rare cases in the PDB where a DNA/RNA hybrid chain 
                # is mislabeled as DNA. In these cases, the data processing
                # pipeline labels RNA residues as DNA residues, and there is
                # an error with transfering the O2' atom into the RFaa format.
                if (HB_data.num2aa[restype_int_rfaa] in [" DA", " DC", " DG", " DT"]) and \
                     (atom_type == "O2'"):
                    continue

                # RFaa does not represent the OXT atom type.
                if atom_type == "OXT":
                    continue

                # Write the atom coordinates to the RFaa format.
                atom_idx_rfaa = HB_data.aa2long_stripped[restype_int_rfaa].index(atom_type)
                X_rfaa[i, atom_idx_rfaa] = X[i, atom_idx]
    
    return S_rfaa, X_rfaa

def get_base_pair_mask_and_index(S, X, X_m, rna_mask):
    """
    Given a sequence, atom coordinates, and atom mask, compute the base pairing
    residues and the canonical base pairing residues (represented as a mask
    and index of the base pairing partner).

    Arguments:
        S (np.int32 np.ndarray): an L length array representing the sequence of 
            the biomolecular assembly.
        X (np.float32 np.ndarray): an L x num_atom_types x 3 array representing
            the coordinates of each atom for each residue in the biomolecular
            assembly.
        X_m (np.int32 np.ndarray): an L x num_atom_types x 3 array mask that is
            1 if the corresponding atom in the specified residue was loaded
            and 0 otherwise.
        rna_mask (np.int32 np.ndarray): an L length array mask representing
            whether the residue is an RNA residue.
    
    Returns:
        base_pair_mask (np.int32 np.ndarray): an L length array mask that is
            1 if the corresponding residue is involved in a base pair
            interaction and 0 otherwise.
        base_pair_index (np.int64 np.ndarray): an L length array that
            represents the index of the partner residue in a base pairing
            interaction. For residues not in a base pairing interaction,
            defined as 0, but it is necessary to the base_pair_mask in
            conjunction.
        canonical_base_pair_mask (np.int32 np.ndarray): similar to 
            base_pair_mask, but limited to positions that make canonical base
            pairing interactions.
        canonical_base_pair_index (np.int64 np.ndarray): similar to
            base_pair_index, but limited to positions that make canonical base
            pairing interactions.
    """
    # Convert to the representation needed for the HB_data object.
    S_rfaa, X_rfaa = convert_mpnn_representation(S, X, X_m, rna_mask)

    hb_data = HB_data(torch.tensor(S_rfaa), 
                      torch.tensor(X_rfaa), 
                      compute_paired_bases=True,
                      compute_helical_params=True
                     )
    # basepairs_ij is only created if there is non-DX/RX nucleic acids in the
    # structure.
    if hb_data.is_na.sum() > 0:
        base_pairs_prob = hb_data.basepairs_ij.detach().cpu().numpy()
        base_pairs_binary = (base_pairs_prob > 0.5).astype(np.int32)

        # Only consider base pairing interactions that have one partner.
        base_pair_mask = (np.sum(base_pairs_binary, axis = -1) == 1).astype(np.int32)
        base_pair_index = np.argmax(base_pairs_binary, axis = -1).astype(np.int64)
    else:
        base_pair_mask = np.zeros(S_rfaa.shape[0], dtype = np.int32)
        base_pair_index = np.zeros(S_rfaa.shape[0], dtype = np.int64)

    # Base pair mask needs to be updated so that the base pairing partner
    # also exists.
    base_pair_mask = base_pair_mask * base_pair_mask[base_pair_index]

    # Make sure to update the base pair index using the base pair mask.
    base_pair_index = base_pair_index * base_pair_mask

    # Create the canonical base pair mask and index, removing any base pairing
    # interactions with non-canonical sequences.
    canonical_base_pair_mask = np.copy(base_pair_mask)
    canonical_base_pair_index = np.copy(base_pair_index)
    for i in range(len(S)):
        if base_pair_mask[i] == 1:
            restype_i = S[i]
            restype_j = S[base_pair_index[i]]
            if (restype_i, restype_j) not in pdb_dataset.na_canonical_base_pair_ints:
                canonical_base_pair_mask[i] = 0
                canonical_base_pair_mask[base_pair_index[i]] = 0
    
    # Make sure to update the canonical base pair index using the canonical base 
    # pair mask.
    canonical_base_pair_index = canonical_base_pair_index * canonical_base_pair_mask
    
    return base_pair_mask, base_pair_index, canonical_base_pair_mask, canonical_base_pair_index

# Get nearest neighbors
def get_nearest_interface_neighbors_to_res_i(X, protein_mask, na_mask, i, eps = 1E-6):
    if protein_mask[i] == 1:
        mask = na_mask
    elif na_mask[i] == 1:
        mask = protein_mask
    dX = X - X[i]
    D = mask * torch.sqrt(torch.sum(dX ** 2, 1) + eps)
    D_max, _ = torch.max(D, -1, keepdim=True)
    D_adjust = D + (1. - mask) * (D_max + eps)
    D_neighbors, E_idx = torch.topk(D_adjust, np.minimum(num_neighbors, X.shape[0]), dim=-1, largest=False)
    return E_idx
    
def get_interface_masks(X, X_m, protein_mask, dna_mask, rna_mask):
    L = X.shape[0]
    na_mask = dna_mask + rna_mask #[L]

    interface_mask = np.zeros(L, dtype = np.int32)

    Ca = X[:,pdb_dataset.atom_dict["CA"],:]
    na_ref_atom = X[:,pdb_dataset.atom_dict[params["NA_REF_ATOM"]],:]

    side_chain_interface_mask = np.zeros(L, dtype = np.int32)
    nearest_protein_side_chain_index = np.zeros(L, dtype = np.int64)
    for i in range(L):
        nearest_neighbor_idx = get_nearest_interface_neighbors_to_res_i(torch.tensor(Ca + na_ref_atom), torch.tensor(protein_mask), torch.tensor(na_mask), i)
        nearest_protein_side_chain_distance = None
        for j in nearest_neighbor_idx:
            if not (na_mask[i] == 1 or na_mask[j] == 1):
                continue

            res_i_X = X[i] #[N,3]
            res_i_X_m = X_m[i] #[N]

            res_j_X = X[j] #[N,3]
            res_j_X_m = X_m[j] #[N]

            # Compute the per-atom pairwise distance.
            dX = res_i_X[:,None,:] - res_j_X[None,:,:] #[N,N,3]
            pairwise_atom_distances = np.sqrt(np.sum(dX ** 2, axis = -1)) #[N,N]

            # Mask out pairwise distances for atoms that do not exist.
            X_m_pairwise = res_i_X_m[:,None] * res_j_X_m[None,:] #[N,N]
            
            min_distance = np.min(pairwise_atom_distances[(X_m_pairwise == 1)])
            if min_distance < interface_distance_cutoff:
                if (protein_mask[i] == 1 and na_mask[j] == 1) or (protein_mask[j] == 1 and na_mask[i] == 1): 
                    interface_mask[i] = 1
                    interface_mask[j] = 1
            
            X_m_side_chain_pairwise = X_m_pairwise * side_chain_pairwise_mask

            if np.count_nonzero(X_m_side_chain_pairwise) > 0:
                min_side_chain_distance = np.min(pairwise_atom_distances[(X_m_side_chain_pairwise == 1)])
                if min_side_chain_distance < interface_distance_cutoff:
                    if (protein_mask[i] == 1 and na_mask[j] == 1) or (protein_mask[j] == 1 and na_mask[i] == 1): 
                        side_chain_interface_mask[i] = 1
                        side_chain_interface_mask[j] = 1
                    
                    if protein_mask[j] == 1 and \
                    (nearest_protein_side_chain_distance == None or \
                        min_side_chain_distance < nearest_protein_side_chain_distance):
                        nearest_protein_side_chain_index[i] = j
                        nearest_protein_side_chain_distance = min_side_chain_distance

    return interface_mask, side_chain_interface_mask, nearest_protein_side_chain_index

if __name__ == "__main__":
    # Load the command line arguments.
    input_csv_path = sys.argv[1]
    output_directory = sys.argv[2]
    modulo = int(sys.argv[3])
    remainder = int(sys.argv[4])

    # Load the csv, containing the structure path and pwm paths.
    df = pd.read_csv(input_csv_path)

    # Output directory file paths.
    sequences_directory = os.path.join(output_directory, "sequences")
    asmb_lengths_directory = os.path.join(output_directory, "asmb_lengths")
    asmb_interface_masks_directory = os.path.join(output_directory, "asmb_interface_masks")
    asmb_side_chain_interface_masks_directory = os.path.join(output_directory, "asmb_side_chain_interface_masks")
    asmb_nearest_protein_side_chain_index_directory = os.path.join(output_directory, "asmb_nearest_protein_side_chain_index")
    asmb_base_pair_masks_directory = os.path.join(output_directory, "asmb_base_pair_masks")
    asmb_base_pair_index_directory = os.path.join(output_directory, "asmb_base_pair_index")
    asmb_canonical_base_pair_masks_directory = os.path.join(output_directory, "asmb_canonical_base_pair_masks")
    asmb_canonical_base_pair_index_directory = os.path.join(output_directory, "asmb_canonical_base_pair_index")
    bad_directory = os.path.join(output_directory, "bad")

    # Make output directories.
    os.makedirs(sequences_directory, exist_ok = True)
    os.makedirs(asmb_lengths_directory, exist_ok = True)
    os.makedirs(asmb_interface_masks_directory, exist_ok = True)
    os.makedirs(asmb_side_chain_interface_masks_directory, exist_ok = True)
    os.makedirs(asmb_nearest_protein_side_chain_index_directory, exist_ok = True)
    os.makedirs(asmb_base_pair_masks_directory, exist_ok = True)
    os.makedirs(asmb_base_pair_index_directory, exist_ok = True)
    os.makedirs(asmb_canonical_base_pair_masks_directory, exist_ok = True)
    os.makedirs(asmb_canonical_base_pair_index_directory, exist_ok = True)
    os.makedirs(bad_directory, exist_ok = True)

    # Preprocess data.
    for iii in range(len(df)):
        if (iii + 1) % modulo != remainder:
            continue
        
        example_dict = df.iloc[iii].to_dict()

        structure_file_name = os.path.basename(example_dict["structure_path"])
        # Handle GZipped files.
        if structure_file_name.endswith(".gz"):
            structure_name = os.path.splitext(os.path.splitext(structure_file_name)[0])[0]
        else:
            structure_name = os.path.splitext(structure_file_name)[0]
        
        sequences_path = os.path.join(sequences_directory, structure_name + ".csv")
        asmb_lengths_path = os.path.join(asmb_lengths_directory, structure_name + ".npy")
        asmb_interface_masks_path = os.path.join(asmb_interface_masks_directory, structure_name + ".npy")
        asmb_side_chain_interface_masks_path = os.path.join(asmb_side_chain_interface_masks_directory, structure_name + ".npy")
        asmb_nearest_protein_side_chain_index_path = os.path.join(asmb_nearest_protein_side_chain_index_directory, structure_name + ".npy")
        asmb_base_pair_masks_path = os.path.join(asmb_base_pair_masks_directory, structure_name + ".npy")
        asmb_base_pair_index_path = os.path.join(asmb_base_pair_index_directory, structure_name + ".npy")
        asmb_canonical_base_pair_masks_path = os.path.join(asmb_canonical_base_pair_masks_directory, structure_name + ".npy")
        asmb_canonical_base_pair_index_path = os.path.join(asmb_canonical_base_pair_index_directory, structure_name + ".npy")
        bad_path = os.path.join(bad_directory, structure_name + ".txt")

        try:
            assemblies, chain_sequences = pdb_dataset.load_for_structure_preprocessing(example_dict)
        except Exception as e:
            write_text_file(bad_path, str(e))
            continue

        if assemblies == "pass" or (len(assemblies) == 0):
            write_text_file(bad_path, "cifutils_failed_to_load_assemblies")
            continue

        asmb_lengths_dict = {}
        asmb_interface_masks_dict = {}
        asmb_side_chain_interface_masks_dict = {}
        asmb_nearest_protein_side_chain_index_dict = {}
        asmb_base_pair_masks_dict = {}
        asmb_base_pair_index_dict = {}
        asmb_canonical_base_pair_masks_dict = {}
        asmb_canonical_base_pair_index_dict = {}
        missing_na_count = 0
        for (assembly_id, out_dict) in assemblies:
            # Filter out assemblies with no resolved/occupied nucleic acids.
            if (out_dict["dna_L"] == 0) and (out_dict["rna_L"] == 0):
                missing_na_count += 1
                continue

            # Get the base pair mask and index. If the sequence longer than the
            # normal batch size for MPNN, then the base pair mask and index will 
            # be empty.
            if out_dict["S"].shape[0] > residue_cutoff:
                base_pair_mask = np.zeros(out_dict["S"].shape, dtype = np.int32)
                base_pair_index = np.zeros(out_dict["S"].shape, dtype = np.int64)
                canonical_base_pair_mask = np.zeros(out_dict["S"].shape, dtype = np.int32)
                canonical_base_pair_index = np.zeros(out_dict["S"].shape, dtype = np.int64)
            else:
                base_pair_mask, base_pair_index, canonical_base_pair_mask, canonical_base_pair_index = \
                    get_base_pair_mask_and_index(out_dict["S"], 
                                                    out_dict["X"], 
                                                    out_dict["X_m"], 
                                                    out_dict["rna_mask"])
            
            # Get the interface masks.
            interface_mask, side_chain_interface_mask, nearest_protein_side_chain_index = \
                get_interface_masks(out_dict["X"], 
                                    out_dict["X_m"], 
                                    out_dict["protein_mask"], 
                                    out_dict["dna_mask"], 
                                    out_dict["rna_mask"])
            
            # Save the per-assembly data.
            asmb_lengths_dict[assembly_id] = (out_dict["macromolecule_L"], out_dict["protein_L"], out_dict["dna_L"], out_dict["rna_L"])
            asmb_interface_masks_dict[assembly_id] = interface_mask
            asmb_side_chain_interface_masks_dict[assembly_id] = side_chain_interface_mask
            asmb_nearest_protein_side_chain_index_dict[assembly_id] = nearest_protein_side_chain_index
            asmb_base_pair_masks_dict[assembly_id] = base_pair_mask
            asmb_base_pair_index_dict[assembly_id] = base_pair_index
            asmb_canonical_base_pair_masks_dict[assembly_id] = canonical_base_pair_mask
            asmb_canonical_base_pair_index_dict[assembly_id] = canonical_base_pair_index

        if len(list(asmb_lengths_dict)) > 0:
            chain_sequences_lines = ["chain_id,chain_type,sequence"]
            for chain_sequence_line in chain_sequences:
                chain_sequence_line = tuple(map(lambda x: "" if x is None else x, chain_sequence_line))
                chain_sequences_lines.append(",".join(chain_sequence_line))
            chain_sequences_str = "\n".join(chain_sequences_lines)
            write_text_file(sequences_path, chain_sequences_str)

            np.save(asmb_lengths_path, asmb_lengths_dict)
            np.save(asmb_interface_masks_path, asmb_interface_masks_dict)
            np.save(asmb_side_chain_interface_masks_path, asmb_side_chain_interface_masks_dict)
            np.save(asmb_nearest_protein_side_chain_index_path, asmb_nearest_protein_side_chain_index_dict)
            np.save(asmb_base_pair_masks_path, asmb_base_pair_masks_dict)
            np.save(asmb_base_pair_index_path, asmb_base_pair_index_dict)
            np.save(asmb_canonical_base_pair_masks_path, asmb_canonical_base_pair_masks_dict)
            np.save(asmb_canonical_base_pair_index_path, asmb_canonical_base_pair_index_dict)
        elif missing_na_count == len(assemblies):
            write_text_file(bad_path, "all_assemblies_no_resolved_and_occupied_nucleic_acids")
            continue
        else:
            write_text_file(bad_path, "all_assemblies_failed")
            continue