Upload NAIAD dataset package with zipped structures

README.md

@@ -0,0 +1,106 @@
+# NAIAD Dataset Package
+
+This package contains the train/valid/test CSV index files used immediately before NAIAD training, plus every referenced `.cif` source structure.
+
+## Contents
+
+- `data/*.csv`: model input index files. `structure_path` has been rewritten to package-relative paths such as `structures/101d.cif`.
+- `structures/*.cif`: all 3725 unique source structures referenced by the packaged CSV files.
+- `splits/*.json`: released split ID lists used to derive train/valid/test sets.
+- `scripts/`: preprocessing, filtering, CSV-generation, and split/preparation scripts from the training repository.
+- `configs/`: NAIAD training config.
+
+The `.cif` files were reconstructed locally from the official wwPDB/RCSB mmCIF mirrors using the PDB IDs in `manifest.csv`.
+Use `scripts/download_structures_from_manifest.py` to reproduce this step.
+
+The parser still expects the normal NAIAD chemical component cache (`ligands.json.gz` and `elements.txt`) under the repository's `data/datasets/rcsb_cif/`, or via `NAIAD_RCSB_CIF_DIR`.
+
+For the reported NAIAD training-data release, use `data/train.csv` as the training index, `data/valid.csv` as validation, and `data/test.csv` as the held-out test index. 
+
+To use after extraction, point `DF_PATH_TRAIN` and `DF_PATH_VALID` to `data/train.csv` and `data/valid.csv` from this package, or copy the package contents under the repository root so the relative `structure_path` values resolve.
+
+## Reproducing The Split CSVs
+
+There are two different workflows in `scripts/`.
+
+### Exact packaged train/valid/test CSVs
+
+Use this route to reproduce the three split CSVs bundled in `data/` from the released split ID files and the packaged CIF files:
+
+```bash
+python scripts/generate_training_csv_from_splits.py \
+  --mmcif_dir structures \
+  --splits_dir splits \
+  --output_dir reproduced_data \
+  --split_type design
+```
+
+Expected result when run against this package:
+
+- `reproduced_data/train.csv`: 3096 rows.
+- `reproduced_data/valid.csv`: 308 rows.
+- `reproduced_data/test.csv`: 321 rows.
+
+The row IDs match the shipped `data/train.csv`, `data/valid.csv`, and `data/test.csv`. This is because the script reads the full split ID lists and keeps only IDs whose CIF file is present under `structures/`. 
+The regenerated CSVs will contain absolute `structure_path` values because that script calls `os.path.abspath`; the shipped CSVs use package-relative paths such as `structures/101d.cif` for portability.
+
+`generate_training_csv_from_splits.py` requires only normal tabular Python dependencies (`pandas`, `tqdm`) and does not import the NAIAD model/parser code.
+
+### Full rescan/filter/preprocess/split from a mmCIF mirror
+
+Use this route only if you want to create a new dataset split from an external mmCIF mirror rather than reproduce the packaged split:
+
+```bash
+python scripts/prepare_diffusion_dataset_full.py scan \
+  --mmcif_dir /path/to/mmcif_files \
+  --output_dir new_dataset \
+  --num_workers 16 \
+  --require_na
+
+python scripts/prepare_diffusion_dataset_full.py preprocess \
+  --output_dir new_dataset \
+  --num_workers 16
+
+# Optional, if CD-HIT is installed.
+python scripts/prepare_diffusion_dataset_full.py cluster \
+  --output_dir new_dataset \
+  --cdhit_path /path/to/cdhit
+
+python scripts/prepare_diffusion_dataset_full.py split \
+  --output_dir new_dataset \
+  --valid_fraction 0.1 \
+  --test_fraction 0.1 \
+  --use_clustering
+```
+
+Equivalent all-in-one form:
+
+```bash
+python scripts/prepare_diffusion_dataset_full.py all \
+  --mmcif_dir /path/to/mmcif_files \
+  --output_dir new_dataset \
+  --num_workers 16 \
+  --require_na \
+  --valid_fraction 0.1 \
+  --test_fraction 0.1
+```
+
+This full workflow performs scanning, quality filtering, per-structure preprocessing, optional CD-HIT sequence clustering, then writes `train.csv`, `valid.csv`, and optionally `test.csv`. 
+It is not the command used to reproduce the fixed manuscript split files in this package.
+
+`prepare_diffusion_dataset_full.py` imports NAIAD parser/data modules (`cifutils.py`, `pdbutils.py`, `na_data_utils.py`) and expects the chemical component cache (`ligands.json.gz`, `elements.txt`). Run it from a NAIAD source checkout or set `PYTHONPATH` so those modules are visible, and set `NAIAD_RCSB_CIF_DIR` if the cache is not under the repository's `data/datasets/rcsb_cif/`.
+
+### Optional preprocessing of an existing CSV
+
+`preprocess_dataset.py` and `preprocess_dataset.sh` do not create train/valid/test splits. They consume an existing CSV, such as `data/train.csv`, and write per-structure sequence and NumPy preprocessing artifacts:
+
+```bash
+python scripts/preprocess_dataset.py \
+  data/train.csv \
+  preprocessed/train \
+  1 \
+  0
+```
+
+The last two arguments are `modulo` and `remainder`, used for array-job sharding. 
+For example, an HPC array with 100 tasks would run each shard with `modulo=100` and `remainder` equal to the task index. `preprocess_dataset.sh` is an example SLURM/Apptainer wrapper for that sharded mode and may need local cluster/container paths edited before use.

configs/NAIAD_model.json

@@ -0,0 +1,109 @@
+{
+  "_comment": "NAIAD universal-transfer diffusion configuration",
+  "_description": "Diffusion-based sequence design over protein and nucleic-acid positions",
+  "VOCAB_SIZE": 33,
+  "NUM_LETTERS": 33,
+  "PARSE_PROTEIN": 1,
+  "PARSE_DNA": 1,
+  "PARSE_RNA": 1,
+  "PARSE_RNA_AS_DNA": 0,
+  "NA_SHARED_TOKENS": 1,
+  "NA_REF_ATOM": "C1'",
+  "INCLUDE_PRED_NA_N": 1,
+  "PROTEIN_BACKBONE_OCC_CUTOFF": 0.8,
+  "PROTEIN_SIDE_CHAIN_OCC_CUTOFF": 0.5,
+  "DNA_BACKBONE_OCC_CUTOFF": 0.8,
+  "DNA_SIDE_CHAIN_OCC_CUTOFF": 0.5,
+  "RNA_BACKBONE_OCC_CUTOFF": 0.8,
+  "RNA_SIDE_CHAIN_OCC_CUTOFF": 0.5,
+  "EXCLUDED_ELEMENTS": [
+    1
+  ],
+  "DATE_CUTOFF": "2030-01-01",
+  "MAX_NUMBER_OF_PDBS_TRAIN": 50000,
+  "MAX_NUMBER_OF_PDBS_VALID": 500,
+  "BATCH_TOKENS": 6000,
+  "LOSS_TOKENS": 10000,
+  "LABEL_SMOOTHING": 0.1,
+  "EXCLUDE_RES": [
+    "HOH",
+    "NA",
+    "CL",
+    "K",
+    "BR"
+  ],
+  "MIN_PROTEIN_LENGTH_CUTOFF": 1,
+  "NUM_WORKERS": 32,
+  "TOTAL_STEPS": 300000,
+  "_total_steps_description": "Extended training for diffusion (300k steps)",
+  "RANDOMIZE_NMR_MODEL": 0,
+  "CROP_LARGE_STRUCTURES": 1,
+  "MIN_OVERLAP_LENGTH": 5,
+  "_data_paths_comment": "=== Data Paths ===",
+  "_pdb_mmcif_dir": "/path/to/pdb_mmcif/mmcif_files",
+  "DF_PATH_TRAIN": "data/naiad_universal_dataset/train.csv",
+  "DF_PATH_VALID": "data/naiad_universal_dataset/valid.csv",
+  "BASE_FOLDER": "models/naiad_universal_diffusion",
+  "_pretrained_comment": "Start from AR checkpoint converted to diffusion format",
+  "PREV_CHECKPOINT": null,
+  "TRUST_CHECKPOINT_PICKLE": false,
+  "_lr_comment": "=== Learning Rate Schedule (Cosine Annealing with Warmup) ===",
+  "LR_SCHEDULER": "cosine_warmup",
+  "LR_BASE": 5e-05,
+  "_lr_base_description": "Lower LR for fine-tuning (already have good NA weights)",
+  "LR_WARMUP_STEPS": 2000,
+  "LR_MIN": 1e-06,
+  "_wandb_comment": "=== Weights & Biases Logging ===",
+  "USE_WANDB": false,
+  "WANDB_PROJECT": "naiad",
+  "WANDB_ENTITY": null,
+  "WANDB_RUN_NAME": "naiad-universal-transfer",
+  "_callback_comment": "=== Callback Task (Anti-forgetting) ===",
+  "FULL_MASK_RATIO": 0.3,
+  "_baseline_comment": "=== Baseline Model for Comparison ===",
+  "BASELINE_CHECKPOINT": null,
+  "COMPARE_WITH_BASELINE": false,
+  "HIDDEN_DIM": 128,
+  "NUM_ENCODER_LAYERS": 3,
+  "NUM_DECODER_LAYERS": 3,
+  "NUM_NEIGHBORS": 32,
+  "DROPOUT": 0.1,
+  "PROTEIN_BACKBONE_NOISE": 0.1,
+  "DNA_BACKBONE_NOISE": 0.1,
+  "RNA_BACKBONE_NOISE": 0.1,
+  "PARSE_PPMS": 0,
+  "NA_ONLY_AS_UNIFORM_PPM": 0,
+  "DROP_PROTEIN_PROBABILITY": 0,
+  "PROTEIN_INTERFACE_RESIDUE_MUTATION_PROBABILITY": 0,
+  "MUTATE_BASE_PAIR_TOGETHER": 0,
+  "MUTATE_ENTIRE_SIDE_CHAIN_INTERFACE_PROBABILITY": 0,
+  "NA_NON_INTERFACE_AS_UNIFORM_PPM": 0,
+  "GRADIENT_NORM": 1.0,
+  "MIXED_PRECISION": 1,
+  "SAVE_EVERY_N_STEPS": 2000,
+  "ATOMS_TO_LOAD": "backbone",
+  "METRICS_TO_COMPUTE": "basic",
+  "_diffusion_comment": "=== Diffusion-Specific Parameters ===",
+  "MASK_RATIO_SCHEDULE": "uniform",
+  "MASK_RATIO_MIN": 0.0,
+  "MASK_RATIO_MAX": 1.0,
+  "LOSS_WEIGHT_STRATEGY": "snr",
+  "LOSS_WEIGHT_EPSILON": 0.1,
+  "_key_change_comment": "=== Universal-transfer setting: mask BOTH protein and NA ===",
+  "MASK_NA_ONLY": false,
+  "_mask_na_only_description": "Set to FALSE to mask both protein and nucleic acid positions",
+  "_mask_mode_comment": "=== Mask Mode Options ===",
+  "MASK_MODE": "all",
+  "_mask_mode_options": "all | protein_only | na_only | interface",
+  "_mask_mode_description": {
+    "all": "Mask all valid positions (protein + NA)",
+    "protein_only": "Only mask protein positions",
+    "na_only": "Only mask nucleic acid positions (original behavior)",
+    "interface": "Only mask interface positions"
+  },
+  "USE_SEQUENCE_CONTEXT": true,
+  "DIFFUSION_LABEL_SMOOTHING": 0.1,
+  "USE_IRM_PENALTY": false,
+  "IRM_PENALTY_WEIGHT": 0.0,
+  "IRM_MIN_TOKENS_PER_ENV": 1
+}

data/test.csv

@@ -0,0 +1,322 @@
+id,structure_path,date,dataset_name,sampling_probability,ppm_paths
+115d,structures/115d.cif,2024-01-01,diffusion_na,1.0,[]
+139d,structures/139d.cif,2024-01-01,diffusion_na,1.0,[]
+1ajt,structures/1ajt.cif,2024-01-01,diffusion_na,1.0,[]
+1cvx,structures/1cvx.cif,2024-01-01,diffusion_na,1.0,[]
+1cvy,structures/1cvy.cif,2024-01-01,diffusion_na,1.0,[]
+1d83,structures/1d83.cif,2024-01-01,diffusion_na,1.0,[]
+1dgc,structures/1dgc.cif,2024-01-01,diffusion_na,1.0,[]
+1dgo,structures/1dgo.cif,2024-01-01,diffusion_na,1.0,[]
+1dk9,structures/1dk9.cif,2024-01-01,diffusion_na,1.0,[]
+1dnk,structures/1dnk.cif,2024-01-01,diffusion_na,1.0,[]
+1duq,structures/1duq.cif,2024-01-01,diffusion_na,1.0,[]
+1hq1,structures/1hq1.cif,2024-01-01,diffusion_na,1.0,[]
+1ibm,structures/1ibm.cif,2024-01-01,diffusion_na,1.0,[]
+1idx,structures/1idx.cif,2024-01-01,diffusion_na,1.0,[]
+1ii1,structures/1ii1.cif,2024-01-01,diffusion_na,1.0,[]
+1ikk,structures/1ikk.cif,2024-01-01,diffusion_na,1.0,[]
+1j46,structures/1j46.cif,2024-01-01,diffusion_na,1.0,[]
+1j5k,structures/1j5k.cif,2024-01-01,diffusion_na,1.0,[]
+1jbr,structures/1jbr.cif,2024-01-01,diffusion_na,1.0,[]
+1jft,structures/1jft.cif,2024-01-01,diffusion_na,1.0,[]
+1jkq,structures/1jkq.cif,2024-01-01,diffusion_na,1.0,[]
+1jp0,structures/1jp0.cif,2024-01-01,diffusion_na,1.0,[]
+1juu,structures/1juu.cif,2024-01-01,diffusion_na,1.0,[]
+1kpy,structures/1kpy.cif,2024-01-01,diffusion_na,1.0,[]
+1ldz,structures/1ldz.cif,2024-01-01,diffusion_na,1.0,[]
+1lmv,structures/1lmv.cif,2024-01-01,diffusion_na,1.0,[]
+1lvs,structures/1lvs.cif,2024-01-01,diffusion_na,1.0,[]
+1m3h,structures/1m3h.cif,2024-01-01,diffusion_na,1.0,[]
+1m5x,structures/1m5x.cif,2024-01-01,diffusion_na,1.0,[]
+1n4e,structures/1n4e.cif,2024-01-01,diffusion_na,1.0,[]
+1na2,structures/1na2.cif,2024-01-01,diffusion_na,1.0,[]
+1ngm,structures/1ngm.cif,2024-01-01,diffusion_na,1.0,[]
+1ngu,structures/1ngu.cif,2024-01-01,diffusion_na,1.0,[]
+1pgl,structures/1pgl.cif,2024-01-01,diffusion_na,1.0,[]
+1pyj,structures/1pyj.cif,2024-01-01,diffusion_na,1.0,[]
+1qp7,structures/1qp7.cif,2024-01-01,diffusion_na,1.0,[]
+1qqb,structures/1qqb.cif,2024-01-01,diffusion_na,1.0,[]
+1skw,structures/1skw.cif,2024-01-01,diffusion_na,1.0,[]
+1sl0,structures/1sl0.cif,2024-01-01,diffusion_na,1.0,[]
+1sl2,structures/1sl2.cif,2024-01-01,diffusion_na,1.0,[]
+1sm5,structures/1sm5.cif,2024-01-01,diffusion_na,1.0,[]
+1szy,structures/1szy.cif,2024-01-01,diffusion_na,1.0,[]
+1vbx,structures/1vbx.cif,2024-01-01,diffusion_na,1.0,[]
+1vc5,structures/1vc5.cif,2024-01-01,diffusion_na,1.0,[]
+1vj4,structures/1vj4.cif,2024-01-01,diffusion_na,1.0,[]
+1x9c,structures/1x9c.cif,2024-01-01,diffusion_na,1.0,[]
+1xs9,structures/1xs9.cif,2024-01-01,diffusion_na,1.0,[]
+1yuj,structures/1yuj.cif,2024-01-01,diffusion_na,1.0,[]
+1yz9,structures/1yz9.cif,2024-01-01,diffusion_na,1.0,[]
+1zjf,structures/1zjf.cif,2024-01-01,diffusion_na,1.0,[]
+1zjg,structures/1zjg.cif,2024-01-01,diffusion_na,1.0,[]
+1zyg,structures/1zyg.cif,2024-01-01,diffusion_na,1.0,[]
+1zyh,structures/1zyh.cif,2024-01-01,diffusion_na,1.0,[]
+272d,structures/272d.cif,2024-01-01,diffusion_na,1.0,[]
+284d,structures/284d.cif,2024-01-01,diffusion_na,1.0,[]
+2a8v,structures/2a8v.cif,2024-01-01,diffusion_na,1.0,[]
+2bcu,structures/2bcu.cif,2024-01-01,diffusion_na,1.0,[]
+2bcz,structures/2bcz.cif,2024-01-01,diffusion_na,1.0,[]
+2cgp,structures/2cgp.cif,2024-01-01,diffusion_na,1.0,[]
+2d2k,structures/2d2k.cif,2024-01-01,diffusion_na,1.0,[]
+2d2l,structures/2d2l.cif,2024-01-01,diffusion_na,1.0,[]
+2d6f,structures/2d6f.cif,2024-01-01,diffusion_na,1.0,[]
+2dgc,structures/2dgc.cif,2024-01-01,diffusion_na,1.0,[]
+2err,structures/2err.cif,2024-01-01,diffusion_na,1.0,[]
+2fjw,structures/2fjw.cif,2024-01-01,diffusion_na,1.0,[]
+2flc,structures/2flc.cif,2024-01-01,diffusion_na,1.0,[]
+2fll,structures/2fll.cif,2024-01-01,diffusion_na,1.0,[]
+2gtt,structures/2gtt.cif,2024-01-01,diffusion_na,1.0,[]
+2h0s,structures/2h0s.cif,2024-01-01,diffusion_na,1.0,[]
+2ho6,structures/2ho6.cif,2024-01-01,diffusion_na,1.0,[]
+2i3q,structures/2i3q.cif,2024-01-01,diffusion_na,1.0,[]
+2ihn,structures/2ihn.cif,2024-01-01,diffusion_na,1.0,[]
+2jlw,structures/2jlw.cif,2024-01-01,diffusion_na,1.0,[]
+2l13,structures/2l13.cif,2024-01-01,diffusion_na,1.0,[]
+2llj,structures/2llj.cif,2024-01-01,diffusion_na,1.0,[]
+2m12,structures/2m12.cif,2024-01-01,diffusion_na,1.0,[]
+2m8k,structures/2m8k.cif,2024-01-01,diffusion_na,1.0,[]
+2mb2,structures/2mb2.cif,2024-01-01,diffusion_na,1.0,[]
+2moe,structures/2moe.cif,2024-01-01,diffusion_na,1.0,[]
+2n0q,structures/2n0q.cif,2024-01-01,diffusion_na,1.0,[]
+2n3o,structures/2n3o.cif,2024-01-01,diffusion_na,1.0,[]
+2npy,structures/2npy.cif,2024-01-01,diffusion_na,1.0,[]
+2npz,structures/2npz.cif,2024-01-01,diffusion_na,1.0,[]
+2o33,structures/2o33.cif,2024-01-01,diffusion_na,1.0,[]
+2oih,structures/2oih.cif,2024-01-01,diffusion_na,1.0,[]
+2oj3,structures/2oj3.cif,2024-01-01,diffusion_na,1.0,[]
+2ost,structures/2ost.cif,2024-01-01,diffusion_na,1.0,[]
+2p7d,structures/2p7d.cif,2024-01-01,diffusion_na,1.0,[]
+2p7e,structures/2p7e.cif,2024-01-01,diffusion_na,1.0,[]
+2pl4,structures/2pl4.cif,2024-01-01,diffusion_na,1.0,[]
+2pl8,structures/2pl8.cif,2024-01-01,diffusion_na,1.0,[]
+2plo,structures/2plo.cif,2024-01-01,diffusion_na,1.0,[]
+2puc,structures/2puc.cif,2024-01-01,diffusion_na,1.0,[]
+2pud,structures/2pud.cif,2024-01-01,diffusion_na,1.0,[]
+2pue,structures/2pue.cif,2024-01-01,diffusion_na,1.0,[]
+2puf,structures/2puf.cif,2024-01-01,diffusion_na,1.0,[]
+2pxe,structures/2pxe.cif,2024-01-01,diffusion_na,1.0,[]
+2pxt,structures/2pxt.cif,2024-01-01,diffusion_na,1.0,[]
+2pxu,structures/2pxu.cif,2024-01-01,diffusion_na,1.0,[]
+2pxv,structures/2pxv.cif,2024-01-01,diffusion_na,1.0,[]
+2rvo,structures/2rvo.cif,2024-01-01,diffusion_na,1.0,[]
+2vbn,structures/2vbn.cif,2024-01-01,diffusion_na,1.0,[]
+2vum,structures/2vum.cif,2024-01-01,diffusion_na,1.0,[]
+2wtu,structures/2wtu.cif,2024-01-01,diffusion_na,1.0,[]
+2xct,structures/2xct.cif,2024-01-01,diffusion_na,1.0,[]
+2xro,structures/2xro.cif,2024-01-01,diffusion_na,1.0,[]
+2z74,structures/2z74.cif,2024-01-01,diffusion_na,1.0,[]
+357d,structures/357d.cif,2024-01-01,diffusion_na,1.0,[]
+361d,structures/361d.cif,2024-01-01,diffusion_na,1.0,[]
+3adi,structures/3adi.cif,2024-01-01,diffusion_na,1.0,[]
+3agv,structures/3agv.cif,2024-01-01,diffusion_na,1.0,[]
+3b4b,structures/3b4b.cif,2024-01-01,diffusion_na,1.0,[]
+3bep,structures/3bep.cif,2024-01-01,diffusion_na,1.0,[]
+3bse,structures/3bse.cif,2024-01-01,diffusion_na,1.0,[]
+3c0w,structures/3c0w.cif,2024-01-01,diffusion_na,1.0,[]
+3coa,structures/3coa.cif,2024-01-01,diffusion_na,1.0,[]
+3dh3,structures/3dh3.cif,2024-01-01,diffusion_na,1.0,[]
+3foz,structures/3foz.cif,2024-01-01,diffusion_na,1.0,[]
+3hxo,structures/3hxo.cif,2024-01-01,diffusion_na,1.0,[]
+3hxq,structures/3hxq.cif,2024-01-01,diffusion_na,1.0,[]
+3jce,structures/3jce.cif,2024-01-01,diffusion_na,1.0,[]
+3k4x,structures/3k4x.cif,2024-01-01,diffusion_na,1.0,[]
+3l1p,structures/3l1p.cif,2024-01-01,diffusion_na,1.0,[]
+3l2p,structures/3l2p.cif,2024-01-01,diffusion_na,1.0,[]
+3loa,structures/3loa.cif,2024-01-01,diffusion_na,1.0,[]
+3lqx,structures/3lqx.cif,2024-01-01,diffusion_na,1.0,[]
+3os0,structures/3os0.cif,2024-01-01,diffusion_na,1.0,[]
+3pu0,structures/3pu0.cif,2024-01-01,diffusion_na,1.0,[]
+3pu1,structures/3pu1.cif,2024-01-01,diffusion_na,1.0,[]
+3q2t,structures/3q2t.cif,2024-01-01,diffusion_na,1.0,[]
+3qg9,structures/3qg9.cif,2024-01-01,diffusion_na,1.0,[]
+3qgc,structures/3qgc.cif,2024-01-01,diffusion_na,1.0,[]
+3r1l,structures/3r1l.cif,2024-01-01,diffusion_na,1.0,[]
+3sq2,structures/3sq2.cif,2024-01-01,diffusion_na,1.0,[]
+3ssf,structures/3ssf.cif,2024-01-01,diffusion_na,1.0,[]
+3szq,structures/3szq.cif,2024-01-01,diffusion_na,1.0,[]
+3tzr,structures/3tzr.cif,2024-01-01,diffusion_na,1.0,[]
+3ufd,structures/3ufd.cif,2024-01-01,diffusion_na,1.0,[]
+3ugo,structures/3ugo.cif,2024-01-01,diffusion_na,1.0,[]
+3v72,structures/3v72.cif,2024-01-01,diffusion_na,1.0,[]
+3va3,structures/3va3.cif,2024-01-01,diffusion_na,1.0,[]
+3vw4,structures/3vw4.cif,2024-01-01,diffusion_na,1.0,[]
+431d,structures/431d.cif,2024-01-01,diffusion_na,1.0,[]
+4a3d,structures/4a3d.cif,2024-01-01,diffusion_na,1.0,[]
+4a3k,structures/4a3k.cif,2024-01-01,diffusion_na,1.0,[]
+4aij,structures/4aij.cif,2024-01-01,diffusion_na,1.0,[]
+4ati,structures/4ati.cif,2024-01-01,diffusion_na,1.0,[]
+4b3r,structures/4b3r.cif,2024-01-01,diffusion_na,1.0,[]
+4by7,structures/4by7.cif,2024-01-01,diffusion_na,1.0,[]
+4fgn,structures/4fgn.cif,2024-01-01,diffusion_na,1.0,[]
+4fxd,structures/4fxd.cif,2024-01-01,diffusion_na,1.0,[]
+4g6r,structures/4g6r.cif,2024-01-01,diffusion_na,1.0,[]
+4ki2,structures/4ki2.cif,2024-01-01,diffusion_na,1.0,[]
+4lnt,structures/4lnt.cif,2024-01-01,diffusion_na,1.0,[]
+4lt8,structures/4lt8.cif,2024-01-01,diffusion_na,1.0,[]
+4lw0,structures/4lw0.cif,2024-01-01,diffusion_na,1.0,[]
+4m59,structures/4m59.cif,2024-01-01,diffusion_na,1.0,[]
+4meg,structures/4meg.cif,2024-01-01,diffusion_na,1.0,[]
+4mfa,structures/4mfa.cif,2024-01-01,diffusion_na,1.0,[]
+4mgm,structures/4mgm.cif,2024-01-01,diffusion_na,1.0,[]
+4mky,structures/4mky.cif,2024-01-01,diffusion_na,1.0,[]
+4oe1,structures/4oe1.cif,2024-01-01,diffusion_na,1.0,[]
+4oqu,structures/4oqu.cif,2024-01-01,diffusion_na,1.0,[]
+4p97,structures/4p97.cif,2024-01-01,diffusion_na,1.0,[]
+4pjo,structures/4pjo.cif,2024-01-01,diffusion_na,1.0,[]
+4plx,structures/4plx.cif,2024-01-01,diffusion_na,1.0,[]
+4prf,structures/4prf.cif,2024-01-01,diffusion_na,1.0,[]
+4q9r,structures/4q9r.cif,2024-01-01,diffusion_na,1.0,[]
+4qz8,structures/4qz8.cif,2024-01-01,diffusion_na,1.0,[]
+4qz9,structures/4qz9.cif,2024-01-01,diffusion_na,1.0,[]
+4qzc,structures/4qzc.cif,2024-01-01,diffusion_na,1.0,[]
+4ri9,structures/4ri9.cif,2024-01-01,diffusion_na,1.0,[]
+4rwp,structures/4rwp.cif,2024-01-01,diffusion_na,1.0,[]
+4tue,structures/4tue.cif,2024-01-01,diffusion_na,1.0,[]
+4tzx,structures/4tzx.cif,2024-01-01,diffusion_na,1.0,[]
+4tzy,structures/4tzy.cif,2024-01-01,diffusion_na,1.0,[]
+4v5j,structures/4v5j.cif,2024-01-01,diffusion_na,1.0,[]
+4v8q,structures/4v8q.cif,2024-01-01,diffusion_na,1.0,[]
+4wtc,structures/4wtc.cif,2024-01-01,diffusion_na,1.0,[]
+4wul,structures/4wul.cif,2024-01-01,diffusion_na,1.0,[]
+4x0g,structures/4x0g.cif,2024-01-01,diffusion_na,1.0,[]
+4xvl,structures/4xvl.cif,2024-01-01,diffusion_na,1.0,[]
+4yfu,structures/4yfu.cif,2024-01-01,diffusion_na,1.0,[]
+4znp,structures/4znp.cif,2024-01-01,diffusion_na,1.0,[]
+5amq,structures/5amq.cif,2024-01-01,diffusion_na,1.0,[]
+5b2p,structures/5b2p.cif,2024-01-01,diffusion_na,1.0,[]
+5bng,structures/5bng.cif,2024-01-01,diffusion_na,1.0,[]
+5cdn,structures/5cdn.cif,2024-01-01,diffusion_na,1.0,[]
+5cpi,structures/5cpi.cif,2024-01-01,diffusion_na,1.0,[]
+5cv2,structures/5cv2.cif,2024-01-01,diffusion_na,1.0,[]
+5d2q,structures/5d2q.cif,2024-01-01,diffusion_na,1.0,[]
+5d9i,structures/5d9i.cif,2024-01-01,diffusion_na,1.0,[]
+5dv7,structures/5dv7.cif,2024-01-01,diffusion_na,1.0,[]
+5e18,structures/5e18.cif,2024-01-01,diffusion_na,1.0,[]
+5e5s,structures/5e5s.cif,2024-01-01,diffusion_na,1.0,[]
+5h3u,structures/5h3u.cif,2024-01-01,diffusion_na,1.0,[]
+5hbw,structures/5hbw.cif,2024-01-01,diffusion_na,1.0,[]
+5jea,structures/5jea.cif,2024-01-01,diffusion_na,1.0,[]
+5k5r,structures/5k5r.cif,2024-01-01,diffusion_na,1.0,[]
+5k7c,structures/5k7c.cif,2024-01-01,diffusion_na,1.0,[]
+5k7d,structures/5k7d.cif,2024-01-01,diffusion_na,1.0,[]
+5n90,structures/5n90.cif,2024-01-01,diffusion_na,1.0,[]
+5swd,structures/5swd.cif,2024-01-01,diffusion_na,1.0,[]
+5swe,structures/5swe.cif,2024-01-01,diffusion_na,1.0,[]
+5t2h,structures/5t2h.cif,2024-01-01,diffusion_na,1.0,[]
+5u30,structures/5u30.cif,2024-01-01,diffusion_na,1.0,[]
+5v17,structures/5v17.cif,2024-01-01,diffusion_na,1.0,[]
+5vfx,structures/5vfx.cif,2024-01-01,diffusion_na,1.0,[]
+5w2a,structures/5w2a.cif,2024-01-01,diffusion_na,1.0,[]
+5wzh,structures/5wzh.cif,2024-01-01,diffusion_na,1.0,[]
+5wzi,structures/5wzi.cif,2024-01-01,diffusion_na,1.0,[]
+5xvp,structures/5xvp.cif,2024-01-01,diffusion_na,1.0,[]
+5y7g,structures/5y7g.cif,2024-01-01,diffusion_na,1.0,[]
+5yzy,structures/5yzy.cif,2024-01-01,diffusion_na,1.0,[]
+5ze2,structures/5ze2.cif,2024-01-01,diffusion_na,1.0,[]
+5zjs,structures/5zjs.cif,2024-01-01,diffusion_na,1.0,[]
+5zk1,structures/5zk1.cif,2024-01-01,diffusion_na,1.0,[]
+5zsl,structures/5zsl.cif,2024-01-01,diffusion_na,1.0,[]
+5zux,structures/5zux.cif,2024-01-01,diffusion_na,1.0,[]
+6ar1,structures/6ar1.cif,2024-01-01,diffusion_na,1.0,[]
+6ar3,structures/6ar3.cif,2024-01-01,diffusion_na,1.0,[]
+6ar5,structures/6ar5.cif,2024-01-01,diffusion_na,1.0,[]
+6b14,structures/6b14.cif,2024-01-01,diffusion_na,1.0,[]
+6bwy,structures/6bwy.cif,2024-01-01,diffusion_na,1.0,[]
+6cao,structures/6cao.cif,2024-01-01,diffusion_na,1.0,[]
+6cap,structures/6cap.cif,2024-01-01,diffusion_na,1.0,[]
+6cmn,structures/6cmn.cif,2024-01-01,diffusion_na,1.0,[]
+6cst,structures/6cst.cif,2024-01-01,diffusion_na,1.0,[]
+6cvo,structures/6cvo.cif,2024-01-01,diffusion_na,1.0,[]
+6fb8,structures/6fb8.cif,2024-01-01,diffusion_na,1.0,[]
+6fb9,structures/6fb9.cif,2024-01-01,diffusion_na,1.0,[]
+6ftu,structures/6ftu.cif,2024-01-01,diffusion_na,1.0,[]
+6fz0,structures/6fz0.cif,2024-01-01,diffusion_na,1.0,[]
+6gb2,structures/6gb2.cif,2024-01-01,diffusion_na,1.0,[]
+6hag,structures/6hag.cif,2024-01-01,diffusion_na,1.0,[]
+6iod,structures/6iod.cif,2024-01-01,diffusion_na,1.0,[]
+6ir8,structures/6ir8.cif,2024-01-01,diffusion_na,1.0,[]
+6is8,structures/6is8.cif,2024-01-01,diffusion_na,1.0,[]
+6iuc,structures/6iuc.cif,2024-01-01,diffusion_na,1.0,[]
+6jdv,structures/6jdv.cif,2024-01-01,diffusion_na,1.0,[]
+6jfu,structures/6jfu.cif,2024-01-01,diffusion_na,1.0,[]
+6jgw,structures/6jgw.cif,2024-01-01,diffusion_na,1.0,[]
+6jni,structures/6jni.cif,2024-01-01,diffusion_na,1.0,[]
+6jrf,structures/6jrf.cif,2024-01-01,diffusion_na,1.0,[]
+6jrp,structures/6jrp.cif,2024-01-01,diffusion_na,1.0,[]
+6k1k,structures/6k1k.cif,2024-01-01,diffusion_na,1.0,[]
+6l6s,structures/6l6s.cif,2024-01-01,diffusion_na,1.0,[]
+6lwr,structures/6lwr.cif,2024-01-01,diffusion_na,1.0,[]
+6m3l,structures/6m3l.cif,2024-01-01,diffusion_na,1.0,[]
+6mur,structures/6mur.cif,2024-01-01,diffusion_na,1.0,[]
+6n7r,structures/6n7r.cif,2024-01-01,diffusion_na,1.0,[]
+6o1k,structures/6o1k.cif,2024-01-01,diffusion_na,1.0,[]
+6o1l,structures/6o1l.cif,2024-01-01,diffusion_na,1.0,[]
+6o7i,structures/6o7i.cif,2024-01-01,diffusion_na,1.0,[]
+6o8q,structures/6o8q.cif,2024-01-01,diffusion_na,1.0,[]
+6oes,structures/6oes.cif,2024-01-01,diffusion_na,1.0,[]
+6oet,structures/6oet.cif,2024-01-01,diffusion_na,1.0,[]
+6oy7,structures/6oy7.cif,2024-01-01,diffusion_na,1.0,[]
+6rfl,structures/6rfl.cif,2024-01-01,diffusion_na,1.0,[]
+6rja,structures/6rja.cif,2024-01-01,diffusion_na,1.0,[]
+6rjd,structures/6rjd.cif,2024-01-01,diffusion_na,1.0,[]
+6rjg,structures/6rjg.cif,2024-01-01,diffusion_na,1.0,[]
+6sdy,structures/6sdy.cif,2024-01-01,diffusion_na,1.0,[]
+6ugj,structures/6ugj.cif,2024-01-01,diffusion_na,1.0,[]
+6vaa,structures/6vaa.cif,2024-01-01,diffusion_na,1.0,[]
+6vtx,structures/6vtx.cif,2024-01-01,diffusion_na,1.0,[]
+6vwt,structures/6vwt.cif,2024-01-01,diffusion_na,1.0,[]
+6waa,structures/6waa.cif,2024-01-01,diffusion_na,1.0,[]
+6wmu,structures/6wmu.cif,2024-01-01,diffusion_na,1.0,[]
+6xh3,structures/6xh3.cif,2024-01-01,diffusion_na,1.0,[]
+6xo6,structures/6xo6.cif,2024-01-01,diffusion_na,1.0,[]
+6xo9,structures/6xo9.cif,2024-01-01,diffusion_na,1.0,[]
+6z8k,structures/6z8k.cif,2024-01-01,diffusion_na,1.0,[]
+6za3,structures/6za3.cif,2024-01-01,diffusion_na,1.0,[]
+7b1y,structures/7b1y.cif,2024-01-01,diffusion_na,1.0,[]
+7cli,structures/7cli.cif,2024-01-01,diffusion_na,1.0,[]
+7cyq,structures/7cyq.cif,2024-01-01,diffusion_na,1.0,[]
+7d3v,structures/7d3v.cif,2024-01-01,diffusion_na,1.0,[]
+7d3w,structures/7d3w.cif,2024-01-01,diffusion_na,1.0,[]
+7dn3,structures/7dn3.cif,2024-01-01,diffusion_na,1.0,[]
+7eiu,structures/7eiu.cif,2024-01-01,diffusion_na,1.0,[]
+7f36,structures/7f36.cif,2024-01-01,diffusion_na,1.0,[]
+7jfx,structures/7jfx.cif,2024-01-01,diffusion_na,1.0,[]
+7jht,structures/7jht.cif,2024-01-01,diffusion_na,1.0,[]
+7jj5,structures/7jj5.cif,2024-01-01,diffusion_na,1.0,[]
+7jjy,structures/7jjy.cif,2024-01-01,diffusion_na,1.0,[]
+7jkd,structures/7jkd.cif,2024-01-01,diffusion_na,1.0,[]
+7jkg,structures/7jkg.cif,2024-01-01,diffusion_na,1.0,[]
+7jkh,structures/7jkh.cif,2024-01-01,diffusion_na,1.0,[]
+7jnh,structures/7jnh.cif,2024-01-01,diffusion_na,1.0,[]
+7jnj,structures/7jnj.cif,2024-01-01,diffusion_na,1.0,[]
+7jnk,structures/7jnk.cif,2024-01-01,diffusion_na,1.0,[]
+7jp7,structures/7jp7.cif,2024-01-01,diffusion_na,1.0,[]
+7jsb,structures/7jsb.cif,2024-01-01,diffusion_na,1.0,[]
+7kjv,structures/7kjv.cif,2024-01-01,diffusion_na,1.0,[]
+7kkv,structures/7kkv.cif,2024-01-01,diffusion_na,1.0,[]
+7l4y,structures/7l4y.cif,2024-01-01,diffusion_na,1.0,[]
+7lyf,structures/7lyf.cif,2024-01-01,diffusion_na,1.0,[]
+7m0a,structures/7m0a.cif,2024-01-01,diffusion_na,1.0,[]
+7m99,structures/7m99.cif,2024-01-01,diffusion_na,1.0,[]
+7nbl,structures/7nbl.cif,2024-01-01,diffusion_na,1.0,[]
+7nha,structures/7nha.cif,2024-01-01,diffusion_na,1.0,[]
+7ni0,structures/7ni0.cif,2024-01-01,diffusion_na,1.0,[]
+7nsh,structures/7nsh.cif,2024-01-01,diffusion_na,1.0,[]
+7nwt,structures/7nwt.cif,2024-01-01,diffusion_na,1.0,[]
+7og0,structures/7og0.cif,2024-01-01,diffusion_na,1.0,[]
+7ork,structures/7ork.cif,2024-01-01,diffusion_na,1.0,[]
+7orm,structures/7orm.cif,2024-01-01,diffusion_na,1.0,[]
+7osm,structures/7osm.cif,2024-01-01,diffusion_na,1.0,[]
+7pwg,structures/7pwg.cif,2024-01-01,diffusion_na,1.0,[]
+7r5s,structures/7r5s.cif,2024-01-01,diffusion_na,1.0,[]
+7r77,structures/7r77.cif,2024-01-01,diffusion_na,1.0,[]
+7r78,structures/7r78.cif,2024-01-01,diffusion_na,1.0,[]
+7u3o,structures/7u3o.cif,2024-01-01,diffusion_na,1.0,[]
+7uga,structures/7uga.cif,2024-01-01,diffusion_na,1.0,[]
+7v9i,structures/7v9i.cif,2024-01-01,diffusion_na,1.0,[]
+7vjq,structures/7vjq.cif,2024-01-01,diffusion_na,1.0,[]
+7wb0,structures/7wb0.cif,2024-01-01,diffusion_na,1.0,[]
+7z4j,structures/7z4j.cif,2024-01-01,diffusion_na,1.0,[]
+7zq6,structures/7zq6.cif,2024-01-01,diffusion_na,1.0,[]
+8dqx,structures/8dqx.cif,2024-01-01,diffusion_na,1.0,[]

data/valid.csv

@@ -0,0 +1,309 @@
+id,structure_path,date,dataset_name,sampling_probability,ppm_paths
+123d,structures/123d.cif,2024-01-01,diffusion_na,1.0,[]
+1a9h,structures/1a9h.cif,2024-01-01,diffusion_na,1.0,[]
+1aju,structures/1aju.cif,2024-01-01,diffusion_na,1.0,[]
+1al9,structures/1al9.cif,2024-01-01,diffusion_na,1.0,[]
+1bd1,structures/1bd1.cif,2024-01-01,diffusion_na,1.0,[]
+1bg1,structures/1bg1.cif,2024-01-01,diffusion_na,1.0,[]
+1bhm,structures/1bhm.cif,2024-01-01,diffusion_na,1.0,[]
+1cw9,structures/1cw9.cif,2024-01-01,diffusion_na,1.0,[]
+1e4p,structures/1e4p.cif,2024-01-01,diffusion_na,1.0,[]
+1e7j,structures/1e7j.cif,2024-01-01,diffusion_na,1.0,[]
+1eop,structures/1eop.cif,2024-01-01,diffusion_na,1.0,[]
+1f7i,structures/1f7i.cif,2024-01-01,diffusion_na,1.0,[]
+1gqu,structures/1gqu.cif,2024-01-01,diffusion_na,1.0,[]
+1guc,structures/1guc.cif,2024-01-01,diffusion_na,1.0,[]
+1hc8,structures/1hc8.cif,2024-01-01,diffusion_na,1.0,[]
+1i6j,structures/1i6j.cif,2024-01-01,diffusion_na,1.0,[]
+1ik5,structures/1ik5.cif,2024-01-01,diffusion_na,1.0,[]
+1imh,structures/1imh.cif,2024-01-01,diffusion_na,1.0,[]
+1jur,structures/1jur.cif,2024-01-01,diffusion_na,1.0,[]
+1k8w,structures/1k8w.cif,2024-01-01,diffusion_na,1.0,[]
+1kh6,structures/1kh6.cif,2024-01-01,diffusion_na,1.0,[]
+1kos,structures/1kos.cif,2024-01-01,diffusion_na,1.0,[]
+1lc6,structures/1lc6.cif,2024-01-01,diffusion_na,1.0,[]
+1m5o,structures/1m5o.cif,2024-01-01,diffusion_na,1.0,[]
+1m5p,structures/1m5p.cif,2024-01-01,diffusion_na,1.0,[]
+1m77,structures/1m77.cif,2024-01-01,diffusion_na,1.0,[]
+1mms,structures/1mms.cif,2024-01-01,diffusion_na,1.0,[]
+1o3r,structures/1o3r.cif,2024-01-01,diffusion_na,1.0,[]
+1o3t,structures/1o3t.cif,2024-01-01,diffusion_na,1.0,[]
+1odh,structures/1odh.cif,2024-01-01,diffusion_na,1.0,[]
+1ouq,structures/1ouq.cif,2024-01-01,diffusion_na,1.0,[]
+1owr,structures/1owr.cif,2024-01-01,diffusion_na,1.0,[]
+1p0u,structures/1p0u.cif,2024-01-01,diffusion_na,1.0,[]
+1p96,structures/1p96.cif,2024-01-01,diffusion_na,1.0,[]
+1pik,structures/1pik.cif,2024-01-01,diffusion_na,1.0,[]
+1q96,structures/1q96.cif,2024-01-01,diffusion_na,1.0,[]
+1qx0,structures/1qx0.cif,2024-01-01,diffusion_na,1.0,[]
+1r3e,structures/1r3e.cif,2024-01-01,diffusion_na,1.0,[]
+1rh6,structures/1rh6.cif,2024-01-01,diffusion_na,1.0,[]
+1ruo,structures/1ruo.cif,2024-01-01,diffusion_na,1.0,[]
+1s6m,structures/1s6m.cif,2024-01-01,diffusion_na,1.0,[]
+1u78,structures/1u78.cif,2024-01-01,diffusion_na,1.0,[]
+1u8b,structures/1u8b.cif,2024-01-01,diffusion_na,1.0,[]
+1uts,structures/1uts.cif,2024-01-01,diffusion_na,1.0,[]
+1wtx,structures/1wtx.cif,2024-01-01,diffusion_na,1.0,[]
+1xsh,structures/1xsh.cif,2024-01-01,diffusion_na,1.0,[]
+1ylg,structures/1ylg.cif,2024-01-01,diffusion_na,1.0,[]
+1yng,structures/1yng.cif,2024-01-01,diffusion_na,1.0,[]
+1ysa,structures/1ysa.cif,2024-01-01,diffusion_na,1.0,[]
+1ze2,structures/1ze2.cif,2024-01-01,diffusion_na,1.0,[]
+1zfa,structures/1zfa.cif,2024-01-01,diffusion_na,1.0,[]
+2a7e,structures/2a7e.cif,2024-01-01,diffusion_na,1.0,[]
+2ab4,structures/2ab4.cif,2024-01-01,diffusion_na,1.0,[]
+2adw,structures/2adw.cif,2024-01-01,diffusion_na,1.0,[]
+2aoq,structures/2aoq.cif,2024-01-01,diffusion_na,1.0,[]
+2b0e,structures/2b0e.cif,2024-01-01,diffusion_na,1.0,[]
+2bcs,structures/2bcs.cif,2024-01-01,diffusion_na,1.0,[]
+2cd5,structures/2cd5.cif,2024-01-01,diffusion_na,1.0,[]
+2d25,structures/2d25.cif,2024-01-01,diffusion_na,1.0,[]
+2dd1,structures/2dd1.cif,2024-01-01,diffusion_na,1.0,[]
+2ex5,structures/2ex5.cif,2024-01-01,diffusion_na,1.0,[]
+2fld,structures/2fld.cif,2024-01-01,diffusion_na,1.0,[]
+2g1p,structures/2g1p.cif,2024-01-01,diffusion_na,1.0,[]
+2g1z,structures/2g1z.cif,2024-01-01,diffusion_na,1.0,[]
+2irn,structures/2irn.cif,2024-01-01,diffusion_na,1.0,[]
+2k41,structures/2k41.cif,2024-01-01,diffusion_na,1.0,[]
+2kf0,structures/2kf0.cif,2024-01-01,diffusion_na,1.0,[]
+2kh3,structures/2kh3.cif,2024-01-01,diffusion_na,1.0,[]
+2kn7,structures/2kn7.cif,2024-01-01,diffusion_na,1.0,[]
+2ktq,structures/2ktq.cif,2024-01-01,diffusion_na,1.0,[]
+2kzl,structures/2kzl.cif,2024-01-01,diffusion_na,1.0,[]
+2lqz,structures/2lqz.cif,2024-01-01,diffusion_na,1.0,[]
+2lvy,structures/2lvy.cif,2024-01-01,diffusion_na,1.0,[]
+2mi0,structures/2mi0.cif,2024-01-01,diffusion_na,1.0,[]
+2miv,structures/2miv.cif,2024-01-01,diffusion_na,1.0,[]
+2ms0,structures/2ms0.cif,2024-01-01,diffusion_na,1.0,[]
+2nci,structures/2nci.cif,2024-01-01,diffusion_na,1.0,[]
+2nuf,structures/2nuf.cif,2024-01-01,diffusion_na,1.0,[]
+2ozb,structures/2ozb.cif,2024-01-01,diffusion_na,1.0,[]
+2ply,structures/2ply.cif,2024-01-01,diffusion_na,1.0,[]
+2pn3,structures/2pn3.cif,2024-01-01,diffusion_na,1.0,[]
+2r8j,structures/2r8j.cif,2024-01-01,diffusion_na,1.0,[]
+2rdj,structures/2rdj.cif,2024-01-01,diffusion_na,1.0,[]
+2rpt,structures/2rpt.cif,2024-01-01,diffusion_na,1.0,[]
+2voa,structures/2voa.cif,2024-01-01,diffusion_na,1.0,[]
+2zjr,structures/2zjr.cif,2024-01-01,diffusion_na,1.0,[]
+2zko,structures/2zko.cif,2024-01-01,diffusion_na,1.0,[]
+2zy6,structures/2zy6.cif,2024-01-01,diffusion_na,1.0,[]
+375d,structures/375d.cif,2024-01-01,diffusion_na,1.0,[]
+376d,structures/376d.cif,2024-01-01,diffusion_na,1.0,[]
+395d,structures/395d.cif,2024-01-01,diffusion_na,1.0,[]
+3avu,structures/3avu.cif,2024-01-01,diffusion_na,1.0,[]
+3bo2,structures/3bo2.cif,2024-01-01,diffusion_na,1.0,[]
+3bo3,structures/3bo3.cif,2024-01-01,diffusion_na,1.0,[]
+3cvv,structures/3cvv.cif,2024-01-01,diffusion_na,1.0,[]
+3cvy,structures/3cvy.cif,2024-01-01,diffusion_na,1.0,[]
+3e2e,structures/3e2e.cif,2024-01-01,diffusion_na,1.0,[]
+3e44,structures/3e44.cif,2024-01-01,diffusion_na,1.0,[]
+3eog,structures/3eog.cif,2024-01-01,diffusion_na,1.0,[]
+3fte,structures/3fte.cif,2024-01-01,diffusion_na,1.0,[]
+3ftf,structures/3ftf.cif,2024-01-01,diffusion_na,1.0,[]
+3g9y,structures/3g9y.cif,2024-01-01,diffusion_na,1.0,[]
+3go3,structures/3go3.cif,2024-01-01,diffusion_na,1.0,[]
+3gp8,structures/3gp8.cif,2024-01-01,diffusion_na,1.0,[]
+3gtl,structures/3gtl.cif,2024-01-01,diffusion_na,1.0,[]
+3gv5,structures/3gv5.cif,2024-01-01,diffusion_na,1.0,[]
+3i5l,structures/3i5l.cif,2024-01-01,diffusion_na,1.0,[]
+3jcs,structures/3jcs.cif,2024-01-01,diffusion_na,1.0,[]
+3jsp,structures/3jsp.cif,2024-01-01,diffusion_na,1.0,[]
+3jtg,structures/3jtg.cif,2024-01-01,diffusion_na,1.0,[]
+3knc,structures/3knc.cif,2024-01-01,diffusion_na,1.0,[]
+3lwh,structures/3lwh.cif,2024-01-01,diffusion_na,1.0,[]
+3mis,structures/3mis.cif,2024-01-01,diffusion_na,1.0,[]
+3mqy,structures/3mqy.cif,2024-01-01,diffusion_na,1.0,[]
+3olb,structures/3olb.cif,2024-01-01,diffusion_na,1.0,[]
+3oqm,structures/3oqm.cif,2024-01-01,diffusion_na,1.0,[]
+3pzp,structures/3pzp.cif,2024-01-01,diffusion_na,1.0,[]
+3rae,structures/3rae.cif,2024-01-01,diffusion_na,1.0,[]
+3rn5,structures/3rn5.cif,2024-01-01,diffusion_na,1.0,[]
+3sj2,structures/3sj2.cif,2024-01-01,diffusion_na,1.0,[]
+3u44,structures/3u44.cif,2024-01-01,diffusion_na,1.0,[]
+3uq0,structures/3uq0.cif,2024-01-01,diffusion_na,1.0,[]
+3v9d,structures/3v9d.cif,2024-01-01,diffusion_na,1.0,[]
+3v9x,structures/3v9x.cif,2024-01-01,diffusion_na,1.0,[]
+3zd5,structures/3zd5.cif,2024-01-01,diffusion_na,1.0,[]
+433d,structures/433d.cif,2024-01-01,diffusion_na,1.0,[]
+474d,structures/474d.cif,2024-01-01,diffusion_na,1.0,[]
+4aa6,structures/4aa6.cif,2024-01-01,diffusion_na,1.0,[]
+4c4w,structures/4c4w.cif,2024-01-01,diffusion_na,1.0,[]
+4cn5,structures/4cn5.cif,2024-01-01,diffusion_na,1.0,[]
+4du4,structures/4du4.cif,2024-01-01,diffusion_na,1.0,[]
+4e0y,structures/4e0y.cif,2024-01-01,diffusion_na,1.0,[]
+4e5z,structures/4e5z.cif,2024-01-01,diffusion_na,1.0,[]
+4eey,structures/4eey.cif,2024-01-01,diffusion_na,1.0,[]
+4esv,structures/4esv.cif,2024-01-01,diffusion_na,1.0,[]
+4fbt,structures/4fbt.cif,2024-01-01,diffusion_na,1.0,[]
+4fj7,structures/4fj7.cif,2024-01-01,diffusion_na,1.0,[]
+4g7h,structures/4g7h.cif,2024-01-01,diffusion_na,1.0,[]
+4h0e,structures/4h0e.cif,2024-01-01,diffusion_na,1.0,[]
+4h5p,structures/4h5p.cif,2024-01-01,diffusion_na,1.0,[]
+4ifd,structures/4ifd.cif,2024-01-01,diffusion_na,1.0,[]
+4ioa,structures/4ioa.cif,2024-01-01,diffusion_na,1.0,[]
+4izq,structures/4izq.cif,2024-01-01,diffusion_na,1.0,[]
+4j9q,structures/4j9q.cif,2024-01-01,diffusion_na,1.0,[]
+4jrp,structures/4jrp.cif,2024-01-01,diffusion_na,1.0,[]
+4k4u,structures/4k4u.cif,2024-01-01,diffusion_na,1.0,[]
+4kpy,structures/4kpy.cif,2024-01-01,diffusion_na,1.0,[]
+4kr9,structures/4kr9.cif,2024-01-01,diffusion_na,1.0,[]
+4lg2,structures/4lg2.cif,2024-01-01,diffusion_na,1.0,[]
+4m3t,structures/4m3t.cif,2024-01-01,diffusion_na,1.0,[]
+4mdx,structures/4mdx.cif,2024-01-01,diffusion_na,1.0,[]
+4n76,structures/4n76.cif,2024-01-01,diffusion_na,1.0,[]
+4oln,structures/4oln.cif,2024-01-01,diffusion_na,1.0,[]
+4peh,structures/4peh.cif,2024-01-01,diffusion_na,1.0,[]
+4qjd,structures/4qjd.cif,2024-01-01,diffusion_na,1.0,[]
+4qzi,structures/4qzi.cif,2024-01-01,diffusion_na,1.0,[]
+4r4e,structures/4r4e.cif,2024-01-01,diffusion_na,1.0,[]
+4rge,structures/4rge.cif,2024-01-01,diffusion_na,1.0,[]
+4rq4,structures/4rq4.cif,2024-01-01,diffusion_na,1.0,[]
+4rq6,structures/4rq6.cif,2024-01-01,diffusion_na,1.0,[]
+4rq8,structures/4rq8.cif,2024-01-01,diffusion_na,1.0,[]
+4rtj,structures/4rtj.cif,2024-01-01,diffusion_na,1.0,[]
+4tvx,structures/4tvx.cif,2024-01-01,diffusion_na,1.0,[]
+4u92,structures/4u92.cif,2024-01-01,diffusion_na,1.0,[]
+4v5q,structures/4v5q.cif,2024-01-01,diffusion_na,1.0,[]
+4v5s,structures/4v5s.cif,2024-01-01,diffusion_na,1.0,[]
+4wal,structures/4wal.cif,2024-01-01,diffusion_na,1.0,[]
+4wc5,structures/4wc5.cif,2024-01-01,diffusion_na,1.0,[]
+4xrm,structures/4xrm.cif,2024-01-01,diffusion_na,1.0,[]
+4xvi,structures/4xvi.cif,2024-01-01,diffusion_na,1.0,[]
+4y52,structures/4y52.cif,2024-01-01,diffusion_na,1.0,[]
+4yf0,structures/4yf0.cif,2024-01-01,diffusion_na,1.0,[]
+4yg1,structures/4yg1.cif,2024-01-01,diffusion_na,1.0,[]
+4yir,structures/4yir.cif,2024-01-01,diffusion_na,1.0,[]
+4zbn,structures/4zbn.cif,2024-01-01,diffusion_na,1.0,[]
+5cdr,structures/5cdr.cif,2024-01-01,diffusion_na,1.0,[]
+5cnq,structures/5cnq.cif,2024-01-01,diffusion_na,1.0,[]
+5d2s,structures/5d2s.cif,2024-01-01,diffusion_na,1.0,[]
+5d39,structures/5d39.cif,2024-01-01,diffusion_na,1.0,[]
+5dcv,structures/5dcv.cif,2024-01-01,diffusion_na,1.0,[]
+5ddo,structures/5ddo.cif,2024-01-01,diffusion_na,1.0,[]
+5elh,structures/5elh.cif,2024-01-01,diffusion_na,1.0,[]
+5fj4,structures/5fj4.cif,2024-01-01,diffusion_na,1.0,[]
+5gwl,structures/5gwl.cif,2024-01-01,diffusion_na,1.0,[]
+5h9f,structures/5h9f.cif,2024-01-01,diffusion_na,1.0,[]
+5hto,structures/5hto.cif,2024-01-01,diffusion_na,1.0,[]
+5iyg,structures/5iyg.cif,2024-01-01,diffusion_na,1.0,[]
+5j4w,structures/5j4w.cif,2024-01-01,diffusion_na,1.0,[]
+5jvw,structures/5jvw.cif,2024-01-01,diffusion_na,1.0,[]
+5k36,structures/5k36.cif,2024-01-01,diffusion_na,1.0,[]
+5lzd,structures/5lzd.cif,2024-01-01,diffusion_na,1.0,[]
+5mdy,structures/5mdy.cif,2024-01-01,diffusion_na,1.0,[]
+5mey,structures/5mey.cif,2024-01-01,diffusion_na,1.0,[]
+5mga,structures/5mga.cif,2024-01-01,diffusion_na,1.0,[]
+5mrc,structures/5mrc.cif,2024-01-01,diffusion_na,1.0,[]
+5nm9,structures/5nm9.cif,2024-01-01,diffusion_na,1.0,[]
+5nw9,structures/5nw9.cif,2024-01-01,diffusion_na,1.0,[]
+5odm,structures/5odm.cif,2024-01-01,diffusion_na,1.0,[]
+5oe1,structures/5oe1.cif,2024-01-01,diffusion_na,1.0,[]
+5ond,structures/5ond.cif,2024-01-01,diffusion_na,1.0,[]
+5ua3,structures/5ua3.cif,2024-01-01,diffusion_na,1.0,[]
+5uq8,structures/5uq8.cif,2024-01-01,diffusion_na,1.0,[]
+5v3j,structures/5v3j.cif,2024-01-01,diffusion_na,1.0,[]
+5va0,structures/5va0.cif,2024-01-01,diffusion_na,1.0,[]
+5vxn,structures/5vxn.cif,2024-01-01,diffusion_na,1.0,[]
+5w20,structures/5w20.cif,2024-01-01,diffusion_na,1.0,[]
+5wjq,structures/5wjq.cif,2024-01-01,diffusion_na,1.0,[]
+5wnp,structures/5wnp.cif,2024-01-01,diffusion_na,1.0,[]
+5xtm,structures/5xtm.cif,2024-01-01,diffusion_na,1.0,[]
+5ytc,structures/5ytc.cif,2024-01-01,diffusion_na,1.0,[]
+5zki,structures/5zki.cif,2024-01-01,diffusion_na,1.0,[]
+6aeg,structures/6aeg.cif,2024-01-01,diffusion_na,1.0,[]
+6b1q,structures/6b1q.cif,2024-01-01,diffusion_na,1.0,[]
+6c4i,structures/6c4i.cif,2024-01-01,diffusion_na,1.0,[]
+6cuu,structures/6cuu.cif,2024-01-01,diffusion_na,1.0,[]
+6d2u,structures/6d2u.cif,2024-01-01,diffusion_na,1.0,[]
+6dcl,structures/6dcl.cif,2024-01-01,diffusion_na,1.0,[]
+6e8c,structures/6e8c.cif,2024-01-01,diffusion_na,1.0,[]
+6e8s,structures/6e8s.cif,2024-01-01,diffusion_na,1.0,[]
+6f1k,structures/6f1k.cif,2024-01-01,diffusion_na,1.0,[]
+6gaz,structures/6gaz.cif,2024-01-01,diffusion_na,1.0,[]
+6gim,structures/6gim.cif,2024-01-01,diffusion_na,1.0,[]
+6gvt,structures/6gvt.cif,2024-01-01,diffusion_na,1.0,[]
+6gz5,structures/6gz5.cif,2024-01-01,diffusion_na,1.0,[]
+6hmi,structures/6hmi.cif,2024-01-01,diffusion_na,1.0,[]
+6i1l,structures/6i1l.cif,2024-01-01,diffusion_na,1.0,[]
+6iid,structures/6iid.cif,2024-01-01,diffusion_na,1.0,[]
+6jgx,structures/6jgx.cif,2024-01-01,diffusion_na,1.0,[]
+6jyw,structures/6jyw.cif,2024-01-01,diffusion_na,1.0,[]
+6l2o,structures/6l2o.cif,2024-01-01,diffusion_na,1.0,[]
+6lbm,structures/6lbm.cif,2024-01-01,diffusion_na,1.0,[]
+6m5b,structures/6m5b.cif,2024-01-01,diffusion_na,1.0,[]
+6m7v,structures/6m7v.cif,2024-01-01,diffusion_na,1.0,[]
+6mfn,structures/6mfn.cif,2024-01-01,diffusion_na,1.0,[]
+6nf8,structures/6nf8.cif,2024-01-01,diffusion_na,1.0,[]
+6nua,structures/6nua.cif,2024-01-01,diffusion_na,1.0,[]
+6nwy,structures/6nwy.cif,2024-01-01,diffusion_na,1.0,[]
+6of6,structures/6of6.cif,2024-01-01,diffusion_na,1.0,[]
+6ol3,structures/6ol3.cif,2024-01-01,diffusion_na,1.0,[]
+6om0,structures/6om0.cif,2024-01-01,diffusion_na,1.0,[]
+6ope,structures/6ope.cif,2024-01-01,diffusion_na,1.0,[]
+6ow3,structures/6ow3.cif,2024-01-01,diffusion_na,1.0,[]
+6oy5,structures/6oy5.cif,2024-01-01,diffusion_na,1.0,[]
+6pbd,structures/6pbd.cif,2024-01-01,diffusion_na,1.0,[]
+6pr5,structures/6pr5.cif,2024-01-01,diffusion_na,1.0,[]
+6qhd,structures/6qhd.cif,2024-01-01,diffusion_na,1.0,[]
+6qzp,structures/6qzp.cif,2024-01-01,diffusion_na,1.0,[]
+6rio,structures/6rio.cif,2024-01-01,diffusion_na,1.0,[]
+6ty9,structures/6ty9.cif,2024-01-01,diffusion_na,1.0,[]
+6u81,structures/6u81.cif,2024-01-01,diffusion_na,1.0,[]
+6ufj,structures/6ufj.cif,2024-01-01,diffusion_na,1.0,[]
+6ufk,structures/6ufk.cif,2024-01-01,diffusion_na,1.0,[]
+6upx,structures/6upx.cif,2024-01-01,diffusion_na,1.0,[]
+6upy,structures/6upy.cif,2024-01-01,diffusion_na,1.0,[]
+6uq3,structures/6uq3.cif,2024-01-01,diffusion_na,1.0,[]
+6va1,structures/6va1.cif,2024-01-01,diffusion_na,1.0,[]
+6w0r,structures/6w0r.cif,2024-01-01,diffusion_na,1.0,[]
+6wbr,structures/6wbr.cif,2024-01-01,diffusion_na,1.0,[]
+6xej,structures/6xej.cif,2024-01-01,diffusion_na,1.0,[]
+6xfc,structures/6xfc.cif,2024-01-01,diffusion_na,1.0,[]
+6xjq,structures/6xjq.cif,2024-01-01,diffusion_na,1.0,[]
+6zm5,structures/6zm5.cif,2024-01-01,diffusion_na,1.0,[]
+6zm6,structures/6zm6.cif,2024-01-01,diffusion_na,1.0,[]
+7a0r,structures/7a0r.cif,2024-01-01,diffusion_na,1.0,[]
+7a18,structures/7a18.cif,2024-01-01,diffusion_na,1.0,[]
+7am2,structures/7am2.cif,2024-01-01,diffusion_na,1.0,[]
+7aoh,structures/7aoh.cif,2024-01-01,diffusion_na,1.0,[]
+7aqc,structures/7aqc.cif,2024-01-01,diffusion_na,1.0,[]
+7b0c,structures/7b0c.cif,2024-01-01,diffusion_na,1.0,[]
+7cq4,structures/7cq4.cif,2024-01-01,diffusion_na,1.0,[]
+7dco,structures/7dco.cif,2024-01-01,diffusion_na,1.0,[]
+7el7,structures/7el7.cif,2024-01-01,diffusion_na,1.0,[]
+7jhr,structures/7jhr.cif,2024-01-01,diffusion_na,1.0,[]
+7jio,structures/7jio.cif,2024-01-01,diffusion_na,1.0,[]
+7jp6,structures/7jp6.cif,2024-01-01,diffusion_na,1.0,[]
+7js1,structures/7js1.cif,2024-01-01,diffusion_na,1.0,[]
+7k5d,structures/7k5d.cif,2024-01-01,diffusion_na,1.0,[]
+7k78,structures/7k78.cif,2024-01-01,diffusion_na,1.0,[]
+7k98,structures/7k98.cif,2024-01-01,diffusion_na,1.0,[]
+7kab,structures/7kab.cif,2024-01-01,diffusion_na,1.0,[]
+7kub,structures/7kub.cif,2024-01-01,diffusion_na,1.0,[]
+7m7z,structures/7m7z.cif,2024-01-01,diffusion_na,1.0,[]
+7m82,structures/7m82.cif,2024-01-01,diffusion_na,1.0,[]
+7mjx,structures/7mjx.cif,2024-01-01,diffusion_na,1.0,[]
+7mkd,structures/7mkd.cif,2024-01-01,diffusion_na,1.0,[]
+7mki,structures/7mki.cif,2024-01-01,diffusion_na,1.0,[]
+7mpj,structures/7mpj.cif,2024-01-01,diffusion_na,1.0,[]
+7o0g,structures/7o0g.cif,2024-01-01,diffusion_na,1.0,[]
+7ogv,structures/7ogv.cif,2024-01-01,diffusion_na,1.0,[]
+7ohj,structures/7ohj.cif,2024-01-01,diffusion_na,1.0,[]
+7ope,structures/7ope.cif,2024-01-01,diffusion_na,1.0,[]
+7p0w,structures/7p0w.cif,2024-01-01,diffusion_na,1.0,[]
+7pli,structures/7pli.cif,2024-01-01,diffusion_na,1.0,[]
+7pnt,structures/7pnt.cif,2024-01-01,diffusion_na,1.0,[]
+7pnw,structures/7pnw.cif,2024-01-01,diffusion_na,1.0,[]
+7q7z,structures/7q7z.cif,2024-01-01,diffusion_na,1.0,[]
+7q81,structures/7q81.cif,2024-01-01,diffusion_na,1.0,[]
+7r6v,structures/7r6v.cif,2024-01-01,diffusion_na,1.0,[]
+7riw,structures/7riw.cif,2024-01-01,diffusion_na,1.0,[]
+7rix,structures/7rix.cif,2024-01-01,diffusion_na,1.0,[]
+7sop,structures/7sop.cif,2024-01-01,diffusion_na,1.0,[]
+7tql,structures/7tql.cif,2024-01-01,diffusion_na,1.0,[]
+7uo5,structures/7uo5.cif,2024-01-01,diffusion_na,1.0,[]
+7uzx,structures/7uzx.cif,2024-01-01,diffusion_na,1.0,[]
+7vo0,structures/7vo0.cif,2024-01-01,diffusion_na,1.0,[]
+7z1o,structures/7z1o.cif,2024-01-01,diffusion_na,1.0,[]
+7z4d,structures/7z4d.cif,2024-01-01,diffusion_na,1.0,[]
+8df9,structures/8df9.cif,2024-01-01,diffusion_na,1.0,[]

scripts/download_structures_from_manifest.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Download package CIF files from official wwPDB/RCSB mirrors.
+
+Run from the package root:
+    python scripts/download_structures_from_manifest.py
+"""
+
+import csv
+import gzip
+from pathlib import Path
+import queue
+import threading
+import time
+import urllib.request
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = PACKAGE_ROOT / "manifest.csv"
+STRUCTURES = PACKAGE_ROOT / "structures"
+WORKERS = 16
+
+
+def urls_for(pdb_id):
+    subdir = pdb_id[1:3]
+    return [
+        f"https://files.wwpdb.org/pub/pdb/data/structures/divided/mmCIF/{subdir}/{pdb_id}.cif.gz",
+        f"https://files.pdbj.org/pub/pdb/data/structures/divided/mmCIF/{subdir}/{pdb_id}.cif.gz",
+        f"https://files.rcsb.org/download/{pdb_id.upper()}.cif.gz",
+        f"https://files.rcsb.org/download/{pdb_id.upper()}.cif",
+    ]
+
+
+def download_one(pdb_id, attempts=6):
+    last_error = None
+    for attempt in range(1, attempts + 1):
+        for url in urls_for(pdb_id):
+            try:
+                req = urllib.request.Request(
+                    url,
+                    headers={"User-Agent": "NAIAD-hf-data-packager/1.0"},
+                )
+                with urllib.request.urlopen(req, timeout=120) as response:
+                    data = response.read()
+                if url.endswith(".gz"):
+                    data = gzip.decompress(data)
+                if not data.startswith(b"data_") and b"_entry.id" not in data[:4096]:
+                    raise ValueError(f"unexpected mmCIF content from {url}")
+                STRUCTURES.mkdir(parents=True, exist_ok=True)
+                tmp = STRUCTURES / f"{pdb_id}.cif.tmp"
+                dst = STRUCTURES / f"{pdb_id}.cif"
+                tmp.write_bytes(data)
+                tmp.replace(dst)
+                return
+            except Exception as exc:
+                last_error = exc
+        time.sleep(min(2 * attempt, 10))
+    raise last_error
+
+
+def main():
+    pdb_ids = []
+    with MANIFEST.open(newline="") as handle:
+        for row in csv.DictReader(handle):
+            pdb_id = row["pdb_id"].lower()
+            dst = STRUCTURES / f"{pdb_id}.cif"
+            if not dst.exists() or dst.stat().st_size == 0:
+                pdb_ids.append(pdb_id)
+
+    jobs = queue.Queue()
+    for pdb_id in pdb_ids:
+        jobs.put(pdb_id)
+
+    failures = []
+    lock = threading.Lock()
+    start = time.time()
+
+    def worker():
+        while True:
+            try:
+                pdb_id = jobs.get_nowait()
+            except queue.Empty:
+                return
+            try:
+                download_one(pdb_id)
+                with lock:
+                    done = len(pdb_ids) - jobs.qsize()
+                    print(f"OK {pdb_id} ({done}/{len(pdb_ids)})", flush=True)
+            except Exception as exc:
+                with lock:
+                    failures.append((pdb_id, repr(exc)))
+                print(f"FAILED {pdb_id}: {exc!r}", flush=True)
+            finally:
+                jobs.task_done()
+
+    threads = [threading.Thread(target=worker, daemon=True) for _ in range(WORKERS)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
+
+    if failures:
+        failure_path = PACKAGE_ROOT / "download_failures.txt"
+        failure_path.write_text("\n".join(f"{pdb_id}\t{err}" for pdb_id, err in failures) + "\n")
+        raise SystemExit(f"{len(failures)} downloads failed; see {failure_path}")
+
+    print(f"Downloaded {len(pdb_ids)} missing structures in {time.time() - start:.1f}s")
+
+
+if __name__ == "__main__":
+    main()

scripts/family_label.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+#SBATCH -p cpu
+#SBATCH --mem=32g
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --time=01:00:00
+
+fasta_splits_directory=$1
+family_label_output_directory=$2
+
+# Fasta path.
+fasta_path=$fasta_splits_directory"/all_protein_sequences_"$SLURM_ARRAY_TASK_ID".fa"
+
+# Output path.
+output_path=$family_label_output_directory"/family_label_"$SLURM_ARRAY_TASK_ID".csv"
+
+# Run InterProScan on the fasta.
+/home/akubaney/software/interproscan/interproscan.sh -i $fasta_path -f tsv -o $output_path -appl Pfam

scripts/generate_training_csv_from_splits.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+"""
+Generate training CSV files from the splits JSON files.
+
+This script reads the PDB ID lists from splits/*.json and creates 
+the CSV files needed for training, matching them with the mmCIF files.
+
+Usage:
+    python generate_training_csv_from_splits.py \
+        --mmcif_dir /path/to/mmcif_files \
+        --splits_dir /path/to/splits \
+        --output_dir /path/to/output
+
+Example:
+    cd /root/autodl-tmp/PH-NA-MPNN/data
+    python generate_training_csv_from_splits.py \
+        --mmcif_dir ./pdb_mmcif \
+        --splits_dir ../splits \
+        --output_dir ./datasets/diffusion_na_full
+"""
+
+import os
+import sys
+import json
+import glob
+import argparse
+import pandas as pd
+from tqdm import tqdm
+
+
+
+def find_structure_path(pdb_id, mmcif_dir):
+    """Find the structure file path for a given PDB ID."""
+    pdb_id_lower = pdb_id.lower()
+    
+    # Try different possible locations and extensions
+    patterns = [
+        os.path.join(mmcif_dir, f"{pdb_id_lower}.cif"),
+        os.path.join(mmcif_dir, f"{pdb_id_lower}.cif.gz"),
+        os.path.join(mmcif_dir, pdb_id_lower[1:3], f"{pdb_id_lower}.cif"),
+        os.path.join(mmcif_dir, pdb_id_lower[1:3], f"{pdb_id_lower}.cif.gz"),
+    ]
+    
+    for pattern in patterns:
+        if os.path.exists(pattern):
+            return pattern
+    
+    return None
+
+
+def load_json(path):
+    """Load a JSON file."""
+    with open(path, 'r') as f:
+        return json.load(f)
+
+
+def create_training_csv(pdb_ids, mmcif_dir, output_path, dataset_name="diffusion_na"):
+    """Create a training CSV file from PDB IDs."""
+    
+    data = []
+    missing_count = 0
+    
+    for pdb_id in tqdm(pdb_ids, desc=f"Processing {os.path.basename(output_path)}"):
+        structure_path = find_structure_path(pdb_id, mmcif_dir)
+
+        if structure_path is None:
+            missing_count += 1
+            continue
+        
+        data.append({
+            'id': pdb_id.lower(),
+            'structure_path': os.path.abspath(structure_path),
+            'date': '2024-01-01',  # Default date
+            'dataset_name': dataset_name,
+            'sampling_probability': 1.0,
+            'ppm_paths': '[]',
+        })
+    
+    df = pd.DataFrame(data)
+    df.to_csv(output_path, index=False)
+    
+    print(f"Created {output_path}")
+    print(f"  Total PDB IDs:     {len(pdb_ids)}")
+    print(f"  Found:             {len(data)}")
+    print(f"  Missing:           {missing_count}")
+    
+    return df
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate training CSVs from splits JSON files"
+    )
+    parser.add_argument('--mmcif_dir', type=str, required=True,
+                        help='Path to mmCIF files directory')
+    parser.add_argument('--splits_dir', type=str, required=True,
+                        help='Path to splits directory containing JSON files')
+    parser.add_argument('--output_dir', type=str, required=True,
+                        help='Output directory for CSV files')
+    parser.add_argument('--split_type', type=str, default='design',
+                        choices=['design', 'specificity'],
+                        help='Which split type to use (default: design)')
+    
+    args = parser.parse_args()
+    
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+    
+    # Load split files
+    train_json = os.path.join(args.splits_dir, f'{args.split_type}_train.json')
+    valid_json = os.path.join(args.splits_dir, f'{args.split_type}_valid.json')
+    test_json = os.path.join(args.splits_dir, f'{args.split_type}_test.json')
+    
+    print(f"Loading splits from {args.splits_dir}...")
+    train_ids = load_json(train_json)
+    valid_ids = load_json(valid_json)
+    test_ids = load_json(test_json) if os.path.exists(test_json) else []
+    
+    print(f"  Train: {len(train_ids)} PDB IDs")
+    print(f"  Valid: {len(valid_ids)} PDB IDs")
+    print(f"  Test: {len(test_ids)} PDB IDs")
+    
+    # Check mmcif directory
+    print(f"\nSearching for mmCIF files in {args.mmcif_dir}...")
+    mmcif_files = glob.glob(os.path.join(args.mmcif_dir, '*.cif'))
+    mmcif_files += glob.glob(os.path.join(args.mmcif_dir, '*.cif.gz'))
+    print(f"  Found {len(mmcif_files)} mmCIF files")
+    
+    # Generate CSVs
+    print("\nGenerating CSV files...")
+    
+    train_csv = os.path.join(args.output_dir, 'train.csv')
+    valid_csv = os.path.join(args.output_dir, 'valid.csv')
+    test_csv = os.path.join(args.output_dir, 'test.csv')
+    
+    create_training_csv(train_ids, args.mmcif_dir, train_csv)
+    create_training_csv(valid_ids, args.mmcif_dir, valid_csv)
+    if test_ids:
+        create_training_csv(test_ids, args.mmcif_dir, test_csv)
+    
+    print("\n" + "="*60)
+    print("Done! Update your config with:")
+    print(f'  "DF_PATH_TRAIN": "{os.path.abspath(train_csv)}",')
+    print(f'  "DF_PATH_VALID": "{os.path.abspath(valid_csv)}",')
+    print("="*60)
+
+
+if __name__ == "__main__":
+    main()

scripts/prepare_diffusion_dataset_full.py

@@ -0,0 +1,997 @@
+"""
+Full-featured dataset preparation for NA-MPNN Diffusion training.
+
+This is the "满血版" that mirrors the original NA-MPNN data preparation:
+1. Multi-process PDB scanning (parallelized)
+2. Filtering (heavy atoms, coverage, unknown residues, resolution, NA)
+3. Full preprocessing (interface masks, base pair masks, etc.)
+4. Optional sequence clustering (CD-HIT)
+5. Train/valid/test splitting (cluster-based to prevent data leakage)
+
+Usage:
+    # Step 1: Scan PDB database (multi-process)
+    python prepare_diffusion_dataset_full.py scan \
+        --mmcif_dir /path/to/pdb_mmcif \
+        --output_dir ./diffusion_dataset \
+        --num_workers 16
+
+    # Step 2: Preprocess structures (multi-process)
+    python prepare_diffusion_dataset_full.py preprocess \
+        --output_dir ./diffusion_dataset \
+        --num_workers 16
+
+    # Step 3: Cluster sequences (optional, requires CD-HIT)
+    python prepare_diffusion_dataset_full.py cluster \
+        --output_dir ./diffusion_dataset \
+        --cdhit_path /path/to/cd-hit
+
+    # Step 4: Split into train/valid/test
+    python prepare_diffusion_dataset_full.py split \
+        --output_dir ./diffusion_dataset \
+        --valid_fraction 0.1 \
+        --test_fraction 0.1
+
+    # Or run all steps at once
+    python prepare_diffusion_dataset_full.py all \
+        --mmcif_dir /path/to/pdb_mmcif \
+        --output_dir ./diffusion_dataset \
+        --num_workers 16
+
+Reference: Original NA-MPNN data preparation pipeline by Andrew Kubaney
+"""
+
+import os
+import sys
+import glob
+import argparse
+import itertools
+import json
+import collections
+import subprocess
+import shutil
+import numpy as np
+import pandas as pd
+from multiprocessing import Pool, cpu_count
+from functools import partial
+from tqdm import tqdm
+import traceback
+
+# Add project root to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+try:
+    from openbabel import openbabel
+    openbabel.obErrorLog.SetOutputLevel(0)
+    openbabel.cvar.obErrorLog.StopLogging()
+except ImportError:
+    pass  # OpenBabel is optional
+
+
+# ============================================================================
+# Step 1: Multi-process PDB Scanning
+# ============================================================================
+
+def parse_single_structure(args):
+    """Parse a single structure file (worker function for multiprocessing)."""
+    fname, skip_res = args
+    
+    # Import inside worker to avoid pickling issues
+    import cifutils
+    
+    try:
+        parser = cifutils.CIFParser(skip_res=skip_res)
+        chains, asmb, covale, meta = parser.parse(fname)
+        
+        # Count heavy atoms
+        heavy_atoms = [a for c in chains.values() for a in c.atoms.values() if a.element > 1]
+        m, n = 0, 0
+        for g in itertools.groupby(heavy_atoms, key=lambda a: a.name[:3]):
+            res_atoms = list(g[1])
+            nobs = sum([a.occ > 0 for a in res_atoms])
+            m += nobs
+            if nobs > 0:
+                n += len(res_atoms)
+        
+        # Extract info
+        label = os.path.basename(fname).replace('.cif.gz', '').replace('.cif', '')
+        
+        poly_chains = [(k, v.type, v.sequence) for k, v in chains.items() if 'nonpoly' not in v.type]
+        chain_types = [c[1] for c in poly_chains]
+        
+        return {
+            'id': label,
+            'structure_path': fname,
+            'date': meta['date'],
+            'method': meta['method'],
+            'resolution': meta['resolution'],
+            'num_heavy': n,
+            'coverage': m / n if n > 0 else 0,
+            'poly_chains': [c[0] for c in poly_chains],
+            'poly_types': chain_types,
+            'poly_sequences': [c[2] for c in poly_chains],
+            'has_protein': 'polypeptide(L)' in chain_types,
+            'has_dna': 'polydeoxyribonucleotide' in chain_types,
+            'has_rna': 'polyribonucleotide' in chain_types,
+            'has_hybrid': 'polydeoxyribonucleotide/polyribonucleotide hybrid' in chain_types,
+            'n_assemblies': len(asmb),
+            'error': None
+        }
+    except Exception as e:
+        return {
+            'id': os.path.basename(fname),
+            'structure_path': fname,
+            'error': str(e)
+        }
+
+
+def scan_database_multiprocess(mmcif_dir, output_dir, num_workers=None, 
+                                skip_res=['HOH', 'NA', 'CL', 'K', 'BR'],
+                                sample_size=None):
+    """Scan PDB database using multiple processes."""
+    
+    if num_workers is None:
+        num_workers = max(1, cpu_count() - 2)
+    
+    # Find all mmCIF files
+    patterns = [
+        os.path.join(mmcif_dir, '*.cif'),
+        os.path.join(mmcif_dir, '*.cif.gz'),
+        os.path.join(mmcif_dir, '*', '*.cif'),
+        os.path.join(mmcif_dir, '*', '*.cif.gz'),
+    ]
+    
+    fnames = []
+    for pattern in patterns:
+        fnames.extend(glob.glob(pattern))
+    fnames = sorted(list(set(fnames)))
+    
+    print(f"Found {len(fnames)} mmCIF files")
+    
+    if sample_size and len(fnames) > sample_size:
+        np.random.seed(42)
+        fnames = list(np.random.choice(fnames, sample_size, replace=False))
+        print(f"Sampling {sample_size} files for testing")
+    
+    # Prepare arguments
+    args_list = [(f, skip_res) for f in fnames]
+    
+    # Process in parallel
+    print(f"Scanning with {num_workers} workers...")
+    
+    results = []
+    errors = []
+    
+    with Pool(num_workers) as pool:
+        for result in tqdm(pool.imap_unordered(parse_single_structure, args_list), 
+                           total=len(args_list), desc="Scanning"):
+            if result.get('error'):
+                errors.append(result)
+            else:
+                results.append(result)
+    
+    print(f"Successfully parsed: {len(results)}")
+    print(f"Errors: {len(errors)}")
+    
+    # Save results
+    os.makedirs(output_dir, exist_ok=True)
+    
+    df = pd.DataFrame(results)
+    scan_path = os.path.join(output_dir, 'scan_results.csv')
+    df.to_csv(scan_path, index=False)
+    print(f"Saved scan results to {scan_path}")
+    
+    if errors:
+        error_path = os.path.join(output_dir, 'scan_errors.csv')
+        pd.DataFrame(errors).to_csv(error_path, index=False)
+        print(f"Saved errors to {error_path}")
+    
+    return df
+
+
+def seq_filter_unknown(seqs, max_unknown=20):
+    """Filter sequences with too many unknown residues (X)."""
+    if not seqs or len(seqs) == 0:
+        return True
+    
+    # Handle string representation of lists
+    if isinstance(seqs, str):
+        try:
+            seqs = eval(seqs)
+        except:
+            return True
+    
+    Lmax = max([len(s) for s in seqs]) if seqs else 0
+    s = "".join(seqs)
+    L = len(s)
+    
+    if Lmax <= max_unknown:
+        return True
+    
+    counter = collections.Counter(s)
+    top_aa = counter.most_common(1)
+    if top_aa and top_aa[0][0] == 'X' and top_aa[0][1] > max_unknown:
+        return False
+    
+    return True
+
+
+def filter_scanned_data(df, min_heavy_atoms=100, min_coverage=0.9, 
+                        max_resolution=3.5, max_unknown_residues=20,
+                        require_na=False, require_protein=False):
+    """Filter scanned structures based on quality criteria.
+    
+    This mirrors the original NA-MPNN filtering from make_dataset_csv.ipynb:
+    - Heavy atoms >= 100
+    - Coverage >= 0.9
+    - Unknown residues <= 20
+    - Resolution <= 3.5Å (or NMR)
+    - Contains nucleic acid (optional)
+    - Contains protein (optional)
+    """
+    
+    print(f"\nFiltering {len(df)} structures...")
+    initial_count = len(df)
+    
+    # Heavy atoms
+    df = df[df['num_heavy'] >= min_heavy_atoms].copy()
+    print(f"  After heavy atoms (>={min_heavy_atoms}): {len(df)}")
+    
+    # Coverage
+    df = df[df['coverage'] >= min_coverage].copy()
+    print(f"  After coverage (>={min_coverage}): {len(df)}")
+    
+    # Unknown residues filter
+    if 'poly_sequences' in df.columns:
+        df = df[df['poly_sequences'].apply(lambda x: seq_filter_unknown(x, max_unknown_residues))].copy()
+        print(f"  After unknown residues (<={max_unknown_residues}): {len(df)}")
+    
+    # Resolution (allow NaN for NMR)
+    df = df[(df['resolution'] <= max_resolution) | (df['resolution'].isna())].copy()
+    print(f"  After resolution (<={max_resolution}Å or NMR): {len(df)}")
+    
+    # Require NA
+    if require_na:
+        df['has_na'] = df['has_dna'] | df['has_rna'] | df['has_hybrid']
+        df = df[df['has_na']].copy()
+        print(f"  After NA requirement: {len(df)}")
+    
+    # Require protein
+    if require_protein:
+        df = df[df['has_protein']].copy()
+        print(f"  After protein requirement: {len(df)}")
+    
+    print(f"\n  Total filtered: {initial_count} -> {len(df)} ({100*len(df)/initial_count:.1f}% retained)")
+    
+    return df
+
+
+# ============================================================================
+# Step 2: Multi-process Preprocessing
+# ============================================================================
+
+def preprocess_single_structure(args):
+    """Preprocess a single structure (worker function)."""
+    
+    row_dict, output_dir, params = args
+    struct_id = row_dict['id']
+    structure_path = row_dict['structure_path']
+    
+    # Import inside worker
+    import torch
+    import pdbutils
+    import cifutils
+    from na_data_utils import PDBDataset
+    
+    try:
+        # Create dataset object
+        atom_list_to_save = [
+            'N', 'CA', 'C', 'O',
+            'OP1', 'OP2', 'P', "O5'", "C5'", "C4'", "O4'", "C3'", "O3'", 
+            "C2'", "O2'", "C1'"
+        ]
+        
+        cif_parser = cifutils.CIFParser(skip_res=params.get('EXCLUDE_RES', ['HOH', 'NA', 'CL', 'K', 'BR']))
+        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=1,
+            parse_dna=1,
+            parse_rna=1,
+            parse_rna_as_dna=0,
+            na_shared_tokens=params.get('NA_SHARED_TOKENS', 1),
+            protein_backbone_occ_cutoff=0.8,
+            protein_side_chain_occ_cutoff=0.5,
+            dna_backbone_occ_cutoff=0.8,
+            dna_side_chain_occ_cutoff=0.5,
+            rna_backbone_occ_cutoff=0.8,
+            rna_side_chain_occ_cutoff=0.5,
+            crop_large_structures=0,
+            batch_tokens=6000,
+            na_ref_atom="C1'"
+        )
+        
+        # Load and preprocess structure
+        assemblies, chain_sequences = pdb_dataset.load_for_structure_preprocessing({
+            'structure_path': structure_path
+        })
+        
+        if assemblies == "pass":
+            return {'id': struct_id, 'error': 'Failed to parse structure'}
+        
+        # Save assembly lengths
+        asmb_lengths = {}
+        asmb_interface_masks = {}
+        asmb_side_chain_interface_masks = {}
+        asmb_nearest_protein_side_chain_index = {}
+        asmb_base_pair_masks = {}
+        asmb_base_pair_index = {}
+        asmb_canonical_base_pair_masks = {}
+        asmb_canonical_base_pair_index = {}
+        
+        for assembly_id, out_dict in assemblies:
+            L = out_dict['macromolecule_L']
+            if L == 0:
+                continue
+            
+            asmb_lengths[assembly_id] = (
+                out_dict['macromolecule_L'],
+                out_dict['protein_L'],
+                out_dict['dna_L'],
+                out_dict['rna_L']
+            )
+            
+            # Simple interface masks (all zeros for now - full computation is expensive)
+            asmb_interface_masks[assembly_id] = np.zeros(L, dtype=np.int32)
+            asmb_side_chain_interface_masks[assembly_id] = np.zeros(L, dtype=np.int32)
+            asmb_nearest_protein_side_chain_index[assembly_id] = np.zeros(L, dtype=np.int64)
+            asmb_base_pair_masks[assembly_id] = np.zeros(L, dtype=np.int32)
+            asmb_base_pair_index[assembly_id] = np.zeros(L, dtype=np.int64)
+            asmb_canonical_base_pair_masks[assembly_id] = np.zeros(L, dtype=np.int32)
+            asmb_canonical_base_pair_index[assembly_id] = np.zeros(L, dtype=np.int64)
+        
+        if len(asmb_lengths) == 0:
+            return {'id': struct_id, 'error': 'No valid assemblies'}
+        
+        # Save preprocessed data
+        preprocessed_dir = os.path.join(output_dir, 'preprocessed')
+        os.makedirs(preprocessed_dir, exist_ok=True)
+        
+        # Save sequences
+        sequences_dir = os.path.join(preprocessed_dir, 'sequences')
+        os.makedirs(sequences_dir, exist_ok=True)
+        seq_df = pd.DataFrame(chain_sequences, columns=['chain_id', 'chain_type', 'sequence'])
+        seq_df.to_csv(os.path.join(sequences_dir, f'{struct_id}.csv'), index=False)
+        
+        # Save numpy arrays
+        for name, data in [
+            ('asmb_lengths', asmb_lengths),
+            ('asmb_interface_masks', asmb_interface_masks),
+            ('asmb_side_chain_interface_masks', asmb_side_chain_interface_masks),
+            ('asmb_nearest_protein_side_chain_index', asmb_nearest_protein_side_chain_index),
+            ('asmb_base_pair_masks', asmb_base_pair_masks),
+            ('asmb_base_pair_index', asmb_base_pair_index),
+            ('asmb_canonical_base_pair_masks', asmb_canonical_base_pair_masks),
+            ('asmb_canonical_base_pair_index', asmb_canonical_base_pair_index),
+        ]:
+            subdir = os.path.join(preprocessed_dir, name)
+            os.makedirs(subdir, exist_ok=True)
+            np.save(os.path.join(subdir, f'{struct_id}.npy'), data)
+        
+        return {
+            'id': struct_id,
+            'n_assemblies': len(asmb_lengths),
+            'total_residues': sum(v[0] for v in asmb_lengths.values()),
+            'error': None
+        }
+        
+    except Exception as e:
+        return {'id': struct_id, 'error': str(e)}
+
+
+def preprocess_structures_multiprocess(output_dir, num_workers=None):
+    """Preprocess all structures using multiple processes."""
+    
+    if num_workers is None:
+        num_workers = max(1, cpu_count() - 2)
+    
+    # Load filtered data
+    filtered_path = os.path.join(output_dir, 'filtered_structures.csv')
+    if not os.path.exists(filtered_path):
+        print(f"Error: {filtered_path} not found. Run 'scan' first.")
+        return
+    
+    df = pd.read_csv(filtered_path)
+    print(f"Preprocessing {len(df)} structures with {num_workers} workers...")
+    
+    # Load params
+    params = {'NA_SHARED_TOKENS': 1, 'EXCLUDE_RES': ['HOH', 'NA', 'CL', 'K', 'BR']}
+    
+    # Prepare arguments
+    args_list = [(row.to_dict(), output_dir, params) for _, row in df.iterrows()]
+    
+    results = []
+    errors = []
+    
+    with Pool(num_workers) as pool:
+        for result in tqdm(pool.imap_unordered(preprocess_single_structure, args_list),
+                           total=len(args_list), desc="Preprocessing"):
+            if result.get('error'):
+                errors.append(result)
+            else:
+                results.append(result)
+    
+    print(f"Successfully preprocessed: {len(results)}")
+    print(f"Errors: {len(errors)}")
+    
+    # Update dataframe with preprocessing paths
+    preprocessed_ids = {r['id'] for r in results}
+    df = df[df['id'].isin(preprocessed_ids)].copy()
+    
+    preprocessed_dir = os.path.join(output_dir, 'preprocessed')
+    df['sequences_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'sequences', f'{x}.csv'))
+    df['asmb_lengths_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_lengths', f'{x}.npy'))
+    df['asmb_interface_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_interface_masks', f'{x}.npy'))
+    df['asmb_side_chain_interface_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_side_chain_interface_masks', f'{x}.npy'))
+    df['asmb_nearest_protein_side_chain_index_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_nearest_protein_side_chain_index', f'{x}.npy'))
+    df['asmb_base_pair_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_base_pair_masks', f'{x}.npy'))
+    df['asmb_base_pair_index_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_base_pair_index', f'{x}.npy'))
+    df['asmb_canonical_base_pair_masks_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_canonical_base_pair_masks', f'{x}.npy'))
+    df['asmb_canonical_base_pair_index_path'] = df['id'].apply(lambda x: os.path.join(preprocessed_dir, 'asmb_canonical_base_pair_index', f'{x}.npy'))
+    
+    # Add training columns
+    df['dataset_name'] = 'diffusion_pdb'
+    df['sampling_probability'] = 1.0
+    df['ppm_paths'] = '[]'
+    
+    preprocessed_path = os.path.join(output_dir, 'preprocessed_structures.csv')
+    df.to_csv(preprocessed_path, index=False)
+    print(f"Saved preprocessed data to {preprocessed_path}")
+    
+    if errors:
+        error_path = os.path.join(output_dir, 'preprocess_errors.csv')
+        pd.DataFrame(errors).to_csv(error_path, index=False)
+
+
+# ============================================================================
+# Step 3: Sequence Clustering (Optional, requires CD-HIT)
+# ============================================================================
+
+def read_fasta(path):
+    """Read a FASTA file and return list of (id, sequence) tuples."""
+    with open(path, 'r') as f:
+        content = f.read().strip()
+    
+    entries = content[1:].split('\n>') if content.startswith('>') else content.split('\n>')
+    pairs = []
+    for entry in entries:
+        lines = entry.strip().split('\n')
+        header = lines[0].strip()
+        sequence = ''.join(lines[1:])
+        pairs.append((header, sequence))
+    return pairs
+
+
+def write_fasta(path, id_sequence_pairs):
+    """Write (id, sequence) pairs to a FASTA file."""
+    with open(path, 'w') as f:
+        for seq_id, sequence in id_sequence_pairs:
+            f.write(f">{seq_id}\n{sequence}\n")
+
+
+def read_cdhit_clusters(path):
+    """Read CD-HIT cluster file."""
+    with open(path, 'r') as f:
+        content = f.read().strip()
+    
+    clusters = {}
+    cluster_entries = content[1:].split('\n>') if content.startswith('>') else content.split('\n>')
+    
+    for entry in cluster_entries:
+        lines = entry.strip().split('\n')
+        cluster_header = lines[0]
+        cluster_id = int(cluster_header.strip().split(' ')[1])
+        
+        members = []
+        for line in lines[1:]:
+            if ', >' in line:
+                _, member_entry = line.strip().split(', >')
+                member_id = member_entry.split('...')[0]
+                members.append(member_id)
+        
+        clusters[cluster_id] = members
+    
+    return clusters
+
+
+def standardize_na_sequence(sequence):
+    """Standardize nucleic acid sequence: U->T, non-ACGT->X."""
+    mapping = {'A': 'A', 'C': 'C', 'G': 'G', 'T': 'T', 'U': 'T'}
+    return ''.join(mapping.get(c, 'X') for c in sequence.upper())
+
+
+def cluster_sequences(output_dir, cdhit_path=None, protein_identity=0.4, na_identity=0.8):
+    """Cluster protein and nucleic acid sequences using CD-HIT.
+    
+    Args:
+        output_dir: Output directory containing preprocessed data
+        cdhit_path: Path to CD-HIT installation directory
+        protein_identity: Sequence identity threshold for proteins (default 0.4)
+        na_identity: Sequence identity threshold for nucleic acids (default 0.8)
+    """
+    
+    if cdhit_path is None:
+        # Try to find CD-HIT in PATH
+        cdhit_path = shutil.which('cd-hit')
+        if cdhit_path:
+            cdhit_path = os.path.dirname(cdhit_path)
+    
+    if cdhit_path is None or not os.path.exists(cdhit_path):
+        print("Warning: CD-HIT not found. Skipping clustering.")
+        print("         Install CD-HIT and provide path with --cdhit_path")
+        print("         Or download from: https://github.com/weizhongli/cdhit/releases")
+        return None
+    
+    cdhit_bin = os.path.join(cdhit_path, 'cd-hit')
+    cdhit_est_bin = os.path.join(cdhit_path, 'cd-hit-est')
+    
+    if not os.path.exists(cdhit_bin):
+        cdhit_bin = shutil.which('cd-hit')
+    if not os.path.exists(cdhit_est_bin):
+        cdhit_est_bin = shutil.which('cd-hit-est')
+    
+    # Load preprocessed data
+    preprocessed_path = os.path.join(output_dir, 'preprocessed_structures.csv')
+    if not os.path.exists(preprocessed_path):
+        print(f"Error: {preprocessed_path} not found. Run 'preprocess' first.")
+        return None
+    
+    df = pd.read_csv(preprocessed_path)
+    print(f"Clustering sequences from {len(df)} structures...")
+    
+    clustering_dir = os.path.join(output_dir, 'clustering')
+    os.makedirs(clustering_dir, exist_ok=True)
+    
+    # Gather all sequences
+    protein_sequences = set()
+    na_sequences = set()
+    
+    for seq_path in tqdm(df['sequences_path'], desc="Gathering sequences"):
+        if os.path.exists(seq_path):
+            seq_df = pd.read_csv(seq_path)
+            for chain_type, sequence in zip(seq_df['chain_type'], seq_df['sequence']):
+                if chain_type == 'polypeptide(L)':
+                    protein_sequences.add(sequence)
+                elif chain_type in ['polydeoxyribonucleotide', 'polyribonucleotide', 
+                                     'polydeoxyribonucleotide/polyribonucleotide hybrid']:
+                    na_sequences.add(sequence)
+    
+    print(f"  Unique protein sequences: {len(protein_sequences)}")
+    print(f"  Unique nucleic acid sequences: {len(na_sequences)}")
+    
+    # Write FASTA files
+    protein_fasta = os.path.join(clustering_dir, 'all_protein_sequences.fa')
+    na_fasta = os.path.join(clustering_dir, 'all_na_sequences.fa')
+    na_std_fasta = os.path.join(clustering_dir, 'all_na_sequences_std.fa')
+    
+    write_fasta(protein_fasta, enumerate(protein_sequences))
+    write_fasta(na_fasta, enumerate(na_sequences))
+    
+    # Write standardized NA sequences
+    na_std_sequences = [standardize_na_sequence(s) for s in na_sequences]
+    write_fasta(na_std_fasta, enumerate(na_std_sequences))
+    
+    # Run CD-HIT for proteins
+    protein_clusters = {}
+    if cdhit_bin and len(protein_sequences) > 0:
+        print("\nClustering protein sequences with CD-HIT...")
+        protein_out = os.path.join(clustering_dir, 'protein_clusters')
+        
+        # Determine word size based on identity threshold
+        word_size = 2 if protein_identity < 0.5 else (3 if protein_identity < 0.6 else 5)
+        
+        cmd = [
+            cdhit_bin,
+            '-i', protein_fasta,
+            '-o', protein_out,
+            '-c', str(protein_identity),
+            '-n', str(word_size),
+            '-d', '0',
+            '-M', '16000',
+            '-T', '0',
+            '-aL', '0.9',
+            '-aS', '0.9'
+        ]
+        
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            protein_clusters = read_cdhit_clusters(protein_out + '.clstr')
+            print(f"  Protein clusters: {len(protein_clusters)}")
+        except Exception as e:
+            print(f"  Warning: Protein clustering failed: {e}")
+    
+    # Run CD-HIT-EST for nucleic acids
+    na_clusters = {}
+    if cdhit_est_bin and len(na_sequences) > 0:
+        print("\nClustering nucleic acid sequences with CD-HIT-EST...")
+        na_out = os.path.join(clustering_dir, 'na_clusters')
+        
+        word_size = 4 if na_identity >= 0.8 else 3
+        
+        cmd = [
+            cdhit_est_bin,
+            '-i', na_std_fasta,
+            '-o', na_out,
+            '-c', str(na_identity),
+            '-n', str(word_size),
+            '-d', '0',
+            '-M', '16000',
+            '-T', '0',
+            '-l', '4',
+            '-aL', '0.9',
+            '-aS', '0.9'
+        ]
+        
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            na_clusters = read_cdhit_clusters(na_out + '.clstr')
+            print(f"  Nucleic acid clusters: {len(na_clusters)}")
+        except Exception as e:
+            print(f"  Warning: NA clustering failed: {e}")
+    
+    # Create sequence -> cluster mappings
+    protein_seq_to_cluster = {}
+    protein_seq_list = list(protein_sequences)
+    for cluster_id, members in protein_clusters.items():
+        for member in members:
+            try:
+                idx = int(member)
+                protein_seq_to_cluster[protein_seq_list[idx]] = cluster_id
+            except:
+                pass
+    
+    na_seq_to_cluster = {}
+    na_seq_list = list(na_sequences)
+    na_std_list = [standardize_na_sequence(s) for s in na_seq_list]
+    std_to_cluster = {}
+    for cluster_id, members in na_clusters.items():
+        for member in members:
+            try:
+                idx = int(member)
+                std_to_cluster[na_std_list[idx]] = cluster_id
+            except:
+                pass
+    
+    for seq in na_seq_list:
+        std_seq = standardize_na_sequence(seq)
+        if std_seq in std_to_cluster:
+            na_seq_to_cluster[seq] = std_to_cluster[std_seq]
+    
+    # Save cluster mappings
+    np.save(os.path.join(clustering_dir, 'protein_seq_to_cluster.npy'), protein_seq_to_cluster)
+    np.save(os.path.join(clustering_dir, 'na_seq_to_cluster.npy'), na_seq_to_cluster)
+    
+    print(f"\nClustering complete. Results saved to {clustering_dir}")
+    
+    return {
+        'protein_seq_to_cluster': protein_seq_to_cluster,
+        'na_seq_to_cluster': na_seq_to_cluster,
+        'n_protein_clusters': len(protein_clusters),
+        'n_na_clusters': len(na_clusters)
+    }
+
+
+# ============================================================================
+# Step 4: Train/Valid/Test Split
+# ============================================================================
+
+def create_train_valid_split(output_dir, valid_fraction=0.1, test_fraction=0.0, 
+                             seed=42, use_clustering=False):
+    """Create train/valid/test split.
+    
+    Args:
+        output_dir: Output directory
+        valid_fraction: Fraction for validation set
+        test_fraction: Fraction for test set
+        seed: Random seed
+        use_clustering: Whether to use sequence clustering for split (prevents data leakage)
+    """
+    
+    preprocessed_path = os.path.join(output_dir, 'preprocessed_structures.csv')
+    if not os.path.exists(preprocessed_path):
+        print(f"Error: {preprocessed_path} not found. Run 'preprocess' first.")
+        return
+    
+    df = pd.read_csv(preprocessed_path)
+    print(f"Splitting {len(df)} structures...")
+    print(f"  Valid fraction: {valid_fraction}")
+    print(f"  Test fraction: {test_fraction}")
+    print(f"  Train fraction: {1 - valid_fraction - test_fraction}")
+    
+    np.random.seed(seed)
+    
+    if use_clustering:
+        # Use cluster-based splitting to prevent data leakage
+        clustering_dir = os.path.join(output_dir, 'clustering')
+        na_cluster_path = os.path.join(clustering_dir, 'na_seq_to_cluster.npy')
+        
+        if os.path.exists(na_cluster_path):
+            print("\nUsing cluster-based splitting (prevents data leakage)...")
+            na_seq_to_cluster = np.load(na_cluster_path, allow_pickle=True).item()
+            
+            # Get cluster IDs for each structure
+            structure_clusters = {}
+            for idx, seq_path in enumerate(df['sequences_path']):
+                if os.path.exists(seq_path):
+                    seq_df = pd.read_csv(seq_path)
+                    clusters = set()
+                    for chain_type, sequence in zip(seq_df['chain_type'], seq_df['sequence']):
+                        if chain_type in ['polydeoxyribonucleotide', 'polyribonucleotide', 
+                                          'polydeoxyribonucleotide/polyribonucleotide hybrid']:
+                            if sequence in na_seq_to_cluster:
+                                clusters.add(na_seq_to_cluster[sequence])
+                    structure_clusters[idx] = clusters
+            
+            # Get all unique clusters
+            all_clusters = set()
+            for clusters in structure_clusters.values():
+                all_clusters.update(clusters)
+            all_clusters = list(all_clusters)
+            np.random.shuffle(all_clusters)
+            
+            n_test = int(len(all_clusters) * test_fraction)
+            n_valid = int(len(all_clusters) * valid_fraction)
+            
+            test_clusters = set(all_clusters[:n_test])
+            valid_clusters = set(all_clusters[n_test:n_test + n_valid])
+            train_clusters = set(all_clusters[n_test + n_valid:])
+            
+            # Assign structures to splits based on cluster membership
+            test_indices = []
+            valid_indices = []
+            train_indices = []
+            
+            for idx, clusters in structure_clusters.items():
+                if clusters & test_clusters:
+                    test_indices.append(idx)
+                elif clusters & valid_clusters:
+                    valid_indices.append(idx)
+                else:
+                    train_indices.append(idx)
+            
+            print(f"  Cluster-based split:")
+            print(f"    Train clusters: {len(train_clusters)}, Valid clusters: {len(valid_clusters)}, Test clusters: {len(test_clusters)}")
+        else:
+            print("Warning: Clustering data not found, falling back to random split")
+            use_clustering = False
+    
+    if not use_clustering:
+        # Random split
+        indices = np.random.permutation(len(df))
+        n_test = int(len(df) * test_fraction)
+        n_valid = int(len(df) * valid_fraction)
+        
+        test_indices = indices[:n_test]
+        valid_indices = indices[n_test:n_test + n_valid]
+        train_indices = indices[n_test + n_valid:]
+    
+    train_df = df.iloc[train_indices].copy()
+    valid_df = df.iloc[valid_indices].copy()
+    test_df = df.iloc[test_indices].copy() if len(test_indices) > 0 else pd.DataFrame()
+    
+    # Save
+    train_path = os.path.join(output_dir, 'train.csv')
+    valid_path = os.path.join(output_dir, 'valid.csv')
+    test_path = os.path.join(output_dir, 'test.csv')
+    all_path = os.path.join(output_dir, 'all.csv')
+    
+    train_df.to_csv(train_path, index=False)
+    valid_df.to_csv(valid_path, index=False)
+    if len(test_df) > 0:
+        test_df.to_csv(test_path, index=False)
+    df.to_csv(all_path, index=False)
+    
+    print(f"\nSplit complete:")
+    print(f"  Train: {len(train_df)} -> {train_path}")
+    print(f"  Valid: {len(valid_df)} -> {valid_path}")
+    if len(test_df) > 0:
+        print(f"  Test:  {len(test_df)} -> {test_path}")
+    
+    # Print statistics
+    print("\nDataset statistics:")
+    print(f"  Total structures: {len(df)}")
+    if 'has_protein' in df.columns:
+        print(f"  With protein: {df['has_protein'].sum()}")
+    if 'has_dna' in df.columns:
+        print(f"  With DNA: {df['has_dna'].sum()}")
+    if 'has_rna' in df.columns:
+        print(f"  With RNA: {df['has_rna'].sum()}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Full dataset preparation for NA-MPNN Diffusion (满血版)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Quick test with small sample
+  python prepare_diffusion_dataset_full.py all \\
+      --mmcif_dir pdb_mmcif --output_dir datasets/test \\
+      --sample_size 1000 --require_na --num_workers 16
+
+  # Full PDB with nucleic acids only
+  python prepare_diffusion_dataset_full.py all \\
+      --mmcif_dir pdb_mmcif --output_dir datasets/na_full \\
+      --require_na --num_workers 32
+
+  # Step-by-step with clustering
+  python prepare_diffusion_dataset_full.py scan --mmcif_dir pdb_mmcif --output_dir out --num_workers 16
+  python prepare_diffusion_dataset_full.py preprocess --output_dir out --num_workers 16
+  python prepare_diffusion_dataset_full.py cluster --output_dir out --cdhit_path /path/to/cdhit
+  python prepare_diffusion_dataset_full.py split --output_dir out --use_clustering
+"""
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+    
+    # Scan command
+    scan_parser = subparsers.add_parser('scan', help='Scan PDB database (Step 1)')
+    scan_parser.add_argument('--mmcif_dir', type=str, required=True, 
+                             help='Path to mmCIF files directory')
+    scan_parser.add_argument('--output_dir', type=str, required=True,
+                             help='Output directory for results')
+    scan_parser.add_argument('--num_workers', type=int, default=None,
+                             help='Number of parallel workers (default: CPU count - 2)')
+    scan_parser.add_argument('--sample_size', type=int, default=None,
+                             help='Sample N structures for testing (default: use all)')
+    scan_parser.add_argument('--require_na', action='store_true',
+                             help='Only keep structures with nucleic acids')
+    scan_parser.add_argument('--require_protein', action='store_true',
+                             help='Only keep structures with proteins')
+    scan_parser.add_argument('--min_heavy_atoms', type=int, default=100,
+                             help='Minimum number of heavy atoms (default: 100)')
+    scan_parser.add_argument('--min_coverage', type=float, default=0.9,
+                             help='Minimum atom coverage (default: 0.9)')
+    scan_parser.add_argument('--max_resolution', type=float, default=3.5,
+                             help='Maximum resolution in Å (default: 3.5)')
+    scan_parser.add_argument('--max_unknown', type=int, default=20,
+                             help='Maximum unknown residues (default: 20)')
+    
+    # Preprocess command
+    preprocess_parser = subparsers.add_parser('preprocess', help='Preprocess structures (Step 2)')
+    preprocess_parser.add_argument('--output_dir', type=str, required=True)
+    preprocess_parser.add_argument('--num_workers', type=int, default=None)
+    
+    # Cluster command
+    cluster_parser = subparsers.add_parser('cluster', help='Cluster sequences with CD-HIT (Step 3, optional)')
+    cluster_parser.add_argument('--output_dir', type=str, required=True)
+    cluster_parser.add_argument('--cdhit_path', type=str, default=None,
+                                help='Path to CD-HIT installation directory')
+    cluster_parser.add_argument('--protein_identity', type=float, default=0.4,
+                                help='Protein clustering identity threshold (default: 0.4)')
+    cluster_parser.add_argument('--na_identity', type=float, default=0.8,
+                                help='Nucleic acid clustering identity threshold (default: 0.8)')
+    
+    # Split command
+    split_parser = subparsers.add_parser('split', help='Create train/valid/test split (Step 4)')
+    split_parser.add_argument('--output_dir', type=str, required=True)
+    split_parser.add_argument('--valid_fraction', type=float, default=0.1,
+                              help='Validation set fraction (default: 0.1)')
+    split_parser.add_argument('--test_fraction', type=float, default=0.0,
+                              help='Test set fraction (default: 0.0)')
+    split_parser.add_argument('--seed', type=int, default=42)
+    split_parser.add_argument('--use_clustering', action='store_true',
+                              help='Use cluster-based split (prevents data leakage)')
+    
+    # All-in-one command
+    all_parser = subparsers.add_parser('all', help='Run all steps (scan + preprocess + split)')
+    all_parser.add_argument('--mmcif_dir', type=str, required=True)
+    all_parser.add_argument('--output_dir', type=str, required=True)
+    all_parser.add_argument('--num_workers', type=int, default=None)
+    all_parser.add_argument('--sample_size', type=int, default=None)
+    all_parser.add_argument('--require_na', action='store_true')
+    all_parser.add_argument('--require_protein', action='store_true')
+    all_parser.add_argument('--min_heavy_atoms', type=int, default=100)
+    all_parser.add_argument('--min_coverage', type=float, default=0.9)
+    all_parser.add_argument('--max_resolution', type=float, default=3.5)
+    all_parser.add_argument('--valid_fraction', type=float, default=0.1)
+    all_parser.add_argument('--test_fraction', type=float, default=0.0)
+    all_parser.add_argument('--cdhit_path', type=str, default=None,
+                            help='Path to CD-HIT (enables clustering)')
+    
+    args = parser.parse_args()
+    
+    if args.command == 'scan':
+        df = scan_database_multiprocess(
+            args.mmcif_dir, args.output_dir, 
+            num_workers=args.num_workers,
+            sample_size=args.sample_size
+        )
+        df = filter_scanned_data(
+            df, 
+            min_heavy_atoms=args.min_heavy_atoms,
+            min_coverage=args.min_coverage,
+            max_resolution=args.max_resolution,
+            max_unknown_residues=args.max_unknown,
+            require_na=args.require_na,
+            require_protein=args.require_protein
+        )
+        filtered_path = os.path.join(args.output_dir, 'filtered_structures.csv')
+        df.to_csv(filtered_path, index=False)
+        print(f"\nSaved filtered data to {filtered_path}")
+        
+    elif args.command == 'preprocess':
+        preprocess_structures_multiprocess(args.output_dir, args.num_workers)
+        
+    elif args.command == 'cluster':
+        cluster_sequences(args.output_dir, args.cdhit_path, 
+                          args.protein_identity, args.na_identity)
+        
+    elif args.command == 'split':
+        create_train_valid_split(args.output_dir, args.valid_fraction, 
+                                 args.test_fraction, args.seed, args.use_clustering)
+        
+    elif args.command == 'all':
+        print("="*70)
+        print("Step 1/4: Scanning PDB database (multi-process)")
+        print("="*70)
+        df = scan_database_multiprocess(
+            args.mmcif_dir, args.output_dir,
+            num_workers=args.num_workers,
+            sample_size=args.sample_size
+        )
+        df = filter_scanned_data(
+            df, 
+            min_heavy_atoms=args.min_heavy_atoms,
+            min_coverage=args.min_coverage,
+            max_resolution=args.max_resolution,
+            require_na=args.require_na,
+            require_protein=args.require_protein
+        )
+        filtered_path = os.path.join(args.output_dir, 'filtered_structures.csv')
+        df.to_csv(filtered_path, index=False)
+        
+        print("\n" + "="*70)
+        print("Step 2/4: Preprocessing structures (multi-process)")
+        print("="*70)
+        preprocess_structures_multiprocess(args.output_dir, args.num_workers)
+        
+        use_clustering = False
+        if args.cdhit_path:
+            print("\n" + "="*70)
+            print("Step 3/4: Clustering sequences (CD-HIT)")
+            print("="*70)
+            result = cluster_sequences(args.output_dir, args.cdhit_path)
+            if result:
+                use_clustering = True
+        else:
+            print("\n" + "="*70)
+            print("Step 3/4: Clustering (skipped, no CD-HIT path provided)")
+            print("="*70)
+        
+        print("\n" + "="*70)
+        print("Step 4/4: Creating train/valid/test split")
+        print("="*70)
+        create_train_valid_split(args.output_dir, args.valid_fraction, 
+                                 args.test_fraction, use_clustering=use_clustering)
+        
+        print("\n" + "="*70)
+        print("✓ COMPLETE!")
+        print("="*70)
+        print(f"\nDataset ready! Update your config with:")
+        print(f'  "DF_PATH_TRAIN": "{os.path.abspath(os.path.join(args.output_dir, "train.csv"))}",')
+        print(f'  "DF_PATH_VALID": "{os.path.abspath(os.path.join(args.output_dir, "valid.csv"))}",')
+        if args.test_fraction > 0:
+            print(f'  "DF_PATH_TEST": "{os.path.abspath(os.path.join(args.output_dir, "test.csv"))}",')
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

scripts/preprocess_dataset.json

@@ -0,0 +1,23 @@
+{
+"PARSE_PROTEIN": 1,
+"PARSE_DNA": 1,
+"PARSE_RNA": 1,
+"PARSE_RNA_AS_DNA": 0,
+"NA_SHARED_TOKENS": 1,
+"NA_REF_ATOM": "C1'",
+"INCLUDE_PRED_NA_N": 1,
+"PROTEIN_BACKBONE_OCC_CUTOFF" : 0.8,
+"PROTEIN_SIDE_CHAIN_OCC_CUTOFF": 0.5,
+"DNA_BACKBONE_OCC_CUTOFF" : 0.8,
+"DNA_SIDE_CHAIN_OCC_CUTOFF": 0.5,
+"RNA_BACKBONE_OCC_CUTOFF" : 0.8,
+"RNA_SIDE_CHAIN_OCC_CUTOFF": 0.5,
+"LIGAND_OCC_CUTOFF": 0.01,
+"BATCH_TOKENS" : 6000,
+"EXCLUDE_RES" : ["HOH", "NA", "CL", "K", "BR"],
+"RANDOMIZE_NMR_MODEL" : 0,
+"CROP_LARGE_STRUCTURES" : 0,
+"MIN_OVERLAP_LENGTH": 5,
+"NUM_NEIGHBORS": 48,
+"ATOMS_TO_LOAD" : "all"
+}

scripts/preprocess_dataset.py

@@ -0,0 +1,1160 @@
+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

scripts/preprocess_dataset.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+#SBATCH -p cpu
+#SBATCH --mem=32g
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH -t 0-02:00:00
+
+input_csv_path=$1
+output_directory=$2
+modulo=$((SLURM_ARRAY_TASK_MAX + 1))
+remainder=$SLURM_ARRAY_TASK_ID
+
+apptainer exec /software/containers/users/akubaney/mpnn.sif python ./preprocess_dataset.py $input_csv_path $output_directory $modulo $remainder

splits/design_evaluation_pseudoknot_test.json

@@ -0,0 +1,12 @@
+[
+    "1drz",
+    "2m8k",
+    "2miy",
+    "3q3z",
+    "4oqu",
+    "4plx",
+    "4znp",
+    "7kd1",
+    "7kga",
+    "7qr4"
+]

splits/design_evaluation_rna_monomer_test.json

@@ -0,0 +1,65 @@
+[
+    "1a9l",
+    "1bvj",
+    "1d0u",
+    "1fmn",
+    "1k6g",
+    "1kpy",
+    "1kpz",
+    "1ldz",
+    "1rfr",
+    "1u3k",
+    "1y26",
+    "2a9l",
+    "2fdt",
+    "2ldz",
+    "2m12",
+    "2m8k",
+    "2miy",
+    "2n6w",
+    "2n7x",
+    "2nbx",
+    "2rvo",
+    "3la5",
+    "3sd3",
+    "4l81",
+    "4lvv",
+    "4lvw",
+    "4lvx",
+    "4lvy",
+    "4lvz",
+    "4lw0",
+    "4lx5",
+    "4lx6",
+    "4oqu",
+    "4qk9",
+    "4tzx",
+    "4tzy",
+    "4xnr",
+    "5m0h",
+    "5swe",
+    "5tpy",
+    "5uza",
+    "5v16",
+    "5v17",
+    "6fz0",
+    "6hag",
+    "6q57",
+    "6ugi",
+    "6ugj",
+    "6xb7",
+    "7kd1",
+    "7lyf",
+    "7rwr",
+    "7u4a",
+    "7uga",
+    "7umd",
+    "7wia",
+    "8cq1",
+    "8tjq",
+    "8tjv",
+    "8tjx",
+    "8upy",
+    "9blm",
+    "9cxf"
+]

splits/design_test.json

@@ -0,0 +1,1375 @@
+[
+    "115d",
+    "139d",
+    "1a9l",
+    "1afx",
+    "1ajl",
+    "1ajt",
+    "1au7",
+    "1aul",
+    "1ax6",
+    "1b23",
+    "1b72",
+    "1bce",
+    "1bdh",
+    "1bdi",
+    "1bn9",
+    "1bp7",
+    "1br3",
+    "1bvj",
+    "1c9s",
+    "1cez",
+    "1cjg",
+    "1cvx",
+    "1cvy",
+    "1d0t",
+    "1d0u",
+    "1d83",
+    "1d8y",
+    "1da4",
+    "1da5",
+    "1dgc",
+    "1dgo",
+    "1dh3",
+    "1dk6",
+    "1dk9",
+    "1dnk",
+    "1drz",
+    "1duh",
+    "1dul",
+    "1duq",
+    "1ea4",
+    "1efa",
+    "1elh",
+    "1emq",
+    "1exy",
+    "1ezn",
+    "1f2i",
+    "1f9l",
+    "1flo",
+    "1fmn",
+    "1fqp",
+    "1h38",
+    "1hf0",
+    "1hq1",
+    "1huz",
+    "1hys",
+    "1i34",
+    "1i3j",
+    "1ibl",
+    "1ibm",
+    "1idx",
+    "1ii1",
+    "1ikk",
+    "1j46",
+    "1j47",
+    "1j5k",
+    "1j9h",
+    "1jbr",
+    "1jfs",
+    "1jft",
+    "1jjp",
+    "1jkp",
+    "1jkq",
+    "1jox",
+    "1jp0",
+    "1jtl",
+    "1juu",
+    "1jve",
+    "1k2g",
+    "1k2z",
+    "1k6g",
+    "1kpy",
+    "1kpz",
+    "1kq2",
+    "1ksb",
+    "1l1m",
+    "1l2b",
+    "1ldz",
+    "1lfu",
+    "1lmv",
+    "1lnt",
+    "1lpw",
+    "1lvs",
+    "1m3h",
+    "1m5x",
+    "1m6x",
+    "1mji",
+    "1mnm",
+    "1mzp",
+    "1n4e",
+    "1n53",
+    "1na2",
+    "1ngm",
+    "1ngo",
+    "1ngu",
+    "1njx",
+    "1nyd",
+    "1o3q",
+    "1o4x",
+    "1old",
+    "1p1y",
+    "1p4e",
+    "1p7d",
+    "1pgl",
+    "1ph5",
+    "1ph7",
+    "1pp7",
+    "1pp8",
+    "1puf",
+    "1pyi",
+    "1pyj",
+    "1qln",
+    "1qp0",
+    "1qp4",
+    "1qp7",
+    "1qpz",
+    "1qqa",
+    "1qqb",
+    "1qum",
+    "1r8d",
+    "1rfr",
+    "1rio",
+    "1rng",
+    "1s0v",
+    "1s76",
+    "1sds",
+    "1sj3",
+    "1sj4",
+    "1sjf",
+    "1sks",
+    "1skw",
+    "1sl0",
+    "1sl1",
+    "1sl2",
+    "1sm5",
+    "1szy",
+    "1t4i",
+    "1t9i",
+    "1t9j",
+    "1tez",
+    "1tut",
+    "1u0b",
+    "1u3e",
+    "1u3k",
+    "1u4b",
+    "1vbx",
+    "1vby",
+    "1vbz",
+    "1vc0",
+    "1vc5",
+    "1vc6",
+    "1vj4",
+    "1vpw",
+    "1w0u",
+    "1wd0",
+    "1wvl",
+    "1x9c",
+    "1x9k",
+    "1x9n",
+    "1xs9",
+    "1y26",
+    "1yui",
+    "1yuj",
+    "1yvp",
+    "1yz9",
+    "1z1c",
+    "1z8v",
+    "1zdi",
+    "1zft",
+    "1zfv",
+    "1zfx",
+    "1zje",
+    "1zjf",
+    "1zjg",
+    "1zx4",
+    "1zx7",
+    "1zyf",
+    "1zyg",
+    "1zyh",
+    "1zz5",
+    "272d",
+    "280d",
+    "284d",
+    "2a04",
+    "2a8v",
+    "2a9l",
+    "2aor",
+    "2aqy",
+    "2b2e",
+    "2b2g",
+    "2b6g",
+    "2b7g",
+    "2bcu",
+    "2bcy",
+    "2bcz",
+    "2bjc",
+    "2bq5",
+    "2c62",
+    "2c9l",
+    "2cgp",
+    "2d2k",
+    "2d2l",
+    "2d6f",
+    "2dgc",
+    "2ere",
+    "2erg",
+    "2err",
+    "2fdt",
+    "2ff0",
+    "2fgp",
+    "2fio",
+    "2fjw",
+    "2fjx",
+    "2flc",
+    "2fll",
+    "2fln",
+    "2fr4",
+    "2gcs",
+    "2gcv",
+    "2gtt",
+    "2h0s",
+    "2h0w",
+    "2h0x",
+    "2h0z",
+    "2h7g",
+    "2hk4",
+    "2hkb",
+    "2hkc",
+    "2ho6",
+    "2ho7",
+    "2i3p",
+    "2i3q",
+    "2ihn",
+    "2irf",
+    "2ixz",
+    "2jlw",
+    "2jpa",
+    "2kei",
+    "2ky8",
+    "2l13",
+    "2l3c",
+    "2l3j",
+    "2l6i",
+    "2ldz",
+    "2ll9",
+    "2llj",
+    "2lo8",
+    "2loa",
+    "2m12",
+    "2m1o",
+    "2m8k",
+    "2mav",
+    "2mb2",
+    "2mft",
+    "2miy",
+    "2moe",
+    "2n0q",
+    "2n3o",
+    "2n6w",
+    "2n7x",
+    "2n82",
+    "2nbx",
+    "2nny",
+    "2np2",
+    "2npy",
+    "2npz",
+    "2o32",
+    "2o33",
+    "2o4i",
+    "2o4y",
+    "2o8k",
+    "2o9l",
+    "2oih",
+    "2oj3",
+    "2ost",
+    "2oue",
+    "2p7d",
+    "2p7e",
+    "2p7f",
+    "2pkv",
+    "2pl4",
+    "2pl8",
+    "2plb",
+    "2plo",
+    "2prt",
+    "2pua",
+    "2pub",
+    "2puc",
+    "2pud",
+    "2pue",
+    "2puf",
+    "2pug",
+    "2pxb",
+    "2pxd",
+    "2pxe",
+    "2pxf",
+    "2pxk",
+    "2pxl",
+    "2pxp",
+    "2pxq",
+    "2pxt",
+    "2pxu",
+    "2pxv",
+    "2py5",
+    "2qhb",
+    "2qnc",
+    "2r5y",
+    "2r5z",
+    "2r9l",
+    "2rba",
+    "2rpk",
+    "2rvo",
+    "2v3l",
+    "2v6e",
+    "2vah",
+    "2vai",
+    "2vbl",
+    "2vbn",
+    "2vum",
+    "2wiw",
+    "2wtf",
+    "2wtu",
+    "2x1a",
+    "2x1f",
+    "2xct",
+    "2xfm",
+    "2xo7",
+    "2xro",
+    "2y95",
+    "2yvh",
+    "2z2g",
+    "2z2h",
+    "2z33",
+    "2z74",
+    "2z75",
+    "357d",
+    "361d",
+    "364d",
+    "3adi",
+    "3agv",
+    "3b4a",
+    "3b4b",
+    "3b4c",
+    "3bep",
+    "3bse",
+    "3bx2",
+    "3c0w",
+    "3co6",
+    "3coa",
+    "3d2s",
+    "3dh3",
+    "3fd2",
+    "3foz",
+    "3gm7",
+    "3gs1",
+    "3gs8",
+    "3hax",
+    "3hou",
+    "3hov",
+    "3htx",
+    "3hxo",
+    "3hxq",
+    "3igt",
+    "3imb",
+    "3jce",
+    "3jra",
+    "3k49",
+    "3k4x",
+    "3k5y",
+    "3k5z",
+    "3l1p",
+    "3l2p",
+    "3la5",
+    "3loa",
+    "3lqx",
+    "3moj",
+    "3mr5",
+    "3mr6",
+    "3mx4",
+    "3mxa",
+    "3nic",
+    "3ogd",
+    "3os0",
+    "3pih",
+    "3pky",
+    "3pu0",
+    "3pu1",
+    "3q2t",
+    "3q3z",
+    "3qg9",
+    "3qgb",
+    "3qgc",
+    "3r1h",
+    "3r1l",
+    "3r7p",
+    "3sd3",
+    "3sq2",
+    "3ssf",
+    "3sun",
+    "3suq",
+    "3szq",
+    "3t5q",
+    "3tzr",
+    "3u6y",
+    "3ufd",
+    "3ugo",
+    "3ugp",
+    "3uo7",
+    "3uob",
+    "3ut9",
+    "3v72",
+    "3va3",
+    "3vw4",
+    "3wbm",
+    "3wgi",
+    "3zvk",
+    "414d",
+    "431d",
+    "432d",
+    "4a3b",
+    "4a3c",
+    "4a3d",
+    "4a3e",
+    "4a3f",
+    "4a3g",
+    "4a3k",
+    "4a3l",
+    "4a93",
+    "4aij",
+    "4aqu",
+    "4aqy",
+    "4ati",
+    "4av1",
+    "4b3m",
+    "4b3r",
+    "4b3s",
+    "4b3t",
+    "4bac",
+    "4by7",
+    "4bzv",
+    "4cgz",
+    "4dr5",
+    "4e7l",
+    "4f41",
+    "4f43",
+    "4f6n",
+    "4fgn",
+    "4fxd",
+    "4fyd",
+    "4g6r",
+    "4gck",
+    "4hqe",
+    "4hsb",
+    "4ig8",
+    "4iqx",
+    "4ir1",
+    "4ir9",
+    "4irc",
+    "4ird",
+    "4irk",
+    "4ivz",
+    "4ix7",
+    "4jv5",
+    "4k0k",
+    "4k1g",
+    "4k4s",
+    "4k4t",
+    "4kb0",
+    "4kb1",
+    "4ki2",
+    "4knq",
+    "4kzd",
+    "4kze",
+    "4l81",
+    "4lmg",
+    "4lnt",
+    "4lox",
+    "4lsk",
+    "4lt8",
+    "4lvv",
+    "4lvw",
+    "4lvx",
+    "4lvy",
+    "4lvz",
+    "4lw0",
+    "4lx5",
+    "4lx6",
+    "4m59",
+    "4meg",
+    "4meh",
+    "4mfa",
+    "4mgm",
+    "4mgn",
+    "4mky",
+    "4noe",
+    "4oav",
+    "4oe1",
+    "4oji",
+    "4oqu",
+    "4p97",
+    "4pjo",
+    "4plx",
+    "4prf",
+    "4q9q",
+    "4q9r",
+    "4qk9",
+    "4qpq",
+    "4qtr",
+    "4qyz",
+    "4qz8",
+    "4qz9",
+    "4qzc",
+    "4qzf",
+    "4r8a",
+    "4r8u",
+    "4rdx",
+    "4rec",
+    "4rhd",
+    "4ri9",
+    "4rtn",
+    "4rto",
+    "4rtp",
+    "4rwn",
+    "4rwo",
+    "4rwp",
+    "4s3n",
+    "4tue",
+    "4tzx",
+    "4tzy",
+    "4u7c",
+    "4umk",
+    "4usg",
+    "4v19",
+    "4v5a",
+    "4v5j",
+    "4v8d",
+    "4v8e",
+    "4v8f",
+    "4v8q",
+    "4v9n",
+    "4w5q",
+    "4wrt",
+    "4wsa",
+    "4wsb",
+    "4wtc",
+    "4wul",
+    "4x0g",
+    "4xnr",
+    "4xvl",
+    "4xvm",
+    "4yfu",
+    "4z2c",
+    "4znp",
+    "5a0m",
+    "5aj0",
+    "5amq",
+    "5amr",
+    "5b2o",
+    "5b2p",
+    "5b2q",
+    "5bng",
+    "5cdm",
+    "5cdn",
+    "5cg9",
+    "5cl3",
+    "5cl4",
+    "5cl5",
+    "5cl6",
+    "5cl7",
+    "5cl8",
+    "5cl9",
+    "5cla",
+    "5clc",
+    "5cld",
+    "5cle",
+    "5cnr",
+    "5cpi",
+    "5cpj",
+    "5cpk",
+    "5cv2",
+    "5d2q",
+    "5d4b",
+    "5d9i",
+    "5dhb",
+    "5do4",
+    "5dqt",
+    "5dv7",
+    "5e17",
+    "5e18",
+    "5e54",
+    "5e5s",
+    "5e63",
+    "5ean",
+    "5eyb",
+    "5f7q",
+    "5gse",
+    "5h1k",
+    "5h1l",
+    "5h3u",
+    "5haw",
+    "5hbu",
+    "5hbw",
+    "5hr4",
+    "5hrb",
+    "5hsw",
+    "5id6",
+    "5ip2",
+    "5jea",
+    "5k58",
+    "5k5r",
+    "5k7c",
+    "5k7d",
+    "5k7e",
+    "5kub",
+    "5l7c",
+    "5lxu",
+    "5m0h",
+    "5m3h",
+    "5mvp",
+    "5n90",
+    "5npp",
+    "5ns3",
+    "5ns4",
+    "5oc6",
+    "5swd",
+    "5swe",
+    "5szx",
+    "5t2h",
+    "5t5h",
+    "5t7b",
+    "5tjg",
+    "5tkz",
+    "5tpy",
+    "5u30",
+    "5u31",
+    "5ud5",
+    "5ulw",
+    "5ulx",
+    "5ux3",
+    "5uz6",
+    "5uza",
+    "5v0o",
+    "5v16",
+    "5v17",
+    "5v6x",
+    "5v9z",
+    "5vfx",
+    "5vl9",
+    "5w2a",
+    "5w6w",
+    "5wzg",
+    "5wzh",
+    "5wzi",
+    "5wzj",
+    "5wzk",
+    "5x2g",
+    "5x2h",
+    "5xog",
+    "5xs0",
+    "5xvp",
+    "5xy3",
+    "5y7g",
+    "5y7q",
+    "5yeh",
+    "5ytx",
+    "5ywt",
+    "5yzy",
+    "5yzz",
+    "5z6w",
+    "5z98",
+    "5zdz",
+    "5ze0",
+    "5ze1",
+    "5ze2",
+    "5zg9",
+    "5zjq",
+    "5zjr",
+    "5zjs",
+    "5zk1",
+    "5zko",
+    "5zmc",
+    "5zsd",
+    "5zsl",
+    "5zux",
+    "5zx2",
+    "5zyt",
+    "6a4b",
+    "6ama",
+    "6ar1",
+    "6ar3",
+    "6ar5",
+    "6b14",
+    "6b3k",
+    "6bch",
+    "6blw",
+    "6bmd",
+    "6bs1",
+    "6bwy",
+    "6c2f",
+    "6c2s",
+    "6cao",
+    "6cap",
+    "6caq",
+    "6car",
+    "6cas",
+    "6cg0",
+    "6cmn",
+    "6cst",
+    "6cvo",
+    "6d6q",
+    "6d6r",
+    "6d92",
+    "6dgd",
+    "6en8",
+    "6evk",
+    "6fb8",
+    "6fb9",
+    "6fhh",
+    "6fhi",
+    "6fqm",
+    "6fqs",
+    "6ftu",
+    "6fz0",
+    "6g1t",
+    "6gaw",
+    "6gb2",
+    "6gdn",
+    "6ge1",
+    "6gis",
+    "6gml",
+    "6go5",
+    "6h0r",
+    "6hag",
+    "6hix",
+    "6imj",
+    "6imk",
+    "6iml",
+    "6imn",
+    "6iod",
+    "6ir8",
+    "6is8",
+    "6iuc",
+    "6iud",
+    "6iv8",
+    "6iv9",
+    "6j4r",
+    "6jdg",
+    "6jdq",
+    "6jdv",
+    "6je3",
+    "6je4",
+    "6je9",
+    "6jfu",
+    "6jgw",
+    "6jni",
+    "6jrf",
+    "6jrg",
+    "6jrp",
+    "6juq",
+    "6k1k",
+    "6kc7",
+    "6kc8",
+    "6ke6",
+    "6koo",
+    "6kqh",
+    "6kwq",
+    "6l6s",
+    "6lqp",
+    "6ltr",
+    "6ltu",
+    "6lwr",
+    "6m05",
+    "6m0v",
+    "6m0w",
+    "6m0x",
+    "6m3l",
+    "6m6c",
+    "6m6k",
+    "6m6r",
+    "6mur",
+    "6mut",
+    "6muu",
+    "6n7r",
+    "6n8h",
+    "6o1k",
+    "6o1l",
+    "6o1m",
+    "6o7e",
+    "6o7h",
+    "6o7i",
+    "6o8q",
+    "6od4",
+    "6oes",
+    "6oet",
+    "6om6",
+    "6ore",
+    "6orl",
+    "6osq",
+    "6oy7",
+    "6p7b",
+    "6pmo",
+    "6q57",
+    "6qdw",
+    "6r9m",
+    "6rfl",
+    "6rj9",
+    "6rja",
+    "6rjd",
+    "6rjg",
+    "6s7d",
+    "6sdw",
+    "6sdy",
+    "6sty",
+    "6svs",
+    "6sy0",
+    "6t0w",
+    "6u6z",
+    "6u82",
+    "6u89",
+    "6u9q",
+    "6ug1",
+    "6ugi",
+    "6ugj",
+    "6utv",
+    "6vaa",
+    "6vcs",
+    "6vlz",
+    "6vmi",
+    "6vtx",
+    "6vwt",
+    "6vwv",
+    "6w5c",
+    "6waa",
+    "6wig",
+    "6wmr",
+    "6wmu",
+    "6x8c",
+    "6xb7",
+    "6xdz",
+    "6xgj",
+    "6xh0",
+    "6xh1",
+    "6xh2",
+    "6xh3",
+    "6xnx",
+    "6xny",
+    "6xo5",
+    "6xo6",
+    "6xo9",
+    "6xu8",
+    "6xwg",
+    "6y0g",
+    "6y2l",
+    "6ybw",
+    "6ys3",
+    "6yw5",
+    "6ywe",
+    "6ywx",
+    "6ywy",
+    "6yxy",
+    "6z1a",
+    "6z2y",
+    "6z6g",
+    "6z8k",
+    "6za3",
+    "6zab",
+    "6zj3",
+    "6znp",
+    "6znq",
+    "6zsc",
+    "6zvi",
+    "6zym",
+    "7aap",
+    "7act",
+    "7aoi",
+    "7b1y",
+    "7b20",
+    "7b23",
+    "7b24",
+    "7b25",
+    "7b7d",
+    "7bhp",
+    "7bkp",
+    "7cc9",
+    "7cli",
+    "7cps",
+    "7cqa",
+    "7csk",
+    "7cvq",
+    "7cxm",
+    "7cyq",
+    "7d12",
+    "7d3v",
+    "7d3w",
+    "7d3x",
+    "7dcj",
+    "7dfg",
+    "7dn3",
+    "7do1",
+    "7doi",
+    "7dok",
+    "7dta",
+    "7dwr",
+    "7edb",
+    "7eiu",
+    "7exy",
+    "7f36",
+    "7fgt",
+    "7jft",
+    "7jfw",
+    "7jfx",
+    "7jh8",
+    "7jh9",
+    "7jha",
+    "7jhc",
+    "7jht",
+    "7jhu",
+    "7jhv",
+    "7jiq",
+    "7jj3",
+    "7jj4",
+    "7jj5",
+    "7jjy",
+    "7jkd",
+    "7jke",
+    "7jkg",
+    "7jkh",
+    "7jkj",
+    "7jkk",
+    "7jl9",
+    "7jla",
+    "7jlb",
+    "7jlc",
+    "7jld",
+    "7jle",
+    "7jlf",
+    "7jnh",
+    "7jnj",
+    "7jnk",
+    "7jnl",
+    "7jnm",
+    "7jp7",
+    "7jsb",
+    "7jsc",
+    "7jy6",
+    "7jy8",
+    "7jy9",
+    "7k9d",
+    "7k9e",
+    "7kd1",
+    "7kga",
+    "7kjv",
+    "7kjw",
+    "7kjx",
+    "7kkv",
+    "7ksp",
+    "7l4x",
+    "7l4y",
+    "7lyf",
+    "7m09",
+    "7m0a",
+    "7m0d",
+    "7m0e",
+    "7m5d",
+    "7m99",
+    "7ml0",
+    "7n0c",
+    "7nbl",
+    "7nbp",
+    "7nej",
+    "7nha",
+    "7nhc",
+    "7nhx",
+    "7ni0",
+    "7nqh",
+    "7nql",
+    "7nsh",
+    "7nsp",
+    "7nsq",
+    "7nwt",
+    "7nx5",
+    "7oar",
+    "7obr",
+    "7og0",
+    "7oii",
+    "7okx",
+    "7ol0",
+    "7ork",
+    "7orm",
+    "7orn",
+    "7oro",
+    "7osa",
+    "7osm",
+    "7ot5",
+    "7ouf",
+    "7oug",
+    "7ouh",
+    "7p0v",
+    "7p6z",
+    "7pdu",
+    "7pel",
+    "7pkt",
+    "7po6",
+    "7pof",
+    "7pwg",
+    "7pwo",
+    "7q2y",
+    "7qd6",
+    "7qhs",
+    "7qiw",
+    "7qiz",
+    "7qr3",
+    "7qr4",
+    "7qv1",
+    "7qvp",
+    "7r21",
+    "7r2k",
+    "7r5s",
+    "7r77",
+    "7r78",
+    "7r9g",
+    "7rgu",
+    "7rsu",
+    "7rwr",
+    "7sd8",
+    "7sdf",
+    "7sga",
+    "7sgz",
+    "7sh2",
+    "7sm9",
+    "7st9",
+    "7stb",
+    "7svu",
+    "7tfh",
+    "7tfi",
+    "7tfj",
+    "7tfk",
+    "7tfl",
+    "7u3o",
+    "7u4a",
+    "7ubl",
+    "7ufx",
+    "7uga",
+    "7ujl",
+    "7umd",
+    "7un7",
+    "7und",
+    "7upz",
+    "7uv6",
+    "7uv7",
+    "7uyn",
+    "7v9i",
+    "7ve5",
+    "7vjq",
+    "7vki",
+    "7vm9",
+    "7vou",
+    "7vp1",
+    "7vp3",
+    "7vsj",
+    "7vyx",
+    "7vz4",
+    "7way",
+    "7waz",
+    "7wb0",
+    "7wia",
+    "7wv5",
+    "7wve",
+    "7wvj",
+    "7x5a",
+    "7xg0",
+    "7xg1",
+    "7xg2",
+    "7xg3",
+    "7xpx",
+    "7xso",
+    "7xsp",
+    "7xsq",
+    "7xsr",
+    "7xss",
+    "7xue",
+    "7y7c",
+    "7y7d",
+    "7y7e",
+    "7y7f",
+    "7y7g",
+    "7y7h",
+    "7ypo",
+    "7yse",
+    "7ysf",
+    "7z43",
+    "7z4j",
+    "7z9c",
+    "7z9g",
+    "7z9k",
+    "7z9m",
+    "7zb5",
+    "7zhg",
+    "7zo1",
+    "7zq6",
+    "7zta",
+    "8a22",
+    "8a8j",
+    "8a93",
+    "8aa5",
+    "8aas",
+    "8af0",
+    "8ag6",
+    "8ane",
+    "8apn",
+    "8apo",
+    "8azw",
+    "8b1t",
+    "8b2l",
+    "8b4d",
+    "8bf8",
+    "8br8",
+    "8brm",
+    "8bsi",
+    "8btr",
+    "8bw5",
+    "8c4u",
+    "8c4v",
+    "8c8j",
+    "8cq1",
+    "8d33",
+    "8d37",
+    "8d3r",
+    "8d42",
+    "8d4a",
+    "8d4b",
+    "8dcj",
+    "8dej",
+    "8df8",
+    "8dfb",
+    "8dk3",
+    "8dlf",
+    "8dqx",
+    "8e3d",
+    "8e3e",
+    "8ea4",
+    "8edj",
+    "8eey",
+    "8eg7",
+    "8eg8",
+    "8eh8",
+    "8ehf",
+    "8ekz",
+    "8em9",
+    "8ep8",
+    "8epb",
+    "8epg",
+    "8ex9",
+    "8exa",
+    "8f3c",
+    "8f40",
+    "8fak",
+    "8ffr",
+    "8fkp",
+    "8fkq",
+    "8fkr",
+    "8fks",
+    "8fkt",
+    "8fku",
+    "8fkv",
+    "8fkw",
+    "8fkx",
+    "8fky",
+    "8fkz",
+    "8fl2",
+    "8fl6",
+    "8fla",
+    "8fld",
+    "8fru",
+    "8fs3",
+    "8fs4",
+    "8fs5",
+    "8fs6",
+    "8fs7",
+    "8fs8",
+    "8fy9",
+    "8fya",
+    "8g00",
+    "8g5i",
+    "8g5j",
+    "8g5k",
+    "8g5l",
+    "8gh6",
+    "8gj0",
+    "8gj1",
+    "8gj2",
+    "8gj3",
+    "8gs2",
+    "8gxb",
+    "8gxc",
+    "8gzg",
+    "8gzh",
+    "8h9d",
+    "8hig",
+    "8hj4",
+    "8hml",
+    "8i3q",
+    "8iaz",
+    "8id2",
+    "8ifb",
+    "8ifc",
+    "8igr",
+    "8igs",
+    "8ik8",
+    "8ip8",
+    "8ipa",
+    "8ipb",
+    "8j1q",
+    "8j26",
+    "8j86",
+    "8j8f",
+    "8j8g",
+    "8j9v",
+    "8j9x",
+    "8jiv",
+    "8jmj",
+    "8jmk",
+    "8jo2",
+    "8k4l",
+    "8k87",
+    "8k88",
+    "8kah",
+    "8kai",
+    "8kaj",
+    "8kb5",
+    "8oiq",
+    "8okd",
+    "8oki",
+    "8ova",
+    "8ove",
+    "8p16",
+    "8p17",
+    "8p18",
+    "8p4b",
+    "8p6p",
+    "8p7x",
+    "8p8b",
+    "8pbc",
+    "8pbd",
+    "8pi8",
+    "8pia",
+    "8pj1",
+    "8pj2",
+    "8pj4",
+    "8pj5",
+    "8pj6",
+    "8pj9",
+    "8ppt",
+    "8psx",
+    "8psz",
+    "8ptx",
+    "8ptz",
+    "8pvv",
+    "8q43",
+    "8qcq",
+    "8qgt",
+    "8qh3",
+    "8qk7",
+    "8qkx",
+    "8qoa",
+    "8que",
+    "8r60",
+    "8ram",
+    "8ran",
+    "8rdu",
+    "8re4",
+    "8rea",
+    "8rig",
+    "8rkv",
+    "8rm7",
+    "8rmh",
+    "8rqk",
+    "8rr3",
+    "8s54",
+    "8s55",
+    "8s5n",
+    "8sro",
+    "8sxl",
+    "8sz5",
+    "8t2x",
+    "8t2y",
+    "8t2z",
+    "8t7e",
+    "8tjq",
+    "8tju",
+    "8tjv",
+    "8tjx",
+    "8toc",
+    "8txo",
+    "8u0j",
+    "8u3y",
+    "8udk",
+    "8uha",
+    "8uhd",
+    "8uhg",
+    "8ui0",
+    "8uis",
+    "8umv",
+    "8umw",
+    "8umy",
+    "8un0",
+    "8upy",
+    "8urb",
+    "8uvx",
+    "8uzt",
+    "8ves",
+    "8vma",
+    "8vmb",
+    "8w2o",
+    "8w2z",
+    "8wat",
+    "8wau",
+    "8way",
+    "8wpe",
+    "8wpf",
+    "8wpk",
+    "8wpp",
+    "8wus",
+    "8x1v",
+    "8xa9",
+    "8xj7",
+    "8xj8",
+    "8xyc",
+    "8y2i",
+    "8y6o",
+    "8zlu",
+    "8zm3",
+    "8zol",
+    "8zp7",
+    "8zp9",
+    "9b8t",
+    "9bgk",
+    "9blm",
+    "9ces",
+    "9cet",
+    "9cj6",
+    "9cji",
+    "9cjj",
+    "9cxf",
+    "9e6q",
+    "9e71",
+    "9e7f",
+    "9eco",
+    "9enb",
+    "9enc",
+    "9erf",
+    "9esh",
+    "9esi",
+    "9f2r",
+    "9f37",
+    "9f6i",
+    "9fia",
+    "9foy",
+    "9g6k",
+    "9gd0",
+    "9gr1",
+    "9ij1",
+    "9ixm",
+    "9jxs"
+]

splits/design_valid.json

@@ -0,0 +1,1332 @@
+[
+    "118d",
+    "122d",
+    "123d",
+    "185d",
+    "192d",
+    "1a1f",
+    "1a1k",
+    "1a4d",
+    "1a9g",
+    "1a9h",
+    "1a9i",
+    "1a9j",
+    "1aju",
+    "1akx",
+    "1al9",
+    "1anr",
+    "1arj",
+    "1aud",
+    "1awc",
+    "1axl",
+    "1azq",
+    "1b69",
+    "1bd1",
+    "1bg1",
+    "1bgb",
+    "1bhm",
+    "1bjd",
+    "1bnz",
+    "1cf7",
+    "1cgp",
+    "1crx",
+    "1cw9",
+    "1d3r",
+    "1d91",
+    "1d93",
+    "1drg",
+    "1dsa",
+    "1dsi",
+    "1dsm",
+    "1e4p",
+    "1e7j",
+    "1eeg",
+    "1emh",
+    "1emj",
+    "1eop",
+    "1f44",
+    "1f6x",
+    "1f6z",
+    "1f78",
+    "1f79",
+    "1f7f",
+    "1f7g",
+    "1f7h",
+    "1f7i",
+    "1fje",
+    "1fuf",
+    "1fyi",
+    "1gdt",
+    "1gqu",
+    "1gtn",
+    "1guc",
+    "1hc8",
+    "1hji",
+    "1hm1",
+    "1i6j",
+    "1i9x",
+    "1ie1",
+    "1ie2",
+    "1ik5",
+    "1ikd",
+    "1imh",
+    "1ir5",
+    "1ixj",
+    "1j59",
+    "1jur",
+    "1jvc",
+    "1k1g",
+    "1k6o",
+    "1k8w",
+    "1kfo",
+    "1kh6",
+    "1kix",
+    "1kks",
+    "1kos",
+    "1ksy",
+    "1l3z",
+    "1lc6",
+    "1le9",
+    "1lvj",
+    "1m5k",
+    "1m5o",
+    "1m5p",
+    "1m5v",
+    "1m77",
+    "1mfk",
+    "1mjm",
+    "1mms",
+    "1n1k",
+    "1n35",
+    "1n66",
+    "1nk0",
+    "1nk2",
+    "1nk3",
+    "1nwq",
+    "1nz1",
+    "1o3r",
+    "1o3s",
+    "1o3t",
+    "1odh",
+    "1oln",
+    "1omh",
+    "1oq0",
+    "1osb",
+    "1osl",
+    "1ouq",
+    "1ow9",
+    "1owr",
+    "1p0u",
+    "1p5m",
+    "1p96",
+    "1pik",
+    "1q3f",
+    "1q3v",
+    "1q93",
+    "1q96",
+    "1qa6",
+    "1qc0",
+    "1qd3",
+    "1qfq",
+    "1qss",
+    "1qsy",
+    "1qtm",
+    "1qwa",
+    "1qx0",
+    "1r2l",
+    "1r3e",
+    "1r4e",
+    "1r9t",
+    "1rh6",
+    "1rkj",
+    "1rlg",
+    "1rsb",
+    "1run",
+    "1ruo",
+    "1s6m",
+    "1s9n",
+    "1sa9",
+    "1saq",
+    "1scl",
+    "1sp6",
+    "1ssj",
+    "1sy4",
+    "1syz",
+    "1tf6",
+    "1tlr",
+    "1tn9",
+    "1tob",
+    "1u6b",
+    "1u78",
+    "1u8b",
+    "1uts",
+    "1uud",
+    "1uui",
+    "1vfg",
+    "1w36",
+    "1wsu",
+    "1wtq",
+    "1wtv",
+    "1wtx",
+    "1xhu",
+    "1xhv",
+    "1xpx",
+    "1xsg",
+    "1xsh",
+    "1xst",
+    "1xsu",
+    "1xv0",
+    "1xvn",
+    "1y39",
+    "1y69",
+    "1yfv",
+    "1yg3",
+    "1yg4",
+    "1ylg",
+    "1ync",
+    "1yne",
+    "1yng",
+    "1ysa",
+    "1ysv",
+    "1ze2",
+    "1zew",
+    "1zfa",
+    "1zl3",
+    "1zm5",
+    "1zns",
+    "1zq3",
+    "1zr4",
+    "1zzn",
+    "220d",
+    "243d",
+    "295d",
+    "2a6o",
+    "2a7e",
+    "2ab4",
+    "2adw",
+    "2aoq",
+    "2ap0",
+    "2ap5",
+    "2b0d",
+    "2b0e",
+    "2bam",
+    "2bcr",
+    "2bcs",
+    "2bdp",
+    "2bgg",
+    "2c6y",
+    "2cd1",
+    "2cd3",
+    "2cd5",
+    "2cd6",
+    "2cdm",
+    "2csx",
+    "2ct8",
+    "2czj",
+    "2d25",
+    "2dd1",
+    "2dd2",
+    "2dd3",
+    "2e2i",
+    "2e9t",
+    "2evy",
+    "2ex5",
+    "2ez6",
+    "2f8s",
+    "2fld",
+    "2fy1",
+    "2g1p",
+    "2g1z",
+    "2gjw",
+    "2glo",
+    "2gm4",
+    "2grw",
+    "2gv4",
+    "2ht0",
+    "2irn",
+    "2iy5",
+    "2jlt",
+    "2jq7",
+    "2jx1",
+    "2k3z",
+    "2k41",
+    "2kdq",
+    "2kez",
+    "2kf0",
+    "2kh3",
+    "2kn7",
+    "2kpr",
+    "2kqg",
+    "2ktq",
+    "2kwg",
+    "2kx5",
+    "2kye",
+    "2kzl",
+    "2l1f",
+    "2l8h",
+    "2ld5",
+    "2lkx",
+    "2lqz",
+    "2lvy",
+    "2m6v",
+    "2map",
+    "2mf8",
+    "2mi0",
+    "2miv",
+    "2mrz",
+    "2ms0",
+    "2ms1",
+    "2n4y",
+    "2nci",
+    "2nok",
+    "2nuf",
+    "2nvq",
+    "2o49",
+    "2o4a",
+    "2o5i",
+    "2o5j",
+    "2oeu",
+    "2oxm",
+    "2oyt",
+    "2ozb",
+    "2pjp",
+    "2ply",
+    "2pn3",
+    "2pn4",
+    "2ppb",
+    "2pyl",
+    "2qsg",
+    "2qsh",
+    "2r8j",
+    "2r8k",
+    "2rdj",
+    "2rpt",
+    "2uwm",
+    "2voa",
+    "2w42",
+    "2wb2",
+    "2wq6",
+    "2wq7",
+    "2x2q",
+    "2xgp",
+    "2xgq",
+    "2xs2",
+    "2yu9",
+    "2zi0",
+    "2zjq",
+    "2zjr",
+    "2zkf",
+    "2zko",
+    "2zy6",
+    "317d",
+    "344d",
+    "358d",
+    "365d",
+    "375d",
+    "376d",
+    "395d",
+    "3ana",
+    "3avu",
+    "3avw",
+    "3bam",
+    "3bo2",
+    "3bo3",
+    "3bo4",
+    "3bsb",
+    "3cf5",
+    "3cvu",
+    "3cvv",
+    "3cvw",
+    "3cvx",
+    "3cvy",
+    "3dll",
+    "3e2e",
+    "3e44",
+    "3eog",
+    "3eoh",
+    "3exj",
+    "3exl",
+    "3f2b",
+    "3f2c",
+    "3f2d",
+    "3fte",
+    "3ftf",
+    "3g9y",
+    "3go3",
+    "3gp8",
+    "3gtj",
+    "3gtl",
+    "3gv5",
+    "3i5e",
+    "3i5l",
+    "3iff",
+    "3j7o",
+    "3j7p",
+    "3j7q",
+    "3jah",
+    "3jcs",
+    "3jso",
+    "3jsp",
+    "3jtg",
+    "3k62",
+    "3k9f",
+    "3knc",
+    "3ko2",
+    "3ksa",
+    "3ktq",
+    "3ltn",
+    "3lwh",
+    "3m3y",
+    "3mgv",
+    "3mip",
+    "3mis",
+    "3mqy",
+    "3n6s",
+    "3nnc",
+    "3nvi",
+    "3odh",
+    "3oh6",
+    "3oh9",
+    "3ol6",
+    "3ol9",
+    "3ola",
+    "3olb",
+    "3oqm",
+    "3p59",
+    "3pf4",
+    "3pio",
+    "3pip",
+    "3pkm",
+    "3po5",
+    "3pt6",
+    "3px7",
+    "3pzp",
+    "3q05",
+    "3q06",
+    "3qrp",
+    "3qrr",
+    "3rad",
+    "3rae",
+    "3raf",
+    "3rn5",
+    "3sj2",
+    "3sq4",
+    "3suo",
+    "3sup",
+    "3syw",
+    "3szx",
+    "3t3n",
+    "3tup",
+    "3u3w",
+    "3u44",
+    "3u4q",
+    "3ukg",
+    "3uq0",
+    "3uq2",
+    "3v7j",
+    "3v7k",
+    "3v9d",
+    "3v9x",
+    "3w6v",
+    "3wpg",
+    "3wph",
+    "3x1l",
+    "3zd4",
+    "3zd5",
+    "3zp8",
+    "430d",
+    "433d",
+    "474d",
+    "484d",
+    "4a09",
+    "4a8w",
+    "4aa6",
+    "4ail",
+    "4awl",
+    "4b9n",
+    "4bxo",
+    "4c4w",
+    "4c7o",
+    "4c8l",
+    "4cn5",
+    "4csf",
+    "4dl6",
+    "4du1",
+    "4du4",
+    "4e0p",
+    "4e0y",
+    "4e54",
+    "4e5z",
+    "4e68",
+    "4eey",
+    "4egz",
+    "4esv",
+    "4fbt",
+    "4fbu",
+    "4fj5",
+    "4fj7",
+    "4fj8",
+    "4fjh",
+    "4g7h",
+    "4g92",
+    "4gfb",
+    "4gha",
+    "4gzn",
+    "4h0e",
+    "4h5p",
+    "4h5q",
+    "4hkq",
+    "4hly",
+    "4i2a",
+    "4ifd",
+    "4iht",
+    "4ill",
+    "4io9",
+    "4ioa",
+    "4izq",
+    "4j2b",
+    "4j2e",
+    "4j39",
+    "4j50",
+    "4j5v",
+    "4j9l",
+    "4j9m",
+    "4j9o",
+    "4j9q",
+    "4j9s",
+    "4jrp",
+    "4jrq",
+    "4jrt",
+    "4k4u",
+    "4k4x",
+    "4k4y",
+    "4k4z",
+    "4k50",
+    "4klq",
+    "4kls",
+    "4klt",
+    "4klu",
+    "4koe",
+    "4kpe",
+    "4kpf",
+    "4kpy",
+    "4kr6",
+    "4kr7",
+    "4kr9",
+    "4ktq",
+    "4l62",
+    "4lck",
+    "4lg2",
+    "4lup",
+    "4m2z",
+    "4m30",
+    "4m3t",
+    "4m3u",
+    "4m41",
+    "4m42",
+    "4m4o",
+    "4m94",
+    "4m95",
+    "4m9v",
+    "4mdx",
+    "4mzr",
+    "4n76",
+    "4nca",
+    "4ncb",
+    "4ngf",
+    "4nm2",
+    "4oin",
+    "4okl",
+    "4ol8",
+    "4oln",
+    "4pba",
+    "4peh",
+    "4pmw",
+    "4qjd",
+    "4qze",
+    "4qzi",
+    "4r4e",
+    "4rge",
+    "4rgf",
+    "4ro8",
+    "4rq4",
+    "4rq5",
+    "4rq6",
+    "4rq7",
+    "4rq8",
+    "4rtj",
+    "4rzr",
+    "4tvx",
+    "4u6p",
+    "4u92",
+    "4v2s",
+    "4v5l",
+    "4v5p",
+    "4v5q",
+    "4v5r",
+    "4v5s",
+    "4v9c",
+    "4w2e",
+    "4wal",
+    "4wan",
+    "4wc2",
+    "4wc3",
+    "4wc5",
+    "4wc6",
+    "4wc7",
+    "4wj4",
+    "4wqf",
+    "4wqu",
+    "4x0b",
+    "4x62",
+    "4x64",
+    "4x65",
+    "4x66",
+    "4xrm",
+    "4xrs",
+    "4xvi",
+    "4xvk",
+    "4xzf",
+    "4y52",
+    "4y5w",
+    "4y7n",
+    "4ycp",
+    "4yf0",
+    "4yfh",
+    "4yg1",
+    "4yir",
+    "4yn6",
+    "4z3o",
+    "4z4e",
+    "4z53",
+    "4zbn",
+    "4zer",
+    "4zkk",
+    "5b81",
+    "5bz1",
+    "5c51",
+    "5cd4",
+    "5cdr",
+    "5cki",
+    "5ckk",
+    "5cnq",
+    "5d2s",
+    "5d39",
+    "5dcv",
+    "5ddo",
+    "5ddp",
+    "5ddq",
+    "5ddr",
+    "5dm6",
+    "5dm7",
+    "5dun",
+    "5elh",
+    "5esp",
+    "5f8g",
+    "5f8h",
+    "5f8i",
+    "5f9i",
+    "5f9r",
+    "5fgp",
+    "5fhj",
+    "5fhl",
+    "5fj4",
+    "5gm6",
+    "5gwl",
+    "5h3r",
+    "5h9e",
+    "5h9f",
+    "5hc9",
+    "5hhh",
+    "5hhi",
+    "5hod",
+    "5hr9",
+    "5hto",
+    "5iye",
+    "5iyg",
+    "5iyj",
+    "5j05",
+    "5j0m",
+    "5j1o",
+    "5j2w",
+    "5j37",
+    "5j4p",
+    "5j4w",
+    "5jk0",
+    "5jub",
+    "5jvg",
+    "5jvw",
+    "5k36",
+    "5k5l",
+    "5k78",
+    "5keg",
+    "5kk5",
+    "5kn9",
+    "5kvj",
+    "5lit",
+    "5lzd",
+    "5lze",
+    "5m8i",
+    "5mdv",
+    "5mdw",
+    "5mdy",
+    "5mdz",
+    "5mey",
+    "5mga",
+    "5mrc",
+    "5n9a",
+    "5nm9",
+    "5npk",
+    "5nw9",
+    "5o6e",
+    "5ocz",
+    "5odf",
+    "5odm",
+    "5oe1",
+    "5ond",
+    "5or0",
+    "5sww",
+    "5t2a",
+    "5u0a",
+    "5u4i",
+    "5ua3",
+    "5uk7",
+    "5uq7",
+    "5uq8",
+    "5uug",
+    "5uuh",
+    "5v0e",
+    "5v1i",
+    "5v1j",
+    "5v1o",
+    "5v1r",
+    "5v3j",
+    "5v3m",
+    "5va0",
+    "5vm9",
+    "5vo8",
+    "5voi",
+    "5vpo",
+    "5vsu",
+    "5vvk",
+    "5vvl",
+    "5vxn",
+    "5w20",
+    "5w51",
+    "5w6k",
+    "5w6q",
+    "5wjq",
+    "5wnp",
+    "5wnv",
+    "5wti",
+    "5wwc",
+    "5xtm",
+    "5xuu",
+    "5xuz",
+    "5y6z",
+    "5ytc",
+    "5zc9",
+    "5zki",
+    "5zkj",
+    "5zwm",
+    "6aeg",
+    "6aso",
+    "6az3",
+    "6b1q",
+    "6bk8",
+    "6c4i",
+    "6c5l",
+    "6cae",
+    "6cfi",
+    "6chv",
+    "6cik",
+    "6cuu",
+    "6d2u",
+    "6dbi",
+    "6dcb",
+    "6dcc",
+    "6dcl",
+    "6dkl",
+    "6dmc",
+    "6dmd",
+    "6dme",
+    "6dww",
+    "6dwz",
+    "6dx0",
+    "6dy9",
+    "6e8c",
+    "6e8s",
+    "6e8t",
+    "6e8u",
+    "6f1k",
+    "6f2s",
+    "6f4h",
+    "6f57",
+    "6fi8",
+    "6fn0",
+    "6fqp",
+    "6fqq",
+    "6gaz",
+    "6gd2",
+    "6gim",
+    "6grb",
+    "6grc",
+    "6grd",
+    "6gtg",
+    "6gvq",
+    "6gvt",
+    "6gvu",
+    "6gy3",
+    "6gz5",
+    "6gz7",
+    "6hct",
+    "6hmi",
+    "6hmo",
+    "6i1k",
+    "6i1l",
+    "6i4n",
+    "6i4o",
+    "6iid",
+    "6j6g",
+    "6jbx",
+    "6jgx",
+    "6jyw",
+    "6kbx",
+    "6kbz",
+    "6l2n",
+    "6l2o",
+    "6lbm",
+    "6lff",
+    "6lnb",
+    "6lqf",
+    "6lsg",
+    "6lts",
+    "6m5b",
+    "6m7v",
+    "6mcb",
+    "6mce",
+    "6mfn",
+    "6mig",
+    "6mpu",
+    "6nd6",
+    "6ne0",
+    "6neq",
+    "6nf8",
+    "6nld",
+    "6nsh",
+    "6nta",
+    "6nua",
+    "6nuh",
+    "6nuo",
+    "6nwy",
+    "6o0x",
+    "6o0y",
+    "6o5f",
+    "6o97",
+    "6oeb",
+    "6of1",
+    "6of6",
+    "6oj2",
+    "6ol3",
+    "6ole",
+    "6olg",
+    "6oli",
+    "6om0",
+    "6ope",
+    "6ord",
+    "6ovr",
+    "6ovy",
+    "6ow3",
+    "6oy5",
+    "6oy6",
+    "6ozi",
+    "6pbd",
+    "6pq7",
+    "6pqu",
+    "6pr5",
+    "6prv",
+    "6qhd",
+    "6qhi",
+    "6qtk",
+    "6qx1",
+    "6qzp",
+    "6r6p",
+    "6r8e",
+    "6rio",
+    "6rou",
+    "6rr7",
+    "6s3i",
+    "6swa",
+    "6ty9",
+    "6u81",
+    "6ufj",
+    "6ufk",
+    "6uin",
+    "6up0",
+    "6upx",
+    "6upy",
+    "6upz",
+    "6uq3",
+    "6va1",
+    "6va2",
+    "6va3",
+    "6va4",
+    "6var",
+    "6vrb",
+    "6vvj",
+    "6w0r",
+    "6wbr",
+    "6wlh",
+    "6wya",
+    "6xdv",
+    "6xdx",
+    "6xej",
+    "6xek",
+    "6xem",
+    "6xfc",
+    "6xfw",
+    "6xfy",
+    "6xgo",
+    "6xgw",
+    "6xjq",
+    "6xjw",
+    "6xjy",
+    "6xjz",
+    "6xki",
+    "6y39",
+    "6yal",
+    "6ydp",
+    "6yyt",
+    "6zm5",
+    "6zm6",
+    "6ztl",
+    "7a09",
+    "7a0r",
+    "7a0s",
+    "7a18",
+    "7ae1",
+    "7ae3",
+    "7aea",
+    "7am2",
+    "7amv",
+    "7aoh",
+    "7aoz",
+    "7ap8",
+    "7ap9",
+    "7aqc",
+    "7aqd",
+    "7as8",
+    "7as9",
+    "7asa",
+    "7b0c",
+    "7b0g",
+    "7b9v",
+    "7bzf",
+    "7c2k",
+    "7c9o",
+    "7cq4",
+    "7csw",
+    "7cuk",
+    "7d0y",
+    "7d0z",
+    "7dco",
+    "7dpe",
+    "7dq0",
+    "7dq8",
+    "7ecf",
+    "7ecg",
+    "7ech",
+    "7eh1",
+    "7eh2",
+    "7el7",
+    "7jfv",
+    "7jhr",
+    "7ji5",
+    "7ji8",
+    "7jim",
+    "7jio",
+    "7jj6",
+    "7jjw",
+    "7jnp",
+    "7jog",
+    "7jok",
+    "7jon",
+    "7jp6",
+    "7jp9",
+    "7jpb",
+    "7jrs",
+    "7js1",
+    "7js2",
+    "7ju1",
+    "7k51",
+    "7k52",
+    "7k54",
+    "7k55",
+    "7k5d",
+    "7k5l",
+    "7k78",
+    "7k98",
+    "7k9m",
+    "7ka0",
+    "7kab",
+    "7kee",
+    "7kha",
+    "7kqn",
+    "7kub",
+    "7l49",
+    "7l4c",
+    "7lys",
+    "7lyt",
+    "7m7y",
+    "7m7z",
+    "7m80",
+    "7m81",
+    "7m82",
+    "7mga",
+    "7mjw",
+    "7mjx",
+    "7mjy",
+    "7mkd",
+    "7mki",
+    "7mpi",
+    "7mpj",
+    "7mxx",
+    "7n8s",
+    "7nwi",
+    "7o0g",
+    "7o81",
+    "7ogv",
+    "7ohe",
+    "7ohj",
+    "7ohm",
+    "7ol9",
+    "7onb",
+    "7oo3",
+    "7oob",
+    "7ope",
+    "7oue",
+    "7oy7",
+    "7ozq",
+    "7p0w",
+    "7p3f",
+    "7p8l",
+    "7p9z",
+    "7pli",
+    "7pmm",
+    "7pnt",
+    "7pnu",
+    "7pnv",
+    "7pnw",
+    "7po2",
+    "7pu7",
+    "7q7x",
+    "7q7y",
+    "7q7z",
+    "7q80",
+    "7q81",
+    "7q82",
+    "7qca",
+    "7qd5",
+    "7qh7",
+    "7qi4",
+    "7qi5",
+    "7qi6",
+    "7qqd",
+    "7qqq",
+    "7qqw",
+    "7r5r",
+    "7r6t",
+    "7r6v",
+    "7r97",
+    "7rip",
+    "7riw",
+    "7rix",
+    "7s38",
+    "7sop",
+    "7sr6",
+    "7sum",
+    "7sx5",
+    "7tql",
+    "7txc",
+    "7u32",
+    "7uo0",
+    "7uo1",
+    "7uo2",
+    "7uo5",
+    "7urk",
+    "7usf",
+    "7uzx",
+    "7v9e",
+    "7vbb",
+    "7vo0",
+    "7vrl",
+    "7vtn",
+    "7w5p",
+    "7w5x",
+    "7wb3",
+    "7wju",
+    "7x2z",
+    "7x3a",
+    "7x75",
+    "7x9f",
+    "7xdj",
+    "7xht",
+    "7xpl",
+    "7xsz",
+    "7xvn",
+    "7yfe",
+    "7yfq",
+    "7ync",
+    "7ypa",
+    "7yuk",
+    "7yul",
+    "7yun",
+    "7z1m",
+    "7z1o",
+    "7z1z",
+    "7z2z",
+    "7z4d",
+    "7z4i",
+    "7z4l",
+    "7z5a",
+    "7zew",
+    "8a3w",
+    "8a5p",
+    "8a98",
+    "8any",
+    "8as6",
+    "8as7",
+    "8asd",
+    "8asg",
+    "8ask",
+    "8axa",
+    "8b3d",
+    "8b3f",
+    "8b4b",
+    "8b4c",
+    "8bf7",
+    "8bf9",
+    "8bge",
+    "8bgh",
+    "8bh4",
+    "8bhj",
+    "8bhl",
+    "8bhn",
+    "8bhp",
+    "8bil",
+    "8bim",
+    "8bws",
+    "8c41",
+    "8cbo",
+    "8cf2",
+    "8ci5",
+    "8crx",
+    "8csh",
+    "8cvm",
+    "8d2m",
+    "8d8k",
+    "8d8l",
+    "8d93",
+    "8dex",
+    "8df9",
+    "8dfa",
+    "8dfo",
+    "8dfs",
+    "8dp3",
+    "8dqw",
+    "8dr6",
+    "8dzj",
+    "8ee9",
+    "8ej6",
+    "8ejo",
+    "8ejp",
+    "8eku",
+    "8fni",
+    "8fyb",
+    "8g5z",
+    "8g9l",
+    "8g9n",
+    "8gcc",
+    "8gzr",
+    "8hag",
+    "8hb1",
+    "8hb3",
+    "8hi1",
+    "8hku",
+    "8htx",
+    "8hud",
+    "8i3z",
+    "8i44",
+    "8i46",
+    "8if5",
+    "8ifo",
+    "8ijc",
+    "8ik5",
+    "8ike",
+    "8ilg",
+    "8ili",
+    "8iyq",
+    "8j54",
+    "8jkk",
+    "8joz",
+    "8k59",
+    "8k8b",
+    "8oir",
+    "8ois",
+    "8oit",
+    "8oly",
+    "8olz",
+    "8om2",
+    "8om3",
+    "8om4",
+    "8om9",
+    "8ovj",
+    "8ow4",
+    "8p03",
+    "8p09",
+    "8p0j",
+    "8p0k",
+    "8p0n",
+    "8pbl",
+    "8pkl",
+    "8pnf",
+    "8pop",
+    "8ppu",
+    "8ppv",
+    "8qie",
+    "8qoz",
+    "8qpe",
+    "8qrn",
+    "8qwe",
+    "8qwf",
+    "8r1x",
+    "8r3v",
+    "8r62",
+    "8r63",
+    "8r6u",
+    "8r6w",
+    "8r6y",
+    "8r7f",
+    "8r8p",
+    "8r8r",
+    "8rcl",
+    "8reb",
+    "8rm6",
+    "8ro0",
+    "8ro1",
+    "8rxh",
+    "8rxx",
+    "8s1p",
+    "8s1u",
+    "8sh0",
+    "8sh5",
+    "8sqj",
+    "8sqk",
+    "8ssq",
+    "8ssr",
+    "8ssw",
+    "8sy5",
+    "8t2t",
+    "8t6p",
+    "8tac",
+    "8thv",
+    "8tom",
+    "8tvy",
+    "8u3b",
+    "8u3m",
+    "8u5j",
+    "8u9l",
+    "8u9r",
+    "8u9x",
+    "8ub7",
+    "8ub8",
+    "8ub9",
+    "8uba",
+    "8ubb",
+    "8ubc",
+    "8ubd",
+    "8ube",
+    "8udl",
+    "8ukb",
+    "8uvk",
+    "8uw3",
+    "8v1h",
+    "8v5r",
+    "8vat",
+    "8vm8",
+    "8vm9",
+    "8vxa",
+    "8vxc",
+    "8vzm",
+    "8w35",
+    "8w76",
+    "8w7w",
+    "8w8n",
+    "8wa1",
+    "8wax",
+    "8wce",
+    "8wmm",
+    "8wnb",
+    "8wq5",
+    "8wq7",
+    "8wt8",
+    "8wt9",
+    "8wzc",
+    "8x0s",
+    "8x6g",
+    "8xak",
+    "8xca",
+    "8xcc",
+    "8xk7",
+    "8xko",
+    "8xs6",
+    "8xs7",
+    "8xs8",
+    "8xs9",
+    "8xsa",
+    "8xsb",
+    "8y07",
+    "8y09",
+    "8y0b",
+    "8y0c",
+    "8yb6",
+    "8ydb",
+    "8yeo",
+    "8yh9",
+    "8yha",
+    "8yzt",
+    "8z85",
+    "8z8j",
+    "8z8n",
+    "8z8x",
+    "8z90",
+    "8z97",
+    "8z9h",
+    "8z9r",
+    "9asn",
+    "9aso",
+    "9avr",
+    "9axv",
+    "9bf5",
+    "9bvt",
+    "9bz0",
+    "9c0j",
+    "9c4g",
+    "9c9p",
+    "9cgu",
+    "9cpd",
+    "9cpg",
+    "9cpi",
+    "9cpj",
+    "9d7r",
+    "9d7s",
+    "9d7t",
+    "9dll",
+    "9dtr",
+    "9ey0",
+    "9ey2",
+    "9gbv",
+    "9gch",
+    "9ggq",
+    "9gs9"
+]

structures.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc094c5b44bb23195c109c3f4c7ff1b0dbaf6fd59410abcd62c729bdae11264d
+size 2183779817

structures.zip.sha256

@@ -0,0 +1 @@
+bc094c5b44bb23195c109c3f4c7ff1b0dbaf6fd59410abcd62c729bdae11264d  structures.zip