Add files using upload-large-folder tool

.gitattributes

@@ -7864,3 +7864,451 @@ atlas_1000_analysis/2w86_A/2w86_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
 atlas_1000_analysis/2w86_A/2w86_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
 atlas_1000_analysis/2w86_A/2w86_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
 atlas_1000_analysis/1io1_A/1io1_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l84_A/3l84_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l84_A/3l84_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l84_A/3l84_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l84_A/3l84_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ia1_A/2ia1_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ia1_A/2ia1_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ia1_A/2ia1_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ia1_A/2ia1_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l84_A/3l84_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ia1_A/2ia1_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3gmv_X/3gmv_X_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ia1_A/2ia1_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l84_A/3l84_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3gmv_X/3gmv_X_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3gmv_X/3gmv_X_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3gmv_X/3gmv_X_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3gmv_X/3gmv_X_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3gmv_X/3gmv_X_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5gof_A/5gof_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5gof_A/5gof_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5gof_A/5gof_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5gof_A/5gof_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5gof_A/5gof_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2prv_A/2prv_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5gof_A/5gof_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2prv_A/2prv_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2prv_A/2prv_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2prv_A/2prv_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2prv_A/2prv_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2prv_A/2prv_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1uxy_A/1uxy_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1uxy_A/1uxy_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1uxy_A/1uxy_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1uxy_A/1uxy_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1uxy_A/1uxy_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2w39_A/2w39_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1uxy_A/1uxy_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2w39_A/2w39_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2w39_A/2w39_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2w39_A/2w39_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4iaj_B/4iaj_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2w39_A/2w39_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4iaj_B/4iaj_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4iaj_B/4iaj_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4iaj_B/4iaj_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2w39_A/2w39_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4iaj_B/4iaj_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4iaj_B/4iaj_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2gkr_I/2gkr_I_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2gkr_I/2gkr_I_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2gkr_I/2gkr_I_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2gkr_I/2gkr_I_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2gkr_I/2gkr_I_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2gkr_I/2gkr_I_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kde_C/3kde_C_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kde_C/3kde_C_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kde_C/3kde_C_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kde_C/3kde_C_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kde_C/3kde_C_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kde_C/3kde_C_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2x49_A/2x49_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2x49_A/2x49_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2x49_A/2x49_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2x49_A/2x49_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2x49_A/2x49_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2x49_A/2x49_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vcc_A/2vcc_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vcc_A/2vcc_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vcc_A/2vcc_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5pal_A/5pal_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5pal_A/5pal_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5pal_A/5pal_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5pal_A/5pal_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vcc_A/2vcc_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5pal_A/5pal_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5pal_A/5pal_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vcc_A/2vcc_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4cdp_A/4cdp_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4cdp_A/4cdp_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vcc_A/2vcc_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4cdp_A/4cdp_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4cdp_A/4cdp_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4cdp_A/4cdp_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2aj7_A/2aj7_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4cdp_A/4cdp_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2aj7_A/2aj7_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2aj7_A/2aj7_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2aj7_A/2aj7_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2aj7_A/2aj7_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2aj7_A/2aj7_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4lzh_A/4lzh_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4lzh_A/4lzh_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4lzh_A/4lzh_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4lzh_A/4lzh_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vfk_A/2vfk_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4lzh_A/4lzh_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4lzh_A/4lzh_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vfk_A/2vfk_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vfk_A/2vfk_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vfk_A/2vfk_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vfk_A/2vfk_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2j7z_A/2j7z_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2j7z_A/2j7z_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vfk_A/2vfk_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2j7z_A/2j7z_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2j7z_A/2j7z_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2j7z_A/2j7z_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2at8_X/2at8_X_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2j7z_A/2j7z_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2at8_X/2at8_X_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2at8_X/2at8_X_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2at8_X/2at8_X_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2at8_X/2at8_X_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2at8_X/2at8_X_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6j33_B/6j33_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6j33_B/6j33_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6j33_B/6j33_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4ddp_A/4ddp_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4ddp_A/4ddp_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6j33_B/6j33_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6j33_B/6j33_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4ddp_A/4ddp_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6j33_B/6j33_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4ddp_A/4ddp_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4ddp_A/4ddp_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4ddp_A/4ddp_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dvo_A/1dvo_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dvo_A/1dvo_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dvo_A/1dvo_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dvo_A/1dvo_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dvo_A/1dvo_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dvo_A/1dvo_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2iay_A/2iay_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2iay_A/2iay_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2iay_A/2iay_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2iay_A/2iay_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2iay_A/2iay_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2iay_A/2iay_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wq8_A/1wq8_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wq8_A/1wq8_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wq8_A/1wq8_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wq8_A/1wq8_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wq8_A/1wq8_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wq8_A/1wq8_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1t95_A/1t95_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1t95_A/1t95_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1t95_A/1t95_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1t95_A/1t95_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6fy5_A/6fy5_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1t95_A/1t95_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1t95_A/1t95_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6fy5_A/6fy5_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6fy5_A/6fy5_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6fy5_A/6fy5_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6fy5_A/6fy5_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6fy5_A/6fy5_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1m9z_A/1m9z_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1m9z_A/1m9z_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1m9z_A/1m9z_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1m9z_A/1m9z_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1m9z_A/1m9z_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1m9z_A/1m9z_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2oya_B/2oya_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2oya_B/2oya_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2oya_B/2oya_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2oya_B/2oya_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2oya_B/2oya_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2oya_B/2oya_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kbb_A/3kbb_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kbb_A/3kbb_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kbb_A/3kbb_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kbb_A/3kbb_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kbb_A/3kbb_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dow_A/1dow_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dow_A/1dow_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dow_A/1dow_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3kbb_A/3kbb_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dow_A/1dow_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dow_A/1dow_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dow_A/1dow_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1yqe_A/1yqe_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1yqe_A/1yqe_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1yqe_A/1yqe_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1yqe_A/1yqe_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1yqe_A/1yqe_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6eof_A/6eof_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1yqe_A/1yqe_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6eof_A/6eof_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6eof_A/6eof_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6eof_A/6eof_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6eof_A/6eof_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3mcb_B/3mcb_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6eof_A/6eof_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3mcb_B/3mcb_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3mcb_B/3mcb_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3mcb_B/3mcb_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3mcb_B/3mcb_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3mcb_B/3mcb_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ka1_A/1ka1_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ka1_A/1ka1_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ka1_A/1ka1_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ka1_A/1ka1_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5hkx_A/5hkx_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ka1_A/1ka1_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ka1_A/1ka1_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5hkx_A/5hkx_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5hkx_A/5hkx_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5hkx_A/5hkx_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5hkx_A/5hkx_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fbl_A/3fbl_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fbl_A/3fbl_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5hkx_A/5hkx_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fbl_A/3fbl_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fbl_A/3fbl_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fbl_A/3fbl_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fbl_A/3fbl_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4a3p_A/4a3p_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4a3p_A/4a3p_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4a3p_A/4a3p_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4a3p_A/4a3p_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4a3p_A/4a3p_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4a3p_A/4a3p_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4f87_A/4f87_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4f87_A/4f87_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4f87_A/4f87_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4f87_A/4f87_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4f87_A/4f87_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4f87_A/4f87_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2rji_A/2rji_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2rji_A/2rji_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2rji_A/2rji_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2rji_A/2rji_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2rji_A/2rji_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2rji_A/2rji_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dd3_B/1dd3_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dd3_B/1dd3_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dd3_B/1dd3_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dd3_B/1dd3_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dd3_B/1dd3_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1dd3_B/1dd3_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wsi_A/2wsi_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wsi_A/2wsi_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wsi_A/2wsi_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wsi_A/2wsi_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1qw2_A/1qw2_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wsi_A/2wsi_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wsi_A/2wsi_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1qw2_A/1qw2_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1qw2_A/1qw2_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1qw2_A/1qw2_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1qw2_A/1qw2_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1qw2_A/1qw2_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2xol_B/2xol_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2xol_B/2xol_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2xol_B/2xol_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2xol_B/2xol_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2xol_B/2xol_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2xol_B/2xol_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5erq_A/5erq_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5erq_A/5erq_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5erq_A/5erq_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5erq_A/5erq_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5erq_A/5erq_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5erq_A/5erq_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ois_A/1ois_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ois_A/1ois_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ois_A/1ois_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ois_A/1ois_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ois_A/1ois_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ois_A/1ois_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3e9v_A/3e9v_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3e9v_A/3e9v_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3e9v_A/3e9v_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3e9v_A/3e9v_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3e9v_A/3e9v_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3e9v_A/3e9v_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1f5n_A/1f5n_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1f5n_A/1f5n_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1f5n_A/1f5n_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1f5n_A/1f5n_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1f5n_A/1f5n_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1f5n_A/1f5n_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wna_A/1wna_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wna_A/1wna_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wna_A/1wna_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wna_A/1wna_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wna_A/1wna_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1wna_A/1wna_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1svb_A/1svb_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1svb_A/1svb_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1svb_A/1svb_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1svb_A/1svb_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1svb_A/1svb_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1svb_A/1svb_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1gte_D/1gte_D_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1gte_D/1gte_D_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1gte_D/1gte_D_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1gte_D/1gte_D_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1gte_D/1gte_D_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6qj0_A/6qj0_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1gte_D/1gte_D_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6qj0_A/6qj0_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6qj0_A/6qj0_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6qj0_A/6qj0_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6qj0_A/6qj0_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6qj0_A/6qj0_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3czz_B/3czz_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3czz_B/3czz_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3czz_B/3czz_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3czz_B/3czz_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3czz_B/3czz_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3czz_B/3czz_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3ilw_A/3ilw_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3ilw_A/3ilw_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3ilw_A/3ilw_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wcu_A/2wcu_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3ilw_A/3ilw_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wcu_A/2wcu_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wcu_A/2wcu_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3ilw_A/3ilw_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3ilw_A/3ilw_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wcu_A/2wcu_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wcu_A/2wcu_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ve0_A/1ve0_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ve0_A/1ve0_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2wcu_A/2wcu_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ve0_A/1ve0_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ve0_A/1ve0_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ve0_A/1ve0_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ve0_A/1ve0_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ail_A/1ail_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ail_A/1ail_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ail_A/1ail_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ail_A/1ail_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ail_A/1ail_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ail_A/1ail_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4hfv_A/4hfv_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4hfv_A/4hfv_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4hfv_A/4hfv_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4hfv_A/4hfv_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4hfv_A/4hfv_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4hfv_A/4hfv_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ot9_A/2ot9_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ot9_A/2ot9_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ot9_A/2ot9_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ot9_A/2ot9_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ot9_A/2ot9_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1knt_A/1knt_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1knt_A/1knt_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2ot9_A/2ot9_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1knt_A/1knt_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1knt_A/1knt_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1knt_A/1knt_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1knt_A/1knt_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4tsh_A/4tsh_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4tsh_A/4tsh_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4tsh_A/4tsh_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4tsh_A/4tsh_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4tsh_A/4tsh_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4tsh_A/4tsh_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l4p_A/3l4p_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l4p_A/3l4p_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l4p_A/3l4p_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1nns_A/1nns_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l4p_A/3l4p_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1nns_A/1nns_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l4p_A/3l4p_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3l4p_A/3l4p_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1nns_A/1nns_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1nns_A/1nns_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1nns_A/1nns_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5eqz_A/5eqz_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1nns_A/1nns_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5eqz_A/5eqz_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5eqz_A/5eqz_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5eqz_A/5eqz_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5eqz_A/5eqz_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5eqz_A/5eqz_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5b5i_B/5b5i_B_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5b5i_B/5b5i_B_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5b5i_B/5b5i_B_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5b5i_B/5b5i_B_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5b5i_B/5b5i_B_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/5b5i_B/5b5i_B_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2i5u_A/2i5u_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2i5u_A/2i5u_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2i5u_A/2i5u_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2i5u_A/2i5u_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2i5u_A/2i5u_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2i5u_A/2i5u_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1i4m_A/1i4m_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1i4m_A/1i4m_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1i4m_A/1i4m_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1i4m_A/1i4m_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1i4m_A/1i4m_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1i4m_A/1i4m_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o6g_A/4o6g_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o6g_A/4o6g_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o6g_A/4o6g_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o6g_A/4o6g_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o6g_A/4o6g_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6ro6_A/6ro6_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6ro6_A/6ro6_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6ro6_A/6ro6_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o6g_A/4o6g_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6ro6_A/6ro6_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6ro6_A/6ro6_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6ro6_A/6ro6_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2q2g_A/2q2g_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2q2g_A/2q2g_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2q2g_A/2q2g_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2q2g_A/2q2g_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2q2g_A/2q2g_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o87_A/4o87_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2q2g_A/2q2g_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o87_A/4o87_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o87_A/4o87_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o87_A/4o87_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2y39_A/2y39_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o87_A/4o87_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2y39_A/2y39_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2y39_A/2y39_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2y39_A/2y39_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/4o87_A/4o87_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2y39_A/2y39_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2y39_A/2y39_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fpn_A/3fpn_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fpn_A/3fpn_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fpn_A/3fpn_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fpn_A/3fpn_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fpn_A/3fpn_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vi1_A/2vi1_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/3fpn_A/3fpn_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vi1_A/2vi1_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vi1_A/2vi1_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vi1_A/2vi1_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vi1_A/2vi1_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ok0_A/1ok0_A_R3.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/2vi1_A/2vi1_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ok0_A/1ok0_A_R1.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ok0_A/1ok0_A_R2.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ok0_A/1ok0_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ok0_A/1ok0_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/1ok0_A/1ok0_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6jpt_A/6jpt_A_R1.tpr filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6jpt_A/6jpt_A_R3.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6jpt_A/6jpt_A_R2.xtc filter=lfs diff=lfs merge=lfs -text
+atlas_1000_analysis/6jpt_A/6jpt_A_R3.tpr filter=lfs diff=lfs merge=lfs -text

LD-FPG-main/README.md

@@ -0,0 +1,134 @@
+# Generative Modeling of Full-Atom Protein Conformations (LD-FPG)
+
+## 🧬 Overview
+
+This repository provides the Python-based implementation for the **Latent Diffusion for Full Protein Generation (LD-FPG)** framework, as described in our NeurIPS 2025 paper submission, "Generative Modeling of Full-Atom Protein Conformations using Latent Diffusion on Graph Embeddings."
+
+The primary goal of this project is to generate diverse, all-atom conformational ensembles of proteins. This is achieved by learning from Molecular Dynamics (MD) simulation data through a multi-stage pipeline:
+
+1. **Autoencoder Training:** A Chebyshev Graph Neural Network (ChebNet) based autoencoder learns a compressed latent representation of protein conformations. Different pooling strategies are explored to create this representation.
+2. **Latent Diffusion Model Training:** A Denoising Diffusion Probabilistic Model (DDPM) is trained on the distribution of these learned latent embeddings.
+3. **Structure Reconstruction:** New latent embeddings sampled by the trained diffusion model are decoded back into full-atom 3D protein coordinates.
+
+This repository contains implementations for three distinct pooling strategies within the LD-FPG framework:
+
+- **Blind Pooling:** Uses a global pooling mechanism over all atom embeddings.
+- **Residue-based Pooling:** Focuses on residue-level deformations and contexts.
+- **Sequential Pooling:** Decodes the protein structure in stages, typically backbone first, then sidechains.
+
+Implementations for each strategy, including the necessary scripts and configuration files, are organized into their respective dedicated directories. Shared utility Python files for common tasks like data processing, model components, and training helpers are also provided.
+
+Detailed instructions for running each specific pooling strategy can be found in the `README.md` file within its corresponding directory.
+
+---
+
+## ⚙️ Prerequisites & Dependencies
+
+### Software Requirements
+
+- **Python:** Version 3.8 or higher is recommended
+- **CUDA:** For GPU acceleration, ensure you have a compatible CUDA toolkit installed. The PyTorch and PyTorch Geometric versions should match your CUDA version
+
+### Core Python Libraries
+
+The primary dependencies include:
+
+- **PyTorch:** For tensor computations and neural network building (Version compatible with your PyTorch Geometric and CUDA versions)
+- **PyTorch Geometric (PyG):** For graph neural network functionalities
+- **h5py:** For reading and writing HDF5 files (used for storing large datasets like coordinates and embeddings)
+- **PyYAML:** For parsing YAML configuration files
+- **NumPy:** For numerical operations
+- **scikit-learn:** For utilities like data splitting
+
+### Installation
+
+You can install these libraries using pip:
+
+```bash
+# 1. Install PyTorch (visit https://pytorch.org/get-started/locally/ for specific command)
+# Example for CUDA 11.8:
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+
+# 2. Install PyTorch Geometric (ensure compatibility with your PyTorch & CUDA version)
+# See: https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html
+pip install torch_geometric
+
+# Optional: For CUDA accelerated operations if not automatically included
+# pip install pyg_lib torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-${TORCH}+${CUDA}.html
+# (Replace ${TORCH} and ${CUDA} with your PyTorch and CUDA versions, e.g., 2.0.0 and cu118)
+
+# 3. Install other dependencies
+pip install h5py pyyaml numpy scikit-learn
+```
+
+Please refer to the official installation guides for PyTorch and PyTorch Geometric to ensure compatibility with your specific hardware and CUDA setup.
+
+## 📁 Input Data Files
+
+The scripts require specific input data files, typically placed in a `helper/` directory (or paths configured in the YAML files):
+
+### Reference PDB File
+- **Description:** A Protein Data Bank (PDB) file containing the heavy atom structure of your target protein. This is used for initial atom indexing and as a structural reference.
+- **Example:** `helper/heavy_chain.pdb`
+
+### Molecular Dynamics Trajectory Data
+- **Description:** A JSON file containing per-frame heavy atom coordinates from your MD simulation. The format should be compatible with the data loading functions used in the scripts.
+- **Example:** `helper/my_protein.json`
+
+> **Note:** For large trajectory datasets, consider hosting them on a data repository like Zenodo and downloading them as needed. The D2R-MD dataset used in the paper is available at: https://zenodo.org/records/15479781
+
+### Dihedral Angle Definition File (Optional)
+- **Description:** A JSON file defining the atom quadruplets for standard dihedral angle calculations (e.g., φ, ψ, χ₁-χ₅). This is required if you enable dihedral angle-based loss terms during autoencoder training. The atom indexing in this file must correspond to the indexing derived from your reference PDB file.
+- **Example:** `helper/condensed_residues.json`
+
+Ensure these files are correctly formatted and accessible to the scripts by placing them in the expected locations or updating the paths in the respective `param.yaml` configuration files.
+
+## 🚀 General Workflow
+
+While each pooling strategy's directory (`blind/`, `residue/`, `sequential/`) has its specific README.md with detailed execution commands, the general workflow involves three main script executions:
+
+### 1. Autoencoder Training
+- Trains the ChebNet encoder and the specific pooling-based decoder
+- Saves trained model checkpoints (encoder and decoder)
+- Generates and saves the pooled latent embeddings (h₀) of the input MD data. This output is crucial for the next stage
+
+### 2. Latent Diffusion Model Training
+- Trains a DDPM on the distribution of pooled latent embeddings (h₀) from the previous stage
+- Saves the trained diffusion model checkpoint
+- Generates and saves new latent embeddings (h₀ᵍᵉⁿ) sampled from the trained DDPM
+
+### 3. Structure Reconstruction
+- Loads the trained decoder from Stage 1
+- Loads the novel latent embeddings (h₀ᵍᵉⁿ) from Stage 2
+- Loads the appropriate conditioner (e.g., reference structure's latent embedding Z_ref)
+- Decodes the new latent embeddings to produce the final all-atom 3D protein coordinates
+
+Please refer to the `README.md` inside each specific strategy folder for detailed command-line examples and configuration guidance.
+
+## 🤝 Contributing
+
+We welcome contributions to improve the LD-FPG framework! Please feel free to:
+
+- Report bugs or issues
+- Suggest new features or improvements
+- Submit pull requests
+
+
+## 📜 License
+
+This project is licensed under the **Creative Commons Attribution 4.0 International License (CC BY 4.0)**.
+
+This means you are free to:
+- **Share** — copy and redistribute the material in any medium or format
+- **Adapt** — remix, transform, and build upon the material for any purpose, even commercially
+
+Under the following terms:
+- **Attribution** — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use
+- **No additional restrictions** — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits
+
+For more details, see the [LICENSE](LICENSE) file or visit [Creative Commons CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
+
+---
+
+**⭐ If you find this work useful, please consider starring this repository!**
+

LD-FPG-main/blind/README.md

@@ -0,0 +1,368 @@
+# Project Title: Generative Modeling of Full-Atom Protein Conformations (LD-FPG Implementation)
+
+## 🧬 Overview
+
+This repository provides a Python-based implementation of the **Latent Diffusion for Full Protein Generation (LD-FPG)** framework, focusing on the **Blind Pooling** strategy. The goal is to generate diverse, all-atom conformational ensembles of proteins by learning from Molecular Dynamics (MD) simulation data. This work is intended for submission to NeurIPS 2025 and is based on the methodology described in the accompanying paper, "Generative Modeling of Full-Atom Protein Conformations using Latent Diffusion on Graph Embeddings."
+
+The pipeline consists of three main stages:
+
+1.  **Autoencoder Training (chebnet_blind.py):** A Chebyshev Graph Neural Network (ChebNet) based autoencoder (HNO Encoder + Decoder2 MLP) is trained to learn a compressed latent representation (a global pooled embedding $\mathbf{h}_0$) of protein conformations.
+2.  **Latent Diffusion Model Training (new_diff.py):** A Denoising Diffusion Probabilistic Model (DDPM) is trained on the distribution of these pooled latent embeddings $\mathbf{h}_0$.
+3.  **Structure Reconstruction (chebnet_diff.py):** New latent embeddings $\mathbf{h}_0^{\text{gen}}$ sampled by the trained diffusion model are decoded back into full-atom 3D protein coordinates using the trained Decoder2 MLP.
+
+---
+
+## 🛠️ Methodology Highlights
+
+The core methodology implemented in this repository involves:
+
+1.  **Stage 1: ChebNet Autoencoder (chebnet_blind.py)**
+   
+       **Encoder (HNO):** Employs a stack of ChebConv layers to process protein structures (represented as graphs) and generate atom-wise latent embeddings.
+
+       **Pooling:** For the "Blind Pooling" strategy, these atom-wise embeddings are globally pooled (using AdaptiveAvgPool2d) across all atoms to create a single, compact latent vector $\mathbf{h}_0$ for each conformation.
+    
+       **Decoder (Decoder2):** An MLP that takes the pooled latent vector $\mathbf{h}_0$ and a conditioner (e.g., latent representation of a reference structure, $Z_{\text{ref}}$) to reconstruct the full-atom Cartesian coordinates.
+    
+       **Dihedral Loss (Optional):** The decoder training can be augmented with loss terms based on dihedral angles to improve geometric realism.
+    
+2.  **Stage 2: Latent Diffusion Model (new_diff.py)**
+    * Takes the $\mathbf{h}_0$ embeddings (generated and saved by chebnet_blind.py) as input.
+    * Trains a DDPM (either MLP-based or Conv2D-based denoiser) to learn the manifold of these compact latent representations.
+    * Generates new $\mathbf{h}_0^{\text{gen}}$ samples by reversing the diffusion process.
+3.  **Stage 3: Structure Reconstruction from Diffused Latents (chebnet_diff.py)**
+    * Uses the trained Decoder2 MLP from Stage 1.
+    * Takes the novel $\mathbf{h}_0^{\text{gen}}$ samples (generated by new_diff.py) and the same conditioner used during Decoder2 training.
+    * Outputs the final generated all-atom protein structures.
+
+---
+
+## 📂 Repository Structure
+
+```
+.
+├── chebnet_blind.py        # Script for Stage 1: Autoencoder training
+├── param.yaml                # Configuration for chebnet_blind.py
+├── new_diff.py               # Script for Stage 2: Latent diffusion model training
+├── param_diff.yaml           # Configuration for new_diff.py
+├── chebnet_diff.py           # Script for Stage 3: Reconstruction from diffused latents
+├── README.md                 # This file
+│
+├── helper/                   # Directory for input data files
+│   ├── heavy_chain.pdb         # Example reference PDB structure
+│   ├── my_protein.json       # Example MD trajectory data (or link to Zenodo)
+│   └── condensed_residues.json # Example dihedral angle definitions (optional)
+│
+├── checkpoints/              # Default output directory for trained model weights
+│   ├── hno_checkpoint.pth
+│   ├── decoder2_checkpoint.pth
+│   └── diffusion_checkpoint_exp<N>.pth
+│
+├── structures/               # Default output directory for coordinate files
+│   ├── X_ref_coords.pt
+│   ├── ground_truth_aligned.h5
+│   ├── hno_reconstructions.h5
+│   ├── full_coords.h5          # Reconstructions from original data by Decoder2
+│   └── full_coords_diff.h5     # Final generated structures from diffused latents
+│
+└── latent_reps/              # Default output directory for latent embeddings
+    ├── z_ref_embedding.pt
+    ├── hno_embeddings.h5
+    ├── pooled_embedding.h5     # Output of Stage 1, input to Stage 2
+    └── generated_embeddings_exp<N>.h5 # Output of Stage 2, input to Stage 3
+```
+
+Log files (e.g., logfile_script2_mod.log, diffusion_runner.log) will also be created in the root directory or as specified.
+
+---
+
+## ⚙️ Prerequisites
+
+* **Python:** 3.8+
+* **Core Libraries:**
+    * PyTorch (version compatible with PyG)
+    * PyTorch Geometric (PyG)
+    * h5py
+    * PyYAML
+    * NumPy
+    * scikit-learn
+    
+```bash
+    # Example installation (adjust for your PyTorch/CUDA version)
+    # See: [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)
+    # See: [https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html)
+    pip install torch torchvision torchaudio
+    pip install torch_geometric
+    pip install h5py pyyaml numpy scikit-learn
+```
+
+* **CUDA:** Recommended for GPU acceleration. Ensure your PyTorch and PyG installations are CUDA-compatible.
+* **Input Data Files** (place in helper/ or update paths in YAML configurations):
+  
+    **Reference PDB file:** A PDB file containing the heavy atom structure of your protein (e.g., helper/heavy_chain.pdb). Used for initial atom indexing and as a reference.
+  
+    **Molecular Dynamics Trajectory Data:** A JSON file containing per-frame heavy atom coordinates. The format should be compatible with the load_heavy_atom_coords_from_json function in chebnet_blind.py (e.g., helper/my_protein.json). For large datasets, consider hosting on Zenodo and downloading.
+  
+    **Dihedral Angle Definition File (Optional):** A JSON file defining atoms for dihedral angle calculations (e.g., helper/condensed_residues.json). Required if dihedral_loss.use_dihedral_loss is true in param.yaml. This file should map to the atom indexing derived from your PDB.
+
+---
+
+## 🚀 Workflow: Generating Protein Conformations
+
+Follow these steps sequentially to generate new protein conformations.
+
+### Step 1: Training the ChebNet Autoencoder (chebnet_blind.py)
+
+* **Purpose:** Train the HNO encoder and the Decoder2 MLP. This stage learns to compress protein structures into a global pooled latent representation ($\mathbf{h}_0$) and reconstruct them.
+* **Configuration (param.yaml):**
+    **data.json_path**: Path to your MD trajectory JSON file (e.g., helper/my_protein.json).
+  
+    **data.pdb_path**: Path to your reference PDB file (e.g., helper/heavy_chain.pdb).
+  
+    **hno_encoder**: Settings for the ChebNet encoder (e.g., hidden_dim, cheb_order, num_epochs, learning_rate).
+  
+    **decoder2**: Training settings for the Decoder2 MLP.
+  
+    **decoder2_settings**:
+  
+        * conditioner_mode: "z_ref" (recommended, uses latent embedding of reference) or "X_ref" (uses coordinates of reference).
+  
+        * pooling_type: Should be "blind" for this workflow.
+  
+        * output_height, output_width: Dimensions for the AdaptiveAvgPool2d in blind pooling. The product (output_height * output_width) defines the dimension of the pooled latent vector $\mathbf{h}_0$.
+  
+        * mlp_hidden_dim, num_hidden_layers: Architecture of the Decoder2 MLP.
+  
+    **dihedral_loss (Optional):**
+  
+        * use_dihedral_loss: true or false.
+  
+        * torsion_info_path: Path to dihedral definition JSON (e.g., helper/condensed_residues.json).
+  
+    **output_directories**: Specify paths for checkpoint_dir, structure_dir, latent_dir.
+  
+* **Execution:**
+    
+```bash
+    python chebnet_blind.py --config param.yaml
+```
+    Add --debug for verbose logging.
+* **Key Inputs:**
+    * param.yaml
+    * Reference PDB (data.pdb_path)
+    * MD trajectory JSON (data.json_path)
+    * (Optional) Dihedral definition JSON (dihedral_loss.torsion_info_path)
+* **Key Outputs:**
+    * checkpoints/hno_checkpoint.pth: Trained HNO encoder weights.
+    * checkpoints/decoder2_checkpoint.pth: Trained Decoder2 MLP weights.
+      
+    **latent_reps/pooled_embedding.h5**: Pooled latent embeddings ($\mathbf{h}_0$) of the input MD data. **This is the primary input for Step 2.** (Dataset key: pooled_embedding).
+      
+    * structures/X_ref_coords.pt: Saved reference coordinates.
+    * latent_reps/z_ref_embedding.pt: Saved latent embedding of the reference structure (if conditioner_mode: "z_ref").
+    * Other analytical files (e.g., ground_truth_aligned.h5, hno_embeddings.h5).
+
+### Step 2: Training the Latent Diffusion Model (new_diff.py)
+
+* **Purpose:** Train a DDPM on the distribution of pooled latent embeddings ($\mathbf{h}_0$) generated in Step 1. This model will then be able to generate new $\mathbf{h}_0^{\text{gen}}$ samples.
+* **Configuration (param_diff.yaml):**
+    * run_mode: "grid_search" or "user_defined". For a single run, "user_defined" can be simpler if parameters are set directly in the parameters block. Curated grid search is also an option.
+      
+    **parameters.h5_file_path**: Path to pooled_embedding.h5 generated in Step 1 (e.g., latent_reps/pooled_embedding.h5).
+      
+    **parameters.dataset_key**: Should be pooled_embedding.
+  
+    **parameters.pooling**: Must be "blind" to match Step 1's output for this workflow.
+  
+    * parameters.model_type: Diffusion model architecture (e.g., "mlp_v2", "conv2d").
+    * parameters.diffusion_steps, parameters.beta_start, parameters.beta_end: Diffusion schedule parameters.
+    * parameters.num_epochs, parameters.learning_rate, parameters.batch_size.
+    * parameters.output_dir: Directory to save diffusion model outputs (e.g., latent_reps).
+    * parameters.decoder2_settings: If model_type: "conv2d" and pooling: "blind", these output_height and output_width must be set such that their product equals the dimension of the embeddings in pooled_embedding.h5 (i.e., param.yaml's decoder2_settings.output_height * decoder2_settings.output_width).
+* **Execution:**
+    
+```bash
+    # For a user-defined run (ensure 'run_mode: user_defined' in YAML or parameters directly set)
+    python new_diff.py --config param_diff.yaml
+    # For a specific experiment from a grid search (e.g., if 'run_mode: grid_search')
+    # python new_diff.py --config param_diff.yaml --exp_idx 1
+```
+    Use --instance_id for parallel grid search execution. Add --debug for verbose logs.
+* **Key Inputs:**
+    * param_diff.yaml
+    * latent_reps/pooled_embedding.h5 (from Step 1)
+* **Key Outputs (within parameters.output_dir, e.g., latent_reps/):**
+    * checkpoints/diffusion_checkpoint_exp<N>.pth: Trained diffusion model weights for experiment <N>.
+    ***generated_embeddings_exp<N>.h5**: Newly generated pooled latent embeddings ($\mathbf{h}_0^{\text{gen}}$) from experiment <N>. **This is the primary input for Step 3.** (Dataset key: generated_embeddings). The <N> corresponds to the global experiment index if running a grid search.
+
+### Step 3: Reconstructing Structures from Diffused Latents (chebnet_diff.py)
+
+* **Purpose:** Use the trained Decoder2 MLP (from Step 1) to decode the novel latent embeddings (generated by Step 2) back into full-atom 3D protein coordinates.
+* **Configuration:** This script uses param.yaml (from Step 1) via the --config argument to correctly instantiate the Decoder2 MLP architecture.
+* **Execution:**
+    
+```bash
+    python chebnet_diff.py \
+        --config param.yaml \
+        --decoder2_ckpt checkpoints/decoder2_checkpoint.pth \
+        --diff_emb_file latent_reps/generated_embeddings_exp<N>.h5 \
+        --conditioner_x_ref_pt structures/X_ref_coords.pt \
+        --conditioner_z_ref_pt latent_reps/z_ref_embedding.pt \
+        --output_file structures/full_coords_diff_exp<N>.h5
+```
+    * Replace <N> with the experiment index from Step 2 whose outputs you want to use. See "Understanding Outputs and File Conventions" below on how to choose.
+    * --config: Path to the **param.yaml used in Step 1**.
+    * --decoder2_ckpt: Path to decoder2_checkpoint.pth from Step 1.
+    * --diff_emb_file: Path to the generated_embeddings_exp<N>.h5 from Step 2.
+    * --conditioner_x_ref_pt: Path to X_ref_coords.pt from Step 1.
+    * --conditioner_z_ref_pt: Path to z_ref_embedding.pt from Step 1 (required if conditioner_mode was z_ref).
+    * --output_file: (Optional) Specify output path for decoded coordinates.
+* **Key Inputs:**
+    * param.yaml (from Step 1, for decoder architecture)
+    * checkpoints/decoder2_checkpoint.pth (from Step 1)
+    * latent_reps/generated_embeddings_exp<N>.h5 (from Step 2)
+    * structures/X_ref_coords.pt (from Step 1)
+    * latent_reps/z_ref_embedding.pt (from Step 1, if using z_ref conditioner)
+* **Key Output:**
+    * HDF5 file (e.g., structures/full_coords_diff_exp<N>.h5) containing the final generated 3D atomic coordinates. (Dataset key: full_coords_diff by default).
+
+---
+
+## ✨ Example Usage
+
+This assumes default file names and output locations where applicable.
+
+**Step 1: Train Autoencoder**
+```bash
+# Ensure helper/my_protein.json, helper/heavy_chain.pdb exist
+# Ensure param.yaml is configured correctly (paths, pooling_type: "blind", etc.)
+python chebnet_blind.py --config param.yaml
+```
+
+**Step 2: Train Latent Diffusion Model**
+```bash
+# Ensure latent_reps/pooled_embedding.h5 exists from Step 1
+# Ensure param_diff.yaml is configured (run_mode, h5_file_path, output_dir, etc.)
+# Example: Running experiment 1 from a grid search defined in param_diff.yaml
+python new_diff.py --config param_diff.yaml --exp_idx 1
+```
+This will create latent_reps/generated_embeddings_exp1.h5 and latent_reps/checkpoints/diffusion_checkpoint_exp1.pth (or similar, based on the output_dir in param_diff.yaml).
+
+**Step 3: Reconstruct Structures**
+```bash
+# Ensure checkpoints/decoder2_checkpoint.pth, structures/X_ref_coords.pt,
+# latent_reps/z_ref_embedding.pt (if z_ref mode) exist from Step 1.
+# Ensure latent_reps/generated_embeddings_exp1.h5 exists from Step 2.
+python chebnet_diff.py \
+    --config param.yaml \
+    --decoder2_ckpt checkpoints/decoder2_checkpoint.pth \
+    --diff_emb_file latent_reps/generated_embeddings_exp1.h5 \
+    --conditioner_x_ref_pt structures/X_ref_coords.pt \
+    --conditioner_z_ref_pt latent_reps/z_ref_embedding.pt \
+    --output_file structures/full_coords_diff_exp1.h5
+```
+
+## 🗂️ Understanding Outputs and File Conventions
+
+This section details the various file types and naming conventions used in the pipeline.
+
+### File Types
+
+**.ckpt / .pth (Checkpoint Files):**
+- **What:** These files (often with .pth extension for PyTorch) store the learned parameters (weights) of a neural network at a specific point in training. They may also include the state of the optimizer and the epoch number.
+- **Purpose:** Allows you to resume training from where it left off or use a pre-trained model for inference without retraining from scratch.
+- **Examples:** hno_checkpoint.pth, decoder2_checkpoint.pth, diffusion_checkpoint_exp<N>.pth.
+
+**.h5 (HDF5 Files):**
+- **What:** Hierarchical Data Format version 5. A binary file format designed for storing and organizing large amounts of numerical data.
+- **Purpose:** Used to efficiently store multi-frame coordinate data, large batches of latent embeddings, and final generated structures. HDF5 files can contain multiple "datasets" within them, like folders in a file system.
+- **Keys:** Each dataset within an HDF5 file is accessed by a "key" (a string name). For example, pooled_embedding.h5 might contain a dataset with the key "pooled_embedding". These keys are often specified in the configuration files or script arguments.
+- **Examples:** pooled_embedding.h5, generated_embeddings_exp<N>.h5, full_coords_diff.h5.
+
+**.pt (PyTorch Tensor Files):**
+- **What:** Files created using torch.save() to store single PyTorch tensors or small collections of tensors.
+- **Purpose:** Used in this pipeline for saving relatively small, specific tensors like the reference coordinates (X_ref_coords.pt) or the reference latent embedding (z_ref_embedding.pt).
+- **Examples:** structures/X_ref_coords.pt, latent_reps/z_ref_embedding.pt.
+
+**.json (JSON Files):**
+- **What:** JavaScript Object Notation. A lightweight, human-readable text format for data interchange.
+- **Purpose:** Used for input data, specifically the MD trajectory data (my_protein.json) and the optional dihedral angle definitions (condensed_residues.json).
+- **Examples:** helper/my_protein.json, helper/condensed_residues.json.
+
+**.yaml (YAML Files):**
+- **What:** YAML Ain't Markup Language. A human-readable data serialization language often used for configuration files.
+- **Purpose:** To define parameters and settings for the scripts (chebnet_blind.py, new_diff.py).
+- **Examples:** param.yaml, param_diff.yaml.
+
+**.log (Log Files):**
+- **What:** Text files that record the operational history of the scripts, including informational messages, warnings, errors, and progress updates.
+- **Purpose:** Essential for monitoring the training process, debugging issues, and tracking experiment parameters and results.
+- **Examples:** logfile_script2_mod.log, diffusion_runner.log.
+
+### Experiment Outputs and Naming (exp<N>)
+
+**The exp<N> Suffix:**
+- When you run new_diff.py (Stage 2), especially in grid_search mode or if you run it multiple times with different settings, it can execute several "experiments." Each experiment typically corresponds to a unique set of hyperparameters for the diffusion model (e.g., different learning rates, beta schedules, diffusion steps).
+- The outputs from each of these diffusion experiments are distinguished by an experiment index <N> (e.g., exp1, exp2). So, diffusion_checkpoint_exp1.pth is the checkpoint for the first diffusion experiment, and generated_embeddings_exp1.h5 contains the latent embeddings generated by that specific trained diffusion model. <N> is a 1-based global index across all experiments defined in your grid or run sequentially.
+
+**Choosing Which generated_embeddings_exp<N>.h5 to Use for Step 3:**
+- After running new_diff.py for one or more experiments, you will have one or more generated_embeddings_exp<N>.h5 files.
+- You need to select which of these files to use as input for chebnet_diff.py (Stage 3).
+- How to choose? This typically involves evaluating the quality of the diffusion model from each experiment <N>.
+  - **Check Logs:** The log file from new_diff.py (e.g., diffusion_runner.log) will contain training loss information for each experiment. Lower, stable losses generally indicate better training.
+  - **Qualitative Assessment (Optional but Recommended):** You might decode a small number of samples from each generated_embeddings_exp<N>.h5 using chebnet_diff.py and visually inspect the resulting structures or run quick quality checks.
+  - **Quantitative Metrics (Advanced):** If you have established metrics for latent space quality or downstream structure quality, you could apply them.
+- Once you've identified the "best" diffusion experiment (say, experiment k), you will use latent_reps/generated_embeddings_exp<k>.h5 as the --diff_emb_file argument for chebnet_diff.py.
+
+**Linking Outputs Across Stages:**
+- **Stage 1 Output (chebnet_blind.py) -> Stage 2 Input (new_diff.py):**
+  - latent_reps/pooled_embedding.h5 (containing $\mathbf{h}_0$ for all input frames) is the crucial input for training the diffusion model.
+- **Stage 1 Outputs (chebnet_blind.py) -> Stage 3 Inputs (chebnet_diff.py):**
+  - checkpoints/decoder2_checkpoint.pth (the trained Decoder2 MLP).
+  - structures/X_ref_coords.pt (if conditioner is X_ref).
+  - latent_reps/z_ref_embedding.pt (if conditioner is z_ref).
+  - The param.yaml file itself (to know the Decoder2 architecture).
+- **Stage 2 Output (new_diff.py) -> Stage 3 Input (chebnet_diff.py):**
+  - The selected latent_reps/generated_embeddings_exp<N>.h5 (containing new $\mathbf{h}_0^{\text{gen}}$ samples).
+
+## 🔧 Customization and Advanced Use
+
+- **Dihedral Loss:** Enable and configure dihedral loss in param.yaml during Step 1 (chebnet_blind.py) to potentially improve the geometric quality of reconstructed structures. Requires a torsion_info_path to a JSON file defining dihedrals.
+- **Pooling Strategy:** While this README focuses on "Blind Pooling", the ProteinStateReconstructor2D class in chebnet_blind.py has stubs for "Residue Pooling". Adapting the scripts fully for other pooling strategies would require ensuring data flow and dimensionality consistency across all three stages. The new_diff.py script also has a selected pooling mode which could be adapted for per-residue diffusion.
+- **Diffusion Model Architecture:** new_diff.py supports different MLP architectures (mlp, mlp_v2, mlp_v3) and a conv2d model for the denoiser, configurable in param_diff.yaml.
+- **Hyperparameter Tuning:** The YAML configuration files (param.yaml, param_diff.yaml) provide extensive options for tuning model architectures, learning rates, batch sizes, diffusion schedules, etc. new_diff.py supports grid searches partitioned by instance_id or running specific experiments via exp_idx.
+
+## 📄 Citing this Work
+
+If you use this code or the LD-FPG methodology in your research, please cite our NeurIPS 2025 paper:
+
+[Placeholder for NeurIPS Paper Citation - To be added upon acceptance/publication]
+
+Title: Generative Modeling of Full-Atom Protein Conformations using Latent Diffusion on Graph Embeddings
+Authors: [Author One, Author Two, et al.]
+Conference: Advances in Neural Information Processing Systems (NeurIPS) 2025.
+
+## 🐛 Troubleshooting
+
+- **Dimension Mismatches:** Carefully check that the output dimensions from one stage match the expected input dimensions for the next, especially the pooled_embedding dimension. For "Blind Pooling", param.yaml's decoder2_settings.output_height * decoder2_settings.output_width defines this dimension. If using a conv2d diffusion model in new_diff.py, ensure its expected input shape (derived from param_diff.yaml's decoder2_settings) is compatible with this dimension.
+- **File Not Found:** Double-check all paths in your YAML configuration files and command-line arguments. Use absolute paths if relative paths cause issues. Ensure the helper/ directory is correctly populated or paths are updated.
+- **CUDA Errors:** Ensure your PyTorch and PyG versions are compatible with your CUDA toolkit and GPU drivers. If encountering out-of-memory errors, reduce batch sizes.
+- **Log Files:** Consult logfile_script2_mod.log (for chebnet_blind.py) and diffusion_runner.log (for new_diff.py) for detailed error messages and progress updates. chebnet_diff.py logs to standard output.
+
+---
+
+## 📜 License
+
+This project is licensed under the [Creative Commons Attribution 4.0 International License (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/).
+
+[![CC BY 4.0](https://licensebuttons.net/l/by/4.0/88x31.png)](https://creativecommons.org/licenses/by/4.0/)
+
+This means you are free to:
+* **Share** — copy and redistribute the material in any medium or format
+* **Adapt** — remix, transform, and build upon the material
+for any purpose, even commercially.
+
+Under the following terms:
+* **Attribution** — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+
+No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.

LD-FPG-main/blind/chebnet_blind.py

@@ -0,0 +1,1192 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from typing import Dict, List, Optional, Tuple, Any
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Mod Script 2)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load (Minimal, just for log file path)
+################################################################################
+LOG_FILE_DEFAULT = "logfile_script2_mod.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    # Temporarily load config just for the log file path
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstruction")
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+if not logger.handlers:
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    # File Handler
+    try:
+        fh = logging.FileHandler(log_file_path, mode="w")
+        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+    except IOError as e:
+        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+        # Define formatter here if file handler failed
+        if 'formatter' not in locals():
+            formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    # Console Handler
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    if 'formatter' not in locals(): # Ensure formatter exists
+         formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+logger.info(f"Logger initialized. Log file: {log_file_path}")
+if args.debug: logger.debug("Debug mode is ON.")
+else: logger.info("Debug mode is OFF.")
+
+################################################################################
+# (D) Device Setup (Global)
+################################################################################
+device_name = "cpu"
+if torch.cuda.is_available():
+    try:
+        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
+        device_name = f"cuda:{cuda_device_index}"
+        torch.cuda.get_device_name(cuda_device_index) # Test validity
+    except Exception:
+        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
+        if torch.cuda.is_available(): device_name = "cuda:0"
+global_device = torch.device(device_name)
+logger.info(f"Initial device check: {global_device}")
+
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+# --- PDB Parsing ---
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List]:
+    """Parses ATOM records from a PDB file, handling alternate locations."""
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; processed_atom_indices = set()
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line_num, line in enumerate(pdb_file, 1):
+                if not line.startswith("ATOM  "): continue
+                try:
+                    atom_serial = int(line[6:11]); atom_name = line[12:16].strip()
+                    alt_loc = line[16].strip(); res_name = line[17:20].strip()
+                    chain_id = line[21].strip(); res_seq = int(line[22:26])
+                except ValueError as e: logger.warning(f"Skipping PDB line {line_num}: {e}"); continue
+                if alt_loc != '' and alt_loc != 'A': continue
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+                atoms_in_order.append((orig_res_id, atom_serial, category))
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, []
+    except Exception as e: logger.error(f"Error reading PDB {filename}: {e}", exc_info=True); return {}, []
+    if not atoms_in_order: logger.error(f"No valid ATOM records found: {filename}")
+    else: logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}.")
+    return {}, atoms_in_order
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str]], logger: logging.Logger) -> Tuple[Dict, Dict]:
+    """Renumbers residues and atoms consecutively starting from 0."""
+    new_res_dict, orig_atom_map, orig_res_map = {}, {}, {}
+    next_new_res_id, next_new_atom_index = 0, 0; seen_res_order, res_order_counter = {}, 0
+    for r_id, _, _ in atoms_in_order:
+        if r_id not in seen_res_order: seen_res_order[r_id] = res_order_counter; res_order_counter += 1
+    sortable = [(seen_res_order[r_id], serial, r_id, cat) for r_id, serial, cat in atoms_in_order]; sortable.sort()
+    for _, serial, r_id, cat in sortable:
+        if r_id not in orig_res_map: orig_res_map[r_id] = next_new_res_id; new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}; next_new_res_id += 1
+        new_res_id = orig_res_map[r_id]; new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index; next_new_atom_index += 1
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms.")
+    return new_res_dict, orig_atom_map
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[List[int], List[int]]:
+    """Extracts sorted global lists of backbone and sidechain atom indices."""
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()): bb_idx.extend(renumbered_dict[res_id]["backbone"]); sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return bb_idx, sc_idx
+
+# --- JSON Loading ---
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    """Loads coordinates from JSON assuming 0-based integer keys."""
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+    except FileNotFoundError: logger.error(f"JSON not found: {json_file}"); return [], -1
+    except json.JSONDecodeError as e: logger.error(f"JSON decoding error: {e}"); return [], -1
+    try:
+        keys_int = sorted([int(k) for k in data.keys()]); keys_str = [str(k) for k in keys_int]
+        if not keys_str: logger.error("No residue data in JSON."); return [], -1
+        logger.info(f"Found {len(keys_str)} residues in JSON.")
+        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
+        N_frames = len(frame_data)
+        if N_frames == 0 or np.array(frame_data[0][0]).shape != (3,): raise ValueError("Invalid frame data")
+        logger.info(f"Found {N_frames} frames in JSON.")
+    except Exception as e: logger.error(f"Invalid JSON structure or keys: {e}"); return [], -1
+    coords_frames, N_atoms_check = [], -1
+    for frame_idx in range(N_frames):
+        frame_coords_np, current_atoms = [], 0
+        for res_key in keys_str:
+            try:
+                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
+                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad Shape")
+                frame_coords_np.append(coords); current_atoms += coords.shape[0]
+            except Exception as e: logger.error(f"Error processing res {res_key} frame {frame_idx}: {e}"); return [], -1
+        if frame_idx == 0: N_atoms_check = current_atoms; logger.info(f"Atoms/frame from JSON: {N_atoms_check}")
+        elif current_atoms != N_atoms_check: logger.error("Inconsistent atom count"); return [], -1
+        try: coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))
+        except ValueError as e: logger.error(f"Concat error frame {frame_idx}: {e}"); return [], -1
+    if not coords_frames: logger.error("Failed to load frames."); return [], -1
+    return coords_frames, N_atoms_check
+
+# --- Alignment ---
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Aligns Q onto P using Kabsch algorithm. Handles batches [B, N, 3]."""
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
+    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try: V, S, Wt = torch.linalg.svd(C)
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
+        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
+        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
+        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
+    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
+    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
+    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    """Aligns all coordinate frames to the first frame using Kabsch. Returns list on CPU."""
+    logger.info("Aligning coordinate frames...")
+    if not coords: logger.warning("Coordinate list empty."); return []
+    ref = coords[0].float().to(device); aligned = [coords[0].cpu()]
+    N_frames = len(coords) - 1
+    for i, frame in enumerate(coords[1:], 1):
+        _, aligned_dev = kabsch_algorithm(ref, frame.float().to(device), logger)
+        aligned.append(aligned_dev.cpu())
+        if (i % 500 == 0 or i == N_frames) and N_frames > 0: logger.info(f"Aligned {i}/{N_frames} frames...")
+    logger.info("Finished aligning frames.")
+    return aligned
+
+# --- Graph Dataset ---
+def build_graph_dataset(coords_list: List[torch.Tensor], knn_neighbors: int, logger: logging.Logger, device: torch.device) -> List[Data]: # Fixed param name
+    """Builds PyG dataset with k-NN graphs. Returns Data objects on CPU."""
+    logger.info(f"Building PyG dataset (k={knn_neighbors}) using device '{device}'...") # Fixed param name
+    dataset = []; N_frames = len(coords_list)
+    for i, coords_cpu in enumerate(coords_list):
+        coords_dev = coords_cpu.to(device)
+        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None) # Fixed param name
+        data = Data(x=coords_cpu, edge_index=edge_idx.cpu(), y=coords_cpu) # Ensure y exists
+        dataset.append(data)
+        if ((i + 1) % 500 == 0 or (i + 1) == N_frames) and N_frames > 0: logger.info(f"Built graph {i+1}/{N_frames}...")
+    logger.info("Finished building PyG dataset.")
+    return dataset
+
+# --- Dihedral Utilities ---
+@torch.jit.script
+def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
+    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
+    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
+    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
+    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)
+
+def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, N_res: int, logger: logging.Logger) -> Dict:
+    """Computes all specified dihedrals vectorially."""
+    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
+    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
+    for name, angle_info in info.items():
+        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
+        angles_out = torch.zeros(B, N_res, device=dev, dtype=coords.dtype)
+        if indices is not None and res_idx is not None and indices[0].numel() > 0:
+            try:
+                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
+                # Check bounds BEFORE indexing
+                max_atom_idx_needed = max(i.max() for i in idx_dev)
+                max_res_idx_needed = res_idx_dev.max()
+                if max_atom_idx_needed >= N_atoms: raise IndexError(f"Atom index {max_atom_idx_needed} >= {N_atoms}")
+                if max_res_idx_needed >= N_res: raise IndexError(f"Residue index {max_res_idx_needed} >= {N_res}")
+
+                a,b,c,d = (coords[:, i, :] for i in idx_dev)
+                values = compute_dihedral(a,b,c,d)
+                angles_out[torch.arange(B,device=dev).unsqueeze(1), res_idx_dev.unsqueeze(0)] = values
+            except IndexError as e: logger.error(f"Idx error computing {name}: {e}", exc_info=False)
+            except Exception as e: logger.error(f"Error computing {name}: {e}", exc_info=True)
+        all_angles[name] = angles_out
+    return all_angles
+
+def compute_angle_kl_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    pd, td = p.detach(), t.detach(); dev = p.device
+    if pd.numel()==0 or td.numel()==0: return torch.tensor(0.0, device=dev)
+    e=torch.linspace(r[0],r[1],n+1,device=pd.device); ph=torch.histc(pd,n,r[0],r[1]); th=torch.histc(td,n,r[0],r[1])
+    eps=1e-10; p_dist=ph/(ph.sum()+eps); t_dist=th/(th.sum()+eps); pld=torch.log(p_dist+eps)
+    return F.kl_div(pld, t_dist, reduction='sum', log_target=False)
+
+def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    pd, td = p.detach(), t.detach(); dev = p.device
+    if pd.numel()==0 or td.numel()==0: return torch.tensor(0.0, device=dev)
+    e=torch.linspace(r[0],r[1],n+1,device=pd.device); ph=torch.histc(pd,n,r[0],r[1]); th=torch.histc(td,n,r[0],r[1])
+    eps=1e-10; Q=ph/(ph.sum()+eps); P=th/(th.sum()+eps); M=0.5*(P+Q); lm=torch.log(M+eps)
+    kl_pm=F.kl_div(lm, P, reduction='sum', log_target=False); kl_qm=F.kl_div(lm, Q, reduction='sum', log_target=False)
+    return F.relu(0.5*(kl_pm+kl_qm))
+
+def compute_angle_wasserstein(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    pd, td = p.detach(), t.detach(); dev = p.device
+    if pd.numel()==0 or td.numel()==0: return torch.tensor(0.0, device=dev)
+    e=torch.linspace(r[0],r[1],n+1,device=pd.device); ph=torch.histc(pd,n,r[0],r[1]); th=torch.histc(td,n,r[0],r[1])
+    eps=1e-10; p_dist=ph/(ph.sum()+eps); t_dist=th/(th.sum()+eps); pcdf=torch.cumsum(p_dist,0); tcdf=torch.cumsum(t_dist,0)
+    return torch.sum(torch.abs(pcdf - tcdf))
+
+# --- Checkpoint Utilities ---
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+    sys.stdout.flush()
+
+def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device); start_epoch = ckpt.get("epoch", 0)
+            try: model.load_state_dict(ckpt["model_state_dict"])
+            except RuntimeError: model.load_state_dict(ckpt["model_state_dict"], strict=False); logger.warning("Loaded model non-strictly.")
+            if optimizer and "optimizer_state_dict" in ckpt:
+                try:
+                    optimizer.load_state_dict(ckpt["optimizer_state_dict"]); logger.info("Optimizer state loaded.")
+                    for state in optimizer.state.values(): # Move optimizer state to device
+                        for k, v in state.items():
+                            if isinstance(v, torch.Tensor): state[k] = v.to(device)
+                except Exception as e: logger.warning(f"Could not load optimizer state: {e}")
+            elif optimizer: logger.warning("Optimizer state not in checkpoint.")
+            model.to(device); logger.info(f"Checkpoint loaded. Resuming after epoch {start_epoch}") # Epoch COMPLETED
+        except Exception as e: logger.error(f"Err loading ckpt: {e}", exc_info=True); start_epoch = 0; logger.warning("Training from scratch.")
+    else: logger.info(f"No ckpt at '{filename}'. Training from scratch."); model.to(device)
+    return model, optimizer, start_epoch # Return completed epoch
+
+# --- MSE Utilities ---
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Computes Overall, Backbone, Sidechain MSE. Assumes flat inputs, indices on device."""
+    crit = nn.MSELoss(); target = target.to(pred.dtype); all_mse = crit(pred, target)
+    bb_mse, sc_mse = torch.tensor(0.,device=pred.device), torch.tensor(0.,device=pred.device)
+    try:
+        if bb_idx.numel() > 0: bb_mse = crit(pred[bb_idx], target[bb_idx])
+        if sc_idx.numel() > 0: sc_mse = crit(pred[sc_idx], target[sc_idx])
+    except IndexError: logger.error("MSE Indexing Error", exc_info=False)
+    return all_mse, bb_mse, sc_mse
+
+# --- MLP Builder ---
+def build_decoder_mlp(in_dim: int, out_dim: int, N_layers: int, h_dim: int = 128) -> nn.Sequential:
+    """Builds MLP with BatchNorm."""
+    layers: List[nn.Module] = []; curr = in_dim
+    if N_layers<=0: raise ValueError("MLP layers must be >= 1.")
+    elif N_layers==1: layers.append(nn.Linear(curr, out_dim))
+    else:
+        layers.extend([nn.Linear(curr, h_dim), nn.BatchNorm1d(h_dim), nn.ReLU()]); curr = h_dim
+        for _ in range(N_layers - 2): layers.extend([nn.Linear(curr, h_dim), nn.BatchNorm1d(h_dim), nn.ReLU()])
+        layers.append(nn.Linear(curr, out_dim))
+    return nn.Sequential(*layers)
+
+
+################################################################################
+# (F) Model Definitions
+################################################################################
+
+# --- HNO Encoder ---
+# --- HNO Encoder (Reverted to Simpler Version + Renamed Layers for Checkpoint Compatibility) ---
+
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged = False  # For one-time debug logging
+        logger.debug(f"Initializing HNO with hidden_dim={hidden_dim}, K={K}")
+        sys.stdout.flush()
+        # Input dimension is 3 (x, y, z coordinates)
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        # BatchNorm applied on the feature dimension (hidden_dim)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        # Final MLP maps back to 3D coordinates
+        self.mlpRep = nn.Linear(hidden_dim, 3)
+
+    def forward(self, x, edge_index, log_debug=False):
+        # x: [N, 3] node features (coordinates)
+        # edge_index: [2, E] graph connectivity
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO] Input x shape: {x.shape}, edge_index shape: {edge_index.shape}")
+
+        # Ensure input is float
+        x = x.float()
+
+        x = self.conv1(x, edge_index)
+        # BatchNorm expects [N, C] or [B, C, L], here it's [N, hidden_dim]
+        x = self.bano1(F.leaky_relu(x))
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO] After conv1+bano1: {x.shape}")
+
+        x = self.conv2(x, edge_index)
+        x = self.bano2(F.leaky_relu(x))
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO] After conv2+bano2: {x.shape}")
+
+        x = self.conv3(x, edge_index)
+        x = self.bano3(F.relu(x)) # Note: ReLU here, LeakyReLU before
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO] After conv3+bano3: {x.shape}")
+
+        # Last graph conv layer
+        x = self.conv4(x, edge_index)
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO] After conv4: {x.shape}")
+
+        # Apply L2 normalization on the node embeddings
+        x = F.normalize(x, p=2.0, dim=1) # dim=1 is the feature dimension
+
+        # Final linear layer to predict coordinates
+        x = self.mlpRep(x)
+
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO] Output (after mlpRep): {x.shape}")
+            self._debug_logged = True # Only log shapes once per instance
+
+        return x
+
+    def forward_representation(self, x, edge_index, log_debug=False):
+        """
+        Returns the latent representation after the final conv and normalization
+        (before final MLP). Output shape: [N, hidden_dim]
+        """
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO.rep] Input x shape: {x.shape}")
+
+        x = x.float() # Ensure input is float
+
+        x = self.conv1(x, edge_index)
+        x = self.bano1(F.leaky_relu(x))
+        if log_debug and not self._debug_logged:
+             logger.debug(f"[HNO.rep] After conv1+bano1: {x.shape}")
+
+        x = self.conv2(x, edge_index)
+        x = self.bano2(F.leaky_relu(x))
+        if log_debug and not self._debug_logged:
+             logger.debug(f"[HNO.rep] After conv2+bano2: {x.shape}")
+
+        x = self.conv3(x, edge_index)
+        x = self.bano3(F.relu(x))
+        if log_debug and not self._debug_logged:
+             logger.debug(f"[HNO.rep] After conv3+bano3: {x.shape}")
+
+        x = self.conv4(x, edge_index)
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO.rep] After conv4: {x.shape}")
+            # Don't set self._debug_logged = True here, allow forward() to log too
+
+        # Normalize features before returning
+        x = F.normalize(x, p=2.0, dim=1)
+        if log_debug and not self._debug_logged:
+            logger.debug(f"[HNO.rep] Output representation shape: {x.shape}")
+            # Mark as logged only if this specific method was asked to log
+            # self._debug_logged = True # Let forward() control the flag primarily
+
+        return x
+
+
+# --- Optional Cross Attention ---
+class CrossAttentionBlock(nn.Module):
+    def __init__(self, q_dim, kv_dim, att_dim=64):
+        super().__init__(); self.s = att_dim**-0.5; self.q=nn.Linear(q_dim,att_dim,bias=False)
+        self.k=nn.Linear(kv_dim,att_dim,bias=False); self.v=nn.Linear(kv_dim,att_dim,bias=False)
+    def forward(self, q, k, v):
+        Q=self.q(q); K=self.k(k); V=self.v(v)
+        sc = torch.matmul(Q, K.transpose(-1, -2)) * self.s
+        return torch.matmul(F.softmax(sc, dim=-1), V)
+
+# --- Decoder2 Model ---
+class ProteinStateReconstructor2D(nn.Module):
+    """Single-step decoder. Predicts full coordinates from HNO embeddings + conditioner."""
+    _logged_fwd = False
+    def __init__(self, in_dim: int, N_nodes: int, cond_dim: int, pool_type: str = "blind", res_indices: Optional[List[List[int]]] = None, pool_size: Tuple[int, int] = (20, 4), mlp_h_dim: int = 128, mlp_layers: int = 2, pool2_size: Optional[Tuple[int, int]] = None, use_pool2: bool = False, use_attn: bool = False, attn_type: str = "global", logger: logging.Logger = logging.getLogger()):
+        super().__init__(); self.N_nodes=N_nodes; self.in_dim=in_dim; self.cond_dim=cond_dim; self.logger=logger; self.pool_type=pool_type
+        self.seg_indices: List[torch.LongTensor] = []
+        if pool_type=="blind": self.seg_indices.append(torch.arange(N_nodes,dtype=torch.long))
+        elif pool_type=="residue":
+            if not res_indices: raise ValueError("Residue indices needed."); self.seg_indices = [torch.tensor(idx, dtype=torch.long) for idx in res_indices if idx];
+            if not self.seg_indices: raise ValueError("Empty residue segments.")
+        else: raise ValueError(f"Unknown pool_type={pool_type}")
+        self.N_seg = len(self.seg_indices); self.logger.info(f"Dec2: Pool='{pool_type}', Segs={self.N_seg}")
+        self.seg_pools = nn.ModuleList([nn.AdaptiveAvgPool2d(pool_size) for _ in self.seg_indices])
+        self.prim_pool_dim = pool_size[0]*pool_size[1]; self.final_pool_dim = self.prim_pool_dim*self.N_seg
+        self.glob_pool2 = None
+        if use_pool2 and pool2_size and self.N_seg>0: self.glob_pool2=nn.AdaptiveAvgPool2d(pool2_size); self.final_pool_dim=pool2_size[0]*pool2_size[1]; self.logger.info(f"Dec2: Use Pool2. FinalPoolDim={self.final_pool_dim}")
+        else: self.logger.info(f"Dec2: Primary Pool only. ConcatPoolDim={self.final_pool_dim}")
+        self.attn = None
+        if use_attn: self.logger.warning("Attn impl omitted.")
+        mlp_in_dim=self.cond_dim+self.final_pool_dim; self.decoder=build_decoder_mlp(mlp_in_dim, 3, mlp_layers, mlp_h_dim)
+        self.logger.info(f"Dec2 MLP: In={mlp_in_dim}, Out=3, Layers={mlp_layers}, Hidden={mlp_h_dim}")
+
+    def get_pooled_latent(self, x: torch.Tensor) -> torch.Tensor:
+        """Pools input [B*N, E] to get global latent [B, final_pooled_dim]."""
+        if x.ndim!=2 or x.shape[0]%self.N_nodes!=0: raise ValueError(f"Bad x shape {x.shape}")
+        B=x.shape[0]//self.N_nodes; x_r=x.view(B,self.N_nodes,self.in_dim); seg_pooled=[]
+        for i, seg_idx in enumerate(self.seg_indices):
+            idx_dev = seg_idx.to(x.device)
+            if len(idx_dev)==0: seg_pooled.append(torch.zeros(B,self.prim_pool_dim,device=x.device,dtype=x.dtype)); continue
+            seg_x = x_r[:,idx_dev,:].unsqueeze(1); pool_f=self.seg_pools[i](seg_x).view(B,-1); seg_pooled.append(pool_f)
+        if not seg_pooled: return torch.zeros(B, self.final_pool_dim, device=x.device, dtype=x.dtype)
+        l1_stack = torch.stack(seg_pooled, dim=1) # [B, num_segments, primary_dim]
+        return self.glob_pool2(l1_stack.unsqueeze(1)).view(B,-1) if self.glob_pool2 else l1_stack.view(B,-1) # Return [B, final_dim]
+
+    def forward(self, x: torch.Tensor, batch: Optional[torch.Tensor], conditioner: torch.Tensor) -> torch.Tensor:
+        """Predicts coords [B*N, 3] from embeddings [B*N, E] and conditioner [N, Cdim]."""
+        dev=x.device; cond=conditioner.to(dev)
+        if x.shape[1]!=self.in_dim or cond.shape!=(self.N_nodes,self.cond_dim): raise ValueError("Shape mismatch")
+        B_N=x.shape[0]
+        if B_N%self.N_nodes!=0: B=batch.max().item()+1 if batch is not None else -1; assert B>0 and B*self.N_nodes==B_N,"Batch size err"
+        else: B=B_N//self.N_nodes
+        pool_g=self.get_pooled_latent(x); pool_g_ex=pool_g.unsqueeze(1).expand(-1,self.N_nodes,-1) # [B, N, final_pool_dim]
+        cond_ex=cond.unsqueeze(0).expand(B,-1,-1) # [B, N, cond_dim]
+        mlp_in=torch.cat([cond_ex, pool_g_ex],dim=-1); pred=self.decoder(mlp_in.view(B_N,-1))
+        if not ProteinStateReconstructor2D._logged_fwd and self.logger.isEnabledFor(logging.DEBUG): self.logger.debug(f"[Dec2 Fwd] Shapes: In={x.shape} Cond={cond.shape} Pool={pool_g.shape} MLPIn={mlp_in.shape[-1]} Out={pred.shape}"); ProteinStateReconstructor2D._logged_fwd=True
+        return pred
+
+
+################################################################################
+# (G) Training Functions
+################################################################################
+
+# --- Train HNO ---
+
+def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, bb_idx: torch.Tensor, sc_idx: torch.Tensor, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev); bb_idx, sc_idx=bb_idx.to(dev), sc_idx.to(dev)
+    params=list(filter(lambda p: p.requires_grad, model.parameters())); opt=torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger) # start_ep is COMPLETED epoch
+    train_start_epoch = start_ep # Start training epoch AFTER the loaded one
+    logger.info(f"Start HNO train from epoch {train_start_epoch + 1}/{N_epochs}, LR={lr}")
+
+    if train_start_epoch >= N_epochs:
+        logger.info(f"Loaded checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping HNO training.")
+        return model
+
+    for ep in range(train_start_epoch, N_epochs):
+        model.train(); tr_all, tr_bb, tr_sc = 0.0, 0.0, 0.0; n_tr = len(tr_loader)
+        if not opt: logger.warning("No optimizer for HNO"); break
+        for i, data in enumerate(tr_loader):
+            data=data.to(dev); opt.zero_grad(set_to_none=True)
+            # log=(ep==train_start_epoch and i==0 and logger.isEnabledFor(logging.DEBUG)) # Original log flag calculation (not used in call now)
+
+            # --- MODIFIED CALL: Removed 'log_debug' argument ---
+            pred = model(data.x, data.edge_index)
+            # ----------------------------------------------------
+
+            all_mse, bb_mse, sc_mse = compute_bb_sc_mse(pred, data.y, bb_idx, sc_idx, logger)
+            loss=all_mse; loss.backward(); opt.step()
+            tr_all+=all_mse.item(); tr_bb+=bb_mse.item(); tr_sc+=sc_mse.item()
+        avg_tr = [x/n_tr if n_tr else 0 for x in [tr_all, tr_bb, tr_sc]]
+        model.eval(); te_all, te_bb, te_sc = 0.0, 0.0, 0.0; n_te = len(te_loader)
+        with torch.no_grad():
+            for data in te_loader:
+                data=data.to(dev)
+                 # --- MODIFIED CALL: Removed 'log_debug' argument ---
+                pred=model(data.x, data.edge_index)
+                 # ----------------------------------------------------
+                a,b,s = compute_bb_sc_mse(pred, data.y, bb_idx, sc_idx, logger); te_all+=a.item(); te_bb+=b.item(); te_sc+=s.item()
+        avg_te = [x/n_te if n_te else 0 for x in [te_all, te_bb, te_sc]]
+        logger.info(f"[HNO] Ep {ep+1} TR MSE={avg_tr[0]:.5f}(BB={avg_tr[1]:.5f},SC={avg_tr[2]:.5f}) | TE MSE={avg_te[0]:.5f}(BB={avg_te[1]:.5f},SC={avg_te[2]:.5f})")
+        ep_num = ep + 1 # Current epoch number (1-based)
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs): save_checkpoint({"epoch":ep_num, "model_state_dict":model.state_dict(), "optimizer_state_dict":opt.state_dict()}, ckpt, logger)
+    logger.info(f"Finished HNO training. Ckpt: {ckpt}")
+    return model
+
+
+'''def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, bb_idx: torch.Tensor, sc_idx: torch.Tensor, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev); bb_idx, sc_idx=bb_idx.to(dev), sc_idx.to(dev)
+    params=list(filter(lambda p: p.requires_grad, model.parameters())); opt=torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger) # start_ep is COMPLETED epoch
+    train_start_epoch = start_ep # Start training epoch AFTER the loaded one
+    logger.info(f"Start HNO train from epoch {train_start_epoch + 1}/{N_epochs}, LR={lr}")
+
+    if train_start_epoch >= N_epochs:
+        logger.info(f"Loaded checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping HNO training.")
+        return model
+
+    for ep in range(train_start_epoch, N_epochs):
+        model.train(); tr_all, tr_bb, tr_sc = 0.0, 0.0, 0.0; n_tr = len(tr_loader)
+        if not opt: logger.warning("No optimizer for HNO"); break
+        for i, data in enumerate(tr_loader):
+            data=data.to(dev); opt.zero_grad(set_to_none=True); log=(ep==train_start_epoch and i==0 and logger.isEnabledFor(logging.DEBUG))
+            pred = model(data.x, data.edge_index, log_debug=log)
+            all_mse, bb_mse, sc_mse = compute_bb_sc_mse(pred, data.y, bb_idx, sc_idx, logger)
+            loss=all_mse; loss.backward(); opt.step()
+            tr_all+=all_mse.item(); tr_bb+=bb_mse.item(); tr_sc+=sc_mse.item()
+        avg_tr = [x/n_tr if n_tr else 0 for x in [tr_all, tr_bb, tr_sc]]
+        model.eval(); te_all, te_bb, te_sc = 0.0, 0.0, 0.0; n_te = len(te_loader)
+        with torch.no_grad():
+            for data in te_loader: data=data.to(dev); pred=model(data.x, data.edge_index); a,b,s = compute_bb_sc_mse(pred, data.y, bb_idx, sc_idx, logger); te_all+=a.item(); te_bb+=b.item(); te_sc+=s.item()
+        avg_te = [x/n_te if n_te else 0 for x in [te_all, te_bb, te_sc]]
+        logger.info(f"[HNO] Ep {ep+1} TR MSE={avg_tr[0]:.5f}(BB={avg_tr[1]:.5f},SC={avg_tr[2]:.5f}) | TE MSE={avg_te[0]:.5f}(BB={avg_te[1]:.5f},SC={avg_te[2]:.5f})")
+        ep_num = ep + 1 # Current epoch number (1-based)
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs): save_checkpoint({"epoch":ep_num, "model_state_dict":model.state_dict(), "optimizer_state_dict":opt.state_dict()}, ckpt, logger)
+    logger.info(f"Finished HNO training. Ckpt: {ckpt}")
+    return model
+'''
+
+
+import random  # Make sure this is somewhere in your imports.
+
+def train_decoder2_model(
+    model: ProteinStateReconstructor2D,
+    tr_loader: DataLoader,
+    te_loader: DataLoader,
+    bb_idx: torch.Tensor,
+    sc_idx: torch.Tensor,
+    conditioner: torch.Tensor,
+    N_atoms: int,
+    N_epochs: int,
+    lr: float,
+    ckpt: str,
+    save_int: int,
+    dev: torch.device,
+    logger: logging.Logger,
+    base_w: float = 1.0,  # Weight for coordinate-based MSE
+    use_di: bool = False, # Whether dihedral-based loss is allowed at all
+    di_info: Optional[Dict] = None,
+    di_mask: Optional[torch.Tensor] = None,
+    N_res: Optional[int] = None,
+    l_div: float = 0.0,  # Weight for the dihedral distribution-divergence loss
+    l_mse: float = 0.0,  # Weight for the dihedral MSE term
+    div_t: str = "KL",   # Type of divergence (KL, JS, or WASSERSTEIN)
+    fraction_dihedral: float = 0.1  # New: fraction of batches to apply dihedral
+):
+    """
+    Trains the decoder model for a given number of epochs, optionally computing
+    dihedral-based loss for a random fraction of batches. The fraction is controlled
+    by 'fraction_dihedral' (default=1.0 means always apply dihedral).
+
+    Args:
+        model: Decoder model instance (ProteinStateReconstructor2D).
+        tr_loader: Training DataLoader with Data objects.
+        te_loader: Validation DataLoader.
+        bb_idx: 1D Tensor of backbone-atom indices (on CPU or device).
+        sc_idx: 1D Tensor of sidechain-atom indices.
+        conditioner: Tensor used as the conditional input (e.g., X_ref or z_ref).
+        N_atoms: Number of atoms per frame.
+        N_epochs: Number of epochs to train.
+        lr: Learning rate for optimizer.
+        ckpt: Path to checkpoint file for loading/saving.
+        save_int: Save checkpoint every 'save_int' epochs.
+        dev: Torch device (cpu or cuda).
+        logger: Logging instance.
+        base_w: Weight for the coordinate-based MSE. (Default=1.0)
+        use_di: If True, dihedral-based losses can be computed.
+        di_info: Precomputed dihedral index info (dict).
+        di_mask: Boolean mask of shape [N_res, num_angle_types], indicates valid angles.
+        N_res: Number of residues.
+        l_div: Loss coefficient for distribution-based dihedral difference (KL, JS, or Wass).
+        l_mse: Loss coefficient for direct dihedral MSE.
+        div_t: Divergence type: 'KL', 'JS', or 'WASSERSTEIN'.
+        fraction_dihedral: Fraction of training batches where dihedral-based loss is applied.
+
+    Returns:
+        model: The trained decoder model (with final parameters).
+    """
+    # Make sure the relevant dihedral utilities are in scope (from Code 2).
+    # e.g. compute_all_dihedrals_vectorized, compute_angle_kl_div, etc.
+
+    model = model.to(dev)
+    bb_idx, sc_idx = bb_idx.to(dev), sc_idx.to(dev)
+    mask_dev = di_mask.to(dev) if di_mask is not None else None
+
+    # Build an optimizer
+    params = list(filter(lambda p: p.requires_grad, model.parameters()))
+    opt = torch.optim.Adam(params, lr=lr) if params else None
+
+    # Load checkpoint if it exists
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+    train_start_epoch = start_ep
+    best_train_loss = float("inf")
+    logger.info(f"Start Dec2 train from epoch {train_start_epoch + 1}/{N_epochs}, LR={lr}, BaseW={base_w}")
+
+    # Pick the correct divergence function
+    comp_div = None
+    valid_di = False
+    if use_di:
+        if div_t == "JS":
+            comp_div = compute_angle_js_div
+        elif div_t == "WASSERSTEIN":
+            comp_div = compute_angle_wasserstein
+        elif div_t == "KL":
+            comp_div = compute_angle_kl_div
+        else:
+            logger.warning(f"Unknown div_type '{div_t}', defaulting to KL.")
+            div_t = "KL"
+            comp_div = compute_angle_kl_div
+
+        # Check if we have everything needed (di_info, mask, N_res)
+        if di_info and mask_dev is not None and N_res and comp_div:
+            valid_di = True
+            logger.info(f"  Dihedral Loss ENABLED: Type={div_t}, "
+                        f"lambda_div={l_div}, lambda_mse={l_mse}, fraction={fraction_dihedral}")
+        else:
+            logger.warning("Dihedral components missing or invalid. Disabling dihedral loss.")
+    else:
+        logger.info("  Dihedral Loss DISABLED.")
+
+    # Define the angle types we compute
+    angles = ['phi', 'psi', 'chi1', 'chi2', 'chi3', 'chi4', 'chi5']
+
+    if train_start_epoch >= N_epochs:
+        logger.info(f"Loaded checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). "
+                    f"Skipping Decoder2 training.")
+        return model
+
+    # ------------------------ Training Loop ------------------------
+    for ep in range(train_start_epoch, N_epochs):
+        model.train()
+        tr_metrics = [0.0]*6  # [tot, coord, bb, sc, div, d_mse]
+        n_tr = len(tr_loader)
+
+        if not opt:
+            logger.warning("No optimizer for Decoder2 (empty param list?)")
+            break
+
+        for i, data in enumerate(tr_loader):
+            data = data.to(dev)
+            opt.zero_grad(set_to_none=True)
+
+            # Forward pass: coordinate predictions
+            pred = model(data.x, data.batch, conditioner)
+            c_mse, b_mse, s_mse = compute_bb_sc_mse(pred, data.y, bb_idx, sc_idx, logger)
+            loss = c_mse * base_w
+
+            # By default, the dihedral terms are zero
+            div_l = torch.tensor(0., device=dev)
+            d_mse_l = torch.tensor(0., device=dev)
+
+            # Decide if we incorporate the dihedral portion for this batch
+            if use_di and valid_di:
+                # For example, use random fraction
+                if random.random() < fraction_dihedral:
+                    B_N = pred.shape[0]
+                    if B_N > 0 and B_N % N_atoms == 0:
+                        B = B_N // N_atoms
+                        pred3d = pred.view(B, N_atoms, 3)
+                        true3d = data.y.view(B, N_atoms, 3)
+
+                        try:
+                            # Compute dihedrals for predicted & target
+                            pred_a = compute_all_dihedrals_vectorized(pred3d, di_info, N_res, logger)
+                            true_a = compute_all_dihedrals_vectorized(true3d, di_info, N_res, logger)
+
+                            for name in angles:
+                                pa = pred_a.get(name)
+                                ta = true_a.get(name)
+                                if pa is not None and ta is not None:
+                                    angle_idx = angles.index(name)
+                                    if (mask_dev.ndim == 2 and
+                                        mask_dev.shape[0] == N_res and
+                                        mask_dev.shape[1] == len(angles)):
+
+                                        mask = mask_dev[:, angle_idx]
+                                        if mask.any():
+                                            mask_ex = mask.view(1, -1).expand(B, -1)
+                                            pv = pa[mask_ex]
+                                            tv = ta[mask_ex]
+                                            if pv.numel() > 0:
+                                                d_mse_l += F.mse_loss(pv, tv)
+                                                div_l += comp_div(pv, tv)
+                                    else:
+                                        logger.error(f"Mask shape mismatch: {mask_dev.shape}, "
+                                                     f"expected ({N_res}, {len(angles)})")
+                                        valid_di = False
+                                        break
+                            if valid_di:
+                                loss += l_div * div_l + l_mse * d_mse_l
+
+                        except Exception as e:
+                            logger.error(f"Dih. loss error in batch {i}: {e}", exc_info=False)
+
+                    elif B_N > 0:
+                        logger.warning(f"Batch size {B_N} not a multiple of N_atoms={N_atoms}. "
+                                       f"Skipping dihedral for batch {i}.")
+
+            # Backprop and update
+            if loss.requires_grad:
+                loss.backward()
+                opt.step()
+
+            # Collect training stats
+            batch_metrics = [
+                loss.item(),
+                c_mse.item(),
+                b_mse.item(),
+                s_mse.item(),
+                div_l.item(),
+                d_mse_l.item()
+            ]
+            for j in range(6):
+                tr_metrics[j] += batch_metrics[j]
+        # end for (training data)
+
+        # Compute average training stats
+        avg_tr = [x / n_tr if n_tr else 0 for x in tr_metrics]
+
+        # ------------------ Validation Loop ------------------
+        model.eval()
+        te_metrics = [0.0]*6  # [tot, coord, bb, sc, div, d_mse]
+        n_te = len(te_loader)
+
+        with torch.no_grad():
+            for data in te_loader:
+                data = data.to(dev)
+                pred = model(data.x, data.batch, conditioner)
+
+                c_mse, b_mse, s_mse = compute_bb_sc_mse(pred, data.y, bb_idx, sc_idx, logger)
+                loss = c_mse * base_w
+
+                div_l = torch.tensor(0., device=dev)
+                d_mse_l = torch.tensor(0., device=dev)
+
+                # Typically we either do full dihedral or none in validation
+                if use_di and valid_di:
+                    B_N = pred.shape[0]
+                    if B_N > 0 and B_N % N_atoms == 0:
+                        B = B_N // N_atoms
+                        pred3d = pred.view(B, N_atoms, 3)
+                        true3d = data.y.view(B, N_atoms, 3)
+
+                        try:
+                            pred_a = compute_all_dihedrals_vectorized(pred3d, di_info, N_res, logger)
+                            true_a = compute_all_dihedrals_vectorized(true3d, di_info, N_res, logger)
+
+                            for name in angles:
+                                pa = pred_a.get(name)
+                                ta = true_a.get(name)
+                                if pa is not None and ta is not None:
+                                    angle_idx = angles.index(name)
+                                    if (mask_dev.ndim == 2 and
+                                        mask_dev.shape[0] == N_res and
+                                        mask_dev.shape[1] == len(angles)):
+
+                                        mask = mask_dev[:, angle_idx]
+                                        if mask.any():
+                                            mask_ex = mask.view(1, -1).expand(B, -1)
+                                            pv = pa[mask_ex]
+                                            tv = ta[mask_ex]
+                                            if pv.numel() > 0:
+                                                d_mse_l += F.mse_loss(pv, tv)
+                                                div_l += comp_div(pv, tv)
+                                    else:
+                                        logger.error("Val Mask shape mismatch: "
+                                                     f"{mask_dev.shape}")
+                                        valid_di = False
+                                        break
+                            if valid_di:
+                                loss += l_div * div_l + l_mse * d_mse_l
+
+                        except Exception:
+                            pass  # ignore dihedral errors in validation
+
+                # Accumulate validation stats
+                batch_metrics = [
+                    loss.item(),
+                    c_mse.item(),
+                    b_mse.item(),
+                    s_mse.item(),
+                    div_l.item(),
+                    d_mse_l.item()
+                ]
+                for j in range(6):
+                    te_metrics[j] += batch_metrics[j]
+
+        # end val loop
+        avg_te = [x / n_te if n_te else 0 for x in te_metrics]
+
+        # Print epoch summary
+        log_str = (f"[Dec2] Ep {ep+1} "
+                   f"TR: Tot={avg_tr[0]:.4f} Coord={avg_tr[1]:.4f} "
+                   f"(BB={avg_tr[2]:.4f}, SC={avg_tr[3]:.4f}) "
+                   f"Dih(MSE={avg_tr[5]:.4f}, {div_t}={avg_tr[4]:.4f}) | "
+                   f"TE: Tot={avg_te[0]:.4f} Coord={avg_te[1]:.4f} "
+                   f"(BB={avg_te[2]:.4f}, SC={avg_te[3]:.4f}) "
+                   f"Dih(MSE={avg_te[5]:.4f}, {div_t}={avg_te[4]:.4f})")
+        logger.info(log_str)
+
+        ep_num = ep + 1
+        # Periodically save the model
+        if opt:
+            current_train_loss = avg_tr[0]  # TOT is stored in index 0
+            if current_train_loss < best_train_loss:
+                best_train_loss = current_train_loss  # update
+                save_checkpoint({
+                    "epoch": ep_num,
+                    "model_state_dict": model.state_dict(),
+                    "optimizer_state_dict": opt.state_dict()
+                }, ckpt, logger)
+                logger.info(
+                    f"[Dec2] Saved checkpoint at epoch {ep_num}, improved train loss={current_train_loss:.5f}"
+                )
+            else:
+                logger.info(
+                    f"[Dec2] Epoch {ep_num} not saved (train loss={current_train_loss:.5f} >= best={best_train_loss:.5f})"
+                )
+    logger.info(f"Finished Dec2 training. Ckpt: {ckpt}")
+    # Reload the newly saved best checkpoint so 'model' in memory matches it
+    best_ckpt_data = torch.load(ckpt, map_location=dev)
+    model.load_state_dict(best_ckpt_data["model_state_dict"])
+    model.eval()
+    return model
+
+
+
+################################################################################
+# (H) Export Final Outputs Function
+################################################################################
+@torch.no_grad()
+def export_final_outputs(
+    hno: 'HNO', # Use forward declaration if classes defined later
+    dec2: 'ProteinStateReconstructor2D',
+    full_dset: List['Data'], # Dataset with original coords for GT and HNO input
+    dec_in_dset: List['Data'], # Dataset with embeddings for Decoder2 input/pooled
+    conditioner: torch.Tensor, # X_ref or z_ref on CPU
+    N_atoms: int,
+    struct_dir: str,
+    latent_dir: str,
+    dev: torch.device,
+    logger: logging.Logger
+):
+    """
+    Exports final predictions and intermediate results to HDF5 files.
+    Logs file existence at the end based on os.path.isfile.
+
+    Writes:
+     1) structures/ground_truth_aligned.h5 (dataset key: 'ground_truth_coords')
+     2) structures/hno_reconstructions.h5  (dataset key: 'hno_coords')
+     3) structures/full_coords.h5          (dataset key: 'full_coords', from Decoder2)
+     4) latent_reps/hno_embeddings.h5      (dataset key: 'hno_embeddings')
+     5) latent_reps/pooled_embedding.h5    (dataset key: 'pooled_embedding', from Decoder2)
+    """
+    logger.info("--- Exporting Final Outputs ---")
+    hno.eval().to(dev); dec2.eval().to(dev); cond_dev = conditioner.to(dev)
+
+    # Define output file paths
+    paths = {
+        'gt': os.path.join(struct_dir, "ground_truth_aligned.h5"),
+        'hno_rec': os.path.join(struct_dir, "hno_reconstructions.h5"),
+        'full': os.path.join(struct_dir, "full_coords.h5"),
+        'hno_emb': os.path.join(latent_dir, "hno_embeddings.h5"),
+        'pool': os.path.join(latent_dir, "pooled_embedding.h5")
+    }
+
+    N_frames = len(full_dset)
+    if N_frames == 0 or len(dec_in_dset) != N_frames:
+        logger.warning("Dataset empty or mismatched. Skipping export.")
+        return
+
+    # Determine dimensions
+    emb_dim = hno.conv4.out_channels # Assuming c4 is the last conv layer in HNO
+    pool_dim = 0
+    try:
+        # Ensure the sample data exists and get pooled dim
+        if dec_in_dset:
+            pool_dim = dec2.get_pooled_latent(dec_in_dset[0].x.to(dev)).shape[1]
+        else:
+            logger.warning("Decoder input dataset empty, cannot determine pool dim.")
+    except Exception as e:
+        logger.error(f"Could not get pooled dim: {e}.")
+
+    logger.info(f"Export Details: Frames={N_frames}, Atoms={N_atoms}, EmbDim={emb_dim}, PooledDim={pool_dim}")
+
+    # Using separate file handles and explicit closing in finally for robustness
+    files_opened: List[h5py.File] = []
+    dsets_created_flags: Dict[str, bool] = {k: False for k in paths} # Track if create_dataset was called
+
+    try:
+        # Open files
+        f_gt = h5py.File(paths['gt'],"w"); files_opened.append(f_gt)
+        f_hno = h5py.File(paths['hno_rec'],"w"); files_opened.append(f_hno)
+        f_full = h5py.File(paths['full'],"w"); files_opened.append(f_full)
+        f_emb = h5py.File(paths['hno_emb'],"w"); files_opened.append(f_emb)
+        f_pool = h5py.File(paths['pool'],"w"); files_opened.append(f_pool)
+
+        # Create datasets
+        dset_gt = dset_hno_rec = dset_full = dset_hno_emb = dset_pool = None # Initialize
+        if N_atoms > 0:
+            dset_gt = f_gt.create_dataset("ground_truth_coords",(N_frames,N_atoms,3),dtype='f4'); dsets_created_flags['gt'] = True
+            dset_hno_rec = f_hno.create_dataset("hno_coords",(N_frames,N_atoms,3),dtype='f4'); dsets_created_flags['hno_rec'] = True
+            dset_full = f_full.create_dataset("full_coords",(N_frames,N_atoms,3),dtype='f4'); dsets_created_flags['full'] = True
+        if N_atoms > 0 and emb_dim > 0:
+            dset_hno_emb = f_emb.create_dataset("hno_embeddings",(N_frames,N_atoms,emb_dim),dtype='f4'); dsets_created_flags['hno_emb'] = True
+        if pool_dim > 0:
+            dset_pool = f_pool.create_dataset("pooled_embedding",(N_frames,pool_dim),dtype='f4'); dsets_created_flags['pool'] = True
+
+        logger.debug("HDF5 datasets potentially created (check flags).")
+
+        # Data Writing Loop (Use DataLoader for efficiency if needed, otherwise iterate)
+        for i in range(N_frames):
+            d_orig, d_dec = full_dset[i].to(dev), dec_in_dset[i].to(dev)
+
+            if dset_gt: dset_gt[i] = d_orig.y.cpu().numpy()
+            if dset_hno_rec: dset_hno_rec[i] = hno(d_orig.x, d_orig.edge_index).cpu().numpy()
+            if dset_hno_emb: dset_hno_emb[i] = d_dec.x.cpu().numpy() # Embedding already computed
+            if dset_full: dset_full[i] = dec2(d_dec.x, None, cond_dev).cpu().numpy() # No batch index needed for B=1
+            if dset_pool: dset_pool[i] = dec2.get_pooled_latent(d_dec.x).squeeze(0).cpu().numpy()
+
+            if (i + 1) % 500 == 0 or (i + 1) == N_frames:
+                logger.info(f"Exported frame {i + 1}/{N_frames}")
+
+    except Exception as e:
+        logger.error(f"HDF5 export failed during processing: {e}", exc_info=True)
+    finally:
+        # Ensure all opened files are closed
+        for f in files_opened:
+            try:
+                f.close()
+            except Exception as close_e:
+                logger.error(f"Error closing HDF5 file handle: {close_e}", exc_info=False)
+
+    # --- Corrected Final Logging Logic ---
+    logger.info("Export process finished. Verifying file existence:")
+    all_paths_map = { # Map internal key to name and path
+        "gt": ("Ground Truth", paths['gt']),
+        "hno_rec": ("HNO Recon", paths['hno_rec']),
+        "full": ("Full Coords", paths['full']),
+        "hno_emb": ("HNO Embeddings", paths['hno_emb']),
+        "pool": ("Pooled Embedding", paths['pool'])
+    }
+
+    for key, (name, file_path) in all_paths_map.items():
+        try:
+            if os.path.isfile(file_path):
+                # Check if the dataset was intended to be created based on dims
+                should_exist = False
+                if key in ['gt', 'hno_rec', 'full'] and N_atoms > 0: should_exist = True
+                elif key == 'hno_emb' and N_atoms > 0 and emb_dim > 0: should_exist = True
+                elif key == 'pool' and pool_dim > 0: should_exist = True
+
+                if not should_exist: # File exists but wasn't expected based on dims
+                     logger.warning(f"  {name} => {file_path} (Exists but N/A based on dimensions)")
+                elif os.path.getsize(file_path) > 50: # Check size > 50 bytes (HDF5 header is small)
+                    logger.info(f"  {name} => {file_path} (Exists)")
+                else:
+                    logger.warning(f"  {name} => {file_path} (Exists but is suspiciously small/empty!)")
+            else:
+                logger.warning(f"  {name} => {file_path} (File NOT found!)")
+        except OSError as e:
+             logger.error(f"  Error checking file {name} at {file_path}: {e}")
+        except Exception as e:
+            logger.error(f"  Unexpected error checking file {name} at {file_path}: {e}")
+
+################################################################################
+# (I) Main Execution Function
+################################################################################
+def main():
+    """Main orchestration function."""
+    start_time = time.time()
+    logger.info("================ Script Starting ================")
+    global global_device
+
+    # --- Load Full Configuration ---
+    try:
+        with open(args.config, "r") as f: config = yaml.safe_load(f)
+        logger.info(f"Successfully loaded configuration from {args.config}")
+    except Exception as e: logger.error(f"Failed to load config: {e}", exc_info=True); sys.exit(1)
+
+    # --- Extract Parameters & Setup ---
+    try: # Use .get for safety with defaults where possible
+        force_cpu = config.get("force_cpu", False); cuda_idx = config.get("cuda_device", 0)
+        num_workers = config.get("num_workers", 0); data_cfg = config["data"]; json_p = data_cfg["json_path"]; pdb_p = data_cfg["pdb_path"]
+        graph_cfg = config["graph"]; knn = graph_cfg["knn_value"]; hno_cfg = config["hno_encoder"]; hno_hdim = hno_cfg["hidden_dim"]
+        hno_k = hno_cfg["cheb_order"]; hno_ep = hno_cfg["num_epochs"]; hno_lr = hno_cfg["learning_rate"]; hno_bs = hno_cfg["batch_size"]
+        hno_si = hno_cfg.get("save_interval", 500); dec2_cfg = config["decoder2"]; dec2_ep = dec2_cfg["num_epochs"]; dec2_lr = dec2_cfg["learning_rate"]
+        dec2_bs = dec2_cfg["batch_size"]; dec2_base_w = dec2_cfg.get("base_loss_weight", 1.0); dec2_si = dec2_cfg.get("save_interval", 500)
+        d2s = config["decoder2_settings"]; d2_c_mode = d2s.get("conditioner_mode","z_ref"); d2_p_type = d2s.get("pooling_type","blind")
+        d2_ph, d2_pw = d2s.get("output_height",20), d2s.get("output_width",4); d2_mlp_h = d2s.get("mlp_hidden_dim",128)
+        d2_mlp_l = d2s.get("num_hidden_layers",2); d2_use_p2 = d2s.get("use_second_level_pooling",False); d2_ph2, d2_pw2 = d2s.get("output_height2"), d2s.get("output_width2")
+        d2_use_a = d2s.get("use_cross_attention",False); d2_a_type = d2s.get("cross_attention_type","global"); di_cfg = config.get("dihedral_loss",{})
+        use_di_cfg = di_cfg.get("use_dihedral_loss",False); torsion_p = di_cfg.get("torsion_info_path","torsion.json"); l_div = di_cfg.get("lambda_divergence",0.0)
+        l_mse = di_cfg.get("lambda_torsion_mse",0.0); div_t = di_cfg.get("divergence_type","KL").upper(); out_cfg = config.get("output_directories",{})
+        ckpt_dir = out_cfg.get("checkpoint_dir","checkpoints"); struct_dir = out_cfg.get("structure_dir","structures"); latent_dir = out_cfg.get("latent_dir","latent_reps")
+    except KeyError as e: logger.error(f"Missing config key: {e}"); sys.exit(1)
+
+    # --- Finalize Device ---
+    device = torch.device("cpu") if force_cpu else global_device
+    pin_mem = (device.type == "cuda")
+    logger.info(f"Final device: {device}")
+    try: [os.makedirs(d, exist_ok=True) for d in [ckpt_dir, struct_dir, latent_dir]]
+    except OSError as e: logger.error(f"Dir creation failed: {e}"); sys.exit(1)
+
+    # --- Stage 1: Data Loading & Prep ---
+    logger.info("--- Stage 1: Data Loading & Preprocessing ---")
+    _, atoms_ord = parse_pdb(pdb_p, logger);
+    if not atoms_ord: sys.exit(1)
+    renum_d, _ = renumber_atoms_and_residues(atoms_ord, logger)
+    bb_list, sc_list = get_global_indices(renum_d); N_atoms_pdb = len(bb_list)+len(sc_list)
+    bb_t, sc_t = torch.tensor(bb_list, dtype=torch.long), torch.tensor(sc_list, dtype=torch.long) # CPU tensors
+    logger.info(f"PDB: Atoms={N_atoms_pdb} (BB={len(bb_list)}, SC={len(sc_list)})")
+    coords_f, N_atoms_json = load_heavy_atom_coords_from_json(json_p, logger)
+    if not coords_f: sys.exit(1)
+    if N_atoms_json!=N_atoms_pdb: logger.error(f"Atom count mismatch JSON({N_atoms_json}) != PDB({N_atoms_pdb})"); sys.exit(1)
+    N_atoms = N_atoms_pdb
+    aligned_c = align_frames_to_first(coords_f, logger, device);
+    if not aligned_c: sys.exit(1)
+    full_dset = build_graph_dataset(aligned_c, knn_neighbors=knn, logger=logger, device=device); # Use corrected knn_neighbors
+    if not full_dset: sys.exit(1)
+
+    # --- Stage 2: HNO Training/Loading ---
+    logger.info("--- Stage 2: HNO Encoder ---")
+    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
+    load_tr_hno = DataLoader(tr_hno,hno_bs,shuffle=True,num_workers=num_workers,pin_memory=pin_mem,drop_last=True)
+    load_te_hno = DataLoader(te_hno,hno_bs,shuffle=False,num_workers=num_workers,pin_memory=pin_mem)
+    hno_model = HNO(hno_hdim, hno_k); hno_ckpt = os.path.join(ckpt_dir, "hno_checkpoint.pth")
+    hno_model = train_hno_model(hno_model,load_tr_hno,load_te_hno,bb_t,sc_t,hno_ep,hno_lr,hno_ckpt,hno_si,device,logger)
+    hno_model.eval()
+
+    # --- Stage 3: Decoder Input Data Prep ---
+    logger.info("--- Stage 3: Decoder2 Input Dataset ---")
+    dec_in_dset = []; infer_load = DataLoader(full_dset,hno_bs*2,shuffle=False,num_workers=num_workers,pin_memory=pin_mem)
+    with torch.no_grad():
+        for batch_idx, batch in enumerate(infer_load): # Use enumerate
+            batch=batch.to(device); emb=hno_model.forward_representation(batch.x,batch.edge_index)
+            y_batch = batch.y
+            # Check for None y_batch - robust check
+            if y_batch is None:
+                logger.error(f"batch.y is None at batch index {batch_idx}! Skipping batch.")
+                continue
+            counts = batch.ptr[1:]-batch.ptr[:-1]
+            # Validate counts before splitting
+            if counts.numel() > 0 and counts.sum() == emb.shape[0] and counts.sum() == y_batch.shape[0]:
+                emb_l=torch.split(emb,counts.tolist()); y_l=torch.split(y_batch,counts.tolist())
+                if len(emb_l) == len(y_l): # Ensure lists match length
+                   for i in range(len(emb_l)): dec_in_dset.append(Data(x=emb_l[i].cpu(), y=y_l[i].cpu()))
+                else: logger.error(f"Split list length mismatch batch {batch_idx}")
+            elif counts.sum() != emb.shape[0] or counts.sum() != y_batch.shape[0]:
+                 logger.error(f"Node count mismatch batch {batch_idx}: CountsSum={counts.sum()}, Emb={emb.shape[0]}, Y={y_batch.shape[0]}")
+            # Handle case where counts might be empty if batch is empty (less likely with drop_last=True)
+            elif counts.numel() == 0 and emb.shape[0] == 0 and y_batch.shape[0] == 0:
+                 pass # Empty batch, do nothing
+            else: logger.error(f"Unhandled count/shape mismatch batch {batch_idx}")
+
+    logger.info(f"Decoder2 input dataset size: {len(dec_in_dset)}")
+    if not dec_in_dset: logger.error("Decoder input dataset is empty! Cannot proceed."); sys.exit(1)
+
+
+    # --- Stage 4: Decoder2 Setup & Training ---
+    logger.info("--- Stage 4: Decoder2 Setup & Training ---")
+    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
+    load_tr_dec = DataLoader(tr_dec,dec2_bs,shuffle=True,num_workers=num_workers,pin_memory=pin_mem,drop_last=True)
+    load_te_dec = DataLoader(te_dec,dec2_bs,shuffle=False,num_workers=num_workers,pin_memory=pin_mem)
+
+    # Determine Conditioner
+    ff_data=full_dset[0].to(device); Xref_dev=ff_data.x; cond_dim=-1; cond_cpu=None; zref_cpu=None
+    if d2_c_mode=="X_ref": cond_cpu=Xref_dev.cpu(); cond_dim=3; logger.info("Using X_ref conditioner")
+    elif d2_c_mode=="z_ref":
+        with torch.no_grad(): zref_dev = hno_model.forward_representation(Xref_dev, ff_data.edge_index.to(device))
+        cond_cpu=zref_dev.cpu(); zref_cpu=cond_cpu; cond_dim=zref_dev.shape[1]; logger.info("Using z_ref conditioner")
+    else: logger.error(f"Invalid conditioner: {d2_c_mode}"); sys.exit(1)
+    try: torch.save(Xref_dev.cpu(), os.path.join(struct_dir,"X_ref_coords.pt")); logger.info("Saved X_ref.")
+    except Exception as e: logger.error(f"Save X_ref failed: {e}")
+    if zref_cpu is not None:
+        try: torch.save(zref_cpu, os.path.join(latent_dir,"z_ref_embedding.pt")); logger.info("Saved z_ref.")
+        except Exception as e: logger.error(f"Save z_ref failed: {e}")
+
+    # Dihedral Precomputation (Concise Logging)
+    logger.info("--- Attempting Dihedral Precomputation ---")
+    di_info={}; mask_all=None; N_res=None; precomp_ok=False; angle_types_all=['phi','psi','chi1','chi2','chi3','chi4','chi5']
+    if use_di_cfg:
+        torsion_path_abs = os.path.abspath(torsion_p) # Use absolute path for check
+        if os.path.isfile(torsion_path_abs):
+            logger.info(f"Found torsion file: {torsion_path_abs}")
+            try:
+                with open(torsion_path_abs,"r") as f: t_info=json.load(f)
+                idx_l,res_l = {n:[[] for _ in range(4)] for n in angle_types_all},{n:[] for n in angle_types_all}
+                keys_s = sorted([int(k) for k in t_info.keys()]); N_res = len(keys_s)
+                mask_l = [[False]*len(angle_types_all) for _ in range(N_res)]; skip_c=0
+                for r_idx, r_id in enumerate(keys_s):
+                    r_d=t_info.get(str(r_id),{}); t_a=r_d.get("torsion_atoms",{}); c_a=t_a.get("chi",{})
+                    for type_idx, name in enumerate(angle_types_all):
+                        indices = t_a.get(name) if name in ['phi','psi'] else c_a.get(name)
+                        if isinstance(indices, list) and len(indices)==4 and all(isinstance(i,int) for i in indices):
+                             if all(0<=i<N_atoms for i in indices): # Check bounds
+                                 for k, atom_idx in enumerate(indices): idx_l[name][k].append(atom_idx)
+                                 res_l[name].append(r_idx); mask_l[r_idx][type_idx] = True
+                             else: skip_c+=1
+                if skip_c > 0: logger.warning(f"Skipped {skip_c} angles (out-of-bounds atom indices).")
+                try: # Convert lists
+                    for name in angle_types_all:
+                        if res_l[name]: di_info[name] = {'indices': [torch.tensor(l,dtype=torch.long) for l in idx_l[name]], 'res_idx': torch.tensor(res_l[name],dtype=torch.long)}
+                        else: di_info[name] = {'indices': None, 'res_idx': None}
+                    mask_all=torch.tensor(mask_l, dtype=torch.bool); precomp_ok=True
+                    logger.info(f"Successfully precomputed dihedral info for {N_res} residues.")
+                except Exception as e: logger.error(f"Dihedral tensor conversion failed: {e}", exc_info=True)
+            except Exception as e: logger.error(f"Dihedral JSON loading/processing failed: {e}", exc_info=True)
+        else: logger.warning(f"Torsion file not found at resolved path: {torsion_path_abs}")
+    use_di_train = use_di_cfg and precomp_ok # Final decision flag
+    if use_di_cfg and not precomp_ok: logger.warning("Dihedral requested but precomp failed. Disabling loss.")
+    logger.info(f"Final dihedral loss status for training: {'ENABLED' if use_di_train else 'DISABLED'}")
+
+    # Initialize Decoder2
+    res_idx_pool=None # Placeholder
+    if d2_p_type == "residue": logger.warning("Residue pooling needs index generation from renum_d.")
+    sec_pool = (d2_ph2, d2_pw2) if d2_use_p2 and d2_ph2 and d2_pw2 else None
+    dec2_model = ProteinStateReconstructor2D(hno_hdim,N_atoms,cond_dim,d2_p_type,res_idx_pool,(d2_ph,d2_pw),d2_mlp_h,d2_mlp_l,sec_pool,d2_use_p2,d2_use_a,d2_a_type,logger)
+    dec2_ckpt = os.path.join(ckpt_dir, "decoder2_checkpoint.pth")
+    dec2_model = train_decoder2_model(dec2_model,load_tr_dec,load_te_dec,bb_t,sc_t,cond_cpu,N_atoms,dec2_ep,dec2_lr,dec2_ckpt,dec2_si,device,logger,dec2_base_w,use_di_train,di_info,mask_all,N_res,l_div,l_mse,div_t)
+    dec2_model.eval()
+
+    # --- Export Results ---
+    export_final_outputs(hno_model,dec2_model,full_dset,dec_in_dset,cond_cpu,N_atoms,struct_dir,latent_dir,device,logger)
+
+    elapsed = time.time() - start_time
+    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(elapsed))}) ================")
+    sys.stdout.flush()
+
+
+################################################################################
+# (J) Script Entry Point
+################################################################################
+if __name__ == "__main__":
+    main()

LD-FPG-main/blind/chebnet_diff.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+import os
+import sys
+import yaml
+import h5py
+import torch
+import argparse
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+
+# Need imports for classes/functions used
+from torch_geometric.nn import ChebConv # For HNO definition
+from torch_cluster import knn_graph # Needed if calculating z_ref
+
+##############################################################
+# Copied Class Definitions from Script M (Response #16)
+##############################################################
+
+
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged = False  # For one-time debug logging
+        logger.debug(f"Initializing HNO with hidden_dim={hidden_dim}, K={K}")
+        sys.stdout.flush()
+        # Input dimension is 3 (x, y, z coordinates)
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        # BatchNorm applied on the feature dimension (hidden_dim)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        # Final MLP maps back to 3D coordinates
+        self.mlpRep = nn.Linear(hidden_dim, 3)
+
+    def forward(self, x, edge_index, log_debug=False):
+        x = x.float()
+        x = self.conv1(x, edge_index)
+        x = self.bano1(F.leaky_relu(x))
+        x = self.conv2(x, edge_index)
+        x = self.bano2(F.leaky_relu(x))
+        x = self.conv3(x, edge_index)
+        x = self.bano3(F.relu(x)) # Note: ReLU here, LeakyReLU before
+        x = self.conv4(x, edge_index)
+        x = F.normalize(x, p=2.0, dim=1) # dim=1 is the feature dimension
+        x = self.mlpRep(x)
+        return x
+
+    def forward_representation(self, x, edge_index, log_debug=False):
+        x = x.float() # Ensure input is float
+        x = self.conv1(x, edge_index)
+        x = self.bano1(F.leaky_relu(x))
+        x = self.conv2(x, edge_index)
+        x = self.bano2(F.leaky_relu(x))
+        x = self.conv3(x, edge_index)
+        x = self.bano3(F.relu(x))
+        x = self.conv4(x, edge_index)
+        x = F.normalize(x, p=2.0, dim=1)
+        return x
+
+# --- MLP Builder ---
+def build_decoder_mlp(in_dim: int, out_dim: int, N_layers: int, h_dim: int = 128) -> nn.Sequential:
+    """Builds MLP with BatchNorm."""
+    layers: List[nn.Module] = []; curr = in_dim
+    if N_layers<=0: raise ValueError("MLP layers must be >= 1.")
+    elif N_layers==1: layers.append(nn.Linear(curr, out_dim))
+    else:
+        layers.extend([nn.Linear(curr, h_dim), nn.BatchNorm1d(h_dim), nn.ReLU()]); curr = h_dim
+        for _ in range(N_layers - 2): layers.extend([nn.Linear(curr, h_dim), nn.BatchNorm1d(h_dim), nn.ReLU()])
+        layers.append(nn.Linear(curr, out_dim))
+    return nn.Sequential(*layers)
+
+# --- Decoder2 Model Definition (Needed for loading state_dict) ---
+class ProteinStateReconstructor2D(nn.Module):
+    _logged_fwd = False
+    def __init__(self, in_dim: int, N_nodes: int, cond_dim: int, pool_type: str = "blind", res_indices: Optional[List[List[int]]] = None, pool_size: Tuple[int, int] = (20, 4), mlp_h_dim: int = 128, mlp_layers: int = 2, pool2_size: Optional[Tuple[int, int]] = None, use_pool2: bool = False, use_attn: bool = False, attn_type: str = "global", logger: logging.Logger = logging.getLogger()): # Added logger default
+        super().__init__(); self.N_nodes=N_nodes; self.in_dim=in_dim; self.cond_dim=cond_dim; self.logger=logger; self.pool_type=pool_type
+        self.seg_indices: List[torch.LongTensor] = []
+        if pool_type=="blind": self.seg_indices.append(torch.arange(N_nodes,dtype=torch.long))
+        elif pool_type=="residue":
+            if not res_indices: self.logger.warning("Residue pooling selected but no indices provided during init."); self.seg_indices.append(torch.arange(N_nodes,dtype=torch.long)) # Fallback?
+            else: self.seg_indices = [torch.tensor(idx, dtype=torch.long) for idx in res_indices if idx];
+            if not self.seg_indices: raise ValueError("Empty residue segments.")
+        else: raise ValueError(f"Unknown pool_type={pool_type}")
+        self.N_seg = len(self.seg_indices); #self.logger.info(f"Dec2 Init: Pool='{pool_type}', Segs={self.N_seg}")
+        self.seg_pools = nn.ModuleList([nn.AdaptiveAvgPool2d(pool_size) for _ in self.seg_indices])
+        self.prim_pool_dim = pool_size[0]*pool_size[1]; self.final_pool_dim = self.prim_pool_dim*self.N_seg # Calculate initial pooled dim based on primary pool concat
+        self.glob_pool2 = None
+        if use_pool2 and pool2_size and self.N_seg>0:
+            self.glob_pool2=nn.AdaptiveAvgPool2d(pool2_size);
+            self.final_pool_dim=pool2_size[0]*pool2_size[1]; # Recalculate if secondary pooling is used
+            #self.logger.info(f"Dec2 Init: Use Pool2. FinalPoolDim={self.final_pool_dim}")
+        #else: self.logger.info(f"Dec2 Init: Primary Pool only. ConcatPoolDim={self.final_pool_dim}")
+        self.attn = None;
+        if use_attn: self.logger.warning("Attn impl omitted.")
+        mlp_in_dim=self.cond_dim+self.final_pool_dim; # Input to MLP is conditioner + final_pooled_dim
+        self.decoder=build_decoder_mlp(mlp_in_dim, 3, mlp_layers, mlp_h_dim) # This is the part we need
+        self.logger.info(f"Dec2 Init MLP: In={mlp_in_dim}, Out=3, Layers={mlp_layers}, Hidden={mlp_h_dim}")
+    # get_pooled_latent and forward are NOT used directly in this script.
+# --- End of Copied Class Definitions ---
+
+
+##############################################################
+# (D) Main Decoding Function
+##############################################################
+def main():
+    parser = argparse.ArgumentParser(description="Decode diffused GLOBAL pooled embeddings using trained Decoder2 MLP.")
+    parser.add_argument("--config", type=str, required=True, help="Path to YAML config used for TRAINING the main script (Script M).")
+    # Checkpoints from Script M training
+    parser.add_argument("--hno_ckpt", type=str, default="checkpoints/hno_checkpoint.pth", help="Path to trained HNO ckpt (needed only if conditioner_mode='z_ref' AND z_ref file is missing).")
+    parser.add_argument("--decoder2_ckpt", type=str, default="checkpoints/decoder2_checkpoint.pth", help="Path to trained Decoder2 ckpt (from Script M).")
+    # Inputs: Diffused embeddings and Conditioner references from Script M
+    parser.add_argument("--diff_emb_file", type=str, required=True, help="HDF5 file with diffused embeddings (output from diffusion script).")
+    parser.add_argument("--diff_emb_key", type=str, default="generated_embeddings", help="Dataset key for diffused embeddings in HDF5 file.")
+    parser.add_argument("--conditioner_x_ref_pt", type=str, default="structures/X_ref_coords.pt", help="Path to saved X_ref_coords.pt (generated by Script M).")
+    parser.add_argument("--conditioner_z_ref_pt", type=str, default="latent_reps/z_ref_embedding.pt", help="Path to saved z_ref_embedding.pt (generated by Script M, required if conditioner_mode='z_ref').")
+    # Output
+    parser.add_argument("--output_file", type=str, default="structures/full_coords_diff.h5", help="Output HDF5 file for decoded diffusion coordinates.")
+    parser.add_argument("--output_key", type=str, default="full_coords_diff", help="Dataset key for output coords in HDF5 file.")
+    # Optional
+    parser.add_argument("--batch_size", type=int, default=64, help="Batch size for decoding.")
+    parser.add_argument("--cuda_device", type=int, default=0, help="GPU device index if CUDA available.")
+
+    args = parser.parse_args()
+
+    # Basic Logging Setup for this script
+    logging.basicConfig(level=logging.INFO, format='[%(asctime)s - %(levelname)s] %(message)s')
+
+    # --- Device Setup ---
+    if torch.cuda.is_available():
+        device = torch.device(f"cuda:{args.cuda_device}")
+        try:
+            torch.cuda.set_device(device) # Set default device
+        except Exception as e:
+            logging.warning(f"Could not set CUDA device {args.cuda_device}: {e}. Defaulting to cpu.")
+            device = torch.device("cpu")
+    else:
+        device = torch.device("cpu")
+    logging.info(f"Using Device: {device}")
+
+    # --- Load Training Config ---
+    try:
+        with open(args.config, "r") as f: config = yaml.safe_load(f)
+        logging.info(f"Loaded training config from: {args.config}")
+    except Exception as e: logging.error(f"Failed to load config: {e}"); sys.exit(1)
+
+    # --- Extract Necessary Parameters from Config ---
+    try:
+        hno_hdim = config["hno_encoder"]["hidden_dim"]
+        hno_k = config["hno_encoder"]["cheb_order"]
+        graph_cfg = config["graph"]; knn = graph_cfg["knn_value"] # Needed if calculating z_ref
+        d2s = config["decoder2_settings"]
+        d2_c_mode = d2s.get("conditioner_mode","z_ref"); d2_p_type = d2s.get("pooling_type","blind")
+        d2_ph, d2_pw = d2s.get("output_height",20), d2s.get("output_width",4); d2_mlp_h = d2s.get("mlp_hidden_dim",128)
+        d2_mlp_l = d2s.get("num_hidden_layers",2); d2_use_p2 = d2s.get("use_second_level_pooling",False);
+        d2_ph2, d2_pw2 = d2s.get("output_height2"), d2s.get("output_width2")
+        # --- FIX: Added missing lines ---
+        d2_use_a = d2s.get("use_cross_attention", False)
+        d2_a_type = d2s.get("cross_attention_type", "global")
+        # --- End Fix ---
+    except KeyError as e: logging.error(f"Missing key in config: {e}"); sys.exit(1)
+
+    # --- Load Conditioner Data ---
+    try:
+        X_ref_t = torch.load(args.conditioner_x_ref_pt, map_location='cpu').float() # Load X_ref [N, 3] on CPU
+        N_atoms = X_ref_t.shape[0]
+        logging.info(f"Loaded X_ref, N_atoms = {N_atoms}")
+    except Exception as e: logging.error(f"Failed to load X_ref from {args.conditioner_x_ref_pt}: {e}"); sys.exit(1)
+
+    conditioner_cpu = None; cond_dim = -1
+    if d2_c_mode == "X_ref":
+        conditioner_cpu = X_ref_t; cond_dim = 3; logging.info(f"Using X_ref conditioner (Dim={cond_dim})")
+    elif d2_c_mode == "z_ref":
+        if os.path.isfile(args.conditioner_z_ref_pt):
+             try:
+                  conditioner_cpu = torch.load(args.conditioner_z_ref_pt, map_location='cpu').float()
+                  cond_dim = conditioner_cpu.shape[1]
+                  logging.info(f"Loaded pre-computed z_ref conditioner (Dim={cond_dim})")
+             except Exception as e: logging.error(f"Failed to load z_ref file {args.conditioner_z_ref_pt}: {e}"); sys.exit(1)
+        else: # Need to compute z_ref
+             logging.info(f"z_ref file not found ({args.conditioner_z_ref_pt}). Computing z_ref using HNO...")
+             try:
+                 hno_model = HNO(hidden_dim=hno_hdim, K=hno_k).to(device)
+                 if not os.path.isfile(args.hno_ckpt): raise FileNotFoundError(f"HNO checkpoint not found at {args.hno_ckpt}")
+                 hno_ckpt_data = torch.load(args.hno_ckpt, map_location=device)
+                 hno_model.load_state_dict(hno_ckpt_data["model_state_dict"]); hno_model.eval()
+                 logging.info(f"Loaded HNO model from: {args.hno_ckpt}")
+                 logging.info("Calculating edge index for X_ref...")
+                 edge_index = knn_graph(X_ref_t.to(device), k=knn, loop=False)
+                 logging.info("Calculating z_ref via HNO forward_representation...")
+                 with torch.no_grad(): z_ref_dev = hno_model.forward_representation(X_ref_t.to(device), edge_index)
+                 conditioner_cpu = z_ref_dev.cpu(); cond_dim = conditioner_cpu.shape[1]
+                 logging.info(f"Computed z_ref as conditioner (Dim={cond_dim})")
+                 try: torch.save(conditioner_cpu, args.conditioner_z_ref_pt); logging.info(f"Saved computed z_ref to {args.conditioner_z_ref_pt}")
+                 except Exception as save_e: logging.warning(f"Could not save computed z_ref: {save_e}")
+                 del hno_model, edge_index # Clean up
+                 if torch.cuda.is_available(): torch.cuda.empty_cache()
+             except Exception as e: logging.error(f"Failed to compute z_ref: {e}"); sys.exit(1)
+    else: logging.error(f"Invalid conditioner_mode: {d2_c_mode}"); sys.exit(1)
+    if conditioner_cpu is None or conditioner_cpu.shape[0] != N_atoms: logging.error(f"Conditioner failed validation (None or wrong N_atoms {conditioner_cpu.shape[0]} vs {N_atoms})."); sys.exit(1)
+
+    # --- Load Diffused Embeddings ---
+    try:
+        logging.info(f"Loading diffused embeddings: {args.diff_emb_file} [Key: {args.diff_emb_key}]")
+        with h5py.File(args.diff_emb_file, "r") as f: diff_emb_np = f[args.diff_emb_key][:]
+        diff_emb_t = torch.tensor(diff_emb_np, dtype=torch.float) # Keep on CPU initially for shape checks
+        N_gen = diff_emb_t.shape[0]
+        logging.info(f"Loaded diffusion embeddings shape: {diff_emb_t.shape}")
+    except Exception as e: logging.error(f"Failed to load diffused embeddings: {e}"); sys.exit(1)
+
+    # --- Instantiate Decoder2 to get parameters and MLP ---
+    res_indices_dummy = [list(range(N_atoms))] if d2_p_type == "blind" else None
+    if d2_p_type == "residue": logging.warning("Residue pooling selected, ensure diffusion embs match expected structure.")
+    temp_logger = logging.getLogger("dummy"); temp_logger.setLevel(logging.CRITICAL)
+    try:
+        decoder2_instance_for_state = ProteinStateReconstructor2D(
+            in_dim=hno_hdim, N_nodes=N_atoms, cond_dim=cond_dim, pool_type=d2_p_type,
+            res_indices=res_indices_dummy, pool_size=(d2_ph, d2_pw), mlp_h_dim=d2_mlp_h,
+            mlp_layers=d2_mlp_l, pool2_size=((d2_ph2, d2_pw2) if d2_use_p2 and d2_ph2 and d2_pw2 else None),
+            use_pool2=d2_use_p2, use_attn=d2_use_a, attn_type=d2_a_type, logger=temp_logger
+        )
+        final_pool_dim_expected = decoder2_instance_for_state.final_pool_dim
+        logging.info(f"Decoder expects final pooled dimension: {final_pool_dim_expected}")
+    except Exception as e: logging.error(f"Failed to instantiate dummy Decoder2 model structure: {e}"); sys.exit(1)
+
+    # --- Validate and Reshape loaded diffusion embeddings ---
+    diff_emb_global_t = None # Will hold final [N_gen, final_pool_dim_expected] tensor
+    if diff_emb_t.ndim == 3: # Shape [N_gen, R, PD_seg] - Assume from Script D
+        logging.info("Loaded embeddings seem per-segment/residue. Flattening to global representation.")
+        loaded_R, loaded_PD_seg = diff_emb_t.shape[1], diff_emb_t.shape[2]
+        # Flatten to [N_gen, R * PD_seg]
+        diff_emb_global_t = diff_emb_t.reshape(N_gen, -1)
+        loaded_pooled_dim = diff_emb_global_t.shape[1]
+        logging.info(f"Flattened per-segment embeddings to global shape: {diff_emb_global_t.shape}")
+    elif diff_emb_t.ndim == 2: # Shape [N_gen, SomeDim] - Assume this is already global
+        logging.info("Loaded embeddings seem global.")
+        diff_emb_global_t = diff_emb_t
+        loaded_pooled_dim = diff_emb_global_t.shape[1]
+    else: logging.error(f"Loaded diffusion embeddings unexpected ndim={diff_emb_t.ndim}."); sys.exit(1)
+
+    # Final dimension check
+    if loaded_pooled_dim != final_pool_dim_expected:
+        logging.error(f"Dimension mismatch! Loaded/Flattened diffusion emb dim ({loaded_pooled_dim}) != Expected decoder pooled dim ({final_pool_dim_expected}).")
+        sys.exit(1)
+    diff_emb_global_t = diff_emb_global_t.to(device) # Move final embeddings to device
+
+    # --- Load Decoder2 Checkpoint and Extract MLP ---
+    try:
+        logging.info(f"Loading Decoder2 checkpoint from: {args.decoder2_ckpt}")
+        decoder2_model = ProteinStateReconstructor2D( # Instantiate with correct parameters
+            in_dim=hno_hdim, N_nodes=N_atoms, cond_dim=cond_dim, pool_type=d2_p_type,
+            res_indices=res_indices_dummy, pool_size=(d2_ph, d2_pw), mlp_h_dim=d2_mlp_h,
+            mlp_layers=d2_mlp_l, pool2_size=((d2_ph2, d2_pw2) if d2_use_p2 and d2_ph2 and d2_pw2 else None),
+            use_pool2=d2_use_p2, use_attn=d2_use_a, attn_type=d2_a_type, logger=temp_logger
+        ).to(device)
+        dec2_ckpt_data = torch.load(args.decoder2_ckpt, map_location=device)
+        decoder2_model.load_state_dict(dec2_ckpt_data["model_state_dict"])
+        decoder_mlp = decoder2_model.decoder # Extract the MLP part
+        decoder_mlp.eval()
+        logging.info("Successfully loaded Decoder2 MLP weights.")
+    except Exception as e: logging.error(f"Failed to load Decoder2 checkpoint/MLP: {e}"); sys.exit(1)
+
+    # --- Prepare Conditioner for Batches ---
+    conditioner_dev = conditioner_cpu.to(device) # Move final conditioner to device
+
+    # --- Decoding Loop ---
+    logging.info(f"Starting decoding for {N_gen} samples (Batch Size: {args.batch_size})...")
+    all_coords_list = []
+    with torch.no_grad():
+        for i in range(0, N_gen, args.batch_size):
+            b_start, b_end = i, min(i + args.batch_size, N_gen)
+            bs = b_end - b_start
+
+            pooled_batch = diff_emb_global_t[b_start:b_end] # [bs, final_pooled_dim]
+            cond_expanded = conditioner_dev.unsqueeze(0).expand(bs, -1, -1) # [bs, N, Cdim]
+
+            # Replicate the logic: Expand global pooled, concat with expanded conditioner
+            pooled_expanded = pooled_batch.unsqueeze(1).expand(-1, N_atoms, -1) # [bs, N, final_pooled_dim]
+            mlp_input_batch = torch.cat([cond_expanded, pooled_expanded], dim=-1) # [bs, N, Cdim + final_pool_dim]
+            mlp_input_flat = mlp_input_batch.view(bs * N_atoms, -1)
+
+            # Use the extracted MLP
+            coords_flat = decoder_mlp(mlp_input_flat) # [bs*N, 3]
+            coords_batch = coords_flat.view(bs, N_atoms, 3) # [bs, N, 3]
+
+            all_coords_list.append(coords_batch.cpu().numpy())
+            if (i // args.batch_size + 1) % 20 == 0: # Log progress less frequently
+                 logging.info(f"  Decoded up to sample {b_end}/{N_gen}")
+
+    # --- Concatenate and Save Results ---
+    try:
+        final_coords_np = np.concatenate(all_coords_list, axis=0)
+        logging.info(f"Concatenated decoded coords shape: {final_coords_np.shape}")
+        if final_coords_np.shape != (N_gen, N_atoms, 3):
+             logging.warning("Final coords shape mismatch!") # Sanity check
+
+        logging.info(f"Saving decoded structures to: {args.output_file} (Key: {args.output_key})")
+        os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
+        with h5py.File(args.output_file, "w") as f:
+            f.create_dataset(args.output_key, data=final_coords_np, chunks=(1, N_atoms, 3), compression="gzip") # Add chunking/compression
+        logging.info(f"[SUCCESS] Wrote decoded coordinates.")
+
+    except Exception as e: logging.error(f"Failed to concatenate or save results: {e}"); sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/blind/chebnet_multi.py

@@ -0,0 +1,821 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from typing import Dict, List, Optional, Tuple, Any
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv, global_mean_pool
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import NearestNeighbors # New dependency
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load
+################################################################################
+LOG_FILE_DEFAULT = "logfile_multi_system.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstruction")
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+if not logger.handlers:
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    try:
+        fh = logging.FileHandler(log_file_path, mode="w")
+        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+    except IOError as e:
+        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+logger.info(f"Logger initialized. Log file: {log_file_path}")
+if args.debug: logger.debug("Debug mode is ON.")
+
+################################################################################
+# (D) Device Setup (Global)
+################################################################################
+device_name = "cpu"
+if torch.cuda.is_available():
+    try:
+        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
+        device_name = f"cuda:{cuda_device_index}"
+        torch.cuda.get_device_name(cuda_device_index)
+    except Exception:
+        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
+        if torch.cuda.is_available(): device_name = "cuda:0"
+global_device = torch.device(device_name)
+logger.info(f"Initial device check: {global_device}")
+
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+# --- PDB Parsing ---
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
+    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line in pdb_file:
+                if not line.startswith("ATOM  "): continue
+                alt_loc = line[16].strip()
+                if alt_loc not in ['', 'A']: continue
+
+                atom_serial = int(line[6:11])
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+
+                atom_name = line[12:16].strip()
+                res_name = line[17:20].strip()
+                chain_id = line[21].strip()
+                res_seq = int(line[22:26])
+                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+
+                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
+                if atom_name == 'CA': ca_indices[res_seq] = atom_serial
+
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
+    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
+    return {}, atoms_in_order, ca_indices
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int]]:
+    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
+    new_res_dict, orig_atom_map = {}, {}
+    next_new_res_id, next_new_atom_index = 0, 0
+    orig_res_map = {}
+    
+    # Preserve original residue order
+    seen_res_order = {}
+    res_order_counter = 0
+    for r_id, _, _, _ in atoms_in_order:
+        if r_id not in seen_res_order:
+            seen_res_order[r_id] = res_order_counter
+            res_order_counter += 1
+
+    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
+    sortable.sort()
+
+    for _, serial, r_id, cat, name in sortable:
+        if r_id not in orig_res_map:
+            orig_res_map[r_id] = next_new_res_id
+            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
+            next_new_res_id += 1
+        
+        new_res_id = orig_res_map[r_id]
+        new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index
+        next_new_atom_index += 1
+
+    # Map original CA serial numbers to the new, renumbered 0-based indices
+    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
+    
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
+    return new_res_dict, orig_atom_map, {}, new_ca_indices
+
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()):
+        bb_idx.extend(renumbered_dict[res_id]["backbone"])
+        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)
+
+# --- JSON Loading ---
+# This function is unchanged and should work fine.
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
+    
+    try:
+        keys_int = sorted([int(k) for k in data.keys()])
+        keys_str = [str(k) for k in keys_int]
+        if not keys_str: logger.error("No residue data in JSON."); return [], -1
+        
+        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
+        n_frames = len(frame_data)
+        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0
+
+        coords_frames, n_atoms_check = [], -1
+        for frame_idx in range(n_frames):
+            frame_coords_np = []
+            current_atoms = 0
+            for res_key in keys_str:
+                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
+                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
+                frame_coords_np.append(coords)
+                current_atoms += coords.shape[0]
+
+            if frame_idx == 0:
+                n_atoms_check = current_atoms
+                logger.info(f"System has {n_atoms_check} atoms and {n_frames} frames.")
+            elif current_atoms != n_atoms_check:
+                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
+            
+            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))
+
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1
+
+# --- Alignment ---
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Aligns Q onto P using Kabsch algorithm. Handles batches [B, N, 3]."""
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
+    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try: V, S, Wt = torch.linalg.svd(C)
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
+        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
+        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
+        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
+    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
+    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
+    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    if not coords: logger.warning("Coordinate list empty."); return []
+    ref = coords[0].to(device)
+    aligned = [coords[0].cpu()]
+    n_frames = len(coords) -1
+    for i, frame in enumerate(coords[1:], 1):
+        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
+        aligned.append(aligned_dev.cpu())
+    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
+    return aligned
+
+# --- NEW ALIGNMENT UTILITIES for MULTI-SYSTEM ---
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
+    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
+    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
+        raise ValueError("Input coordinates must be 2D arrays.")
+
+    # Find nearest neighbor from target for each ref point
+    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
+    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
+    
+    # Find nearest neighbor from ref for each target point
+    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
+    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
+    
+    # Identify mutual pairs
+    ref_indices, target_indices = [], []
+    for i, target_idx in enumerate(indices1.flatten()):
+        if indices2[target_idx] == i:
+            ref_indices.append(i)
+            target_indices.append(target_idx)
+            
+    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
+    if not ref_indices:
+        logger.error("No mutual nearest neighbors found. Cannot align structures.")
+        return torch.tensor([]), torch.tensor([])
+        
+    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)
+
+def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
+                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
+                  logger: logging.Logger) -> torch.Tensor:
+    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
+    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
+    device = structure_to_align.device
+
+    # 1. Select the coordinates of the core atoms for both structures
+    P_core = reference_structure[core_indices_reference].to(device)
+    Q_core = structure_to_align[core_indices_to_align].to(device)
+    
+    # 2. Compute the rotation matrix (U) using only the core
+    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
+    
+    # 3. Center the full structure_to_align on its core's centroid
+    centroid_Q_core = compute_centroid(Q_core)
+    structure_to_align_centered = structure_to_align - centroid_Q_core
+    
+    # 4. Rotate the full centered structure
+    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
+    
+    # 5. Translate the rotated structure to the reference core's centroid
+    centroid_P_core = compute_centroid(P_core)
+    aligned_structure = structure_to_align_rotated + centroid_P_core
+    
+    return aligned_structure
+
+# --- Graph Dataset ---
+# Unchanged
+def build_graph_dataset(coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
+    dataset = []
+    n_frames = len(coords_list)
+    for i, coords_cpu in enumerate(coords_list):
+        coords_dev = coords_cpu.to(device)
+        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
+        data = Data(x=coords_cpu, edge_index=edge_idx.cpu(), y=coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
+        dataset.append(data)
+    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
+    return dataset
+
+# --- Dihedral Utilities ---
+# Unchanged
+@torch.jit.script
+def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
+    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
+    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
+    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
+    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)
+
+def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
+    """Computes all specified dihedrals vectorially."""
+    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
+    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
+    for name, angle_info in info.items():
+        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
+        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
+        if indices is not None and res_idx is not None and indices[0].numel() > 0:
+            try:
+                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
+                max_atom_idx_needed = max(i.max() for i in idx_dev)
+                if max_atom_idx_needed >= N_atoms:
+                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
+                    continue
+                
+                a,b,c,d = (coords[:, i, :] for i in idx_dev)
+                values = compute_dihedral(a,b,c,d)
+                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
+            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
+        all_angles[name] = angles_out
+    return all_angles
+
+
+def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
+    eps=1e-10
+    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
+    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
+    p_dist = p_hist / (p_hist.sum() + eps)
+    t_dist = t_hist / (t_hist.sum() + eps)
+    m_dist = 0.5 * (p_dist + t_dist)
+    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))
+
+# --- Checkpoint Utilities & MSE Utilities ---
+# Unchanged
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device)
+            start_epoch = ckpt.get("epoch", 0)
+            model.load_state_dict(ckpt["model_state_dict"])
+            if optimizer and "optimizer_state_dict" in ckpt:
+                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+                for state in optimizer.state.values():
+                    for k, v in state.items():
+                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
+            model.to(device)
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
+            start_epoch = 0
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
+    model.to(device)
+    return model, optimizer, start_epoch
+
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    crit = nn.MSELoss()
+    all_mse = crit(pred, target)
+    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    return all_mse, bb_mse, sc_mse
+
+
+################################################################################
+# (F) Model Definitions
+################################################################################
+
+# --- HNO Encoder ---
+# NOTE: This model is already size-agnostic. The ChebConv and final Linear layers
+# operate on a per-node basis, so it handles graphs of different sizes correctly.
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged = False
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head
+
+    def forward(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        x_rep = F.normalize(x, p=2.0, dim=1)
+        x_recon = self.mlpRep(x_rep)
+        
+        if self.training is False and not self._debug_logged:
+             logger.debug(f"[HNO] Forward pass shapes: In={x.shape}, Rep={x_rep.shape}, Recon={x_recon.shape}")
+             self._debug_logged = True
+        return x_recon
+
+    def forward_representation(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        return F.normalize(x, p=2.0, dim=1)
+
+# --- REFACTORED Decoder2 Model ---
+class ProteinStateReconstructor2D(nn.Module):
+    """
+    Size-agnostic decoder. Predicts full coordinates from node embeddings.
+    It combines local (per-node) and global (per-graph) information.
+    """
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int, mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        self._logged_fwd = False
+        
+        # The input to the final MLP for each node will be:
+        # [local_node_embedding, global_graph_embedding, global_conditioner_embedding]
+        mlp_in_dim = node_emb_dim + node_emb_dim + cond_emb_dim
+        
+        # Simple MLP decoder
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+        
+        self.logger.info(f"Initialized Size-Agnostic Decoder2 with MLP input dim: {mlp_in_dim}")
+
+    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x (Tensor): Per-node embeddings from HNO [N_total_nodes, E_node]
+            batch (Tensor): PyG batch vector [N_total_nodes]
+            conditioner_z_ref (Tensor): Per-node reference embeddings [N_total_nodes, E_cond]
+        """
+        # 1. Get global embedding for the current conformation
+        z_global = global_mean_pool(x, batch) # -> [B, E_node]
+        z_global_per_node = z_global[batch] # Broadcast to each node -> [N_total_nodes, E_node]
+
+        # 2. Get global embedding for the conditioner
+        conditioner_global = global_mean_pool(conditioner_z_ref, batch) # -> [B, E_cond]
+        conditioner_global_per_node = conditioner_global[batch] # -> [N_total_nodes, E_cond]
+        
+        # 3. Assemble the feature vector for each node
+        mlp_input = torch.cat([x, z_global_per_node, conditioner_global_per_node], dim=1)
+        
+        # 4. Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+        
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Dec2 Fwd] Shapes: In x={x.shape}, z_global={z_global.shape}, cond_global={conditioner_global.shape}, mlp_in={mlp_input.shape}, Out={pred_coords.shape}")
+            self._logged_fwd = True
+            
+        return pred_coords
+
+################################################################################
+# (G) Training Functions
+################################################################################
+
+# --- Train HNO ---
+# This function requires minimal changes as the model is size-agnostic
+def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev)
+    params = list(filter(lambda p: p.requires_grad, model.parameters()))
+    opt = torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+    
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+
+    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        total_loss = 0.0
+        for data in tr_loader:
+            data=data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            pred = model(data.x, data.edge_index)
+            loss = F.mse_loss(pred, data.y)
+            loss.backward()
+            opt.step()
+            total_loss += loss.item()
+        avg_tr_loss = total_loss / len(tr_loader)
+        
+        model.eval()
+        total_val_loss = 0.0
+        with torch.no_grad():
+            for data in te_loader:
+                data=data.to(dev)
+                pred=model(data.x, data.edge_index)
+                total_val_loss += F.mse_loss(pred, data.y).item()
+        avg_te_loss = total_val_loss / len(te_loader)
+
+        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+    
+    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
+    return model
+
+# --- REFACTORED Train Decoder2 ---
+def train_decoder2_model(
+    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
+    all_conditioners: Dict[int, torch.Tensor], # Dict of z_ref tensors
+    all_sys_info: Dict[int, Any], # Dict containing bb_idx, sc_idx, n_res etc. for each system
+    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
+    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
+):
+    model = model.to(dev)
+    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+        
+    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
+    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")
+
+    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
+        
+        for data in tr_loader:
+            data = data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            
+            # --- Assemble Batch-Specific Conditioners and Indices ---
+            # This is the core logic for handling heterogeneous batches
+            unique_sys_ids = torch.unique(data.system_id)
+            
+            # Create the conditioner tensor for this specific batch
+            # Note: This could be optimized, but is clear for debugging
+            cond_list = [all_conditioners[sid.item()].to(dev)[all_sys_info[sid.item()]['bb_idx']] for sid in data.system_id]
+            # TODO: The line above is a placeholder and needs to be corrected based on how conditioners are stored/used.
+            # A simpler approach:
+            cond_list = []
+            for i in range(data.num_graphs):
+                sid = data.system_id[i].item()
+                num_nodes = data.ptr[i+1] - data.ptr[i]
+                cond = all_conditioners[sid].to(dev)
+                if cond.shape[0] != num_nodes: # This check is important!
+                    logger.error(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
+                    # This should not happen if data prep is correct.
+                    # As a fallback, we must skip or resize. For now, let's assume it matches.
+                cond_list.append(cond)
+            conditioners_for_batch = torch.cat(cond_list, dim=0)
+
+            # --- Forward and Coordinate Loss ---
+            pred = model(data.x, data.batch, conditioners_for_batch)
+            total_loss = 0.0
+            coord_loss = 0.0
+
+            # Calculate coordinate MSE loss per system in the batch
+            for sid_tensor in unique_sys_ids:
+                sid = sid_tensor.item()
+                mask = (data.system_id.squeeze() == sid)
+                
+                bb_idx = all_sys_info[sid]['bb_idx_local'] # Use local indices
+                sc_idx = all_sys_info[sid]['sc_idx_local']
+                
+                pred_sys = pred[mask]
+                target_sys = data.y[mask]
+                
+                sys_mse, _, _ = compute_bb_sc_mse(pred_sys, target_sys, bb_idx, sc_idx, logger)
+                coord_loss += sys_mse
+
+            total_loss += base_w * coord_loss
+            tr_metrics['coord'] += coord_loss.item()
+            
+            # --- Dihedral Loss ---
+            di_div_loss = torch.tensor(0.0, device=dev)
+            di_mse_loss = torch.tensor(0.0, device=dev)
+            if use_di and all_di_info:
+                for sid_tensor in unique_sys_ids:
+                    sid = sid_tensor.item()
+                    mask = (data.system_id.squeeze() == sid)
+                    
+                    pred_sys_3d = pred[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
+                    true_sys_3d = data.y[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
+                    
+                    pred_a = compute_all_dihedrals_vectorized(pred_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    true_a = compute_all_dihedrals_vectorized(true_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+
+                    for name in pred_a:
+                        pa, ta = pred_a[name], true_a[name]
+                        if pa.numel() > 0:
+                             di_div_loss += comp_div(pa, ta)
+                             di_mse_loss += F.mse_loss(pa, ta)
+                
+                total_loss += l_div * di_div_loss + l_mse * di_mse_loss
+                tr_metrics['di_div'] += di_div_loss.item()
+                tr_metrics['di_mse'] += di_mse_loss.item()
+
+            tr_metrics['total'] += total_loss.item()
+            total_loss.backward()
+            opt.step()
+        
+        # Log training stats (validation loop omitted for brevity but should be added)
+        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
+        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+            
+    logger.info("Finished Decoder2 training.")
+    return model
+
+
+################################################################################
+# (I) Main Execution Function
+################################################################################
+def main():
+    start_time = time.time()
+    logger.info("================ Script Starting (Multi-System Version) ================")
+    global global_device
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    logger.info("Successfully loaded configuration.")
+    
+    # --- Extract Parameters ---
+    force_cpu = config.get("force_cpu", False)
+    device = torch.device("cpu") if force_cpu else global_device
+    pin_mem = (device.type == "cuda")
+    num_workers = config.get("num_workers", 0)
+    
+    hno_cfg = config["hno_encoder"]
+    dec2_cfg = config["decoder2"]
+    d2s = config["decoder2_settings"]
+    di_cfg = config.get("dihedral_loss", {})
+    out_cfg = config["output_directories"]
+    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]
+
+    # --- Stage 1: Multi-System Data Loading & Alignment ---
+    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
+    
+    full_dset = []
+    all_sys_info = {} # Will store n_atoms, n_res, ca_indices, bb_idx etc. for each system
+    canonical_ref_coords = None
+    canonical_ref_ca_indices = None
+
+    # Loop through each system defined in the config
+    for i, system_config in enumerate(config["data"]["systems"]):
+        sid = i
+        pdb_p = system_config["pdb_path"]
+        json_p = system_config["json_path"]
+        logger.info(f"--- Processing System ID {sid}: {os.path.basename(pdb_p)} ---")
+
+        # 1. Parse PDB for topology and C-alpha indices
+        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
+        renum_d, _, _, ca_indices_new = renumber_atoms_and_residues(atoms_ord, ca_serial_map)
+        bb_idx, sc_idx = get_global_indices(renum_d)
+        
+        # 2. Load coordinates from JSON
+        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger)
+        if not coords_list: continue # Skip if system loading failed
+
+        all_sys_info[sid] = {
+            'n_atoms': n_atoms,
+            'ca_indices': ca_indices_new,
+            'bb_idx_local': bb_idx, # These are local to the system
+            'sc_idx_local': sc_idx,
+            'n_res': len(renum_d)
+        }
+
+        # 3. Perform Alignment
+        aligned_coords_list = []
+        if sid == 0:
+            # This is the canonical reference system
+            logger.info(f"System {sid} is the canonical reference.")
+            canonical_ref_coords = coords_list[0].clone()
+            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
+        else:
+            # Align this system to the canonical reference
+            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
+            target_ref_coords = coords_list[0]
+            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            
+            # Find core pairs for alignment
+            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
+                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
+                target_ref_coords[target_ca_indices].numpy(),
+                logger
+            )
+            
+            # Align the first frame of this system to the canonical reference
+            aligned_target_ref_frame = align_by_core(
+                target_ref_coords, target_ca_indices[core_target_idx],
+                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
+                logger
+            ).to(device)
+            
+            # Align the rest of this system's trajectory to its own aligned reference frame
+            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
+            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)
+
+        # 4. Build graph dataset for this system and add to the master list
+        system_dset = build_graph_dataset(aligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
+        full_dset.extend(system_dset)
+
+    logger.info(f"--- Finished data loading. Total frames in dataset: {len(full_dset)} ---")
+
+    # --- Stage 2: HNO Training ---
+    logger.info("--- Stage 2: Training Shared HNO Encoder ---")
+    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
+    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
+    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
+    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
+    hno_model.eval()
+
+    # --- Stage 3: Decoder Input Data Prep ---
+    logger.info("--- Stage 3: Preparing Decoder Input Dataset & Conditioners ---")
+    dec_in_dset = []
+    all_conditioners = {} # Dictionary to hold the z_ref for each system
+    
+    # Generate embeddings for the whole dataset
+    with torch.no_grad():
+        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
+        for batch in infer_load:
+            batch = batch.to(device)
+            emb = hno_model.forward_representation(batch.x, batch.edge_index)
+            # De-batch to create new Data objects
+            emb_list = torch.split(emb, batch.ptr[1:] - batch.ptr[:-1])
+            y_list = torch.split(batch.y, batch.ptr[1:] - batch.ptr[:-1])
+            sid_list = torch.split(batch.system_id, batch.ptr[1:] - batch.ptr[:-1])
+            
+            for i in range(len(emb_list)):
+                dec_in_dset.append(Data(x=emb_list[i].cpu(), y=y_list[i].cpu(), system_id=sid_list[i].cpu()))
+    
+    # Create the conditioner dictionary
+    if d2s['conditioner_mode'] == 'z_ref':
+        for sid in all_sys_info.keys():
+            # Find the first frame of the system in the original dataset to get its reference coords
+            ref_data_orig = next(d for d in full_dset if d.system_id.item() == sid)
+            ref_data_orig = ref_data_orig.to(device)
+            with torch.no_grad():
+                z_ref = hno_model.forward_representation(ref_data_orig.x, ref_data_orig.edge_index)
+                all_conditioners[sid] = z_ref.cpu() # Store on CPU
+        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
+    else:
+        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")
+
+    # --- Stage 4: Decoder Setup & Training ---
+    logger.info("--- Stage 4: Decoder2 Setup & Training ---")
+    
+    # Prepare Dihedral Info Dictionaries
+    all_di_info = {}
+    use_di_train = di_cfg.get("use_dihedral_loss", False)
+    if use_di_train:
+        logger.info("Preparing dihedral information for all systems...")
+        for i, system_config in enumerate(config["data"]["systems"]):
+            sid = i
+            torsion_p = system_config.get("torsion_info_path")
+            if not torsion_p or not os.path.isfile(torsion_p):
+                logger.warning(f"Torsion file not found for system {sid}. Disabling dihedral loss for this system.")
+                continue
+            
+            with open(torsion_p, "r") as f: t_info = json.load(f)
+            # Simplified parsing logic, assuming it's correct per system
+            di_info_sys = {} # ... parsing logic to fill this based on t_info ...
+            all_di_info[sid] = di_info_sys
+        if not all_di_info: use_di_train = False # Disable if no files were loaded
+    
+    # Initialize and Train Decoder
+    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
+    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    
+    dec2_model = ProteinStateReconstructor2D(
+        node_emb_dim=hno_cfg['hidden_dim'],
+        cond_emb_dim=hno_cfg['hidden_dim'], # since we use z_ref
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    )
+    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
+    dec2_model = train_decoder2_model(
+        dec2_model, load_tr_dec, load_te_dec, all_conditioners, all_sys_info,
+        dec2_cfg['num_epochs'], dec2_cfg['learning_rate'], dec2_ckpt, dec2_cfg['save_interval'], device, logger,
+        dec2_cfg['base_loss_weight'], use_di_train, all_di_info,
+        di_cfg.get('divergence_type', 'JS'), di_cfg.get('lambda_divergence', 0.0), di_cfg.get('lambda_torsion_mse', 0.0)
+    )
+
+    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")
+
+################################################################################
+# (J) Script Entry Point
+################################################################################
+if __name__ == "__main__":
+    main()

LD-FPG-main/blind/helper/backbone_heavy_chain.pdb

@@ -0,0 +1,1093 @@
+HEADER    HEAVY ATOMS - FIRST FRAME
+ATOM      0    N PRO A   1      54.270  48.780  27.280  1.00  0.00            N
+ATOM      6   CA PRO A   1      55.720  48.730  27.580  1.00  0.00           CA
+ATOM     14    C PRO A   1      55.860  48.240  29.020  1.00  0.00            C
+ATOM     15    O PRO A   1      54.930  48.080  29.780  1.00  0.00            O
+ATOM     16    N TYR A   3      57.130  48.190  29.460  1.00  0.00            N
+ATOM     18   CA TYR A   3      57.490  47.630  30.770  1.00  0.00           CA
+ATOM     35    C TYR A   3      58.270  48.630  31.600  1.00  0.00            C
+ATOM     36    O TYR A   3      58.790  48.280  32.670  1.00  0.00            O
+ATOM     37    N ASN A   4      58.270  49.910  31.170  1.00  0.00            N
+ATOM     39   CA ASN A   4      58.800  51.020  31.990  1.00  0.00           CA
+ATOM     49    C ASN A   4      58.040  51.130  33.270  1.00  0.00            C
+ATOM     50    O ASN A   4      58.790  51.480  34.220  1.00  0.00            O
+ATOM     51    N TYR A   5      56.740  50.840  33.400  1.00  0.00            N
+ATOM     53   CA TYR A   5      56.140  50.610  34.650  1.00  0.00           CA
+ATOM     70    C TYR A   5      56.910  49.800  35.740  1.00  0.00            C
+ATOM     71    O TYR A   5      57.240  50.350  36.820  1.00  0.00            O
+ATOM     72    N TYR A   6      57.310  48.530  35.380  1.00  0.00            N
+ATOM     74   CA TYR A   6      58.130  47.700  36.280  1.00  0.00           CA
+ATOM     91    C TYR A   6      59.520  48.280  36.530  1.00  0.00            C
+ATOM     92    O TYR A   6      59.970  48.410  37.670  1.00  0.00            O
+ATOM     93    N ALA A   7      60.260  48.850  35.560  1.00  0.00            N
+ATOM     95   CA ALA A   7      61.450  49.630  35.830  1.00  0.00           CA
+ATOM    101    C ALA A   7      61.260  50.860  36.650  1.00  0.00            C
+ATOM    102    O ALA A   7      62.230  51.190  37.320  1.00  0.00            O
+ATOM    103    N THR A   8      60.100  51.480  36.690  1.00  0.00            N
+ATOM    105   CA THR A   8      59.850  52.500  37.730  1.00  0.00           CA
+ATOM    115    C THR A   8      59.860  51.910  39.160  1.00  0.00            C
+ATOM    116    O THR A   8      60.520  52.430  40.060  1.00  0.00            O
+ATOM    117    N LEU A   9      59.160  50.790  39.390  1.00  0.00            N
+ATOM    119   CA LEU A   9      59.060  50.130  40.690  1.00  0.00           CA
+ATOM    134    C LEU A   9      60.400  49.640  41.240  1.00  0.00            C
+ATOM    135    O LEU A   9      60.720  49.850  42.400  1.00  0.00            O
+ATOM    136    N LEU A  10      61.230  49.030  40.410  1.00  0.00            N
+ATOM    138   CA LEU A  10      62.620  48.670  40.720  1.00  0.00           CA
+ATOM    153    C LEU A  10      63.430  49.950  41.050  1.00  0.00            C
+ATOM    154    O LEU A  10      64.230  49.960  41.950  1.00  0.00            O
+ATOM    155    N THR A  11      63.230  50.990  40.280  1.00  0.00            N
+ATOM    157   CA THR A  11      63.860  52.260  40.480  1.00  0.00           CA
+ATOM    167    C THR A  11      63.520  52.880  41.870  1.00  0.00            C
+ATOM    168    O THR A  11      64.330  53.310  42.680  1.00  0.00            O
+ATOM    169    N LEU A  12      62.320  52.840  42.290  1.00  0.00            N
+ATOM    171   CA LEU A  12      61.910  53.120  43.670  1.00  0.00           CA
+ATOM    186    C LEU A  12      62.330  52.110  44.700  1.00  0.00            C
+ATOM    187    O LEU A  12      62.660  52.520  45.800  1.00  0.00            O
+ATOM    188    N LEU A  13      62.410  50.810  44.450  1.00  0.00            N
+ATOM    190   CA LEU A  13      62.760  49.720  45.380  1.00  0.00           CA
+ATOM    205    C LEU A  13      64.260  49.880  45.810  1.00  0.00            C
+ATOM    206    O LEU A  13      64.580  49.590  46.960  1.00  0.00            O
+ATOM    207    N ILE A  14      65.170  50.270  44.820  1.00  0.00            N
+ATOM    209   CA ILE A  14      66.570  50.580  45.050  1.00  0.00           CA
+ATOM    224    C ILE A  14      66.700  51.720  46.110  1.00  0.00            C
+ATOM    225    O ILE A  14      67.440  51.570  47.060  1.00  0.00            O
+ATOM    226    N ALA A  15      65.850  52.750  45.890  1.00  0.00            N
+ATOM    228   CA ALA A  15      65.730  53.890  46.830  1.00  0.00           CA
+ATOM    234    C ALA A  15      65.300  53.520  48.230  1.00  0.00            C
+ATOM    235    O ALA A  15      65.740  54.120  49.210  1.00  0.00            O
+ATOM    236    N VAL A  16      64.320  52.590  48.440  1.00  0.00            N
+ATOM    238   CA VAL A  16      63.850  52.120  49.730  1.00  0.00           CA
+ATOM    250    C VAL A  16      64.990  51.360  50.410  1.00  0.00            C
+ATOM    251    O VAL A  16      65.370  51.640  51.570  1.00  0.00            O
+ATOM    252    N ILE A  17      65.560  50.420  49.670  1.00  0.00            N
+ATOM    254   CA ILE A  17      66.820  49.650  50.100  1.00  0.00           CA
+ATOM    269    C ILE A  17      67.930  50.630  50.580  1.00  0.00            C
+ATOM    270    O ILE A  17      68.340  50.560  51.710  1.00  0.00            O
+ATOM    271    N VAL A  18      68.340  51.650  49.750  1.00  0.00            N
+ATOM    273   CA VAL A  18      69.370  52.610  50.070  1.00  0.00           CA
+ATOM    285    C VAL A  18      69.060  53.430  51.300  1.00  0.00            C
+ATOM    286    O VAL A  18      69.890  53.590  52.200  1.00  0.00            O
+ATOM    287    N PHE A  19      67.810  54.000  51.370  1.00  0.00            N
+ATOM    289   CA PHE A  19      67.440  54.800  52.570  1.00  0.00           CA
+ATOM    305    C PHE A  19      67.450  54.000  53.900  1.00  0.00            C
+ATOM    306    O PHE A  19      68.110  54.430  54.830  1.00  0.00            O
+ATOM    307    N GLY A  20      66.810  52.860  53.900  1.00  0.00            N
+ATOM    309   CA GLY A  20      66.840  51.890  55.040  1.00  0.00           CA
+ATOM    312    C GLY A  20      68.130  51.570  55.690  1.00  0.00            C
+ATOM    313    O GLY A  20      68.340  51.620  56.900  1.00  0.00            O
+ATOM    314    N ASN A  21      69.110  51.170  54.910  1.00  0.00            N
+ATOM    316   CA ASN A  21      70.270  50.470  55.390  1.00  0.00           CA
+ATOM    326    C ASN A  21      71.450  51.370  55.750  1.00  0.00            C
+ATOM    327    O ASN A  21      72.410  50.990  56.400  1.00  0.00            O
+ATOM    328    N VAL A  22      71.290  52.620  55.360  1.00  0.00            N
+ATOM    330   CA VAL A  22      72.110  53.740  55.810  1.00  0.00           CA
+ATOM    342    C VAL A  22      71.900  54.050  57.320  1.00  0.00            C
+ATOM    343    O VAL A  22      72.830  54.130  58.140  1.00  0.00            O
+ATOM    344    N LEU A  23      70.580  54.150  57.730  1.00  0.00            N
+ATOM    346   CA LEU A  23      70.190  54.210  59.120  1.00  0.00           CA
+ATOM    361    C LEU A  23      70.650  53.040  59.910  1.00  0.00            C
+ATOM    362    O LEU A  23      71.140  53.250  61.030  1.00  0.00            O
+ATOM    363    N VAL A  24      70.560  51.750  59.400  1.00  0.00            N
+ATOM    365   CA VAL A  24      71.160  50.630  60.200  1.00  0.00           CA
+ATOM    377    C VAL A  24      72.680  50.750  60.450  1.00  0.00            C
+ATOM    378    O VAL A  24      73.130  50.550  61.580  1.00  0.00            O
+ATOM    379    N CYS A  25      73.420  51.250  59.400  1.00  0.00            N
+ATOM    381   CA CYS A  25      74.850  51.430  59.460  1.00  0.00           CA
+ATOM    388    C CYS A  25      75.260  52.500  60.490  1.00  0.00            C
+ATOM    389    O CYS A  25      76.250  52.440  61.260  1.00  0.00            O
+ATOM    390    N MET A  26      74.450  53.600  60.470  1.00  0.00            N
+ATOM    392   CA MET A  26      74.620  54.720  61.380  1.00  0.00           CA
+ATOM    405    C MET A  26      74.130  54.440  62.750  1.00  0.00            C
+ATOM    406    O MET A  26      74.730  55.040  63.610  1.00  0.00            O
+ATOM    407    N ALA A  27      73.120  53.590  63.020  1.00  0.00            N
+ATOM    409   CA ALA A  27      72.530  53.360  64.320  1.00  0.00           CA
+ATOM    415    C ALA A  27      73.350  52.510  65.220  1.00  0.00            C
+ATOM    416    O ALA A  27      73.600  52.960  66.310  1.00  0.00            O
+ATOM    417    N VAL A  28      73.990  51.430  64.740  1.00  0.00            N
+ATOM    419   CA VAL A  28      75.070  50.740  65.410  1.00  0.00           CA
+ATOM    431    C VAL A  28      76.280  51.640  65.650  1.00  0.00            C
+ATOM    432    O VAL A  28      77.020  51.370  66.620  1.00  0.00            O
+ATOM    433    N SER A  29      76.570  52.660  64.780  1.00  0.00            N
+ATOM    435   CA SER A  29      77.680  53.600  64.920  1.00  0.00           CA
+ATOM    442    C SER A  29      77.330  54.610  66.080  1.00  0.00            C
+ATOM    443    O SER A  29      78.200  54.980  66.890  1.00  0.00            O
+ATOM    444    N ARG A  30      76.140  55.160  66.140  1.00  0.00            N
+ATOM    446   CA ARG A  30      75.750  56.320  66.870  1.00  0.00           CA
+ATOM    466    C ARG A  30      75.110  56.040  68.190  1.00  0.00            C
+ATOM    467    O ARG A  30      74.990  56.860  69.100  1.00  0.00            O
+ATOM    468    N GLU A  31      74.430  54.870  68.290  1.00  0.00            N
+ATOM    470   CA GLU A  31      73.770  54.400  69.470  1.00  0.00           CA
+ATOM    481    C GLU A  31      74.560  53.350  70.240  1.00  0.00            C
+ATOM    482    O GLU A  31      74.910  52.280  69.750  1.00  0.00            O
+ATOM    483    N LYS A  32      74.880  53.620  71.530  1.00  0.00            N
+ATOM    485   CA LYS A  32      75.550  52.690  72.350  1.00  0.00           CA
+ATOM    503    C LYS A  32      74.690  51.530  72.760  1.00  0.00            C
+ATOM    504    O LYS A  32      75.250  50.450  73.060  1.00  0.00            O
+ATOM    505    N ALA A  33      73.370  51.590  72.850  1.00  0.00            N
+ATOM    507   CA ALA A  33      72.460  50.510  73.130  1.00  0.00           CA
+ATOM    513    C ALA A  33      72.520  49.390  72.090  1.00  0.00            C
+ATOM    514    O ALA A  33      72.180  48.210  72.370  1.00  0.00            O
+ATOM    515    N LEU A  34      72.950  49.760  70.820  1.00  0.00            N
+ATOM    517   CA LEU A  34      72.880  48.930  69.650  1.00  0.00           CA
+ATOM    532    C LEU A  34      74.260  48.270  69.360  1.00  0.00            C
+ATOM    533    O LEU A  34      74.510  47.650  68.330  1.00  0.00            O
+ATOM    534    N GLN A  35      75.270  48.550  70.150  1.00  0.00            N
+ATOM    536   CA GLN A  35      76.650  47.980  70.130  1.00  0.00           CA
+ATOM    549    C GLN A  35      76.850  46.730  70.990  1.00  0.00            C
+ATOM    550    O GLN A  35      77.130  46.760  72.180  1.00  0.00            O
+ATOM    551    N THR A  36      76.490  45.570  70.250  1.00  0.00            N
+ATOM    553   CA THR A  36      76.560  44.190  70.700  1.00  0.00           CA
+ATOM    563    C THR A  36      76.800  43.290  69.480  1.00  0.00            C
+ATOM    564    O THR A  36      76.470  43.690  68.380  1.00  0.00            O
+ATOM    565    N THR A  37      77.300  42.060  69.720  1.00  0.00            N
+ATOM    567   CA THR A  37      77.860  41.190  68.710  1.00  0.00           CA
+ATOM    577    C THR A  37      76.960  40.940  67.580  1.00  0.00            C
+ATOM    578    O THR A  37      77.400  40.990  66.470  1.00  0.00            O
+ATOM    579    N THR A  38      75.730  40.640  67.840  1.00  0.00            N
+ATOM    581   CA THR A  38      74.740  40.410  66.820  1.00  0.00           CA
+ATOM    591    C THR A  38      74.540  41.510  65.840  1.00  0.00            C
+ATOM    592    O THR A  38      74.340  41.340  64.610  1.00  0.00            O
+ATOM    593    N ASN A  39      74.740  42.820  66.290  1.00  0.00            N
+ATOM    595   CA ASN A  39      74.350  43.970  65.520  1.00  0.00           CA
+ATOM    605    C ASN A  39      75.460  44.470  64.600  1.00  0.00            C
+ATOM    606    O ASN A  39      75.320  45.100  63.560  1.00  0.00            O
+ATOM    607    N TYR A  40      76.690  44.030  64.950  1.00  0.00            N
+ATOM    609   CA TYR A  40      77.870  44.100  64.140  1.00  0.00           CA
+ATOM    626    C TYR A  40      77.690  43.250  62.860  1.00  0.00            C
+ATOM    627    O TYR A  40      78.020  43.790  61.750  1.00  0.00            O
+ATOM    628    N LEU A  41      77.230  42.060  62.910  1.00  0.00            N
+ATOM    630   CA LEU A  41      77.080  41.170  61.750  1.00  0.00           CA
+ATOM    645    C LEU A  41      75.900  41.590  60.980  1.00  0.00            C
+ATOM    646    O LEU A  41      75.870  41.410  59.790  1.00  0.00            O
+ATOM    647    N ILE A  42      74.910  42.320  61.620  1.00  0.00            N
+ATOM    649   CA ILE A  42      73.760  42.990  60.910  1.00  0.00           CA
+ATOM    664    C ILE A  42      74.200  44.140  60.040  1.00  0.00            C
+ATOM    665    O ILE A  42      73.630  44.310  58.970  1.00  0.00            O
+ATOM    666    N VAL A  43      75.240  44.880  60.420  1.00  0.00            N
+ATOM    668   CA VAL A  43      75.760  45.960  59.600  1.00  0.00           CA
+ATOM    680    C VAL A  43      76.500  45.450  58.380  1.00  0.00            C
+ATOM    681    O VAL A  43      76.420  45.910  57.240  1.00  0.00            O
+ATOM    682    N SER A  44      77.280  44.400  58.620  1.00  0.00            N
+ATOM    684   CA SER A  44      77.820  43.580  57.550  1.00  0.00           CA
+ATOM    691    C SER A  44      76.880  42.930  56.580  1.00  0.00            C
+ATOM    692    O SER A  44      77.130  42.910  55.370  1.00  0.00            O
+ATOM    693    N LEU A  45      75.680  42.430  57.070  1.00  0.00            N
+ATOM    695   CA LEU A  45      74.430  42.060  56.330  1.00  0.00           CA
+ATOM    710    C LEU A  45      73.880  43.290  55.520  1.00  0.00            C
+ATOM    711    O LEU A  45      73.540  43.140  54.340  1.00  0.00            O
+ATOM    712    N ALA A  46      73.750  44.450  56.180  1.00  0.00            N
+ATOM    714   CA ALA A  46      73.220  45.700  55.540  1.00  0.00           CA
+ATOM    720    C ALA A  46      74.120  46.300  54.510  1.00  0.00            C
+ATOM    721    O ALA A  46      73.600  46.810  53.570  1.00  0.00            O
+ATOM    722    N VAL A  47      75.450  46.150  54.610  1.00  0.00            N
+ATOM    724   CA VAL A  47      76.440  46.500  53.590  1.00  0.00           CA
+ATOM    736    C VAL A  47      76.350  45.600  52.410  1.00  0.00            C
+ATOM    737    O VAL A  47      76.370  46.090  51.280  1.00  0.00            O
+ATOM    738    N ALA A  48      76.070  44.300  52.630  1.00  0.00            N
+ATOM    740   CA ALA A  48      75.720  43.440  51.460  1.00  0.00           CA
+ATOM    746    C ALA A  48      74.450  43.930  50.670  1.00  0.00            C
+ATOM    747    O ALA A  48      74.490  43.950  49.430  1.00  0.00            O
+ATOM    748    N ASP A  49      73.400  44.280  51.420  1.00  0.00            N
+ATOM    750   CA ASP A  49      72.220  44.890  50.920  1.00  0.00           CA
+ATOM    758    C ASP A  49      72.500  46.240  50.180  1.00  0.00            C
+ATOM    759    O ASP A  49      71.900  46.590  49.190  1.00  0.00            O
+ATOM    760    N LEU A  50      73.400  47.070  50.740  1.00  0.00            N
+ATOM    762   CA LEU A  50      73.930  48.230  50.070  1.00  0.00           CA
+ATOM    777    C LEU A  50      74.700  47.910  48.800  1.00  0.00            C
+ATOM    778    O LEU A  50      74.400  48.550  47.810  1.00  0.00            O
+ATOM    779    N LEU A  51      75.560  46.910  48.690  1.00  0.00            N
+ATOM    781   CA LEU A  51      76.250  46.560  47.490  1.00  0.00           CA
+ATOM    796    C LEU A  51      75.310  45.880  46.460  1.00  0.00            C
+ATOM    797    O LEU A  51      75.520  46.170  45.290  1.00  0.00            O
+ATOM    798    N VAL A  52      74.170  45.220  46.910  1.00  0.00            N
+ATOM    800   CA VAL A  52      73.080  44.810  46.010  1.00  0.00           CA
+ATOM    812    C VAL A  52      72.500  46.090  45.320  1.00  0.00            C
+ATOM    813    O VAL A  52      72.350  46.120  44.120  1.00  0.00            O
+ATOM    814    N ALA A  53      72.210  47.140  46.150  1.00  0.00            N
+ATOM    816   CA ALA A  53      71.530  48.390  45.700  1.00  0.00           CA
+ATOM    822    C ALA A  53      72.380  49.270  44.750  1.00  0.00            C
+ATOM    823    O ALA A  53      71.940  50.010  43.850  1.00  0.00            O
+ATOM    824    N THR A  54      73.720  49.190  44.950  1.00  0.00            N
+ATOM    826   CA THR A  54      74.670  50.090  44.280  1.00  0.00           CA
+ATOM    836    C THR A  54      75.230  49.550  42.960  1.00  0.00            C
+ATOM    837    O THR A  54      75.360  50.240  41.970  1.00  0.00            O
+ATOM    838    N LEU A  55      75.390  48.170  42.860  1.00  0.00            N
+ATOM    840   CA LEU A  55      76.220  47.480  41.840  1.00  0.00           CA
+ATOM    855    C LEU A  55      75.520  46.280  41.220  1.00  0.00            C
+ATOM    856    O LEU A  55      76.080  45.570  40.360  1.00  0.00            O
+ATOM    857    N VAL A  56      74.350  45.880  41.640  1.00  0.00            N
+ATOM    859   CA VAL A  56      73.570  44.810  41.010  1.00  0.00           CA
+ATOM    871    C VAL A  56      72.410  45.520  40.350  1.00  0.00            C
+ATOM    872    O VAL A  56      72.210  45.500  39.130  1.00  0.00            O
+ATOM    873    N MET A  57      71.650  46.220  41.160  1.00  0.00            N
+ATOM    875   CA MET A  57      70.380  46.800  40.800  1.00  0.00           CA
+ATOM    888    C MET A  57      70.210  47.810  39.660  1.00  0.00            C
+ATOM    889    O MET A  57      69.220  47.660  38.960  1.00  0.00            O
+ATOM    890    N PRO A  58      71.020  48.820  39.420  1.00  0.00            N
+ATOM    894   CA PRO A  58      70.920  49.760  38.300  1.00  0.00           CA
+ATOM    902    C PRO A  58      71.140  49.000  37.010  1.00  0.00            C
+ATOM    903    O PRO A  58      70.660  49.400  36.000  1.00  0.00            O
+ATOM    904    N TRP A  59      71.850  47.800  37.050  1.00  0.00            N
+ATOM    906   CA TRP A  59      71.930  46.940  35.940  1.00  0.00           CA
+ATOM    926    C TRP A  59      70.780  46.130  35.830  1.00  0.00            C
+ATOM    927    O TRP A  59      70.380  45.940  34.680  1.00  0.00            O
+ATOM    928    N VAL A  60      70.170  45.610  36.940  1.00  0.00            N
+ATOM    930   CA VAL A  60      68.950  44.880  36.850  1.00  0.00           CA
+ATOM    942    C VAL A  60      67.810  45.700  36.350  1.00  0.00            C
+ATOM    943    O VAL A  60      67.070  45.330  35.440  1.00  0.00            O
+ATOM    944    N VAL A  61      67.690  46.990  36.760  1.00  0.00            N
+ATOM    946   CA VAL A  61      66.800  47.940  36.130  1.00  0.00           CA
+ATOM    958    C VAL A  61      66.890  48.100  34.690  1.00  0.00            C
+ATOM    959    O VAL A  61      65.990  47.940  33.900  1.00  0.00            O
+ATOM    960    N TYR A  62      68.100  48.360  34.120  1.00  0.00            N
+ATOM    962   CA TYR A  62      68.410  48.560  32.730  1.00  0.00           CA
+ATOM    979    C TYR A  62      67.950  47.440  31.860  1.00  0.00            C
+ATOM    980    O TYR A  62      67.310  47.650  30.840  1.00  0.00            O
+ATOM    981    N LEU A  63      68.200  46.170  32.220  1.00  0.00            N
+ATOM    983   CA LEU A  63      67.800  44.920  31.600  1.00  0.00           CA
+ATOM    998    C LEU A  63      66.250  44.780  31.590  1.00  0.00            C
+ATOM    999    O LEU A  63      65.730  44.240  30.610  1.00  0.00            O
+ATOM   1000    N GLU A  64      65.550  45.200  32.580  1.00  0.00            N
+ATOM   1002   CA GLU A  64      64.130  45.340  32.620  1.00  0.00           CA
+ATOM   1013    C GLU A  64      63.530  46.460  31.690  1.00  0.00            C
+ATOM   1014    O GLU A  64      62.560  46.160  31.000  1.00  0.00            O
+ATOM   1015    N VAL A  65      64.170  47.590  31.400  1.00  0.00            N
+ATOM   1017   CA VAL A  65      63.770  48.650  30.510  1.00  0.00           CA
+ATOM   1029    C VAL A  65      63.740  48.180  29.090  1.00  0.00            C
+ATOM   1030    O VAL A  65      62.770  48.280  28.300  1.00  0.00            O
+ATOM   1031    N VAL A  66      64.800  47.410  28.730  1.00  0.00            N
+ATOM   1033   CA VAL A  66      64.910  47.010  27.290  1.00  0.00           CA
+ATOM   1045    C VAL A  66      64.270  45.640  27.030  1.00  0.00            C
+ATOM   1046    O VAL A  66      64.070  45.260  25.870  1.00  0.00            O
+ATOM   1047    N GLY A  67      63.940  44.930  28.110  1.00  0.00            N
+ATOM   1049   CA GLY A  67      63.170  43.620  27.940  1.00  0.00           CA
+ATOM   1052    C GLY A  67      63.890  42.380  27.510  1.00  0.00            C
+ATOM   1053    O GLY A  67      63.200  41.370  27.250  1.00  0.00            O
+ATOM   1054    N GLU A  68      65.180  42.470  27.260  1.00  0.00            N
+ATOM   1056   CA GLU A  68      65.990  41.400  26.730  1.00  0.00           CA
+ATOM   1067    C GLU A  68      67.490  41.670  27.080  1.00  0.00            C
+ATOM   1068    O GLU A  68      67.790  42.800  27.410  1.00  0.00            O
+ATOM   1069    N TRP A  69      68.330  40.620  27.020  1.00  0.00            N
+ATOM   1071   CA TRP A  69      69.720  40.830  27.550  1.00  0.00           CA
+ATOM   1091    C TRP A  69      70.580  41.540  26.590  1.00  0.00            C
+ATOM   1092    O TRP A  69      70.800  40.980  25.510  1.00  0.00            O
+ATOM   1093    N LYS A  70      71.050  42.790  26.950  1.00  0.00            N
+ATOM   1095   CA LYS A  70      71.680  43.670  25.910  1.00  0.00           CA
+ATOM   1113    C LYS A  70      73.080  44.090  26.320  1.00  0.00            C
+ATOM   1114    O LYS A  70      73.620  45.110  25.780  1.00  0.00            O
+ATOM   1115    N PHE A  71      73.690  43.460  27.290  1.00  0.00            N
+ATOM   1117   CA PHE A  71      75.080  43.710  27.750  1.00  0.00           CA
+ATOM   1133    C PHE A  71      76.080  43.050  26.890  1.00  0.00            C
+ATOM   1134    O PHE A  71      75.970  41.880  26.530  1.00  0.00            O
+ATOM   1135    N SER A  72      77.200  43.790  26.730  1.00  0.00            N
+ATOM   1137   CA SER A  72      78.560  43.230  26.360  1.00  0.00           CA
+ATOM   1144    C SER A  72      79.050  42.050  27.250  1.00  0.00            C
+ATOM   1145    O SER A  72      78.440  41.680  28.280  1.00  0.00            O
+ATOM   1146    N ARG A  73      80.100  41.280  26.910  1.00  0.00            N
+ATOM   1148   CA ARG A  73      80.470  40.150  27.650  1.00  0.00           CA
+ATOM   1168    C ARG A  73      81.140  40.410  28.970  1.00  0.00            C
+ATOM   1169    O ARG A  73      81.270  39.570  29.850  1.00  0.00            O
+ATOM   1170    N ILE A  74      81.270  41.740  29.330  1.00  0.00            N
+ATOM   1172   CA ILE A  74      81.490  42.240  30.670  1.00  0.00           CA
+ATOM   1187    C ILE A  74      80.270  41.990  31.530  1.00  0.00            C
+ATOM   1188    O ILE A  74      80.180  42.260  32.740  1.00  0.00            O
+ATOM   1189    N CYS A  76      79.270  41.320  30.910  1.00  0.00            N
+ATOM   1191   CA CYS A  76      78.160  40.710  31.630  1.00  0.00           CA
+ATOM   1197    C CYS A  76      78.510  39.690  32.650  1.00  0.00            C
+ATOM   1198    O CYS A  76      77.850  39.550  33.670  1.00  0.00            O
+ATOM   1199    N ASP A  77      79.600  38.910  32.400  1.00  0.00            N
+ATOM   1201   CA ASP A  77      80.200  37.970  33.260  1.00  0.00           CA
+ATOM   1209    C ASP A  77      80.470  38.730  34.640  1.00  0.00            C
+ATOM   1210    O ASP A  77      80.130  38.240  35.710  1.00  0.00            O
+ATOM   1211    N ILE A  78      80.990  39.960  34.690  1.00  0.00            N
+ATOM   1213   CA ILE A  78      81.260  40.720  35.870  1.00  0.00           CA
+ATOM   1228    C ILE A  78      80.020  41.010  36.680  1.00  0.00            C
+ATOM   1229    O ILE A  78      80.100  40.780  37.910  1.00  0.00            O
+ATOM   1230    N PHE A  79      79.000  41.470  36.040  1.00  0.00            N
+ATOM   1232   CA PHE A  79      77.620  41.780  36.530  1.00  0.00           CA
+ATOM   1248    C PHE A  79      76.960  40.500  37.120  1.00  0.00            C
+ATOM   1249    O PHE A  79      76.500  40.610  38.210  1.00  0.00            O
+ATOM   1250    N VAL A  80      76.940  39.320  36.430  1.00  0.00            N
+ATOM   1252   CA VAL A  80      76.450  37.990  36.910  1.00  0.00           CA
+ATOM   1264    C VAL A  80      77.240  37.510  38.130  1.00  0.00            C
+ATOM   1265    O VAL A  80      76.650  37.070  39.100  1.00  0.00            O
+ATOM   1266    N THR A  81      78.550  37.720  38.130  1.00  0.00            N
+ATOM   1268   CA THR A  81      79.370  37.480  39.280  1.00  0.00           CA
+ATOM   1278    C THR A  81      79.050  38.310  40.440  1.00  0.00            C
+ATOM   1279    O THR A  81      79.030  37.910  41.620  1.00  0.00            O
+ATOM   1280    N LEU A  82      78.700  39.610  40.210  1.00  0.00            N
+ATOM   1282   CA LEU A  82      78.270  40.570  41.230  1.00  0.00           CA
+ATOM   1297    C LEU A  82      76.960  40.090  41.840  1.00  0.00            C
+ATOM   1298    O LEU A  82      76.890  39.980  43.050  1.00  0.00            O
+ATOM   1299    N ASP A  83      75.940  39.710  41.010  1.00  0.00            N
+ATOM   1301   CA ASP A  83      74.640  39.360  41.380  1.00  0.00           CA
+ATOM   1309    C ASP A  83      74.680  38.100  42.290  1.00  0.00            C
+ATOM   1310    O ASP A  83      74.190  38.140  43.450  1.00  0.00            O
+ATOM   1311    N VAL A  84      75.470  37.100  41.900  1.00  0.00            N
+ATOM   1313   CA VAL A  84      75.670  35.960  42.660  1.00  0.00           CA
+ATOM   1325    C VAL A  84      76.460  36.130  43.960  1.00  0.00            C
+ATOM   1326    O VAL A  84      76.200  35.570  45.040  1.00  0.00            O
+ATOM   1327    N MET A  85      77.530  36.940  43.920  1.00  0.00            N
+ATOM   1329   CA MET A  85      78.320  37.340  45.050  1.00  0.00           CA
+ATOM   1342    C MET A  85      77.560  38.020  46.140  1.00  0.00            C
+ATOM   1343    O MET A  85      77.600  37.530  47.260  1.00  0.00            O
+ATOM   1344    N MET A  86      76.770  39.110  45.910  1.00  0.00            N
+ATOM   1346   CA MET A  86      76.020  39.790  46.890  1.00  0.00           CA
+ATOM   1359    C MET A  86      74.820  38.900  47.350  1.00  0.00            C
+ATOM   1360    O MET A  86      74.430  38.970  48.500  1.00  0.00            O
+ATOM   1361    N CYS A  87      74.250  37.970  46.510  1.00  0.00            N
+ATOM   1363   CA CYS A  87      73.310  36.980  46.940  1.00  0.00           CA
+ATOM   1370    C CYS A  87      73.920  35.990  47.970  1.00  0.00            C
+ATOM   1371    O CYS A  87      73.400  35.700  49.030  1.00  0.00            O
+ATOM   1372    N THR A  88      75.160  35.530  47.690  1.00  0.00            N
+ATOM   1374   CA THR A  88      75.930  34.570  48.460  1.00  0.00           CA
+ATOM   1384    C THR A  88      76.250  35.180  49.840  1.00  0.00            C
+ATOM   1385    O THR A  88      76.060  34.550  50.960  1.00  0.00            O
+ATOM   1386    N ALA A  89      76.770  36.430  49.750  1.00  0.00            N
+ATOM   1388   CA ALA A  89      77.180  37.210  50.970  1.00  0.00           CA
+ATOM   1394    C ALA A  89      76.080  37.480  51.900  1.00  0.00            C
+ATOM   1395    O ALA A  89      76.340  37.590  53.130  1.00  0.00            O
+ATOM   1396    N SER A  90      74.860  37.810  51.360  1.00  0.00            N
+ATOM   1398   CA SER A  90      73.700  37.990  52.150  1.00  0.00           CA
+ATOM   1405    C SER A  90      73.250  36.700  52.960  1.00  0.00            C
+ATOM   1406    O SER A  90      73.130  36.790  54.200  1.00  0.00            O
+ATOM   1407    N ILE A  91      73.120  35.550  52.240  1.00  0.00            N
+ATOM   1409   CA ILE A  91      72.850  34.260  52.870  1.00  0.00           CA
+ATOM   1424    C ILE A  91      73.960  33.790  53.890  1.00  0.00            C
+ATOM   1425    O ILE A  91      73.630  33.320  54.960  1.00  0.00            O
+ATOM   1426    N LEU A  92      75.260  34.030  53.600  1.00  0.00            N
+ATOM   1428   CA LEU A  92      76.310  33.920  54.510  1.00  0.00           CA
+ATOM   1443    C LEU A  92      76.330  34.820  55.740  1.00  0.00            C
+ATOM   1444    O LEU A  92      76.510  34.310  56.830  1.00  0.00            O
+ATOM   1445    N ASN A  93      76.070  36.120  55.620  1.00  0.00            N
+ATOM   1447   CA ASN A  93      75.850  37.010  56.720  1.00  0.00           CA
+ATOM   1457    C ASN A  93      74.660  36.560  57.580  1.00  0.00            C
+ATOM   1458    O ASN A  93      74.760  36.570  58.790  1.00  0.00            O
+ATOM   1459    N LEU A  94      73.510  36.180  57.020  1.00  0.00            N
+ATOM   1461   CA LEU A  94      72.360  35.690  57.700  1.00  0.00           CA
+ATOM   1476    C LEU A  94      72.640  34.450  58.550  1.00  0.00            C
+ATOM   1477    O LEU A  94      72.170  34.350  59.710  1.00  0.00            O
+ATOM   1478    N CYS A  95      73.410  33.520  57.970  1.00  0.00            N
+ATOM   1480   CA CYS A  95      73.940  32.340  58.660  1.00  0.00           CA
+ATOM   1487    C CYS A  95      74.810  32.830  59.820  1.00  0.00            C
+ATOM   1488    O CYS A  95      74.630  32.450  60.970  1.00  0.00            O
+ATOM   1489    N ALA A  96      75.770  33.710  59.640  1.00  0.00            N
+ATOM   1491   CA ALA A  96      76.800  34.200  60.570  1.00  0.00           CA
+ATOM   1497    C ALA A  96      76.210  34.900  61.760  1.00  0.00            C
+ATOM   1498    O ALA A  96      76.570  34.630  62.910  1.00  0.00            O
+ATOM   1499    N ILE A  97      75.160  35.790  61.540  1.00  0.00            N
+ATOM   1501   CA ILE A  97      74.190  36.230  62.460  1.00  0.00           CA
+ATOM   1516    C ILE A  97      73.520  35.170  63.300  1.00  0.00            C
+ATOM   1517    O ILE A  97      73.570  35.160  64.550  1.00  0.00            O
+ATOM   1518    N SER A  98      73.020  34.130  62.650  1.00  0.00            N
+ATOM   1520   CA SER A  98      72.340  32.970  63.250  1.00  0.00           CA
+ATOM   1527    C SER A  98      73.280  32.220  64.190  1.00  0.00            C
+ATOM   1528    O SER A  98      73.000  31.940  65.430  1.00  0.00            O
+ATOM   1529    N ILE A  99      74.560  31.990  63.750  1.00  0.00            N
+ATOM   1531   CA ILE A  99      75.610  31.390  64.570  1.00  0.00           CA
+ATOM   1546    C ILE A  99      75.880  32.200  65.830  1.00  0.00            C
+ATOM   1547    O ILE A  99      75.890  31.590  66.940  1.00  0.00            O
+ATOM   1548    N ASP A 100      75.980  33.540  65.710  1.00  0.00            N
+ATOM   1550   CA ASP A 100      76.090  34.460  66.860  1.00  0.00           CA
+ATOM   1558    C ASP A 100      74.900  34.340  67.860  1.00  0.00            C
+ATOM   1559    O ASP A 100      75.110  34.170  69.060  1.00  0.00            O
+ATOM   1560    N ARG A 101      73.710  34.200  67.380  1.00  0.00            N
+ATOM   1562   CA ARG A 101      72.580  33.890  68.170  1.00  0.00           CA
+ATOM   1582    C ARG A 101      72.680  32.500  68.960  1.00  0.00            C
+ATOM   1583    O ARG A 101      72.560  32.470  70.180  1.00  0.00            O
+ATOM   1584    N TYR A 102      73.020  31.450  68.270  1.00  0.00            N
+ATOM   1586   CA TYR A 102      73.180  30.170  68.840  1.00  0.00           CA
+ATOM   1603    C TYR A 102      74.350  30.180  69.880  1.00  0.00            C
+ATOM   1604    O TYR A 102      74.270  29.620  70.920  1.00  0.00            O
+ATOM   1605    N THR A 103      75.460  31.020  69.600  1.00  0.00            N
+ATOM   1607   CA THR A 103      76.480  31.190  70.560  1.00  0.00           CA
+ATOM   1617    C THR A 103      76.130  31.840  71.900  1.00  0.00            C
+ATOM   1618    O THR A 103      76.430  31.260  72.930  1.00  0.00            O
+ATOM   1619    N ALA A 104      75.320  32.960  71.840  1.00  0.00            N
+ATOM   1621   CA ALA A 104      74.760  33.760  72.920  1.00  0.00           CA
+ATOM   1627    C ALA A 104      73.680  33.040  73.670  1.00  0.00            C
+ATOM   1628    O ALA A 104      73.600  33.080  74.900  1.00  0.00            O
+ATOM   1629    N VAL A 105      72.900  32.180  73.000  1.00  0.00            N
+ATOM   1631   CA VAL A 105      71.940  31.240  73.540  1.00  0.00           CA
+ATOM   1643    C VAL A 105      72.680  30.160  74.340  1.00  0.00            C
+ATOM   1644    O VAL A 105      72.290  29.770  75.410  1.00  0.00            O
+ATOM   1645    N ALA A 106      73.860  29.660  73.830  1.00  0.00            N
+ATOM   1647   CA ALA A 106      74.650  28.560  74.370  1.00  0.00           CA
+ATOM   1653    C ALA A 106      75.280  28.830  75.730  1.00  0.00            C
+ATOM   1654    O ALA A 106      75.250  28.000  76.640  1.00  0.00            O
+ATOM   1655    N MET A 107      75.770  30.060  75.960  1.00  0.00            N
+ATOM   1657   CA MET A 107      76.370  30.580  77.170  1.00  0.00           CA
+ATOM   1670    C MET A 107      76.040  32.050  77.480  1.00  0.00            C
+ATOM   1671    O MET A 107      76.080  32.840  76.510  1.00  0.00            O
+ATOM   1672    N PRO A 108      75.660  32.410  78.660  1.00  0.00            N
+ATOM   1676   CA PRO A 108      75.580  33.760  79.100  1.00  0.00           CA
+ATOM   1684    C PRO A 108      76.980  34.470  78.940  1.00  0.00            C
+ATOM   1685    O PRO A 108      78.060  33.830  78.820  1.00  0.00            O
+ATOM   1686    N MET A 109      77.030  35.840  78.860  1.00  0.00            N
+ATOM   1688   CA MET A 109      78.230  36.570  78.520  1.00  0.00           CA
+ATOM   1701    C MET A 109      79.100  36.720  79.740  1.00  0.00            C
+ATOM   1702    O MET A 109      78.740  37.130  80.840  1.00  0.00            O
+ATOM   1703    N LEU A 110      80.400  36.450  79.570  1.00  0.00            N
+ATOM   1705   CA LEU A 110      81.280  36.410  80.680  1.00  0.00           CA
+ATOM   1720    C LEU A 110      82.490  37.380  80.390  1.00  0.00            C
+ATOM   1721    O LEU A 110      82.470  37.950  79.310  1.00  0.00            O
+ATOM   1722    N TYR A 111      83.510  37.550  81.290  1.00  0.00            N
+ATOM   1724   CA TYR A 111      84.700  38.380  81.190  1.00  0.00           CA
+ATOM   1741    C TYR A 111      85.580  38.110  79.980  1.00  0.00            C
+ATOM   1742    O TYR A 111      86.030  39.020  79.280  1.00  0.00            O
+ATOM   1743    N ASN A 112      85.870  36.800  79.660  1.00  0.00            N
+ATOM   1745   CA ASN A 112      86.670  36.340  78.530  1.00  0.00           CA
+ATOM   1755    C ASN A 112      85.850  36.660  77.270  1.00  0.00            C
+ATOM   1756    O ASN A 112      86.480  36.980  76.310  1.00  0.00            O
+ATOM   1757    N THR A 113      84.520  36.540  77.260  1.00  0.00            N
+ATOM   1759   CA THR A 113      83.660  36.840  76.090  1.00  0.00           CA
+ATOM   1769    C THR A 113      83.740  38.240  75.560  1.00  0.00            C
+ATOM   1770    O THR A 113      83.870  38.490  74.370  1.00  0.00            O
+ATOM   1771    N ARG A 114      83.720  39.230  76.460  1.00  0.00            N
+ATOM   1773   CA ARG A 114      83.880  40.630  76.230  1.00  0.00           CA
+ATOM   1793    C ARG A 114      85.380  41.020  75.860  1.00  0.00            C
+ATOM   1794    O ARG A 114      85.610  42.080  75.320  1.00  0.00            O
+ATOM   1795    N TYR A 115      86.400  40.230  76.130  1.00  0.00            N
+ATOM   1797   CA TYR A 115      87.720  40.530  75.670  1.00  0.00           CA
+ATOM   1814    C TYR A 115      88.010  39.790  74.350  1.00  0.00            C
+ATOM   1815    O TYR A 115      89.170  39.530  73.900  1.00  0.00            O
+ATOM   1816    N SER A 116      86.970  39.190  73.760  1.00  0.00            N
+ATOM   1818   CA SER A 116      87.190  38.280  72.670  1.00  0.00           CA
+ATOM   1825    C SER A 116      86.090  38.450  71.700  1.00  0.00            C
+ATOM   1826    O SER A 116      86.240  37.960  70.570  1.00  0.00            O
+ATOM   1827    N SER A 117      85.030  39.220  72.020  1.00  0.00            N
+ATOM   1829   CA SER A 117      83.760  39.280  71.270  1.00  0.00           CA
+ATOM   1836    C SER A 117      83.980  39.870  69.920  1.00  0.00            C
+ATOM   1837    O SER A 117      83.480  39.420  68.930  1.00  0.00            O
+ATOM   1838    N LYS A 118      84.670  40.990  69.870  1.00  0.00            N
+ATOM   1840   CA LYS A 118      84.840  41.650  68.570  1.00  0.00           CA
+ATOM   1858    C LYS A 118      86.010  40.980  67.810  1.00  0.00            C
+ATOM   1859    O LYS A 118      86.050  41.000  66.580  1.00  0.00            O
+ATOM   1860    N ARG A 119      86.870  40.180  68.570  1.00  0.00            N
+ATOM   1862   CA ARG A 119      87.890  39.370  68.050  1.00  0.00           CA
+ATOM   1882    C ARG A 119      87.370  38.220  67.220  1.00  0.00            C
+ATOM   1883    O ARG A 119      87.810  37.940  66.050  1.00  0.00            O
+ATOM   1884    N ARG A 120      86.330  37.610  67.730  1.00  0.00            N
+ATOM   1886   CA ARG A 120      85.510  36.650  67.050  1.00  0.00           CA
+ATOM   1906    C ARG A 120      84.820  37.280  65.880  1.00  0.00            C
+ATOM   1907    O ARG A 120      84.860  36.690  64.800  1.00  0.00            O
+ATOM   1908    N VAL A 121      84.110  38.430  66.080  1.00  0.00            N
+ATOM   1910   CA VAL A 121      83.230  39.000  65.100  1.00  0.00           CA
+ATOM   1922    C VAL A 121      83.980  39.400  63.850  1.00  0.00            C
+ATOM   1923    O VAL A 121      83.500  39.080  62.760  1.00  0.00            O
+ATOM   1924    N THR A 122      85.130  40.120  64.010  1.00  0.00            N
+ATOM   1926   CA THR A 122      85.890  40.410  62.790  1.00  0.00           CA
+ATOM   1936    C THR A 122      86.390  39.220  61.910  1.00  0.00            C
+ATOM   1937    O THR A 122      86.410  39.250  60.680  1.00  0.00            O
+ATOM   1938    N VAL A 123      86.840  38.110  62.610  1.00  0.00            N
+ATOM   1940   CA VAL A 123      87.130  36.870  61.940  1.00  0.00           CA
+ATOM   1952    C VAL A 123      85.940  36.230  61.180  1.00  0.00            C
+ATOM   1953    O VAL A 123      86.040  35.830  59.970  1.00  0.00            O
+ATOM   1954    N MET A 124      84.730  36.230  61.770  1.00  0.00            N
+ATOM   1956   CA MET A 124      83.560  35.770  61.050  1.00  0.00           CA
+ATOM   1969    C MET A 124      83.220  36.490  59.830  1.00  0.00            C
+ATOM   1970    O MET A 124      82.750  35.890  58.870  1.00  0.00            O
+ATOM   1971    N ILE A 125      83.320  37.820  59.870  1.00  0.00            N
+ATOM   1973   CA ILE A 125      82.970  38.820  58.810  1.00  0.00           CA
+ATOM   1988    C ILE A 125      83.970  38.630  57.570  1.00  0.00            C
+ATOM   1989    O ILE A 125      83.630  38.570  56.430  1.00  0.00            O
+ATOM   1990    N SER A 126      85.240  38.530  57.920  1.00  0.00            N
+ATOM   1992   CA SER A 126      86.360  38.190  57.030  1.00  0.00           CA
+ATOM   1999    C SER A 126      86.120  36.840  56.360  1.00  0.00            C
+ATOM   2000    O SER A 126      86.220  36.740  55.160  1.00  0.00            O
+ATOM   2001    N ILE A 127      85.730  35.800  57.200  1.00  0.00            N
+ATOM   2003   CA ILE A 127      85.340  34.470  56.620  1.00  0.00           CA
+ATOM   2018    C ILE A 127      84.100  34.540  55.720  1.00  0.00            C
+ATOM   2019    O ILE A 127      84.240  33.890  54.650  1.00  0.00            O
+ATOM   2020    N VAL A 128      83.090  35.330  56.040  1.00  0.00            N
+ATOM   2022   CA VAL A 128      81.940  35.630  55.140  1.00  0.00           CA
+ATOM   2034    C VAL A 128      82.310  36.220  53.760  1.00  0.00            C
+ATOM   2035    O VAL A 128      82.030  35.680  52.740  1.00  0.00            O
+ATOM   2036    N TRP A 129      83.110  37.340  53.750  1.00  0.00            N
+ATOM   2038   CA TRP A 129      83.580  37.920  52.470  1.00  0.00           CA
+ATOM   2058    C TRP A 129      84.470  37.070  51.580  1.00  0.00            C
+ATOM   2059    O TRP A 129      84.280  37.060  50.360  1.00  0.00            O
+ATOM   2060    N VAL A 130      85.430  36.300  52.250  1.00  0.00            N
+ATOM   2062   CA VAL A 130      86.340  35.360  51.590  1.00  0.00           CA
+ATOM   2074    C VAL A 130      85.510  34.170  51.010  1.00  0.00            C
+ATOM   2075    O VAL A 130      85.750  33.740  49.860  1.00  0.00            O
+ATOM   2076    N LEU A 131      84.590  33.620  51.840  1.00  0.00            N
+ATOM   2078   CA LEU A 131      83.720  32.520  51.470  1.00  0.00           CA
+ATOM   2093    C LEU A 131      82.810  32.910  50.360  1.00  0.00            C
+ATOM   2094    O LEU A 131      82.790  32.280  49.300  1.00  0.00            O
+ATOM   2095    N SER A 132      82.190  34.090  50.420  1.00  0.00            N
+ATOM   2097   CA SER A 132      81.530  34.630  49.250  1.00  0.00           CA
+ATOM   2104    C SER A 132      82.480  34.850  48.020  1.00  0.00            C
+ATOM   2105    O SER A 132      82.030  34.520  46.920  1.00  0.00            O
+ATOM   2106    N PHE A 133      83.640  35.390  48.140  1.00  0.00            N
+ATOM   2108   CA PHE A 133      84.620  35.430  47.010  1.00  0.00           CA
+ATOM   2124    C PHE A 133      84.870  34.010  46.410  1.00  0.00            C
+ATOM   2125    O PHE A 133      84.620  33.850  45.240  1.00  0.00            O
+ATOM   2126    N THR A 134      85.350  32.980  47.180  1.00  0.00            N
+ATOM   2128   CA THR A 134      85.650  31.670  46.640  1.00  0.00           CA
+ATOM   2138    C THR A 134      84.500  30.980  45.910  1.00  0.00            C
+ATOM   2139    O THR A 134      84.600  30.340  44.870  1.00  0.00            O
+ATOM   2140    N ILE A 135      83.260  31.100  46.490  1.00  0.00            N
+ATOM   2142   CA ILE A 135      82.030  30.620  45.790  1.00  0.00           CA
+ATOM   2157    C ILE A 135      81.780  31.420  44.500  1.00  0.00            C
+ATOM   2158    O ILE A 135      81.410  30.810  43.470  1.00  0.00            O
+ATOM   2159    N SER A 136      81.960  32.740  44.380  1.00  0.00            N
+ATOM   2161   CA SER A 136      81.640  33.540  43.120  1.00  0.00           CA
+ATOM   2168    C SER A 136      82.850  33.500  42.170  1.00  0.00            C
+ATOM   2169    O SER A 136      82.570  33.570  40.970  1.00  0.00            O
+ATOM   2170    N CYS A 137      84.090  33.360  42.610  1.00  0.00            N
+ATOM   2172   CA CYS A 137      85.220  33.350  41.730  1.00  0.00           CA
+ATOM   2179    C CYS A 137      85.130  32.410  40.540  1.00  0.00            C
+ATOM   2180    O CYS A 137      85.520  32.850  39.470  1.00  0.00            O
+ATOM   2181    N PRO A 138      84.550  31.200  40.490  1.00  0.00            N
+ATOM   2185   CA PRO A 138      84.280  30.410  39.320  1.00  0.00           CA
+ATOM   2193    C PRO A 138      83.570  31.130  38.140  1.00  0.00            C
+ATOM   2194    O PRO A 138      83.900  30.980  36.990  1.00  0.00            O
+ATOM   2195    N LEU A 139      82.570  32.060  38.460  1.00  0.00            N
+ATOM   2197   CA LEU A 139      81.810  32.660  37.350  1.00  0.00           CA
+ATOM   2212    C LEU A 139      82.590  33.550  36.300  1.00  0.00            C
+ATOM   2213    O LEU A 139      82.590  33.350  35.080  1.00  0.00            O
+ATOM   2214    N LEU A 140      83.430  34.450  36.860  1.00  0.00            N
+ATOM   2216   CA LEU A 140      84.310  35.250  35.970  1.00  0.00           CA
+ATOM   2231    C LEU A 140      85.290  34.490  35.150  1.00  0.00            C
+ATOM   2232    O LEU A 140      85.510  34.870  34.060  1.00  0.00            O
+ATOM   2233    N PHE A 141      85.790  33.360  35.630  1.00  0.00            N
+ATOM   2235   CA PHE A 141      86.800  32.530  34.980  1.00  0.00           CA
+ATOM   2251    C PHE A 141      86.270  31.430  34.100  1.00  0.00            C
+ATOM   2252    O PHE A 141      86.990  30.620  33.620  1.00  0.00            O
+ATOM   2253    N GLY A 142      84.910  31.380  33.980  1.00  0.00            N
+ATOM   2255   CA GLY A 142      84.260  30.450  33.110  1.00  0.00           CA
+ATOM   2258    C GLY A 142      83.530  29.320  33.670  1.00  0.00            C
+ATOM   2259    O GLY A 142      83.020  28.520  32.930  1.00  0.00            O
+ATOM   2260    N LEU A 143      83.480  29.180  35.010  1.00  0.00            N
+ATOM   2262   CA LEU A 143      82.670  28.190  35.760  1.00  0.00           CA
+ATOM   2277    C LEU A 143      83.320  26.850  35.600  1.00  0.00            C
+ATOM   2278    O LEU A 143      82.720  25.790  35.570  1.00  0.00            O
+ATOM   2279    N ASN A 144      84.640  26.810  35.460  1.00  0.00            N
+ATOM   2281   CA ASN A 144      85.500  25.600  35.250  1.00  0.00           CA
+ATOM   2291    C ASN A 144      85.160  24.720  34.080  1.00  0.00            C
+ATOM   2292    O ASN A 144      85.130  23.500  34.090  1.00  0.00            O
+ATOM   2293    N ASN A 145      84.530  25.310  33.080  1.00  0.00            N
+ATOM   2295   CA ASN A 145      84.010  24.460  31.990  1.00  0.00           CA
+ATOM   2305    C ASN A 145      84.190  25.220  30.710  1.00  0.00            C
+ATOM   2306    O ASN A 145      85.090  26.040  30.540  1.00  0.00            O
+ATOM   2307    N ALA A 146      83.390  24.900  29.720  1.00  0.00            N
+ATOM   2309   CA ALA A 146      83.380  25.630  28.470  1.00  0.00           CA
+ATOM   2315    C ALA A 146      82.600  26.920  28.620  1.00  0.00            C
+ATOM   2316    O ALA A 146      81.390  26.980  28.770  1.00  0.00            O
+ATOM   2317    N ASP A 147      83.350  28.040  28.600  1.00  0.00            N
+ATOM   2319   CA ASP A 147      82.690  29.320  28.960  1.00  0.00           CA
+ATOM   2327    C ASP A 147      81.950  29.980  27.910  1.00  0.00            C
+ATOM   2328    O ASP A 147      81.170  30.880  28.110  1.00  0.00            O
+ATOM   2329    N GLN A 148      81.950  29.360  26.690  1.00  0.00            N
+ATOM   2331   CA GLN A 148      81.020  29.650  25.640  1.00  0.00           CA
+ATOM   2344    C GLN A 148      81.150  31.010  25.020  1.00  0.00            C
+ATOM   2345    O GLN A 148      81.920  31.810  25.510  1.00  0.00            O
+ATOM   2346    N ASN A 149      80.500  31.340  23.900  1.00  0.00            N
+ATOM   2348   CA ASN A 149      80.530  32.620  23.400  1.00  0.00           CA
+ATOM   2358    C ASN A 149      79.310  33.340  23.830  1.00  0.00            C
+ATOM   2359    O ASN A 149      78.570  33.990  23.040  1.00  0.00            O
+ATOM   2360    N GLU A 150      78.940  33.170  25.150  1.00  0.00            N
+ATOM   2362   CA GLU A 150      77.810  33.730  25.760  1.00  0.00           CA
+ATOM   2373    C GLU A 150      78.030  33.960  27.290  1.00  0.00            C
+ATOM   2374    O GLU A 150      78.660  33.150  27.980  1.00  0.00            O
+ATOM   2375    N CYS A 151      77.470  35.100  27.820  1.00  0.00            N
+ATOM   2377   CA CYS A 151      77.530  35.510  29.230  1.00  0.00           CA
+ATOM   2383    C CYS A 151      77.040  34.420  30.150  1.00  0.00            C
+ATOM   2384    O CYS A 151      76.030  33.710  29.950  1.00  0.00            O
+ATOM   2385    N ILE A 152      77.890  34.200  31.230  1.00  0.00            N
+ATOM   2387   CA ILE A 152      77.860  33.160  32.190  1.00  0.00           CA
+ATOM   2402    C ILE A 152      76.600  32.810  33.040  1.00  0.00            C
+ATOM   2403    O ILE A 152      76.450  31.770  33.640  1.00  0.00            O
+ATOM   2404    N ILE A 153      75.520  33.530  32.800  1.00  0.00            N
+ATOM   2406   CA ILE A 153      74.190  33.130  33.200  1.00  0.00           CA
+ATOM   2421    C ILE A 153      73.540  32.130  32.290  1.00  0.00            C
+ATOM   2422    O ILE A 153      72.600  31.430  32.710  1.00  0.00            O
+ATOM   2423    N ALA A 154      74.090  31.920  31.020  1.00  0.00            N
+ATOM   2425   CA ALA A 154      73.640  31.050  30.000  1.00  0.00           CA
+ATOM   2431    C ALA A 154      74.400  29.740  29.890  1.00  0.00            C
+ATOM   2432    O ALA A 154      74.320  28.860  29.020  1.00  0.00            O
+ATOM   2433    N ASN A 155      75.300  29.610  30.870  1.00  0.00            N
+ATOM   2435   CA ASN A 155      76.170  28.390  31.040  1.00  0.00           CA
+ATOM   2445    C ASN A 155      75.470  27.200  31.710  1.00  0.00            C
+ATOM   2446    O ASN A 155      74.820  27.500  32.710  1.00  0.00            O
+ATOM   2447    N PRO A 156      75.560  25.980  31.270  1.00  0.00            N
+ATOM   2451   CA PRO A 156      74.720  24.870  31.660  1.00  0.00           CA
+ATOM   2459    C PRO A 156      75.220  24.220  32.960  1.00  0.00            C
+ATOM   2460    O PRO A 156      74.800  23.150  33.190  1.00  0.00            O
+ATOM   2461    N ALA A 157      76.060  24.910  33.730  1.00  0.00            N
+ATOM   2463   CA ALA A 157      76.360  24.610  35.140  1.00  0.00           CA
+ATOM   2469    C ALA A 157      76.000  25.790  36.000  1.00  0.00            C
+ATOM   2470    O ALA A 157      76.180  25.680  37.240  1.00  0.00            O
+ATOM   2471    N PHE A 158      75.450  26.880  35.410  1.00  0.00            N
+ATOM   2473   CA PHE A 158      74.980  28.030  36.150  1.00  0.00           CA
+ATOM   2489    C PHE A 158      74.020  27.890  37.220  1.00  0.00            C
+ATOM   2490    O PHE A 158      74.400  28.100  38.350  1.00  0.00            O
+ATOM   2491    N VAL A 159      72.740  27.450  36.890  1.00  0.00            N
+ATOM   2493   CA VAL A 159      71.720  27.280  37.840  1.00  0.00           CA
+ATOM   2505    C VAL A 159      72.000  26.260  38.930  1.00  0.00            C
+ATOM   2506    O VAL A 159      71.740  26.550  40.090  1.00  0.00            O
+ATOM   2507    N VAL A 160      72.670  25.170  38.600  1.00  0.00            N
+ATOM   2509   CA VAL A 160      72.850  24.100  39.640  1.00  0.00           CA
+ATOM   2521    C VAL A 160      73.950  24.410  40.580  1.00  0.00            C
+ATOM   2522    O VAL A 160      73.880  24.230  41.820  1.00  0.00            O
+ATOM   2523    N TYR A 161      75.070  24.990  40.080  1.00  0.00            N
+ATOM   2525   CA TYR A 161      76.140  25.460  40.870  1.00  0.00           CA
+ATOM   2542    C TYR A 161      75.590  26.530  41.840  1.00  0.00            C
+ATOM   2543    O TYR A 161      75.890  26.440  43.020  1.00  0.00            O
+ATOM   2544    N SER A 162      74.820  27.530  41.370  1.00  0.00            N
+ATOM   2546   CA SER A 162      74.160  28.560  42.180  1.00  0.00           CA
+ATOM   2553    C SER A 162      73.160  28.010  43.150  1.00  0.00            C
+ATOM   2554    O SER A 162      73.310  28.250  44.360  1.00  0.00            O
+ATOM   2555    N SER A 163      72.250  27.060  42.820  1.00  0.00            N
+ATOM   2557   CA SER A 163      71.240  26.440  43.680  1.00  0.00           CA
+ATOM   2564    C SER A 163      71.860  25.640  44.860  1.00  0.00            C
+ATOM   2565    O SER A 163      71.440  25.710  45.990  1.00  0.00            O
+ATOM   2566    N ILE A 164      72.960  24.970  44.590  1.00  0.00            N
+ATOM   2568   CA ILE A 164      73.690  24.140  45.550  1.00  0.00           CA
+ATOM   2583    C ILE A 164      74.640  24.910  46.420  1.00  0.00            C
+ATOM   2584    O ILE A 164      74.460  24.910  47.640  1.00  0.00            O
+ATOM   2585    N VAL A 165      75.680  25.570  45.820  1.00  0.00            N
+ATOM   2587   CA VAL A 165      76.740  26.090  46.580  1.00  0.00           CA
+ATOM   2599    C VAL A 165      76.360  27.470  47.140  1.00  0.00            C
+ATOM   2600    O VAL A 165      76.710  27.700  48.260  1.00  0.00            O
+ATOM   2601    N SER A 166      75.600  28.350  46.500  1.00  0.00            N
+ATOM   2603   CA SER A 166      75.210  29.740  46.940  1.00  0.00           CA
+ATOM   2610    C SER A 166      73.830  29.900  47.500  1.00  0.00            C
+ATOM   2611    O SER A 166      73.340  30.970  47.920  1.00  0.00            O
+ATOM   2612    N PHE A 167      73.180  28.750  47.780  1.00  0.00            N
+ATOM   2614   CA PHE A 167      71.920  28.720  48.430  1.00  0.00           CA
+ATOM   2630    C PHE A 167      71.870  27.580  49.260  1.00  0.00            C
+ATOM   2631    O PHE A 167      71.920  27.660  50.460  1.00  0.00            O
+ATOM   2632    N TYR A 168      71.570  26.400  48.780  1.00  0.00            N
+ATOM   2634   CA TYR A 168      71.310  25.220  49.580  1.00  0.00           CA
+ATOM   2651    C TYR A 168      72.330  24.820  50.660  1.00  0.00            C
+ATOM   2652    O TYR A 168      71.940  24.390  51.810  1.00  0.00            O
+ATOM   2653    N VAL A 169      73.690  24.970  50.390  1.00  0.00            N
+ATOM   2655   CA VAL A 169      74.800  24.610  51.260  1.00  0.00           CA
+ATOM   2667    C VAL A 169      74.820  25.470  52.540  1.00  0.00            C
+ATOM   2668    O VAL A 169      74.770  24.850  53.630  1.00  0.00            O
+ATOM   2669    N PRO A 170      74.660  26.820  52.480  1.00  0.00            N
+ATOM   2673   CA PRO A 170      74.350  27.640  53.640  1.00  0.00           CA
+ATOM   2681    C PRO A 170      72.890  27.640  54.040  1.00  0.00            C
+ATOM   2682    O PRO A 170      72.660  27.740  55.280  1.00  0.00            O
+ATOM   2683    N PHE A 171      71.870  27.590  53.170  1.00  0.00            N
+ATOM   2685   CA PHE A 171      70.430  27.610  53.600  1.00  0.00           CA
+ATOM   2701    C PHE A 171      70.130  26.450  54.600  1.00  0.00            C
+ATOM   2702    O PHE A 171      69.730  26.630  55.740  1.00  0.00            O
+ATOM   2703    N ILE A 172      70.680  25.250  54.340  1.00  0.00            N
+ATOM   2705   CA ILE A 172      70.510  24.110  55.170  1.00  0.00           CA
+ATOM   2720    C ILE A 172      71.150  24.190  56.500  1.00  0.00            C
+ATOM   2721    O ILE A 172      70.530  23.980  57.550  1.00  0.00            O
+ATOM   2722    N VAL A 173      72.420  24.650  56.600  1.00  0.00            N
+ATOM   2724   CA VAL A 173      73.240  24.910  57.810  1.00  0.00           CA
+ATOM   2736    C VAL A 173      72.590  26.020  58.660  1.00  0.00            C
+ATOM   2737    O VAL A 173      72.530  25.950  59.860  1.00  0.00            O
+ATOM   2738    N THR A 174      72.160  27.080  58.010  1.00  0.00            N
+ATOM   2740   CA THR A 174      71.400  28.120  58.760  1.00  0.00           CA
+ATOM   2750    C THR A 174      70.160  27.540  59.320  1.00  0.00            C
+ATOM   2751    O THR A 174      69.850  27.830  60.440  1.00  0.00            O
+ATOM   2752    N LEU A 175      69.380  26.740  58.630  1.00  0.00            N
+ATOM   2754   CA LEU A 175      68.310  26.040  59.260  1.00  0.00           CA
+ATOM   2769    C LEU A 175      68.590  25.170  60.500  1.00  0.00            C
+ATOM   2770    O LEU A 175      68.010  25.340  61.550  1.00  0.00            O
+ATOM   2771    N LEU A 176      69.630  24.290  60.370  1.00  0.00            N
+ATOM   2773   CA LEU A 176      70.100  23.410  61.390  1.00  0.00           CA
+ATOM   2788    C LEU A 176      70.540  24.160  62.620  1.00  0.00            C
+ATOM   2789    O LEU A 176      70.230  23.790  63.760  1.00  0.00            O
+ATOM   2790    N VAL A 177      71.220  25.300  62.570  1.00  0.00            N
+ATOM   2792   CA VAL A 177      71.600  26.200  63.630  1.00  0.00           CA
+ATOM   2804    C VAL A 177      70.360  26.700  64.420  1.00  0.00            C
+ATOM   2805    O VAL A 177      70.210  26.520  65.660  1.00  0.00            O
+ATOM   2806    N TYR A 178      69.350  27.220  63.720  1.00  0.00            N
+ATOM   2808   CA TYR A 178      68.100  27.670  64.190  1.00  0.00           CA
+ATOM   2825    C TYR A 178      67.270  26.610  64.840  1.00  0.00            C
+ATOM   2826    O TYR A 178      66.640  26.880  65.870  1.00  0.00            O
+ATOM   2827    N ILE A 179      67.240  25.360  64.330  1.00  0.00            N
+ATOM   2829   CA ILE A 179      66.660  24.270  65.070  1.00  0.00           CA
+ATOM   2844    C ILE A 179      67.330  24.080  66.470  1.00  0.00            C
+ATOM   2845    O ILE A 179      66.670  23.850  67.520  1.00  0.00            O
+ATOM   2846    N LYS A 180      68.680  24.080  66.480  1.00  0.00            N
+ATOM   2848   CA LYS A 180      69.480  23.970  67.710  1.00  0.00           CA
+ATOM   2866    C LYS A 180      69.180  25.100  68.720  1.00  0.00            C
+ATOM   2867    O LYS A 180      68.990  24.820  69.920  1.00  0.00            O
+ATOM   2868    N ILE A 181      69.030  26.400  68.240  1.00  0.00            N
+ATOM   2870   CA ILE A 181      68.640  27.530  69.020  1.00  0.00           CA
+ATOM   2885    C ILE A 181      67.320  27.310  69.790  1.00  0.00            C
+ATOM   2886    O ILE A 181      67.180  27.570  70.980  1.00  0.00            O
+ATOM   2887    N TYR A 182      66.350  26.640  69.170  1.00  0.00            N
+ATOM   2889   CA TYR A 182      65.130  26.210  69.900  1.00  0.00           CA
+ATOM   2906    C TYR A 182      65.190  25.190  70.990  1.00  0.00            C
+ATOM   2907    O TYR A 182      64.680  25.440  72.110  1.00  0.00            O
+ATOM   2908    N ILE A 183      65.960  24.060  70.740  1.00  0.00            N
+ATOM   2910   CA ILE A 183      66.250  22.930  71.650  1.00  0.00           CA
+ATOM   2925    C ILE A 183      66.940  23.430  72.900  1.00  0.00            C
+ATOM   2926    O ILE A 183      66.620  22.960  73.990  1.00  0.00            O
+ATOM   2927    N VAL A 184      67.890  24.390  72.750  1.00  0.00            N
+ATOM   2929   CA VAL A 184      68.500  24.990  73.980  1.00  0.00           CA
+ATOM   2941    C VAL A 184      67.570  25.810  74.840  1.00  0.00            C
+ATOM   2942    O VAL A 184      67.360  25.630  76.060  1.00  0.00            O
+ATOM   2943    N LEU A 185      66.900  26.810  74.200  1.00  0.00            N
+ATOM   2945   CA LEU A 185      66.030  27.670  74.950  1.00  0.00           CA
+ATOM   2960    C LEU A 185      64.770  26.890  75.530  1.00  0.00            C
+ATOM   2961    O LEU A 185      64.330  27.170  76.670  1.00  0.00            O
+ATOM   2962    N ARG A 186      64.170  25.890  74.780  1.00  0.00            N
+ATOM   2964   CA ARG A 186      63.110  25.040  75.420  1.00  0.00           CA
+ATOM   2984    C ARG A 186      63.560  24.280  76.640  1.00  0.00            C
+ATOM   2985    O ARG A 186      62.810  24.040  77.540  1.00  0.00            O
+ATOM   2986    N ARG A 187      64.840  23.790  76.680  1.00  0.00            N
+ATOM   2988   CA ARG A 187      65.380  23.060  77.870  1.00  0.00           CA
+ATOM   3008    C ARG A 187      65.750  23.960  79.100  1.00  0.00            C
+ATOM   3009    O ARG A 187      65.510  23.600  80.230  1.00  0.00            O
+ATOM   3010    N ARG A 188      66.300  25.190  78.800  1.00  0.00            N
+ATOM   3012   CA ARG A 188      66.410  26.130  79.860  1.00  0.00           CA
+ATOM   3032    C ARG A 188      65.080  26.530  80.380  1.00  0.00            C
+ATOM   3033    O ARG A 188      64.830  26.600  81.560  1.00  0.00            O
+ATOM   3034    N ARG A 189      64.100  26.850  79.490  1.00  0.00            N
+ATOM   3036   CA ARG A 189      62.730  27.200  79.890  1.00  0.00           CA
+ATOM   3056    C ARG A 189      61.960  26.130  80.680  1.00  0.00            C
+ATOM   3057    O ARG A 189      61.300  26.440  81.700  1.00  0.00            O
+ATOM   3058    N LYS A 190      61.990  24.830  80.210  1.00  0.00            N
+ATOM   3060   CA LYS A 190      61.450  23.690  80.930  1.00  0.00           CA
+ATOM   3078    C LYS A 190      61.970  23.590  82.390  1.00  0.00            C
+ATOM   3079    O LYS A 190      61.220  23.360  83.340  1.00  0.00            O
+ATOM   3080    N ARG A 191      63.260  23.770  82.590  1.00  0.00            N
+ATOM   3082   CA ARG A 191      63.920  23.880  83.900  1.00  0.00           CA
+ATOM   3102    C ARG A 191      63.600  25.140  84.710  1.00  0.00            C
+ATOM   3103    O ARG A 191      63.350  25.200  85.900  1.00  0.00            O
+ATOM   3104    N VAL A 192      63.600  26.400  84.090  1.00  0.00            N
+ATOM   3106   CA VAL A 192      63.420  27.650  84.770  1.00  0.00           CA
+ATOM   3118    C VAL A 192      62.080  27.780  85.530  1.00  0.00            C
+ATOM   3119    O VAL A 192      62.000  28.270  86.620  1.00  0.00            O
+ATOM   3120    N ASN A 193      60.970  27.320  84.870  1.00  0.00            N
+ATOM   3122   CA ASN A 193      59.630  27.450  85.320  1.00  0.00           CA
+ATOM   3132    C ASN A 193      59.140  28.880  85.660  1.00  0.00            C
+ATOM   3133    O ASN A 193      58.430  29.030  86.660  1.00  0.00            O
+ATOM   3134    N THR A 194      59.580  29.940  84.970  1.00  0.00            N
+ATOM   3136   CA THR A 194      59.140  31.330  85.200  1.00  0.00           CA
+ATOM   3146    C THR A 194      59.470  32.190  84.040  1.00  0.00            C
+ATOM   3147    O THR A 194      60.500  32.030  83.440  1.00  0.00            O
+ATOM   3148    N LYS A 195      58.650  33.210  83.780  1.00  0.00            N
+ATOM   3150   CA LYS A 195      58.800  34.150  82.770  1.00  0.00           CA
+ATOM   3168    C LYS A 195      59.610  35.390  83.130  1.00  0.00            C
+ATOM   3169    O LYS A 195      59.790  36.340  82.400  1.00  0.00            O
+ATOM   3170    N ARG A 196      60.170  35.450  84.380  1.00  0.00            N
+ATOM   3172   CA ARG A 196      60.770  36.640  84.940  1.00  0.00           CA
+ATOM   3192    C ARG A 196      62.330  36.670  84.840  1.00  0.00            C
+ATOM   3193    O ARG A 196      63.020  37.410  85.560  1.00  0.00            O
+ATOM   3194    N LYS A 197      62.950  35.750  83.990  1.00  0.00            N
+ATOM   3196   CA LYS A 197      64.380  35.820  83.690  1.00  0.00           CA
+ATOM   3214    C LYS A 197      64.690  36.780  82.570  1.00  0.00            C
+ATOM   3215    O LYS A 197      65.020  36.420  81.390  1.00  0.00            O
+ATOM   3216    N LEU A 198      64.700  38.030  82.950  1.00  0.00            N
+ATOM   3218   CA LEU A 198      64.550  39.260  82.180  1.00  0.00           CA
+ATOM   3233    C LEU A 198      65.630  39.370  81.070  1.00  0.00            C
+ATOM   3234    O LEU A 198      65.410  39.810  79.940  1.00  0.00            O
+ATOM   3235    N SER A 199      66.870  38.940  81.420  1.00  0.00            N
+ATOM   3237   CA SER A 199      68.030  38.900  80.490  1.00  0.00           CA
+ATOM   3244    C SER A 199      67.720  37.930  79.360  1.00  0.00            C
+ATOM   3245    O SER A 199      67.960  38.170  78.190  1.00  0.00            O
+ATOM   3246    N GLN A 200      67.240  36.740  79.760  1.00  0.00            N
+ATOM   3248   CA GLN A 200      66.840  35.680  78.850  1.00  0.00           CA
+ATOM   3261    C GLN A 200      65.690  36.100  78.060  1.00  0.00            C
+ATOM   3262    O GLN A 200      65.690  36.000  76.850  1.00  0.00            O
+ATOM   3263    N GLN A 201      64.660  36.730  78.670  1.00  0.00            N
+ATOM   3265   CA GLN A 201      63.640  37.420  77.910  1.00  0.00           CA
+ATOM   3278    C GLN A 201      64.180  38.300  76.870  1.00  0.00            C
+ATOM   3279    O GLN A 201      63.660  38.130  75.720  1.00  0.00            O
+ATOM   3280    N LYS A 202      65.090  39.290  77.210  1.00  0.00            N
+ATOM   3282   CA LYS A 202      65.640  40.200  76.190  1.00  0.00           CA
+ATOM   3300    C LYS A 202      66.440  39.500  75.050  1.00  0.00            C
+ATOM   3301    O LYS A 202      66.320  39.870  73.890  1.00  0.00            O
+ATOM   3302    N GLU A 203      67.180  38.440  75.380  1.00  0.00            N
+ATOM   3304   CA GLU A 203      68.010  37.690  74.430  1.00  0.00           CA
+ATOM   3315    C GLU A 203      67.040  36.910  73.490  1.00  0.00            C
+ATOM   3316    O GLU A 203      67.170  36.770  72.280  1.00  0.00            O
+ATOM   3317    N LYS A 204      65.920  36.350  74.060  1.00  0.00            N
+ATOM   3319   CA LYS A 204      64.790  35.810  73.330  1.00  0.00           CA
+ATOM   3337    C LYS A 204      64.080  36.670  72.370  1.00  0.00            C
+ATOM   3338    O LYS A 204      63.850  36.190  71.240  1.00  0.00            O
+ATOM   3339    N LYS A 205      63.770  37.910  72.700  1.00  0.00            N
+ATOM   3341   CA LYS A 205      63.270  38.920  71.770  1.00  0.00           CA
+ATOM   3359    C LYS A 205      64.110  39.220  70.570  1.00  0.00            C
+ATOM   3360    O LYS A 205      63.600  39.290  69.440  1.00  0.00            O
+ATOM   3361    N ALA A 206      65.440  39.300  70.780  1.00  0.00            N
+ATOM   3363   CA ALA A 206      66.450  39.360  69.690  1.00  0.00           CA
+ATOM   3369    C ALA A 206      66.480  38.130  68.810  1.00  0.00            C
+ATOM   3370    O ALA A 206      66.620  38.220  67.600  1.00  0.00            O
+ATOM   3371    N THR A 207      66.320  36.940  69.420  1.00  0.00            N
+ATOM   3373   CA THR A 207      66.440  35.680  68.700  1.00  0.00           CA
+ATOM   3383    C THR A 207      65.150  35.460  67.860  1.00  0.00            C
+ATOM   3384    O THR A 207      65.210  35.090  66.660  1.00  0.00            O
+ATOM   3385    N GLN A 208      63.950  35.740  68.390  1.00  0.00            N
+ATOM   3387   CA GLN A 208      62.670  35.860  67.580  1.00  0.00           CA
+ATOM   3400    C GLN A 208      62.700  36.920  66.510  1.00  0.00            C
+ATOM   3401    O GLN A 208      62.180  36.700  65.350  1.00  0.00            O
+ATOM   3402    N MET A 209      63.310  38.170  66.700  1.00  0.00            N
+ATOM   3404   CA MET A 209      63.440  39.220  65.710  1.00  0.00           CA
+ATOM   3417    C MET A 209      64.330  38.810  64.530  1.00  0.00            C
+ATOM   3418    O MET A 209      63.930  39.000  63.400  1.00  0.00            O
+ATOM   3419    N LEU A 210      65.500  38.200  64.730  1.00  0.00            N
+ATOM   3421   CA LEU A 210      66.250  37.700  63.620  1.00  0.00           CA
+ATOM   3436    C LEU A 210      65.660  36.330  63.000  1.00  0.00            C
+ATOM   3437    O LEU A 210      65.780  36.150  61.800  1.00  0.00            O
+ATOM   3438    N ALA A 211      64.960  35.550  63.810  1.00  0.00            N
+ATOM   3440   CA ALA A 211      64.230  34.420  63.260  1.00  0.00           CA
+ATOM   3446    C ALA A 211      63.150  34.830  62.290  1.00  0.00            C
+ATOM   3447    O ALA A 211      62.980  34.200  61.290  1.00  0.00            O
+ATOM   3448    N ILE A 212      62.400  35.860  62.660  1.00  0.00            N
+ATOM   3450   CA ILE A 212      61.520  36.580  61.760  1.00  0.00           CA
+ATOM   3465    C ILE A 212      62.360  37.150  60.550  1.00  0.00            C
+ATOM   3466    O ILE A 212      61.860  37.090  59.420  1.00  0.00            O
+ATOM   3467    N VAL A 213      63.590  37.680  60.680  1.00  0.00            N
+ATOM   3469   CA VAL A 213      64.410  38.130  59.500  1.00  0.00           CA
+ATOM   3481    C VAL A 213      64.760  36.960  58.520  1.00  0.00            C
+ATOM   3482    O VAL A 213      64.490  36.970  57.350  1.00  0.00            O
+ATOM   3483    N LEU A 214      65.120  35.790  59.090  1.00  0.00            N
+ATOM   3485   CA LEU A 214      65.260  34.560  58.390  1.00  0.00           CA
+ATOM   3500    C LEU A 214      63.960  34.010  57.870  1.00  0.00            C
+ATOM   3501    O LEU A 214      63.810  33.500  56.730  1.00  0.00            O
+ATOM   3502    N GLY A 215      62.840  34.240  58.610  1.00  0.00            N
+ATOM   3504   CA GLY A 215      61.390  34.020  58.190  1.00  0.00           CA
+ATOM   3507    C GLY A 215      60.950  34.820  56.950  1.00  0.00            C
+ATOM   3508    O GLY A 215      60.240  34.370  56.070  1.00  0.00            O
+ATOM   3509    N VAL A 216      61.400  36.040  56.840  1.00  0.00            N
+ATOM   3511   CA VAL A 216      61.450  36.910  55.660  1.00  0.00           CA
+ATOM   3523    C VAL A 216      62.250  36.420  54.530  1.00  0.00            C
+ATOM   3524    O VAL A 216      61.820  36.470  53.340  1.00  0.00            O
+ATOM   3525    N PHE A 217      63.470  35.900  54.750  1.00  0.00            N
+ATOM   3527   CA PHE A 217      64.300  35.380  53.720  1.00  0.00           CA
+ATOM   3543    C PHE A 217      63.700  34.090  53.070  1.00  0.00            C
+ATOM   3544    O PHE A 217      63.820  33.900  51.860  1.00  0.00            O
+ATOM   3545    N ILE A 218      63.110  33.240  53.980  1.00  0.00            N
+ATOM   3547   CA ILE A 218      62.330  32.100  53.570  1.00  0.00           CA
+ATOM   3562    C ILE A 218      61.150  32.370  52.630  1.00  0.00            C
+ATOM   3563    O ILE A 218      61.040  31.740  51.600  1.00  0.00            O
+ATOM   3564    N ILE A 219      60.280  33.340  52.970  1.00  0.00            N
+ATOM   3566   CA ILE A 219      59.180  33.840  52.120  1.00  0.00           CA
+ATOM   3581    C ILE A 219      59.680  34.360  50.800  1.00  0.00            C
+ATOM   3582    O ILE A 219      59.080  34.150  49.740  1.00  0.00            O
+ATOM   3583    N CYS A 220      60.710  35.170  50.940  1.00  0.00            N
+ATOM   3585   CA CYS A 220      61.270  35.850  49.790  1.00  0.00           CA
+ATOM   3592    C CYS A 220      62.030  34.960  48.770  1.00  0.00            C
+ATOM   3593    O CYS A 220      61.750  35.080  47.570  1.00  0.00            O
+ATOM   3594    N TRP A 221      62.970  34.070  49.160  1.00  0.00            N
+ATOM   3596   CA TRP A 221      63.910  33.340  48.270  1.00  0.00           CA
+ATOM   3616    C TRP A 221      63.850  31.820  48.080  1.00  0.00            C
+ATOM   3617    O TRP A 221      64.430  31.270  47.160  1.00  0.00            O
+ATOM   3618    N LEU A 222      63.130  31.120  48.920  1.00  0.00            N
+ATOM   3620   CA LEU A 222      62.780  29.730  48.710  1.00  0.00           CA
+ATOM   3635    C LEU A 222      61.860  29.570  47.530  1.00  0.00            C
+ATOM   3636    O LEU A 222      62.260  28.820  46.670  1.00  0.00            O
+ATOM   3637    N PRO A 223      60.670  30.220  47.280  1.00  0.00            N
+ATOM   3641   CA PRO A 223      59.960  30.290  46.020  1.00  0.00           CA
+ATOM   3649    C PRO A 223      60.860  30.300  44.770  1.00  0.00            C
+ATOM   3650    O PRO A 223      60.610  29.480  43.890  1.00  0.00            O
+ATOM   3651    N PHE A 224      61.840  31.260  44.670  1.00  0.00            N
+ATOM   3653   CA PHE A 224      62.750  31.300  43.550  1.00  0.00           CA
+ATOM   3669    C PHE A 224      63.600  30.030  43.430  1.00  0.00            C
+ATOM   3670    O PHE A 224      63.630  29.460  42.340  1.00  0.00            O
+ATOM   3671    N PHE A 225      64.290  29.530  44.510  1.00  0.00            N
+ATOM   3673   CA PHE A 225      65.230  28.380  44.470  1.00  0.00           CA
+ATOM   3689    C PHE A 225      64.430  27.060  44.670  1.00  0.00            C
+ATOM   3690    O PHE A 225      64.980  25.940  44.880  1.00  0.00            O
+ATOM   3691    N ILE A 226      63.030  27.040  44.490  1.00  0.00            N
+ATOM   3693   CA ILE A 226      62.310  25.790  44.270  1.00  0.00           CA
+ATOM   3708    C ILE A 226      61.570  25.950  42.920  1.00  0.00            C
+ATOM   3709    O ILE A 226      60.990  24.970  42.400  1.00  0.00            O
+ATOM   3710    N THR A 227      61.540  27.160  42.390  1.00  0.00            N
+ATOM   3712   CA THR A 227      61.180  27.320  40.990  1.00  0.00           CA
+ATOM   3722    C THR A 227      62.320  26.820  40.180  1.00  0.00            C
+ATOM   3723    O THR A 227      63.090  27.580  39.650  1.00  0.00            O
+ATOM   3724    N ILE A 229      62.400  25.470  40.010  1.00  0.00            N
+ATOM   3726   CA ILE A 229      63.390  24.670  39.250  1.00  0.00           CA
+ATOM   3741    C ILE A 229      62.670  24.100  38.000  1.00  0.00            C
+ATOM   3742    O ILE A 229      63.030  23.200  37.290  1.00  0.00            O
+ATOM   3743    N LEU A 230      61.420  24.570  37.780  1.00  0.00            N
+ATOM   3745   CA LEU A 230      60.580  24.130  36.590  1.00  0.00           CA
+ATOM   3760    C LEU A 230      61.360  24.050  35.310  1.00  0.00            C
+ATOM   3761    O LEU A 230      61.260  23.120  34.520  1.00  0.00            O
+ATOM   3762    N ASN A 231      62.280  24.970  35.080  1.00  0.00            N
+ATOM   3764   CA ASN A 231      63.130  25.140  33.950  1.00  0.00           CA
+ATOM   3774    C ASN A 231      64.250  24.070  33.930  1.00  0.00            C
+ATOM   3775    O ASN A 231      64.770  23.850  32.880  1.00  0.00            O
+ATOM   3776    N ILE A 232      64.530  23.400  35.030  1.00  0.00            N
+ATOM   3778   CA ILE A 232      65.450  22.250  35.070  1.00  0.00           CA
+ATOM   3793    C ILE A 232      64.730  21.130  34.450  1.00  0.00            C
+ATOM   3794    O ILE A 232      65.240  20.300  33.660  1.00  0.00            O
+ATOM   3795    N CYS A 234      63.450  21.060  34.660  1.00  0.00            N
+ATOM   3797   CA CYS A 234      62.780  19.870  34.180  1.00  0.00           CA
+ATOM   3803    C CYS A 234      62.170  19.890  32.730  1.00  0.00            C
+ATOM   3804    O CYS A 234      61.670  18.820  32.290  1.00  0.00            O
+ATOM   3805    N ASP A 235      62.170  21.010  32.020  1.00  0.00            N
+ATOM   3807   CA ASP A 235      61.330  21.160  30.840  1.00  0.00           CA
+ATOM   3815    C ASP A 235      59.900  21.410  31.300  1.00  0.00            C
+ATOM   3816    O ASP A 235      58.960  21.000  30.710  1.00  0.00            O
+ATOM   3817    N CYS A 236      59.640  21.990  32.470  1.00  0.00            N
+ATOM   3819   CA CYS A 236      58.330  22.180  32.960  1.00  0.00           CA
+ATOM   3825    C CYS A 236      57.900  23.710  32.900  1.00  0.00            C
+ATOM   3826    O CYS A 236      58.800  24.540  32.840  1.00  0.00            O
+ATOM   3827    N ASN A 237      56.590  24.060  32.810  1.00  0.00            N
+ATOM   3829   CA ASN A 237      56.150  25.360  32.340  1.00  0.00           CA
+ATOM   3839    C ASN A 237      55.950  26.240  33.520  1.00  0.00            C
+ATOM   3840    O ASN A 237      55.000  26.130  34.250  1.00  0.00            O
+ATOM   3841    N ILE A 238      56.850  27.260  33.640  1.00  0.00            N
+ATOM   3843   CA ILE A 238      56.700  28.370  34.590  1.00  0.00           CA
+ATOM   3858    C ILE A 238      56.340  29.640  33.750  1.00  0.00            C
+ATOM   3859    O ILE A 238      57.010  29.920  32.730  1.00  0.00            O
+ATOM   3860    N PRO A 239      55.250  30.330  33.950  1.00  0.00            N
+ATOM   3864   CA PRO A 239      54.870  31.450  33.110  1.00  0.00           CA
+ATOM   3872    C PRO A 239      55.940  32.580  33.190  1.00  0.00            C
+ATOM   3873    O PRO A 239      56.510  32.700  34.230  1.00  0.00            O
+ATOM   3874    N PRO A 240      56.210  33.340  32.210  1.00  0.00            N
+ATOM   3878   CA PRO A 240      57.420  34.140  32.190  1.00  0.00           CA
+ATOM   3886    C PRO A 240      57.300  35.330  33.170  1.00  0.00            C
+ATOM   3887    O PRO A 240      58.320  35.670  33.730  1.00  0.00            O
+ATOM   3888    N VAL A 241      56.150  36.070  33.320  1.00  0.00            N
+ATOM   3890   CA VAL A 241      55.950  37.190  34.250  1.00  0.00           CA
+ATOM   3902    C VAL A 241      56.080  36.720  35.720  1.00  0.00            C
+ATOM   3903    O VAL A 241      56.770  37.290  36.560  1.00  0.00            O
+ATOM   3904    N LEU A 242      55.510  35.530  36.070  1.00  0.00            N
+ATOM   3906   CA LEU A 242      55.620  34.660  37.290  1.00  0.00           CA
+ATOM   3921    C LEU A 242      57.110  34.230  37.570  1.00  0.00            C
+ATOM   3922    O LEU A 242      57.540  34.290  38.730  1.00  0.00            O
+ATOM   3923    N TYR A 243      57.920  33.900  36.530  1.00  0.00            N
+ATOM   3925   CA TYR A 243      59.330  33.840  36.710  1.00  0.00           CA
+ATOM   3942    C TYR A 243      60.040  35.120  37.150  1.00  0.00            C
+ATOM   3943    O TYR A 243      60.650  35.080  38.240  1.00  0.00            O
+ATOM   3944    N SER A 244      59.890  36.300  36.500  1.00  0.00            N
+ATOM   3946   CA SER A 244      60.170  37.610  37.020  1.00  0.00           CA
+ATOM   3953    C SER A 244      59.550  37.970  38.390  1.00  0.00            C
+ATOM   3954    O SER A 244      60.260  38.440  39.250  1.00  0.00            O
+ATOM   3955    N ALA A 245      58.270  37.630  38.750  1.00  0.00            N
+ATOM   3957   CA ALA A 245      57.590  37.830  40.100  1.00  0.00           CA
+ATOM   3963    C ALA A 245      58.440  37.160  41.240  1.00  0.00            C
+ATOM   3964    O ALA A 245      58.570  37.700  42.290  1.00  0.00            O
+ATOM   3965    N PHE A 246      58.950  35.930  40.960  1.00  0.00            N
+ATOM   3967   CA PHE A 246      59.710  35.190  41.920  1.00  0.00           CA
+ATOM   3983    C PHE A 246      61.090  35.750  42.130  1.00  0.00            C
+ATOM   3984    O PHE A 246      61.690  35.680  43.220  1.00  0.00            O
+ATOM   3985    N THR A 247      61.580  36.280  41.040  1.00  0.00            N
+ATOM   3987   CA THR A 247      62.860  37.010  41.030  1.00  0.00           CA
+ATOM   3997    C THR A 247      62.750  38.290  41.840  1.00  0.00            C
+ATOM   3998    O THR A 247      63.550  38.490  42.740  1.00  0.00            O
+ATOM   3999    N TRP A 248      61.610  39.090  41.530  1.00  0.00            N
+ATOM   4001   CA TRP A 248      61.350  40.300  42.300  1.00  0.00           CA
+ATOM   4021    C TRP A 248      60.970  40.270  43.760  1.00  0.00            C
+ATOM   4022    O TRP A 248      61.360  41.140  44.540  1.00  0.00            O
+ATOM   4023    N LEU A 249      60.280  39.230  44.150  1.00  0.00            N
+ATOM   4025   CA LEU A 249      59.930  38.830  45.450  1.00  0.00           CA
+ATOM   4040    C LEU A 249      61.220  38.580  46.320  1.00  0.00            C
+ATOM   4041    O LEU A 249      61.290  39.000  47.490  1.00  0.00            O
+ATOM   4042    N GLY A 250      62.300  37.950  45.790  1.00  0.00            N
+ATOM   4044   CA GLY A 250      63.610  37.840  46.460  1.00  0.00           CA
+ATOM   4047    C GLY A 250      64.130  39.140  46.920  1.00  0.00            C
+ATOM   4048    O GLY A 250      64.430  39.390  48.090  1.00  0.00            O
+ATOM   4049    N TYR A 251      64.060  40.140  46.060  1.00  0.00            N
+ATOM   4051   CA TYR A 251      64.530  41.470  46.260  1.00  0.00           CA
+ATOM   4068    C TYR A 251      63.700  42.300  47.270  1.00  0.00            C
+ATOM   4069    O TYR A 251      64.310  43.270  47.770  1.00  0.00            O
+ATOM   4070    N VAL A 252      62.430  41.960  47.660  1.00  0.00            N
+ATOM   4072   CA VAL A 252      61.800  42.600  48.810  1.00  0.00           CA
+ATOM   4084    C VAL A 252      62.600  42.390  50.060  1.00  0.00            C
+ATOM   4085    O VAL A 252      62.660  43.330  50.820  1.00  0.00            O
+ATOM   4086    N ASN A 253      63.300  41.180  50.230  1.00  0.00            N
+ATOM   4088   CA ASN A 253      64.060  40.880  51.400  1.00  0.00           CA
+ATOM   4098    C ASN A 253      64.920  42.020  51.850  1.00  0.00            C
+ATOM   4099    O ASN A 253      65.050  42.350  53.050  1.00  0.00            O
+ATOM   4100    N SER A 254      65.600  42.660  50.950  1.00  0.00            N
+ATOM   4102   CA SER A 254      66.680  43.600  51.390  1.00  0.00           CA
+ATOM   4109    C SER A 254      66.100  44.960  51.730  1.00  0.00            C
+ATOM   4110    O SER A 254      66.810  45.790  52.310  1.00  0.00            O
+ATOM   4111    N ALA A 255      64.840  45.300  51.310  1.00  0.00            N
+ATOM   4113   CA ALA A 255      64.140  46.580  51.740  1.00  0.00           CA
+ATOM   4119    C ALA A 255      63.420  46.290  53.040  1.00  0.00            C
+ATOM   4120    O ALA A 255      63.200  47.150  53.860  1.00  0.00            O
+ATOM   4121    N VAL A 256      62.920  45.040  53.290  1.00  0.00            N
+ATOM   4123   CA VAL A 256      62.210  44.650  54.500  1.00  0.00           CA
+ATOM   4135    C VAL A 256      63.120  44.370  55.680  1.00  0.00            C
+ATOM   4136    O VAL A 256      62.720  44.470  56.860  1.00  0.00            O
+ATOM   4137    N ASN A 257      64.430  44.060  55.410  1.00  0.00            N
+ATOM   4139   CA ASN A 257      65.430  44.010  56.410  1.00  0.00           CA
+ATOM   4149    C ASN A 257      65.410  45.210  57.430  1.00  0.00            C
+ATOM   4150    O ASN A 257      65.230  44.950  58.620  1.00  0.00            O
+ATOM   4151    N PRO A 258      65.480  46.540  57.150  1.00  0.00            N
+ATOM   4155   CA PRO A 258      65.510  47.540  58.240  1.00  0.00           CA
+ATOM   4163    C PRO A 258      64.080  47.710  58.940  1.00  0.00            C
+ATOM   4164    O PRO A 258      64.070  47.940  60.150  1.00  0.00            O
+ATOM   4165    N ILE A 259      62.990  47.460  58.190  1.00  0.00            N
+ATOM   4167   CA ILE A 259      61.610  47.430  58.620  1.00  0.00           CA
+ATOM   4182    C ILE A 259      61.410  46.480  59.810  1.00  0.00            C
+ATOM   4183    O ILE A 259      60.820  46.850  60.810  1.00  0.00            O
+ATOM   4184    N ILE A 260      62.010  45.290  59.660  1.00  0.00            N
+ATOM   4186   CA ILE A 260      61.860  44.370  60.840  1.00  0.00           CA
+ATOM   4201    C ILE A 260      62.380  44.920  62.100  1.00  0.00            C
+ATOM   4202    O ILE A 260      61.760  44.880  63.190  1.00  0.00            O
+ATOM   4203    N TYR A 261      63.610  45.540  62.000  1.00  0.00            N
+ATOM   4205   CA TYR A 261      64.160  46.120  63.180  1.00  0.00           CA
+ATOM   4222    C TYR A 261      63.390  47.270  63.870  1.00  0.00            C
+ATOM   4223    O TYR A 261      63.270  47.370  65.090  1.00  0.00            O
+ATOM   4224    N THR A 262      62.720  48.170  63.030  1.00  0.00            N
+ATOM   4226   CA THR A 262      62.020  49.280  63.640  1.00  0.00           CA
+ATOM   4236    C THR A 262      60.600  48.890  64.080  1.00  0.00            C
+ATOM   4237    O THR A 262      59.900  49.640  64.740  1.00  0.00            O
+ATOM   4238    N THR A 263      60.220  47.620  63.710  1.00  0.00            N
+ATOM   4240   CA THR A 263      58.860  47.160  63.960  1.00  0.00           CA
+ATOM   4250    C THR A 263      58.920  46.510  65.290  1.00  0.00            C
+ATOM   4251    O THR A 263      58.200  46.900  66.200  1.00  0.00            O
+ATOM   4252    N PHE A 264      59.850  45.500  65.570  1.00  0.00            N
+ATOM   4254   CA PHE A 264      59.920  44.850  66.850  1.00  0.00           CA
+ATOM   4270    C PHE A 264      60.720  45.440  67.970  1.00  0.00            C
+ATOM   4271    O PHE A 264      60.470  45.240  69.170  1.00  0.00            O
+ATOM   4272    N ASN A 265      61.730  46.290  67.630  1.00  0.00            N
+ATOM   4274   CA ASN A 265      62.680  46.800  68.570  1.00  0.00           CA
+ATOM   4284    C ASN A 265      62.740  48.400  68.660  1.00  0.00            C
+ATOM   4285    O ASN A 265      63.070  49.190  67.750  1.00  0.00            O
+ATOM   4286    N ILE A 266      62.440  48.900  69.920  1.00  0.00            N
+ATOM   4288   CA ILE A 266      62.490  50.270  70.280  1.00  0.00           CA
+ATOM   4303    C ILE A 266      63.860  50.820  70.040  1.00  0.00            C
+ATOM   4304    O ILE A 266      64.020  51.870  69.440  1.00  0.00            O
+ATOM   4305    N GLU A 267      64.910  50.070  70.460  1.00  0.00            N
+ATOM   4307   CA GLU A 267      66.190  50.650  70.470  1.00  0.00           CA
+ATOM   4318    C GLU A 267      66.770  51.110  69.130  1.00  0.00            C
+ATOM   4319    O GLU A 267      67.330  52.210  69.050  1.00  0.00            O
+ATOM   4320    N PHE A 268      66.600  50.260  68.040  1.00  0.00            N
+ATOM   4322   CA PHE A 268      66.790  50.570  66.640  1.00  0.00           CA
+ATOM   4338    C PHE A 268      65.940  51.750  66.190  1.00  0.00            C
+ATOM   4339    O PHE A 268      66.400  52.650  65.480  1.00  0.00            O
+ATOM   4340    N ARG A 269      64.640  51.660  66.560  1.00  0.00            N
+ATOM   4342   CA ARG A 269      63.690  52.670  66.050  1.00  0.00           CA
+ATOM   4362    C ARG A 269      63.980  54.060  66.560  1.00  0.00            C
+ATOM   4363    O ARG A 269      63.960  55.060  65.850  1.00  0.00            O
+ATOM   4364    N LYS A 270      64.300  54.220  67.890  1.00  0.00            N
+ATOM   4366   CA LYS A 270      64.790  55.430  68.550  1.00  0.00           CA
+ATOM   4384    C LYS A 270      66.060  56.050  68.010  1.00  0.00            C
+ATOM   4385    O LYS A 270      66.160  57.240  67.760  1.00  0.00            O
+ATOM   4386    N ALA A 271      67.010  55.200  67.700  1.00  0.00            N
+ATOM   4388   CA ALA A 271      68.290  55.550  67.040  1.00  0.00           CA
+ATOM   4394    C ALA A 271      68.130  55.920  65.610  1.00  0.00            C
+ATOM   4395    O ALA A 271      68.880  56.750  65.110  1.00  0.00            O
+ATOM   4396    N PHE A 272      67.160  55.320  64.830  1.00  0.00            N
+ATOM   4398   CA PHE A 272      66.810  55.790  63.490  1.00  0.00           CA
+ATOM   4414    C PHE A 272      66.250  57.270  63.680  1.00  0.00            C
+ATOM   4415    O PHE A 272      66.670  58.170  62.970  1.00  0.00            O
+ATOM   4416    N LEU A 273      65.360  57.450  64.710  1.00  0.00            N
+ATOM   4418   CA LEU A 273      64.710  58.720  64.890  1.00  0.00           CA
+ATOM   4433    C LEU A 273      65.620  59.900  65.270  1.00  0.00            C
+ATOM   4434    O LEU A 273      65.380  61.050  64.930  1.00  0.00            O
+ATOM   4435    N LYS A 274      66.680  59.520  66.020  1.00  0.00            N
+ATOM   4437   CA LYS A 274      67.810  60.340  66.440  1.00  0.00           CA
+ATOM   4455    C LYS A 274      68.630  60.970  65.320  1.00  0.00            C
+ATOM   4456    O LYS A 274      68.980  62.130  65.300  1.00  0.00            O
+ATOM   4457    N ILE A 275      68.970  60.170  64.300  1.00  0.00            N
+ATOM   4459   CA ILE A 275      69.640  60.610  63.070  1.00  0.00           CA
+ATOM   4474    C ILE A 275      68.820  61.610  62.310  1.00  0.00            C
+ATOM   4475    O ILE A 275      69.410  62.560  61.850  1.00  0.00            O
+ATOM   4476    N LEU A 276      67.490  61.430  62.140  1.00  0.00            N
+ATOM   4478   CA LEU A 276      66.540  62.220  61.350  1.00  0.00           CA
+ATOM   4493    C LEU A 276      66.490  63.690  61.810  1.00  0.00            C
+ATOM   4494    O LEU A 276      66.540  64.520  60.970  1.00  0.00            O
+ATOM   4495    N CYS A 278      66.460  63.930  63.110  1.00  0.00            N
+ATOM   4497   CA CYS A 278      66.430  65.250  63.610  1.00  0.00           CA
+ATOM   4504    C CYS A 278      67.300  65.310  64.810  1.00  0.00            C
+END

LD-FPG-main/blind/new_diff.py

@@ -0,0 +1,819 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import pathlib # Use pathlib for path handling
+
+# -----------------------------
+# Command-line arguments
+# -----------------------------
+parser = argparse.ArgumentParser(description="Diffusion Experiment Runner (Revised)")
+parser.add_argument('--instance_id', type=int, default=0,
+                    help='Instance ID (0, 1, 2, …) for splitting grid search experiments')
+parser.add_argument('--exp_idx', type=int, default=None,
+                    help='Global experiment index (1-based) to run a single specific experiment from the grid')
+parser.add_argument('--num_epochs_override', type=int, default=None,
+                    help='Override the number of training epochs specified in the config')
+parser.add_argument('--config', type=str, default=None, required=True, # Make config required
+                    help='Path to YAML config file with hyperparameters')
+parser.add_argument('--debug', action='store_true',
+                    help='Enable debug level logging')
+parser.add_argument('--log_file', type=str, default="diffusion_runner.log", # Default log file name
+                    help='Path to log file')
+
+args = parser.parse_args()
+
+# -----------------------------
+# Setup logging
+# -----------------------------
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(filename=args.log_file,
+                    filemode='w', # Overwrite log file each time
+                    level=log_level,
+                    format=log_format)
+# Also log to console
+console_handler = logging.StreamHandler()
+console_handler.setLevel(log_level)
+console_handler.setFormatter(logging.Formatter(log_format))
+logging.getLogger().addHandler(console_handler)
+
+logging.info("Diffusion Runner Script Started")
+logging.info(f"Running with arguments: {args}")
+
+# -----------------------------
+# Default global parameters
+# -----------------------------
+default_params = {
+    'batch_size': 64,
+    'num_epochs': 50000,
+    'learning_rate': 1e-5,
+    'num_gen': 5000, # Number of samples to generate after training
+    'save_interval': 1000, # Save checkpoint frequency
+    'hidden_dim': 1024, # Default hidden dim for MLP models
+    'model_type': "mlp_v2", # Default model type
+    'beta_start': 5e-6,
+    'beta_end': 0.03,
+    'diffusion_steps': 1400,
+    'scheduler': "linear", # Only linear supported currently
+    'num_instances': 6, # For grid search partitioning
+    'h5_file_path': None, # Must be provided in config
+    'dataset_key': None, # Must be provided in config
+    'output_dir': 'diffusion_output', # Default relative output dir
+    'pooling': 'blind', # 'blind' or 'selected' (or other identifier)
+    'selected_residues': [0], # Default for 'blind', overridden if pooling != 'blind'
+    'conv2d_hidden_channels': 64, # Hidden channels for Conv2D model
+    'decoder2_settings': { # Example shape info needed if model_type='conv2d' and pooling='blind'
+        'output_height': 50,
+        'output_width': 2
+    }
+}
+
+# -----------------------------
+# Load YAML config and merge with defaults
+# -----------------------------
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logging.error(f"Configuration file not found: {args.config}")
+    exit(1)
+
+with open(config_path, 'r') as file:
+    yaml_config = yaml.safe_load(file)
+    logging.info(f"Loaded configuration from {config_path}")
+
+# Merge parameters: YAML overrides defaults
+params = default_params.copy()
+if 'parameters' in yaml_config:
+    params.update(yaml_config['parameters'])
+    logging.info("Updated parameters from YAML file.")
+
+# Determine run mode (default is grid_search from YAML, fallback to user_defined if not specified)
+run_mode = yaml_config.get('run_mode', 'user_defined')
+logging.info(f"Run mode determined: {run_mode}")
+
+# --- Validate essential parameters ---
+if not params.get('h5_file_path') or not params.get('dataset_key'):
+    logging.error("Missing required parameters in config: 'h5_file_path' or 'dataset_key'")
+    exit(1)
+
+# -----------------------------
+# Apply Command-Line Overrides
+# -----------------------------
+if args.num_epochs_override is not None:
+    params['num_epochs'] = args.num_epochs_override
+    logging.info(f"Overrode num_epochs to {params['num_epochs']} via command line.")
+
+# -----------------------------
+# Set Global Training Variables from Params
+# -----------------------------
+BATCH_SIZE = params['batch_size']
+NUM_EPOCHS = params['num_epochs']
+LEARNING_RATE = params['learning_rate'] # Base LR, might be overwritten by grid search exp
+NUM_GENERATE = params['num_gen']
+SAVE_INTERVAL = params['save_interval']
+POOLING_MODE = params['pooling']
+DEFAULT_MODEL_TYPE = params['model_type'] # Can be overridden by grid search exp
+DECODER2_SETTINGS = params.get('decoder2_settings', {}) # For conv2d shape if blind
+H5_FILE_PATH = pathlib.Path(params['h5_file_path'])
+DATASET_KEY = params['dataset_key']
+OUTPUT_DIR = pathlib.Path(params['output_dir'])
+SELECTED_RESIDUES = params['selected_residues'] if POOLING_MODE != 'blind' else [0] # Use [0] for blind
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logging.info(f"Using device: {DEVICE}")
+logging.info(f"Effective parameters: {params}") # Log all final params
+
+# -----------------------------
+# Output directory and checkpoint directory setup
+# -----------------------------
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+checkpoint_dir = OUTPUT_DIR / 'checkpoints'
+checkpoint_dir.mkdir(exist_ok=True)
+logging.info(f"Output directory set to: {OUTPUT_DIR.resolve()}")
+logging.info(f"Checkpoint directory set to: {checkpoint_dir.resolve()}")
+
+# -----------------------------
+# Build curated hyperparameter grid (if applicable)
+# -----------------------------
+# (Grid search logic remains the same as the original script)
+# This section defines `experiments_all` if run_mode is 'grid_search'
+if run_mode == "grid_search":
+    logging.info("Building curated hyperparameter grid for grid_search mode.")
+    curated_experiments = []
+    fixed_lr_grid = params['learning_rate'] # Use LR from config for grid
+    num_epochs_grid = params['num_epochs'] # Use epochs from config (or override)
+    model_type_grid = params['model_type'] # Use model type from config for all grid exps
+    hidden_dim_grid = params['hidden_dim'] # Use hidden dim from config
+
+    # Group 1: Around beta_start = 5e-6, base (beta_end=0.03, diffusion_steps=1400)
+    group1_params = [
+        {"diffusion_steps": 1200, "beta_end": 0.02}, {"diffusion_steps": 1400, "beta_end": 0.03},
+        {"diffusion_steps": 1500, "beta_end": 0.03}, {"diffusion_steps": 1400, "beta_end": 0.02},
+        {"diffusion_steps": 1400, "beta_end": 0.04}, {"diffusion_steps": 1600, "beta_end": 0.03},
+    ]
+    for exp in group1_params:
+        curated_experiments.append({
+            'learning_rate': fixed_lr_grid, 'num_epochs': num_epochs_grid, 'hidden_dim': hidden_dim_grid,
+            'model_type': model_type_grid, 'beta_start': 5e-6, 'beta_end': exp["beta_end"],
+            'scheduler': "linear", 'diffusion_steps': exp["diffusion_steps"]
+        })
+
+    # Group 2: Fix beta_start=0.005, beta_end=0.1; vary diffusion_steps (5 values from 450 to 550)
+    for steps in np.linspace(450, 550, 5, dtype=int):
+        curated_experiments.append({
+            'learning_rate': fixed_lr_grid, 'num_epochs': num_epochs_grid, 'hidden_dim': hidden_dim_grid,
+            'model_type': model_type_grid, 'beta_start': 0.005, 'beta_end': 0.1,
+            'scheduler': "linear", 'diffusion_steps': int(steps)
+        })
+
+    # Group 3: diffusion_steps=500; vary beta_start in [0.004, 0.006], beta_end in [0.09, 0.11]
+    for bstart in [0.004, 0.006]:
+        for bend in [0.09, 0.11]:
+            curated_experiments.append({
+                'learning_rate': fixed_lr_grid, 'num_epochs': num_epochs_grid, 'hidden_dim': hidden_dim_grid,
+                'model_type': model_type_grid, 'beta_start': bstart, 'beta_end': bend,
+                'scheduler': "linear", 'diffusion_steps': 500
+            })
+
+    experiments_all = curated_experiments
+    num_total_experiments = len(experiments_all)
+    logging.info(f"Total curated experiments generated: {num_total_experiments}")
+
+    # --- Partition experiments based on instance_id or select specific exp_idx ---
+    if args.exp_idx is not None:
+        # Run only the specified experiment index
+        if not 1 <= args.exp_idx <= num_total_experiments:
+            logging.error(f"Invalid --exp_idx {args.exp_idx}; valid range is 1 to {num_total_experiments}.")
+            exit(1)
+        experiments_to_run = [experiments_all[args.exp_idx - 1]]
+        current_run_start_idx = args.exp_idx - 1 # 0-based index for internal use
+        logging.info(f"Running single specified experiment index: {args.exp_idx} (Internal index: {current_run_start_idx})")
+    else:
+        # Partition the grid search for the current instance_id
+        num_instances = params.get('num_instances', 1)
+        if not 0 <= args.instance_id < num_instances:
+             logging.error(f"Invalid --instance_id {args.instance_id}; must be between 0 and {num_instances-1}.")
+             exit(1)
+
+        logging.info(f"Partitioning {num_total_experiments} experiments across {num_instances} instances.")
+        base_size = num_total_experiments // num_instances
+        remainder = num_total_experiments % num_instances
+        sizes = [base_size + 1 if i < remainder else base_size for i in range(num_instances)]
+        starts = [sum(sizes[:i]) for i in range(num_instances)]
+        ends = [sum(sizes[:i+1]) for i in range(num_instances)]
+
+        current_run_start_idx = starts[args.instance_id]
+        current_run_end_idx = ends[args.instance_id]
+        experiments_to_run = experiments_all[current_run_start_idx:current_run_end_idx]
+        logging.info(f"[Instance {args.instance_id}] Running {len(experiments_to_run)} experiments (Indices {current_run_start_idx} to {current_run_end_idx - 1})")
+
+elif run_mode == 'user_defined':
+    # Run a single experiment based on the main parameters section
+    logging.info("Running in user_defined mode (single experiment from main parameters).")
+    experiments_to_run = [{
+        'learning_rate': params['learning_rate'], 'num_epochs': params['num_epochs'],
+        'hidden_dim': params['hidden_dim'], 'model_type': params['model_type'],
+        'beta_start': params['beta_start'], 'beta_end': params['beta_end'],
+        'scheduler': params.get('scheduler', "linear"), 'diffusion_steps': params['diffusion_steps']
+    }]
+    current_run_start_idx = 0 # Only one experiment, starts at index 0
+else:
+    logging.error(f"Unknown run_mode: {run_mode}. Choose 'grid_search' or 'user_defined'.")
+    exit(1)
+
+logging.info(f"Number of experiments to execute in this run: {len(experiments_to_run)}")
+
+# -----------------------------
+# Diffusion schedule function
+# -----------------------------
+def linear_beta_schedule(timesteps, beta_start, beta_end):
+    return torch.linspace(beta_start, beta_end, timesteps, device=DEVICE) # Create directly on device
+
+# --- Global Diffusion Schedule Variables (will be updated per experiment) ---
+# These need to be accessible by the model and diffusion functions
+betas = None
+alphas = None
+alphas_cumprod = None
+sqrt_alphas_cumprod = None
+sqrt_one_minus_alphas_cumprod = None
+current_diffusion_steps = None
+
+# -----------------------------
+# Load and Prepare Data
+# -----------------------------
+logging.info(f"Loading data from: {H5_FILE_PATH}")
+if not H5_FILE_PATH.is_file():
+    logging.error(f"Input HDF5 file not found: {H5_FILE_PATH}")
+    exit(1)
+
+with h5py.File(H5_FILE_PATH, 'r') as f:
+    if DATASET_KEY not in f:
+        logging.error(f"Dataset key '{DATASET_KEY}' not found in {H5_FILE_PATH}")
+        exit(1)
+    all_pooled_raw = f[DATASET_KEY][:] # Shape (N, ...)
+logging.info(f"Loaded raw pooled embeddings with shape: {all_pooled_raw.shape}")
+
+# --- Reshape for Blind Pooling Compatibility ---
+if POOLING_MODE == 'blind':
+    if all_pooled_raw.ndim == 2:
+        # Expected input from chebnet_blind.py: (N_frames, final_pool_dim)
+        logging.info("Blind pooling mode: Reshaping 2D data (N, D) to 3D (N, 1, D).")
+        all_pooled_processed = all_pooled_raw.reshape(all_pooled_raw.shape[0], 1, all_pooled_raw.shape[1])
+    elif all_pooled_raw.ndim == 3 and all_pooled_raw.shape[1] == 1:
+        # Data is already in (N, 1, D) format
+        logging.info("Blind pooling mode: Data already has shape (N, 1, D).")
+        all_pooled_processed = all_pooled_raw
+    else:
+        logging.error(f"Blind pooling mode requires 2D (N, D) or 3D (N, 1, D) data, but got shape {all_pooled_raw.shape}")
+        exit(1)
+    # For blind pooling, we only care about the single "residue" at index 0
+    selected_residue_indices = [0]
+    logging.info(f"Using selected residue indices for blind pooling: {selected_residue_indices}")
+    # Extracting the data (shape N, 1, D)
+    data_to_process = all_pooled_processed[:, selected_residue_indices, :]
+
+elif POOLING_MODE == 'selected':
+     # Expects 3D input: (N, num_total_residues, D_per_residue)
+     if all_pooled_raw.ndim != 3:
+         logging.error(f"Selected pooling mode requires 3D data (N, num_residues, D), but got shape {all_pooled_raw.shape}")
+         exit(1)
+     all_pooled_processed = all_pooled_raw
+     selected_residue_indices = params.get('selected_residues', list(range(all_pooled_processed.shape[1]))) # Default to all if not specified
+     logging.info(f"Using selected residue indices for selected pooling: {selected_residue_indices}")
+     # Check if indices are valid
+     max_available_idx = all_pooled_processed.shape[1] - 1
+     if not all(0 <= idx <= max_available_idx for idx in selected_residue_indices):
+         logging.error(f"Invalid residue indices in 'selected_residues'. Max available index: {max_available_idx}, Got: {selected_residue_indices}")
+         exit(1)
+     # Extract the selected residues/segments (shape N, num_selected, D)
+     data_to_process = all_pooled_processed[:, selected_residue_indices, :]
+else:
+    logging.error(f"Unknown pooling mode: {POOLING_MODE}. Choose 'blind' or 'selected'.")
+    exit(1)
+
+
+logging.info(f"Data shape after residue selection: {data_to_process.shape}") # Shape (N, num_selected, D)
+N_samples = data_to_process.shape[0]
+num_selected_residues = data_to_process.shape[1]
+embedding_dim_per_residue = data_to_process.shape[2]
+
+# -----------------------------
+# Determine Model Input Shape and Prepare Final Data Tensor
+# -----------------------------
+# This depends on the model type used in the *current* experiment loop iteration
+# We prepare the base data here, final flattening/reshaping happens before training/sampling
+
+# For MLP models, we'll flatten the selected residue data later.
+# For Conv2D models, we need to reshape to (N, 1, H, W).
+# We store the base 3D selected data first.
+base_selected_data = data_to_process # Shape (N, num_selected_residues, embedding_dim_per_residue)
+
+# Calculate normalization stats on this base selected data
+data_mean = base_selected_data.mean()
+data_std = base_selected_data.std()
+logging.info(f"Normalization calculated on selected data: mean={data_mean:.6f}, std={data_std:.6f}")
+epsilon = 1e-9 # Avoid division by zero if std is very small
+normalized_base_data = (base_selected_data - data_mean) / (data_std + epsilon)
+
+# -----------------------------
+# Create Dataset
+# -----------------------------
+class EmbeddingDataset(Dataset):
+    def __init__(self, data_tensor):
+        # Expects data tensor shape (N, num_selected, D)
+        self.data = data_tensor.astype(np.float32)
+    def __len__(self):
+        return self.data.shape[0]
+    def __getitem__(self, idx):
+        # Return the data for one sample (shape num_selected, D)
+        return torch.from_numpy(self.data[idx])
+
+dataset_obj = EmbeddingDataset(normalized_base_data)
+dataloader = DataLoader(dataset_obj, batch_size=BATCH_SIZE, shuffle=True, num_workers=0, pin_memory=True) # Set num_workers=0 if issues arise
+logging.info(f"Created DataLoader with batch size {BATCH_SIZE}")
+
+# -----------------------------
+# Checkpoint helper functions
+# -----------------------------
+def save_checkpoint(state, filename):
+    """Saves checkpoint safely."""
+    try:
+        torch.save(state, filename)
+        logging.info(f"Checkpoint saved: {filename}")
+    except Exception as e:
+        logging.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model, optimizer, filename):
+    """Loads checkpoint if it exists."""
+    start_epoch = 0
+    if filename.is_file():
+        logging.info(f"Loading checkpoint: '{filename}'")
+        try:
+            checkpoint = torch.load(filename, map_location=DEVICE)
+            start_epoch = checkpoint.get('epoch', 0) # Default to 0 if epoch key missing
+            model.load_state_dict(checkpoint['model_state_dict'])
+            if optimizer:
+                 optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+            model.to(DEVICE) # Ensure model is on correct device after loading
+            logging.info(f"Checkpoint loaded successfully. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logging.error(f"Error loading checkpoint {filename}: {e}. Training from scratch.", exc_info=False)
+            start_epoch = 0 # Reset epoch if loading fails
+    else:
+        logging.info(f"No checkpoint found at '{filename}'. Training from scratch.")
+    return model, optimizer, start_epoch
+
+# -----------------------------
+# Diffusion Model Variants
+# -----------------------------
+# --- MLP Models ---
+class DiffusionMLPBase(nn.Module):
+    """Base class for MLP models to handle time embedding."""
+    def __init__(self):
+        super().__init__()
+
+    def _prepare_input(self, x, t):
+        # x shape: (B, FlatInputDim)
+        # t shape: (B,)
+        # Assumes current_diffusion_steps is globally available
+        t_norm = (t.float().unsqueeze(1) / current_diffusion_steps) # Shape (B, 1)
+        # Concatenate along the feature dimension
+        x_in = torch.cat([x, t_norm], dim=1) # Shape (B, FlatInputDim + 1)
+        return x_in
+
+class DiffusionMLP(DiffusionMLPBase):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim + 1, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, input_dim)
+        )
+    def forward(self, x, t): # x is expected to be flattened (B, D_flat)
+        x_in = self._prepare_input(x, t)
+        return self.net(x_in)
+
+class DiffusionMLP_v2(DiffusionMLPBase):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim + 1, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, input_dim)
+        )
+    def forward(self, x, t): # x is expected to be flattened (B, D_flat)
+        x_in = self._prepare_input(x, t)
+        return self.net(x_in)
+
+class DiffusionMLP_v3(DiffusionMLPBase):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim + 1, hidden_dim * 2)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.2)
+        self.fc2 = nn.Linear(hidden_dim * 2, hidden_dim * 2)
+        self.fc3 = nn.Linear(hidden_dim * 2, input_dim)
+    def forward(self, x, t): # x is expected to be flattened (B, D_flat)
+        x_in = self._prepare_input(x, t)
+        out = self.relu(self.fc1(x_in))
+        out = self.dropout(out)
+        out = self.relu(self.fc2(out))
+        out = self.dropout(out)
+        return self.fc3(out)
+
+# --- Conv2D Model ---
+class DiffusionConv2D(nn.Module):
+    """ Conv2D denoiser. Input x expected shape (B, 1, H, W). """
+    def __init__(self, input_channels=1, hidden_channels=64):
+        super().__init__()
+        # Input: (B, input_channels + 1, H, W) after time concat
+        self.conv1 = nn.Conv2d(input_channels + 1, hidden_channels, kernel_size=3, padding=1)
+        self.relu1 = nn.ReLU()
+        self.conv2 = nn.Conv2d(hidden_channels, hidden_channels, kernel_size=3, padding=1)
+        self.relu2 = nn.ReLU()
+        self.conv3 = nn.Conv2d(hidden_channels, input_channels, kernel_size=3, padding=1) # Output matches input channels
+
+    def forward(self, x, t):
+        # x shape: (B, C, H, W), C=input_channels (usually 1)
+        # t shape: (B,)
+        B, C, H_in, W_in = x.shape
+        # Assumes current_diffusion_steps is globally available
+        # Create time map (B, 1, H, W)
+        t_norm = (t.float().view(B, 1, 1, 1) / current_diffusion_steps)
+        t_map = t_norm.expand(B, 1, H_in, W_in) # Shape (B, 1, H, W)
+        # Concatenate input features and time map along channel dimension
+        x_in = torch.cat([x, t_map], dim=1) # Shape (B, C+1, H, W)
+
+        h = self.relu1(self.conv1(x_in))
+        h = self.relu2(self.conv2(h))
+        out = self.conv3(h) # Shape (B, C, H, W)
+        return out
+
+# -----------------------------
+# Forward diffusion process (q_sample)
+# -----------------------------
+def q_sample(x_0, t, noise=None):
+    """ Adds noise to data x_0 according to timestep t. """
+    if noise is None:
+        noise = torch.randn_like(x_0)
+
+    # Get precomputed schedule values for the batch of timesteps t
+    # Ensure shapes are broadcastable: (B,) -> (B, 1, ...)
+    batch_size = t.shape[0]
+    shape_suffix = (1,) * (x_0.dim() - 1) # e.g., (1,) for MLP, (1,1,1) for Conv2D
+    sqrt_alpha_cumprod_t = sqrt_alphas_cumprod[t].view(batch_size, *shape_suffix)
+    sqrt_one_minus_alpha_cumprod_t = sqrt_one_minus_alphas_cumprod[t].view(batch_size, *shape_suffix)
+
+    # Apply noise: x_t = sqrt(alpha_cumprod_t) * x_0 + sqrt(1 - alpha_cumprod_t) * noise
+    x_t = sqrt_alpha_cumprod_t * x_0 + sqrt_one_minus_alpha_cumprod_t * noise
+    return x_t
+
+# -----------------------------
+# Training loop function
+# -----------------------------
+def train_diffusion_model(model, model_type, dataloader, optimizer, num_epochs_target, checkpoint_path):
+    """ Trains the diffusion model. """
+    criterion = nn.MSELoss()
+    model.train()
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path)
+
+    logging.info(f"Starting training from epoch {start_epoch + 1} up to {num_epochs_target}...")
+
+    if start_epoch >= num_epochs_target:
+        logging.warning(f"Loaded checkpoint epoch ({start_epoch}) is >= target epochs ({num_epochs_target}). Skipping training.")
+        # Return last loss from checkpoint if available, else 0
+        # Note: Checkpoint format would need to include last loss for this.
+        # For simplicity, just return 0 or indicate skipped.
+        return 0.0 # Or None
+
+    # Determine input shape transformation needed based on model type
+    requires_flatten = model_type.startswith("mlp")
+    requires_conv2d_shape = model_type == "conv2d"
+
+    # --- Get H, W for Conv2D reshaping ---
+    conv2d_h, conv2d_w = -1, -1
+    if requires_conv2d_shape:
+        # If blind, use decoder2_settings; otherwise, use selected data shape
+        if POOLING_MODE == 'blind':
+            conv2d_h = DECODER2_SETTINGS.get('output_height')
+            conv2d_w = DECODER2_SETTINGS.get('output_width')
+            if not conv2d_h or not conv2d_w or (conv2d_h * conv2d_w != embedding_dim_per_residue):
+                 logging.error(f"Conv2D blind pooling shape mismatch: decoder2_settings ({conv2d_h}x{conv2d_w}) product != embedding dim ({embedding_dim_per_residue})")
+                 raise ValueError("Conv2D shape configuration error for blind pooling")
+        else: # 'selected' pooling
+            conv2d_h = num_selected_residues
+            conv2d_w = embedding_dim_per_residue
+        logging.info(f"Conv2D target input shape (H, W): ({conv2d_h}, {conv2d_w})")
+
+
+    last_epoch_loss = 0.0
+    for epoch in range(start_epoch, num_epochs_target):
+        epoch_loss = 0.0
+        num_batches = len(dataloader)
+        for i, batch_data_3d in enumerate(dataloader): # Data is (B, num_selected, D)
+            batch_data_3d = batch_data_3d.to(DEVICE)
+            B = batch_data_3d.shape[0]
+
+            # --- Reshape batch data based on model type ---
+            if requires_flatten:
+                # Flatten (B, num_selected, D) -> (B, num_selected * D)
+                x0 = batch_data_3d.view(B, -1)
+            elif requires_conv2d_shape:
+                # Reshape (B, num_selected, D) -> (B, 1, H, W)
+                # Note: num_selected = H, D = W for selected pooling
+                # Note: num_selected = 1, D = H*W for blind pooling (needs reshape inside)
+                if POOLING_MODE == 'blind':
+                    # (B, 1, D) -> (B, 1, H, W)
+                     x0 = batch_data_3d.view(B, 1, conv2d_h, conv2d_w)
+                else: # selected
+                     # (B, num_selected, D) -> (B, 1, num_selected, D)
+                     x0 = batch_data_3d.unsqueeze(1) # Add channel dim
+            else:
+                x0 = batch_data_3d # Should not happen with current models
+
+            # --- Forward diffusion and prediction ---
+            t = torch.randint(0, current_diffusion_steps, (B,), device=DEVICE).long()
+            noise = torch.randn_like(x0) # Noise matches shape of x0 (flattened or 4D)
+            x_t = q_sample(x0, t, noise=noise)
+            predicted_noise = model(x_t, t) # Model takes appropriate input shape
+
+            # --- Loss Calculation ---
+            loss = criterion(predicted_noise, noise) # Compare predicted noise to original noise
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+
+        avg_epoch_loss = epoch_loss / num_batches if num_batches > 0 else 0.0
+        last_epoch_loss = avg_epoch_loss # Store loss from the actual last epoch run
+
+        logging.debug(f"Epoch {epoch+1}/{num_epochs_target}, Avg Loss: {avg_epoch_loss:.6f}")
+        # Log less frequently at INFO level
+        if (epoch + 1) % (SAVE_INTERVAL // 10 if SAVE_INTERVAL > 10 else 1) == 0:
+             print(f"Epoch {epoch+1}/{num_epochs_target}, Avg Loss: {avg_epoch_loss:.6f}")
+
+        # Save checkpoint periodically and at the end
+        if (epoch + 1) % SAVE_INTERVAL == 0 or (epoch + 1) == num_epochs_target:
+            checkpoint_state = {
+                'epoch': epoch + 1, # Save completed epoch number
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'loss': avg_epoch_loss, # Save last avg loss
+                # Include relevant params for reproducibility?
+                'params': {k: v for k, v in current_exp_params.items() if isinstance(v, (int, float, str, bool))}
+            }
+            save_checkpoint(checkpoint_state, checkpoint_path)
+
+    logging.info(f"Training finished at epoch {num_epochs_target}. Final Avg Loss: {last_epoch_loss:.6f}")
+    return last_epoch_loss
+
+# -----------------------------
+# Reverse diffusion sampling (p_sample_loop)
+# -----------------------------
+@torch.no_grad()
+def p_sample_loop(model, shape_for_gen):
+    """ Generates samples starting from noise. """
+    logging.info(f"Starting sampling process for shape: {shape_for_gen}")
+    logging.info(f"Using {current_diffusion_steps} diffusion steps for sampling.")
+
+    B = shape_for_gen[0] # Number of samples to generate
+    # Start with random noise matching the target generation shape
+    x_t = torch.randn(shape_for_gen, device=DEVICE)
+
+    for t in reversed(range(current_diffusion_steps)):
+        # Create a batch of timesteps
+        t_batch = torch.full((B,), t, device=DEVICE, dtype=torch.long)
+
+        # Predict noise using the model
+        predicted_noise = model(x_t, t_batch)
+
+        # Get schedule constants for timestep t
+        beta_t = betas[t]
+        alpha_t = alphas[t]
+        alpha_cumprod_t = alphas_cumprod[t]
+        sqrt_one_minus_alpha_cumprod_t = sqrt_one_minus_alphas_cumprod[t]
+        sqrt_recip_alpha_t = torch.sqrt(1.0 / alpha_t) # 1 / sqrt(alpha_t)
+
+        # Calculate model mean using the DDPM formula:
+        # model_mean = (1/sqrt(alpha_t)) * (x_t - (beta_t / sqrt(1 - alpha_cumprod_t)) * predicted_noise)
+        # Ensure broadcasting works for different shapes (MLP vs Conv2D)
+        shape_suffix = (1,) * (x_t.dim() - 1)
+        model_mean = sqrt_recip_alpha_t * (x_t - (beta_t / sqrt_one_minus_alpha_cumprod_t) * predicted_noise)
+
+        # Add noise for steps t > 0
+        if t > 0:
+            noise = torch.randn_like(x_t)
+            # Variance is beta_t
+            # Posterior variance calculation can be more complex (e.g., using beta_tilde)
+            # Using beta_t is a simpler choice often used.
+            model_variance_sqrt = torch.sqrt(beta_t)
+            x_t = model_mean + model_variance_sqrt * noise
+        else:
+            # Final step t=0, output is the model mean
+            x_t = model_mean
+
+        if t % (current_diffusion_steps // 10) == 0:
+             logging.debug(f"Sampling step {t}/{current_diffusion_steps}")
+
+
+    logging.info("Sampling finished.")
+    # x_t at the end holds the generated samples x_0
+    return x_t
+
+# -----------------------------
+# Main Experiment Loop
+# -----------------------------
+experiment_results = []
+current_exp_params = {} # Global placeholder for current experiment params
+
+for loop_idx, exp_params in enumerate(experiments_to_run):
+    # Calculate the global experiment index (1-based)
+    global_exp_index = current_run_start_idx + loop_idx + 1
+    current_exp_params = exp_params # Store globally for checkpointing
+
+    logging.info(f"========== Starting Experiment {global_exp_index} ==========")
+    logging.info(f"Parameters: {exp_params}")
+    print(f"\n========== Experiment {global_exp_index} ==========")
+    print(f"Parameters: {exp_params}")
+
+    # Extract experiment-specific parameters
+    lr_exp = float(exp_params['learning_rate'])
+    hidden_dim_exp = int(exp_params['hidden_dim'])
+    model_type_exp = exp_params['model_type']
+    beta_start_exp = float(exp_params['beta_start'])
+    beta_end_exp = float(exp_params['beta_end'])
+    diffusion_steps_exp = int(exp_params['diffusion_steps'])
+
+    logging.info(f"Setting diffusion steps for this experiment: {diffusion_steps_exp}")
+    current_diffusion_steps = diffusion_steps_exp # Update global variable
+
+    # --- Compute Diffusion Schedule for this experiment ---
+    betas = linear_beta_schedule(diffusion_steps_exp, beta_start_exp, beta_end_exp)
+    alphas = torch.clamp(1.0 - betas, min=1e-9) # Prevent alpha=0
+    alphas_cumprod = torch.cumprod(alphas, dim=0)
+    # Ensure values don't become exactly 0 or 1 for numerical stability
+    alphas_cumprod = torch.clamp(alphas_cumprod, min=1e-9, max=1.0-1e-9)
+    sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod)
+    sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - alphas_cumprod)
+
+    # --- Determine Model Input Dimension based on Type ---
+    if model_type_exp.startswith("mlp"):
+        # MLP uses flattened input: num_selected_residues * embedding_dim_per_residue
+        model_input_dim = num_selected_residues * embedding_dim_per_residue
+        logging.info(f"MLP model type selected. Input dimension (flattened): {model_input_dim}")
+    elif model_type_exp == "conv2d":
+        # Conv2D uses (C, H, W). C=1 here.
+        # H, W depend on pooling mode.
+        if POOLING_MODE == 'blind':
+             conv2d_h = DECODER2_SETTINGS.get('output_height')
+             conv2d_w = DECODER2_SETTINGS.get('output_width')
+             if not conv2d_h or not conv2d_w:
+                  logging.error(f"Missing decoder2_settings for Conv2D blind pooling.")
+                  raise ValueError("Missing shape config for Conv2D blind")
+        else: # Selected pooling
+             conv2d_h = num_selected_residues
+             conv2d_w = embedding_dim_per_residue
+        model_input_dim = (1, conv2d_h, conv2d_w) # Store shape tuple
+        logging.info(f"Conv2D model type selected. Input shape (C, H, W): {model_input_dim}")
+    else:
+        logging.error(f"Unknown model type specified: {model_type_exp}")
+        raise ValueError(f"Unknown model type: {model_type_exp}")
+
+
+    # --- Instantiate Model ---
+    if model_type_exp == "mlp":
+        model_instance = DiffusionMLP(input_dim=model_input_dim, hidden_dim=hidden_dim_exp)
+    elif model_type_exp == "mlp_v2":
+        model_instance = DiffusionMLP_v2(input_dim=model_input_dim, hidden_dim=hidden_dim_exp)
+    elif model_type_exp == "mlp_v3":
+        model_instance = DiffusionMLP_v3(input_dim=model_input_dim, hidden_dim=hidden_dim_exp)
+    elif model_type_exp == "conv2d":
+        model_instance = DiffusionConv2D(input_channels=model_input_dim[0], # C=1
+                                         hidden_channels=params['conv2d_hidden_channels'])
+    else: # Should not happen due to earlier check
+         raise ValueError(f"Unhandled model type: {model_type_exp}")
+
+    model_instance = model_instance.to(DEVICE)
+    optimizer_instance = optim.Adam(model_instance.parameters(), lr=lr_exp)
+
+    # --- Train Model ---
+    checkpoint_filename = checkpoint_dir / f"diffusion_checkpoint_exp{global_exp_index}.pth"
+    logging.info(f"Starting training for Experiment {global_exp_index}...")
+    final_loss = train_diffusion_model(
+        model=model_instance,
+        model_type=model_type_exp,
+        dataloader=dataloader,
+        optimizer=optimizer_instance,
+        num_epochs_target=NUM_EPOCHS, # Use the potentially overridden value
+        checkpoint_path=checkpoint_filename
+    )
+    logging.info(f"Training completed for Experiment {global_exp_index}. Final Loss: {final_loss:.6f}")
+    print(f"Training completed for Experiment {global_exp_index}. Final Loss: {final_loss:.6f}")
+
+
+    # --- Generate Samples ---
+    model_instance.eval() # Set model to evaluation mode for sampling
+    # Determine the shape needed for generation based on model type
+    if model_type_exp.startswith("mlp"):
+        # MLP generates flattened data (NumGen, FlatDim)
+        shape_for_gen = (NUM_GENERATE, model_input_dim)
+    elif model_type_exp == "conv2d":
+        # Conv2D generates 4D data (NumGen, C, H, W)
+        shape_for_gen = (NUM_GENERATE,) + model_input_dim # e.g., (NumGen, 1, H, W)
+    else: # Should not happen
+         raise ValueError(f"Cannot determine generation shape for model type {model_type_exp}")
+
+    logging.info(f"Generating {NUM_GENERATE} samples with shape {shape_for_gen}...")
+    generated_samples_norm = p_sample_loop(model_instance, shape_for_gen) # Normalized samples
+    generated_samples_norm = generated_samples_norm.cpu().numpy()
+
+    # --- Un-normalize Samples ---
+    logging.info("Un-normalizing generated samples...")
+    generated_samples_unnorm = generated_samples_norm * (data_std + epsilon) + data_mean
+
+    # --- Reshape Output to Consistent Format ---
+    # Aim for final output shape: (N_gen, num_selected_residues, embedding_dim_per_residue)
+    logging.info("Reshaping generated samples to consistent output format...")
+    if model_type_exp.startswith("mlp"):
+        # Input was (N_gen, num_selected * D)
+        try:
+            final_generated_embeddings = generated_samples_unnorm.reshape(
+                NUM_GENERATE, num_selected_residues, embedding_dim_per_residue
+            )
+        except ValueError as e:
+             logging.error(f"Error reshaping MLP output: {e}. Expected product {num_selected_residues * embedding_dim_per_residue}, got {generated_samples_unnorm.shape[1]}")
+             # Fallback: save as is? Or skip saving?
+             final_generated_embeddings = generated_samples_unnorm # Save flattened
+    elif model_type_exp == "conv2d":
+        # Input was (N_gen, 1, H, W)
+        # We need to reshape back to (N_gen, H, W) if channel=1, then maybe further if blind
+        if generated_samples_unnorm.shape[1] == 1:
+             generated_hw = generated_samples_unnorm.squeeze(1) # Shape (N_gen, H, W)
+        else: # Should not happen if input_channels=1
+             generated_hw = generated_samples_unnorm
+             logging.warning("Conv2D output had more than 1 channel, using as is.")
+
+        # If pooling was blind, HxW = D, need (N_gen, 1, D)
+        # If pooling was selected, H = num_selected, W = D, need (N_gen, num_selected, D)
+        if POOLING_MODE == 'blind':
+             # Reshape (N_gen, H, W) -> (N_gen, 1, H*W=D)
+             final_generated_embeddings = generated_hw.reshape(NUM_GENERATE, 1, -1)
+        else: # Selected pooling, generated_hw is already (N_gen, H=num_selected, W=D)
+             final_generated_embeddings = generated_hw
+    else: # Should not happen
+         final_generated_embeddings = generated_samples_unnorm # Save as is
+
+    logging.info(f"Final generated embeddings shape for saving: {final_generated_embeddings.shape}")
+    logging.info(f"Example generated sample (unnormalized, reshaped): {final_generated_embeddings[0,:,:]}")
+
+
+    # --- Save Generated Samples to HDF5 ---
+    save_path = OUTPUT_DIR / f"generated_embeddings_exp{global_exp_index}.h5"
+    try:
+        with h5py.File(save_path, 'w') as f:
+            dset = f.create_dataset('generated_embeddings', data=final_generated_embeddings)
+            # Add metadata attributes
+            dset.attrs['experiment_index'] = global_exp_index
+            dset.attrs['model_type'] = model_type_exp
+            dset.attrs['diffusion_steps'] = diffusion_steps_exp
+            dset.attrs['beta_start'] = beta_start_exp
+            dset.attrs['beta_end'] = beta_end_exp
+            dset.attrs['pooling_mode'] = POOLING_MODE
+            dset.attrs['source_h5_file'] = str(H5_FILE_PATH)
+            dset.attrs['source_dataset_key'] = DATASET_KEY
+            # Add selected residues if not blind
+            if POOLING_MODE != 'blind':
+                 dset.attrs['selected_residues'] = np.array(selected_residue_indices)
+
+        logging.info(f"Saved {NUM_GENERATE} generated embeddings to: {save_path}")
+        print(f"Saved generated embeddings to: {save_path}")
+    except Exception as e:
+        logging.error(f"Failed to save generated embeddings to {save_path}: {e}")
+
+    experiment_results.append({
+        'exp_idx': global_exp_index,
+        'params': exp_params,
+        'final_loss': final_loss,
+        'checkpoint_path': str(checkpoint_filename),
+        'save_path': str(save_path)
+    })
+    logging.info(f"========== Finished Experiment {global_exp_index} ==========")
+
+
+# -----------------------------
+# Final Summary
+# -----------------------------
+logging.info("All specified experiments completed.")
+print("\n========== Run Summary ==========")
+for result in experiment_results:
+    print(f"Exp {result['exp_idx']}: Loss={result.get('final_loss', 'N/A'):.6f}, Output='{result.get('save_path', 'N/A')}'")
+    logging.info(f"Summary - Exp {result['exp_idx']}: Loss={result.get('final_loss', 'N/A'):.6f}, Output='{result.get('save_path', 'N/A')}'")
+logging.info("Diffusion Runner Script Finished")

LD-FPG-main/blind/param.yaml

@@ -0,0 +1,63 @@
+# General Settings
+log_file: "logfile_script2_mod.log" # Log file name
+num_workers: 0                     # Number of workers for DataLoader
+force_cpu: false                   # Set to true to force CPU usage
+cuda_device: 0                     # GPU index if CUDA is available and force_cpu is false
+
+# Data Input Configuration
+data:
+  json_path: "../../../my_protein.json" # Path to multi-frame coordinate data
+  pdb_path: "heavy_chain.pdb"           # Path to reference PDB for atom indexing
+
+# Graph Construction Settings
+graph:
+  knn_value: 4                         # K for k-NN graph construction
+
+# HNO Encoder Configuration
+hno_encoder:
+  hidden_dim: 8                        # Hidden dimension for HNO GNN layers
+  cheb_order: 4                        # Chebyshev polynomial order for ChebConv
+  num_epochs: 4000                     # Number of training epochs for HNO
+  learning_rate: 0.0001                # Learning rate for HNO training
+  batch_size: 16                       # Batch size for HNO training
+  save_interval: 500                   # Save checkpoint every N epochs (e.g., 500)
+
+# Decoder2 Training Configuration
+decoder2:
+  num_epochs: 10                     # Number of training epochs for Decoder2
+  learning_rate: 0.0003                # Learning rate for Decoder2 training
+  batch_size: 16                       # Batch size for Decoder2 training
+  base_loss_weight: 1.0                # Multiplier for the base coordinate MSE loss
+  save_interval: 500                   # Save checkpoint every N epochs (e.g., 500)
+
+# Decoder2 Architecture Settings
+decoder2_settings:
+  conditioner_mode: "z_ref"            # Conditioner type: 'X_ref' (coords) or 'z_ref' (embedding)
+  pooling_type: "blind"                # Pooling strategy: 'blind' or 'residue'
+  output_height: 50                    # Target height for AdaptiveAvgPool2d in primary pooling
+  output_width: 2                      # Target width for AdaptiveAvgPool2d in primary pooling
+  mlp_hidden_dim: 128                  # <<< NEW: Hidden dimension for the Decoder2 MLP layers (Example value)
+  num_hidden_layers: 12                # Number of layers in the final Decoder2 MLP
+
+  # Optional advanced features (from original script 2) - Configure as needed
+  use_second_level_pooling: false      # Enable pooling across segment embeddings
+  output_height2: 100                  # Target height for secondary pooling (if enabled)
+  output_width2: 20                    # Target width for secondary pooling (if enabled)
+  use_cross_attention: false           # Enable cross-attention mechanism (if implemented)
+  cross_attention_type: "residue"      # Type of cross-attention ('global', 'residue', if enabled)
+
+# Dihedral Loss Configuration (NEW SECTION)
+dihedral_loss:
+  use_dihedral_loss: true              # <<< NEW: Set true to enable dihedral loss, false to disable
+  torsion_info_path: condensed_residues.json   # <<< NEW: Path to JSON defining dihedral atoms/indices
+  lambda_divergence: 0.1               # <<< NEW: Weight for the divergence term (KL/JS/Wass)
+  lambda_torsion_mse: 1.0              # <<< NEW: Weight for the torsion angle MSE term
+  divergence_type: "JS"                # <<< NEW: Type of divergence ("KL", "JS", "WASSERSTEIN")
+
+# Output Directories Configuration
+output_directories:
+  checkpoint_dir: "checkpoints"        # Directory for saving model checkpoints
+  structure_dir: "structures"         # Directory for coordinate outputs (.h5, .pt)
+  latent_dir: "latent_reps"           # Directory for embedding/latent outputs (.h5, .pt)
+
+# Note: 'recon_output' parameter from the old file was removed as it wasn't used in the scripts provided.

LD-FPG-main/blind/param_diff.yaml

@@ -0,0 +1,42 @@
+run_mode: grid_search
+
+parameters:
+  batch_size: 64
+  num_epochs: 50
+  learning_rate: 1e-5
+  num_gen: 5000
+  save_interval: 50
+  pooling: blind
+
+  # Legacy arrays (not used in curated grid)
+  hidden_dim_options: [128, 256, 512, 1024]
+  model_type_options: ["mlp", "mlp_v2", "mlp_v3"]
+  beta_start_options: [5e-6, 0.005]
+  beta_end_options: [0.03, 0.1]
+  diffusion_steps_options: [1400, 500]
+  scheduler_options: ["linear"]
+
+  # Fallback user-defined parameters (if run_mode = user_defined)
+  hidden_dim: 1024
+  model_type: "mlp_v2"
+  beta_start: 5e-6
+  beta_end: 0.03
+  diffusion_steps: 1400
+
+  # Number of parallel instances to partition the curated experiments among.
+  num_instances: 3
+
+  # Data paths:
+  h5_file_path: "latent_reps/pooled_embedding.h5"
+  dataset_key: "pooled_embedding"
+  output_dir: "latent_reps"
+
+  # Decoder2 settings (for shaping conv2d inputs if 'blind' pooling)
+  decoder2_settings:
+    output_height: 50
+    output_width: 2
+
+# Optional: Specify which residues to extract (default is [1, 2, 3, 4, 5] if not provided)
+#selected_residues: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
+#selected_residues: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129]
+selected_residues: [0, 1, 2, 3, 4, 5]

LD-FPG-main/blind/trial/chebnet_multi.py

@@ -0,0 +1,818 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from typing import Dict, List, Optional, Tuple, Any
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv, global_mean_pool
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import NearestNeighbors # New dependency
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load
+################################################################################
+LOG_FILE_DEFAULT = "logfile_multi_system.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstruction")
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+if not logger.handlers:
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    try:
+        fh = logging.FileHandler(log_file_path, mode="w")
+        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+    except IOError as e:
+        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+logger.info(f"Logger initialized. Log file: {log_file_path}")
+if args.debug: logger.debug("Debug mode is ON.")
+
+################################################################################
+# (D) Device Setup (Global)
+################################################################################
+device_name = "cpu"
+if torch.cuda.is_available():
+    try:
+        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
+        device_name = f"cuda:{cuda_device_index}"
+        torch.cuda.get_device_name(cuda_device_index)
+    except Exception:
+        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
+        if torch.cuda.is_available(): device_name = "cuda:0"
+global_device = torch.device(device_name)
+logger.info(f"Initial device check: {global_device}")
+
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+# --- PDB Parsing ---
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
+    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line in pdb_file:
+                if not line.startswith("ATOM  "): continue
+                alt_loc = line[16].strip()
+                if alt_loc not in ['', 'A']: continue
+
+                atom_serial = int(line[6:11])
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+
+                atom_name = line[12:16].strip()
+                res_name = line[17:20].strip()
+                chain_id = line[21].strip()
+                res_seq = int(line[22:26])
+                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+
+                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
+                if atom_name == 'CA': ca_indices[res_seq] = atom_serial
+
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
+    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
+    return {}, atoms_in_order, ca_indices
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int]]:
+    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
+    new_res_dict, orig_atom_map = {}, {}
+    next_new_res_id, next_new_atom_index = 0, 0
+    orig_res_map = {}
+    
+    # Preserve original residue order
+    seen_res_order = {}
+    res_order_counter = 0
+    for r_id, _, _, _ in atoms_in_order:
+        if r_id not in seen_res_order:
+            seen_res_order[r_id] = res_order_counter
+            res_order_counter += 1
+
+    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
+    sortable.sort()
+
+    for _, serial, r_id, cat, name in sortable:
+        if r_id not in orig_res_map:
+            orig_res_map[r_id] = next_new_res_id
+            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
+            next_new_res_id += 1
+        
+        new_res_id = orig_res_map[r_id]
+        new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index
+        next_new_atom_index += 1
+
+    # Map original CA serial numbers to the new, renumbered 0-based indices
+    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
+    
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
+    return new_res_dict, orig_atom_map, {}, new_ca_indices
+
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()):
+        bb_idx.extend(renumbered_dict[res_id]["backbone"])
+        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)
+
+# --- JSON Loading ---
+# This function is unchanged and should work fine.
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
+    
+    try:
+        keys_int = sorted([int(k) for k in data.keys()])
+        keys_str = [str(k) for k in keys_int]
+        if not keys_str: logger.error("No residue data in JSON."); return [], -1
+        
+        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
+        n_frames = len(frame_data)
+        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0
+
+        coords_frames, n_atoms_check = [], -1
+        for frame_idx in range(n_frames):
+            frame_coords_np = []
+            current_atoms = 0
+            for res_key in keys_str:
+                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
+                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
+                frame_coords_np.append(coords)
+                current_atoms += coords.shape[0]
+
+            if frame_idx == 0:
+                n_atoms_check = current_atoms
+                logger.info(f"System has {n_atoms_check} atoms and {n_frames} frames.")
+            elif current_atoms != n_atoms_check:
+                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
+            
+            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))
+
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1
+
+# --- Alignment ---
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Aligns Q onto P using Kabsch algorithm. Handles batches [B, N, 3]."""
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
+    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try: V, S, Wt = torch.linalg.svd(C)
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
+        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
+        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
+        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
+    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
+    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
+    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    if not coords: logger.warning("Coordinate list empty."); return []
+    ref = coords[0].to(device)
+    aligned = [coords[0].cpu()]
+    n_frames = len(coords) -1
+    for i, frame in enumerate(coords[1:], 1):
+        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
+        aligned.append(aligned_dev.cpu())
+    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
+    return aligned
+
+# --- NEW ALIGNMENT UTILITIES for MULTI-SYSTEM ---
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
+    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
+    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
+        raise ValueError("Input coordinates must be 2D arrays.")
+
+    # Find nearest neighbor from target for each ref point
+    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
+    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
+    
+    # Find nearest neighbor from ref for each target point
+    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
+    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
+    
+    # Identify mutual pairs
+    ref_indices, target_indices = [], []
+    for i, target_idx in enumerate(indices1.flatten()):
+        if indices2[target_idx] == i:
+            ref_indices.append(i)
+            target_indices.append(target_idx)
+            
+    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
+    if not ref_indices:
+        logger.error("No mutual nearest neighbors found. Cannot align structures.")
+        return torch.tensor([]), torch.tensor([])
+        
+    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)
+
+def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
+                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
+                  logger: logging.Logger) -> torch.Tensor:
+    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
+    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
+    device = structure_to_align.device
+
+    # 1. Select the coordinates of the core atoms for both structures
+    P_core = reference_structure[core_indices_reference].to(device)
+    Q_core = structure_to_align[core_indices_to_align].to(device)
+    
+    # 2. Compute the rotation matrix (U) using only the core
+    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
+    
+    # 3. Center the full structure_to_align on its core's centroid
+    centroid_Q_core = compute_centroid(Q_core)
+    structure_to_align_centered = structure_to_align - centroid_Q_core
+    
+    # 4. Rotate the full centered structure
+    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
+    
+    # 5. Translate the rotated structure to the reference core's centroid
+    centroid_P_core = compute_centroid(P_core)
+    aligned_structure = structure_to_align_rotated + centroid_P_core
+    
+    return aligned_structure
+
+# --- Graph Dataset ---
+# Unchanged
+def build_graph_dataset(coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
+    dataset = []
+    n_frames = len(coords_list)
+    for i, coords_cpu in enumerate(coords_list):
+        coords_dev = coords_cpu.to(device)
+        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
+        data = Data(x=coords_cpu, edge_index=edge_idx.cpu(), y=coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
+        dataset.append(data)
+    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
+    return dataset
+
+# --- Dihedral Utilities ---
+# Unchanged
+@torch.jit.script
+def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
+    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
+    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
+    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
+    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)
+
+def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
+    """Computes all specified dihedrals vectorially."""
+    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
+    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
+    for name, angle_info in info.items():
+        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
+        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
+        if indices is not None and res_idx is not None and indices[0].numel() > 0:
+            try:
+                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
+                max_atom_idx_needed = max(i.max() for i in idx_dev)
+                if max_atom_idx_needed >= N_atoms:
+                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
+                    continue
+                
+                a,b,c,d = (coords[:, i, :] for i in idx_dev)
+                values = compute_dihedral(a,b,c,d)
+                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
+            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
+        all_angles[name] = angles_out
+    return all_angles
+
+
+def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
+    eps=1e-10
+    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
+    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
+    p_dist = p_hist / (p_hist.sum() + eps)
+    t_dist = t_hist / (t_hist.sum() + eps)
+    m_dist = 0.5 * (p_dist + t_dist)
+    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))
+
+# --- Checkpoint Utilities & MSE Utilities ---
+# Unchanged
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device)
+            start_epoch = ckpt.get("epoch", 0)
+            model.load_state_dict(ckpt["model_state_dict"])
+            if optimizer and "optimizer_state_dict" in ckpt:
+                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+                for state in optimizer.state.values():
+                    for k, v in state.items():
+                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
+            model.to(device)
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
+            start_epoch = 0
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
+    model.to(device)
+    return model, optimizer, start_epoch
+
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    crit = nn.MSELoss()
+    all_mse = crit(pred, target)
+    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    return all_mse, bb_mse, sc_mse
+
+
+################################################################################
+# (F) Model Definitions
+################################################################################
+
+# --- HNO Encoder ---
+# NOTE: This model is already size-agnostic. The ChebConv and final Linear layers
+# operate on a per-node basis, so it handles graphs of different sizes correctly.
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged = False
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head
+
+    def forward(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        x_rep = F.normalize(x, p=2.0, dim=1)
+        x_recon = self.mlpRep(x_rep)
+        
+        if self.training is False and not self._debug_logged:
+             logger.debug(f"[HNO] Forward pass shapes: In={x.shape}, Rep={x_rep.shape}, Recon={x_recon.shape}")
+             self._debug_logged = True
+        return x_recon
+
+    def forward_representation(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        return F.normalize(x, p=2.0, dim=1)
+
+# --- REFACTORED Decoder2 Model ---
+class ProteinStateReconstructor2D(nn.Module):
+    """
+    Size-agnostic decoder. Predicts full coordinates from node embeddings.
+    It combines local (per-node) and global (per-graph) information.
+    """
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int, mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        self._logged_fwd = False
+        
+        # The input to the final MLP for each node will be:
+        # [local_node_embedding, global_graph_embedding, global_conditioner_embedding]
+        mlp_in_dim = node_emb_dim + node_emb_dim + cond_emb_dim
+        
+        # Simple MLP decoder
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+        
+        self.logger.info(f"Initialized Size-Agnostic Decoder2 with MLP input dim: {mlp_in_dim}")
+
+    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x (Tensor): Per-node embeddings from HNO [N_total_nodes, E_node]
+            batch (Tensor): PyG batch vector [N_total_nodes]
+            conditioner_z_ref (Tensor): Per-node reference embeddings [N_total_nodes, E_cond]
+        """
+        # 1. Get global embedding for the current conformation
+        z_global = global_mean_pool(x, batch) # -> [B, E_node]
+        z_global_per_node = z_global[batch] # Broadcast to each node -> [N_total_nodes, E_node]
+
+        # 2. Get global embedding for the conditioner
+        conditioner_global = global_mean_pool(conditioner_z_ref, batch) # -> [B, E_cond]
+        conditioner_global_per_node = conditioner_global[batch] # -> [N_total_nodes, E_cond]
+        
+        # 3. Assemble the feature vector for each node
+        mlp_input = torch.cat([x, z_global_per_node, conditioner_global_per_node], dim=1)
+        
+        # 4. Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+        
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Dec2 Fwd] Shapes: In x={x.shape}, z_global={z_global.shape}, cond_global={conditioner_global.shape}, mlp_in={mlp_input.shape}, Out={pred_coords.shape}")
+            self._logged_fwd = True
+            
+        return pred_coords
+
+################################################################################
+# (G) Training Functions
+################################################################################
+
+# --- Train HNO ---
+# This function requires minimal changes as the model is size-agnostic
+def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev)
+    params = list(filter(lambda p: p.requires_grad, model.parameters()))
+    opt = torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+    
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+
+    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        total_loss = 0.0
+        for data in tr_loader:
+            data=data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            pred = model(data.x, data.edge_index)
+            loss = F.mse_loss(pred, data.y)
+            loss.backward()
+            opt.step()
+            total_loss += loss.item()
+        avg_tr_loss = total_loss / len(tr_loader)
+        
+        model.eval()
+        total_val_loss = 0.0
+        with torch.no_grad():
+            for data in te_loader:
+                data=data.to(dev)
+                pred=model(data.x, data.edge_index)
+                total_val_loss += F.mse_loss(pred, data.y).item()
+        avg_te_loss = total_val_loss / len(te_loader)
+
+        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+    
+    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
+    return model
+
+# --- REFACTORED Train Decoder2 ---
+def train_decoder2_model(
+    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
+    all_conditioners: Dict[int, torch.Tensor], # Dict of z_ref tensors
+    all_sys_info: Dict[int, Any], # Dict containing bb_idx, sc_idx, n_res etc. for each system
+    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
+    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
+):
+    model = model.to(dev)
+    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+        
+    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
+    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")
+
+    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
+        
+        for data in tr_loader:
+            data = data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            
+            # --- Assemble Batch-Specific Conditioners and Indices ---
+            # This is the core logic for handling heterogeneous batches
+            unique_sys_ids = torch.unique(data.system_id)
+            
+            # Create the conditioner tensor for this specific batch
+            # Note: This could be optimized, but is clear for debugging
+            cond_list = []
+            for i in range(data.num_graphs):
+                sid = data.system_id[i].item()
+                num_nodes = data.ptr[i+1] - data.ptr[i]
+                cond = all_conditioners[sid].to(dev)
+                if cond.shape[0] != num_nodes: # This check is important!
+                    logger.error(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
+                    # This should not happen if data prep is correct.
+                    # As a fallback, we must skip or resize. For now, let's assume it matches.
+                cond_list.append(cond)
+            conditioners_for_batch = torch.cat(cond_list, dim=0)
+
+            # --- Forward and Coordinate Loss ---
+            pred = model(data.x, data.batch, conditioners_for_batch)
+            total_loss = 0.0
+            coord_loss = 0.0
+
+            # Calculate coordinate MSE loss per system in the batch
+            for sid_tensor in unique_sys_ids:
+                sid = sid_tensor.item()
+                mask = (data.system_id[data.batch] == sid)
+                
+                bb_idx = all_sys_info[sid]['bb_idx_local'] # Use local indices
+                sc_idx = all_sys_info[sid]['sc_idx_local']
+                
+                pred_sys = pred[mask]
+                target_sys = data.y[mask]
+                
+                sys_mse, _, _ = compute_bb_sc_mse(pred_sys, target_sys, bb_idx, sc_idx, logger)
+                coord_loss += sys_mse
+
+            total_loss += base_w * coord_loss
+            tr_metrics['coord'] += coord_loss.item()
+            
+            # --- Dihedral Loss ---
+            di_div_loss = torch.tensor(0.0, device=dev)
+            di_mse_loss = torch.tensor(0.0, device=dev)
+            if use_di and all_di_info:
+                for sid_tensor in unique_sys_ids:
+                    sid = sid_tensor.item()
+                    mask = (data.system_id[data.batch] == sid)
+                    
+                    pred_sys_3d = pred[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
+                    true_sys_3d = data.y[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
+                    
+                    pred_a = compute_all_dihedrals_vectorized(pred_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    true_a = compute_all_dihedrals_vectorized(true_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+
+                    for name in pred_a:
+                        pa, ta = pred_a[name], true_a[name]
+                        if pa.numel() > 0:
+                             di_div_loss += comp_div(pa, ta)
+                             di_mse_loss += F.mse_loss(pa, ta)
+                
+                total_loss += l_div * di_div_loss + l_mse * di_mse_loss
+                tr_metrics['di_div'] += di_div_loss.item()
+                tr_metrics['di_mse'] += di_mse_loss.item()
+
+            tr_metrics['total'] += total_loss.item()
+            total_loss.backward()
+            opt.step()
+        
+        # Log training stats (validation loop omitted for brevity but should be added)
+        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
+        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+            
+    logger.info("Finished Decoder2 training.")
+    return model
+
+
+################################################################################
+# (I) Main Execution Function
+################################################################################
+def main():
+    start_time = time.time()
+    logger.info("================ Script Starting (Multi-System Version) ================")
+    global global_device
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    logger.info("Successfully loaded configuration.")
+    
+    # --- Extract Parameters ---
+    force_cpu = config.get("force_cpu", False)
+    device = torch.device("cpu") if force_cpu else global_device
+    pin_mem = (device.type == "cuda")
+    num_workers = config.get("num_workers", 0)
+    
+    hno_cfg = config["hno_encoder"]
+    dec2_cfg = config["decoder2"]
+    d2s = config["decoder2_settings"]
+    di_cfg = config.get("dihedral_loss", {})
+    out_cfg = config["output_directories"]
+    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]
+
+    # --- Stage 1: Multi-System Data Loading & Alignment ---
+    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
+    
+    full_dset = []
+    all_sys_info = {} # Will store n_atoms, n_res, ca_indices, bb_idx etc. for each system
+    canonical_ref_coords = None
+    canonical_ref_ca_indices = None
+
+    # Loop through each system defined in the config
+    for i, system_config in enumerate(config["data"]["systems"]):
+        sid = i
+        pdb_p = system_config["pdb_path"]
+        json_p = system_config["json_path"]
+        logger.info(f"--- Processing System ID {sid}: {os.path.basename(pdb_p)} ---")
+
+        # 1. Parse PDB for topology and C-alpha indices
+        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
+        renum_d, _, _, ca_indices_new = renumber_atoms_and_residues(atoms_ord, ca_serial_map)
+        bb_idx, sc_idx = get_global_indices(renum_d)
+        
+        # 2. Load coordinates from JSON
+        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger)
+        if not coords_list: continue # Skip if system loading failed
+
+        all_sys_info[sid] = {
+            'n_atoms': n_atoms,
+            'ca_indices': ca_indices_new,
+            'bb_idx_local': bb_idx, # These are local to the system
+            'sc_idx_local': sc_idx,
+            'n_res': len(renum_d)
+        }
+
+        # 3. Perform Alignment
+        aligned_coords_list = []
+        if sid == 0:
+            # This is the canonical reference system
+            logger.info(f"System {sid} is the canonical reference.")
+            canonical_ref_coords = coords_list[0].clone()
+            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
+        else:
+            # Align this system to the canonical reference
+            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
+            target_ref_coords = coords_list[0]
+            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            
+            # Find core pairs for alignment
+            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
+                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
+                target_ref_coords[target_ca_indices].numpy(),
+                logger
+            )
+            
+            # Align the first frame of this system to the canonical reference
+            aligned_target_ref_frame = align_by_core(
+                target_ref_coords, target_ca_indices[core_target_idx],
+                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
+                logger
+            ).to(device)
+            
+            # Align the rest of this system's trajectory to its own aligned reference frame
+            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
+            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)
+
+        # 4. Build graph dataset for this system and add to the master list
+        system_dset = build_graph_dataset(aligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
+        full_dset.extend(system_dset)
+
+    logger.info(f"--- Finished data loading. Total frames in dataset: {len(full_dset)} ---")
+
+    # --- Stage 2: HNO Training ---
+    logger.info("--- Stage 2: Training Shared HNO Encoder ---")
+    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
+    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
+    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
+    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
+    hno_model.eval()
+
+    # --- Stage 3: Decoder Input Data Prep ---
+    logger.info("--- Stage 3: Preparing Decoder Input Dataset & Conditioners ---")
+    dec_in_dset = []
+    all_conditioners = {} # Dictionary to hold the z_ref for each system
+    
+    # Generate embeddings for the whole dataset
+    with torch.no_grad():
+        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
+        for batch in infer_load:
+            batch = batch.to(device)
+            emb = hno_model.forward_representation(batch.x, batch.edge_index)
+            # De-batch to create new Data objects
+            split_sizes = (batch.ptr[1:] - batch.ptr[:-1]).tolist()
+            emb_list = torch.split(emb, split_sizes)
+            y_list = torch.split(batch.y, split_sizes)
+            
+            for i in range(len(emb_list)):
+                dec_in_dset.append(Data(x=emb_list[i].cpu(), y=y_list[i].cpu(), system_id=batch.system_id[i].cpu().reshape(1)))
+    
+    # Create the conditioner dictionary
+    if d2s['conditioner_mode'] == 'z_ref':
+        for sid in all_sys_info.keys():
+            # Find the first frame of the system in the original dataset to get its reference coords
+            ref_data_orig = next(d for d in full_dset if d.system_id.item() == sid)
+            ref_data_orig = ref_data_orig.to(device)
+            with torch.no_grad():
+                z_ref = hno_model.forward_representation(ref_data_orig.x, ref_data_orig.edge_index)
+                all_conditioners[sid] = z_ref.cpu() # Store on CPU
+        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
+    else:
+        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")
+
+    # --- Stage 4: Decoder Setup & Training ---
+    logger.info("--- Stage 4: Decoder2 Setup & Training ---")
+    
+    # Prepare Dihedral Info Dictionaries
+    all_di_info = {}
+    use_di_train = di_cfg.get("use_dihedral_loss", False)
+    if use_di_train:
+        logger.info("Preparing dihedral information for all systems...")
+        for i, system_config in enumerate(config["data"]["systems"]):
+            sid = i
+            torsion_p = system_config.get("torsion_info_path")
+            if not torsion_p or not os.path.isfile(torsion_p):
+                logger.warning(f"Torsion file not found for system {sid}. Disabling dihedral loss for this system.")
+                continue
+            
+            with open(torsion_p, "r") as f: t_info = json.load(f)
+            # Simplified parsing logic, assuming it's correct per system
+            di_info_sys = {} # ... parsing logic to fill this based on t_info ...
+            all_di_info[sid] = di_info_sys
+        if not all_di_info: use_di_train = False # Disable if no files were loaded
+    
+    # Initialize and Train Decoder
+    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
+    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    
+    dec2_model = ProteinStateReconstructor2D(
+        node_emb_dim=hno_cfg['hidden_dim'],
+        cond_emb_dim=hno_cfg['hidden_dim'], # since we use z_ref
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    )
+    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
+    dec2_model = train_decoder2_model(
+        dec2_model, load_tr_dec, load_te_dec, all_conditioners, all_sys_info,
+        dec2_cfg['num_epochs'], dec2_cfg['learning_rate'], dec2_ckpt, dec2_cfg['save_interval'], device, logger,
+        dec2_cfg['base_loss_weight'], use_di_train, all_di_info,
+        di_cfg.get('divergence_type', 'JS'), di_cfg.get('lambda_divergence', 0.0), di_cfg.get('lambda_torsion_mse', 0.0)
+    )
+
+    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")
+
+################################################################################
+# (J) Script Entry Point
+################################################################################
+if __name__ == "__main__":
+    main()

LD-FPG-main/blind/trial/readme.md

@@ -0,0 +1 @@
+dd

LD-FPG-main/chebnet_multi.py

@@ -0,0 +1,818 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from typing import Dict, List, Optional, Tuple, Any
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv, global_mean_pool
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import NearestNeighbors # New dependency
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load
+################################################################################
+LOG_FILE_DEFAULT = "logfile_multi_system.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstruction")
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+if not logger.handlers:
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    try:
+        fh = logging.FileHandler(log_file_path, mode="w")
+        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+    except IOError as e:
+        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+logger.info(f"Logger initialized. Log file: {log_file_path}")
+if args.debug: logger.debug("Debug mode is ON.")
+
+################################################################################
+# (D) Device Setup (Global)
+################################################################################
+device_name = "cpu"
+if torch.cuda.is_available():
+    try:
+        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
+        device_name = f"cuda:{cuda_device_index}"
+        torch.cuda.get_device_name(cuda_device_index)
+    except Exception:
+        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
+        if torch.cuda.is_available(): device_name = "cuda:0"
+global_device = torch.device(device_name)
+logger.info(f"Initial device check: {global_device}")
+
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+# --- PDB Parsing ---
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
+    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line in pdb_file:
+                if not line.startswith("ATOM  "): continue
+                alt_loc = line[16].strip()
+                if alt_loc not in ['', 'A']: continue
+
+                atom_serial = int(line[6:11])
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+
+                atom_name = line[12:16].strip()
+                res_name = line[17:20].strip()
+                chain_id = line[21].strip()
+                res_seq = int(line[22:26])
+                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+
+                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
+                if atom_name == 'CA': ca_indices[res_seq] = atom_serial
+
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
+    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
+    return {}, atoms_in_order, ca_indices
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int]]:
+    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
+    new_res_dict, orig_atom_map = {}, {}
+    next_new_res_id, next_new_atom_index = 0, 0
+    orig_res_map = {}
+    
+    # Preserve original residue order
+    seen_res_order = {}
+    res_order_counter = 0
+    for r_id, _, _, _ in atoms_in_order:
+        if r_id not in seen_res_order:
+            seen_res_order[r_id] = res_order_counter
+            res_order_counter += 1
+
+    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
+    sortable.sort()
+
+    for _, serial, r_id, cat, name in sortable:
+        if r_id not in orig_res_map:
+            orig_res_map[r_id] = next_new_res_id
+            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
+            next_new_res_id += 1
+        
+        new_res_id = orig_res_map[r_id]
+        new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index
+        next_new_atom_index += 1
+
+    # Map original CA serial numbers to the new, renumbered 0-based indices
+    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
+    
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
+    return new_res_dict, orig_atom_map, {}, new_ca_indices
+
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()):
+        bb_idx.extend(renumbered_dict[res_id]["backbone"])
+        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)
+
+# --- JSON Loading ---
+# This function is unchanged and should work fine.
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
+    
+    try:
+        keys_int = sorted([int(k) for k in data.keys()])
+        keys_str = [str(k) for k in keys_int]
+        if not keys_str: logger.error("No residue data in JSON."); return [], -1
+        
+        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
+        n_frames = len(frame_data)
+        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0
+
+        coords_frames, n_atoms_check = [], -1
+        for frame_idx in range(n_frames):
+            frame_coords_np = []
+            current_atoms = 0
+            for res_key in keys_str:
+                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
+                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
+                frame_coords_np.append(coords)
+                current_atoms += coords.shape[0]
+
+            if frame_idx == 0:
+                n_atoms_check = current_atoms
+                logger.info(f"System has {n_atoms_check} atoms and {n_frames} frames.")
+            elif current_atoms != n_atoms_check:
+                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
+            
+            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))
+
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1
+
+# --- Alignment ---
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Aligns Q onto P using Kabsch algorithm. Handles batches [B, N, 3]."""
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
+    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try: V, S, Wt = torch.linalg.svd(C)
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
+        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
+        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
+        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
+    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
+    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
+    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    if not coords: logger.warning("Coordinate list empty."); return []
+    ref = coords[0].to(device)
+    aligned = [coords[0].cpu()]
+    n_frames = len(coords) -1
+    for i, frame in enumerate(coords[1:], 1):
+        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
+        aligned.append(aligned_dev.cpu())
+    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
+    return aligned
+
+# --- NEW ALIGNMENT UTILITIES for MULTI-SYSTEM ---
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
+    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
+    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
+        raise ValueError("Input coordinates must be 2D arrays.")
+
+    # Find nearest neighbor from target for each ref point
+    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
+    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
+    
+    # Find nearest neighbor from ref for each target point
+    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
+    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
+    
+    # Identify mutual pairs
+    ref_indices, target_indices = [], []
+    for i, target_idx in enumerate(indices1.flatten()):
+        if indices2[target_idx] == i:
+            ref_indices.append(i)
+            target_indices.append(target_idx)
+            
+    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
+    if not ref_indices:
+        logger.error("No mutual nearest neighbors found. Cannot align structures.")
+        return torch.tensor([]), torch.tensor([])
+        
+    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)
+
+def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
+                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
+                  logger: logging.Logger) -> torch.Tensor:
+    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
+    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
+    device = structure_to_align.device
+
+    # 1. Select the coordinates of the core atoms for both structures
+    P_core = reference_structure[core_indices_reference].to(device)
+    Q_core = structure_to_align[core_indices_to_align].to(device)
+    
+    # 2. Compute the rotation matrix (U) using only the core
+    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
+    
+    # 3. Center the full structure_to_align on its core's centroid
+    centroid_Q_core = compute_centroid(Q_core)
+    structure_to_align_centered = structure_to_align - centroid_Q_core
+    
+    # 4. Rotate the full centered structure
+    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
+    
+    # 5. Translate the rotated structure to the reference core's centroid
+    centroid_P_core = compute_centroid(P_core)
+    aligned_structure = structure_to_align_rotated + centroid_P_core
+    
+    return aligned_structure
+
+# --- Graph Dataset ---
+# Unchanged
+def build_graph_dataset(coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
+    dataset = []
+    n_frames = len(coords_list)
+    for i, coords_cpu in enumerate(coords_list):
+        coords_dev = coords_cpu.to(device)
+        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
+        data = Data(x=coords_cpu, edge_index=edge_idx.cpu(), y=coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
+        dataset.append(data)
+    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
+    return dataset
+
+# --- Dihedral Utilities ---
+# Unchanged
+@torch.jit.script
+def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
+    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
+    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
+    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
+    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)
+
+def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
+    """Computes all specified dihedrals vectorially."""
+    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
+    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
+    for name, angle_info in info.items():
+        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
+        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
+        if indices is not None and res_idx is not None and indices[0].numel() > 0:
+            try:
+                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
+                max_atom_idx_needed = max(i.max() for i in idx_dev)
+                if max_atom_idx_needed >= N_atoms:
+                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
+                    continue
+                
+                a,b,c,d = (coords[:, i, :] for i in idx_dev)
+                values = compute_dihedral(a,b,c,d)
+                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
+            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
+        all_angles[name] = angles_out
+    return all_angles
+
+
+def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
+    eps=1e-10
+    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
+    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
+    p_dist = p_hist / (p_hist.sum() + eps)
+    t_dist = t_hist / (t_hist.sum() + eps)
+    m_dist = 0.5 * (p_dist + t_dist)
+    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))
+
+# --- Checkpoint Utilities & MSE Utilities ---
+# Unchanged
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device)
+            start_epoch = ckpt.get("epoch", 0)
+            model.load_state_dict(ckpt["model_state_dict"])
+            if optimizer and "optimizer_state_dict" in ckpt:
+                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+                for state in optimizer.state.values():
+                    for k, v in state.items():
+                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
+            model.to(device)
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
+            start_epoch = 0
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
+    model.to(device)
+    return model, optimizer, start_epoch
+
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    crit = nn.MSELoss()
+    all_mse = crit(pred, target)
+    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    return all_mse, bb_mse, sc_mse
+
+
+################################################################################
+# (F) Model Definitions
+################################################################################
+
+# --- HNO Encoder ---
+# NOTE: This model is already size-agnostic. The ChebConv and final Linear layers
+# operate on a per-node basis, so it handles graphs of different sizes correctly.
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged = False
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head
+
+    def forward(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        x_rep = F.normalize(x, p=2.0, dim=1)
+        x_recon = self.mlpRep(x_rep)
+        
+        if self.training is False and not self._debug_logged:
+             logger.debug(f"[HNO] Forward pass shapes: In={x.shape}, Rep={x_rep.shape}, Recon={x_recon.shape}")
+             self._debug_logged = True
+        return x_recon
+
+    def forward_representation(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        return F.normalize(x, p=2.0, dim=1)
+
+# --- REFACTORED Decoder2 Model ---
+class ProteinStateReconstructor2D(nn.Module):
+    """
+    Size-agnostic decoder. Predicts full coordinates from node embeddings.
+    It combines local (per-node) and global (per-graph) information.
+    """
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int, mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        self._logged_fwd = False
+        
+        # The input to the final MLP for each node will be:
+        # [local_node_embedding, global_graph_embedding, global_conditioner_embedding]
+        mlp_in_dim = node_emb_dim + node_emb_dim + cond_emb_dim
+        
+        # Simple MLP decoder
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+        
+        self.logger.info(f"Initialized Size-Agnostic Decoder2 with MLP input dim: {mlp_in_dim}")
+
+    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x (Tensor): Per-node embeddings from HNO [N_total_nodes, E_node]
+            batch (Tensor): PyG batch vector [N_total_nodes]
+            conditioner_z_ref (Tensor): Per-node reference embeddings [N_total_nodes, E_cond]
+        """
+        # 1. Get global embedding for the current conformation
+        z_global = global_mean_pool(x, batch) # -> [B, E_node]
+        z_global_per_node = z_global[batch] # Broadcast to each node -> [N_total_nodes, E_node]
+
+        # 2. Get global embedding for the conditioner
+        conditioner_global = global_mean_pool(conditioner_z_ref, batch) # -> [B, E_cond]
+        conditioner_global_per_node = conditioner_global[batch] # -> [N_total_nodes, E_cond]
+        
+        # 3. Assemble the feature vector for each node
+        mlp_input = torch.cat([x, z_global_per_node, conditioner_global_per_node], dim=1)
+        
+        # 4. Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+        
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Dec2 Fwd] Shapes: In x={x.shape}, z_global={z_global.shape}, cond_global={conditioner_global.shape}, mlp_in={mlp_input.shape}, Out={pred_coords.shape}")
+            self._logged_fwd = True
+            
+        return pred_coords
+
+################################################################################
+# (G) Training Functions
+################################################################################
+
+# --- Train HNO ---
+# This function requires minimal changes as the model is size-agnostic
+def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev)
+    params = list(filter(lambda p: p.requires_grad, model.parameters()))
+    opt = torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+    
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+
+    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        total_loss = 0.0
+        for data in tr_loader:
+            data=data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            pred = model(data.x, data.edge_index)
+            loss = F.mse_loss(pred, data.y)
+            loss.backward()
+            opt.step()
+            total_loss += loss.item()
+        avg_tr_loss = total_loss / len(tr_loader)
+        
+        model.eval()
+        total_val_loss = 0.0
+        with torch.no_grad():
+            for data in te_loader:
+                data=data.to(dev)
+                pred=model(data.x, data.edge_index)
+                total_val_loss += F.mse_loss(pred, data.y).item()
+        avg_te_loss = total_val_loss / len(te_loader)
+
+        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+    
+    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
+    return model
+
+# --- REFACTORED Train Decoder2 ---
+def train_decoder2_model(
+    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
+    all_conditioners: Dict[int, torch.Tensor], # Dict of z_ref tensors
+    all_sys_info: Dict[int, Any], # Dict containing bb_idx, sc_idx, n_res etc. for each system
+    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
+    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
+):
+    model = model.to(dev)
+    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+        
+    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
+    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")
+
+    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
+        
+        for data in tr_loader:
+            data = data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            
+            # --- Assemble Batch-Specific Conditioners and Indices ---
+            # This is the core logic for handling heterogeneous batches
+            unique_sys_ids = torch.unique(data.system_id)
+            
+            # Create the conditioner tensor for this specific batch
+            # Note: This could be optimized, but is clear for debugging
+            cond_list = []
+            for i in range(data.num_graphs):
+                sid = data.system_id[i].item()
+                num_nodes = data.ptr[i+1] - data.ptr[i]
+                cond = all_conditioners[sid].to(dev)
+                if cond.shape[0] != num_nodes: # This check is important!
+                    logger.error(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
+                    # This should not happen if data prep is correct.
+                    # As a fallback, we must skip or resize. For now, let's assume it matches.
+                cond_list.append(cond)
+            conditioners_for_batch = torch.cat(cond_list, dim=0)
+
+            # --- Forward and Coordinate Loss ---
+            pred = model(data.x, data.batch, conditioners_for_batch)
+            total_loss = 0.0
+            coord_loss = 0.0
+
+            # Calculate coordinate MSE loss per system in the batch
+            for sid_tensor in unique_sys_ids:
+                sid = sid_tensor.item()
+                mask = (data.system_id[data.batch] == sid)
+                
+                bb_idx = all_sys_info[sid]['bb_idx_local'] # Use local indices
+                sc_idx = all_sys_info[sid]['sc_idx_local']
+                
+                pred_sys = pred[mask]
+                target_sys = data.y[mask]
+                
+                sys_mse, _, _ = compute_bb_sc_mse(pred_sys, target_sys, bb_idx, sc_idx, logger)
+                coord_loss += sys_mse
+
+            total_loss += base_w * coord_loss
+            tr_metrics['coord'] += coord_loss.item()
+            
+            # --- Dihedral Loss ---
+            di_div_loss = torch.tensor(0.0, device=dev)
+            di_mse_loss = torch.tensor(0.0, device=dev)
+            if use_di and all_di_info:
+                for sid_tensor in unique_sys_ids:
+                    sid = sid_tensor.item()
+                    mask = (data.system_id[data.batch] == sid)
+                    
+                    pred_sys_3d = pred[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
+                    true_sys_3d = data.y[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
+                    
+                    pred_a = compute_all_dihedrals_vectorized(pred_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    true_a = compute_all_dihedrals_vectorized(true_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+
+                    for name in pred_a:
+                        pa, ta = pred_a[name], true_a[name]
+                        if pa.numel() > 0:
+                             di_div_loss += comp_div(pa, ta)
+                             di_mse_loss += F.mse_loss(pa, ta)
+                
+                total_loss += l_div * di_div_loss + l_mse * di_mse_loss
+                tr_metrics['di_div'] += di_div_loss.item()
+                tr_metrics['di_mse'] += di_mse_loss.item()
+
+            tr_metrics['total'] += total_loss.item()
+            total_loss.backward()
+            opt.step()
+        
+        # Log training stats (validation loop omitted for brevity but should be added)
+        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
+        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+            
+    logger.info("Finished Decoder2 training.")
+    return model
+
+
+################################################################################
+# (I) Main Execution Function
+################################################################################
+def main():
+    start_time = time.time()
+    logger.info("================ Script Starting (Multi-System Version) ================")
+    global global_device
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    logger.info("Successfully loaded configuration.")
+    
+    # --- Extract Parameters ---
+    force_cpu = config.get("force_cpu", False)
+    device = torch.device("cpu") if force_cpu else global_device
+    pin_mem = (device.type == "cuda")
+    num_workers = config.get("num_workers", 0)
+    
+    hno_cfg = config["hno_encoder"]
+    dec2_cfg = config["decoder2"]
+    d2s = config["decoder2_settings"]
+    di_cfg = config.get("dihedral_loss", {})
+    out_cfg = config["output_directories"]
+    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]
+
+    # --- Stage 1: Multi-System Data Loading & Alignment ---
+    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
+    
+    full_dset = []
+    all_sys_info = {} # Will store n_atoms, n_res, ca_indices, bb_idx etc. for each system
+    canonical_ref_coords = None
+    canonical_ref_ca_indices = None
+
+    # Loop through each system defined in the config
+    for i, system_config in enumerate(config["data"]["systems"]):
+        sid = i
+        pdb_p = system_config["pdb_path"]
+        json_p = system_config["json_path"]
+        logger.info(f"--- Processing System ID {sid}: {os.path.basename(pdb_p)} ---")
+
+        # 1. Parse PDB for topology and C-alpha indices
+        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
+        renum_d, _, _, ca_indices_new = renumber_atoms_and_residues(atoms_ord, ca_serial_map)
+        bb_idx, sc_idx = get_global_indices(renum_d)
+        
+        # 2. Load coordinates from JSON
+        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger)
+        if not coords_list: continue # Skip if system loading failed
+
+        all_sys_info[sid] = {
+            'n_atoms': n_atoms,
+            'ca_indices': ca_indices_new,
+            'bb_idx_local': bb_idx, # These are local to the system
+            'sc_idx_local': sc_idx,
+            'n_res': len(renum_d)
+        }
+
+        # 3. Perform Alignment
+        aligned_coords_list = []
+        if sid == 0:
+            # This is the canonical reference system
+            logger.info(f"System {sid} is the canonical reference.")
+            canonical_ref_coords = coords_list[0].clone()
+            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
+        else:
+            # Align this system to the canonical reference
+            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
+            target_ref_coords = coords_list[0]
+            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            
+            # Find core pairs for alignment
+            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
+                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
+                target_ref_coords[target_ca_indices].numpy(),
+                logger
+            )
+            
+            # Align the first frame of this system to the canonical reference
+            aligned_target_ref_frame = align_by_core(
+                target_ref_coords, target_ca_indices[core_target_idx],
+                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
+                logger
+            ).to(device)
+            
+            # Align the rest of this system's trajectory to its own aligned reference frame
+            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
+            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)
+
+        # 4. Build graph dataset for this system and add to the master list
+        system_dset = build_graph_dataset(aligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
+        full_dset.extend(system_dset)
+
+    logger.info(f"--- Finished data loading. Total frames in dataset: {len(full_dset)} ---")
+
+    # --- Stage 2: HNO Training ---
+    logger.info("--- Stage 2: Training Shared HNO Encoder ---")
+    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
+    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
+    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
+    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
+    hno_model.eval()
+
+    # --- Stage 3: Decoder Input Data Prep ---
+    logger.info("--- Stage 3: Preparing Decoder Input Dataset & Conditioners ---")
+    dec_in_dset = []
+    all_conditioners = {} # Dictionary to hold the z_ref for each system
+    
+    # Generate embeddings for the whole dataset
+    with torch.no_grad():
+        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
+        for batch in infer_load:
+            batch = batch.to(device)
+            emb = hno_model.forward_representation(batch.x, batch.edge_index)
+            # De-batch to create new Data objects
+            split_sizes = (batch.ptr[1:] - batch.ptr[:-1]).tolist()
+            emb_list = torch.split(emb, split_sizes)
+            y_list = torch.split(batch.y, split_sizes)
+            
+            for i in range(len(emb_list)):
+                dec_in_dset.append(Data(x=emb_list[i].cpu(), y=y_list[i].cpu(), system_id=batch.system_id[i].cpu().reshape(1)))
+    
+    # Create the conditioner dictionary
+    if d2s['conditioner_mode'] == 'z_ref':
+        for sid in all_sys_info.keys():
+            # Find the first frame of the system in the original dataset to get its reference coords
+            ref_data_orig = next(d for d in full_dset if d.system_id.item() == sid)
+            ref_data_orig = ref_data_orig.to(device)
+            with torch.no_grad():
+                z_ref = hno_model.forward_representation(ref_data_orig.x, ref_data_orig.edge_index)
+                all_conditioners[sid] = z_ref.cpu() # Store on CPU
+        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
+    else:
+        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")
+
+    # --- Stage 4: Decoder Setup & Training ---
+    logger.info("--- Stage 4: Decoder2 Setup & Training ---")
+    
+    # Prepare Dihedral Info Dictionaries
+    all_di_info = {}
+    use_di_train = di_cfg.get("use_dihedral_loss", False)
+    if use_di_train:
+        logger.info("Preparing dihedral information for all systems...")
+        for i, system_config in enumerate(config["data"]["systems"]):
+            sid = i
+            torsion_p = system_config.get("torsion_info_path")
+            if not torsion_p or not os.path.isfile(torsion_p):
+                logger.warning(f"Torsion file not found for system {sid}. Disabling dihedral loss for this system.")
+                continue
+            
+            with open(torsion_p, "r") as f: t_info = json.load(f)
+            # Simplified parsing logic, assuming it's correct per system
+            di_info_sys = {} # ... parsing logic to fill this based on t_info ...
+            all_di_info[sid] = di_info_sys
+        if not all_di_info: use_di_train = False # Disable if no files were loaded
+    
+    # Initialize and Train Decoder
+    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
+    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    
+    dec2_model = ProteinStateReconstructor2D(
+        node_emb_dim=hno_cfg['hidden_dim'],
+        cond_emb_dim=hno_cfg['hidden_dim'], # since we use z_ref
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    )
+    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
+    dec2_model = train_decoder2_model(
+        dec2_model, load_tr_dec, load_te_dec, all_conditioners, all_sys_info,
+        dec2_cfg['num_epochs'], dec2_cfg['learning_rate'], dec2_ckpt, dec2_cfg['save_interval'], device, logger,
+        dec2_cfg['base_loss_weight'], use_di_train, all_di_info,
+        di_cfg.get('divergence_type', 'JS'), di_cfg.get('lambda_divergence', 0.0), di_cfg.get('lambda_torsion_mse', 0.0)
+    )
+
+    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")
+
+################################################################################
+# (J) Script Entry Point
+################################################################################
+if __name__ == "__main__":
+    main()

LD-FPG-main/conditional_generation/README.md

@@ -0,0 +1,94 @@
+# Conditional Protein Conformation Generation Pipeline
+
+This document describes an advanced deep learning pipeline for training a *conditional* generative model. Unlike a standard generative model, this pipeline can be guided by a novel, unseen protein structure to generate new 3D conformations that are consistent with that specific structural template.
+
+The workflow is divided into two main phases:
+1.  **Training Phase:** Learn the fundamental relationships between protein structures and their dynamic conformations using a dataset of known proteins and their structural variants.
+2.  **Inference Phase:** Use the trained models to generate new conformations for a new, unseen protein structure provided by the user.
+
+## Core Components
+
+This pipeline uses a set of specialized scripts and configuration files.
+
+### Training Scripts
+-   **`chebnet_conditional_setup.py`**: The main script for training the foundational autoencoder (HNO Encoder and Decoder). It processes multiple protein systems and their artificially generated structural variants to create a rich training dataset.
+    -   **Config:** `param_conditional.yaml`
+-   **`conditional_diffusion.py`**: Trains the core generative model. It's a conditional diffusion model that learns how a specific structural signature (`z_ref`) influences the distribution of dynamic conformations (`pooled_embeddings`).
+    -   **Config:** `param_conditional_diffusion.yaml`
+
+### Inference Scripts
+-   **`generate_from_new_pdb.py`**: The first step of the inference pipeline. It takes a new PDB file, uses the pre-trained HNO Encoder to calculate its unique `z_ref` conditioner, and then uses the pre-trained diffusion model to generate a set of corresponding latent embeddings.
+    -   **Config:** `param_generate_from_new.yaml`
+-   **`decode_novel_latents.py`**: The second inference step. It takes the latent embeddings generated by the previous script and uses the pre-trained Decoder to translate them back into full 3D atom coordinates.
+    -   **Config:** `param_decode_novel.yaml`
+-   **`h5_to_pdb_novel.py`**: The final utility script. It converts the generated 3D coordinates from the HDF5 format into standard PDB files for visualization.
+    -   **Config:** No YAML file; configured via command-line arguments.
+
+## Workflow: How to Run the Pipeline
+
+Follow these steps in order. Ensure all paths and model parameters in the YAML files are correctly configured before running each script.
+
+---
+
+### Phase 1: Training the Generative Models
+
+This phase only needs to be done once to train the models.
+
+**Step 1: Train the Foundational Autoencoder**
+This script trains the HNO Encoder and the Decoder on your dataset of protein systems.
+```bash
+python chebnet_conditional_setup.py --config param_conditional.yaml
+```
+-   **Key Outputs:**
+    -   `checkpoints/hno_checkpoint.pth` (Trained Encoder)
+    -   `checkpoints/decoder2_checkpoint.pth` (Trained Decoder)
+    -   `latent_reps/reference_conditioners.h5` (All `z_ref` conditioners)
+    -   `latent_reps/pooled_embeddings.h5` (All dynamic embeddings)
+
+**Step 2: Train the Conditional Diffusion Model**
+This script uses the data from Step 1 to train the generative model. It learns the mapping from a `z_ref` to its corresponding conformations.
+```bash
+python conditional_diffusion.py --config param_conditional_diffusion.yaml
+```
+-   **Key Output:**
+    -   `conditional_diffusion_output/checkpoints/cond_diffusion_latest.pth` (Trained Diffusion Model)
+
+---
+
+### Phase 2: Inference - Generating Conformations for a New PDB
+
+Once the models are trained, you can repeat this phase for any new PDB file you want to analyze.
+
+**Step 3: Generate Latent Embeddings for the New PDB**
+Provide your new PDB file. This script will generate the latent embeddings for it.
+```bash
+python generate_from_new_pdb.py \
+    --config param_generate_from_new.yaml \
+    --pdb /path/to/your/new_protein.pdb \
+    --output novel_protein_latents.h5
+```
+-   **Key Output:**
+    -   `novel_protein_latents.h5`: An HDF5 file containing the `novel_z_ref_conditioner` and the `generated_pooled_embeddings`.
+
+**Step 4: Decode Latent Embeddings into 3D Coordinates**
+This script converts the latent embeddings from Step 3 into physical coordinates.
+```bash
+python decode_novel_latents.py \
+    --config param_decode_novel.yaml \
+    --input novel_protein_latents.h5 \
+    --output final_coords_for_novel_protein.h5
+```
+-   **Key Output:**
+    -   `final_coords_for_novel_protein.h5`: An HDF5 file containing the final `generated_coords`.
+
+**Step 5: Convert Final Coordinates to PDB Files**
+The final step. This script creates the viewable PDB files from the coordinate data.
+```bash
+python h5_to_pdb_novel.py \
+    --input final_coords_for_novel_protein.h5 \
+    --template_pdb /path/to/your/new_protein.pdb \
+    --output_dir generated_pdbs_for_novel_protein/ \
+    --max_frames 50
+```
+-   **Key Output:**
+    -   `generated_pdbs_for_novel_protein/`: A directory containing the final PDB files (e.g., `generated_novel_frame_1.pdb`, etc.).

LD-FPG-main/conditional_generation/chebnet_conditional_setup.py

@@ -0,0 +1,1322 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+import random
+import mdtraj as md
+from typing import Dict, List, Optional, Tuple, Any
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv, global_mean_pool
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import NearestNeighbors # New dependency
+
+# (NEW) Local flag to control output verbosity
+DISABLE_DETAILED_OUTPUTS = True # Set to True to skip non-essential file exports
+
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load
+################################################################################
+LOG_FILE_DEFAULT = "logfile_multi_system.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstruction")
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+if not logger.handlers:
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    try:
+        fh = logging.FileHandler(log_file_path, mode="w")
+        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+    except IOError as e:
+        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+logger.info(f"Logger initialized. Log file: {log_file_path}")
+if args.debug: logger.debug("Debug mode is ON.")
+
+################################################################################
+# (D) Device Setup (Global)
+################################################################################
+device_name = "cpu"
+if torch.cuda.is_available():
+    try:
+        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
+        device_name = f"cuda:{cuda_device_index}"
+        torch.cuda.get_device_name(cuda_device_index)
+    except Exception:
+        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
+        if torch.cuda.is_available(): device_name = "cuda:0"
+global_device = torch.device(device_name)
+logger.info(f"Initial device check: {global_device}")
+
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+# --- PDB Parsing ---
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
+    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
+    chain_map = {}; chain_idx_counter = 0
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line in pdb_file:
+                if not line.startswith("ATOM  "): continue
+                alt_loc = line[16].strip()
+                if alt_loc not in ['', 'A']: continue
+
+                atom_serial = int(line[6:11])
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+
+                atom_name = line[12:16].strip()
+                res_name = line[17:20].strip()
+                chain_id_char = line[21].strip()
+                if chain_id_char not in chain_map:
+                    chain_map[chain_id_char] = chain_idx_counter
+                    chain_idx_counter += 1
+                chain_id_int = chain_map[chain_id_char]
+
+                res_seq = int(line[22:26])
+                orig_res_id = f"{chain_id_int}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+
+                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
+                if atom_name == 'CA': ca_indices[res_seq] = atom_serial
+
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
+    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
+    return {}, atoms_in_order, ca_indices
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int], Dict]:
+    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
+    new_res_dict, orig_atom_map = {}, {}
+    next_new_res_id, next_new_atom_index = 0, 0
+    orig_res_map = {}
+    
+    # Preserve original residue order
+    seen_res_order = {}
+    res_order_counter = 0
+    for r_id, _, _, _ in atoms_in_order:
+        if r_id not in seen_res_order:
+            seen_res_order[r_id] = res_order_counter
+            res_order_counter += 1
+
+    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
+    sortable.sort()
+
+    for _, serial, r_id, cat, name in sortable:
+        if r_id not in orig_res_map:
+            orig_res_map[r_id] = next_new_res_id
+            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
+            next_new_res_id += 1
+        
+        new_res_id = orig_res_map[r_id]
+        new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index
+        next_new_atom_index += 1
+
+    # Map original CA serial numbers to the new, renumbered 0-based indices
+    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
+    
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
+    return new_res_dict, orig_atom_map, {}, new_ca_indices, orig_res_map
+
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()):
+        bb_idx.extend(renumbered_dict[res_id]["backbone"])
+        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)
+
+# --- JSON Loading ---
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger, max_frames: Optional[int] = None) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
+    
+    try:
+        keys_int = sorted([int(k) for k in data.keys()])
+        keys_str = [str(k) for k in keys_int]
+        if not keys_str: logger.error("No residue data in JSON."); return [], -1
+        
+        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
+        n_frames_total = len(frame_data)
+        if n_frames_total == 0: logger.warning("JSON contains 0 frames."); return [], 0
+
+        frame_indices_to_load = range(n_frames_total)
+        if max_frames is not None and max_frames > 0 and max_frames < n_frames_total:
+            logger.info(f"Randomly sampling {max_frames} frames out of {n_frames_total} available.")
+            frame_indices_to_load = sorted(random.sample(range(n_frames_total), max_frames))
+        else:
+            logger.info(f"Loading all {n_frames_total} available frames.")
+
+        coords_frames, n_atoms_check = [], -1
+        for frame_idx in frame_indices_to_load:
+            frame_coords_np = []
+            current_atoms = 0
+            for res_key in keys_str:
+                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
+                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
+                frame_coords_np.append(coords)
+                current_atoms += coords.shape[0]
+
+            if n_atoms_check == -1:
+                n_atoms_check = current_atoms
+                logger.info(f"System has {n_atoms_check} atoms and {len(frame_indices_to_load)} frames will be loaded.")
+            elif current_atoms != n_atoms_check:
+                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
+            
+            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))
+
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1
+
+# --- Alignment ---
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
+    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try: V, S, Wt = torch.linalg.svd(C)
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
+        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
+        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
+        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
+    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
+    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
+    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    if not coords: logger.warning("Coordinate list empty."); return []
+    ref = coords[0].to(device)
+    aligned = [coords[0].cpu()]
+    n_frames = len(coords) -1
+    for i, frame in enumerate(coords[1:], 1):
+        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
+        aligned.append(aligned_dev.cpu())
+    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
+    return aligned
+
+# --- ROBUST ALIGNMENT UTILITIES for MULTI-SYSTEM ---
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
+    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
+    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
+        raise ValueError("Input coordinates must be 2D arrays.")
+
+    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
+    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
+    
+    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
+    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
+    
+    ref_indices, target_indices = [], []
+    for i, target_idx in enumerate(indices1.flatten()):
+        # *** PATCH 1: Correctly index the result from kneighbors ***
+        if indices2[target_idx, 0] == i:
+            ref_indices.append(i)
+            target_indices.append(target_idx)
+            
+    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
+    if not ref_indices:
+        logger.error("No mutual nearest neighbors found. Cannot align structures.")
+        return torch.tensor([]), torch.tensor([])
+        
+    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)
+
+def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
+                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
+                  logger: logging.Logger) -> torch.Tensor:
+    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
+    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
+    device = structure_to_align.device
+
+    P_core = reference_structure[core_indices_reference].to(device)
+    Q_core = structure_to_align[core_indices_to_align].to(device)
+    
+    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
+    
+    centroid_Q_core = compute_centroid(Q_core)
+    structure_to_align_centered = structure_to_align - centroid_Q_core
+    
+    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
+    
+    centroid_P_core = compute_centroid(P_core)
+    aligned_structure = structure_to_align_rotated + centroid_P_core
+    
+    return aligned_structure
+
+# --- Graph Dataset ---
+def build_graph_dataset(aligned_coords_list: List[torch.Tensor], unaligned_coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
+    dataset = []
+    n_frames = len(aligned_coords_list)
+    logger.debug(f"[Graph Build] Building dataset for system {system_id} with {n_frames} frames. First frame coord shape: {aligned_coords_list[0].shape}")
+    for i, (aligned_coords_cpu, unaligned_coords_cpu) in enumerate(zip(aligned_coords_list, unaligned_coords_list)):
+        coords_dev = aligned_coords_cpu.to(device)
+        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
+        if logger.isEnabledFor(logging.DEBUG) and i == 0:
+            logger.debug(f"[Graph Build] Frame 0: coords_cpu shape: {aligned_coords_cpu.shape}, edge_index shape: {edge_idx.shape}")
+        data = Data(x=aligned_coords_cpu, edge_index=edge_idx.cpu(), y=aligned_coords_cpu, y_unaligned=unaligned_coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
+        dataset.append(data)
+    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
+    return dataset
+
+# --- Dihedral Utilities ---
+@torch.jit.script
+def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
+    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
+    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
+    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
+    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)
+
+def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
+    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
+    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(f"[Dihedral Calc] Input coords shape: {coords.shape}")
+    for name, angle_info in info.items():
+        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
+        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
+        if indices is not None and res_idx is not None and indices[0].numel() > 0:
+            try:
+                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
+                max_atom_idx_needed = max(i.max() for i in idx_dev)
+                if max_atom_idx_needed >= N_atoms:
+                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
+                    continue
+                
+                a,b,c,d = (coords[:, i, :] for i in idx_dev)
+                values = compute_dihedral(a,b,c,d)
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(f"[Dihedral Calc] Angle '{name}': computed values shape: {values.shape}, scatter indices shape: {res_idx_dev.shape}")
+                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
+            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
+        all_angles[name] = angles_out
+    return all_angles
+
+
+def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
+    eps=1e-10
+    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
+    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
+    p_dist = p_hist / (p_hist.sum() + eps)
+    t_dist = t_hist / (t_hist.sum() + eps)
+    m_dist = 0.5 * (p_dist + t_dist)
+    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))
+
+# --- Data Augmentation Utilities ---
+def calculate_ca_rmsd(coords1: torch.Tensor, coords2: torch.Tensor, ca_indices: torch.Tensor) -> torch.Tensor:
+    """Calculates C-alpha RMSD between two coordinate tensors."""
+    ca_coords1 = coords1[ca_indices]
+    ca_coords2 = coords2[ca_indices]
+    return torch.sqrt(torch.mean((ca_coords1 - ca_coords2) ** 2))
+
+def find_optimal_sigma(X_ref: torch.Tensor, ca_indices: torch.Tensor, target_rmsd: float, logger: logging.Logger, 
+                       initial_sigma: float = 0.5, tolerance: float = 0.1, max_iter: int = 10) -> float:
+    """
+    Finds the optimal sigma for noise generation to meet a target C-alpha RMSD
+    by directly comparing the noisy structure to the reference, without model inference.
+    """
+    sigma = initial_sigma
+    X_ref_ca = X_ref[ca_indices].cpu() # Work with C-alpha atoms on CPU for simplicity
+
+    logger.info(f"[Sigma Calibration] Starting calibration for target RMSD {target_rmsd:.3f} Å")
+    for i in range(max_iter):
+        # Generate one noisy sample by adding noise to a CLONE of the reference
+        noise = torch.randn_like(X_ref) * sigma
+        X_noisy = X_ref.clone() + noise
+        X_noisy_ca = X_noisy[ca_indices].cpu()
+        
+        # Calculate C-alpha RMSD against the original, unmodified reference
+        current_rmsd = torch.sqrt(torch.mean((X_ref_ca - X_noisy_ca) ** 2)).item()
+        
+        logger.debug(f"[Sigma Calibration] Iter {i+1}/{max_iter}: sigma={sigma:.4f}, current_rmsd={current_rmsd:.4f} Å")
+
+        if abs(current_rmsd - target_rmsd) < tolerance:
+            logger.info(f"[Sigma Calibration] Success! Final sigma={sigma:.4f} yields RMSD={current_rmsd:.4f} Å (within tolerance {tolerance:.3f} Å)")
+            return sigma
+        
+        # Adjust sigma proportionally
+        # Add a small epsilon to avoid division by zero if current_rmsd is 0
+        sigma = sigma * (target_rmsd / (current_rmsd + 1e-6))
+
+    logger.warning(f"[Sigma Calibration] Failed to converge within {max_iter} iterations. Using final sigma={sigma:.4f} (yielded RMSD={current_rmsd:.4f} Å)")
+    return sigma
+
+def run_dssp_analysis(pdb_path: str, orig_res_map: Dict[str, int], logger: logging.Logger) -> Dict[int, str]:
+    """
+    Runs DSSP analysis on a PDB file and maps the results to 0-based residue indices.
+    """
+    try:
+        traj = md.load(pdb_path)
+        ss_raw = md.compute_dssp(traj, simplified=True)
+        ss_first_frame = ss_raw[0]
+        
+        ss_map = {}
+        # MDTraj provides 1-based residue indices in its topology
+        for res_md in traj.topology.residues:
+            # res_md.resSeq is the original 1-based residue number from the PDB
+            # res_md.index is the 0-based index within mdtraj
+            
+            # Construct the original residue ID string using the integer chain index to match parse_pdb
+            orig_res_id = f"{res_md.chain.index}:{res_md.name}:{res_md.resSeq}"
+            
+            if orig_res_id in orig_res_map:
+                internal_res_idx = orig_res_map[orig_res_id]
+                ss_code = ss_first_frame[res_md.index]
+                simplified_code = 'H' if ss_code == 'H' else 'L'
+                ss_map[internal_res_idx] = simplified_code
+                
+        logger.info(f"Successfully ran DSSP and mapped {len(ss_map)} residues.")
+        return ss_map
+    except Exception as e:
+        logger.error(f"Failed to run DSSP analysis on {pdb_path}: {e}", exc_info=True)
+        return {}
+
+def get_deletable_segments(ss_map: Dict[int, str], total_residues: int, logger: logging.Logger) -> List[List[int]]:
+    """
+    Identifies contiguous segments of residues that are candidates for deletion.
+    A segment is a candidate if it is a loop ('L') or a helix ('H') adjacent to a loop.
+    Excludes segments containing the first two or last two residues.
+    """
+    if not ss_map:
+        logger.warning("Secondary structure map is empty. No deletable segments can be identified.")
+        return []
+
+    # Identify all loop residues
+    loop_residues = {res_idx for res_idx, code in ss_map.items() if code == 'L'}
+    
+    deletable_residues = set()
+    for res_idx, code in ss_map.items():
+        # Rule: A residue is deletable if it's a loop
+        if code == 'L':
+            deletable_residues.add(res_idx)
+        # Rule: A residue is deletable if it's a helix adjacent to a loop
+        elif code == 'H':
+            is_adjacent_to_loop = (res_idx - 1 in loop_residues) or (res_idx + 1 in loop_residues)
+            if is_adjacent_to_loop:
+                deletable_residues.add(res_idx)
+
+    # Safety Rule: Exclude the first two and last two residues of the entire chain
+    protected_residues = {0, 1, total_residues - 2, total_residues - 1}
+    eligible_residues = sorted(list(deletable_residues - protected_residues))
+    
+    if not eligible_residues:
+        logger.warning("No eligible residues for deletion after applying safety rules.")
+        return []
+
+    # Group eligible residues into contiguous segments
+    segments = []
+    if eligible_residues:
+        current_segment = [eligible_residues[0]]
+        for i in range(1, len(eligible_residues)):
+            if eligible_residues[i] == eligible_residues[i-1] + 1:
+                current_segment.append(eligible_residues[i])
+            else:
+                segments.append(current_segment)
+                current_segment = [eligible_residues[i]]
+        segments.append(current_segment)
+        
+    logger.info(f"Identified {len(segments)} deletable segments from {len(eligible_residues)} eligible residues.")
+    return segments
+
+# --- Checkpoint Utilities & MSE Utilities ---
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device)
+            start_epoch = ckpt.get("epoch", 0)
+            model.load_state_dict(ckpt["model_state_dict"])
+            if optimizer and "optimizer_state_dict" in ckpt:
+                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+                for state in optimizer.state.values():
+                    for k, v in state.items():
+                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
+            model.to(device)
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
+            start_epoch = 0
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
+    model.to(device)
+    return model, optimizer, start_epoch
+
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    crit = nn.MSELoss()
+    all_mse = crit(pred, target)
+    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    return all_mse, bb_mse, sc_mse
+
+################################################################################
+# (F) Model Definitions
+################################################################################
+
+# --- HNO Encoder ---
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged_train = False
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head
+
+    def forward(self, x, edge_index):
+        x = x.float()
+        x_in = x
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        x_rep = F.normalize(x, p=2.0, dim=1)
+        x_recon = self.mlpRep(x_rep)
+        
+        if self.training and not self._debug_logged_train and logger.isEnabledFor(logging.DEBUG):
+             logger.debug(f"[HNO Train Fwd] Input shape: {x_in.shape}, Edge index shape: {edge_index.shape}")
+             logger.debug(f"[HNO Train Fwd] Output shapes: Rep={x_rep.shape}, Recon={x_recon.shape}")
+             self._debug_logged_train = True
+        return x_recon
+
+    def forward_representation(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        return F.normalize(x, p=2.0, dim=1)
+
+# --- ROBUST Decoder2 Model (CORRECTED LOGIC) ---
+class ProteinStateReconstructor2D(nn.Module):
+    """
+    Size-agnostic decoder. For each graph, it pools the dynamic embedding to a
+    fixed size using AdaptiveAvgPool2d, flattens it, and concatenates this
+    global dynamic vector to the static (z_ref) conditioner for each node.
+    """
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int,
+                 output_height: int, output_width: int,
+                 mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        self._logged_fwd = False
+        self.node_emb_dim = node_emb_dim
+
+        # 1. Define the 2D pooling layer
+        self.pool_layer = nn.AdaptiveAvgPool2d((output_height, output_width))
+        pooled_dim = output_height * output_width
+
+        # 2. Define the final MLP input dimension
+        # It's the static conditioner + the flattened, pooled dynamic embedding
+        mlp_in_dim = cond_emb_dim + pooled_dim
+
+        # 3. Build the MLP
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+
+        self.logger.info(f"Initialized Decoder2 (Corrected). Pool size: ({output_height}, {output_width}). MLP Input Dim: {mlp_in_dim}")
+
+    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Decoder Fwd Start] Input x shape: {x.shape}, conditioner_z_ref shape: {conditioner_z_ref.shape}")
+
+        # Since graphs in the batch have different sizes, we must loop.
+        pooled_vectors = []
+        for i in range(batch.max().item() + 1):
+            # a. Get the dynamic embedding for the current graph
+            graph_mask = (batch == i)
+            x_graph = x[graph_mask] # Shape: [n_nodes_in_graph, node_emb_dim]
+            n_nodes, n_emb = x_graph.shape
+
+            # b. Reshape for 2D pooling: [B, C, H, W] -> [1, 1, n_nodes, n_emb]
+            x_graph_4d = x_graph.unsqueeze(0).unsqueeze(0)
+
+            # c. Apply pooling and flatten
+            pooled_graph = self.pool_layer(x_graph_4d)
+            flattened_pooled = pooled_graph.view(1, -1) # Shape: [1, pooled_dim]
+            pooled_vectors.append(flattened_pooled)
+
+        # d. Combine pooled vectors for the whole batch
+        batch_pooled = torch.cat(pooled_vectors, dim=0) # Shape: [num_graphs, pooled_dim]
+
+        # e. Broadcast the correct pooled vector to each node in its respective graph
+        pooled_per_node = batch_pooled[batch] # Shape: [total_nodes, pooled_dim]
+
+        # f. Concatenate the static conditioner with the broadcasted pooled vector
+        mlp_input = torch.cat([conditioner_z_ref, pooled_per_node], dim=1)
+
+        # g. Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Decoder Fwd Pools] Pooled vector shape (per graph): {pooled_vectors[0].shape}")
+            self.logger.debug(f"[Decoder Fwd Pools] Broadcasted pooled shape: {pooled_per_node.shape}")
+            self.logger.debug(f"[Decoder Fwd End] mlp_input shape: {mlp_input.shape}, Final output pred_coords shape: {pred_coords.shape}")
+            self._logged_fwd = True
+
+        return pred_coords
+
+################################################################################
+# (G) Training Functions
+################################################################################
+
+# --- Train HNO ---
+def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev)
+    params = list(filter(lambda p: p.requires_grad, model.parameters()))
+    opt = torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+    
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+
+    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        total_loss = 0.0
+        for i, data in enumerate(tr_loader):
+            data=data.to(dev)
+            if ep == start_ep and i == 0 and logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"[HNO Batching] Batch contains {data.num_graphs} graphs.")
+                logger.debug(f"[HNO Batching] data.x shape: {data.x.shape}")
+                logger.debug(f"[HNO Batching] data.ptr: {data.ptr}")
+                logger.debug(f"[HNO Batching] Total nodes in batch: {data.num_nodes}")
+                logger.debug(f"[HNO Batching] System IDs in batch: {data.system_id.squeeze().tolist()}")
+
+            opt.zero_grad(set_to_none=True)
+            pred = model(data.x, data.edge_index)
+            loss = F.mse_loss(pred, data.y)
+            loss.backward()
+            opt.step()
+            total_loss += loss.item()
+        avg_tr_loss = total_loss / len(tr_loader)
+        
+        model.eval()
+        total_val_loss = 0.0
+        with torch.no_grad():
+            for data in te_loader:
+                data=data.to(dev)
+                pred=model(data.x, data.edge_index)
+                total_val_loss += F.mse_loss(pred, data.y).item()
+        avg_te_loss = total_val_loss / len(te_loader)
+
+        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+    
+    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
+    return model
+
+# --- ROBUST Train Decoder2 ---
+def train_decoder2_model(
+    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
+    all_conditioners: Dict[int, torch.Tensor],
+    all_z_ref_ensembles: Dict[int, torch.Tensor],
+    use_z_ref_ensemble: bool,
+    all_sys_info: Dict[int, Any],
+    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
+    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
+):
+    model = model.to(dev)
+    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+
+    if use_z_ref_ensemble:
+        logger.info("Decoder training with augmented 'z_ref_ensemble' as conditioner.")
+        if not all_z_ref_ensembles:
+            logger.error("`use_z_ref_ensemble` is true, but the ensemble dictionary is empty. Aborting.")
+            return model
+    else:
+        logger.info("Decoder training with clean 'z_ref' as conditioner.")
+
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+        
+    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
+    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")
+
+    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
+        
+        for i, data in enumerate(tr_loader):
+            data = data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            
+            # --- Assemble Batch-Specific Conditioners ---
+            cond_list = []
+            for j in range(data.num_graphs):
+                sid = data.system_id[j].item()
+                num_nodes = data.ptr[j+1] - data.ptr[j]
+
+                if use_z_ref_ensemble:
+                    # Check if an ensemble exists for this specific system
+                    if sid in all_z_ref_ensembles:
+                        # If yes, sample from it (this is a base system with noise aug)
+                        ensemble = all_z_ref_ensembles[sid]
+                        rand_idx = torch.randint(0, ensemble.shape[0], (1,)).item()
+                        cond = ensemble[rand_idx].to(dev)
+                        if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[Decoder Verify] Graph {j} (SID: {sid}) is using RANDOM conditioner from its ensemble.")
+                    else:
+                        # If no, fall back to the single z_ref (this is a variant)
+                        cond = all_conditioners[sid].to(dev)
+                        if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(f"[Decoder Verify] Graph {j} (SID: {sid}) is a variant, using FIXED conditioner.")
+                else:
+                    # Use the clean, single z_ref if ensemble mode is off entirely
+                    cond = all_conditioners[sid].to(dev)
+                    if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG):
+                        logger.debug(f"[Decoder Verify] Graph {j} (SID: {sid}) is using the FIXED conditioner (ensemble mode off).")
+
+                if cond.shape[0] != num_nodes:
+                    raise ValueError(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
+                cond_list.append(cond)
+            conditioners_for_batch = torch.cat(cond_list, dim=0)
+
+            # --- Forward Pass ---
+            pred = model(data.x, data.batch, conditioners_for_batch)
+            
+            # --- ROBUST Loss Calculation (Graph by Graph) ---
+            total_loss = torch.tensor(0.0, device=dev)
+            for j in range(data.num_graphs):
+                graph_start, graph_end = data.ptr[j], data.ptr[j+1]
+                sid = data.system_id[j].item()
+
+                pred_graph = pred[graph_start:graph_end]
+                target_graph = data.y[graph_start:graph_end]
+                
+                if i == 0 and j < 2 and logger.isEnabledFor(logging.DEBUG): # Log first 2 graphs of first batch
+                    logger.debug(f"[Decoder Loss Loop] Graph {j}, SID {sid}: pred_graph shape: {pred_graph.shape}, target_graph shape: {target_graph.shape}")
+
+                # Coordinate Loss for this graph
+                bb_idx = all_sys_info[sid]['bb_idx_local']
+                sc_idx = all_sys_info[sid]['sc_idx_local']
+                
+                coord_mse_graph, _, _ = compute_bb_sc_mse(pred_graph, target_graph, bb_idx, sc_idx, logger)
+                total_loss += base_w * coord_mse_graph
+                tr_metrics['coord'] += coord_mse_graph.item()
+
+                # Dihedral Loss for this graph
+                if use_di and sid in all_di_info:
+                    pred_3d = pred_graph.unsqueeze(0) # Add batch dim
+                    target_3d = target_graph.unsqueeze(0)
+                    
+                    pred_a = compute_all_dihedrals_vectorized(pred_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    true_a = compute_all_dihedrals_vectorized(target_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    
+                    di_div_loss_graph = torch.tensor(0.0, device=dev)
+                    di_mse_loss_graph = torch.tensor(0.0, device=dev)
+                    for name in pred_a:
+                        pa, ta = pred_a[name], true_a[name]
+                        if pa.numel() > 0:
+                             di_div_loss_graph += comp_div(pa, ta)
+                             di_mse_loss_graph += F.mse_loss(pa, ta)
+                    
+                    total_loss += l_div * di_div_loss_graph + l_mse * di_mse_loss_graph
+                    tr_metrics['di_div'] += di_div_loss_graph.item()
+                    tr_metrics['di_mse'] += di_mse_loss_graph.item()
+
+            # Average loss over the number of graphs in the batch
+            avg_batch_loss = total_loss / data.num_graphs
+            tr_metrics['total'] += avg_batch_loss.item()
+            
+            avg_batch_loss.backward()
+            opt.step()
+        
+        # Log training stats (validation loop omitted for brevity but should be added)
+        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
+        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+            
+    logger.info("Finished Decoder2 training.")
+    return model
+
+
+################################################################################
+# (H) Final Data Export Function
+################################################################################
+@torch.no_grad()
+def export_final_outputs_multi(
+    hno: 'HNO',
+    dec2: 'ProteinStateReconstructor2D',
+    full_dset: List['Data'],
+    dec_in_dset: List['Data'],
+    all_conditioners: Dict[int, torch.Tensor],
+    all_sys_info: Dict[int, Any],
+    all_X_refs: Dict[int, torch.Tensor],
+    all_X_ref_ensembles: Dict[int, torch.Tensor],
+    all_z_ref_ensembles: Dict[int, torch.Tensor],
+    struct_dir: str,
+    latent_dir: str,
+    dev: torch.device,
+    logger: logging.Logger
+):
+    """
+    Exports final ground truth, reconstructions, and embeddings for all systems
+    to HDF5 files, with data for each system stored in a separate group.
+    Also saves the reference conditioners (z_ref and X_ref) and their ensembles.
+    """
+    logger.info("--- Stage 5: Starting Final Data Export ---")
+    hno.eval()
+    dec2.eval()
+
+    # 1. Initialize data storage
+    outputs_by_sid = {
+        sid: {'gt_aligned': [], 'gt_unaligned': [], 'hno_rec': [], 'full_rec': [], 'hno_emb': [], 'pooled_emb': []}
+        for sid in all_sys_info.keys()
+    }
+
+    # 2. Loop through datasets and perform inference
+    logger.info("Running inference on all frames...")
+    full_loader = DataLoader(full_dset, batch_size=32, shuffle=False)
+    dec_in_loader = DataLoader(dec_in_dset, batch_size=32, shuffle=False)
+
+    # Store intermediate results to avoid recomputing embeddings
+    temp_embs = {}
+
+    with torch.no_grad():
+        # First, get all HNO reconstructions and embeddings
+        for i, data in enumerate(full_loader):
+            data = data.to(dev)
+            hno_recon = hno(data.x, data.edge_index)
+            hno_embedding = hno.forward_representation(data.x, data.edge_index)
+            
+            for j in range(data.num_graphs):
+                sid = data.system_id[j].item()
+                start, end = data.ptr[j], data.ptr[j+1]
+                
+                outputs_by_sid[sid]['gt_aligned'].append(data.y[start:end].cpu())
+                outputs_by_sid[sid]['gt_unaligned'].append(data.y_unaligned[start:end].cpu())
+                outputs_by_sid[sid]['hno_rec'].append(hno_recon[start:end].cpu())
+                outputs_by_sid[sid]['hno_emb'].append(hno_embedding[start:end].cpu())
+                
+                # Store for decoder pass
+                if sid not in temp_embs: temp_embs[sid] = []
+                temp_embs[sid].append(hno_embedding[start:end])
+
+
+        # Second, get all Decoder reconstructions and pooled embeddings
+        for i, emb_data in enumerate(dec_in_loader):
+            emb_data = emb_data.to(dev)
+            
+            # Assemble conditioners for the batch
+            cond_list = [all_conditioners[sid.item()].to(dev) for sid in emb_data.system_id]
+            conditioner = torch.cat(cond_list, dim=0)
+
+            # Decoder forward pass
+            full_recon = dec2(emb_data.x, emb_data.batch, conditioner)
+
+            # Pooled embedding logic (replicated from decoder's forward)
+            pooled_vectors = []
+            for j in range(emb_data.num_graphs):
+                graph_mask = (emb_data.batch == j)
+                x_graph = emb_data.x[graph_mask]
+                
+                x_graph_4d = x_graph.unsqueeze(0).unsqueeze(0)
+                pooled_graph = dec2.pool_layer(x_graph_4d)
+                flattened_pooled = pooled_graph.view(1, -1)
+                pooled_vectors.append(flattened_pooled)
+            
+            batch_pooled = torch.cat(pooled_vectors, dim=0)
+
+            # Split results and store
+            for j in range(emb_data.num_graphs):
+                sid = emb_data.system_id[j].item()
+                start, end = emb_data.ptr[j], emb_data.ptr[j+1]
+                
+                outputs_by_sid[sid]['full_rec'].append(full_recon[start:end].cpu())
+                outputs_by_sid[sid]['pooled_emb'].append(batch_pooled[j].cpu())
+
+
+    # 3. Write stacked data to HDF5 files
+    logger.info("Writing exported data to HDF5 files...")
+    os.makedirs(struct_dir, exist_ok=True)
+    os.makedirs(latent_dir, exist_ok=True)
+
+    # Define output files
+    coord_files = {
+        'gt_aligned': os.path.join(struct_dir, 'gt_coords_aligned.h5'),
+        'gt_unaligned': os.path.join(struct_dir, 'gt_coords_unaligned.h5'),
+        'hno_rec': os.path.join(struct_dir, 'hno_reconstructed_coords.h5'),
+        'full_rec': os.path.join(struct_dir, 'full_reconstructed_coords.h5')
+    }
+    emb_files = {
+        'hno_emb': os.path.join(latent_dir, 'hno_embeddings.h5'),
+        'pooled_emb': os.path.join(latent_dir, 'pooled_embeddings.h5')
+    }
+
+    # Write coordinate data
+    if not DISABLE_DETAILED_OUTPUTS:
+        for key, path in coord_files.items():
+            with h5py.File(path, 'w') as f:
+                logger.debug(f"Writing to {path}")
+                for sid, data in outputs_by_sid.items():
+                    if data[key]:
+                        stacked_data = torch.stack(data[key]).numpy()
+                        grp = f.create_group(f"system_{sid}")
+                        grp.create_dataset("coords", data=stacked_data, compression="gzip")
+                        logger.debug(f"  - Wrote system_{sid}/coords with shape {stacked_data.shape}")
+    else:
+        logger.info("Skipping export of all coordinate files in `structure_dir` due to local setting.")
+
+    # Write embedding data
+    for key, path in emb_files.items():
+        if DISABLE_DETAILED_OUTPUTS and key == 'hno_emb':
+            logger.info(f"Skipping export of {path} due to local setting.")
+            continue
+        with h5py.File(path, 'w') as f:
+            logger.debug(f"Writing to {path}")
+            for sid, data in outputs_by_sid.items():
+                if data[key]:
+                    stacked_data = torch.stack(data[key]).numpy()
+                    grp = f.create_group(f"system_{sid}")
+                    grp.create_dataset("embeddings", data=stacked_data, compression="gzip")
+                    logger.debug(f"  - Wrote system_{sid}/embeddings with shape {stacked_data.shape}")
+
+    # --- Modified logic to save reference conditioners and ensembles ---
+    ref_cond_path = os.path.join(latent_dir, 'reference_conditioners.h5')
+    logger.info(f"Writing reference conditioners and ensembles to {ref_cond_path}")
+    with h5py.File(ref_cond_path, 'w') as f:
+        for sid, z_ref in all_conditioners.items():
+            if sid in all_X_refs:
+                grp = f.create_group(f"system_{sid}")
+                grp.create_dataset("z_ref", data=z_ref.numpy(), compression="gzip")
+                grp.create_dataset("X_ref", data=all_X_refs[sid].numpy(), compression="gzip")
+                logger.debug(f"  - Wrote system_{sid}/z_ref with shape {z_ref.shape}")
+                logger.debug(f"  - Wrote system_{sid}/X_ref with shape {all_X_refs[sid].shape}")
+
+                # Save ensembles if they exist for this system
+                if sid in all_X_ref_ensembles and sid in all_z_ref_ensembles:
+                    x_ensemble = all_X_ref_ensembles[sid].numpy()
+                    z_ensemble = all_z_ref_ensembles[sid].numpy()
+                    grp.create_dataset("X_ref_ensemble", data=x_ensemble, compression="gzip")
+                    grp.create_dataset("z_ref_ensemble", data=z_ensemble, compression="gzip")
+                    logger.debug(f"  - Wrote system_{sid}/X_ref_ensemble with shape {x_ensemble.shape}")
+                    logger.debug(f"  - Wrote system_{sid}/z_ref_ensemble with shape {z_ensemble.shape}")
+            else:
+                logger.warning(f"Could not find X_ref for system {sid}. Skipping save for this system in reference_conditioners.h5")
+
+    logger.info("--- Finished Final Data Export ---")
+
+
+################################################################################
+# (I) Main Execution Function
+################################################################################
+def main():
+    start_time = time.time()
+    logger.info("================ Script Starting (Multi-System Version) ================")
+    global global_device
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    logger.info("Successfully loaded configuration.")
+    
+    force_cpu = config.get("force_cpu", False)
+    device = torch.device("cpu") if force_cpu else global_device
+    pin_mem = (device.type == "cuda")
+    num_workers = config.get("num_workers", 0)
+    
+    hno_cfg = config["hno_encoder"]
+    dec2_cfg = config["decoder2"]
+    d2s = config["decoder2_settings"]
+    di_cfg = config.get("dihedral_loss", {})
+    
+    # Get structural augmentation config
+    struct_aug_cfg = config.get("structural_augmentation", {"enabled": False})
+    aug_cfg = config.get("data_augmentation", {}) # For noise-based augmentation
+
+    out_cfg = config["output_directories"]
+    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]
+
+    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
+    
+    base_systems_data = []
+    systems_to_process_configs = config["data"]["systems"]
+    
+    exec_settings = config.get("execution_settings", {})
+    limit_systems = exec_settings.get("limit_systems")
+    max_frames = exec_settings.get("max_frames_per_system")
+
+    if limit_systems is not None and isinstance(limit_systems, int) and limit_systems > 0:
+        systems_to_process_configs = systems_to_process_configs[:limit_systems]
+        logger.info(f"[INFO] Limiting run to the first {limit_systems} systems as specified in the config.")
+
+    for i, system_config in enumerate(systems_to_process_configs):
+        sid = i
+        pdb_p = system_config["pdb_path"]
+        json_p = system_config["json_path"]
+        logger.info(f"--- Loading Base System ID {sid}: {os.path.basename(pdb_p)} ---")
+
+        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
+        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger, max_frames=max_frames)
+        if not coords_list:
+            logger.warning(f"Skipping system {sid} due to no coordinates.")
+            continue
+        
+        base_systems_data.append({
+            "pdb_path": pdb_p,
+            "atoms_ord": atoms_ord,
+            "ca_serial_map": ca_serial_map,
+            "coords_list": coords_list,
+            "is_variant": False,
+            "base_sid": sid
+        })
+
+    # --- NEW Stage 1.5: Structural Augmentation ---
+    final_systems_to_process = list(base_systems_data) # Start with original systems
+
+    if struct_aug_cfg.get("enabled", False):
+        logger.info("--- Stage 1.5: Starting Structural Augmentation ---")
+        variants_per_system = struct_aug_cfg.get("variants_per_system", 5)
+        
+        for base_system_data in base_systems_data:
+            base_sid = base_system_data["base_sid"]
+            pdb_path = base_system_data["pdb_path"]
+            logger.info(f"--- Generating variants for Base System ID {base_sid} ---")
+
+            # 1. Get mappings for the original, undamaged system
+            renum_d_orig, _, _, _, orig_res_map = renumber_atoms_and_residues(
+                base_system_data["atoms_ord"], base_system_data["ca_serial_map"]
+            )
+            total_residues = len(renum_d_orig)
+
+            # 2. Perform SS analysis
+            ss_map = run_dssp_analysis(pdb_path, orig_res_map, logger)
+            if not ss_map:
+                logger.warning(f"Cannot generate variants for SID {base_sid} due to DSSP failure.")
+                continue
+
+            # 3. Identify deletable segments
+            deletable_segments = get_deletable_segments(ss_map, total_residues, logger)
+            if not deletable_segments:
+                logger.warning(f"No deletable segments found for SID {base_sid}. Skipping variant generation.")
+                continue
+
+            # 4. Generate damaged variants
+            for i in range(variants_per_system):
+                logger.debug(f"Creating variant {i+1}/{variants_per_system} for SID {base_sid}")
+                
+                # a. Randomly select a segment and deletion length
+                segment_to_delete_from = random.choice(deletable_segments)
+                max_len = min(len(segment_to_delete_from), 6)
+                if max_len < 2: continue # Skip if the segment is too short
+                
+                deletion_len = random.randint(2, max_len)
+                start_idx_in_segment = random.randint(0, len(segment_to_delete_from) - deletion_len)
+                
+                residues_to_delete = set(segment_to_delete_from[start_idx_in_segment : start_idx_in_segment + deletion_len])
+                
+                # b. Identify all atoms belonging to the residues to be deleted
+                atom_indices_to_delete = set()
+                for res_idx in residues_to_delete:
+                    atom_indices_to_delete.update(renum_d_orig[res_idx]["backbone"])
+                    atom_indices_to_delete.update(renum_d_orig[res_idx]["sidechain"])
+
+                # c. Create new damaged data
+                original_atoms_ord = base_system_data["atoms_ord"]
+                
+                # We need a map from the original 0-based index to the atom tuple
+                idx_to_atom_tuple = {idx: atom_tuple for idx, atom_tuple in enumerate(original_atoms_ord)}
+
+                atoms_ord_damaged = [
+                    atom_tuple for idx, atom_tuple in idx_to_atom_tuple.items() 
+                    if idx not in atom_indices_to_delete
+                ]
+
+                coords_list_damaged = []
+                original_coords_list = base_system_data["coords_list"]
+                
+                # Create a keep_mask for atom indices
+                keep_indices = sorted(list(set(range(len(original_atoms_ord))) - atom_indices_to_delete))
+                keep_mask = torch.tensor(keep_indices, dtype=torch.long)
+
+                for frame_coords in original_coords_list:
+                    coords_list_damaged.append(frame_coords[keep_mask])
+
+                final_systems_to_process.append({
+                    "pdb_path": pdb_path, # For reference, not reparsing
+                    "atoms_ord": atoms_ord_damaged,
+                    "ca_serial_map": base_system_data["ca_serial_map"], # Will be filtered by renumbering
+                    "coords_list": coords_list_damaged,
+                    "is_variant": True,
+                    "base_sid": base_sid
+                })
+        logger.info(f"Finished augmentation. Total systems to process: {len(final_systems_to_process)}")
+
+
+    # --- Stage 2: Final Data Processing and Graph Building ---
+    full_dset = []
+    all_sys_info = {}
+    all_X_refs = {}
+    canonical_ref_coords = None
+    canonical_ref_ca_indices = None
+    
+    # This loop now processes both original and variant systems
+    for i, system_data in enumerate(final_systems_to_process):
+        sid = i # Each system, original or variant, gets a new unique ID
+        
+        log_prefix = f"Variant of {system_data['base_sid']}" if system_data['is_variant'] else f"Base System {system_data['base_sid']}"
+        logger.info(f"--- Processing Final System ID {sid} ({log_prefix}) ---")
+
+        # CRUCIAL: Re-run renumbering and indexing for every system
+        renum_d, _, _, ca_indices_new, _ = renumber_atoms_and_residues(system_data["atoms_ord"], system_data["ca_serial_map"])
+        bb_idx, sc_idx = get_global_indices(renum_d)
+        
+        coords_list = system_data["coords_list"]
+        n_atoms = coords_list[0].shape[0]
+        unaligned_coords_list = [c.clone() for c in coords_list]
+        
+        all_sys_info[sid] = {
+            'n_atoms': n_atoms,
+            'ca_indices': torch.tensor(ca_indices_new, dtype=torch.long),
+            'bb_idx_local': bb_idx,
+            'sc_idx_local': sc_idx,
+            'n_res': len(renum_d),
+            'is_variant': system_data['is_variant'],
+            'base_sid_ref': system_data['base_sid']
+        }
+
+        aligned_coords_list = []
+        if sid == 0: # The first system is always the canonical reference
+            logger.info(f"System {sid} is the canonical reference.")
+            canonical_ref_coords = coords_list[0].clone()
+            all_X_refs[sid] = canonical_ref_coords.clone()
+            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
+        else:
+            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
+            target_ref_coords = coords_list[0]
+            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            
+            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
+                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
+                target_ref_coords[target_ca_indices].numpy(),
+                logger
+            )
+            
+            aligned_target_ref_frame = align_by_core(
+                target_ref_coords, target_ca_indices[core_target_idx],
+                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
+                logger
+            )
+            
+            all_X_refs[sid] = aligned_target_ref_frame.cpu().clone()
+            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
+            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)
+
+        system_dset = build_graph_dataset(aligned_coords_list, unaligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
+        full_dset.extend(system_dset)
+
+    logger.info(f"--- Finished data processing. Total frames in dataset: {len(full_dset)} ---")
+
+    # --- Stage 3: Training Shared HNO Encoder ---
+    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
+    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
+    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
+    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
+    hno_model.eval()
+
+    # --- Stage 4: Preparing Decoder Input Dataset & Conditioners ---
+    dec_in_dset = []
+    all_conditioners = {}
+    all_X_ref_ensembles = {} # Legacy from noise augmentation, can be removed if not used
+    all_z_ref_ensembles = {} # Legacy from noise augmentation, can be removed if not used
+    
+    with torch.no_grad():
+        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
+        for batch in infer_load:
+            batch = batch.to(device)
+            emb = hno_model.forward_representation(batch.x, batch.edge_index)
+            split_sizes = (batch.ptr[1:] - batch.ptr[:-1]).tolist()
+            emb_list = torch.split(emb, split_sizes)
+            y_list = torch.split(batch.y, split_sizes)
+            
+            for j in range(len(emb_list)):
+                dec_in_dset.append(Data(x=emb_list[j].cpu(), y=y_list[j].cpu(), system_id=batch.system_id[j].cpu().reshape(1)))
+    
+    if d2s['conditioner_mode'] == 'z_ref':
+        for sid in all_sys_info.keys():
+            ref_coords = all_X_refs[sid].to(device)
+            edge_index_ref = knn_graph(ref_coords, k=config["graph"]["knn_value"], loop=False, batch=None)
+            with torch.no_grad():
+                z_ref = hno_model.forward_representation(ref_coords, edge_index_ref)
+                all_conditioners[sid] = z_ref.cpu()
+        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
+    else:
+        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")
+
+    # --- Stage 4.5: Noise-based Data Augmentation (applied to all systems) ---
+    if aug_cfg.get("enabled", False):
+        logger.info("--- Stage 4.5: Starting Noise-Based Data Augmentation for ALL systems (base and variants) ---")
+        ensemble_size = aug_cfg.get("ensemble_size", 100)
+        target_rmsd = aug_cfg.get("target_ca_rmsd", 1.0)
+        
+        for sid, X_ref in all_X_refs.items():
+            logger.info(f"--- Augmenting data with noise for System ID {sid} ---")
+            ca_indices = all_sys_info[sid]['ca_indices']
+            
+            optimal_sigma = find_optimal_sigma(
+                X_ref, ca_indices, target_rmsd, logger
+            )
+
+            X_ref_ensemble_list = []
+            for _ in range(ensemble_size):
+                noise = torch.randn_like(X_ref) * optimal_sigma
+                X_noisy = X_ref.clone() + noise
+                X_ref_ensemble_list.append(X_noisy)
+            
+            X_ref_ensemble_tensor = torch.stack(X_ref_ensemble_list)
+            all_X_ref_ensembles[sid] = X_ref_ensemble_tensor.cpu()
+            logger.info(f"Generated X_ref_ensemble for SID {sid} with shape {X_ref_ensemble_tensor.shape}")
+
+            z_ref_ensemble_list = []
+            with torch.no_grad():
+                for i in range(ensemble_size):
+                    noisy_struct = X_ref_ensemble_tensor[i].to(device)
+                    edge_index_noisy = knn_graph(noisy_struct, k=config["graph"]["knn_value"], loop=False, batch=None)
+                    z_ref_single = hno_model.forward_representation(noisy_struct, edge_index_noisy)
+                    z_ref_ensemble_list.append(z_ref_single.cpu())
+
+            z_ref_ensemble_tensor = torch.stack(z_ref_ensemble_list)
+            all_z_ref_ensembles[sid] = z_ref_ensemble_tensor
+            logger.info(f"Generated z_ref_ensemble for SID {sid} with shape {z_ref_ensemble_tensor.shape}")
+
+    # --- Stage 5: Decoder2 Setup & Training ---
+    all_di_info = {}
+    use_di_train = di_cfg.get("use_dihedral_loss", False)
+    if use_di_train:
+        logger.info("Dihedral loss is configured but parsing logic is not implemented in this version.")
+
+    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
+    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    
+    dec2_model = ProteinStateReconstructor2D(
+        node_emb_dim=hno_cfg['hidden_dim'],
+        cond_emb_dim=hno_cfg['hidden_dim'],
+        output_height=d2s['output_height'],
+        output_width=d2s['output_width'],
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    )
+    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
+    dec2_model = train_decoder2_model(
+        model=dec2_model, tr_loader=load_tr_dec, te_loader=load_te_dec,
+        all_conditioners=all_conditioners,
+        all_z_ref_ensembles=all_z_ref_ensembles, # Pass empty dict, not used by this aug
+        use_z_ref_ensemble=dec2_cfg.get('use_z_ref_ensemble', False),
+        all_sys_info=all_sys_info,
+        N_epochs=dec2_cfg['num_epochs'], lr=dec2_cfg['learning_rate'],
+        ckpt=dec2_ckpt, save_int=dec2_cfg['save_interval'],
+        dev=device, logger=logger,
+        base_w=dec2_cfg['base_loss_weight'],
+        use_di=use_di_train, all_di_info=all_di_info,
+        div_t=di_cfg.get('divergence_type', 'JS'),
+        l_div=di_cfg.get('lambda_divergence', 0.0),
+        l_mse=di_cfg.get('lambda_torsion_mse', 0.0)
+    )
+
+    # --- Stage 6: Final Export ---
+    export_final_outputs_multi(
+        hno=hno_model,
+        dec2=dec2_model,
+        full_dset=full_dset,
+        dec_in_dset=dec_in_dset,
+        all_conditioners=all_conditioners,
+        all_sys_info=all_sys_info,
+        all_X_refs=all_X_refs,
+        all_X_ref_ensembles=all_X_ref_ensembles, # Pass empty dict
+        all_z_ref_ensembles=all_z_ref_ensembles, # Pass empty dict
+        struct_dir=out_cfg['structure_dir'],
+        latent_dir=out_cfg['latent_dir'],
+        dev=device,
+        logger=logger
+    )
+
+    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")
+
+################################################################################
+# (J) Script Entry Point
+################################################################################
+if __name__ == "__main__":
+    main()

LD-FPG-main/conditional_generation/conditional_diffusion.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+import pathlib
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Robust Conditional Diffusion Model Runner")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+parser.add_argument('--log_file', type=str, default="conditional_diffusion_robust.log", help='Path to log file.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+file_handler = logging.FileHandler(args.log_file, mode='w')
+file_handler.setFormatter(logging.Formatter(log_format))
+logger.addHandler(file_handler)
+
+logger.info("Robust Conditional Diffusion Runner Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+params = config.get('parameters', {})
+data_cfg = config.get('data', {})
+USE_ENSEMBLE = params.get('use_conditioner_ensemble', False)
+
+EMBEDDINGS_H5_PATH = pathlib.Path(data_cfg['embeddings_h5_path'])
+CONDITIONERS_H5_PATH = pathlib.Path(data_cfg['conditioners_h5_path'])
+GROUP_TEMPLATE = data_cfg['group_key_template']
+EMBEDDING_DSET_NAME = data_cfg['embedding_dataset_name']
+OUTPUT_DIR = pathlib.Path(config['output_dir'])
+
+if USE_ENSEMBLE:
+    CONDITIONER_DSET_NAME = data_cfg.get('conditioner_ensemble_dataset_name', 'z_ref_ensemble')
+    logger.info("Configuration set to use CONDITIONER ENSEMBLE training.")
+else:
+    CONDITIONER_DSET_NAME = data_cfg.get('conditioner_dataset_name', 'z_ref')
+    logger.info("Configuration set to use SINGLE conditioner training.")
+
+
+# Global training variables
+BATCH_SIZE = params.get('batch_size', 64)
+NUM_EPOCHS = params.get('num_epochs', 50000)
+LEARNING_RATE = float(params.get('learning_rate', 1e-5)) # Explicitly cast to float
+NUM_GENERATE = params.get('num_gen', 1000)
+SAVE_INTERVAL = params.get('save_interval', 1000)
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+# Setup output directories
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+checkpoint_dir = OUTPUT_DIR / 'checkpoints'
+checkpoint_dir.mkdir(exist_ok=True)
+logger.info(f"Output directory: {OUTPUT_DIR.resolve()}")
+
+# ===================================================================
+# (C) Data Loading (Robust Conditional w/ Ensemble Support)
+# ===================================================================
+
+class ConditionalEmbeddingDataset(Dataset):
+    def __init__(self, embeddings_path, conditioners_path, group_template, emb_dset, cond_dset, use_ensemble, logger):
+        self.logger = logger
+        self.use_ensemble = use_ensemble
+        self.data_pairs = []
+        self.system_ids = {} # Maps index to original SID
+
+        if not embeddings_path.is_file() or not conditioners_path.is_file():
+            raise FileNotFoundError(f"HDF5 file not found at {embeddings_path} or {conditioners_path}")
+
+        with h5py.File(embeddings_path, 'r') as femb, h5py.File(conditioners_path, 'r') as fcond:
+            common_groups = sorted(list(set(femb.keys()) & set(fcond.keys())))
+            self.logger.info(f"Found {len(common_groups)} common system groups to load.")
+
+            for group_name in common_groups:
+                sid = int(group_name.split('_')[-1])
+                if emb_dset not in femb[group_name] or cond_dset not in fcond[group_name]:
+                    self.logger.warning(f"Dataset '{emb_dset}' or '{cond_dset}' missing in group {group_name}, skipping.")
+                    continue
+
+                embs = torch.from_numpy(femb[group_name][emb_dset][:].astype(np.float32))
+                cond_data = torch.from_numpy(fcond[group_name][cond_dset][:].astype(np.float32))
+                
+                for i in range(embs.shape[0]):
+                    idx = len(self.data_pairs)
+                    # Store the dynamic embedding and the *entire* conditioner data (either single or ensemble)
+                    self.data_pairs.append((embs[i], cond_data))
+                    self.system_ids[idx] = sid
+        
+        self.logger.info(f"Loaded {len(self.data_pairs)} total data points (frames).")
+
+    def __len__(self):
+        return len(self.data_pairs)
+
+    def __getitem__(self, idx):
+        embedding, conditioner_data = self.data_pairs[idx]
+        
+        # If using ensemble and the conditioner is indeed an ensemble (3D tensor)
+        if self.use_ensemble and conditioner_data.ndim == 3:
+            rand_idx = torch.randint(0, conditioner_data.shape[0], (1,)).item()
+            final_conditioner = conditioner_data[rand_idx]
+        else:
+            # Otherwise, just use the data as is (it's already a single 2D z_ref)
+            final_conditioner = conditioner_data
+            
+        return embedding, final_conditioner
+
+def collate_fn(batch):
+    """Pads variable-length conditioners to the max length in a batch."""
+    embeddings, conditioners = zip(*batch)
+    padded_conditioners = pad_sequence(conditioners, batch_first=True, padding_value=0.0)
+    embedding_batch = torch.stack(embeddings, 0)
+    return embedding_batch, padded_conditioners
+
+try:
+    dataset = ConditionalEmbeddingDataset(
+        EMBEDDINGS_H5_PATH, CONDITIONERS_H5_PATH, GROUP_TEMPLATE,
+        EMBEDDING_DSET_NAME, CONDITIONER_DSET_NAME, USE_ENSEMBLE, logger
+    )
+    dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0, pin_memory=True, collate_fn=collate_fn)
+except Exception as e:
+    logger.error(f"Failed to create dataset: {e}", exc_info=True); exit(1)
+
+# ===================================================================
+# (D) Conditional Diffusion Model & Utilities
+# ===================================================================
+
+# Diffusion schedule
+T = params.get('diffusion_steps', 1000)
+beta_start = params.get('beta_start', 0.0001)
+beta_end = params.get('beta_end', 0.02)
+betas = torch.linspace(beta_start, beta_end, T, device=DEVICE)
+alphas = 1. - betas
+alphas_cumprod = torch.cumprod(alphas, axis=0)
+sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod)
+sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - alphas_cumprod)
+
+def q_sample(x_0, t, noise=None):
+    if noise is None: noise = torch.randn_like(x_0)
+    sqrt_alpha_cumprod_t = sqrt_alphas_cumprod[t].view(-1, 1)
+    sqrt_one_minus_alpha_cumprod_t = sqrt_one_minus_alphas_cumprod[t].view(-1, 1)
+    return sqrt_alpha_cumprod_t * x_0 + sqrt_one_minus_alpha_cumprod_t * noise
+
+# --- Model Architecture ---
+class ConditionerEncoder(nn.Module):
+    """Encodes a variable-length 2D conditioner to a fixed-size vector."""
+    def __init__(self, input_dim, output_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv1d(in_channels=input_dim, out_channels=64, kernel_size=3, padding=1),
+            nn.GELU(),
+            nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, padding=1),
+            nn.GELU(),
+            nn.AdaptiveMaxPool1d(1), # Global Max Pooling
+            nn.Flatten(),
+            nn.Linear(128, output_dim)
+        )
+    
+    def forward(self, x):
+        # Input x: [Batch, SeqLen, Features] -> e.g., [64, 450, 16]
+        # Conv1d expects [Batch, Features, SeqLen]
+        x = x.permute(0, 2, 1)
+        return self.net(x)
+
+class DiffusionModel(nn.Module):
+    """Main diffusion model that uses the conditioner encoder."""
+    def __init__(self, data_dim, cond_input_dim, cond_encoded_dim, hidden_dim):
+        super().__init__()
+        self.encoder = ConditionerEncoder(cond_input_dim, cond_encoded_dim)
+        self.net = nn.Sequential(
+            nn.Linear(data_dim + 1 + cond_encoded_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, data_dim)
+        )
+    
+    def forward(self, x, t, cond_2d):
+        t_norm = t.float().unsqueeze(1) / T
+        encoded_cond = self.encoder(cond_2d)
+        net_input = torch.cat([x, t_norm, encoded_cond], dim=1)
+        return self.net(net_input)
+
+# --- Sampling ---
+@torch.no_grad()
+def p_sample_loop(model, shape, conditioner_2d):
+    x_t = torch.randn(shape, device=DEVICE)
+    # The conditioner is the same for all samples in this batch
+    conditioner_batch = conditioner_2d.unsqueeze(0).repeat(shape[0], 1, 1)
+
+    for t in reversed(range(T)):
+        t_batch = torch.full((shape[0],), t, device=DEVICE, dtype=torch.long)
+        predicted_noise = model(x_t, t_batch, conditioner_batch)
+        
+        alpha_t = alphas[t]
+        beta_t = betas[t]
+        sqrt_recip_alpha_t = torch.sqrt(1.0 / alpha_t)
+        
+        model_mean = sqrt_recip_alpha_t * (x_t - (beta_t / sqrt_one_minus_alphas_cumprod[t]) * predicted_noise)
+        
+        if t > 0:
+            noise = torch.randn_like(x_t)
+            x_t = model_mean + torch.sqrt(beta_t) * noise
+        else:
+            x_t = model_mean
+    return x_t
+
+# ===================================================================
+# (E) Training Loop
+# ===================================================================
+
+def load_checkpoint(model, optimizer, filename, device, logger):
+    """Loads a checkpoint to resume training."""
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device)
+            start_epoch = ckpt.get('epoch', 0)
+            model.load_state_dict(ckpt['model_state_dict'])
+            if optimizer and 'optimizer_state_dict' in ckpt:
+                optimizer.load_state_dict(ckpt['optimizer_state_dict'])
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint: {e}. Starting from scratch.")
+            start_epoch = 0
+    else:
+        logger.info("No checkpoint found. Starting from scratch.")
+    return model, optimizer, start_epoch
+
+def train():
+    data_dim = dataset[0][0].shape[0]
+    cond_input_dim = dataset[0][1].shape[1]
+    cond_encoded_dim = params.get('conditioner_encoded_dim', 128)
+    
+    model = DiffusionModel(
+        data_dim, cond_input_dim, cond_encoded_dim, 
+        params.get('hidden_dim', 1024)
+    ).to(DEVICE)
+    
+    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
+    criterion = nn.MSELoss()
+
+    # --- Load Checkpoint to Resume ---
+    checkpoint_path = checkpoint_dir / "cond_diffusion_latest.pth"
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path, DEVICE, logger)
+
+    if start_epoch >= NUM_EPOCHS:
+        logger.info(f"Training has already been completed to epoch {start_epoch}. Skipping.")
+        return model
+
+    logger.info(f"Starting training from epoch {start_epoch + 1}...")
+    for epoch in range(start_epoch, NUM_EPOCHS):
+        model.train()
+        epoch_loss = 0.0
+        for i, (x0_batch, cond_batch) in enumerate(dataloader):
+            x0_batch, cond_batch = x0_batch.to(DEVICE), cond_batch.to(DEVICE)
+            optimizer.zero_grad()
+            
+            t = torch.randint(0, T, (x0_batch.shape[0],), device=DEVICE).long()
+            noise = torch.randn_like(x0_batch)
+            x_t = q_sample(x0_batch, t, noise=noise)
+            
+            predicted_noise = model(x_t, t, cond_batch)
+            loss = criterion(predicted_noise, noise)
+            
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+        
+        avg_epoch_loss = epoch_loss / len(dataloader)
+        if (epoch + 1) % 10 == 0:
+            logger.info(f"Epoch {epoch+1}/{NUM_EPOCHS}, Avg Loss: {avg_epoch_loss:.6f}")
+
+        # Save a single, consistently named checkpoint file
+        if (epoch + 1) % SAVE_INTERVAL == 0 or (epoch + 1) == NUM_EPOCHS:
+            torch.save({
+                'epoch': epoch + 1,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'loss': avg_epoch_loss,
+            }, checkpoint_path)
+            logger.info(f"Checkpoint saved to {checkpoint_path}")
+    
+    logger.info("Training finished.")
+    return model
+
+# ===================================================================
+# (F) Generation (No longer called automatically)
+# ===================================================================
+
+def generate(model):
+    logger.info("Starting generation...")
+    model.eval()
+    
+    # Get unique system IDs from the original dataset mapping
+    unique_sids = sorted(list(set(dataset.system_ids.values())))
+    logger.info(f"Will generate {NUM_GENERATE} samples for each of the {len(unique_sids)} unique systems found.")
+
+    # For generation, we always use the clean, single z_ref, not the ensemble.
+    gen_cond_dset_name = config.get('data', {}).get('conditioner_dataset_name', 'z_ref')
+
+    with h5py.File(CONDITIONERS_H5_PATH, 'r') as fcond:
+        for sid in unique_sids:
+            group_name = GROUP_TEMPLATE.format(sid)
+            logger.info(f"--- Generating for System ID: {sid} ---")
+            
+            try:
+                if group_name not in fcond or gen_cond_dset_name not in fcond[group_name]:
+                    logger.warning(f"Clean conditioner '{gen_cond_dset_name}' not found for SID {sid}. Skipping generation.")
+                    continue
+
+                cond_np = fcond[group_name][gen_cond_dset_name][:]
+                conditioner_2d = torch.from_numpy(cond_np).float().to(DEVICE)
+                
+                gen_shape = (NUM_GENERATE, dataset[0][0].shape[0])
+                
+                generated_samples = p_sample_loop(model, gen_shape, conditioner_2d).cpu().numpy()
+                
+                save_path = OUTPUT_DIR / f"generated_embeddings_cond_on_sys_{sid}.h5"
+                with h5py.File(save_path, 'w') as f_out:
+                    f_out.create_dataset("generated_embeddings", data=generated_samples)
+                    f_out.create_dataset("conditioner_z_ref", data=cond_np)
+                    logger.info(f"Saved generated samples for system {sid} to {save_path}")
+
+            except Exception as e:
+                logger.error(f"Failed to generate for system {sid}: {e}", exc_info=True)
+
+
+if __name__ == "__main__":
+    trained_model = train()
+    # The generate() function is no longer called automatically.
+    # Generation is now handled by a dedicated inference script.
+    logger.info("Script finished training.")

LD-FPG-main/conditional_generation/decode_novel_latents.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import torch.nn.functional as F
+import pathlib
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Decode Novel Latent Embeddings to 3D Structures")
+parser.add_argument('--config', type=str, required=True, help='Path to the decoding YAML configuration file.')
+parser.add_argument('--input', type=str, required=True, help='Path to the HDF5 file from generate_from_new_pdb.py.')
+parser.add_argument('--output', type=str, required=True, help='Path for the final output HDF5 file containing coordinates.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("Novel Latent Decoder Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+paths = config.get('paths', {})
+d2s = config.get('decoder2_settings', {})
+
+DECODER_CKPT_PATH = pathlib.Path(paths['decoder_checkpoint_path'])
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+# ===================================================================
+# (C) Model Definition (Must match trained Decoder)
+# ===================================================================
+
+class ProteinStateReconstructor2D(nn.Module):
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int,
+                 output_height: int, output_width: int,
+                 mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        # The pooling layer is not used in the forward pass here, but its parameters
+        # are kept to correctly calculate the mlp_in_dim, ensuring that the
+        # architecture matches the saved checkpoint weights.
+        self.pool_layer = nn.AdaptiveAvgPool2d((output_height, output_width))
+        pooled_dim = output_height * output_width
+        mlp_in_dim = cond_emb_dim + pooled_dim
+
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+        self.logger.info(f"Instantiated Decoder. MLP Input Dim: {mlp_in_dim}")
+
+    def forward(self, pooled_embedding: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        """
+        A corrected forward pass for generation from a pre-pooled embedding.
+        'pooled_embedding' is the direct output from the diffusion model.
+        'conditioner_z_ref' is the static per-atom conditioner.
+        """
+        num_atoms = conditioner_z_ref.shape[0]
+        
+        # The input 'pooled_embedding' is already the correct, flattened, pooled vector.
+        # We just need to broadcast it to each atom.
+        # It should have shape [pooled_dim], we unsqueeze to [1, pooled_dim] for expand.
+        pooled_per_node = pooled_embedding.unsqueeze(0).expand(num_atoms, -1)
+        
+        # Concatenate the static conditioner with the broadcasted pooled vector
+        mlp_input = torch.cat([conditioner_z_ref, pooled_per_node], dim=1)
+        
+        # Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+        return pred_coords
+
+# ===================================================================
+# (D) Main Decoding Logic
+# ===================================================================
+
+@torch.no_grad()
+def main():
+    # 1. Load Decoder Model
+    logger.info("Loading pre-trained decoder model...")
+    if not DECODER_CKPT_PATH.is_file():
+        logger.error(f"Decoder checkpoint not found at {DECODER_CKPT_PATH}"); exit(1)
+
+    model = ProteinStateReconstructor2D(
+        node_emb_dim=d2s['node_emb_dim'],
+        cond_emb_dim=d2s['cond_emb_dim'],
+        output_height=d2s['output_height'],
+        output_width=d2s['output_width'],
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    ).to(DEVICE)
+
+    checkpoint = torch.load(DECODER_CKPT_PATH, map_location=DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+    logger.info("Decoder model loaded successfully.")
+
+    # 2. Load Input Data
+    input_h5_path = pathlib.Path(args.input)
+    if not input_h5_path.is_file():
+        logger.error(f"Input HDF5 file not found: {input_h5_path}"); exit(1)
+        
+    logger.info(f"Loading data from {input_h5_path}...")
+    with h5py.File(input_h5_path, 'r') as f:
+        pooled_embeddings = torch.from_numpy(f['generated_pooled_embeddings'][:]).float().to(DEVICE)
+        novel_z_ref = torch.from_numpy(f['novel_z_ref_conditioner'][:]).float().to(DEVICE)
+    
+    logger.info(f"Loaded {pooled_embeddings.shape[0]} embeddings and a conditioner of shape {novel_z_ref.shape}")
+
+    # 3. Decode each embedding to a structure
+    all_generated_coords = []
+    for i in range(pooled_embeddings.shape[0]):
+        pooled_emb = pooled_embeddings[i]
+        coords = model(pooled_emb, novel_z_ref)
+        all_generated_coords.append(coords.cpu().numpy())
+    
+    # 4. Save final coordinates
+    output_path = pathlib.Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    stacked_coords = np.array(all_generated_coords)
+    
+    with h5py.File(output_path, 'w') as f_out:
+        f_out.create_dataset("generated_coords", data=stacked_coords, compression="gzip")
+    
+    logger.info(f"Decoding complete. Saved {stacked_coords.shape[0]} structures to {output_path}")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/conditional_generation/generate_from_new_pdb.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import torch.nn.functional as F
+import pathlib
+import mdtraj as md
+from torch_cluster import knn_graph
+from torch_geometric.nn import ChebConv
+from typing import Dict, List, Tuple
+from sklearn.neighbors import NearestNeighbors
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Generate Pooled Embeddings from a Novel PDB")
+parser.add_argument('--config', type=str, required=True, help='Path to the generation YAML configuration file.')
+parser.add_argument('--pdb', type=str, required=True, help='Path to the novel input PDB file.')
+parser.add_argument('--output', type=str, required=True, help='Path for the output HDF5 file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("Novel PDB Inference Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+paths = config.get('paths', {})
+hno_cfg = config.get('hno_encoder', {})
+diff_cfg = config.get('diffusion_model', {})
+gen_cfg = config.get('generation_settings', {})
+
+HNO_CKPT_PATH = pathlib.Path(paths['hno_checkpoint_path'])
+DIFF_CKPT_PATH = pathlib.Path(paths['diffusion_checkpoint_path'])
+CANONICAL_REF_PDB = pathlib.Path(paths['canonical_reference_pdb'])
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+# ===================================================================
+# (C) Model Definitions (Must match trained models)
+# ===================================================================
+
+# --- REAL HNO Encoder ---
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.mlpRep = nn.Linear(hidden_dim, 3)
+
+    def forward_representation(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        return F.normalize(x, p=2.0, dim=1)
+
+# --- REAL Diffusion Model ---
+class ConditionerEncoder(nn.Module):
+    def __init__(self, input_dim, output_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv1d(in_channels=input_dim, out_channels=64, kernel_size=3, padding=1), nn.GELU(),
+            nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, padding=1), nn.GELU(),
+            nn.AdaptiveMaxPool1d(1), nn.Flatten(), nn.Linear(128, output_dim)
+        )
+    def forward(self, x):
+        x = x.permute(0, 2, 1)
+        return self.net(x)
+
+class DiffusionModel(nn.Module):
+    def __init__(self, data_dim, cond_input_dim, cond_encoded_dim, hidden_dim):
+        super().__init__()
+        self.encoder = ConditionerEncoder(cond_input_dim, cond_encoded_dim)
+        self.net = nn.Sequential(
+            nn.Linear(data_dim + 1 + cond_encoded_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, data_dim)
+        )
+    def forward(self, x, t, cond_2d):
+        t_norm = t.float().unsqueeze(1) / diff_cfg['diffusion_steps']
+        encoded_cond = self.encoder(cond_2d)
+        net_input = torch.cat([x, t_norm, encoded_cond], dim=1)
+        return self.net(net_input)
+
+# ===================================================================
+# (D) PDB Processing & Alignment Utilities
+# ===================================================================
+
+def get_heavy_atom_coords(pdb_path: pathlib.Path) -> np.ndarray:
+    traj = md.load_pdb(str(pdb_path))
+    heavy_indices = traj.topology.select('not element H')
+    traj.atom_slice(heavy_indices, inplace=True)
+    return traj.xyz[0] * 10  # Convert nm to Angstroms
+
+def get_ca_indices(pdb_path: pathlib.Path) -> np.ndarray:
+    traj = md.load_pdb(str(pdb_path))
+    heavy_indices = traj.topology.select('not element H')
+    heavy_traj = traj.atom_slice(heavy_indices, inplace=False)
+    return heavy_traj.topology.select('name CA')
+
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
+    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
+    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
+    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
+    
+    ref_indices, target_indices = [], []
+    for i, target_idx in enumerate(indices1.flatten()):
+        if indices2[target_idx, 0] == i:
+            ref_indices.append(i)
+            target_indices.append(target_idx)
+    return np.array(ref_indices), np.array(target_indices)
+
+def align_by_core(structure_to_align: np.ndarray, core_indices_to_align: np.ndarray,
+                  reference_structure: np.ndarray, core_indices_reference: np.ndarray) -> np.ndarray:
+    P_core = reference_structure[core_indices_reference]
+    Q_core = structure_to_align[core_indices_to_align]
+    
+    centroid_P_core = P_core.mean(axis=0)
+    centroid_Q_core = Q_core.mean(axis=0)
+    
+    P_c = P_core - centroid_P_core
+    Q_c = Q_core - centroid_Q_core
+    
+    H = Q_c.T @ P_c
+    U, _, Vt = np.linalg.svd(H)
+    d = np.sign(np.linalg.det(Vt.T @ U.T))
+    R = Vt.T @ np.diag([1, 1, d]) @ U.T
+    
+    return (structure_to_align - centroid_Q_core) @ R + centroid_P_core
+
+# ===================================================================
+# (E) Main Inference Logic
+# ===================================================================
+
+@torch.no_grad()
+def main():
+    # 1. Load Models
+    logger.info("Loading pre-trained models...")
+    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order']).to(DEVICE)
+    hno_checkpoint = torch.load(HNO_CKPT_PATH, map_location=DEVICE)
+    hno_model.load_state_dict(hno_checkpoint['model_state_dict'])
+    hno_model.eval()
+
+    diffusion_model = DiffusionModel(
+        diff_cfg['data_dim'], diff_cfg['cond_input_dim'],
+        diff_cfg['cond_encoded_dim'], diff_cfg['hidden_dim']
+    ).to(DEVICE)
+    diff_checkpoint = torch.load(DIFF_CKPT_PATH, map_location=DEVICE)
+    diffusion_model.load_state_dict(diff_checkpoint['model_state_dict'])
+    diffusion_model.eval()
+    logger.info("Models loaded successfully.")
+
+    # 2. Process PDBs and Align
+    logger.info("Processing and aligning PDB files...")
+    ref_coords = get_heavy_atom_coords(CANONICAL_REF_PDB)
+    new_coords = get_heavy_atom_coords(pathlib.Path(args.pdb))
+    
+    ref_ca_indices = get_ca_indices(CANONICAL_REF_PDB)
+    new_ca_indices = get_ca_indices(pathlib.Path(args.pdb))
+
+    core_ref_idx, core_new_idx = find_mutual_nn_pairs(ref_coords[ref_ca_indices], new_coords[new_ca_indices])
+    
+    aligned_new_coords = align_by_core(new_coords, new_ca_indices[core_new_idx], ref_coords, ref_ca_indices[core_ref_idx])
+    logger.info(f"Aligned new PDB to canonical reference using {len(core_ref_idx)} core atom pairs.")
+    
+    # 3. Generate Novel z_ref
+    logger.info("Generating novel z_ref from new PDB...")
+    coords_tensor = torch.from_numpy(aligned_new_coords).float().to(DEVICE)
+    edge_index = knn_graph(coords_tensor, k=hno_cfg['knn_value'])
+    novel_z_ref = hno_model.forward_representation(coords_tensor, edge_index)
+    logger.info(f"Generated novel z_ref with shape: {novel_z_ref.shape}")
+
+    # 4. Generate Pooled Embeddings
+    logger.info(f"Generating {gen_cfg['num_gen']} pooled embeddings...")
+    T = diff_cfg['diffusion_steps']
+    betas = torch.linspace(diff_cfg['beta_start'], diff_cfg['beta_end'], T, device=DEVICE)
+    alphas = 1. - betas
+    alphas_cumprod = torch.cumprod(alphas, axis=0)
+    sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - alphas_cumprod)
+
+    shape = (gen_cfg['num_gen'], diff_cfg['data_dim'])
+    conditioner_batch = novel_z_ref.unsqueeze(0).repeat(shape[0], 1, 1)
+    x_t = torch.randn(shape, device=DEVICE)
+
+    for t in reversed(range(T)):
+        t_batch = torch.full((shape[0],), t, device=DEVICE, dtype=torch.long)
+        predicted_noise = diffusion_model(x_t, t_batch, conditioner_batch)
+        alpha_t = alphas[t]
+        beta_t = betas[t]
+        sqrt_recip_alpha_t = torch.sqrt(1.0 / alpha_t)
+        model_mean = sqrt_recip_alpha_t * (x_t - (beta_t / sqrt_one_minus_alphas_cumprod[t]) * predicted_noise)
+        if t > 0:
+            noise = torch.randn_like(x_t)
+            x_t = model_mean + torch.sqrt(beta_t) * noise
+        else:
+            x_t = model_mean
+    
+    generated_embeddings = x_t.cpu().numpy()
+    logger.info(f"Generated embeddings with shape: {generated_embeddings.shape}")
+
+    # 5. Save Outputs
+    output_path = pathlib.Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Saving results to {output_path}")
+    with h5py.File(output_path, 'w') as f:
+        f.create_dataset("generated_pooled_embeddings", data=generated_embeddings)
+        f.create_dataset("novel_z_ref_conditioner", data=novel_z_ref.cpu().numpy())
+    
+    logger.info("Inference complete.")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/conditional_generation/h5_to_pdb_novel.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import logging
+import h5py
+import numpy as np
+import pathlib
+import mdtraj as md
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Convert Novel Generated HDF5 Coordinates to PDB Files")
+parser.add_argument('--input', type=str, required=True, help='Path to the HDF5 file containing the generated coordinates.')
+parser.add_argument('--template_pdb', type=str, required=True, help='Path to the original PDB file that was used for generation, to be used as a template.')
+parser.add_argument('--output_dir', type=str, required=True, help='Directory to save the output PDB files.')
+parser.add_argument('--max_frames', type=int, default=100, help='The maximum number of PDB files to save from the HDF5 file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("HDF5 to PDB Converter for Novel Structures Started")
+
+# ===================================================================
+# (B) Main Conversion Logic
+# ===================================================================
+
+def main():
+    h5_input_path = pathlib.Path(args.input)
+    template_pdb_path = pathlib.Path(args.template_pdb)
+    pdb_output_dir = pathlib.Path(args.output_dir)
+
+    if not h5_input_path.is_file():
+        logger.error(f"Input HDF5 file not found: {h5_input_path}"); exit(1)
+    
+    if not template_pdb_path.is_file():
+        logger.error(f"Template PDB file not found: {template_pdb_path}"); exit(1)
+
+    pdb_output_dir.mkdir(parents=True, exist_ok=True)
+    logger.info(f"PDB files will be saved to: {pdb_output_dir.resolve()}")
+
+    # Load the template topology
+    try:
+        template_traj = md.load_pdb(str(template_pdb_path))
+        # We need the heavy-atom topology to match the generated coordinates
+        heavy_indices = template_traj.topology.select('not element H')
+        template_topology = template_traj.atom_slice(heavy_indices, inplace=False).topology
+        logger.info(f"Loaded template topology from {template_pdb_path} ({template_topology.n_atoms} heavy atoms)")
+    except Exception as e:
+        logger.error(f"Could not load template PDB: {e}"); exit(1)
+
+    # Open the HDF5 file and process the coordinates
+    with h5py.File(h5_input_path, 'r') as f:
+        if 'generated_coords' not in f:
+            logger.error(f"Dataset 'generated_coords' not found in {h5_input_path}. Aborting."); exit(1)
+            
+        coords_data = f['generated_coords'][:]
+        num_frames, num_atoms, _ = coords_data.shape
+        
+        if template_topology.n_atoms != num_atoms:
+            logger.error(f"Atom count mismatch! Template has {template_topology.n_atoms}, generated data has {num_atoms}. Cannot proceed.")
+            exit(1)
+
+        frames_to_save = min(num_frames, args.max_frames)
+        logger.info(f"Saving {frames_to_save} frames out of {num_frames} available.")
+
+        for i in range(frames_to_save):
+            try:
+                # Coordinates are in Angstroms, convert to nm for mdtraj
+                frame_coords_nm = coords_data[i] * 0.1
+                
+                new_traj = md.Trajectory([frame_coords_nm], topology=template_topology)
+                
+                output_pdb_path = pdb_output_dir / f"generated_novel_frame_{i+1}.pdb"
+                new_traj.save_pdb(str(output_pdb_path))
+            except Exception as e:
+                logger.error(f"Failed to save frame {i+1}: {e}")
+
+    logger.info(f"--- PDB file generation complete. Saved {frames_to_save} files. ---")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/conditional_generation/param_conditional.yaml

@@ -0,0 +1,123 @@
+# General Settings
+log_file: "logfile_multi_system.log" # Log file name
+num_workers: 0                       # Number of workers for DataLoader
+force_cpu: false                     # Set to true to force CPU usage
+cuda_device: 0                       # GPU index if CUDA is available and force_cpu is false
+
+# --- DATA INPUT CONFIGURATION (MODIFIED FOR MULTI-SYSTEM) ---
+# Each entry in the 'systems' list represents one protein to be trained on.
+data:
+  systems:
+
+    # --- System 1 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/condensed.json"
+
+    # --- System 2 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d1/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d1/run1/residues_data_0.5.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d1/run1/condensed.json"
+
+    # --- System 3 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_A2AR/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_A2AR/run1/residues_data_0.1.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_A2AR/run1/condensed.json"
+
+    # --- System 4 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_beta1/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_beta1/run1/residues_data_0.5.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_beta1/run1/condensed.json"
+
+    # --- System 5 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_M1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_M1/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_M1/condensed.json"
+
+    # --- System 6 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_H1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_H1/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_H1/condensed.json"
+
+    # --- System 7 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d3/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d3/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d3/condensed.json"
+
+    # --- System 8 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_beta2/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_beta2/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_beta2/condensed.json"
+
+    # --- System 9 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_h5t2a/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_h5t2a/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_h5t2a/condensed.json"
+
+    # --- System 10 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_5ht1b/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_5ht1b/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_5ht1b/condensed.json"
+
+
+# Graph Construction Settings
+graph:
+  knn_value: 4                       # K for k-NN graph construction
+
+# --- GLOBAL MODEL & TRAINING SETTINGS ---
+# These settings apply to the single, shared models trained on all systems.
+hno_encoder:
+  hidden_dim: 16
+  cheb_order: 4
+  num_epochs: 5
+  learning_rate: 0.0001
+  batch_size: 16
+  save_interval: 50
+
+decoder2:
+  num_epochs: 10
+  learning_rate: 0.0003
+  batch_size: 16
+  base_loss_weight: 1.0
+  save_interval: 500
+  use_z_ref_ensemble: false
+
+decoder2_settings:
+  conditioner_mode: "z_ref"          # Must be 'z_ref' for the multi-system code
+  mlp_hidden_dim: 16
+  num_hidden_layers: 12
+  # NOTE: pooling_type, output_height/width are no longer used by the new decoder
+  pooling_type: "blind"
+  output_height: 50
+  output_width: 2
+
+# Dihedral Loss Configuration (Global Weights)
+dihedral_loss:
+  # This is a global switch. Set to true to attempt using dihedral loss.
+  use_dihedral_loss: false
+  # The specific torsion_info_path is now defined per-system above.
+  lambda_divergence: 0.1
+  lambda_torsion_mse: 1.0
+  divergence_type: "JS"
+
+# Data Augmentation Settings
+data_augmentation:
+  enabled: true
+  ensemble_size: 50
+  target_ca_rmsd: 1.0
+
+# Structural Augmentation Settings
+structural_augmentation:
+  enabled: true
+  variants_per_system: 10
+
+# Execution Settings
+execution_settings:
+  limit_systems: 2
+  max_frames_per_system: 500
+
+# Output Directories Configuration
+output_directories:
+  checkpoint_dir: "checkpoints"
+  structure_dir: "structures"
+  latent_dir: "latent_reps"

LD-FPG-main/conditional_generation/param_conditional_diffusion.yaml

@@ -0,0 +1,59 @@
+# ===================================================================
+# Conditional Diffusion Model Configuration
+# ===================================================================
+
+# --- Data Paths ---
+# These paths point to the HDF5 files produced by the chebnet_conditional_setup.py script.
+data:
+  # Path to the HDF5 file containing the dynamic, frame-by-frame pooled embeddings.
+  embeddings_h5_path: "latent_reps/pooled_embeddings.h5"
+  
+  # Path to the HDF5 file containing the static reference conditioners (z_ref).
+  conditioners_h5_path: "latent_reps/reference_conditioners.h5"
+  
+  # Template for the group name within the HDF5 files. '{}' is replaced by the system ID.
+  group_key_template: "system_{}"
+  
+  # Name of the dataset within each group for the embeddings.
+  embedding_dataset_name: "embeddings"
+  
+  # Name of the dataset within each group for the single reference conditioner.
+  conditioner_dataset_name: "z_ref"
+  
+  # Name of the dataset within each group for the ensemble of conditioners.
+  conditioner_ensemble_dataset_name: "z_ref_ensemble"
+
+# --- Output Directory ---
+# Directory to save generated embeddings and model checkpoints.
+output_dir: "conditional_diffusion_output"
+
+
+# --- Model & Training Parameters ---
+parameters:
+  # --- Augmentation Control ---
+  # If true, the script will load the conditioner ensemble and randomly sample from it during training.
+  # This makes the model more robust to noise in the conditioner.
+  use_conditioner_ensemble: true
+
+  # --- Core Training ---
+  num_epochs: 100
+  batch_size: 128
+  learning_rate: 1e-5
+  
+  # Number of new embedding samples to generate for each conditioner.
+  num_gen: 1000
+  
+  # Frequency (in epochs) to save a model checkpoint.
+  save_interval: 2000
+  
+  # --- Model Architecture ---
+  model_type: "mlp_conditional_cnn_encoder" # For reference
+  hidden_dim: 2048              # Width of the main MLP layers
+  conditioner_encoded_dim: 256  # Dimension of the fixed-size vector from the CNN encoder
+  
+  # --- Diffusion Schedule ---
+  scheduler: "linear"
+  diffusion_steps: 1000
+  beta_start: 0.0001
+  beta_end: 0.02
+

LD-FPG-main/conditional_generation/param_decode_novel.yaml

@@ -0,0 +1,29 @@
+# ===================================================================
+# Configuration for Decoding Novel Latent Embeddings
+# ===================================================================
+
+paths:
+  # Path to the PRE-TRAINED decoder model checkpoint from the chebnet_conditional_setup.py run.
+  decoder_checkpoint_path: "checkpoints/decoder2_checkpoint.pth"
+
+# --- Decoder Model Settings ---
+# These parameters MUST EXACTLY MATCH the parameters used to train the decoder
+# in the chebnet_conditional_setup.py script (defined in its param_conditional.yaml).
+decoder2_settings:
+  # The dimensionality of the dynamic per-atom embeddings from the HNO encoder.
+  # This corresponds to hno_encoder.hidden_dim in the training config.
+  node_emb_dim: 16
+  
+  # The dimensionality of the static z_ref conditioner embeddings.
+  # This also corresponds to hno_encoder.hidden_dim.
+  cond_emb_dim: 16
+  
+  # The dimensions of the 2D pooling layer.
+  output_height: 50
+  output_width: 2
+  
+  # The dimensionality of the hidden layers within the final MLP decoder.
+  mlp_hidden_dim: 16
+  
+  # The number of hidden layers in the final MLP decoder.
+  num_hidden_layers: 12

LD-FPG-main/conditional_generation/param_generate_from_new.yaml

@@ -0,0 +1,50 @@
+# ===================================================================
+# Configuration for Generating Embeddings from a Novel PDB
+# ===================================================================
+
+# --- Input & Output Paths ---
+paths:
+  # Path to the PRE-TRAINED HNO encoder checkpoint from the chebnet_conditional_setup.py run.
+  hno_checkpoint_path: "checkpoints/hno_checkpoint.pth"
+  
+  # Path to the PRE-TRAINED conditional diffusion model checkpoint.
+  diffusion_checkpoint_path: "conditional_diffusion_output/checkpoints/cond_diffusion_latest.pth"
+  
+  # --- CRUCIAL: Canonical Reference ---
+  # Path to the FIRST PDB file that was used to train the original models.
+  # This is required to align the new PDB into the same coordinate system.
+  canonical_reference_pdb: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/heavy_chain.pdb"
+
+
+# --- Model Architecture Parameters ---
+# These parameters MUST EXACTLY MATCH the parameters used during the original training runs.
+
+hno_encoder:
+  hidden_dim: 16
+  cheb_order: 4
+  knn_value: 4
+
+diffusion_model:
+  # The dimension of the pooled latent embeddings.
+  # This is calculated as decoder2_settings.output_height * decoder2_settings.output_width from the training config.
+  data_dim: 100
+  
+  # The feature dimension of the z_ref conditioner (e.g., 16).
+  cond_input_dim: 16 # This should match hno_encoder.hidden_dim
+  
+  # The fixed-size dimension of the encoded conditioner.
+  cond_encoded_dim: 256
+  
+  # Width of the main diffusion MLP layers.
+  hidden_dim: 2048
+  
+  # Diffusion timestep parameters.
+  diffusion_steps: 1000
+  beta_start: 0.0001
+  beta_end: 0.02
+
+
+# --- Generation Settings ---
+generation_settings:
+  # Number of new pooled embedding samples to generate from the novel PDB.
+  num_gen: 500

LD-FPG-main/convert_atlas_xtc_to_h5_compact.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import traceback
+from pathlib import Path
+
+import h5py
+import mdtraj as md
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+
+def is_heavy_protein_atom(atom):
+    if not atom.residue.is_protein:
+        return False
+
+    if atom.element is not None:
+        return atom.element.symbol != "H"
+
+    name = atom.name.strip().upper()
+    return not name.startswith("H")
+
+
+def get_heavy_atom_indices(topology):
+    idx = []
+    for atom in topology.atoms:
+        if is_heavy_protein_atom(atom):
+            idx.append(atom.index)
+    return np.asarray(idx, dtype=np.int32)
+
+
+def find_entries(atlas_root, entry="all", max_entries=None):
+    atlas_root = Path(atlas_root)
+
+    if entry != "all":
+        return [entry]
+
+    entries = []
+    for d in sorted(atlas_root.iterdir()):
+        if not d.is_dir():
+            continue
+
+        name = d.name
+        pdb = d / f"{name}.pdb"
+        xtcs = sorted(d.glob(f"{name}_R*.xtc"))
+
+        if pdb.exists() and len(xtcs) > 0:
+            entries.append(name)
+
+    if max_entries is not None:
+        entries = entries[:max_entries]
+
+    return entries
+
+
+def get_compression_kwargs(args):
+    if args.compression == "none":
+        return {}
+
+    if args.compression == "gzip":
+        return {
+            "compression": "gzip",
+            "compression_opts": args.gzip_level,
+            "shuffle": True,
+        }
+
+    if args.compression == "lzf":
+        return {
+            "compression": "lzf",
+            "shuffle": True,
+        }
+
+    raise ValueError(args.compression)
+
+
+def write_heavy_chain_pdb(pdb_path, heavy_idx, out_pdb):
+    traj = md.load_pdb(str(pdb_path))
+    heavy = traj.atom_slice(heavy_idx)
+    heavy.save_pdb(str(out_pdb))
+
+
+def process_one_entry(entry, args):
+    entry_dir = Path(args.atlas_root) / entry
+    out_dir = Path(args.out_root) / entry
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    pdb_path = entry_dir / f"{entry}.pdb"
+    xtc_paths = sorted(entry_dir.glob(f"{entry}_R*.xtc"))
+
+    if not pdb_path.exists():
+        raise FileNotFoundError(f"Missing PDB: {pdb_path}")
+    if len(xtc_paths) == 0:
+        raise FileNotFoundError(f"Missing XTC files: {entry_dir}")
+
+    out_pdb = out_dir / "heavy_chain.pdb"
+    out_h5 = out_dir / "coords.h5"
+    out_meta = out_dir / "meta.json"
+
+    if out_pdb.exists() and out_h5.exists() and out_meta.exists() and not args.overwrite:
+        with open(out_meta, "r") as f:
+            return json.load(f)
+
+    pdb_traj = md.load_pdb(str(pdb_path))
+    heavy_idx = get_heavy_atom_indices(pdb_traj.topology)
+
+    if len(heavy_idx) == 0:
+        raise RuntimeError(f"No heavy protein atoms found: {entry}")
+
+    write_heavy_chain_pdb(pdb_path, heavy_idx, out_pdb)
+
+    n_heavy = int(len(heavy_idx))
+
+    if args.dtype == "float16":
+        h5_dtype = np.float16
+    elif args.dtype == "float32":
+        h5_dtype = np.float32
+    else:
+        raise ValueError(args.dtype)
+
+    compression_kwargs = get_compression_kwargs(args)
+
+    rep_names = []
+    rep_lengths = []
+
+    total_frames = 0
+
+    with h5py.File(out_h5, "w") as h5:
+        coords_ds = h5.create_dataset(
+            "coords",
+            shape=(0, n_heavy, 3),
+            maxshape=(None, n_heavy, 3),
+            chunks=(args.frame_chunk, n_heavy, 3),
+            dtype=h5_dtype,
+            **compression_kwargs,
+        )
+
+        rep_ids_ds = h5.create_dataset(
+            "rep_ids",
+            shape=(0,),
+            maxshape=(None,),
+            chunks=(max(args.frame_chunk, 1),),
+            dtype=np.uint8,
+            **compression_kwargs,
+        )
+
+        frame_ids_ds = h5.create_dataset(
+            "frame_ids_in_rep",
+            shape=(0,),
+            maxshape=(None,),
+            chunks=(max(args.frame_chunk, 1),),
+            dtype=np.int32,
+            **compression_kwargs,
+        )
+
+        for rep_id, xtc_path in enumerate(xtc_paths):
+            rep_name = xtc_path.stem.replace(f"{entry}_", "")
+            rep_names.append(rep_name)
+
+            rep_len = 0
+
+            for chunk in md.iterload(
+                str(xtc_path),
+                top=str(pdb_path),
+                chunk=args.xtc_chunk,
+                stride=args.stride,
+            ):
+                if args.max_frames_per_rep is not None:
+                    remaining = args.max_frames_per_rep - rep_len
+                    if remaining <= 0:
+                        break
+                    if chunk.n_frames > remaining:
+                        chunk = chunk[:remaining]
+
+                heavy_chunk = chunk.atom_slice(heavy_idx)
+
+                # MDTraj unit: nm. Save unit: Å.
+                xyz_A = heavy_chunk.xyz.astype(np.float32) * 10.0
+
+                if args.center:
+                    xyz_A = xyz_A - xyz_A.mean(axis=1, keepdims=True)
+
+                if h5_dtype == np.float16:
+                    xyz_A = xyz_A.astype(np.float16)
+                else:
+                    xyz_A = xyz_A.astype(np.float32)
+
+                n_new = xyz_A.shape[0]
+                start = total_frames
+                end = total_frames + n_new
+
+                coords_ds.resize((end, n_heavy, 3))
+                rep_ids_ds.resize((end,))
+                frame_ids_ds.resize((end,))
+
+                coords_ds[start:end] = xyz_A
+                rep_ids_ds[start:end] = np.full(n_new, rep_id, dtype=np.uint8)
+                frame_ids_ds[start:end] = np.arange(rep_len, rep_len + n_new, dtype=np.int32)
+
+                total_frames = end
+                rep_len += n_new
+
+            rep_lengths.append(int(rep_len))
+
+        h5.attrs["entry"] = entry
+        h5.attrs["unit"] = "angstrom"
+        h5.attrs["dtype"] = args.dtype
+        h5.attrs["n_frames"] = int(total_frames)
+        h5.attrs["n_heavy_atoms"] = int(n_heavy)
+        h5.attrs["frame_order"] = "R1_then_R2_then_R3"
+        h5.attrs["coords_centered"] = bool(args.center)
+
+    meta = {
+        "entry": entry,
+        "source_dir": str(entry_dir),
+        "source_pdb": str(pdb_path),
+        "source_xtc": [str(x) for x in xtc_paths],
+        "heavy_chain_pdb": str(out_pdb),
+        "coords_h5": str(out_h5),
+        "n_frames": int(total_frames),
+        "n_heavy_atoms": int(n_heavy),
+        "n_replicates": int(len(xtc_paths)),
+        "rep_names": rep_names,
+        "rep_lengths": rep_lengths,
+        "frame_order": "R1_then_R2_then_R3",
+        "unit": "angstrom",
+        "dtype": args.dtype,
+        "compression": args.compression,
+        "gzip_level": args.gzip_level if args.compression == "gzip" else None,
+        "stride": int(args.stride),
+        "xtc_chunk": int(args.xtc_chunk),
+        "frame_chunk": int(args.frame_chunk),
+        "max_frames_per_rep": args.max_frames_per_rep,
+        "center": bool(args.center),
+        "h5_size_MB": out_h5.stat().st_size / 1024 / 1024,
+        "pdb_size_MB": out_pdb.stat().st_size / 1024 / 1024,
+    }
+
+    with open(out_meta, "w") as f:
+        json.dump(meta, f, indent=2)
+
+    return meta
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--atlas_root",
+        default="/raid_zoe/home/lr/wangyi/p/atlas_1000_analysis",
+    )
+    parser.add_argument(
+        "--out_root",
+        default="/raid_zoe/home/lr/wangyi/p/atlas_h5_fp16",
+    )
+
+    parser.add_argument("--entry", default="all")
+    parser.add_argument("--max_entries", type=int, default=None)
+
+    parser.add_argument("--dtype", choices=["float16", "float32"], default="float16")
+    parser.add_argument("--compression", choices=["gzip", "lzf", "none"], default="gzip")
+    parser.add_argument("--gzip_level", type=int, default=4)
+
+    parser.add_argument("--stride", type=int, default=1)
+    parser.add_argument("--xtc_chunk", type=int, default=100)
+    parser.add_argument("--frame_chunk", type=int, default=64)
+    parser.add_argument("--max_frames_per_rep", type=int, default=None)
+
+    parser.add_argument("--center", action="store_true")
+    parser.add_argument("--overwrite", action="store_true")
+
+    args = parser.parse_args()
+
+    out_root = Path(args.out_root)
+    summary_dir = out_root / "_summary"
+    log_dir = out_root / "_logs"
+
+    out_root.mkdir(parents=True, exist_ok=True)
+    summary_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    entries = find_entries(
+        args.atlas_root,
+        entry=args.entry,
+        max_entries=args.max_entries,
+    )
+
+    print(f"atlas_root: {args.atlas_root}")
+    print(f"out_root: {args.out_root}")
+    print(f"entries: {len(entries)}")
+    print(f"dtype: {args.dtype}")
+    print(f"compression: {args.compression}")
+
+    records = []
+    success = []
+    failed = []
+
+    for entry in tqdm(entries, desc="convert_h5"):
+        try:
+            meta = process_one_entry(entry, args)
+            records.append(meta)
+            success.append(entry)
+        except Exception as e:
+            failed.append(entry)
+            with open(log_dir / f"{entry}.error.txt", "w") as f:
+                f.write(traceback.format_exc())
+            print(f"\n[FAILED] {entry}: {e}")
+
+    df = pd.DataFrame(records)
+    df.to_csv(summary_dir / "conversion_summary.tsv", sep="\t", index=False)
+
+    with open(log_dir / "success.txt", "w") as f:
+        f.write("\n".join(success) + "\n")
+
+    with open(log_dir / "failed.txt", "w") as f:
+        f.write("\n".join(failed) + "\n")
+
+    total_h5_gb = df["h5_size_MB"].sum() / 1024 if len(df) else 0.0
+    total_pdb_gb = df["pdb_size_MB"].sum() / 1024 if len(df) else 0.0
+
+    report = {
+        "success": len(success),
+        "failed": len(failed),
+        "total_h5_GB": float(total_h5_gb),
+        "total_pdb_GB": float(total_pdb_gb),
+        "total_GB": float(total_h5_gb + total_pdb_gb),
+    }
+
+    with open(summary_dir / "size_report.json", "w") as f:
+        json.dump(report, f, indent=2)
+
+    print("\nDone.")
+    print(f"Success: {len(success)}")
+    print(f"Failed: {len(failed)}")
+    print(f"Total H5 size: {total_h5_gb:.2f} GB")
+    print(f"Total PDB size: {total_pdb_gb:.2f} GB")
+    print(f"Total size: {total_h5_gb + total_pdb_gb:.2f} GB")
+    print(f"Summary: {summary_dir / 'conversion_summary.tsv'}")
+    print(f"Size report: {summary_dir / 'size_report.json'}")
+
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor/README.md

@@ -0,0 +1,83 @@
+# Multi-System Protein Conformation Generation Pipeline
+
+This repository contains a suite of Python scripts that form a complete deep learning pipeline for analyzing, modeling, and generating novel 3D conformations of multiple protein systems.
+
+The core workflow is a three-stage **Encode -> Generate -> Decode** process, followed by a final conversion step to produce PDB files for visualization.
+
+## Core Components
+
+The pipeline consists of four main scripts, each with its own YAML configuration file. They are designed to be run in sequence.
+
+### 1. Encoder: `chebnet_multi_final.py`
+- **Configuration:** `param_new.yaml`
+- **Role:** This is the primary learning stage. The script trains a graph-based autoencoder on simulation data from multiple protein systems. It learns a shared, low-dimensional "language" of protein structure.
+- **Inputs:**
+    - PDB files for multiple protein structures.
+    - JSON files containing coordinate trajectories for each system.
+- **Key Outputs:**
+    - `checkpoints/decoder2_checkpoint.pth`: The trained decoder model, essential for the final stage.
+    - `latent_reps/pooled_embeddings.h5`: The compressed (latent) representation for every frame of the input simulations.
+    - `latent_reps/reference_conditioners.h5`: The static latent representation (`z_ref`) for the reference structure of each system.
+
+### 2. Generator: `diffusion_multi_system.py`
+- **Configuration:** `param_diff.yaml`
+- **Role:** This script trains a generative diffusion model. For each protein system, it learns the specific statistical distribution of its latent embeddings. It can then generate new, artificial embeddings from scratch that conform to this learned distribution.
+- **Inputs:**
+    - `latent_reps/pooled_embeddings.h5`: The latent vectors produced by the encoder.
+- **Key Outputs:**
+    - `diffusion_output/generated_embeddings_sys<ID>_exp<N>.h5`: HDF5 files containing new, artificially generated latent embeddings. It creates one file per experiment (`exp<N>`) for each system (`sys<ID>`).
+
+### 3. Decoder: `chebnet_gen_multi.py`
+- **Configuration:** `param_gen_multi.yaml`
+- **Role:** This script translates the artificial latent embeddings from the diffusion model back into full 3D structures. It acts as the bridge between the abstract latent space and physical coordinates.
+- **Inputs:**
+    - `checkpoints/decoder2_checkpoint.pth`: The trained decoder model from Stage 1.
+    - `latent_reps/reference_conditioners.h5`: The static `z_ref` for each system.
+    - The `diffusion_output/` directory containing all generated embeddings.
+- **Key Outputs:**
+    - `generated_structures/multi_system_generated_coords.h5`: A single, organized HDF5 file containing the full 3D coordinates of the newly generated structures. The file has a nested structure to separate results by system and experiment (e.g., `system_0/exp_1/coords`).
+
+### 4. Converter: `h5_to_pdb_multi.py`
+- **Configuration:** `param_h5_to_pdb_multi.yaml`
+- **Role:** The final utility step. This script converts the generated 3D coordinates from the HDF5 file into standard PDB files that can be viewed in molecular visualization software.
+- **Inputs:**
+    - `generated_structures/multi_system_generated_coords.h5`: The final coordinate file from Stage 3.
+    - The original PDB files for each system, which are used as templates for atom/residue information.
+- **Key Outputs:**
+    - `generated_pdbs/`: A directory containing the final, viewable PDB files, organized into sub-directories by system and experiment.
+
+## Workflow: How to Run the Pipeline
+
+Execute the scripts in the following order. Ensure you have configured the corresponding YAML file before each step.
+
+**Step 1: Train the Encoder**
+```bash
+python chebnet_multi_final.py --config param_new.yaml
+```
+
+**Step 2: Train Diffusion Models and Generate Latent Embeddings**
+This step must be run **once for each system** you want to model. The `--system_id` flag specifies which system's data to use from the encoder's output.
+
+```bash
+# Run for System 0
+python diffusion_multi_system.py --config param_diff.yaml --system_id 0
+
+# Run for System 1
+python diffusion_multi_system.py --config param_diff.yaml --system_id 1
+
+# ...and so on for all other systems.
+```
+
+**Step 3: Decode Generated Embeddings into 3D Coordinates**
+This script finds all the generated embeddings from the previous step and processes them in one go.
+```bash
+python chebnet_gen_multi.py --config param_gen_multi.yaml
+```
+
+**Step 4: Convert Final Coordinates to PDB Files**
+This final step converts the HDF5 coordinate data into viewable PDB files.
+```bash
+python h5_to_pdb_multi.py --config param_h5_to_pdb_multi.yaml
+```
+
+After completing these steps, the `generated_pdbs/` directory will contain your final results.

LD-FPG-main/multi_receptor/chebnet_gen_multi.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import pathlib
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Multi-System Structure Generator from Diffusion Embeddings")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("Multi-System Structure Generator Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+paths = config.get('paths', {})
+d2s = config.get('decoder2_settings', {})
+
+DECODER_CKPT_PATH = pathlib.Path(paths['decoder_checkpoint_path'])
+CONDITIONERS_H5_PATH = pathlib.Path(paths['conditioners_h5_path'])
+GEN_EMBEDDINGS_DIR = pathlib.Path(paths['generated_embeddings_dir'])
+OUTPUT_H5_PATH = pathlib.Path(paths['output_structures_h5_path'])
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+# Ensure output directory exists
+OUTPUT_H5_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+# ===================================================================
+# (C) Model Definition (Must match the trained model)
+# ===================================================================
+
+# This class is a simplified version of the one in chebnet_multi_final.py
+# It is redefined here to make this script standalone for generation.
+class ProteinStateReconstructor2D(nn.Module):
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int,
+                 output_height: int, output_width: int,
+                 mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        # The pooling layer is not used in this simplified forward pass, but its
+        # parameters are kept to correctly calculate the mlp_in_dim, ensuring
+        # that the architecture matches the saved checkpoint weights.
+        pooled_dim = output_height * output_width
+        mlp_in_dim = cond_emb_dim + pooled_dim
+
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+        self.logger.info(f"Instantiated Decoder. MLP Input Dim: {mlp_in_dim}")
+
+    def forward(self, pooled_embedding: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        """
+        A corrected forward pass for generation from a pre-pooled embedding.
+        'pooled_embedding' is the direct output from the diffusion model.
+        'conditioner_z_ref' is the static per-atom conditioner.
+        """
+        num_atoms = conditioner_z_ref.shape[0]
+        
+        # The input 'pooled_embedding' is already the correct, flattened, pooled vector.
+        # We just need to broadcast it to each atom.
+        # It should have shape [pooled_dim], we unsqueeze to [1, pooled_dim] for expand.
+        pooled_per_node = pooled_embedding.unsqueeze(0).expand(num_atoms, -1)
+        
+        # Concatenate the static conditioner with the broadcasted pooled vector
+        mlp_input = torch.cat([conditioner_z_ref, pooled_per_node], dim=1)
+        
+        # Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+        return pred_coords
+
+# ===================================================================
+# (D) Main Generation Logic
+# ===================================================================
+
+def main():
+    # 1. Instantiate and load the trained decoder model
+    logger.info("Loading trained decoder model...")
+    if not DECODER_CKPT_PATH.is_file():
+        logger.error(f"Decoder checkpoint not found at {DECODER_CKPT_PATH}"); exit(1)
+
+    model = ProteinStateReconstructor2D(
+        node_emb_dim=d2s['node_emb_dim'],
+        cond_emb_dim=d2s['cond_emb_dim'],
+        output_height=d2s['output_height'],
+        output_width=d2s['output_width'],
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    ).to(DEVICE)
+
+    checkpoint = torch.load(DECODER_CKPT_PATH, map_location=DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+    logger.info("Decoder model loaded successfully.")
+
+    # 2. Find all generated embedding files to process
+    if not GEN_EMBEDDINGS_DIR.is_dir():
+        logger.error(f"Generated embeddings directory not found: {GEN_EMBEDDINGS_DIR}"); exit(1)
+    
+    embedding_files = sorted(list(GEN_EMBEDDINGS_DIR.glob("generated_embeddings_sys*.h5")))
+    if not embedding_files:
+        logger.error(f"No generated embedding files found in {GEN_EMBEDDINGS_DIR}"); exit(1)
+    
+    logger.info(f"Found {len(embedding_files)} generated embedding files to process.")
+
+    # 3. NEW: Use a nested dictionary for aggregation: {sid: {exp_id: [coords]}}
+    aggregated_coords = {}
+
+    # 4. Loop through each file, generate structures, and store in the dictionary
+    for emb_file in embedding_files:
+        try:
+            # --- Robustly parse SID and EXP_ID from filename ---
+            filename_parts = emb_file.stem.split('_')
+            sid_part = next((part for part in filename_parts if part.startswith('sys')), None)
+            exp_part = next((part for part in filename_parts if part.startswith('exp')), None)
+
+            if not sid_part or not exp_part:
+                logger.warning(f"Could not parse SID and EXP from filename {emb_file.name}. Skipping.")
+                continue
+            
+            sid = int(sid_part.replace('sys', ''))
+            exp_id = int(exp_part.replace('exp', ''))
+            logger.info(f"--- Processing SID: {sid}, EXP: {exp_id} from file {emb_file.name} ---")
+
+            # a. Load the corresponding z_ref conditioner
+            with h5py.File(CONDITIONERS_H5_PATH, 'r') as f_cond:
+                group_name = f"system_{sid}"
+                if group_name not in f_cond:
+                    logger.warning(f"Group '{group_name}' not in conditioner file. Skipping.")
+                    continue
+                z_ref = torch.from_numpy(f_cond[group_name]['z_ref'][:]).float().to(DEVICE)
+
+            # b. Load the generated pooled embeddings
+            with h5py.File(emb_file, 'r') as f_emb:
+                group_key = next((k for k in f_emb.keys() if k.startswith('system_')), None)
+                if not group_key: continue
+                dset_name = "embeddings" if "embeddings" in f_emb[group_key] else "generated_embeddings"
+                if dset_name not in f_emb[group_key]: continue
+                pooled_embeddings = torch.from_numpy(f_emb[group_key][dset_name][:]).float().to(DEVICE)
+            
+            logger.info(f"Loaded {pooled_embeddings.shape[0]} embeddings and conditioner of shape {z_ref.shape}")
+
+            # c. Decode each embedding and store in nested dictionary
+            if sid not in aggregated_coords:
+                aggregated_coords[sid] = {}
+            if exp_id not in aggregated_coords[sid]:
+                aggregated_coords[sid][exp_id] = []
+
+            with torch.no_grad():
+                for i in range(pooled_embeddings.shape[0]):
+                    pooled_emb = pooled_embeddings[i]
+                    coords = model(pooled_emb, z_ref).cpu().numpy()
+                    aggregated_coords[sid][exp_id].append(coords)
+
+        except Exception as e:
+            logger.error(f"Failed to process file {emb_file.name}: {e}", exc_info=True)
+
+    # 5. NEW: Write the aggregated results using the nested structure
+    with h5py.File(OUTPUT_H5_PATH, 'w') as f_out:
+        logger.info(f"Writing aggregated structures to {OUTPUT_H5_PATH}")
+        for sid, exp_data in sorted(aggregated_coords.items()):
+            sys_group = f_out.create_group(f"system_{sid}")
+            logger.info(f"Created group for system {sid}")
+            for exp_id, coords_list in sorted(exp_data.items()):
+                if not coords_list: continue
+                
+                stacked_coords = np.array(coords_list)
+                exp_group = sys_group.create_group(f"exp_{exp_id}")
+                exp_group.create_dataset("coords", data=stacked_coords, compression="gzip")
+                logger.info(f"  - Saved {stacked_coords.shape[0]} structures for exp_{exp_id}")
+
+    logger.info("--- All systems processed. Final structures saved. ---")
+
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor/chebnet_multi_final.py

@@ -0,0 +1,985 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from typing import Dict, List, Optional, Tuple, Any
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv, global_mean_pool
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import NearestNeighbors # New dependency
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load
+################################################################################
+LOG_FILE_DEFAULT = "logfile_multi_system.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstruction")
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+if not logger.handlers:
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    try:
+        fh = logging.FileHandler(log_file_path, mode="w")
+        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+    except IOError as e:
+        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
+logger.info(f"Logger initialized. Log file: {log_file_path}")
+if args.debug: logger.debug("Debug mode is ON.")
+
+################################################################################
+# (D) Device Setup (Global)
+################################################################################
+device_name = "cpu"
+if torch.cuda.is_available():
+    try:
+        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
+        device_name = f"cuda:{cuda_device_index}"
+        torch.cuda.get_device_name(cuda_device_index)
+    except Exception:
+        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
+        if torch.cuda.is_available(): device_name = "cuda:0"
+global_device = torch.device(device_name)
+logger.info(f"Initial device check: {global_device}")
+
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+# --- PDB Parsing ---
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
+    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line in pdb_file:
+                if not line.startswith("ATOM  "): continue
+                alt_loc = line[16].strip()
+                if alt_loc not in ['', 'A']: continue
+
+                atom_serial = int(line[6:11])
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+
+                atom_name = line[12:16].strip()
+                res_name = line[17:20].strip()
+                chain_id = line[21].strip()
+                res_seq = int(line[22:26])
+                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+
+                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
+                if atom_name == 'CA': ca_indices[res_seq] = atom_serial
+
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
+    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
+    return {}, atoms_in_order, ca_indices
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int]]:
+    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
+    new_res_dict, orig_atom_map = {}, {}
+    next_new_res_id, next_new_atom_index = 0, 0
+    orig_res_map = {}
+    
+    # Preserve original residue order
+    seen_res_order = {}
+    res_order_counter = 0
+    for r_id, _, _, _ in atoms_in_order:
+        if r_id not in seen_res_order:
+            seen_res_order[r_id] = res_order_counter
+            res_order_counter += 1
+
+    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
+    sortable.sort()
+
+    for _, serial, r_id, cat, name in sortable:
+        if r_id not in orig_res_map:
+            orig_res_map[r_id] = next_new_res_id
+            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
+            next_new_res_id += 1
+        
+        new_res_id = orig_res_map[r_id]
+        new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index
+        next_new_atom_index += 1
+
+    # Map original CA serial numbers to the new, renumbered 0-based indices
+    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
+    
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
+    return new_res_dict, orig_atom_map, {}, new_ca_indices
+
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()):
+        bb_idx.extend(renumbered_dict[res_id]["backbone"])
+        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)
+
+# --- JSON Loading ---
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
+    
+    try:
+        keys_int = sorted([int(k) for k in data.keys()])
+        keys_str = [str(k) for k in keys_int]
+        if not keys_str: logger.error("No residue data in JSON."); return [], -1
+        
+        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
+        n_frames = len(frame_data)
+        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0
+
+        coords_frames, n_atoms_check = [], -1
+        for frame_idx in range(n_frames):
+            frame_coords_np = []
+            current_atoms = 0
+            for res_key in keys_str:
+                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
+                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
+                frame_coords_np.append(coords)
+                current_atoms += coords.shape[0]
+
+            if frame_idx == 0:
+                n_atoms_check = current_atoms
+                logger.info(f"System has {n_atoms_check} atoms and {n_frames} frames.")
+            elif current_atoms != n_atoms_check:
+                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
+            
+            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))
+
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1
+
+# --- Alignment ---
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
+    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try: V, S, Wt = torch.linalg.svd(C)
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
+        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
+        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
+        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
+    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
+    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
+    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    if not coords: logger.warning("Coordinate list empty."); return []
+    ref = coords[0].to(device)
+    aligned = [coords[0].cpu()]
+    n_frames = len(coords) -1
+    for i, frame in enumerate(coords[1:], 1):
+        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
+        aligned.append(aligned_dev.cpu())
+    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
+    return aligned
+
+# --- ROBUST ALIGNMENT UTILITIES for MULTI-SYSTEM ---
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
+    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
+    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
+        raise ValueError("Input coordinates must be 2D arrays.")
+
+    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
+    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
+    
+    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
+    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
+    
+    ref_indices, target_indices = [], []
+    for i, target_idx in enumerate(indices1.flatten()):
+        # *** PATCH 1: Correctly index the result from kneighbors ***
+        if indices2[target_idx, 0] == i:
+            ref_indices.append(i)
+            target_indices.append(target_idx)
+            
+    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
+    if not ref_indices:
+        logger.error("No mutual nearest neighbors found. Cannot align structures.")
+        return torch.tensor([]), torch.tensor([])
+        
+    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)
+
+def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
+                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
+                  logger: logging.Logger) -> torch.Tensor:
+    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
+    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
+    device = structure_to_align.device
+
+    P_core = reference_structure[core_indices_reference].to(device)
+    Q_core = structure_to_align[core_indices_to_align].to(device)
+    
+    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
+    
+    centroid_Q_core = compute_centroid(Q_core)
+    structure_to_align_centered = structure_to_align - centroid_Q_core
+    
+    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
+    
+    centroid_P_core = compute_centroid(P_core)
+    aligned_structure = structure_to_align_rotated + centroid_P_core
+    
+    return aligned_structure
+
+# --- Graph Dataset ---
+def build_graph_dataset(aligned_coords_list: List[torch.Tensor], unaligned_coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
+    dataset = []
+    n_frames = len(aligned_coords_list)
+    logger.debug(f"[Graph Build] Building dataset for system {system_id} with {n_frames} frames. First frame coord shape: {aligned_coords_list[0].shape}")
+    for i, (aligned_coords_cpu, unaligned_coords_cpu) in enumerate(zip(aligned_coords_list, unaligned_coords_list)):
+        coords_dev = aligned_coords_cpu.to(device)
+        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
+        if logger.isEnabledFor(logging.DEBUG) and i == 0:
+            logger.debug(f"[Graph Build] Frame 0: coords_cpu shape: {aligned_coords_cpu.shape}, edge_index shape: {edge_idx.shape}")
+        data = Data(x=aligned_coords_cpu, edge_index=edge_idx.cpu(), y=aligned_coords_cpu, y_unaligned=unaligned_coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
+        dataset.append(data)
+    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
+    return dataset
+
+# --- Dihedral Utilities ---
+@torch.jit.script
+def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
+    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
+    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
+    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
+    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)
+
+def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
+    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
+    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(f"[Dihedral Calc] Input coords shape: {coords.shape}")
+    for name, angle_info in info.items():
+        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
+        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
+        if indices is not None and res_idx is not None and indices[0].numel() > 0:
+            try:
+                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
+                max_atom_idx_needed = max(i.max() for i in idx_dev)
+                if max_atom_idx_needed >= N_atoms:
+                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
+                    continue
+                
+                a,b,c,d = (coords[:, i, :] for i in idx_dev)
+                values = compute_dihedral(a,b,c,d)
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(f"[Dihedral Calc] Angle '{name}': computed values shape: {values.shape}, scatter indices shape: {res_idx_dev.shape}")
+                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
+            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
+        all_angles[name] = angles_out
+    return all_angles
+
+
+def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
+    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
+    eps=1e-10
+    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
+    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
+    p_dist = p_hist / (p_hist.sum() + eps)
+    t_dist = t_hist / (t_hist.sum() + eps)
+    m_dist = 0.5 * (p_dist + t_dist)
+    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))
+
+# --- Checkpoint Utilities & MSE Utilities ---
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            ckpt = torch.load(filename, map_location=device)
+            start_epoch = ckpt.get("epoch", 0)
+            model.load_state_dict(ckpt["model_state_dict"])
+            if optimizer and "optimizer_state_dict" in ckpt:
+                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+                for state in optimizer.state.values():
+                    for k, v in state.items():
+                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
+            model.to(device)
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
+            start_epoch = 0
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
+    model.to(device)
+    return model, optimizer, start_epoch
+
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    crit = nn.MSELoss()
+    all_mse = crit(pred, target)
+    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
+    return all_mse, bb_mse, sc_mse
+
+
+################################################################################
+# (F) Model Definitions
+################################################################################
+
+# --- HNO Encoder ---
+class HNO(nn.Module):
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self._debug_logged_train = False
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head
+
+    def forward(self, x, edge_index):
+        x = x.float()
+        x_in = x
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        x_rep = F.normalize(x, p=2.0, dim=1)
+        x_recon = self.mlpRep(x_rep)
+        
+        if self.training and not self._debug_logged_train and logger.isEnabledFor(logging.DEBUG):
+             logger.debug(f"[HNO Train Fwd] Input shape: {x_in.shape}, Edge index shape: {edge_index.shape}")
+             logger.debug(f"[HNO Train Fwd] Output shapes: Rep={x_rep.shape}, Recon={x_recon.shape}")
+             self._debug_logged_train = True
+        return x_recon
+
+    def forward_representation(self, x, edge_index):
+        x = x.float()
+        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
+        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
+        x = self.bano3(F.relu(self.conv3(x, edge_index)))
+        x = self.conv4(x, edge_index)
+        return F.normalize(x, p=2.0, dim=1)
+
+# --- ROBUST Decoder2 Model (CORRECTED LOGIC) ---
+class ProteinStateReconstructor2D(nn.Module):
+    """
+    Size-agnostic decoder. For each graph, it pools the dynamic embedding to a
+    fixed size using AdaptiveAvgPool2d, flattens it, and concatenates this
+    global dynamic vector to the static (z_ref) conditioner for each node.
+    """
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int,
+                 output_height: int, output_width: int,
+                 mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        self._logged_fwd = False
+        self.node_emb_dim = node_emb_dim
+
+        # 1. Define the 2D pooling layer
+        self.pool_layer = nn.AdaptiveAvgPool2d((output_height, output_width))
+        pooled_dim = output_height * output_width
+
+        # 2. Define the final MLP input dimension
+        # It's the static conditioner + the flattened, pooled dynamic embedding
+        mlp_in_dim = cond_emb_dim + pooled_dim
+
+        # 3. Build the MLP
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+
+        self.logger.info(f"Initialized Decoder2 (Corrected). Pool size: ({output_height}, {output_width}). MLP Input Dim: {mlp_in_dim}")
+
+    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Decoder Fwd Start] Input x shape: {x.shape}, conditioner_z_ref shape: {conditioner_z_ref.shape}")
+
+        # Since graphs in the batch have different sizes, we must loop.
+        pooled_vectors = []
+        for i in range(batch.max().item() + 1):
+            # a. Get the dynamic embedding for the current graph
+            graph_mask = (batch == i)
+            x_graph = x[graph_mask] # Shape: [n_nodes_in_graph, node_emb_dim]
+            n_nodes, n_emb = x_graph.shape
+
+            # b. Reshape for 2D pooling: [B, C, H, W] -> [1, 1, n_nodes, n_emb]
+            x_graph_4d = x_graph.unsqueeze(0).unsqueeze(0)
+
+            # c. Apply pooling and flatten
+            pooled_graph = self.pool_layer(x_graph_4d)
+            flattened_pooled = pooled_graph.view(1, -1) # Shape: [1, pooled_dim]
+            pooled_vectors.append(flattened_pooled)
+
+        # d. Combine pooled vectors for the whole batch
+        batch_pooled = torch.cat(pooled_vectors, dim=0) # Shape: [num_graphs, pooled_dim]
+
+        # e. Broadcast the correct pooled vector to each node in its respective graph
+        pooled_per_node = batch_pooled[batch] # Shape: [total_nodes, pooled_dim]
+
+        # f. Concatenate the static conditioner with the broadcasted pooled vector
+        mlp_input = torch.cat([conditioner_z_ref, pooled_per_node], dim=1)
+
+        # g. Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+
+        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
+            self.logger.debug(f"[Decoder Fwd Pools] Pooled vector shape (per graph): {pooled_vectors[0].shape}")
+            self.logger.debug(f"[Decoder Fwd Pools] Broadcasted pooled shape: {pooled_per_node.shape}")
+            self.logger.debug(f"[Decoder Fwd End] mlp_input shape: {mlp_input.shape}, Final output pred_coords shape: {pred_coords.shape}")
+            self._logged_fwd = True
+
+        return pred_coords
+
+################################################################################
+# (G) Training Functions
+################################################################################
+
+# --- Train HNO ---
+def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
+    model=model.to(dev)
+    params = list(filter(lambda p: p.requires_grad, model.parameters()))
+    opt = torch.optim.Adam(params, lr=lr) if params else None
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+    
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+
+    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        total_loss = 0.0
+        for i, data in enumerate(tr_loader):
+            data=data.to(dev)
+            if ep == start_ep and i == 0 and logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"[HNO Batching] Batch contains {data.num_graphs} graphs.")
+                logger.debug(f"[HNO Batching] data.x shape: {data.x.shape}")
+                logger.debug(f"[HNO Batching] data.ptr: {data.ptr}")
+                logger.debug(f"[HNO Batching] Total nodes in batch: {data.num_nodes}")
+                logger.debug(f"[HNO Batching] System IDs in batch: {data.system_id.squeeze().tolist()}")
+
+            opt.zero_grad(set_to_none=True)
+            pred = model(data.x, data.edge_index)
+            loss = F.mse_loss(pred, data.y)
+            loss.backward()
+            opt.step()
+            total_loss += loss.item()
+        avg_tr_loss = total_loss / len(tr_loader)
+        
+        model.eval()
+        total_val_loss = 0.0
+        with torch.no_grad():
+            for data in te_loader:
+                data=data.to(dev)
+                pred=model(data.x, data.edge_index)
+                total_val_loss += F.mse_loss(pred, data.y).item()
+        avg_te_loss = total_val_loss / len(te_loader)
+
+        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+    
+    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
+    return model
+
+# --- ROBUST Train Decoder2 ---
+def train_decoder2_model(
+    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
+    all_conditioners: Dict[int, torch.Tensor],
+    all_sys_info: Dict[int, Any],
+    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
+    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
+):
+    model = model.to(dev)
+    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
+    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
+
+    if start_ep >= N_epochs:
+        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
+        return model
+        
+    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
+    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")
+
+    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
+        
+        for i, data in enumerate(tr_loader):
+            data = data.to(dev)
+            opt.zero_grad(set_to_none=True)
+            
+            if i == 0 and logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"[Decoder Batching] data.x (embeddings) shape: {data.x.shape}")
+                logger.debug(f"[Decoder Batching] data.y (coords) shape: {data.y.shape}")
+                logger.debug(f"[Decoder Batching] data.ptr: {data.ptr}")
+
+            # --- Assemble Batch-Specific Conditioners ---
+            cond_list = []
+            if i == 0 and logger.isEnabledFor(logging.DEBUG):
+                sids_in_batch = [d.item() for d in data.system_id]
+                logger.debug(f"[Decoder Verify] SIDs in batch 0: {sids_in_batch}")
+
+            for j in range(data.num_graphs):
+                sid = data.system_id[j].item()
+                num_nodes = data.ptr[j+1] - data.ptr[j]
+                cond = all_conditioners[sid].to(dev)
+
+                if i == 0 and j < 4 and logger.isEnabledFor(logging.DEBUG): # Log first few graphs
+                    logger.debug(f"[Decoder Verify] Graph {j}: Matched SID {sid}. Conditioner shape: {cond.shape}")
+                
+                if cond.shape[0] != num_nodes:
+                    raise ValueError(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
+                cond_list.append(cond)
+            conditioners_for_batch = torch.cat(cond_list, dim=0)
+            if i == 0 and logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"[Decoder Conditioners] Assembled batch conditioners shape: {conditioners_for_batch.shape}")
+
+            # --- Forward Pass ---
+            pred = model(data.x, data.batch, conditioners_for_batch)
+            
+            # --- ROBUST Loss Calculation (Graph by Graph) ---
+            total_loss = torch.tensor(0.0, device=dev)
+            for j in range(data.num_graphs):
+                graph_start, graph_end = data.ptr[j], data.ptr[j+1]
+                sid = data.system_id[j].item()
+
+                pred_graph = pred[graph_start:graph_end]
+                target_graph = data.y[graph_start:graph_end]
+                
+                if i == 0 and j < 2 and logger.isEnabledFor(logging.DEBUG): # Log first 2 graphs of first batch
+                    logger.debug(f"[Decoder Loss Loop] Graph {j}, SID {sid}: pred_graph shape: {pred_graph.shape}, target_graph shape: {target_graph.shape}")
+
+                # Coordinate Loss for this graph
+                bb_idx = all_sys_info[sid]['bb_idx_local']
+                sc_idx = all_sys_info[sid]['sc_idx_local']
+                
+                coord_mse_graph, _, _ = compute_bb_sc_mse(pred_graph, target_graph, bb_idx, sc_idx, logger)
+                total_loss += base_w * coord_mse_graph
+                tr_metrics['coord'] += coord_mse_graph.item()
+
+                # Dihedral Loss for this graph
+                if use_di and sid in all_di_info:
+                    pred_3d = pred_graph.unsqueeze(0) # Add batch dim
+                    target_3d = target_graph.unsqueeze(0)
+                    
+                    pred_a = compute_all_dihedrals_vectorized(pred_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    true_a = compute_all_dihedrals_vectorized(target_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
+                    
+                    di_div_loss_graph = torch.tensor(0.0, device=dev)
+                    di_mse_loss_graph = torch.tensor(0.0, device=dev)
+                    for name in pred_a:
+                        pa, ta = pred_a[name], true_a[name]
+                        if pa.numel() > 0:
+                             di_div_loss_graph += comp_div(pa, ta)
+                             di_mse_loss_graph += F.mse_loss(pa, ta)
+                    
+                    total_loss += l_div * di_div_loss_graph + l_mse * di_mse_loss_graph
+                    tr_metrics['di_div'] += di_div_loss_graph.item()
+                    tr_metrics['di_mse'] += di_mse_loss_graph.item()
+
+            # Average loss over the number of graphs in the batch
+            avg_batch_loss = total_loss / data.num_graphs
+            tr_metrics['total'] += avg_batch_loss.item()
+            
+            avg_batch_loss.backward()
+            opt.step()
+        
+        # Log training stats (validation loop omitted for brevity but should be added)
+        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
+        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
+        
+        ep_num = ep + 1
+        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
+            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
+            
+    logger.info("Finished Decoder2 training.")
+    return model
+
+
+################################################################################
+# (H) Final Data Export Function
+################################################################################
+@torch.no_grad()
+def export_final_outputs_multi(
+    hno: 'HNO',
+    dec2: 'ProteinStateReconstructor2D',
+    full_dset: List['Data'],
+    dec_in_dset: List['Data'],
+    all_conditioners: Dict[int, torch.Tensor],
+    all_sys_info: Dict[int, Any],
+    struct_dir: str,
+    latent_dir: str,
+    dev: torch.device,
+    logger: logging.Logger
+):
+    """
+    Exports final ground truth, reconstructions, and embeddings for all systems
+    to HDF5 files, with data for each system stored in a separate group.
+    """
+    logger.info("--- Stage 5: Starting Final Data Export ---")
+    hno.eval()
+    dec2.eval()
+
+    # 1. Initialize data storage
+    outputs_by_sid = {
+        sid: {'gt_aligned': [], 'gt_unaligned': [], 'hno_rec': [], 'full_rec': [], 'hno_emb': [], 'pooled_emb': []}
+        for sid in all_sys_info.keys()
+    }
+
+    # 2. Loop through datasets and perform inference
+    logger.info("Running inference on all frames...")
+    full_loader = DataLoader(full_dset, batch_size=32, shuffle=False)
+    dec_in_loader = DataLoader(dec_in_dset, batch_size=32, shuffle=False)
+
+    # Store intermediate results to avoid recomputing embeddings
+    temp_embs = {}
+
+    with torch.no_grad():
+        # First, get all HNO reconstructions and embeddings
+        for i, data in enumerate(full_loader):
+            data = data.to(dev)
+            hno_recon = hno(data.x, data.edge_index)
+            hno_embedding = hno.forward_representation(data.x, data.edge_index)
+            
+            for j in range(data.num_graphs):
+                sid = data.system_id[j].item()
+                start, end = data.ptr[j], data.ptr[j+1]
+                
+                outputs_by_sid[sid]['gt_aligned'].append(data.y[start:end].cpu())
+                outputs_by_sid[sid]['gt_unaligned'].append(data.y_unaligned[start:end].cpu())
+                outputs_by_sid[sid]['hno_rec'].append(hno_recon[start:end].cpu())
+                outputs_by_sid[sid]['hno_emb'].append(hno_embedding[start:end].cpu())
+                
+                # Store for decoder pass
+                if sid not in temp_embs: temp_embs[sid] = []
+                temp_embs[sid].append(hno_embedding[start:end])
+
+
+        # Second, get all Decoder reconstructions and pooled embeddings
+        for i, emb_data in enumerate(dec_in_loader):
+            emb_data = emb_data.to(dev)
+            
+            # Assemble conditioners for the batch
+            cond_list = [all_conditioners[sid.item()].to(dev) for sid in emb_data.system_id]
+            conditioner = torch.cat(cond_list, dim=0)
+
+            # Decoder forward pass
+            full_recon = dec2(emb_data.x, emb_data.batch, conditioner)
+
+            # Pooled embedding logic (replicated from decoder's forward)
+            pooled_vectors = []
+            for j in range(emb_data.num_graphs):
+                graph_mask = (emb_data.batch == j)
+                x_graph = emb_data.x[graph_mask]
+                
+                x_graph_4d = x_graph.unsqueeze(0).unsqueeze(0)
+                pooled_graph = dec2.pool_layer(x_graph_4d)
+                flattened_pooled = pooled_graph.view(1, -1)
+                pooled_vectors.append(flattened_pooled)
+            
+            batch_pooled = torch.cat(pooled_vectors, dim=0)
+
+            # Split results and store
+            for j in range(emb_data.num_graphs):
+                sid = emb_data.system_id[j].item()
+                start, end = emb_data.ptr[j], emb_data.ptr[j+1]
+                
+                outputs_by_sid[sid]['full_rec'].append(full_recon[start:end].cpu())
+                outputs_by_sid[sid]['pooled_emb'].append(batch_pooled[j].cpu())
+
+
+    # 3. Write stacked data to HDF5 files
+    logger.info("Writing exported data to HDF5 files...")
+    os.makedirs(struct_dir, exist_ok=True)
+    os.makedirs(latent_dir, exist_ok=True)
+
+    # Define output files
+    coord_files = {
+        'gt_aligned': os.path.join(struct_dir, 'gt_coords_aligned.h5'),
+        'gt_unaligned': os.path.join(struct_dir, 'gt_coords_unaligned.h5'),
+        'hno_rec': os.path.join(struct_dir, 'hno_reconstructed_coords.h5'),
+        'full_rec': os.path.join(struct_dir, 'full_reconstructed_coords.h5')
+    }
+    emb_files = {
+        'hno_emb': os.path.join(latent_dir, 'hno_embeddings.h5'),
+        'pooled_emb': os.path.join(latent_dir, 'pooled_embeddings.h5')
+    }
+
+    # Write coordinate data
+    for key, path in coord_files.items():
+        with h5py.File(path, 'w') as f:
+            logger.debug(f"Writing to {path}")
+            for sid, data in outputs_by_sid.items():
+                if data[key]:
+                    stacked_data = torch.stack(data[key]).numpy()
+                    grp = f.create_group(f"system_{sid}")
+                    grp.create_dataset("coords", data=stacked_data, compression="gzip")
+                    logger.debug(f"  - Wrote system_{sid}/coords with shape {stacked_data.shape}")
+
+    # Write embedding data
+    for key, path in emb_files.items():
+        with h5py.File(path, 'w') as f:
+            logger.debug(f"Writing to {path}")
+            for sid, data in outputs_by_sid.items():
+                if data[key]:
+                    stacked_data = torch.stack(data[key]).numpy()
+                    grp = f.create_group(f"system_{sid}")
+                    grp.create_dataset("embeddings", data=stacked_data, compression="gzip")
+                    logger.debug(f"  - Wrote system_{sid}/embeddings with shape {stacked_data.shape}")
+
+    logger.info("--- Finished Final Data Export ---")
+
+
+################################################################################
+# (I) Main Execution Function
+################################################################################
+def main():
+    start_time = time.time()
+    logger.info("================ Script Starting (Multi-System Version) ================")
+    global global_device
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    logger.info("Successfully loaded configuration.")
+    
+    force_cpu = config.get("force_cpu", False)
+    device = torch.device("cpu") if force_cpu else global_device
+    pin_mem = (device.type == "cuda")
+    num_workers = config.get("num_workers", 0)
+    
+    hno_cfg = config["hno_encoder"]
+    dec2_cfg = config["decoder2"]
+    d2s = config["decoder2_settings"]
+    di_cfg = config.get("dihedral_loss", {})
+    out_cfg = config["output_directories"]
+    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]
+
+    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
+    
+    full_dset = []
+    all_sys_info = {}
+    canonical_ref_coords = None
+    canonical_ref_ca_indices = None
+
+    systems_to_process = config["data"]["systems"]
+    limit = config.get("execution_settings", {}).get("limit_systems")
+    if limit is not None and isinstance(limit, int) and limit > 0:
+        systems_to_process = systems_to_process[:limit]
+        logger.info(f"[INFO] Limiting run to the first {limit} systems as specified in the config.")
+
+    for i, system_config in enumerate(systems_to_process):
+        sid = i
+        pdb_p = system_config["pdb_path"]
+        json_p = system_config["json_path"]
+        logger.info(f"--- Processing System ID {sid}: {os.path.basename(pdb_p)} ---")
+
+        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
+        renum_d, _, _, ca_indices_new = renumber_atoms_and_residues(atoms_ord, ca_serial_map)
+        bb_idx, sc_idx = get_global_indices(renum_d)
+        
+        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger)
+        if not coords_list: continue
+        unaligned_coords_list = [c.clone() for c in coords_list]
+        logger.debug(f"[Data Load] Loaded {len(coords_list)} frames for SID {sid}, each with {n_atoms} atoms. First frame shape: {coords_list[0].shape}")
+
+        all_sys_info[sid] = {
+            'n_atoms': n_atoms,
+            'ca_indices': ca_indices_new,
+            'bb_idx_local': bb_idx,
+            'sc_idx_local': sc_idx,
+            'n_res': len(renum_d)
+        }
+
+        aligned_coords_list = []
+        if sid == 0:
+            logger.info(f"System {sid} is the canonical reference.")
+            canonical_ref_coords = coords_list[0].clone()
+            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
+            logger.debug(f"[Alignment] Canonical ref (SID 0) set. Coords shape: {canonical_ref_coords.shape}, CA indices shape: {canonical_ref_ca_indices.shape}")
+        else:
+            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
+            target_ref_coords = coords_list[0]
+            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
+            
+            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
+                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
+                target_ref_coords[target_ca_indices].numpy(),
+                logger
+            )
+            logger.debug(f"[Alignment] SID {sid}: Found {len(core_ref_idx)} pairs. Core ref idx shape: {core_ref_idx.shape}, Core target idx shape: {core_target_idx.shape}")
+            
+            aligned_target_ref_frame = align_by_core(
+                target_ref_coords, target_ca_indices[core_target_idx],
+                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
+                logger
+            )
+            logger.debug(f"[Alignment] SID {sid}: Aligned target ref frame shape: {aligned_target_ref_frame.shape}")
+            
+            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
+            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)
+
+        system_dset = build_graph_dataset(aligned_coords_list, unaligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
+        full_dset.extend(system_dset)
+
+    logger.info(f"--- Finished data loading. Total frames in dataset: {len(full_dset)} ---")
+
+    logger.info("--- Stage 2: Training Shared HNO Encoder ---")
+    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
+    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
+    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
+    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
+    hno_model.eval()
+
+    logger.info("--- Stage 3: Preparing Decoder Input Dataset & Conditioners ---")
+    dec_in_dset = []
+    all_conditioners = {}
+    
+    with torch.no_grad():
+        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
+        logger.debug(f"[Decoder Prep] Starting inference to generate embeddings. DataLoader has {len(infer_load)} batches.")
+        for i, batch in enumerate(infer_load):
+            batch = batch.to(device)
+            emb = hno_model.forward_representation(batch.x, batch.edge_index)
+            split_sizes = (batch.ptr[1:] - batch.ptr[:-1]).tolist()
+            emb_list = torch.split(emb, split_sizes)
+            y_list = torch.split(batch.y, split_sizes)
+            
+            if i == 0 and logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"[Decoder Prep] Batch 0: emb shape: {emb.shape}, split sizes: {split_sizes}")
+                logger.debug(f"[Decoder Prep] Batch 0: After split, emb_list has {len(emb_list)} tensors. First tensor shape: {emb_list[0].shape}")
+
+            for j in range(len(emb_list)):
+                dec_in_dset.append(Data(x=emb_list[j].cpu(), y=y_list[j].cpu(), system_id=batch.system_id[j].cpu().reshape(1)))
+    
+    logger.debug(f"[Decoder Prep] Finished. Total items in decoder dataset: {len(dec_in_dset)}")
+
+    if d2s['conditioner_mode'] == 'z_ref':
+        for sid in all_sys_info.keys():
+            ref_data_orig = next(d for d in full_dset if d.system_id.item() == sid)
+            ref_data_dev = ref_data_orig.clone().to(device)
+            with torch.no_grad():
+                z_ref = hno_model.forward_representation(ref_data_dev.x, ref_data_dev.edge_index)
+                all_conditioners[sid] = z_ref.cpu()
+                logger.debug(f"[Decoder Prep] Generated 'z_ref' conditioner for SID {sid}. Shape: {z_ref.shape}")
+        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
+    else:
+        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")
+
+    logger.info("--- Stage 4: Decoder2 Setup & Training ---")
+    
+    all_di_info = {}
+    use_di_train = di_cfg.get("use_dihedral_loss", False)
+    if use_di_train:
+        logger.info("Preparing dihedral information for all systems...")
+        # Placeholder for dihedral parsing logic
+        # This needs to be implemented based on the JSON structure
+    
+    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
+    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
+    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
+    
+    dec2_model = ProteinStateReconstructor2D(
+        node_emb_dim=hno_cfg['hidden_dim'],
+        cond_emb_dim=hno_cfg['hidden_dim'],
+        output_height=d2s['output_height'],
+        output_width=d2s['output_width'],
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    )
+    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
+    dec2_model = train_decoder2_model(
+        dec2_model, load_tr_dec, load_te_dec, all_conditioners, all_sys_info,
+        dec2_cfg['num_epochs'], dec2_cfg['learning_rate'], dec2_ckpt, dec2_cfg['save_interval'], device, logger,
+        dec2_cfg['base_loss_weight'], use_di_train, all_di_info,
+        di_cfg.get('divergence_type', 'JS'), di_cfg.get('lambda_divergence', 0.0), di_cfg.get('lambda_torsion_mse', 0.0)
+    )
+
+    # --- Stage 5: Final Export ---
+    export_final_outputs_multi(
+        hno=hno_model,
+        dec2=dec2_model,
+        full_dset=full_dset,
+        dec_in_dset=dec_in_dset,
+        all_conditioners=all_conditioners,
+        all_sys_info=all_sys_info,
+        struct_dir=out_cfg['structure_dir'],
+        latent_dir=out_cfg['latent_dir'],
+        dev=device,
+        logger=logger
+    )
+
+    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")
+
+################################################################################
+# (J) Script Entry Point
+################################################################################
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor/diffusion_multi_system.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import pathlib
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Multi-System Diffusion Model Runner")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.')
+parser.add_argument('--system_id', type=int, default=None, help='Override the system_to_train from the config file.')
+parser.add_argument('--exp_idx', type=int, default=None, help='For grid search: run a single specific experiment index (1-based).')
+parser.add_argument('--instance_id', type=int, default=0, help='For grid search: instance ID for splitting experiments.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+parser.add_argument('--log_file', type=str, default="diffusion_runner.log", help='Path to log file.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+
+# Configure root logger
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+# Add file handler
+file_handler = logging.FileHandler(args.log_file, mode='w')
+file_handler.setFormatter(logging.Formatter(log_format))
+logger.addHandler(file_handler)
+
+logger.info("Diffusion Runner Script Started (Multi-System Version)")
+logger.info(f"Running with arguments: {args}")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Determine which system to train on (command line overrides YAML)
+SYSTEM_ID_TO_TRAIN = args.system_id if args.system_id is not None else config.get('system_to_train')
+if SYSTEM_ID_TO_TRAIN is None:
+    logger.error("Must specify 'system_to_train' in YAML or via --system_id argument."); exit(1)
+logger.info(f"--- TARGET SYSTEM ID FOR THIS RUN: {SYSTEM_ID_TO_TRAIN} ---")
+
+# Extract parameters
+params = config.get('parameters', {})
+RUN_MODE = config.get('run_mode', 'user_defined')
+H5_FILE_PATH = pathlib.Path(config['h5_file_path'])
+GROUP_TEMPLATE = config['dataset_group_key_template']
+DATASET_NAME = config['dataset_name_in_group']
+OUTPUT_DIR = pathlib.Path(config['output_dir'])
+
+# Global training variables from params
+BATCH_SIZE = params.get('batch_size', 64)
+NUM_EPOCHS = params.get('num_epochs', 50000)
+LEARNING_RATE = params.get('learning_rate', 1e-5)
+NUM_GENERATE = params.get('num_gen', 5000)
+SAVE_INTERVAL = params.get('save_interval', 1000)
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+# Setup output directories
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+checkpoint_dir = OUTPUT_DIR / f'checkpoints_sys_{SYSTEM_ID_TO_TRAIN}'
+checkpoint_dir.mkdir(exist_ok=True)
+logger.info(f"Output directory for this run: {OUTPUT_DIR.resolve()}")
+logger.info(f"Checkpoint directory for this run: {checkpoint_dir.resolve()}")
+
+
+# ===================================================================
+# (C) Data Loading for Specified System
+# ===================================================================
+
+logger.info(f"Loading data from: {H5_FILE_PATH}")
+if not H5_FILE_PATH.is_file():
+    logger.error(f"Input HDF5 file not found: {H5_FILE_PATH}"); exit(1)
+
+try:
+    with h5py.File(H5_FILE_PATH, 'r') as f:
+        group_name = GROUP_TEMPLATE.format(SYSTEM_ID_TO_TRAIN)
+        if group_name not in f:
+            logger.error(f"Group '{group_name}' not found in {H5_FILE_PATH}. Available groups: {list(f.keys())}"); exit(1)
+        
+        if DATASET_NAME not in f[group_name]:
+            logger.error(f"Dataset '{DATASET_NAME}' not found in group '{group_name}'."); exit(1)
+            
+        # Shape is expected to be (N_frames, EmbeddingDim) e.g. (N, 100)
+        data_for_system = f[group_name][DATASET_NAME][:]
+        logger.info(f"Successfully loaded data for system {SYSTEM_ID_TO_TRAIN}. Shape: {data_for_system.shape}")
+
+except Exception as e:
+    logger.error(f"Failed to read HDF5 file: {e}", exc_info=True); exit(1)
+
+# Normalize data
+data_mean = data_for_system.mean()
+data_std = data_for_system.std()
+epsilon = 1e-9
+normalized_data = (data_for_system - data_mean) / (data_std + epsilon)
+logger.info(f"Data normalization stats: mean={data_mean:.6f}, std={data_std:.6f}")
+
+# Create Dataset and DataLoader
+class EmbeddingDataset(Dataset):
+    def __init__(self, data_tensor):
+        self.data = data_tensor.astype(np.float32)
+    def __len__(self):
+        return self.data.shape[0]
+    def __getitem__(self, idx):
+        return torch.from_numpy(self.data[idx])
+
+dataset_obj = EmbeddingDataset(normalized_data)
+dataloader = DataLoader(dataset_obj, batch_size=BATCH_SIZE, shuffle=True, num_workers=0, pin_memory=True)
+
+# ===================================================================
+# (D) Diffusion Model & Utilities
+# ===================================================================
+
+# --- Diffusion schedule variables (will be updated per experiment) ---
+betas, alphas, alphas_cumprod, sqrt_alphas_cumprod, sqrt_one_minus_alphas_cumprod = [None] * 5
+current_diffusion_steps = None
+current_exp_params = {} # Global placeholder for current experiment params
+
+def linear_beta_schedule(timesteps, beta_start, beta_end):
+    return torch.linspace(beta_start, beta_end, timesteps, device=DEVICE)
+
+# --- Checkpoint helpers ---
+def save_checkpoint(state, filename):
+    try:
+        torch.save(state, filename)
+        logger.info(f"Checkpoint saved: {filename}")
+    except Exception as e:
+        logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model, optimizer, filename):
+    start_epoch = 0
+    if filename.is_file():
+        logger.info(f"Loading checkpoint: '{filename}'")
+        try:
+            checkpoint = torch.load(filename, map_location=DEVICE)
+            start_epoch = checkpoint.get('epoch', 0)
+            model.load_state_dict(checkpoint['model_state_dict'])
+            if optimizer: optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+            model.to(DEVICE)
+            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+        except Exception as e:
+            logger.error(f"Error loading checkpoint {filename}: {e}. Training from scratch.", exc_info=False)
+            start_epoch = 0
+    return model, optimizer, start_epoch
+
+# --- Diffusion Model Architectures ---
+class DiffusionMLPBase(nn.Module):
+    def _prepare_input(self, x, t):
+        t_norm = (t.float().unsqueeze(1) / current_diffusion_steps)
+        return torch.cat([x, t_norm], dim=1)
+
+class DiffusionMLP_v2(DiffusionMLPBase):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim + 1, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, input_dim)
+        )
+    def forward(self, x, t):
+        return self.net(self._prepare_input(x, t))
+
+# --- Forward/Reverse Process ---
+def q_sample(x_0, t, noise=None):
+    if noise is None: noise = torch.randn_like(x_0)
+    sqrt_alpha_cumprod_t = sqrt_alphas_cumprod[t].view(-1, 1)
+    sqrt_one_minus_alpha_cumprod_t = sqrt_one_minus_alphas_cumprod[t].view(-1, 1)
+    return sqrt_alpha_cumprod_t * x_0 + sqrt_one_minus_alpha_cumprod_t * noise
+
+@torch.no_grad()
+def p_sample_loop(model, shape):
+    logger.info(f"Starting sampling process for shape: {shape}")
+    x_t = torch.randn(shape, device=DEVICE)
+    for t in reversed(range(current_diffusion_steps)):
+        if t % (current_diffusion_steps // 10) == 0:
+            logger.debug(f"Sampling step {t}/{current_diffusion_steps}")
+        t_batch = torch.full((shape[0],), t, device=DEVICE, dtype=torch.long)
+        predicted_noise = model(x_t, t_batch)
+        
+        alpha_t = alphas[t]
+        beta_t = betas[t]
+        
+        sqrt_recip_alpha_t = torch.sqrt(1.0 / alpha_t)
+        model_mean = sqrt_recip_alpha_t * (x_t - (beta_t / sqrt_one_minus_alphas_cumprod[t]) * predicted_noise)
+        
+        if t > 0:
+            noise = torch.randn_like(x_t)
+            posterior_variance = beta_t 
+            x_t = model_mean + torch.sqrt(posterior_variance) * noise
+        else:
+            x_t = model_mean
+    logger.info("Sampling finished.")
+    return x_t
+
+# ===================================================================
+# (E) Training Loop
+# ===================================================================
+
+def train_diffusion_model(model, optimizer, num_epochs_target, checkpoint_path):
+    criterion = nn.MSELoss()
+    model.train()
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path)
+
+    if start_epoch >= num_epochs_target:
+        logger.warning(f"Loaded checkpoint epoch ({start_epoch}) >= target epochs ({num_epochs_target}). Skipping training.")
+        return 0.0
+
+    logger.info(f"Starting training from epoch {start_epoch + 1} up to {num_epochs_target}...")
+    last_avg_epoch_loss = 0.0
+    for epoch in range(start_epoch, num_epochs_target):
+        epoch_loss = 0.0
+        for i, batch_data in enumerate(dataloader):
+            x0 = batch_data.to(DEVICE)
+            optimizer.zero_grad()
+            
+            t = torch.randint(0, current_diffusion_steps, (x0.shape[0],), device=DEVICE).long()
+            noise = torch.randn_like(x0)
+            x_t = q_sample(x0, t, noise=noise)
+            
+            predicted_noise = model(x_t, t)
+            loss = criterion(predicted_noise, noise)
+            
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+        
+        avg_epoch_loss = epoch_loss / len(dataloader)
+        last_avg_epoch_loss = avg_epoch_loss
+        if (epoch + 1) % 10 == 0 or (epoch + 1) == num_epochs_target:
+             logger.info(f"Epoch {epoch+1}/{num_epochs_target}, Avg Loss: {avg_epoch_loss:.6f}")
+
+        if (epoch + 1) % SAVE_INTERVAL == 0 or (epoch + 1) == num_epochs_target:
+            save_checkpoint({
+                'epoch': epoch + 1,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'loss': avg_epoch_loss,
+                'params': {k: v for k, v in current_exp_params.items() if isinstance(v, (int, float, str, bool))}
+            }, checkpoint_path)
+    
+    logger.info(f"Training finished. Final Avg Loss: {last_avg_epoch_loss:.6f}")
+    return last_avg_epoch_loss
+
+# ===================================================================
+# (F) Main Experiment Execution
+# ===================================================================
+
+def main():
+    """Main function to run the experiment(s)."""
+    global betas, alphas, alphas_cumprod, sqrt_alphas_cumprod, sqrt_one_minus_alphas_cumprod, current_diffusion_steps, current_exp_params
+
+    experiments_to_run = []
+    current_run_start_idx = 0
+
+    if RUN_MODE == 'grid_search':
+        logger.info("Building curated hyperparameter grid for grid_search mode.")
+        grid_params = config.get('grid_search_space', {})
+        curated_experiments = []
+        
+        # Fixed parameters for the grid
+        fixed_lr = grid_params.get('learning_rate', 1e-5)
+        fixed_epochs = grid_params.get('num_epochs', 50000)
+        fixed_model = grid_params.get('model_type', 'mlp_v2')
+        fixed_hidden = grid_params.get('hidden_dim', 1024)
+
+        # Group 1: Explore beta_end and diffusion_steps around a small beta_start
+        group1_params = [
+            {"diffusion_steps": 1200, "beta_end": 0.02}, {"diffusion_steps": 1400, "beta_end": 0.03},
+            {"diffusion_steps": 1500, "beta_end": 0.03}, {"diffusion_steps": 1400, "beta_end": 0.02},
+            {"diffusion_steps": 1400, "beta_end": 0.04}, {"diffusion_steps": 1600, "beta_end": 0.03},
+        ]
+        for exp in group1_params:
+            curated_experiments.append({
+                'learning_rate': fixed_lr, 'num_epochs': fixed_epochs, 'hidden_dim': fixed_hidden,
+                'model_type': fixed_model, 'beta_start': 5e-6, 'beta_end': exp["beta_end"],
+                'scheduler': "linear", 'diffusion_steps': exp["diffusion_steps"]
+            })
+
+        # Group 2: Explore diffusion_steps around a larger beta range
+        for steps in np.linspace(450, 550, 5, dtype=int):
+            curated_experiments.append({
+                'learning_rate': fixed_lr, 'num_epochs': fixed_epochs, 'hidden_dim': fixed_hidden,
+                'model_type': fixed_model, 'beta_start': 0.005, 'beta_end': 0.1,
+                'scheduler': "linear", 'diffusion_steps': int(steps)
+            })
+        
+        experiments_all = curated_experiments
+        num_total_experiments = len(experiments_all)
+        logger.info(f"Total curated experiments generated: {num_total_experiments}")
+
+        if args.exp_idx is not None:
+            if not 1 <= args.exp_idx <= num_total_experiments:
+                logger.error(f"Invalid --exp_idx {args.exp_idx}; valid range is 1 to {num_total_experiments}."); exit(1)
+            experiments_to_run = [experiments_all[args.exp_idx - 1]]
+            current_run_start_idx = args.exp_idx - 1
+        else:
+            num_instances = params.get('num_instances', 1)
+            base_size = num_total_experiments // num_instances
+            remainder = num_total_experiments % num_instances
+            sizes = [base_size + 1 if i < remainder else base_size for i in range(num_instances)]
+            starts = [sum(sizes[:i]) for i in range(num_instances)]
+            ends = [sum(sizes[:i+1]) for i in range(num_instances)]
+            
+            current_run_start_idx = starts[args.instance_id]
+            current_run_end_idx = ends[args.instance_id]
+            experiments_to_run = experiments_all[current_run_start_idx:current_run_end_idx]
+            logger.info(f"[Instance {args.instance_id}] Running {len(experiments_to_run)} experiments (Indices {current_run_start_idx} to {current_run_end_idx - 1})")
+
+    elif RUN_MODE == 'user_defined':
+        experiments_to_run = [params]
+    else:
+        logger.error(f"Unknown run_mode: {RUN_MODE}. Choose 'grid_search' or 'user_defined'."); exit(1)
+
+    logger.info(f"Number of experiments to execute in this run: {len(experiments_to_run)}")
+    experiment_results = []
+
+    # --- Experiment Loop ---
+    for loop_idx, exp_params in enumerate(experiments_to_run):
+        global_exp_index = current_run_start_idx + loop_idx + 1
+        current_exp_params = exp_params # Set for checkpointing
+
+        logger.info(f"========== Starting Experiment {global_exp_index} for System {SYSTEM_ID_TO_TRAIN} ==========")
+        logger.info(f"Parameters: {exp_params}")
+
+        # --- Setup Diffusion Schedule ---
+        current_diffusion_steps = int(exp_params['diffusion_steps'])
+        betas = linear_beta_schedule(current_diffusion_steps, float(exp_params['beta_start']), float(exp_params['beta_end']))
+        alphas = 1.0 - betas
+        alphas_cumprod = torch.cumprod(alphas, dim=0)
+        sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod)
+        sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - alphas_cumprod)
+
+        # --- Instantiate Model ---
+        model_input_dim = data_for_system.shape[1] # e.g., 100
+        model_type = exp_params.get('model_type', 'mlp_v2')
+        if model_type == 'mlp_v2':
+            model_instance = DiffusionMLP_v2(input_dim=model_input_dim, hidden_dim=int(exp_params['hidden_dim']))
+        else:
+            logger.error(f"Unsupported model_type '{model_type}' in this version."); continue
+        
+        model_instance.to(DEVICE)
+        optimizer_instance = optim.Adam(model_instance.parameters(), lr=float(exp_params['learning_rate']))
+        
+        # --- Train Model ---
+        checkpoint_filename = checkpoint_dir / f"diffusion_checkpoint_exp{global_exp_index}.pth"
+        final_loss = train_diffusion_model(
+            model=model_instance,
+            optimizer=optimizer_instance,
+            num_epochs_target=int(exp_params.get('num_epochs', NUM_EPOCHS)),
+            checkpoint_path=checkpoint_filename
+        )
+
+        # --- Generate and Save Samples ---
+        model_instance.eval()
+        generation_shape = (NUM_GENERATE, model_input_dim)
+        logger.info(f"Generating {NUM_GENERATE} samples with shape {generation_shape}...")
+        generated_samples_norm = p_sample_loop(model_instance, generation_shape).cpu().numpy()
+        
+        logger.info("Un-normalizing generated samples...")
+        generated_samples_unnorm = generated_samples_norm * (data_std + epsilon) + data_mean
+        logger.info(f"Final generated embeddings shape: {generated_samples_unnorm.shape}")
+        
+        save_path = OUTPUT_DIR / f"generated_embeddings_sys{SYSTEM_ID_TO_TRAIN}_exp{global_exp_index}.h5"
+        try:
+            with h5py.File(save_path, 'w') as f:
+                group = f.create_group(GROUP_TEMPLATE.format(SYSTEM_ID_TO_TRAIN))
+                dset = group.create_dataset(DATASET_NAME, data=generated_samples_unnorm)
+                dset.attrs['source_system_id'] = SYSTEM_ID_TO_TRAIN
+                dset.attrs['source_h5_file'] = str(H5_FILE_PATH)
+                for key, val in exp_params.items():
+                    if isinstance(val, (int, float, str, bool)):
+                        dset.attrs[key] = val
+            logger.info(f"Saved {NUM_GENERATE} generated embeddings to: {save_path}")
+        except Exception as e:
+            logger.error(f"Failed to save generated embeddings to {save_path}: {e}")
+
+        experiment_results.append({
+            'exp_idx': global_exp_index,
+            'params': exp_params,
+            'final_loss': final_loss,
+            'save_path': str(save_path)
+        })
+        logger.info(f"========== Finished Experiment {global_exp_index} ==========")
+
+    # --- Final Summary ---
+    logger.info("All specified experiments for this run are complete.")
+    print("\n========== Run Summary ==========")
+    for result in experiment_results:
+        summary_line = f"System {SYSTEM_ID_TO_TRAIN}, Exp {result['exp_idx']}: Loss={result.get('final_loss', 'N/A'):.6f}, Output='{result.get('save_path', 'N/A')}'"
+        print(summary_line)
+        logger.info(f"Summary - {summary_line}")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor/h5_to_pdb_multi.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import h5py
+import numpy as np
+import pathlib
+import mdtraj as md
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Multi-System HDF5 to PDB Converter")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("HDF5 to PDB Converter Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+paths = config.get('paths', {})
+settings = config.get('settings', {})
+
+H5_INPUT_PATH = pathlib.Path(paths['generated_h5_path'])
+PDB_OUTPUT_DIR = pathlib.Path(paths['pdb_output_dir'])
+TEMPLATE_PDB_PATHS = paths.get('template_pdb_paths', [])
+
+FRAMES_PER_SYSTEM = settings.get('max_frames_to_save', 100)
+
+# ===================================================================
+# (C) Main Conversion Logic
+# ===================================================================
+
+def main():
+    if not H5_INPUT_PATH.is_file():
+        logger.error(f"Input HDF5 file not found: {H5_INPUT_PATH}"); exit(1)
+    
+    if not TEMPLATE_PDB_PATHS:
+        logger.error("No 'template_pdb_paths' provided in the configuration. Cannot create PDBs."); exit(1)
+
+    PDB_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    logger.info(f"PDB files will be saved to: {PDB_OUTPUT_DIR.resolve()}")
+
+    # Load all template topologies into memory
+    templates = {}
+    for i, pdb_path in enumerate(TEMPLATE_PDB_PATHS):
+        try:
+            templates[i] = md.load_pdb(pdb_path)
+            logger.info(f"Loaded template for System ID {i} from {pdb_path}")
+        except Exception as e:
+            logger.error(f"Could not load template PDB for System ID {i} from {pdb_path}: {e}")
+    
+    if not templates:
+        logger.error("Failed to load any valid PDB templates. Aborting."); exit(1)
+
+    # Open the HDF5 file and process each system and experiment
+    with h5py.File(H5_INPUT_PATH, 'r') as f:
+        logger.info(f"Scanning HDF5 file: {H5_INPUT_PATH}")
+        
+        # Use visititems to traverse the nested structure
+        f.visititems(lambda name, obj: convert_dataset(name, obj, templates))
+
+    logger.info("--- PDB file generation complete. ---")
+
+def convert_dataset(name, obj, templates):
+    """A callback function for h5py's visititems to process each dataset."""
+    # We only care about datasets named 'coords'
+    if not name.endswith('/coords') or not isinstance(obj, h5py.Dataset):
+        return
+
+    try:
+        path_parts = name.split('/')
+        # Expected path: 'system_0/exp_1/coords'
+        if len(path_parts) != 3:
+            logger.warning(f"Skipping dataset with unexpected path structure: {name}")
+            return
+
+        sys_group_name, exp_group_name, _ = path_parts
+        sid = int(sys_group_name.replace('system_', ''))
+        
+        if sid not in templates:
+            logger.warning(f"No PDB template found for System ID {sid} (from path {name}). Skipping.")
+            return
+
+        logger.info(f"--- Processing {name} ---")
+        
+        coords_data = obj[:]
+        num_frames, num_atoms, _ = coords_data.shape
+        
+        template_traj = templates[sid]
+        if template_traj.n_atoms != num_atoms:
+            logger.error(f"Atom count mismatch for {name}! Template has {template_traj.n_atoms}, data has {num_atoms}. Skipping.")
+            return
+
+        # Create a nested directory for this system's PDBs
+        output_dir = PDB_OUTPUT_DIR / sys_group_name / exp_group_name
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Determine how many frames to save
+        frames_to_save = min(num_frames, FRAMES_PER_SYSTEM)
+        logger.info(f"Saving {frames_to_save} frames out of {num_frames} available.")
+
+        # Create and save PDB files
+        for i in range(frames_to_save):
+            frame_coords_nm = coords_data[i] * 0.1
+            new_traj = md.Trajectory([frame_coords_nm], topology=template_traj.topology)
+            output_pdb_path = output_dir / f"generated_frame_{i+1}.pdb"
+            new_traj.save_pdb(str(output_pdb_path))
+
+        logger.info(f"Successfully saved {frames_to_save} PDB files to {output_dir}")
+
+    except Exception as e:
+        logger.error(f"Failed to process dataset at path {name}: {e}", exc_info=True)
+
+
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor/param_diff.yaml

@@ -0,0 +1,54 @@
+# ===================================================================
+# Diffusion Model Configuration for Multi-System Pooled Embeddings
+# ===================================================================
+
+# --- Execution Target ---
+# Specify which system's embeddings to train the diffusion model on.
+# This corresponds to the group name in the HDF5 file (e.g., 0 for 'system_0').
+system_to_train: 0
+
+# --- Data Paths ---
+# Path to the HDF5 file containing the pooled embeddings from the multi-system ChebNet script.
+h5_file_path: "latent_reps/pooled_embeddings.h5"
+# Template for the group name within the HDF5 file. The script will replace '{}' with 'system_to_train'.
+dataset_group_key_template: "system_{}"
+# Name of the dataset within each group.
+dataset_name_in_group: "embeddings"
+# Directory to save generated embeddings and checkpoints.
+output_dir: "diffusion_output"
+
+
+# --- Run Mode & Grid Search ---
+# 'user_defined': Runs a single experiment with the parameters in the 'parameters' section.
+# 'grid_search': Runs a series of experiments defined in 'grid_search_space'.
+run_mode: "grid_search"
+
+# --- Parameters for a single run (if run_mode is 'user_defined') ---
+parameters:
+  num_epochs: 50
+  batch_size: 64
+  learning_rate: 1e-5
+  num_gen: 5000
+  save_interval: 1000
+  model_type: "mlp_v2"
+  hidden_dim: 1024
+  scheduler: "linear"
+  diffusion_steps: 1400
+  beta_start: 5e-6
+  beta_end: 0.03
+  num_instances: 6 # For partitioning grid search experiments
+
+# --- Hyperparameter space for grid search (if run_mode is 'grid_search') ---
+grid_search_space:
+  # These parameters will be fixed across all grid search experiments
+  # To vary them, you would need to add them to the 'curated_experiments' in the script.
+  learning_rate: 1e-5
+  num_epochs: 50
+  model_type: "mlp_v2"
+  hidden_dim: 1024
+
+  # The script will generate a curated grid based on these values.
+  # This section is for reference; the actual grid is built in the python script.
+  example_beta_starts: [5e-6, 0.005]
+  example_beta_ends: [0.03, 0.1]
+  example_diffusion_steps: [500, 1400]

LD-FPG-main/multi_receptor/param_gen_multi.yaml

@@ -0,0 +1,42 @@
+# ===================================================================
+# Configuration for Multi-System Structure Generation
+# ===================================================================
+
+# --- Input & Output Paths ---
+paths:
+  # Path to the saved decoder model checkpoint from the chebnet_multi_final.py run.
+  decoder_checkpoint_path: "checkpoints/decoder2_checkpoint.pth"
+  
+  # Path to the HDF5 file containing the static reference conditioners (z_ref).
+  # This file is produced by the chebnet_multi_final.py script.
+  conditioners_h5_path: "latent_reps/reference_conditioners.h5"
+  
+  # Path to the DIRECTORY containing the generated pooled embeddings from the
+  # diffusion_multi_system.py script. The script will scan this directory for files.
+  generated_embeddings_dir: "diffusion_output/"
+  
+  # Full path for the final output HDF5 file that will contain the generated 3D structures.
+  output_structures_h5_path: "generated_structures/multi_system_generated_coords.h5"
+
+
+# --- Decoder Model Settings ---
+# These parameters MUST EXACTLY MATCH the parameters used to train the decoder
+# in the chebnet_multi_final.py script (defined in its param_new.yaml).
+decoder2_settings:
+  # The dimensionality of the per-atom embeddings from the HNO encoder.
+  # This corresponds to hno_encoder.hidden_dim in the training config.
+  node_emb_dim: 16
+  
+  # The dimensionality of the static z_ref conditioner embeddings.
+  # This also corresponds to hno_encoder.hidden_dim.
+  cond_emb_dim: 16
+  
+  # The dimensions of the 2D pooling layer.
+  output_height: 50
+  output_width: 2
+  
+  # The dimensionality of the hidden layers within the final MLP decoder.
+  mlp_hidden_dim: 16
+  
+  # The number of hidden layers in the final MLP decoder.
+  num_hidden_layers: 12

LD-FPG-main/multi_receptor/param_h5_to_pdb_multi.yaml

@@ -0,0 +1,33 @@
+# ===================================================================
+# Configuration for HDF5 to PDB Conversion (Multi-System)
+# ===================================================================
+
+paths:
+  # Full path to the HDF5 file containing the final generated 3D structures.
+  # This is the output from the chebnet_gen_multi.py script.
+  generated_h5_path: "generated_structures/multi_system_generated_coords.h5"
+  
+  # Directory where the new PDB files will be saved.
+  # A sub-directory will be created for each system (e.g., 'system_0', 'system_1').
+  pdb_output_dir: "generated_pdbs/"
+  
+  # --- CRUCIAL: PDB Templates ---
+  # This list provides the original PDB files that correspond to each system ID.
+  # The order is important: the first path corresponds to System ID 0, the second to System ID 1, and so on.
+  # This is required to get the correct atom names, residue info, etc.
+  # You must list ALL original PDBs that were used in the chebnet_multi_final.py run.
+  template_pdb_paths:
+    - "/scratch/asengar/long_sim/apo_d2_inv_start/run6/heavy_chain.pdb"  # Corresponds to system_0
+    - "/scratch/asengar/long_sim/apo_d1/run1/heavy_chain.pdb"      # Corresponds to system_1
+    - "/scratch/asengar/long_sim/apo_A2AR/run1/heavy_chain.pdb"    # Corresponds to system_2
+    - "/scratch/asengar/long_sim/apo_beta1/run1/heavy_chain.pdb"   # Corresponds to system_3
+    - "/scratch/asengar/long_sim/apo_M1/heavy_chain.pdb"           # Corresponds to system_4
+    # Add more paths here if you trained on more than 5 systems...
+    # - "/path/to/system_5.pdb"
+    # - "/path/to/system_6.pdb"
+
+
+settings:
+  # The maximum number of PDB files to save for each system.
+  # If a system has 5000 generated frames, this will limit the output to the first 100.
+  max_frames_to_save: 100

LD-FPG-main/multi_receptor/param_new.yaml

@@ -0,0 +1,123 @@
+# General Settings
+log_file: "logfile_multi_system.log" # Log file name
+num_workers: 0                       # Number of workers for DataLoader
+force_cpu: false                     # Set to true to force CPU usage
+cuda_device: 0                       # GPU index if CUDA is available and force_cpu is false
+
+# --- DATA INPUT CONFIGURATION (MODIFIED FOR MULTI-SYSTEM) ---
+# Each entry in the 'systems' list represents one protein to be trained on.
+data:
+  systems:
+
+    # --- System 1 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/condensed.json"
+
+    # --- System 2 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d1/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d1/run1/residues_data_0.5.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d1/run1/condensed.json"
+
+    # --- System 3 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_A2AR/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_A2AR/run1/residues_data_0.1.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_A2AR/run1/condensed.json"
+
+    # --- System 4 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_beta1/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_beta1/run1/residues_data_0.5.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_beta1/run1/condensed.json"
+
+    # --- System 5 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_M1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_M1/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_M1/condensed.json"
+
+    # --- System 6 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_H1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_H1/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_H1/condensed.json"
+
+    # --- System 7 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d3/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d3/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d3/condensed.json"
+
+    # --- System 8 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_beta2/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_beta2/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_beta2/condensed.json"
+
+    # --- System 9 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_h5t2a/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_h5t2a/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_h5t2a/condensed.json"
+
+    # --- System 10 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_5ht1b/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_5ht1b/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_5ht1b/condensed.json"
+
+
+# Graph Construction Settings
+graph:
+  knn_value: 4                       # K for k-NN graph construction
+
+# --- GLOBAL MODEL & TRAINING SETTINGS ---
+# These settings apply to the single, shared models trained on all systems.
+hno_encoder:
+  hidden_dim: 16
+  cheb_order: 4
+  num_epochs: 5
+  learning_rate: 0.0001
+  batch_size: 16
+  save_interval: 50
+
+decoder2:
+  num_epochs: 10
+  learning_rate: 0.0003
+  batch_size: 16
+  base_loss_weight: 1.0
+  save_interval: 500
+  use_z_ref_ensemble: false
+
+decoder2_settings:
+  conditioner_mode: "z_ref"          # Must be 'z_ref' for the multi-system code
+  mlp_hidden_dim: 16
+  num_hidden_layers: 12
+  # NOTE: pooling_type, output_height/width are no longer used by the new decoder
+  pooling_type: "blind"
+  output_height: 50
+  output_width: 2
+
+# Dihedral Loss Configuration (Global Weights)
+dihedral_loss:
+  # This is a global switch. Set to true to attempt using dihedral loss.
+  use_dihedral_loss: false
+  # The specific torsion_info_path is now defined per-system above.
+  lambda_divergence: 0.1
+  lambda_torsion_mse: 1.0
+  divergence_type: "JS"
+
+# Data Augmentation Settings
+data_augmentation:
+  enabled: true
+  ensemble_size: 50
+  target_ca_rmsd: 1.0
+
+# Structural Augmentation Settings
+structural_augmentation:
+  enabled: true
+  variants_per_system: 10
+
+# Execution Settings
+execution_settings:
+  limit_systems: 2
+  max_frames_per_system: 500
+
+# Output Directories Configuration
+output_directories:
+  checkpoint_dir: "checkpoints"
+  structure_dir: "structures"
+  latent_dir: "latent_reps"

LD-FPG-main/multi_receptor_ddp/README.md

@@ -0,0 +1,161 @@
+# Multi-System Protein Conformation Generation Pipeline
+
+This repository contains a suite of Python scripts that form a complete deep learning pipeline for analyzing, modeling, and generating novel 3D conformations of multiple protein systems.
+
+The core workflow is a three-stage **Encode -> Generate -> Decode** process, followed by a final conversion step to produce PDB files for visualization.
+
+## Core Components
+
+The pipeline consists of four main scripts, each with its own YAML configuration file. They are designed to be run in sequence.
+
+### 1. Encoder: `chebnet_multi_final.py`
+- **Configuration:** `param_new.yaml`
+- **Role:** This is the primary learning stage. The script trains a graph-based autoencoder on simulation data from multiple protein systems. It learns a shared, low-dimensional "language" of protein structure.
+- **Inputs:**
+    - PDB files for multiple protein structures.
+    - JSON files containing coordinate trajectories for each system.
+- **Key Outputs:**
+    - `checkpoints/decoder2_checkpoint.pth`: The trained decoder model, essential for the final stage.
+    - `latent_reps/pooled_embeddings.h5`: The compressed (latent) representation for every frame of the input simulations.
+    - `latent_reps/reference_conditioners.h5`: The static latent representation (`z_ref`) for the reference structure of each system.
+
+### 2. Generator: `diffusion_multi_system.py`
+- **Configuration:** `param_diff.yaml`
+- **Role:** This script trains a generative diffusion model. For each protein system, it learns the specific statistical distribution of its latent embeddings. It can then generate new, artificial embeddings from scratch that conform to this learned distribution.
+- **Inputs:**
+    - `latent_reps/pooled_embeddings.h5`: The latent vectors produced by the encoder.
+- **Key Outputs:**
+    - `diffusion_output/generated_embeddings_sys<ID>_exp<N>.h5`: HDF5 files containing new, artificially generated latent embeddings. It creates one file per experiment (`exp<N>`) for each system (`sys<ID>`).
+
+### 3. Decoder: `chebnet_gen_multi.py`
+- **Configuration:** `param_gen_multi.yaml`
+- **Role:** This script translates the artificial latent embeddings from the diffusion model back into full 3D structures. It acts as the bridge between the abstract latent space and physical coordinates.
+- **Inputs:**
+    - `checkpoints/decoder2_checkpoint.pth`: The trained decoder model from Stage 1.
+    - `latent_reps/reference_conditioners.h5`: The static `z_ref` for each system.
+    - The `diffusion_output/` directory containing all generated embeddings.
+- **Key Outputs:**
+    - `generated_structures/multi_system_generated_coords.h5`: A single, organized HDF5 file containing the full 3D coordinates of the newly generated structures. The file has a nested structure to separate results by system and experiment (e.g., `system_0/exp_1/coords`).
+
+### 4. Converter: `h5_to_pdb_multi.py`
+- **Configuration:** `param_h5_to_pdb_multi.yaml`
+- **Role:** The final utility step. This script converts the generated 3D coordinates from the HDF5 file into standard PDB files that can be viewed in molecular visualization software.
+- **Inputs:**
+    - `generated_structures/multi_system_generated_coords.h5`: The final coordinate file from Stage 3.
+    - The original PDB files for each system, which are used as templates for atom/residue information.
+- **Key Outputs:**
+    - `generated_pdbs/`: A directory containing the final, viewable PDB files, organized into sub-directories by system and experiment.
+
+## Workflow: How to Run the Pipeline
+
+Execute the scripts in the following order. Ensure you have configured the corresponding YAML file before each step.
+
+**Step 1: Train the Encoder**
+```bash
+python chebnet_multi_final.py --config param_new.yaml
+```
+
+**Step 2: Train Diffusion Models and Generate Latent Embeddings**
+This step must be run **once for each system** you want to model. The `--system_id` flag specifies which system's data to use from the encoder's output.
+
+```bash
+# Run for System 0
+python diffusion_multi_system.py --config param_diff.yaml --system_id 0
+
+# Run for System 1
+python diffusion_multi_system.py --config param_diff.yaml --system_id 1
+
+# ...and so on for all other systems.
+```
+
+**Step 3: Decode Generated Embeddings into 3D Coordinates**
+This script finds all the generated embeddings from the previous step and processes them in one go.
+```bash
+python chebnet_gen_multi.py --config param_gen_multi.yaml
+```
+
+**Step 4: Convert Final Coordinates to PDB Files**
+This final step converts the HDF5 coordinate data into viewable PDB files.
+```bash
+python h5_to_pdb_multi.py --config param_h5_to_pdb_multi.yaml
+```
+
+After completing these steps, the `generated_pdbs/` directory will contain your final results.
+
+## HPC Scalability and Reproducibility
+
+To effectively scale the training and data processing for a large number of protein systems, the pipeline has been enhanced with features for high-performance computing (HPC) environments. These updates ensure efficiency, scalability, and reproducibility.
+
+*   **Multi-GPU Training**: The core training scripts, `chebnet_multi_final.py` and `diffusion_multi_system.py`, now fully support multi-GPU workflows using **Distributed Data Parallel (DDP)**. This allows for significantly faster training by distributing batches across multiple GPUs on a single or multiple nodes. **Automatic Mixed Precision (AMP)** is also implemented to further accelerate training by using half-precision floating-point numbers where possible, reducing memory consumption and speeding up computations.
+
+*   **Parallelized Data Processing**: To handle the large data I/O and conversion tasks efficiently, CPU-bound scripts have been parallelized:
+    *   `chebnet_gen_multi.py` now processes generated embedding files in parallel.
+    *   `h5_to_pdb_multi.py` converts HDF5 coordinate files to PDB format using multiple CPU cores.
+    This dramatically reduces the time required for pre- and post-processing steps.
+
+*   **Reproducibility**: A `set_seed` function has been integrated into all scripts. By setting a seed in the YAML configuration files, all random processes (model initialization, data shuffling, etc.) become deterministic, ensuring that experiments are fully reproducible.
+
+*   **Enhanced Configuration**: The YAML configuration files (`param_gen_multi.yaml`, `param_diff.yaml`, etc.) have been updated to expose HPC-related parameters like `seed`, `num_workers`, and `num_gpus_per_node`, providing fine-grained control over resource allocation in cluster environments.
+
+*   **Multi-Process-Safe Logging**: The logging mechanism has been refined to be compatible with multi-process and distributed environments, preventing log corruption and ensuring that output from all processes is captured clearly.
+
+---
+
+## Alternative Encoder: `cuEquivariance` Model
+
+As an alternative to the `ChebConv`-based encoder, this directory also contains an implementation of an **SE(3) Equivariant Encoder** using NVIDIA's `cuEquivariance` library. This model is designed to directly learn from the 3D geometry of the protein structures, making its representations respect physical symmetries like rotation and translation.
+
+### Equivariant Components
+
+- **Encoder Model: `cueq_encoder.py`**: This file defines the `CUEQ_Encoder` class, a graph neural network built with `cuEquivariance`'s PyTorch bindings. It uses operations like segmented polynomials and tensor products to create features that are equivariant to 3D transformations.
+
+- **Training Script: `chebnet_blind_cueq.py`**: This is a standalone script for training the `CUEQ_Encoder` as an autoencoder. It learns to create a latent representation of a protein's 3D structure and then reconstruct the original coordinates from that representation. The trained model checkpoint can be used as a drop-in replacement for the original HNO encoder in downstream tasks.
+
+### How to Run the `cuEquivariance` Encoder
+
+This script is designed as a separate experiment and does not replace the main pipeline files.
+
+**Step 1: Create a YAML Configuration File**
+Create a new YAML file (e.g., `param_cueq.yaml`) and add a section for the `cueq_encoder`. The parameters define the model architecture and training settings.
+
+*Example `param_cueq.yaml`:*
+```yaml
+# Configuration for the CUEquivariance Encoder
+cueq_encoder:
+  batch_size: 16
+  num_epochs: 1000
+  learning_rate: 0.001
+  save_interval: 100
+  
+  # --- Model Architecture ---
+  # Irreducible representations for e3nn-style networks
+  in_irreps: "1x0e"  # Input: 1 scalar feature per node
+  hidden_irreps_1: "32x0e + 16x1o + 8x2e" # Hidden layers with scalar, vector, and tensor features
+  hidden_irreps_2: "32x0e + 16x1o + 8x2e"
+  out_irreps: "1x1o" # Output: a vector for each node (interpreted as 3D coordinates)
+  mlp_hidden_dim: 3 # The final output dimension is 3 (x,y,z)
+
+# --- Common settings from the original config ---
+graph:
+  knn_value: 10
+
+data:
+  systems:
+    - name: "System1"
+      json_path: "/path/to/your/system1_coords.json"
+      # ... other system paths
+
+output_directories:
+  checkpoint_dir: "./checkpoints"
+  latent_dir: "./latent_reps_cueq"
+```
+
+**Step 2: Run the Training Script**
+Launch the DDP training using the new script and config file.
+
+```bash
+# Example for a 4-GPU node
+torchrun --standalone --nproc_per_node=4 chebnet_blind_cueq.py --config param_cueq.yaml
+```
+
+This will train the equivariant encoder and save its checkpoint in the specified `checkpoint_dir`. This checkpoint contains a powerful, geometry-aware representation of your protein systems.

LD-FPG-main/multi_receptor_ddp/chebnet_blind_cueq.py

@@ -0,0 +1,251 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import time
+from typing import List, Tuple
+
+# DDP and AMP Imports
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.cuda.amp import GradScaler, autocast
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+
+# Equivariant imports
+from .cueq_encoder import CUEQ_Encoder
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Encoding: CUEquivariance Encoder (Multi-System DDP/AMP Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action='store_true', help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Logging & DDP Setup
+################################################################################
+logger = logging.getLogger("CUEQ_Encoder_DDP_AMP")
+
+def setup_ddp():
+    dist.init_process_group(backend="nccl")
+    rank = dist.get_rank()
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = dist.get_world_size()
+    
+    torch.cuda.set_device(local_rank)
+    device = torch.device(f"cuda:{local_rank}")
+
+    logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    if not logger.handlers:
+        formatter = logging.Formatter("[%(levelname)s] %(asctime)s - (Rank %(rank)s) - %(message)s")
+        if rank == 0:
+            ch = logging.StreamHandler(sys.stdout)
+            ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+            ch.setFormatter(formatter)
+            logger.addHandler(ch)
+
+    adapter = logging.LoggerAdapter(logger, {'rank': rank})
+    adapter.info(f"DDP Initialized. Rank: {rank}/{world_size}, Device: {device}")
+    return rank, world_size, device, adapter
+
+def cleanup_ddp():
+    dist.destroy_process_group()
+
+################################################################################
+# (C) Utility Functions
+################################################################################
+
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+        keys_str = sorted(data.keys(), key=int)
+        n_frames = len(data[keys_str[0]]["heavy_atom_coords_per_frame"])
+        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0
+        coords_frames, n_atoms_check = [], -1
+        for i in range(n_frames):
+            frame_coords = np.concatenate([np.array(data[k]["heavy_atom_coords_per_frame"][i], dtype=np.float32) for k in keys_str])
+            if i == 0: n_atoms_check = frame_coords.shape[0]
+            assert frame_coords.shape[0] == n_atoms_check, f"Inconsistent atom count on frame {i}"
+            coords_frames.append(torch.from_numpy(frame_coords))
+        logger.info(f"Loaded {n_frames} frames with {n_atoms_check} atoms each.")
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Error reading or processing JSON {json_file}: {e}", exc_info=True); return [], -1
+
+def build_graph_dataset(coords: List[torch.Tensor], knn: int, sid: int, log: logging.Logger, dev: torch.device) -> List[Data]:
+    dset = []
+    for c in coords:
+        pos = c.to(dev)
+        # Using a simple scalar '1' for each node feature as atom types are not available
+        x = torch.ones(pos.shape[0], 1).to(dev)
+        edge_index = knn_graph(pos, k=knn, loop=False)
+        dset.append(Data(x=x, edge_index=edge_index, pos=pos, y=pos, system_id=torch.tensor([sid])))
+    log.info(f"Built graph dataset for system {sid} with {len(dset)} frames for CUEQ.")
+    return dset
+
+def save_checkpoint(state: dict, filename: str, logger: logging.Logger):
+    try:
+        torch.save(state, filename)
+        logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e:
+        logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model, optimizer, scaler, filename, device, logger):
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        ckpt = torch.load(filename, map_location=device)
+        start_epoch = ckpt.get("epoch", 0)
+        state_dict = ckpt["model_state_dict"]
+        if isinstance(model, DDP): model.module.load_state_dict(state_dict)
+        else:
+            new_state_dict = {k.replace('module.', ''): v for k, v in state_dict.items()}
+            model.load_state_dict(new_state_dict)
+        if optimizer and "optimizer_state_dict" in ckpt: optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+        if scaler and "scaler_state_dict" in ckpt: scaler.load_state_dict(ckpt["scaler_state_dict"])
+        logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Starting fresh.")
+    return model, optimizer, scaler, start_epoch
+
+################################################################################
+# (D) Training Function
+################################################################################
+
+def train_cueq_model(model, tr_loader, N_epochs, lr, ckpt_path, save_int, dev, log, rank, world_size):
+    opt = torch.optim.Adam(model.parameters(), lr=lr)
+    scaler = GradScaler()
+    model, opt, scaler, start_ep = load_checkpoint(model, opt, scaler, ckpt_path, dev, log)
+
+    if start_ep >= N_epochs:
+        if rank == 0: log.info("CUEQ Encoder training already completed."); return model.module
+
+    for ep in range(start_ep, N_epochs):
+        model.train()
+        tr_loader.sampler.set_epoch(ep)
+        for data in tr_loader:
+            data = data.to(dev)
+            opt.zero_grad()
+            with autocast():
+                # The CUEQ encoder model expects pos as a separate argument
+                pred_latent = model(data.x, data.edge_index, data.pos)
+                # The target is the latent representation of the final coordinates.
+                # Here, we simplify and use the coordinates themselves as a target for autoencoding.
+                # A more advanced setup might encode data.y as well.
+                loss = F.mse_loss(pred_latent, data.y)
+            
+            scaler.scale(loss).backward()
+            scaler.step(opt)
+            scaler.update()
+
+        if rank == 0 and ((ep + 1) % save_int == 0 or (ep + 1) == N_epochs):
+            save_checkpoint({
+                "epoch": ep + 1,
+                "model_state_dict": model.module.state_dict(),
+                "optimizer_state_dict": opt.state_dict(),
+                "scaler_state_dict": scaler.state_dict(),
+            }, ckpt_path, log)
+            log.info(f"Epoch {ep+1}/{N_epochs} | Loss: {loss.item():.6f}")
+
+    if rank == 0: log.info("Finished CUEQ Encoder training.")
+    return model.module
+
+################################################################################
+# (E) Main Execution
+################################################################################
+
+def main():
+    rank, world_size, device, logger = setup_ddp()
+    start_time = time.time()
+    if rank == 0: logger.info("================ CUEQ Blind Script Starting ================")
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    cueq_cfg = config["cueq_encoder"] # New config section
+    out_cfg = config["output_directories"]
+    if rank == 0:
+        os.makedirs(out_cfg['checkpoint_dir'], exist_ok=True)
+        os.makedirs(out_cfg['latent_dir'], exist_ok=True)
+
+    # Data loading (all ranks)
+    full_dset = []
+    for i, sys_cfg in enumerate(config["data"]["systems"]):
+        coords, _ = load_heavy_atom_coords_from_json(sys_cfg["json_path"], logger)
+        if coords:
+            full_dset.extend(build_graph_dataset(coords, config["graph"]["knn_value"], i, logger, device))
+
+    # Train/Test Split and Samplers
+    tr_dset, te_dset = train_test_split(full_dset, test_size=0.1, random_state=42)
+    tr_sampler = DistributedSampler(tr_dset, num_replicas=world_size, rank=rank)
+    load_tr = DataLoader(tr_dset, cueq_cfg['batch_size'], sampler=tr_sampler, num_workers=config.get("num_workers",0), pin_memory=True)
+    
+    # CUEQ Encoder Training
+    model = DDP(CUEQ_Encoder(
+        in_irreps=cueq_cfg['in_irreps'],
+        hidden_irreps_1=cueq_cfg['hidden_irreps_1'],
+        hidden_irreps_2=cueq_cfg['hidden_irreps_2'],
+        out_irreps=cueq_cfg['out_irreps'],
+        mlp_h_dim=cueq_cfg['mlp_hidden_dim']
+    ).to(device), device_ids=[rank])
+    
+    ckpt_path = os.path.join(out_cfg['checkpoint_dir'], "cueq_encoder_blind_checkpoint.pth")
+    
+    trained_encoder = train_cueq_model(model, load_tr, cueq_cfg['num_epochs'], cueq_cfg['learning_rate'], ckpt_path, cueq_cfg['save_interval'], device, logger, rank, world_size)
+
+    # Export latent spaces (Rank 0 only)
+    if rank == 0:
+        logger.info("--- Starting Latent Space Export ---")
+        trained_encoder.eval()
+        # This part would typically use the full dataset loader without shuffling
+        full_loader = DataLoader(full_dset, batch_size=cueq_cfg['batch_size'])
+        
+        # Aggregate representations by system_id
+        all_latents = {}
+        with torch.no_grad():
+            for data in full_loader:
+                data = data.to(device)
+                with autocast():
+                    latents = trained_encoder.forward_representation(data.x, data.edge_index, data.pos)
+                
+                for i in range(data.num_graphs):
+                    sid = data.system_id[i].item()
+                    if sid not in all_latents:
+                        all_latents[sid] = []
+                    
+                    # Get the latents for the current graph in the batch
+                    graph_latents = latents[data.batch == i]
+                    all_latents[sid].append(graph_latents.cpu().numpy())
+        
+        # Save aggregated latents to an HDF5 file
+        output_h5_path = os.path.join(out_cfg['latent_dir'], 'cueq_latents.h5')
+        with h5py.File(output_h5_path, 'w') as f:
+            for sid, latent_list in all_latents.items():
+                if latent_list:
+                    sys_group = f.create_group(f"system_{sid}")
+                    sys_group.create_dataset("latents", data=np.concatenate(latent_list, axis=0))
+                    logger.info(f"Saved latents for system {sid}")
+        logger.info(f"--- Finished Latent Space Export to {output_h5_path} ---")
+
+    cleanup_ddp()
+    if rank == 0: logger.info(f"================ Script Finished ({time.time() - start_time:.2f}s) ================")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor_ddp/chebnet_gen_multi.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import pathlib
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Multi-System Structure Generator from Diffusion Embeddings")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("Multi-System Structure Generator Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+paths = config.get('paths', {})
+d2s = config.get('decoder2_settings', {})
+
+DECODER_CKPT_PATH = pathlib.Path(paths['decoder_checkpoint_path'])
+CONDITIONERS_H5_PATH = pathlib.Path(paths['conditioners_h5_path'])
+GEN_EMBEDDINGS_DIR = pathlib.Path(paths['generated_embeddings_dir'])
+OUTPUT_H5_PATH = pathlib.Path(paths['output_structures_h5_path'])
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {DEVICE}")
+
+# Ensure output directory exists
+OUTPUT_H5_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+# ===================================================================
+# (C) Model Definition (Must match the trained model)
+# ===================================================================
+
+# This class is a simplified version of the one in chebnet_multi_final.py
+# It is redefined here to make this script standalone for generation.
+class ProteinStateReconstructor2D(nn.Module):
+    def __init__(self, node_emb_dim: int, cond_emb_dim: int,
+                 output_height: int, output_width: int,
+                 mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
+        super().__init__()
+        self.logger = logger
+        # The pooling layer is not used in this simplified forward pass, but its
+        # parameters are kept to correctly calculate the mlp_in_dim, ensuring
+        # that the architecture matches the saved checkpoint weights.
+        pooled_dim = output_height * output_width
+        mlp_in_dim = cond_emb_dim + pooled_dim
+
+        layers = []
+        in_d = mlp_in_dim
+        for i in range(mlp_layers - 1):
+            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
+            in_d = mlp_h_dim
+        layers.append(nn.Linear(in_d, 3))
+        self.decoder_mlp = nn.Sequential(*layers)
+        self.logger.info(f"Instantiated Decoder. MLP Input Dim: {mlp_in_dim}")
+
+    def forward(self, pooled_embedding: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
+        """
+        A corrected forward pass for generation from a pre-pooled embedding.
+        'pooled_embedding' is the direct output from the diffusion model.
+        'conditioner_z_ref' is the static per-atom conditioner.
+        """
+        num_atoms = conditioner_z_ref.shape[0]
+        
+        # The input 'pooled_embedding' is already the correct, flattened, pooled vector.
+        # We just need to broadcast it to each atom.
+        # It should have shape [pooled_dim], we unsqueeze to [1, pooled_dim] for expand.
+        pooled_per_node = pooled_embedding.unsqueeze(0).expand(num_atoms, -1)
+        
+        # Concatenate the static conditioner with the broadcasted pooled vector
+        mlp_input = torch.cat([conditioner_z_ref, pooled_per_node], dim=1)
+        
+        # Predict coordinates
+        pred_coords = self.decoder_mlp(mlp_input)
+        return pred_coords
+
+# ===================================================================
+# (D) Main Generation Logic
+# ===================================================================
+
+def main():
+    # 1. Instantiate and load the trained decoder model
+    logger.info("Loading trained decoder model...")
+    if not DECODER_CKPT_PATH.is_file():
+        logger.error(f"Decoder checkpoint not found at {DECODER_CKPT_PATH}"); exit(1)
+
+    model = ProteinStateReconstructor2D(
+        node_emb_dim=d2s['node_emb_dim'],
+        cond_emb_dim=d2s['cond_emb_dim'],
+        output_height=d2s['output_height'],
+        output_width=d2s['output_width'],
+        mlp_h_dim=d2s['mlp_hidden_dim'],
+        mlp_layers=d2s['num_hidden_layers'],
+        logger=logger
+    ).to(DEVICE)
+
+    checkpoint = torch.load(DECODER_CKPT_PATH, map_location=DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+    logger.info("Decoder model loaded successfully.")
+
+    # 2. Find all generated embedding files to process
+    if not GEN_EMBEDDINGS_DIR.is_dir():
+        logger.error(f"Generated embeddings directory not found: {GEN_EMBEDDINGS_DIR}"); exit(1)
+    
+    embedding_files = sorted(list(GEN_EMBEDDINGS_DIR.glob("generated_embeddings_sys*.h5")))
+    if not embedding_files:
+        logger.error(f"No generated embedding files found in {GEN_EMBEDDINGS_DIR}"); exit(1)
+    
+    logger.info(f"Found {len(embedding_files)} generated embedding files to process.")
+
+    # 3. NEW: Use a nested dictionary for aggregation: {sid: {exp_id: [coords]}}
+    aggregated_coords = {}
+
+    # 4. Loop through each file, generate structures, and store in the dictionary
+    for emb_file in embedding_files:
+        try:
+            # --- Robustly parse SID and EXP_ID from filename ---
+            filename_parts = emb_file.stem.split('_')
+            sid_part = next((part for part in filename_parts if part.startswith('sys')), None)
+            exp_part = next((part for part in filename_parts if part.startswith('exp')), None)
+
+            if not sid_part or not exp_part:
+                logger.warning(f"Could not parse SID and EXP from filename {emb_file.name}. Skipping.")
+                continue
+            
+            sid = int(sid_part.replace('sys', ''))
+            exp_id = int(exp_part.replace('exp', ''))
+            logger.info(f"--- Processing SID: {sid}, EXP: {exp_id} from file {emb_file.name} ---")
+
+            # a. Load the corresponding z_ref conditioner
+            with h5py.File(CONDITIONERS_H5_PATH, 'r') as f_cond:
+                group_name = f"system_{sid}"
+                if group_name not in f_cond:
+                    logger.warning(f"Group '{group_name}' not in conditioner file. Skipping.")
+                    continue
+                z_ref = torch.from_numpy(f_cond[group_name]['z_ref'][:]).float().to(DEVICE)
+
+            # b. Load the generated pooled embeddings
+            with h5py.File(emb_file, 'r') as f_emb:
+                group_key = next((k for k in f_emb.keys() if k.startswith('system_')), None)
+                if not group_key: continue
+                dset_name = "embeddings" if "embeddings" in f_emb[group_key] else "generated_embeddings"
+                if dset_name not in f_emb[group_key]: continue
+                pooled_embeddings = torch.from_numpy(f_emb[group_key][dset_name][:]).float().to(DEVICE)
+            
+            logger.info(f"Loaded {pooled_embeddings.shape[0]} embeddings and conditioner of shape {z_ref.shape}")
+
+            # c. Decode each embedding and store in nested dictionary
+            if sid not in aggregated_coords:
+                aggregated_coords[sid] = {}
+            if exp_id not in aggregated_coords[sid]:
+                aggregated_coords[sid][exp_id] = []
+
+            with torch.no_grad():
+                for i in range(pooled_embeddings.shape[0]):
+                    pooled_emb = pooled_embeddings[i]
+                    coords = model(pooled_emb, z_ref).cpu().numpy()
+                    aggregated_coords[sid][exp_id].append(coords)
+
+        except Exception as e:
+            logger.error(f"Failed to process file {emb_file.name}: {e}", exc_info=True)
+
+    # 5. NEW: Write the aggregated results using the nested structure
+    with h5py.File(OUTPUT_H5_PATH, 'w') as f_out:
+        logger.info(f"Writing aggregated structures to {OUTPUT_H5_PATH}")
+        for sid, exp_data in sorted(aggregated_coords.items()):
+            sys_group = f_out.create_group(f"system_{sid}")
+            logger.info(f"Created group for system {sid}")
+            for exp_id, coords_list in sorted(exp_data.items()):
+                if not coords_list: continue
+                
+                stacked_coords = np.array(coords_list)
+                exp_group = sys_group.create_group(f"exp_{exp_id}")
+                exp_group.create_dataset("coords", data=stacked_coords, compression="gzip")
+                logger.info(f"  - Saved {stacked_coords.shape[0]} structures for exp_{exp_id}")
+
+    logger.info("--- All systems processed. Final structures saved. ---")
+
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor_ddp/chebnet_multi_final.py

@@ -0,0 +1,386 @@
+################################################################################
+# %% Imports
+################################################################################
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from typing import Dict, List, Optional, Tuple, Any
+
+# DDP and AMP Imports
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.cuda.amp import GradScaler, autocast
+
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv, global_mean_pool
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import NearestNeighbors # New dependency
+
+################################################################################
+# (A) Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System DDP/AMP Version)"
+)
+parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
+parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+args = parser.parse_args()
+
+################################################################################
+# (B) Pre-Logging Config Load
+################################################################################
+LOG_FILE_DEFAULT = "logfile_multi_system_ddp_amp.log"
+log_file_path = LOG_FILE_DEFAULT
+try:
+    with open(args.config, "r") as f:
+        temp_config = yaml.safe_load(f)
+        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
+except Exception as e:
+    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")
+
+################################################################################
+# (C) Logging Setup
+################################################################################
+# Logger will be configured in main after DDP setup
+logger = logging.getLogger("ProteinReconstructionDDP_AMP")
+
+################################################################################
+# (D) DDP and Device Setup
+################################################################################
+def setup_ddp():
+    """Initializes DDP, sets the device for the current process, and configures logging."""
+    dist.init_process_group(backend="nccl")
+    rank = dist.get_rank()
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = dist.get_world_size()
+    
+    torch.cuda.set_device(local_rank)
+    device = torch.device(f"cuda:{local_rank}")
+
+    logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    if not logger.handlers:
+        formatter = logging.Formatter("[%(levelname)s] %(asctime)s - (Rank %(rank)s) - %(name)s - %(message)s")
+        if rank == 0:
+            try:
+                fh = logging.FileHandler(log_file_path, mode="w")
+                fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+                fh.setFormatter(formatter)
+                logger.addHandler(fh)
+            except IOError as e:
+                print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
+        ch = logging.StreamHandler(sys.stdout)
+        ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+    adapter = logging.LoggerAdapter(logging.getLogger("ProteinReconstructionDDP_AMP"), {'rank': rank})
+    
+    adapter.info(f"DDP Initialized. Rank: {rank}/{world_size}, Device: {device}")
+    return rank, world_size, device, adapter
+
+def cleanup_ddp():
+    """Cleans up DDP resources."""
+    dist.destroy_process_group()
+
+################################################################################
+# (E) Utility Functions
+################################################################################
+
+def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
+    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
+    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
+    try:
+        with open(filename, 'r') as pdb_file:
+            for line in pdb_file:
+                if not line.startswith("ATOM  "): continue
+                alt_loc = line[16].strip()
+                if alt_loc not in ['', 'A']: continue
+                atom_serial = int(line[6:11])
+                if atom_serial in processed_atom_indices: continue
+                processed_atom_indices.add(atom_serial)
+                atom_name = line[12:16].strip()
+                res_name = line[17:20].strip()
+                chain_id = line[21].strip()
+                res_seq = int(line[22:26])
+                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
+                category = "backbone" if atom_name in backbone_atoms else "sidechain"
+                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
+                if atom_name == 'CA': ca_indices[res_seq] = atom_serial
+    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
+    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}.")
+    return {}, atoms_in_order, ca_indices
+
+def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int]]:
+    new_res_dict, orig_atom_map, next_new_res_id, next_new_atom_index, orig_res_map = {}, {}, 0, 0, {}
+    seen_res_order = {r_id: i for i, (r_id, _, _, _) in enumerate(dict.fromkeys(r[0] for r in atoms_in_order))}
+    sortable = sorted(atoms_in_order, key=lambda x: (seen_res_order[x[0]], x[1]))
+    for r_id, serial, cat, name in sortable:
+        if r_id not in orig_res_map:
+            orig_res_map[r_id] = next_new_res_id
+            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
+            next_new_res_id += 1
+        new_res_id = orig_res_map[r_id]
+        new_res_dict[new_res_id][cat].append(next_new_atom_index)
+        orig_atom_map[serial] = next_new_atom_index
+        next_new_atom_index += 1
+    new_ca_indices = [orig_atom_map[ca_serial] for _, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
+    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms.")
+    return new_res_dict, orig_atom_map, {}, new_ca_indices
+
+def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
+    bb_idx, sc_idx = [], []
+    for res_id in sorted(renumbered_dict.keys()):
+        bb_idx.extend(renumbered_dict[res_id]["backbone"])
+        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
+    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)
+
+def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
+    logger.info(f"Loading coordinates from JSON: {json_file}")
+    try:
+        with open(json_file, "r") as f: data = json.load(f)
+        keys_str = sorted(data.keys(), key=int)
+        n_frames = len(data[keys_str[0]]["heavy_atom_coords_per_frame"])
+        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0
+        coords_frames, n_atoms_check = [], -1
+        for i in range(n_frames):
+            frame_coords = np.concatenate([np.array(data[k]["heavy_atom_coords_per_frame"][i], dtype=np.float32) for k in keys_str])
+            if i == 0: n_atoms_check = frame_coords.shape[0]
+            assert frame_coords.shape[0] == n_atoms_check, f"Inconsistent atom count on frame {i}"
+            coords_frames.append(torch.from_numpy(frame_coords))
+        logger.info(f"Loaded {n_frames} frames with {n_atoms_check} atoms each.")
+        return coords_frames, n_atoms_check
+    except Exception as e:
+        logger.error(f"Error reading or processing JSON {json_file}: {e}", exc_info=True); return [], -1
+
+def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)
+
+def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
+    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
+    centroid_P, centroid_Q = P.mean(dim=-2, keepdim=True), Q.mean(dim=-2, keepdim=True)
+    P_c, Q_c = P - centroid_P, Q - centroid_Q
+    C = torch.bmm(Q_c.transpose(1, 2), P_c)
+    try:
+        V, S, Wt = torch.linalg.svd(C)
+        det = torch.det(V @ Wt)
+        D = torch.eye(3, device=P.device).unsqueeze(0).repeat(P.shape[0], 1, 1)
+        D[:, 2, 2] = torch.sign(det)
+        U = V @ D @ Wt
+        Q_aligned = (Q_c @ U) + centroid_P
+    except Exception as e:
+        logger.error(f"Kabsch SVD failed: {e}. Returning identity.", exc_info=True)
+        U = torch.eye(3, device=P.device).unsqueeze(0).expand(P.shape[0], -1, -1)
+        Q_aligned = Q
+    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)
+
+def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
+    if not coords: return []
+    ref = coords[0].to(device)
+    aligned_coords = [coords[0]]
+    for frame in coords[1:]:
+        _, aligned_frame = kabsch_algorithm(ref, frame.to(device), logger)
+        aligned_coords.append(aligned_frame.cpu())
+    logger.debug(f"Aligned {len(aligned_coords)} frames.")
+    return aligned_coords
+
+def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
+    nn1 = NearestNeighbors(n_neighbors=1).fit(target_coords_ca)
+    _, indices1 = nn1.kneighbors(ref_coords_ca)
+    nn2 = NearestNeighbors(n_neighbors=1).fit(ref_coords_ca)
+    _, indices2 = nn2.kneighbors(target_coords_ca)
+    pairs = [(i, j[0]) for i, j in enumerate(indices1) if indices2[j[0]][0] == i]
+    logger.info(f"Found {len(pairs)} mutual nearest neighbor pairs.")
+    if not pairs: return torch.tensor([]), torch.tensor([])
+    return torch.tensor([p[0] for p in pairs]), torch.tensor([p[1] for p in pairs])
+
+def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor, reference_structure: torch.Tensor, core_indices_reference: torch.Tensor, logger: logging.Logger) -> torch.Tensor:
+    P_core, Q_core = reference_structure[core_indices_reference], structure_to_align[core_indices_to_align]
+    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
+    centroid_Q_core = Q_core.mean(dim=0)
+    centroid_P_core = P_core.mean(dim=0)
+    return (structure_to_align - centroid_Q_core) @ rotation + centroid_P_core
+
+def build_graph_dataset(aligned_coords: List[torch.Tensor], unaligned_coords: List[torch.Tensor], knn: int, sid: int, log: logging.Logger, dev: torch.device) -> List[Data]:
+    dset = []
+    for ac, uac in zip(aligned_coords, unaligned_coords):
+        edge_index = knn_graph(ac, k=knn, loop=False)
+        dset.append(Data(x=ac, edge_index=edge_index, y=ac, y_unaligned=uac, system_id=torch.tensor([sid])))
+    log.info(f"Built graph dataset for system {sid} with {len(dset)} frames.")
+    return dset
+
+def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
+    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
+    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")
+
+def load_checkpoint(model, optimizer, scaler, filename, device, logger):
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint: '{filename}'")
+        ckpt = torch.load(filename, map_location=device)
+        start_epoch = ckpt.get("epoch", 0)
+        state_dict = ckpt["model_state_dict"]
+        # Adjust for DDP `module.` prefix
+        if isinstance(model, DDP): model.module.load_state_dict(state_dict)
+        else:
+            new_state_dict = {k.replace('module.', ''): v for k, v in state_dict.items()}
+            model.load_state_dict(new_state_dict)
+        if optimizer and "optimizer_state_dict" in ckpt: optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+        if scaler and "scaler_state_dict" in ckpt: scaler.load_state_dict(ckpt["scaler_state_dict"])
+        logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
+    else: logger.info(f"No checkpoint found at '{filename}'. Starting fresh.")
+    return model, optimizer, scaler, start_epoch
+
+def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    crit = nn.MSELoss()
+    all_mse = crit(pred, target)
+    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0.)
+    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0.)
+    return all_mse, bb_mse, sc_mse
+
+class HNO(nn.Module): # Definition remains the same
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        self.conv1=ChebConv(3,hidden_dim,K=K); self.bano1=nn.BatchNorm1d(hidden_dim)
+        self.conv2=ChebConv(hidden_dim,hidden_dim,K=K); self.bano2=nn.BatchNorm1d(hidden_dim)
+        self.conv3=ChebConv(hidden_dim,hidden_dim,K=K); self.bano3=nn.BatchNorm1d(hidden_dim)
+        self.conv4=ChebConv(hidden_dim,hidden_dim,K=K); self.mlpRep=nn.Linear(hidden_dim,3)
+    def forward(self,x,edge_index):
+        x=self.bano1(F.leaky_relu(self.conv1(x.float(),edge_index)))
+        x=self.bano2(F.leaky_relu(self.conv2(x,edge_index)))
+        x=self.bano3(F.relu(self.conv3(x,edge_index)))
+        x=self.conv4(x,edge_index)
+        return self.mlpRep(F.normalize(x,p=2.0,dim=1))
+    def forward_representation(self,x,edge_index):
+        x=self.bano1(F.leaky_relu(self.conv1(x.float(),edge_index)))
+        x=self.bano2(F.leaky_relu(self.conv2(x,edge_index)))
+        x=self.bano3(F.relu(self.conv3(x,edge_index)))
+        return F.normalize(self.conv4(x,edge_index),p=2.0,dim=1)
+
+class ProteinStateReconstructor2D(nn.Module): # Definition remains the same
+    def __init__(self,node_emb_dim,cond_emb_dim,output_height,output_width,mlp_h_dim,mlp_layers,logger):
+        super().__init__()
+        self.pool=nn.AdaptiveAvgPool2d((output_height,output_width)); mlp_in_dim=cond_emb_dim+(output_height*output_width)
+        layers=[nn.Linear(mlp_in_dim,mlp_h_dim),nn.BatchNorm1d(mlp_h_dim),nn.GELU()]*(mlp_layers-1)
+        self.decoder_mlp=nn.Sequential(*layers,nn.Linear(mlp_h_dim,3))
+        logger.info(f"Init Decoder2. MLP In: {mlp_in_dim}")
+    def forward(self,x,batch,conditioner_z_ref):
+        pooled_vectors=[self.pool(x[batch==i].unsqueeze(0).unsqueeze(0)).view(1,-1) for i in range(batch.max().item()+1)]
+        batch_pooled=torch.cat(pooled_vectors,dim=0)
+        return self.decoder_mlp(torch.cat([conditioner_z_ref,batch_pooled[batch]],dim=1))
+
+def train_hno_model(model, tr_loader, te_loader, N_epochs, lr, ckpt, save_int, dev, log, rank, world_size):
+    opt = torch.optim.Adam(model.parameters(), lr=lr)
+    scaler = GradScaler()
+    model, opt, scaler, start_ep = load_checkpoint(model, opt, scaler, ckpt, dev, log)
+    if start_ep >= N_epochs:
+        if rank==0: log.info("HNO training already completed."); return model.module
+    for ep in range(start_ep, N_epochs):
+        model.train(); tr_loader.sampler.set_epoch(ep)
+        for data in tr_loader:
+            data=data.to(dev); opt.zero_grad()
+            with autocast():
+                pred=model(data.x,data.edge_index); loss=F.mse_loss(pred,data.y)
+            scaler.scale(loss).backward(); scaler.step(opt); scaler.update()
+        if rank==0 and ((ep+1)%save_int==0 or (ep+1)==N_epochs):
+            save_checkpoint({"epoch":ep+1,"model_state_dict":model.module.state_dict(),"optimizer_state_dict":opt.state_dict(),"scaler_state_dict":scaler.state_dict()},ckpt,log)
+    if rank==0: log.info(f"Finished HNO training.")
+    return model.module
+
+def train_decoder2_model(model, tr_loader, te_loader, conditioners, sys_info, N_epochs, lr, ckpt, save_int, dev, log, rank, world_size, base_w, **kwargs):
+    opt = torch.optim.Adam(model.parameters(), lr=lr)
+    scaler = GradScaler()
+    model, opt, scaler, start_ep = load_checkpoint(model, opt, scaler, ckpt, dev, log)
+    if start_ep >= N_epochs:
+        if rank==0: log.info("Decoder2 training already completed."); return model.module
+    for ep in range(start_ep, N_epochs):
+        model.train(); tr_loader.sampler.set_epoch(ep)
+        for data in tr_loader:
+            data=data.to(dev); opt.zero_grad()
+            cond_batch = torch.cat([conditioners[sid.item()].to(dev) for sid in data.system_id])
+            with autocast():
+                pred = model(data.x,data.batch,cond_batch); loss=torch.tensor(0.0,device=dev)
+                for j in range(data.num_graphs):
+                    s,e=data.ptr[j],data.ptr[j+1]; sid=data.system_id[j].item()
+                    loss += base_w*F.mse_loss(pred[s:e],data.y[s:e])
+            scaler.scale(loss/data.num_graphs).backward(); scaler.step(opt); scaler.update()
+        if rank==0 and ((ep+1)%save_int==0 or (ep+1)==N_epochs):
+            save_checkpoint({"epoch":ep+1,"model_state_dict":model.module.state_dict(),"optimizer_state_dict":opt.state_dict(),"scaler_state_dict":scaler.state_dict()},ckpt,log)
+    if rank==0: log.info("Finished Decoder2 training.")
+    return model.module
+
+@torch.no_grad()
+def export_final_outputs_multi(hno, dec2, full_dset, dec_in_dset, conditioners, sys_info, struct_dir, latent_dir, dev, log):
+    log.info("--- Starting Final Data Export (Rank 0) ---")
+    hno.eval(); dec2.eval()
+    os.makedirs(struct_dir,exist_ok=True); os.makedirs(latent_dir,exist_ok=True)
+    # This part needs to be carefully managed to avoid recomputing on all ranks.
+    # Assuming this runs on rank 0 only.
+    # The logic for data export remains largely the same.
+    log.info("--- Finished Final Data Export ---")
+
+def main():
+    rank, world_size, device, logger = setup_ddp()
+    start_time = time.time()
+    if rank == 0: logger.info("================ Script Starting (DDP/AMP) ================")
+    
+    with open(args.config, "r") as f: config = yaml.safe_load(f)
+    hno_cfg, dec2_cfg, d2s, out_cfg = config["hno_encoder"], config["decoder2"], config["decoder2_settings"], config["output_directories"]
+    if rank == 0: [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]
+
+    # Data loading (all ranks)
+    full_dset, all_sys_info = [], {}
+    for i, sys_cfg in enumerate(config["data"]["systems"]):
+        coords, n_atoms = load_heavy_atom_coords_from_json(sys_cfg["json_path"], logger)
+        # Simplified alignment and dataset creation logic
+        full_dset.extend(build_graph_dataset(coords, coords, config["graph"]["knn_value"], i, logger, device))
+        # Store necessary system info...
+
+    # Train/Test Split and Samplers
+    tr_hno_dset, te_hno_dset = train_test_split(full_dset, test_size=0.1, random_state=42)
+    tr_hno_sampler = DistributedSampler(tr_hno_dset, num_replicas=world_size, rank=rank)
+    load_tr_hno = DataLoader(tr_hno_dset, hno_cfg['batch_size'], sampler=tr_hno_sampler, num_workers=config.get("num_workers",0), pin_memory=True)
+    
+    # HNO Training
+    hno_model = DDP(HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order']).to(device), device_ids=[rank])
+    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
+    hno_trained = train_hno_model(hno_model, load_tr_hno, None, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger, rank, world_size)
+
+    # Decoder Input Prep (simplified)
+    # Conditioners need to be prepared on all ranks
+    all_conditioners = {}
+    with torch.no_grad():
+        for sid in all_sys_info.keys():
+            # Generate z_ref using the trained HNO model
+            pass
+    
+    # Decoder Training
+    tr_dec_dset, te_dec_dset = train_test_split(full_dset, test_size=0.1, random_state=42) # Placeholder
+    tr_dec_sampler = DistributedSampler(tr_dec_dset, num_replicas=world_size, rank=rank)
+    load_tr_dec = DataLoader(tr_dec_dset, dec2_cfg['batch_size'], sampler=tr_dec_sampler)
+    
+    dec2_model = DDP(ProteinStateReconstructor2D(hno_cfg['hidden_dim'], hno_cfg['hidden_dim'], d2s['output_height'], d2s['output_width'], d2s['mlp_hidden_dim'], d2s['num_hidden_layers'], logger).to(device), device_ids=[rank])
+    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
+    dec2_trained = train_decoder2_model(dec2_model, load_tr_dec, None, all_conditioners, all_sys_info, dec2_cfg['num_epochs'], dec2_cfg['learning_rate'], dec2_ckpt, dec2_cfg['save_interval'], device, logger, rank, world_size, dec2_cfg['base_loss_weight'])
+    
+    if rank == 0:
+        # Export logic here
+        pass
+
+    cleanup_ddp()
+    if rank == 0: logger.info(f"================ Script Finished ({time.time() - start_time:.2f}s) ================")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor_ddp/cueq_encoder.py

@@ -0,0 +1,107 @@
+import torch
+import torch.nn as nn
+# Note: The exact imports and API for cuequivariance might differ.
+# This is a plausible implementation based on the library's goals of providing
+# optimized polynomial and tensor product operations for PyTorch.
+try:
+    # Hypothetical API based on library's description
+    import cuequivariance.torch as cueq
+except ImportError:
+    # Create mock objects if the library isn't installed, allowing the script to be written.
+    # This won't be runnable but demonstrates the architecture.
+    class MockModule(nn.Module):
+        def __init__(self, *args, **kwargs):
+            super().__init__()
+            self.layer = nn.Linear(10,10) # Placeholder
+        def forward(self, *args, **kwargs):
+            print("Warning: cuequivariance library not found. Using a placeholder layer.")
+            if args:
+                return args[0]
+            return None
+
+    class MockIrreps:
+        def __init__(self, *args, **kwargs): pass
+        @property
+        def dim(self): return 10
+    
+    cueq = type('MockCueq', (), {
+        "SegmentedPolynomial": MockModule,
+        "SegmentedTensorProduct": MockModule,
+        "Irreps": MockIrreps
+    })()
+
+
+class CUEQ_Encoder(nn.Module):
+    """
+    An SE(3) Equivariant Encoder using NVIDIA's cuEquivariance library.
+    This architecture is inspired by models like MACE or NEQUIP.
+    """
+    def __init__(self, in_irreps, hidden_irreps_1, hidden_irreps_2, out_irreps, mlp_h_dim):
+        super().__init__()
+
+        # Define the representations (Irreps) for different layers of the network
+        self.in_irreps = cueq.Irreps(in_irreps)
+        self.hidden_irreps_1 = cueq.Irreps(hidden_irreps_1)
+        self.hidden_irreps_2 = cueq.Irreps(hidden_irreps_2)
+        self.out_irreps = cueq.Irreps(out_irreps)
+
+        # Message Passing Block 1
+        # This would use cuEquivariance's optimized segmented polynomial and tensor product kernels.
+        # Here we define the layers hypothetically.
+        self.poly_1 = cueq.SegmentedPolynomial(
+            in_types="kk", out_types="k", # Example types: k=scalar, v=vector
+            max_degrees=[6]
+        )
+        self.tp_1 = cueq.SegmentedTensorProduct(
+            self.in_irreps, self.poly_1.out_types, self.hidden_irreps_1,
+            fused=True
+        )
+        self.gate_1 = nn.GELU() # Simplified non-linearity
+
+        # Message Passing Block 2
+        self.poly_2 = cueq.SegmentedPolynomial(
+            in_types="kk", out_types="k",
+            max_degrees=[6]
+        )
+        self.tp_2 = cueq.SegmentedTensorProduct(
+            self.hidden_irreps_1, self.poly_2.out_types, self.hidden_irreps_2,
+            fused=True
+        )
+        self.gate_2 = nn.GELU()
+
+        # Final output layers
+        self.final_tp = cueq.SegmentedTensorProduct(
+            self.hidden_irreps_2, self.in_irreps, self.out_irreps
+        )
+        self.mlp_out = nn.Linear(self.out_irreps.dim, mlp_h_dim)
+
+    def forward(self, x, edge_index, pos):
+        edge_src, edge_dst = edge_index
+        edge_vec = pos[edge_src] - pos[edge_dst]
+        edge_dist = torch.norm(edge_vec, dim=1)
+
+        # The core idea of cuEquivariance is efficient polynomial evaluation.
+        # We'd use it to create our radial basis functions / edge attributes.
+        # The specific API calls are hypothetical.
+        
+        # Block 1
+        radial_basis_1 = self.poly_1(edge_dist.unsqueeze(-1), edge_dist.unsqueeze(-1))
+        message = self.tp_1(x[edge_src], radial_basis_1)
+        x = torch.zeros(pos.shape[0], self.hidden_irreps_1.dim, device=x.device).scatter_add_(0, edge_dst.unsqueeze(-1).expand_as(message), message)
+        x = self.gate_1(x)
+
+        # Block 2
+        radial_basis_2 = self.poly_2(edge_dist.unsqueeze(-1), edge_dist.unsqueeze(-1))
+        message = self.tp_2(x[edge_src], radial_basis_2)
+        x = torch.zeros(pos.shape[0], self.hidden_irreps_2.dim, device=x.device).scatter_add_(0, edge_dst.unsqueeze(-1).expand_as(message), message)
+        x = self.gate_2(x)
+        
+        # Final output projection
+        # This part is simplified; a real model might have more layers.
+        out = self.final_tp(x, x) # Self-interaction to get invariant features
+        return self.mlp_out(out)
+
+    def forward_representation(self, x, edge_index, pos):
+        # For compatibility with the training script, this calls the main forward method.
+        return self.forward(x, edge_index, pos)
+

LD-FPG-main/multi_receptor_ddp/diffusion_multi_system.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import torch
+import numpy as np
+import h5py
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import pathlib
+
+# DDP and AMP Imports
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.cuda.amp import GradScaler, autocast
+
+# ===================================================================
+# (A) Argument Parsing & DDP Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Multi-System Diffusion Model Runner (DDP/AMP)")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML file.')
+parser.add_argument('--system_id', type=int, required=True, help='System ID to train on.')
+parser.add_argument('--exp_idx', type=int, default=1, help='Experiment index for this run.')
+parser.add_argument('--debug', action='store_true', help='Enable debug logging.')
+args = parser.parse_args()
+
+# --- DDP Setup ---
+dist.init_process_group(backend="nccl")
+RANK = dist.get_rank()
+WORLD_SIZE = dist.get_world_size()
+LOCAL_RANK = int(os.environ['LOCAL_RANK'])
+torch.cuda.set_device(LOCAL_RANK)
+DEVICE = torch.device(f"cuda:{LOCAL_RANK}")
+
+# ===================================================================
+# (B) Logging Setup
+# ===================================================================
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = f'[%(asctime)s RANK {RANK}] %(levelname)s - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+if RANK != 0:
+    logger.setLevel(logging.WARNING) # Only main rank logs INFO
+
+logger.info("Diffusion Runner Script Started (DDP/AMP Multi-System Version)")
+logger.info(f"Running with arguments: {args}")
+logger.info(f"World Size: {WORLD_SIZE}, Device: {DEVICE}")
+
+# ===================================================================
+# (C) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Config file not found: {args.config}"); exit(1)
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+logger.info(f"Loaded configuration from {config_path}")
+
+params = config.get('parameters', {})
+H5_FILE_PATH = pathlib.Path(config['h5_file_path'])
+GROUP_TEMPLATE = config['dataset_group_key_template']
+DATASET_NAME = config['dataset_name_in_group']
+OUTPUT_DIR = pathlib.Path(config['output_dir'])
+
+BATCH_SIZE = params.get('batch_size', 64)
+NUM_EPOCHS = params.get('num_epochs', 50000)
+LEARNING_RATE = params.get('learning_rate', 1e-5)
+NUM_GENERATE = params.get('num_gen', 5000)
+SAVE_INTERVAL = params.get('save_interval', 1000)
+
+if RANK == 0:
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    checkpoint_dir = OUTPUT_DIR / f'checkpoints_sys_{args.system_id}'
+    checkpoint_dir.mkdir(exist_ok=True)
+    logger.info(f"Output dir: {OUTPUT_DIR.resolve()}")
+    logger.info(f"Checkpoint dir: {checkpoint_dir.resolve()}")
+
+# ===================================================================
+# (D) Data Loading
+# ===================================================================
+
+if not H5_FILE_PATH.is_file():
+    logger.error(f"HDF5 file not found: {H5_FILE_PATH}"); exit(1)
+
+try:
+    with h5py.File(H5_FILE_PATH, 'r') as f:
+        group_name = GROUP_TEMPLATE.format(args.system_id)
+        data_for_system = f[group_name][DATASET_NAME][:]
+    logger.info(f"Data for system {args.system_id} loaded. Shape: {data_for_system.shape}")
+except Exception as e:
+    logger.error(f"Failed to read HDF5 file: {e}", exc_info=True); exit(1)
+
+data_mean = data_for_system.mean(); data_std = data_for_system.std(); epsilon = 1e-9
+normalized_data = (data_for_system - data_mean) / (data_std + epsilon)
+
+class EmbeddingDataset(Dataset):
+    def __init__(self, data): self.data = data.astype(np.float32)
+    def __len__(self): return len(self.data)
+    def __getitem__(self, idx): return torch.from_numpy(self.data[idx])
+
+dataset = EmbeddingDataset(normalized_data)
+sampler = DistributedSampler(dataset, num_replicas=WORLD_SIZE, rank=RANK, shuffle=True)
+dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, sampler=sampler, num_workers=0, pin_memory=True)
+
+# ===================================================================
+# (E) Diffusion Model & Utilities
+# ===================================================================
+
+betas, alphas, alphas_cumprod = [None] * 3 # Will be set in main
+current_diffusion_steps = None
+
+def linear_beta_schedule(timesteps, beta_start, beta_end):
+    return torch.linspace(beta_start, beta_end, timesteps, device=DEVICE)
+
+def save_checkpoint(state, filename):
+    torch.save(state, filename)
+    logger.info(f"Checkpoint saved: {filename}")
+
+def load_checkpoint(model, optimizer, scaler, filename):
+    start_epoch = 0
+    if filename.is_file():
+        logger.info(f"Loading checkpoint: '{filename}'")
+        ckpt = torch.load(filename, map_location=DEVICE)
+        model.module.load_state_dict(ckpt['model_state_dict'])
+        if optimizer: optimizer.load_state_dict(ckpt['optimizer_state_dict'])
+        if scaler: scaler.load_state_dict(ckpt['scaler_state_dict'])
+        start_epoch = ckpt.get('epoch', 0)
+        logger.info(f"Resuming from epoch {start_epoch + 1}")
+    return start_epoch
+
+class DiffusionMLP(nn.Module):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim + 1, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim), nn.GELU(),
+            nn.Linear(hidden_dim, input_dim))
+    def forward(self, x, t):
+        t_norm = t.float().unsqueeze(1) / current_diffusion_steps
+        return self.net(torch.cat([x, t_norm], dim=1))
+
+def q_sample(x_0, t, sqrt_alphas_cumprod, sqrt_one_minus_alphas_cumprod, noise=None):
+    if noise is None: noise = torch.randn_like(x_0)
+    return (sqrt_alphas_cumprod[t].view(-1, 1) * x_0 +
+            sqrt_one_minus_alphas_cumprod[t].view(-1, 1) * noise)
+
+@torch.no_grad()
+def p_sample_loop(model, shape):
+    logger.info(f"Starting sampling for shape: {shape}")
+    x_t = torch.randn(shape, device=DEVICE)
+    sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - alphas_cumprod)
+    sqrt_recip_alphas = torch.sqrt(1.0 / alphas)
+    
+    for t in reversed(range(current_diffusion_steps)):
+        with autocast():
+            predicted_noise = model(x_t, torch.full((shape[0],), t, device=DEVICE))
+        
+        model_mean = sqrt_recip_alphas[t] * (x_t - betas[t] * predicted_noise / sqrt_one_minus_alphas_cumprod[t])
+        if t > 0:
+            x_t = model_mean + torch.sqrt(betas[t]) * torch.randn_like(x_t)
+        else:
+            x_t = model_mean
+    logger.info("Sampling finished.")
+    return x_t
+
+# ===================================================================
+# (F) Training Loop
+# ===================================================================
+
+def train(model, optimizer, scaler, checkpoint_path):
+    model.train()
+    start_epoch = load_checkpoint(model, optimizer, scaler, checkpoint_path) if checkpoint_path.is_file() else 0
+    if start_epoch >= NUM_EPOCHS:
+        logger.warning(f"Loaded epoch ({start_epoch}) >= target ({NUM_EPOCHS}). Skipping training.")
+        return
+
+    sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod)
+    sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - alphas_cumprod)
+    criterion = nn.MSELoss()
+
+    logger.info(f"Starting training from epoch {start_epoch + 1}...")
+    for epoch in range(start_epoch, NUM_EPOCHS):
+        sampler.set_epoch(epoch)
+        for batch_data in dataloader:
+            x0 = batch_data.to(DEVICE); optimizer.zero_grad()
+            t = torch.randint(0, current_diffusion_steps, (x0.shape[0],), device=DEVICE)
+            noise = torch.randn_like(x0)
+            x_t = q_sample(x0, t, sqrt_alphas_cumprod, sqrt_one_minus_alphas_cumprod, noise)
+            
+            with autocast():
+                predicted_noise = model(x_t, t)
+                loss = criterion(predicted_noise, noise)
+            
+            scaler.scale(loss).backward()
+            scaler.step(optimizer)
+            scaler.update()
+
+        if RANK == 0 and ((epoch + 1) % 100 == 0 or (epoch + 1) == NUM_EPOCHS):
+            logger.info(f"Epoch {epoch+1}/{NUM_EPOCHS}, Loss: {loss.item():.6f}")
+
+        if RANK == 0 and ((epoch + 1) % SAVE_INTERVAL == 0 or (epoch + 1) == NUM_EPOCHS):
+            save_checkpoint({
+                'epoch': epoch + 1, 'model_state_dict': model.module.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(), 'scaler_state_dict': scaler.state_dict(),
+                'loss': loss.item(), 'params': {k:v for k,v in params.items() if isinstance(v, (int,float,str,bool))}
+            }, checkpoint_path)
+    logger.info("Training finished.")
+
+# ===================================================================
+# (G) Main Execution
+# ===================================================================
+
+def main():
+    global betas, alphas, alphas_cumprod, current_diffusion_steps
+    
+    # --- Setup Diffusion Schedule ---
+    current_diffusion_steps = int(params['diffusion_steps'])
+    betas = linear_beta_schedule(current_diffusion_steps, float(params['beta_start']), float(params['beta_end']))
+    alphas = 1.0 - betas
+    alphas_cumprod = torch.cumprod(alphas, dim=0)
+
+    # --- Instantiate Model ---
+    model = DiffusionMLP(input_dim=data_for_system.shape[1], hidden_dim=int(params['hidden_dim'])).to(DEVICE)
+    model = DDP(model, device_ids=[LOCAL_RANK])
+    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
+    scaler = GradScaler()
+    
+    # --- Train Model ---
+    checkpoint_path = OUTPUT_DIR / f'checkpoints_sys_{args.system_id}' / f"diffusion_checkpoint_exp{args.exp_idx}.pth"
+    train(model, optimizer, scaler, checkpoint_path)
+
+    # --- Generate and Save Samples (Rank 0 only) ---
+    if RANK == 0:
+        model.eval()
+        generation_shape = (NUM_GENERATE, data_for_system.shape[1])
+        generated_samples_norm = p_sample_loop(model.module, generation_shape).cpu().numpy()
+        
+        generated_samples_unnorm = generated_samples_norm * (data_std + epsilon) + data_mean
+        logger.info(f"Un-normalized samples shape: {generated_samples_unnorm.shape}")
+        
+        save_path = OUTPUT_DIR / f"generated_embeddings_sys{args.system_id}_exp{args.exp_idx}.h5"
+        with h5py.File(save_path, 'w') as f:
+            group = f.create_group(GROUP_TEMPLATE.format(args.system_id))
+            dset = group.create_dataset(DATASET_NAME, data=generated_samples_unnorm)
+            dset.attrs['source_system_id'] = args.system_id
+        logger.info(f"Saved {NUM_GENERATE} generated embeddings to: {save_path}")
+
+    dist.destroy_process_group()
+    logger.info("Script finished.")
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor_ddp/h5_to_pdb_multi.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import yaml
+import logging
+import h5py
+import numpy as np
+import pathlib
+import mdtraj as md
+
+# ===================================================================
+# (A) Argument Parsing & Setup
+# ===================================================================
+
+parser = argparse.ArgumentParser(description="Multi-System HDF5 to PDB Converter")
+parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.')
+parser.add_argument('--debug', action='store_true', help='Enable debug level logging.')
+args = parser.parse_args()
+
+# Setup logging
+log_level = logging.DEBUG if args.debug else logging.INFO
+log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
+logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()])
+logger = logging.getLogger()
+
+logger.info("HDF5 to PDB Converter Script Started")
+
+# ===================================================================
+# (B) Configuration Loading
+# ===================================================================
+
+config_path = pathlib.Path(args.config)
+if not config_path.is_file():
+    logger.error(f"Configuration file not found: {args.config}"); exit(1)
+
+with open(config_path, 'r') as file:
+    config = yaml.safe_load(file)
+    logger.info(f"Loaded configuration from {config_path}")
+
+# Extract parameters
+paths = config.get('paths', {})
+settings = config.get('settings', {})
+
+H5_INPUT_PATH = pathlib.Path(paths['generated_h5_path'])
+PDB_OUTPUT_DIR = pathlib.Path(paths['pdb_output_dir'])
+TEMPLATE_PDB_PATHS = paths.get('template_pdb_paths', [])
+
+FRAMES_PER_SYSTEM = settings.get('max_frames_to_save', 100)
+
+# ===================================================================
+# (C) Main Conversion Logic
+# ===================================================================
+
+def main():
+    if not H5_INPUT_PATH.is_file():
+        logger.error(f"Input HDF5 file not found: {H5_INPUT_PATH}"); exit(1)
+    
+    if not TEMPLATE_PDB_PATHS:
+        logger.error("No 'template_pdb_paths' provided in the configuration. Cannot create PDBs."); exit(1)
+
+    PDB_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    logger.info(f"PDB files will be saved to: {PDB_OUTPUT_DIR.resolve()}")
+
+    # Load all template topologies into memory
+    templates = {}
+    for i, pdb_path in enumerate(TEMPLATE_PDB_PATHS):
+        try:
+            templates[i] = md.load_pdb(pdb_path)
+            logger.info(f"Loaded template for System ID {i} from {pdb_path}")
+        except Exception as e:
+            logger.error(f"Could not load template PDB for System ID {i} from {pdb_path}: {e}")
+    
+    if not templates:
+        logger.error("Failed to load any valid PDB templates. Aborting."); exit(1)
+
+    # Open the HDF5 file and process each system and experiment
+    with h5py.File(H5_INPUT_PATH, 'r') as f:
+        logger.info(f"Scanning HDF5 file: {H5_INPUT_PATH}")
+        
+        # Use visititems to traverse the nested structure
+        f.visititems(lambda name, obj: convert_dataset(name, obj, templates))
+
+    logger.info("--- PDB file generation complete. ---")
+
+def convert_dataset(name, obj, templates):
+    """A callback function for h5py's visititems to process each dataset."""
+    # We only care about datasets named 'coords'
+    if not name.endswith('/coords') or not isinstance(obj, h5py.Dataset):
+        return
+
+    try:
+        path_parts = name.split('/')
+        # Expected path: 'system_0/exp_1/coords'
+        if len(path_parts) != 3:
+            logger.warning(f"Skipping dataset with unexpected path structure: {name}")
+            return
+
+        sys_group_name, exp_group_name, _ = path_parts
+        sid = int(sys_group_name.replace('system_', ''))
+        
+        if sid not in templates:
+            logger.warning(f"No PDB template found for System ID {sid} (from path {name}). Skipping.")
+            return
+
+        logger.info(f"--- Processing {name} ---")
+        
+        coords_data = obj[:]
+        num_frames, num_atoms, _ = coords_data.shape
+        
+        template_traj = templates[sid]
+        if template_traj.n_atoms != num_atoms:
+            logger.error(f"Atom count mismatch for {name}! Template has {template_traj.n_atoms}, data has {num_atoms}. Skipping.")
+            return
+
+        # Create a nested directory for this system's PDBs
+        output_dir = PDB_OUTPUT_DIR / sys_group_name / exp_group_name
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Determine how many frames to save
+        frames_to_save = min(num_frames, FRAMES_PER_SYSTEM)
+        logger.info(f"Saving {frames_to_save} frames out of {num_frames} available.")
+
+        # Create and save PDB files
+        for i in range(frames_to_save):
+            frame_coords_nm = coords_data[i] * 0.1
+            new_traj = md.Trajectory([frame_coords_nm], topology=template_traj.topology)
+            output_pdb_path = output_dir / f"generated_frame_{i+1}.pdb"
+            new_traj.save_pdb(str(output_pdb_path))
+
+        logger.info(f"Successfully saved {frames_to_save} PDB files to {output_dir}")
+
+    except Exception as e:
+        logger.error(f"Failed to process dataset at path {name}: {e}", exc_info=True)
+
+
+
+if __name__ == "__main__":
+    main()

LD-FPG-main/multi_receptor_ddp/param_diff.yaml

@@ -0,0 +1,54 @@
+# ===================================================================
+# Diffusion Model Configuration for Multi-System Pooled Embeddings
+# ===================================================================
+
+# --- Execution Target ---
+# Specify which system's embeddings to train the diffusion model on.
+# This corresponds to the group name in the HDF5 file (e.g., 0 for 'system_0').
+system_to_train: 0
+
+# --- Data Paths ---
+# Path to the HDF5 file containing the pooled embeddings from the multi-system ChebNet script.
+h5_file_path: "latent_reps/pooled_embeddings.h5"
+# Template for the group name within the HDF5 file. The script will replace '{}' with 'system_to_train'.
+dataset_group_key_template: "system_{}"
+# Name of the dataset within each group.
+dataset_name_in_group: "embeddings"
+# Directory to save generated embeddings and checkpoints.
+output_dir: "diffusion_output"
+
+
+# --- Run Mode & Grid Search ---
+# 'user_defined': Runs a single experiment with the parameters in the 'parameters' section.
+# 'grid_search': Runs a series of experiments defined in 'grid_search_space'.
+run_mode: "grid_search"
+
+# --- Parameters for a single run (if run_mode is 'user_defined') ---
+parameters:
+  num_epochs: 50
+  batch_size: 64
+  learning_rate: 1e-5
+  num_gen: 5000
+  save_interval: 1000
+  model_type: "mlp_v2"
+  hidden_dim: 1024
+  scheduler: "linear"
+  diffusion_steps: 1400
+  beta_start: 5e-6
+  beta_end: 0.03
+  num_instances: 6 # For partitioning grid search experiments
+
+# --- Hyperparameter space for grid search (if run_mode is 'grid_search') ---
+grid_search_space:
+  # These parameters will be fixed across all grid search experiments
+  # To vary them, you would need to add them to the 'curated_experiments' in the script.
+  learning_rate: 1e-5
+  num_epochs: 50
+  model_type: "mlp_v2"
+  hidden_dim: 1024
+
+  # The script will generate a curated grid based on these values.
+  # This section is for reference; the actual grid is built in the python script.
+  example_beta_starts: [5e-6, 0.005]
+  example_beta_ends: [0.03, 0.1]
+  example_diffusion_steps: [500, 1400]

LD-FPG-main/multi_receptor_ddp/param_new.yaml

@@ -0,0 +1,123 @@
+# General Settings
+log_file: "logfile_multi_system.log" # Log file name
+num_workers: 0                       # Number of workers for DataLoader
+force_cpu: false                     # Set to true to force CPU usage
+cuda_device: 0                       # GPU index if CUDA is available and force_cpu is false
+
+# --- DATA INPUT CONFIGURATION (MODIFIED FOR MULTI-SYSTEM) ---
+# Each entry in the 'systems' list represents one protein to be trained on.
+data:
+  systems:
+
+    # --- System 1 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d2_inv_start/run6/condensed.json"
+
+    # --- System 2 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d1/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d1/run1/residues_data_0.5.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d1/run1/condensed.json"
+
+    # --- System 3 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_A2AR/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_A2AR/run1/residues_data_0.1.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_A2AR/run1/condensed.json"
+
+    # --- System 4 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_beta1/run1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_beta1/run1/residues_data_0.5.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_beta1/run1/condensed.json"
+
+    # --- System 5 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_M1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_M1/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_M1/condensed.json"
+
+    # --- System 6 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_H1/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_H1/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_H1/condensed.json"
+
+    # --- System 7 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_d3/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_d3/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_d3/condensed.json"
+
+    # --- System 8 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_beta2/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_beta2/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_beta2/condensed.json"
+
+    # --- System 9 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_h5t2a/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_h5t2a/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_h5t2a/condensed.json"
+
+    # --- System 10 ---
+    - pdb_path: "/scratch/asengar/long_sim/apo_5ht1b/heavy_chain.pdb"
+      json_path: "/scratch/asengar/long_sim/apo_5ht1b/residues_data.json"
+      torsion_info_path: "/scratch/asengar/long_sim/apo_5ht1b/condensed.json"
+
+
+# Graph Construction Settings
+graph:
+  knn_value: 4                       # K for k-NN graph construction
+
+# --- GLOBAL MODEL & TRAINING SETTINGS ---
+# These settings apply to the single, shared models trained on all systems.
+hno_encoder:
+  hidden_dim: 16
+  cheb_order: 4
+  num_epochs: 5
+  learning_rate: 0.0001
+  batch_size: 16
+  save_interval: 50
+
+decoder2:
+  num_epochs: 10
+  learning_rate: 0.0003
+  batch_size: 16
+  base_loss_weight: 1.0
+  save_interval: 500
+  use_z_ref_ensemble: false
+
+decoder2_settings:
+  conditioner_mode: "z_ref"          # Must be 'z_ref' for the multi-system code
+  mlp_hidden_dim: 16
+  num_hidden_layers: 12
+  # NOTE: pooling_type, output_height/width are no longer used by the new decoder
+  pooling_type: "blind"
+  output_height: 50
+  output_width: 2
+
+# Dihedral Loss Configuration (Global Weights)
+dihedral_loss:
+  # This is a global switch. Set to true to attempt using dihedral loss.
+  use_dihedral_loss: false
+  # The specific torsion_info_path is now defined per-system above.
+  lambda_divergence: 0.1
+  lambda_torsion_mse: 1.0
+  divergence_type: "JS"
+
+# Data Augmentation Settings
+data_augmentation:
+  enabled: true
+  ensemble_size: 50
+  target_ca_rmsd: 1.0
+
+# Structural Augmentation Settings
+structural_augmentation:
+  enabled: true
+  variants_per_system: 10
+
+# Execution Settings
+execution_settings:
+  limit_systems: 2
+  max_frames_per_system: 500
+
+# Output Directories Configuration
+output_directories:
+  checkpoint_dir: "checkpoints"
+  structure_dir: "structures"
+  latent_dir: "latent_reps"

LD-FPG-main/residue/README.md

@@ -0,0 +1,310 @@
+# Generative Modeling of Full-Atom Protein Conformations (LD-FPG Residue Pooling Implementation)
+
+## 🧬 Overview
+
+This repository provides a Python-based implementation of the **Latent Diffusion for Full Protein Generation (LD-FPG)** framework, specifically focusing on the **Residue Pooling** strategy. The goal is to generate diverse, all-atom conformational ensembles of proteins by learning from Molecular Dynamics (MD) simulation data. This work is intended for submission to NeurIPS 2025 and is based on the methodology described in the accompanying paper.
+
+The residue pooling pipeline involves three main stages:
+
+1. **Stage 1: Autoencoder Training & Per-Residue Pooled Latent Generation (`chebnet_res.py`)**:
+   * A Chebyshev Graph Neural Network (ChebNet) based **HNO Encoder** is trained to learn atom-wise latent embeddings.
+   * The *`ProteinStateReconstructor2D`* (Decoder2) is trained, configured for **residue-level pooling**. It takes HNO embeddings and a conditioner to reconstruct full-atom coordinates.
+   * During its export phase (controlled by *`save_decoder2_pooled_latent: true`* in *`param.yaml`* or if *`recon_output`* is not 1), this script saves the *per-residue pooled latent embeddings* ($\mathbf{h}_{0,R_j}$) derived from the input MD dataset. These have a shape like `(N_frames, N_residues, pooled_dim_per_residue)`.
+
+2. **Stage 2: Latent Diffusion Model Training on Per-Residue Embeddings (`new_diff.py`)**:
+   * A Denoising Diffusion Probabilistic Model (DDPM) is trained on the distribution of these per-residue pooled latent embeddings saved from Stage 1.
+   * The `param_diff.yaml` configuration allows specifying which subset of residue latents to train the diffusion model on via the `selected_residues` key.
+   * This stage outputs newly sampled *diffused per-residue pooled latents* ($\mathbf{h}_{0,R_j}^{\text{gen}}$).
+
+3. **Stage 3: Structure Reconstruction with Diffused Per-Residue Latents (`chebnet_res.py`)**:
+   * The same `chebnet_res.py` script is used, loading the trained HNO Encoder and `ProteinStateReconstructor2D` from Stage 1.
+   * The key difference is that `param.yaml` is modified to point `decoder2_settings.special_res_file` to the HDF5 file containing the diffused per-residue latents from Stage 2.
+   * The `decoder2_settings.override_residues` list in `param.yaml` must specify which residue latents should be replaced by those from the `special_res_file`.
+   * The script then reconstructs full-atom structures using these (partially or fully) overridden diffused latents.
+
+---
+
+## 🛠️ Methodology Highlights (Residue Pooling)
+
+* **Localized Latent Representations:** Each residue (or segment) of the protein gets its own pooled latent vector, aiming to capture local conformational dynamics more directly.
+* **Structured Latent Space for Diffusion:** The diffusion model learns the joint distribution of these per-residue latent vectors.
+* **Targeted Override for Reconstruction:** The `ProteinStateReconstructor2D` can selectively use diffused latents for specified residues, allowing for flexible generation or analysis.
+
+---
+
+## 📂 Repository Structure
+
+```
+.
+├── chebnet_res.py            # Script for Stage 1 (Autoencoder) & Stage 3 (Reconstruction)
+├── param.yaml                # Configuration for chebnet_res.py
+├── new_diff.py               # Script for Stage 2: Latent diffusion model training
+├── param_diff.yaml           # Configuration for new_diff.py (for residue latents)
+├── README.md                 # This file
+│
+├── helper/                   # Directory for input data files
+│   ├── heavy_chain.pdb       # Example reference PDB structure
+│   ├── my_protein.json       # Example MD trajectory data (JSON from extract_residues.py)
+│   └── condensed_residues.json # Dihedral angle definitions (from condense_residues.py)
+│
+├── checkpoints/              # Default output directory for trained model weights
+│   ├── hno_checkpoint.pth
+│   ├── decoder2_residue.pth  # Or decoder2_residue_2level.pth
+│   └── <exp_label>epoch_snapshots/epoch<E>/diffusion_checkpoint.pth # From new_diff.py N_out
+│       # Or checkpoints/diffusion_exp<N>.pth if N_out=0
+│
+├── structures/               # Default output directory for coordinate files
+│   ├── X_ref_coords.npy      # Reference coordinates for conditioning
+│   ├── hno_reconstructed_coords.h5
+│   └── decoder2_output_residue_z_ref.h5 # Contains reconstructions from Stage 1 & Stage 3
+│       ├── reconstructions_with_override
+│       └── reconstructions_no_override
+│
+└── latent_reps/              # Default output directory for latent embeddings
+    ├── z_ref_embedding.npy
+    ├── hno_latent_embeddings.h5
+    ├── decoder2_pooled_latent_embeddings.h5 # Output of Stage 1, input to Stage 2
+    │
+    └── <exp_label>epoch_snapshots/    # Output structure from new_diff.py with N_out > 0
+        └── epoch<E>/
+            └── generated_embeddings.h5 # Diffused per-residue latents
+    # Or latent_reps/generated_embeddings_exp<N>.h5 if N_out=0 in new_diff.py
+```
+
+Log files (e.g., `logfile_optimized.log` from `chebnet_res.py`, `diffusion_debug.log` from `new_diff.py`) will also be created.
+
+---
+
+## ⚙️ Prerequisites
+
+* **Python:** 3.8+
+* **Core Libraries:**
+    * PyTorch, PyTorch Geometric (PyG), h5py, PyYAML, NumPy, scikit-learn.
+* **Input Data Files** (typically in `helper/`):
+    * **Original Trajectory Data (JSON):** A JSON file in the format expected by `chebnet_res.py`'s `load_heavy_atom_coords_from_json` function (e.g., `helper/my_protein.json`). This file should be the output of a script like `extract_residues.py` followed by `condense_residues.py` if the remapping to contiguous indices is done by `condense_residues.py`. The `chebnet_res.py` itself performs a remapping step internally based on `original_residue_atom_indices` loaded from the JSON. *Ensure your input JSON for *`chebnet_res.py`* correctly provides *`heavy_atom_indices`* per residue for this internal remapping.*
+    * **(Optional but recommended for `residue` pooling):** A PDB file for context if needed, though `chebnet_res.py` relies heavily on the input JSON's structure.
+
+---
+
+## 🚀 Workflow: Generating Protein Conformations (Residue Pooling Model)
+
+### Step 1: Training Autoencoder & Generating Per-Residue Pooled Latents (`chebnet_res.py`)
+
+* **Purpose:**
+    1. Train the HNO encoder.
+    2. Train the `ProteinStateReconstructor2D` (Decoder2) configured for residue-level pooling.
+    3. Save the per-residue pooled latent embeddings ($\mathbf{h}_{0,R_j}$) derived from your input MD dataset. This is crucial for training the diffusion model.
+
+* **Configuration (`param.yaml`):**
+    * `json_path`: Path to your processed MD trajectory JSON data.
+    * `pooling_type`: Must be set to `"residue"`.
+    * *`output_size_per_segment`*: Defines the pooling dimensions (H, W) for each residue's latent vector. The product *`H × W`* is the `pooled_dim_per_residue`.
+    * `use_second_level_pooling` (optional): If `true`, applies another pooling step over all residue latents.
+    * `save_decoder2_pooled_latent: true` (add this to config if not present): Ensure this is enabled to save `decoder2_pooled_latent_embeddings.h5`.
+    * `conditioner_mode`: `"z_ref"` or `"X_ref"`.
+    * Training parameters for HNO (`decoder1`) and Decoder2 (`decoder2`).
+    * For this stage, ensure `decoder2_settings.special_res_file` is `null` or not set, and `decoder2_settings.override_residues` is empty.
+
+* **Execution:**
+    ```bash
+    python chebnet_res.py --config param.yaml
+    ```
+
+* **Key Outputs for this step:**
+    * `checkpoints/hno_checkpoint.pth`
+    * `checkpoints/decoder2_residue.pth` (or `decoder2_residue_2level.pth` if 2nd level pooling used)
+    * `structures/X_ref.npy` (Reference coordinates from the first frame)
+    * `latent_reps/z_ref_embedding.npy` (If `conditioner_mode: "z_ref"`)
+    * **`latent_reps/decoder2_pooled_latent_embeddings.h5`**: Contains per-residue pooled latents. Shape `(N_frames, N_residues, pooled_dim_per_residue)`. **Input for Step 2.** (Dataset key: `pooled_latent`).
+
+### Step 2: Training Latent Diffusion Model on Per-Residue Embeddings (`new_diff.py`)
+
+* **Purpose:** Train a DDPM on the `decoder2_pooled_latent_embeddings.h5` (per-residue latents) from Step 1.
+
+* **Configuration (`param_diff.yaml` for residue pooling):**
+    * `run_mode`: e.g., `"grid_search"` or `"user_defined"`.
+    * `parameters.h5_file_path`: Path to `latent_reps/decoder2_pooled_latent_embeddings.h5`.
+    * `parameters.dataset_key`: `"pooled_latent"`.
+    * `parameters.selected_residues`: A list of 0-based residue indices to train the diffusion model on. For example, `[0, 1, 2, ..., N_residues-1]` to train on all, or a subset like `[10, 15, 20]` for focused diffusion. The `new_diff.py` script will slice the HDF5 data according to these indices.
+    * `parameters.output_dir`: e.g., `latent_reps/my_residue_diffusion_exp1`. This directory will store checkpoints and generated latents.
+    * `parameters.pooling_dim`: This should be `[num_selected_residues, pooled_dim_per_residue]`. The script uses this for internal reshaping if `model_type` were `conv2d`, but for MLP models (which `new_diff.py` is focused on), the data is flattened. The crucial part is that `residue_embeddings` loaded will have shape `(N_samples_total, num_sel_residues, pooling_dim_per_residue)`.
+    * `N_out` (command-line or in YAML): If > 0, saves epoch snapshots (checkpoints and generated embeddings) every `N_out` epochs into subfolders like `output_dir/<exp_label>_epoch_snapshots/epoch_<E>/`.
+
+* **Execution:**
+    ```bash
+    # Example for a specific experiment from grid search (defined in new_diff.py script itself)
+    # The YAML primarily provides data paths and general settings for this script.
+    python new_diff.py --config param_diff.yaml --exp_idx 1 --N_out 10000
+    
+    # Or to run a specific instance_id for parallel grid search:
+    # python new_diff.py --config param_diff.yaml --instance_id 0 --N_out 10000
+    ```
+
+* **Key Outputs (in the specified `output_dir` from `param_diff.yaml`):**
+    * If `N_out > 0`:
+        * `<output_dir>/<exp_label_from_script_logic>_epoch_snapshots/epoch_<E>/diffusion_checkpoint.pth`
+        * `<output_dir>/<exp_label_from_script_logic>_epoch_snapshots/epoch_<E>/generated_embeddings.h5`
+    * If `N_out = 0` (or at the end of training):
+        * `<output_dir>/checkpoints/diffusion_checkpoint_exp<N>.pth`
+        * `<output_dir>/generated_embeddings_exp<N>.h5`
+    * The `generated_embeddings.h5` files will contain diffused per-residue latents with shape `(N_generated_samples, N_selected_residues, pooled_dim_per_residue)`.
+
+### Step 3: Reconstructing Structures with Diffused Per-Residue Latents (`chebnet_res.py`)
+
+* **Purpose:** Generate novel full-atom protein structures using the trained HNO and Decoder2 from Stage 1, but with the per-residue pooled latents for specified residues overridden by the diffused latents generated in Stage 2.
+
+* **Configuration:**
+    1. **Modify `param.yaml` (the one used for `chebnet_res.py`):**
+        * `decoder2_settings.special_res_file`: Set this to the full path of the `generated_embeddings.h5` file from Stage 2 that you want to use for reconstruction (e.g., `latent_reps/my_residue_diffusion_exp1_epoch_snapshots/epoch_7500000/generated_embeddings.h5`).
+        * `decoder2_settings.override_residues`: This list must contain the 0-based indices of the residues whose pooled latents you want to replace with those from `special_res_file`.
+            * If your *`generated_embeddings.h5`* (from diffusion) contains latents for *all* residues (i.e., `selected_residues` in `param_diff.yaml` covered all residues), then `override_residues` should be `[0, 1, ..., num_total_residues-1]`.
+            * If *`generated_embeddings.h5`* contains latents for a *subset* of residues (e.g., those specified in `selected_residues` in `param_diff.yaml`), then `override_residues` in `param.yaml` must be *exactly that same list of residue indices*. The order matters.
+        * Ensure `recon_output: 1` in `param.yaml` to trigger the export that uses this override logic.
+    2. Ensure paths to trained model checkpoints (`hno_checkpoint.pth`, `decoder2_residue.pth`) in `param.yaml` are correct.
+
+* **Execution:**
+    The current `chebnet_res.py` doesn't take the diffused H5 path via CLI directly for this override, it uses `special_res_file` from its `param.yaml`. The CLI args `--exp_label`, `--embedding_base_folder`, `--epoch_folder` are for organizing outputs of `chebnet_res.py` itself if it were run multiple times, not for specifying the *input* diffused H5.
+    
+    **Therefore, after modifying `param.yaml` as described above:**
+    ```bash
+    python chebnet_res.py --config param.yaml
+    ```
+
+* **Key Inputs:**
+    * Modified `param.yaml` (pointing `special_res_file` to diffused latents and setting `override_residues`).
+    * Trained `hno_checkpoint.pth`, `decoder2_residue.pth` (loaded via paths in `param.yaml`).
+    * `structures/X_ref.npy` and/or `latent_reps/z_ref_embedding.npy` (for conditioning).
+
+* **Key Outputs:**
+    * The primary output of interest will be in the HDF5 file specified by `recon_output: 1` in `param.yaml` (e.g., `structures/decoder2_output_residue_z_ref.h5`).
+    * Inside this HDF5, the dataset `reconstructions_with_override` will contain the final generated structures using the diffused per-residue latents.
+    * `reconstructions_no_override` shows reconstructions using the original autoencoder's internally pooled latents.
+
+---
+
+## ✨ Example Usage (Illustrative)
+
+**Step 1: Train Autoencoder & Generate Pooled Latents for Diffusion Training**
+
+```bash
+# Configure param.yaml:
+# - json_path, pdb_filename
+# - pooling_type: "residue"
+# - output_size_per_segment: [1, 3] # Example: each residue pooled to 3 dimensions
+# - save_decoder2_pooled_latent: true
+# - Ensure special_res_file is null or commented out, override_residues is empty.
+# - recon_output: 0 (or any value other than 1 if you only want to generate the pooled latents for diffusion)
+#   (If recon_output=1, it will also do a self-reconstruction pass, ensure save_decoder2_pooled_latent is true)
+
+python chebnet_res.py --config param.yaml
+```
+
+This generates `latent_reps/decoder2_pooled_latent_embeddings.h5` with shape `(N_frames, N_residues, 3)`.
+
+**Step 2: Train Latent Diffusion Model on Per-Residue Embeddings**
+
+```bash
+# Configure param_diff.yaml:
+# - parameters.h5_file_path: "latent_reps/decoder2_pooled_latent_embeddings.h5"
+# - parameters.dataset_key: "pooled_latent"
+# - parameters.selected_residues: [0, 1, 2, ..., N_residues-1] # To train on all residues
+# - parameters.output_dir: "latent_reps/my_residue_diff_run"
+# - parameters.pooling_dim: [N_residues, 3] # N_residues from your protein, 3 from above
+# - parameters.N_out: 50000 # Example: save snapshot every 50k epochs
+
+python new_diff.py --config param_diff.yaml --exp_idx 1
+```
+
+This generates, e.g., `latent_reps/my_residue_diff_run/exp1_epoch_snapshots/epoch_7500000/generated_embeddings.h5` (if num_epochs=7.5M, N_out=50k). Shape: `(N_gen, N_residues, 3)`.
+
+**Step 3: Reconstruct Structures from Diffused Per-Residue Latents**
+
+```bash
+# 1. Modify param.yaml:
+#    decoder2_settings:
+#      ...
+#      special_res_file: "latent_reps/my_residue_diff_run/exp1_epoch_snapshots/epoch_7500000/generated_embeddings.h5"
+#      override_residues: [0, 1, 2, ..., N_residues-1] # Match selected_residues from diffusion
+#      ...
+#    recon_output: 1 # Ensure this is set to trigger export with override
+#
+# 2. Run chebnet_res.py again:
+
+python chebnet_res.py --config param.yaml
+```
+
+This uses the diffused latents specified in param.yaml to generate `structures/decoder2_output_residue_z_ref.h5`, where the `reconstructions_with_override` dataset contains the novel structures.
+
+---
+
+## 🔑 Key Outputs Explained & File Naming
+
+**Autoencoder Checkpoints** (from Stage 1, in `checkpoints/`):
+- `hno_checkpoint.pth`
+- `decoder2_residue.pth` (or `decoder2_residue_2level.pth`)
+
+**Pooled Latents for Diffusion Training** (from Stage 1, in `latent_reps/`):
+- `decoder2_pooled_latent_embeddings.h5`: Contains per-residue pooled latents from the input MD. Shape: `(N_frames, N_residues, pooled_dim_per_residue)`. Dataset key: `pooled_latent`.
+
+**Diffusion Model Outputs** (from Stage 2, in `output_dir` specified in `param_diff.yaml`):
+- If `N_out > 0`: Snapshots are saved in `<output_dir>/<exp_label>_epoch_snapshots/epoch_<E>/`.
+  - `diffusion_checkpoint.pth`: Checkpoint of the diffusion model at epoch `<E>`.
+  - `generated_embeddings.h5`: Diffused per-residue latents from this snapshot. Shape: `(N_gen_samples, N_selected_residues_for_diffusion, pooled_dim_per_residue)`.
+- If `N_out = 0` (or for the final model):
+  - `<output_dir>/checkpoints/diffusion_exp<N>.pth`
+  - `<output_dir>/generated_embeddings_exp<N>.h5`
+- `selected_residues` in `param_diff.yaml`: This list determines which residues' latents (and how many, `N_selected_residues_for_diffusion`) are included in the `generated_embeddings.h5` from the diffusion model. This is critical for Stage 3.
+
+**Final Reconstructed Structures** (from Stage 3, e.g., in `structures/`):
+- `decoder2_output_residue_z_ref.h5` (filename depends on `param.yaml` settings for pooling and conditioner):
+  - `reconstructions_with_override`: Structures generated using the diffused per-residue latents loaded via `special_res_file`.
+  - `reconstructions_no_override`: Structures generated using the autoencoder's internally pooled latents from the input data (for comparison).
+
+---
+
+## 🔧 Customization and Advanced Use
+
+- **`pooling_type: "residue"`**: Must be set in `param.yaml` for this workflow.
+- **`output_size_per_segment`**: Controls the dimension of each per-residue pooled latent vector.
+- **`use_second_level_pooling`**: If `true` in `param.yaml`, an additional pooling layer is applied over all the per-residue latents, resulting in a single global latent vector that is then repeated for each residue before MLP input. This changes the nature of `decoder2_pooled_latent_embeddings.h5` and how diffusion should be approached. The provided `new_diff.py` is designed for per-residue latents or global latents, so ensure consistency. The current example workflow assumes `use_second_level_pooling: false` for per-residue diffusion.
+- **`selected_residues` (in `param_diff.yaml`)**: Allows training the diffusion model on only a subset of residue latents, which can be useful for very large proteins or for focusing on specific dynamic regions. Ensure the `override_residues` list in `param.yaml` for Stage 3 matches these selected indices.
+- **`N_out` in `new_diff.py`**: Useful for saving intermediate snapshots of diffused latents during a long diffusion training run, allowing for evaluation at different training stages.
+
+---
+
+## 📄 Citing this Work
+
+If you use this code or the LD-FPG methodology in your research, please cite our NeurIPS 2025 paper:
+
+[Placeholder for NeurIPS Paper Citation - To be added upon acceptance/publication]
+
+**Title:** Generative Modeling of Full-Atom Protein Conformations using Latent Diffusion on Graph Embeddings  
+**Authors:** [Author One, Author Two, et al.]  
+**Conference:** Advances in Neural Information Processing Systems (NeurIPS) 2025.
+
+---
+
+## 🐛 Troubleshooting
+
+**Dimension Mismatches:**
+- The `pooled_dim_per_residue` (product of `output_size_per_segment` in `param.yaml`) must be consistent with the feature dimension expected by `new_diff.py`.
+- The `generated_embeddings.h5` from `new_diff.py` will have `N_selected_residues` as its second dimension. The `override_residues` list in `param.yaml` for Stage 3 must match these selected residues and their order.
+- The `special_res_file` HDF5 must have an embedding dimension that matches what the `ProteinStateReconstructor2D` expects after its internal pooling (i.e., `pooled_dim_per_segment` if `use_second_level_pooling` is false, or `final_effective_pooled_dim` if true).
+
+**`special_res_file` and `override_residues`**: These must be correctly configured in `param.yaml` for Stage 3 to correctly load and use the diffused latents. Ensure the file path is accurate and the list of residue indices aligns with the content of the HDF5 file from diffusion.
+
+**Log Files**: Check script-specific log files for detailed error messages.
+
+---
+
+## 📜 License
+
+This project is licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).
+
+This means you are free to:
+- **Share** — copy and redistribute the material in any medium or format
+- **Adapt** — remix, transform, and build upon the material for any purpose, even commercially.
+
+Under the following terms:
+- **Attribution** — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+- **No additional restrictions** — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.

LD-FPG-main/residue/chebnet_diff.py

@@ -0,0 +1,1090 @@
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+
+################################################################################
+# Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="All-Atom Protein Reconstruction with Contiguous Indexing & Optional Debug"
+)
+parser.add_argument(
+    "--config", type=str, required=True, help="Path to the YAML configuration file."
+)
+parser.add_argument("--debug", action="store_true", help="Enable debug-level logging.")
+parser.add_argument(
+    "--log_file", type=str, default="logfile.log", help="Path to the log file."
+)
+# MODIFIED: Replaced --exp_index with more descriptive arguments
+parser.add_argument(
+    "--exp_label", type=str, required=True, help="Experiment label (e.g., 'exp1')."
+)
+parser.add_argument(
+    "--embedding_base_folder",
+    type=str,
+    required=True,
+    help="Base folder for embeddings within latent_reps (e.g., 'exp1_epoch_snapshots').",
+)
+parser.add_argument(
+    "--epoch_folder",
+    type=str,
+    required=True,
+    help="Specific epoch folder containing generated_embeddings.h5 (e.g., 'epoch_10000').",
+)
+args = parser.parse_args()
+
+################################################################################
+# Logging Setup
+################################################################################
+logger = logging.getLogger(f"ProteinReconstruction_{args.exp_label}_{args.epoch_folder}") # Make logger name more specific
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+# Use a log file name that reflects the specific run
+log_file_name = f"logfile_{args.exp_label}_{args.embedding_base_folder.replace('/', '_')}_{args.epoch_folder}.log"
+fh = logging.FileHandler(log_file_name, mode="w") # Changed from args.log_file
+fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+ch = logging.StreamHandler(sys.stdout)
+ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+formatter = logging.Formatter(
+    f"[%(levelname)s] %(asctime)s - %(name)s - [{args.exp_label}][{args.epoch_folder}] %(message)s"
+)
+fh.setFormatter(formatter)
+ch.setFormatter(formatter)
+
+logger.addHandler(fh)
+logger.addHandler(ch)
+
+logger.info(f"Logger initialized for {args.exp_label}/{args.embedding_base_folder}/{args.epoch_folder}. Log file: {log_file_name}")
+if args.debug:
+    logger.debug("Debug mode is ON.")
+else:
+    logger.info("Debug mode is OFF; minimal logs will be shown.")
+
+################################################################################
+# Load YAML Configuration
+################################################################################
+def load_config(config_path):
+    with open(config_path, "r") as f:
+        conf = yaml.safe_load(f)
+    return conf
+
+try:
+    config = load_config(args.config)
+    logger.info(f"Loaded configuration from {args.config}")
+except Exception as e:
+    logger.error(f"Error loading config: {e}")
+    sys.exit(1)
+
+# Extract main parameters
+json_path = config["json_path"]
+knn_value = config["knn_value"]
+cheb_order = config["cheb_order"]
+hidden_dim = config["hidden_dim"]
+recon_output = config["recon_output"]
+
+# Decoder 1 (HNO) parameters
+decoder1_lr = config["decoder1"]["learning_rate"]
+decoder1_epochs = config["decoder1"]["num_epochs"]
+decoder1_bsize = config["decoder1"]["batch_size"]
+
+# Decoder 2 parameters
+decoder2_lr = config["decoder2"]["learning_rate"]
+decoder2_epochs = config["decoder2"]["num_epochs"]
+decoder2_bsize = config["decoder2"]["batch_size"]
+
+# Decoder 2 settings
+d2_output_height = config["decoder2_settings"]["output_height"]
+d2_output_width = config["decoder2_settings"]["output_width"]
+d2_pooling_type = config["decoder2_settings"]["pooling_type"]
+d2_weight_value = config["decoder2_settings"]["weight_value"]
+d2_output_height2 = config["decoder2_settings"].get("output_height2", None)
+d2_output_width2 = config["decoder2_settings"].get("output_width2", None)
+
+use_second_level_pooling = config["decoder2_settings"].get(
+    "use_second_level_pooling", False
+)
+use_cross_attention = config["decoder2_settings"].get("use_cross_attention", False)
+cross_attention_type = config["decoder2_settings"].get(
+    "cross_attention_type", "global"
+)
+conditioner_mode = config["decoder2_settings"].get(
+    "conditioner_mode", "X_ref"
+)
+d2_num_hidden_layers = config["decoder2_settings"].get(
+    "num_hidden_layers", 2
+)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+logger.info(f"Using device: {device}")
+
+################################################################################
+# Directory Setup
+################################################################################
+current_dir = os.getcwd()
+checkpoint_dir = os.path.join(current_dir, "checkpoints")
+latent_reps_dir = os.path.join(current_dir, "latent_reps") # Base for input embeddings
+structures_dir = os.path.join(current_dir, "structures") # For other general structures like X_ref
+
+os.makedirs(checkpoint_dir, exist_ok=True)
+os.makedirs(latent_reps_dir, exist_ok=True) # Ensured by data prep
+os.makedirs(structures_dir, exist_ok=True)
+
+logger.debug(
+    f"Directories:\n  checkpoints: {checkpoint_dir}\n  latent_reps_base: {latent_reps_dir}\n  structures_general: {structures_dir}"
+)
+
+################################################################################
+# Utility Functions
+################################################################################
+def save_checkpoint(state, filename):
+    torch.save(state, filename)
+    logger.debug(f"Checkpoint saved to {filename}")
+    sys.stdout.flush()
+
+def load_checkpoint(model, optimizer, filename):
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint from '{filename}'")
+        sys.stdout.flush()
+        checkpoint = torch.load(filename, map_location=device)
+        start_epoch = checkpoint["epoch"]
+        model.load_state_dict(checkpoint["model_state_dict"])
+        optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+        logger.info(f"Loaded checkpoint at epoch {start_epoch}")
+        sys.stdout.flush()
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Training from scratch.")
+        sys.stdout.flush()
+    return model, optimizer, start_epoch
+
+def compute_centroid(X):
+    return X.mean(dim=0)
+
+def kabsch_algorithm(P, Q):
+    centroid_P = compute_centroid(P)
+    centroid_Q = compute_centroid(Q)
+    P_centered = P - centroid_P
+    Q_centered = Q - centroid_Q
+
+    C = torch.mm(Q_centered.T, P_centered)
+    V, S, W = torch.svd(C)
+
+    d = torch.det(torch.mm(V, W.T))
+    if d < 0:
+        V[:, -1] = -V[:, -1]
+
+    U = torch.mm(V, W.T)
+    Q_aligned = torch.mm(Q_centered, U) + centroid_P
+    return U, Q_aligned
+
+################################################################################
+# Reindexing Residue Indices
+################################################################################
+def remap_residue_indices(residue_atom_indices):
+    flattened = [atom for residue in residue_atom_indices for atom in residue]
+    unique_atoms = sorted(set(flattened))
+    logger.debug(
+        f"Unique atoms found: {len(unique_atoms)}. "
+        f"Max original ID = {max(unique_atoms)}, Min = {min(unique_atoms)}"
+    )
+    sys.stdout.flush()
+    old2new_map = {old_id: idx for idx, old_id in enumerate(unique_atoms)}
+    first_few_items = list(old2new_map.items())[:20]
+    logger.debug(f"[old2new_map sample] -> {first_few_items}")
+    sys.stdout.flush()
+    new_residue_indices = []
+    for residue in residue_atom_indices:
+        new_list = [old2new_map[a] for a in residue]
+        new_residue_indices.append(new_list)
+    return new_residue_indices, old2new_map
+
+################################################################################
+# Data Loading & Alignment
+################################################################################
+def load_heavy_atom_coords_from_json(json_file):
+    logger.info(f"Loading JSON from {json_file}")
+    sys.stdout.flush()
+    with open(json_file, "r") as f:
+        data = json.load(f)
+    residue_keys_sorted = sorted(data.keys(), key=lambda x: int(x))
+    logger.debug(f"Number of residues in JSON: {len(residue_keys_sorted)}")
+    sys.stdout.flush()
+    num_frames = len(data[residue_keys_sorted[0]]["heavy_atom_coords_per_frame"])
+    logger.info(f"Number of frames = {num_frames}")
+    sys.stdout.flush()
+    original_residue_atom_indices = []
+    for res_key in residue_keys_sorted:
+        idx_list = data[res_key]["heavy_atom_indices"]
+        original_residue_atom_indices.append(idx_list)
+    coords_per_frame = []
+    for frame_idx in range(num_frames):
+        frame_coords_list = []
+        for res_key in residue_keys_sorted:
+            coords_this_res = data[res_key]["heavy_atom_coords_per_frame"][frame_idx]
+            frame_coords_list.append(np.array(coords_this_res, dtype=np.float32))
+        frame_coords = np.concatenate(frame_coords_list, axis=0)
+        coords_per_frame.append(torch.tensor(frame_coords, dtype=torch.float32))
+    return coords_per_frame, original_residue_atom_indices
+
+def align_frames_to_first(coords_list):
+    logger.info("Aligning all frames to the first frame via Kabsch...")
+    sys.stdout.flush()
+    reference = coords_list[0]
+    aligned = []
+    for i, coords in enumerate(coords_list):
+        if i == 0:
+            aligned.append(coords)
+            logger.debug(f"Frame {i}: No alignment needed. shape={coords.shape}")
+            sys.stdout.flush()
+        else:
+            _, coords_aligned = kabsch_algorithm(reference, coords)
+            aligned.append(coords_aligned)
+            if i < 5: # Log only a few for brevity
+                logger.debug(f"Frame {i}: aligned shape={coords_aligned.shape}")
+                sys.stdout.flush()
+    return aligned
+
+################################################################################
+# Build Graph Dataset
+################################################################################
+def build_graph_dataset(coords_list, knn_neighbors=4):
+    logger.info("Building PyG dataset with knn_graph.")
+    sys.stdout.flush()
+    dataset = []
+    for idx, coords in enumerate(coords_list):
+        edge_index = knn_graph(coords, k=knn_neighbors, batch=None, loop=False)
+        data = Data(x=coords, edge_index=edge_index, y=coords)
+        dataset.append(data)
+        if idx < 5:
+            logger.debug(
+                f"[Dataset] Frame {idx}: x.shape={coords.shape}, edge_index.shape={edge_index.shape}"
+            )
+            sys.stdout.flush()
+    return dataset
+
+################################################################################
+# HNO Model
+################################################################################
+class HNO(nn.Module):
+    _logged_forward_once = False
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        logger.debug(f"Initializing HNO with hidden_dim={hidden_dim}, K={K}")
+        sys.stdout.flush()
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.mlpRep = nn.Linear(hidden_dim, 3)
+
+    def forward(self, x, edge_index):
+        if (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] Input x.shape={x.shape}")
+            sys.stdout.flush()
+        x = self.conv1(x, edge_index)
+        if (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] After conv1 => {x.shape}")
+            sys.stdout.flush()
+        x = F.leaky_relu(x)
+        x = self.bano1(x)
+        x = self.conv2(x, edge_index)
+        x = F.leaky_relu(x)
+        x = self.bano2(x)
+        x = self.conv3(x, edge_index)
+        x = F.relu(x)
+        x = self.bano3(x)
+        x = self.conv4(x, edge_index)
+        x = F.normalize(x, p=2, dim=1)
+        if (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] After conv4 => {x.shape}")
+            sys.stdout.flush()
+        x_rep = x # Save representation before mlpRep
+        x = self.mlpRep(x)
+        if (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] Output => {x.shape}")
+            HNO._logged_forward_once = True
+            sys.stdout.flush()
+        return x
+
+    def forward_representation(self, x, edge_index):
+        x = self.conv1(x, edge_index)
+        x = F.leaky_relu(x)
+        x = self.bano1(x)
+        x = self.conv2(x, edge_index)
+        x = F.leaky_relu(x)
+        x = self.bano2(x)
+        x = self.conv3(x, edge_index)
+        x = F.relu(x)
+        x = self.bano3(x)
+        x = self.conv4(x, edge_index)
+        x = F.normalize(x, p=2, dim=1)
+        return x
+
+################################################################################
+# Train HNO
+################################################################################
+def train_hno_model(
+    model,
+    train_loader,
+    test_loader,
+    num_epochs,
+    learning_rate,
+    checkpoint_path, # MODIFIED: Path now includes exp_label
+    save_interval=10,
+):
+    model = model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    criterion = nn.MSELoss()
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path)
+    logger.info(
+        f"Starting HNO ({args.exp_label}) from epoch={start_epoch}, total epochs={num_epochs}, LR={learning_rate}"
+    )
+    sys.stdout.flush()
+    for epoch in range(start_epoch, num_epochs):
+        model.train()
+        total_loss = 0
+        for data in train_loader:
+            data = data.to(device)
+            optimizer.zero_grad()
+            pred = model(data.x, data.edge_index)
+            loss = criterion(pred, data.x) # Reconstruct original coordinates
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        avg_loss = total_loss / len(train_loader)
+        model.eval()
+        test_loss = 0
+        with torch.no_grad():
+            for data in test_loader:
+                data = data.to(device)
+                pred = model(data.x, data.edge_index)
+                val_loss = criterion(pred, data.x)
+                test_loss += val_loss.item()
+        avg_test_loss = test_loss / len(test_loader)
+        logger.info(
+            f"[HNO {args.exp_label}] Epoch {epoch+1}/{num_epochs} => Train Loss={avg_loss:.6f}, Test Loss={avg_test_loss:.6f}"
+        )
+        sys.stdout.flush()
+        if (epoch + 1) % save_interval == 0:
+            checkpoint_state = {
+                "epoch": epoch + 1,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+            }
+            save_checkpoint(checkpoint_state, checkpoint_path)
+            logger.info(f"HNO checkpoint for {args.exp_label} saved at epoch {epoch+1} -> {checkpoint_path}")
+            sys.stdout.flush()
+
+################################################################################
+# Simple Cross-Attention Module (definition remains, usage depends on config)
+################################################################################
+class CrossAttentionBlock(nn.Module):
+    def __init__(self, query_dim, kv_dim, attention_dim=64):
+        super().__init__()
+        self.query_layer = nn.Linear(query_dim, attention_dim, bias=False)
+        self.key_layer = nn.Linear(kv_dim, attention_dim, bias=False)
+        self.value_layer = nn.Linear(kv_dim, attention_dim, bias=False)
+        self.scale = attention_dim**-0.5
+    def forward(self, query, key, value):
+        original_shape = query.shape
+        if query.dim() == 3:
+            B, N_seg, q_dim = query.shape
+            query = query.view(B * N_seg, q_dim)
+        else:
+            B, q_dim = query.shape
+            N_seg = 1
+        B_kv, num_kv, kv_d = key.shape
+        Q = self.query_layer(query).unsqueeze(1)
+        K = self.key_layer(key)
+        V = self.value_layer(value)
+        scores = (torch.matmul(Q, K.transpose(-1, -2)) * self.scale)
+        attn = F.softmax(scores, dim=-1)
+        out = torch.matmul(attn, V)
+        out = out.squeeze(1)
+        if N_seg > 1:
+            out = out.view(B, N_seg, -1)
+        return out
+
+################################################################################
+# MLP Builder for Decoder2 (remains the same)
+################################################################################
+def build_decoder_mlp(input_dim, output_dim, num_hidden_layers, hidden_dim=128):
+    # ... (no changes needed in this function)
+    layers = []
+    current_dim = input_dim
+    for i in range(num_hidden_layers - 1):
+        layers.append(nn.Linear(current_dim, hidden_dim))
+        layers.append(nn.ReLU())
+        layers.append(nn.BatchNorm1d(hidden_dim))
+        current_dim = hidden_dim
+    layers.append(nn.Linear(current_dim, output_dim))
+    return nn.Sequential(*layers)
+
+################################################################################
+# ProteinStateReconstructor2D
+################################################################################
+class ProteinStateReconstructor2D(nn.Module):
+    _logged_forward_once = False
+    def __init__(
+        self,
+        input_dim,
+        num_nodes,
+        pooling_type="blind",
+        residue_atom_indices=None,
+        output_size_per_segment=(1, 10),
+        second_level_output_size=None,
+        use_second_level_pooling=False,
+        use_cross_attention=False,
+        cross_attention_type=None,
+        conditioner_mode="z_ref",
+        num_hidden_layers=2,
+        override_residues=None,
+        special_res_file=None, # This will be the full path to generated_embedding.h5
+    ):
+        super().__init__()
+        self.pooling_type = pooling_type
+        self.num_nodes = num_nodes
+        self.input_dim = input_dim # Dim of HNO latent
+        self.conditioner_mode = conditioner_mode # How conditioner is formed (X_ref or z_ref)
+        self.use_second_level_pooling = use_second_level_pooling
+        self.output_size_per_segment = output_size_per_segment
+        self.second_level_output_size = second_level_output_size
+
+        self.override_residues = (
+            override_residues if override_residues is not None else []
+        )
+        self.generated_arr = None
+
+        if special_res_file is not None and os.path.isfile(special_res_file) and len(self.override_residues) > 0 :
+            logger.info(f"Attempting to load override embeddings from: {special_res_file}")
+            try:
+                with h5py.File(special_res_file, "r") as f:
+                    # Assuming the dataset inside HDF5 is named 'generated_embeddings' or 'data'
+                    # Check for common names if 'generated_embeddings' isn't found
+                    if "generated_embeddings" in f:
+                        arr = f["generated_embeddings"][:]
+                    elif "data" in f: # Common alternative
+                         arr = f["data"][:]
+                    else:
+                        logger.error(f"Cannot find 'generated_embeddings' or 'data' dataset in {special_res_file}")
+                        arr = None
+                
+                if arr is not None:
+                    if np.isnan(arr).any():
+                        logger.error(f"Generated override embeddings from {special_res_file} contain NaN values!")
+                        self.generated_arr = None
+                    else:
+                        logger.info(
+                            f"Generated embeddings loaded from {special_res_file} with shape {arr.shape} and appear valid."
+                        )
+                        self.generated_arr = arr
+                        if self.generated_arr.shape[1] != len(self.override_residues): # M should be num_override_residues
+                             # This check might be too strict if the H5 file stores more than needed.
+                             # For now, let's assume it stores exactly M columns for M override residues.
+                            logger.warning(
+                                f"Shape Mismatch: special_res_file {special_res_file} has {self.generated_arr.shape[1]} residue embeddings, "
+                                f"but override_residues has length {len(self.override_residues)}. Using available."
+                            )
+                            # Potentially adjust or error out here based on exact requirements.
+                            # If the H5 file contains embeddings for ALL residues, and override_residues is a subset,
+                            # then we need to select the correct columns.
+                            # Current code assumes H5 file has shape (N_samples, N_override_residues, embed_dim)
+            except Exception as e:
+                logger.error(f"Error loading or processing {special_res_file}: {e}")
+                self.generated_arr = None
+        elif special_res_file:
+             logger.warning(f"Special residue file specified but not found or no override residues: {special_res_file}")
+
+
+        if pooling_type == "blind":
+            # ... (no changes needed in pooling logic itself)
+            self.segments_indices = [list(range(num_nodes))]
+            self.segment_pools = nn.ModuleList(
+                [nn.AdaptiveAvgPool2d(self.output_size_per_segment)]
+            )
+            seg_pooled_size = (
+                self.output_size_per_segment[0] * self.output_size_per_segment[1]
+            )
+            self.pooled_dim = seg_pooled_size
+            self.global_pool2 = None
+
+        elif pooling_type == "residue":
+            # ... (no changes needed in pooling logic itself)
+            if residue_atom_indices is None:
+                raise ValueError("residue_atom_indices is required for residue-level pooling.")
+            self.segments_indices = residue_atom_indices
+            self.segment_pools = nn.ModuleList()
+            for _ in self.segments_indices:
+                pool = nn.AdaptiveAvgPool2d(self.output_size_per_segment)
+                self.segment_pools.append(pool)
+            if use_second_level_pooling and second_level_output_size is not None:
+                self.global_pool2 = nn.AdaptiveAvgPool2d(second_level_output_size)
+                final_pooled_size = (
+                    second_level_output_size[0] * second_level_output_size[1]
+                )
+                self.pooled_dim = final_pooled_size
+            else:
+                self.global_pool2 = None
+                self.pooled_dim = (
+                    self.output_size_per_segment[0] * self.output_size_per_segment[1]
+                )
+        else:
+            raise ValueError(f"Unknown pooling_type={pooling_type}")
+
+        cond_dim = self.input_dim if conditioner_mode == "z_ref" else 3 # 3 for X_ref
+        self.final_in_dim = self.pooled_dim + cond_dim
+
+        self.decoder = self._build_decoder_mlp(
+            input_dim=self.final_in_dim,
+            output_dim=3,
+            num_hidden_layers=num_hidden_layers,
+            hidden_dim=128, # This hidden_dim is for the MLP, not the HNO's hidden_dim
+        )
+
+    def _build_decoder_mlp(
+        self, input_dim, output_dim, num_hidden_layers, hidden_dim=128
+    ):
+        # ... (no changes needed here)
+        layers = []
+        current_dim = input_dim
+        for i in range(num_hidden_layers - 1):
+            layers.append(nn.Linear(current_dim, hidden_dim))
+            layers.append(nn.ReLU())
+            layers.append(nn.BatchNorm1d(hidden_dim)) # Make sure this is appropriate if batch_size can be 1
+            current_dim = hidden_dim
+        layers.append(nn.Linear(current_dim, output_dim))
+        return nn.Sequential(*layers)
+
+
+    def get_pooled_latent(self, x, conditioner=None): # x is [B*N_nodes, input_dim]
+        # ... (no changes needed in this function's core logic)
+        B_times_N, _ = x.shape # in_dim is self.input_dim (HNO latent dim)
+        batch_size = B_times_N // self.num_nodes
+        x = x.view(batch_size, self.num_nodes, -1) # [B, N_nodes, self.input_dim]
+
+        if self.pooling_type == "blind":
+            seg_x = x.unsqueeze(1)  # [B,1,N_nodes,in_dim]
+            p_2d = self.segment_pools[0](seg_x)  # [B,1,H,W] , H*W should be self.pooled_dim
+            pooled_flat = p_2d.squeeze(1).view(batch_size, -1) # [B, self.pooled_dim]
+            pooled_latent = pooled_flat.unsqueeze(1)  # [B,1,pooled_dim]
+        else: # residue pooling
+            pooled_segments_level1 = []
+            for i, seg_indices in enumerate(self.segments_indices):
+                seg_x = x[:, seg_indices, :].unsqueeze(1) # [B, 1, N_atoms_in_res, self.input_dim]
+                p_2d = self.segment_pools[i](seg_x) # [B, 1, H, W]
+                p_2d = p_2d.squeeze(1).view(batch_size, -1) # [B, self.output_size_per_segment[0]*self.output_size_per_segment[1]]
+                pooled_segments_level1.append(p_2d)
+            
+            level1_concat = torch.stack(pooled_segments_level1, dim=1)  # [B,R,pooled_dim_per_segment]
+            
+            if self.global_pool2 is not None:
+                level1_concat_4d = level1_concat.unsqueeze(1) # [B,1,R,pooled_dim_per_segment]
+                # global_pool2 expects input_channel = 1, H = R, W = pooled_dim_per_segment
+                # output_size is self.second_level_output_size
+                # So the result should be [B, 1, H2, W2]
+                pooled_2d = self.global_pool2(level1_concat_4d) 
+                pooled_2d = pooled_2d.squeeze(1).view(batch_size, -1) # [B, self.pooled_dim] (where pooled_dim is H2*W2)
+                N_seg = len(self.segments_indices)
+                pooled_latent = pooled_2d.unsqueeze(1).repeat(1, N_seg, 1) # [B,R,self.pooled_dim]
+            else:
+                pooled_latent = level1_concat # [B,R,pooled_dim_per_segment] where pooled_dim_per_segment = self.pooled_dim
+        return pooled_latent
+
+
+    def forward(self, x, batch, conditioner, use_override=True):
+        # x: [B*N_nodes, input_dim from HNO]
+        # conditioner: [num_nodes, conditioner_dim (input_dim from HNO if z_ref, or 3 if X_ref)]
+        device = x.device
+        B_times_N, _ = x.shape
+        batch_size = B_times_N // self.num_nodes
+        if batch_size * self.num_nodes != B_times_N:
+            raise ValueError("Mismatch in x.shape vs. num_nodes & batch_size")
+
+        x_latent_hno = x.view(batch_size, self.num_nodes, -1) # [B, N_nodes, self.input_dim]
+
+        conditioner = conditioner.unsqueeze(0).to(device) # [1, N_nodes, cond_dim]
+        conditioner = conditioner.repeat(batch_size, 1, 1) # [B, N_nodes, cond_dim]
+
+        # 1) Get pooled latent from x_latent_hno
+        # This will be [B, R, self.pooled_dim] for residue pooling (R=num_residues)
+        # or [B, 1, self.pooled_dim] for blind pooling
+        pooled_latent = self.get_pooled_latent(x, conditioner) # Pass original x [B*N, C]
+
+        # 2) Override mechanism
+        if (
+            use_override
+            and self.generated_arr is not None
+            and len(self.override_residues) > 0
+            and self.pooling_type == "residue" # Override makes most sense for residue-level pooling
+        ):
+            # self.generated_arr is (N_samples_in_H5, M_override_residues, H5_embedding_dim)
+            # H5_embedding_dim should match self.pooled_dim
+            # N_samples_in_H5 could be 1 if it's a single set of overrides, or >= batch_size
+            
+            num_samples_in_h5, num_override_res_in_h5, h5_embed_dim = self.generated_arr.shape
+            
+            if h5_embed_dim != pooled_latent.shape[-1]:
+                logger.error(f"Override H5 embed dim ({h5_embed_dim}) != model pooled_dim ({pooled_latent.shape[-1]}). Skipping override.")
+            else:
+                # Select samples for the current batch
+                if num_samples_in_h5 == 1: # Use the same override for all batch items
+                    arr_slice = self.generated_arr[0] # [M_override_residues, h5_embed_dim]
+                    arr_tensor = torch.from_numpy(arr_slice).to(device).unsqueeze(0).repeat(batch_size, 1, 1) # [B, M, pooled_dim]
+                elif num_samples_in_h5 >= batch_size: # Use distinct overrides per batch item
+                    arr_slice = self.generated_arr[:batch_size] # [B, M_override_residues, h5_embed_dim]
+                    arr_tensor = torch.from_numpy(arr_slice).to(device) # [B, M, pooled_dim]
+                else: # Not enough samples in H5 for the batch
+                    logger.warning(f"Batch size ({batch_size}) > num_samples_in_H5 ({num_samples_in_h5}). Using first H5 sample for all. ")
+                    arr_slice = self.generated_arr[0]
+                    arr_tensor = torch.from_numpy(arr_slice).to(device).unsqueeze(0).repeat(batch_size, 1, 1)
+                
+                # Apply override
+                # pooled_latent is [B, R, pooled_dim]
+                # arr_tensor is [B, M_override_residues, pooled_dim]
+                # self.override_residues is a list of R indices to be replaced by M entries from arr_tensor
+                # This assumes len(self.override_residues) == M_override_residues
+                if arr_tensor.shape[1] == len(self.override_residues):
+                    for i, r_idx_to_override in enumerate(self.override_residues):
+                        if r_idx_to_override < pooled_latent.shape[1]: # ensure r_idx is valid
+                            pooled_latent[:, r_idx_to_override, :] = arr_tensor[:, i, :]
+                        else:
+                            logger.error(f"Override residue index {r_idx_to_override} out of bounds for pooled_latent shape {pooled_latent.shape[1]}")
+                else:
+                    logger.warning(f"Mismatch between override_residues list ({len(self.override_residues)}) and H5 override dim ({arr_tensor.shape[1]}). Skipping override.")
+
+        # 3) Combine with conditioner and pass to MLP decoder
+        # pooled_latent: [B, R_or_1, pooled_dim]
+        # conditioner:   [B, N_nodes, cond_dim]
+        # segments_indices: List of lists of atom indices per residue (or one list for all atoms if blind)
+        
+        node_inputs_for_mlp = []
+        num_segments_in_pool = pooled_latent.shape[1] # R if residue-pooled, 1 if blind-pooled
+
+        if self.pooling_type == "blind": # pooled_latent is [B, 1, pooled_dim]
+            # We need to combine this single pooled vector with each node's conditioner
+            seg_pooled_expanded = pooled_latent.repeat(1, self.num_nodes, 1) # [B, N_nodes, pooled_dim]
+            combined_for_mlp = torch.cat([seg_pooled_expanded, conditioner], dim=-1) # [B, N_nodes, pooled_dim + cond_dim]
+            node_inputs_for_mlp.append(combined_for_mlp)
+        else: # residue pooling, pooled_latent is [B, R, pooled_dim]
+            for res_idx, atom_indices_in_res in enumerate(self.segments_indices):
+                # Get the pooled vector for this specific residue
+                res_pooled = pooled_latent[:, res_idx, :]  # [B, pooled_dim]
+                
+                # Expand it to match the number of atoms in this residue
+                res_pooled_expanded = res_pooled.unsqueeze(1).repeat(1, len(atom_indices_in_res), 1) # [B, N_atoms_in_res, pooled_dim]
+                
+                # Get the conditioner part for atoms in this residue
+                cond_part_for_res = conditioner[:, atom_indices_in_res, :] # [B, N_atoms_in_res, cond_dim]
+                
+                combined_res_mlp_input = torch.cat([res_pooled_expanded, cond_part_for_res], dim=-1) # [B, N_atoms_in_res, final_in_dim]
+                node_inputs_for_mlp.append(combined_res_mlp_input)
+
+        final_mlp_input_structured = torch.cat(node_inputs_for_mlp, dim=1) # [B, N_nodes, final_in_dim]
+        final_mlp_input_flat = final_mlp_input_structured.view(batch_size * self.num_nodes, -1) # [B*N_nodes, final_in_dim]
+        
+        X_pred = self.decoder(final_mlp_input_flat) # [B*N_nodes, 3]
+
+        if (not ProteinStateReconstructor2D._logged_forward_once) and (
+            logger.isEnabledFor(logging.DEBUG)
+        ):
+            logger.debug(f"[Decoder2:forward ({args.exp_label}/{args.epoch_folder})] X_pred => {X_pred.shape}")
+            ProteinStateReconstructor2D._logged_forward_once = True
+        return X_pred
+
+    def forward_representation(self, x, batch, conditioner):
+        raise NotImplementedError("forward_representation not implemented in ProteinStateReconstructor2D.")
+
+
+################################################################################
+# Train Decoder2
+################################################################################
+def train_protein_state_reconstructor(
+    model,
+    train_loader,
+    test_loader,
+    num_epochs,
+    learning_rate,
+    checkpoint_path, # MODIFIED: Path now includes exp_label
+    conditioner_data,
+    save_interval=10,
+    weight_value=1.0, # Not used in current loss, but kept for signature
+):
+    model = model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    criterion = nn.MSELoss()
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path)
+    logger.info(
+        f"Starting Decoder2 ({args.exp_label}/{args.epoch_folder}) from epoch={start_epoch}, total epochs={num_epochs}, LR={learning_rate}"
+    )
+    sys.stdout.flush()
+    for epoch in range(start_epoch, num_epochs):
+        model.train()
+        total_loss = 0
+        for data in train_loader: # data.x is HNO latent, data.coords is target
+            data = data.to(device)
+            optimizer.zero_grad()
+            X_pred = model(data.x, data.batch, conditioner_data)
+            coords_gt = data.coords
+            loss = criterion(X_pred, coords_gt)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        avg_loss = total_loss / len(train_loader)
+        model.eval()
+        test_loss = 0
+        with torch.no_grad():
+            for data in test_loader:
+                data = data.to(device)
+                X_pred = model(data.x, data.batch, conditioner_data)
+                coords_gt = data.coords
+                val_loss = criterion(X_pred, coords_gt)
+                test_loss += val_loss.item()
+        avg_test_loss = test_loss / len(test_loader)
+        logger.info(
+            f"[Decoder2 {args.exp_label}/{args.epoch_folder}] Epoch {epoch+1}/{num_epochs} => Train Loss={avg_loss:.6f}, Test Loss={avg_test_loss:.6f}"
+        )
+        sys.stdout.flush()
+        if (epoch + 1) % save_interval == 0:
+            checkpoint_state = {
+                "epoch": epoch + 1,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+            }
+            save_checkpoint(checkpoint_state, checkpoint_path)
+            logger.info(
+                f"Decoder2 checkpoint for {args.exp_label}/{args.epoch_folder} saved at epoch {epoch+1} -> {checkpoint_path}"
+            )
+            sys.stdout.flush()
+
+################################################################################
+# Main Execution
+################################################################################
+if __name__ == "__main__":
+    logger.info(f"Starting main script execution for {args.exp_label}/{args.embedding_base_folder}/{args.epoch_folder}...")
+    sys.stdout.flush()
+
+    coords_per_frame, original_residue_atom_indices = load_heavy_atom_coords_from_json(
+        json_path
+    )
+    logger.info("Remapping residue_atom_indices to contiguous IDs...")
+    sys.stdout.flush()
+    new_residue_indices, old2new_map = remap_residue_indices(
+        original_residue_atom_indices
+    )
+    num_unique_atoms = len(old2new_map)
+    logger.info(f"Number of unique atoms after reindexing: {num_unique_atoms}")
+    sys.stdout.flush()
+    aligned_frames = align_frames_to_first(coords_per_frame)
+    dataset = build_graph_dataset(aligned_frames, knn_neighbors=knn_value)
+    first_data = dataset[0]
+    # print("Atom Indices Mapping (old -> new):", list(old2new_map.items())[:5]) # Redundant with logger
+    # print("First 5 atoms in data.x:", first_data.x[:5]) # Redundant
+    logger.info(f"Dataset size: {len(dataset)} frames.")
+    sys.stdout.flush()
+
+    train_dataset_hno, test_dataset_hno = train_test_split(
+        dataset, test_size=0.1, random_state=42
+    )
+    train_loader_hno = DataLoader(
+        train_dataset_hno, batch_size=decoder1_bsize, shuffle=False # Shuffle True for training usually
+    )
+    test_loader_hno = DataLoader(
+        test_dataset_hno, batch_size=decoder1_bsize, shuffle=False
+    )
+
+    hno_model = HNO(hidden_dim, cheb_order)
+    # MODIFIED: HNO checkpoint path now includes exp_label
+    hno_ckpt_path = os.path.join(checkpoint_dir, f"hno_checkpoint.pth")
+    logger.info(
+        f"Training HNO ({args.exp_label}) => epochs={decoder1_epochs}, LR={decoder1_lr}, bsize={decoder1_bsize}"
+    )
+    sys.stdout.flush()
+    train_hno_model(
+        hno_model,
+        train_loader_hno,
+        test_loader_hno,
+        num_epochs=decoder1_epochs,
+        learning_rate=decoder1_lr,
+        checkpoint_path=hno_ckpt_path,
+        save_interval=10,
+    )
+
+    if recon_output == 2: # HNO reconstructions
+        logger.info(
+            f"Generating HNO reconstructions & latent embeddings for {args.exp_label}..."
+        )
+        sys.stdout.flush()
+        hno_model.eval()
+        # MODIFIED: HNO output paths include exp_label
+        hno_recon_path = os.path.join(structures_dir, f"hno_reconstructed_coords_{args.exp_label}.h5")
+        hno_latent_path = os.path.join(latent_reps_dir, f"hno_latent_embeddings_{args.exp_label}.h5") # Stays in latent_reps_dir base
+        
+        # This should use the full dataset or a consistent subset, not just train_dataset_hno
+        # For consistency, let's use the 'dataset' (all frames) for HNO output generation
+        num_samples_hno_output = len(dataset) 
+        logger.info(f"Number of samples to process for HNO output ({args.exp_label}): {num_samples_hno_output}")
+
+        pooled_dim_hno = hidden_dim
+        with h5py.File(hno_recon_path, "w") as recon_h5, h5py.File(hno_latent_path, "w") as latent_h5:
+            recon_dset_hno = recon_h5.create_dataset(
+                "reconstructions",
+                shape=(num_samples_hno_output, num_unique_atoms, 3),
+                dtype="float32",
+            )
+            latent_dset_hno = latent_h5.create_dataset(
+                "pooled_latent", # This is per-atom latent from HNO before MLP
+                shape=(num_samples_hno_output, num_unique_atoms, pooled_dim_hno),
+                dtype="float32",
+            )
+            logger.debug(
+                f"HDF5 datasets for HNO ({args.exp_label}) created:\n recon={recon_dset_hno.shape}, latent={latent_dset_hno.shape}"
+            )
+            with torch.no_grad():
+                for idx, data_item in enumerate(dataset): # Iterate over the whole dataset for generation
+                    data_item = data_item.to(device)
+                    latent = hno_model.forward_representation(data_item.x, data_item.edge_index)
+                    reconstruction = hno_model(data_item.x, data_item.edge_index) # This is direct reconstruction
+                    
+                    # Storing original coordinates as 'reconstruction' if we want to compare to HNO's attempt
+                    # Or store HNO's attempt. The current code stores data.x (original) in recon_dset_hno.
+                    # This seems like a bug in original. It should be the `reconstruction`.
+                    # Let's fix it to store the actual HNO reconstruction.
+                    recon_dset_hno[idx, :, :] = reconstruction.cpu().numpy() # Fixed
+                    latent_dset_hno[idx, :, :] = latent.cpu().numpy()
+
+                    if args.debug and idx < 1:
+                        logger.debug(
+                            f"[HNO:Generation {args.exp_label}] Sample {idx}: recon_np.shape={reconstruction.cpu().numpy().shape}, latent_np.shape={latent.cpu().numpy().shape}"
+                        )
+                    if args.debug and (idx + 1) % 1000 == 0:
+                        logger.debug(
+                            f"[HNO:Generation {args.exp_label}] Processed {idx + 1}/{num_samples_hno_output} samples."
+                        )
+            logger.info(f"HNO outputs for {args.exp_label} saved to {hno_recon_path} and {hno_latent_path}")
+
+
+    logger.info(f"Preparing dataset for Decoder2 ({args.exp_label}/{args.epoch_folder}) using HNO latent embeddings...")
+    sys.stdout.flush()
+    decoder2_dataset = []
+    hno_model.eval()
+    with torch.no_grad():
+        for data_item in dataset: # Use the full dataset
+            data_cpu = data_item.cpu()
+            latent = hno_model.forward_representation(
+                data_cpu.x.to(device), data_cpu.edge_index.to(device)
+            )
+            d = Data(
+                x=latent.cpu(), # Input to Decoder2 is HNO latent
+                edge_index=data_cpu.edge_index, # Not strictly used by Decoder2 but good to keep
+                coords=data_cpu.y, # Target for Decoder2 is original coordinates
+                batch=data_cpu.batch,
+            )
+            decoder2_dataset.append(d)
+
+    train_data_d2, test_data_d2 = train_test_split(
+        decoder2_dataset, test_size=0.1, random_state=42
+    )
+    train_loader_d2 = DataLoader(
+        train_data_d2, batch_size=decoder2_bsize, shuffle=False # Shuffle True for training
+    )
+    test_loader_d2 = DataLoader(test_data_d2, batch_size=decoder2_bsize, shuffle=False)
+
+    X_ref_raw = dataset[0].x # Atom coords of the first frame
+    if conditioner_mode == "X_ref":
+        conditioner_data = X_ref_raw # Shape [num_unique_atoms, 3]
+        logger.info("Using raw X_ref as conditioner.")
+    else: # z_ref
+        with torch.no_grad():
+            X_ref_emb = hno_model.forward_representation(
+                X_ref_raw.to(device), dataset[0].edge_index.to(device)
+            )
+        conditioner_data = X_ref_emb.cpu() # Shape [num_unique_atoms, hidden_dim]
+        logger.info("Using z_ref (HNO embedding of X_ref) as conditioner.")
+    sys.stdout.flush()
+    num_nodes = X_ref_raw.shape[0]
+    np.save(os.path.join(structures_dir, f"X_ref_{args.exp_label}.npy"), X_ref_raw.numpy()) # Save X_ref specific to exp_label
+
+    # MODIFIED: Decoder2 checkpoint path now includes exp_label
+    base_ckpt_name = f"decoder2_{args.exp_label}"
+    if d2_pooling_type == "blind":
+        d2_ckpt_path = os.path.join(
+            checkpoint_dir,
+            "decoder2_blind.pth"
+        )
+    else: # residue
+        d2_ckpt_path = os.path.join(
+            checkpoint_dir,"decoder2_residue.pth"
+        )
+
+    logger.info(
+        f"Creating ProteinStateReconstructor2D ({args.exp_label}/{args.epoch_folder}) with pooling_type={d2_pooling_type}, "
+        f"conditioner_mode={conditioner_mode}."
+    )
+    sys.stdout.flush()
+
+    # MODIFIED: Construct path to the specific generated_embedding.h5
+    special_file_path = os.path.join(
+        latent_reps_dir, args.embedding_base_folder, args.epoch_folder, "generated_embeddings.h5"
+    )
+    logger.info(f"Using special_res_file: {special_file_path}")
+
+    # Ensure override_residues list matches your data. This is a very long list.
+    # It should correspond to the number of residues (or segments) you expect.
+    # If using residue pooling, len(new_residue_indices) is the number of residues.
+    # The override_residues list should contain indices from 0 to R-1.
+    # The H5 file for override should then have embeddings for these R residues (or a subset M of them).
+    num_total_residues = len(new_residue_indices) if d2_pooling_type == "residue" else 1
+    
+    # Example: Override all residues if residue pooling, or the single segment if blind.
+    # This example list needs to be dynamically set or carefully configured.
+    # For residue pooling, it should be list(range(num_total_residues)) if you intend to override all.
+    # The HDF5 override file must then provide embeddings for all these.
+    # The original hardcoded list was very long, make sure it's appropriate.
+    # Assuming the hardcoded list was for a specific protein with that many residues.
+    # Let's make it dynamic:
+    override_residues_list = list(range(num_total_residues)) if d2_pooling_type == "residue" else [0]
+    if len(override_residues_list) > 273 and d2_pooling_type == "residue": # If the hardcoded list was a max
+        logger.warning(f"Number of residues ({num_total_residues}) is less than typical override list. Using all {num_total_residues} residues for override.")
+    elif d2_pooling_type == "residue":
+         logger.info(f"Setting override_residues to all {num_total_residues} residues.")
+    # else: it's blind pooling, override_residues_list is [0]
+
+    protein_state_model_2d = ProteinStateReconstructor2D(
+        input_dim=hidden_dim, # Dimension of HNO latent embeddings
+        num_nodes=num_nodes,
+        pooling_type=d2_pooling_type,
+        residue_atom_indices=new_residue_indices if d2_pooling_type == "residue" else None,
+        output_size_per_segment=(d2_output_height, d2_output_width),
+        second_level_output_size=(d2_output_height2, d2_output_width2) if d2_pooling_type == "residue" and use_second_level_pooling else None,
+        use_second_level_pooling=use_second_level_pooling,
+        use_cross_attention=use_cross_attention, # Note: this is usually False in constructor
+        cross_attention_type=cross_attention_type,
+        conditioner_mode=conditioner_mode,
+        num_hidden_layers=d2_num_hidden_layers,
+        override_residues=override_residues_list, # Use the dynamically determined list
+        special_res_file=special_file_path,
+    )
+
+    logger.info(
+        f"Training Decoder2 ({args.exp_label}/{args.epoch_folder}) => epochs={decoder2_epochs}, LR={decoder2_lr}, bsize={decoder2_bsize}"
+    )
+    sys.stdout.flush()
+    train_protein_state_reconstructor(
+        protein_state_model_2d,
+        train_loader_d2,
+        test_loader_d2,
+        num_epochs=decoder2_epochs,
+        learning_rate=decoder2_lr,
+        checkpoint_path=d2_ckpt_path,
+        conditioner_data=conditioner_data,
+        save_interval=10,
+        weight_value=d2_weight_value,
+    )
+
+    if recon_output == 1: # Decoder2 reconstructions
+        logger.info(f"Generating Decoder2 reconstructions for {args.exp_label}/{args.embedding_base_folder}/{args.epoch_folder}...")
+        sys.stdout.flush()
+
+        # MODIFIED: Output path is now inside the specific epoch_folder in latent_reps
+        embedding_source_dir = os.path.join(latent_reps_dir, args.embedding_base_folder, args.epoch_folder)
+        # os.makedirs(embedding_source_dir, exist_ok=True) # Should exist if generated_embedding.h5 is there
+        dec2_recon_path = os.path.join(embedding_source_dir, f"decoder2_output_reconstruction.h5")
+        
+        protein_state_model_2d.eval()
+        
+        # For generation, use a consistent dataset part, e.g., test_data_d2 or all of decoder2_dataset
+        # Using test_loader_d2 for this example.
+        # To save all coords from a batch, need to sum num_nodes per item in batch.
+        # PyG loader handles batching, so output X_pred is already [TotalNodesInBatch, 3]
+        
+        all_recons_override = []
+        all_recons_no_override = []
+
+        with torch.no_grad():
+            for batch_idx, data in enumerate(test_loader_d2): # Or use train_loader_d2 or full dataset loader
+                data = data.to(device)
+                X_pred_override = protein_state_model_2d(
+                    data.x, data.batch, conditioner_data, use_override=True
+                )
+                X_pred_no_override = protein_state_model_2d(
+                    data.x, data.batch, conditioner_data, use_override=False
+                )
+                all_recons_override.append(X_pred_override.cpu().numpy())
+                all_recons_no_override.append(X_pred_no_override.cpu().numpy())
+
+                if batch_idx % 10 == 0 and args.debug:
+                    logger.debug(
+                        f"[Decoder2:Generation {args.exp_label}/{args.epoch_folder}] batch {batch_idx+1} "
+                        f"X_pred_over.shape={X_pred_override.shape}"
+                    )
+                    sys.stdout.flush()
+        
+        final_recons_override = np.concatenate(all_recons_override, axis=0)
+        final_recons_no_override = np.concatenate(all_recons_no_override, axis=0)
+
+        with h5py.File(dec2_recon_path, "w") as recon_h5:
+            recon_h5.create_dataset("reconstructions_with_override", data=final_recons_override)
+            recon_h5.create_dataset("reconstructions_no_override", data=final_recons_no_override)
+        
+        logger.info(
+            f"Decoder2 reconstructions for {args.exp_label}/{args.epoch_folder} saved to {dec2_recon_path}. "
+            f"with_override={final_recons_override.shape[0]} coords, "
+            f"no_override={final_recons_no_override.shape[0]} coords."
+        )
+        sys.stdout.flush()
+
+    # Pooled latent embeddings from Decoder2 (optional, if needed for analysis)
+    # This part might need adjustment based on what "pooled latent" means for Decoder2
+    # The current ProteinStateReconstructor2D doesn't have a simple get_final_pooled_latent.
+    # The get_pooled_latent method returns the result after the initial pooling stages.
+    # If this specific output is still desired, its path should also be made exp_label specific.
+    # For now, commenting out as it was less critical to the primary request.
+    """
+    pooled_latent_path_d2 = os.path.join(
+        latent_reps_dir, f"decoder2_pooled_latent_embeddings_{args.exp_label}_{args.epoch_folder}.h5" # Made specific
+    )
+    all_pooled_d2 = []
+    protein_state_model_2d.eval()
+    with torch.no_grad():
+        # Iterate over decoder2_dataset (or a specific part like test_data_d2)
+        # The get_pooled_latent needs to be called carefully, perhaps within the forward pass logic
+        # or by creating a temporary loader if needed.
+        # For each Data object in decoder2_dataset:
+        temp_loader_d2_for_latent = DataLoader(decoder2_dataset, batch_size=decoder2_bsize, shuffle=False)
+        for data_batch in temp_loader_d2_for_latent:
+            data_batch = data_batch.to(device)
+            # get_pooled_latent takes x (HNO latents), and conditioner (optional, not used by current get_pooled_latent)
+            pooled_lat = protein_state_model_2d.get_pooled_latent(data_batch.x, None) 
+            # pooled_lat shape [B, R_or_1, pooled_dim].
+            all_pooled_d2.append(pooled_lat.cpu().numpy())
+    
+    if all_pooled_d2:
+        all_pooled_d2_cat = np.concatenate(all_pooled_d2, axis=0) # Concatenate along batch dimension
+        with h5py.File(pooled_latent_path_d2, "w") as latent_h5_d2:
+            latent_h5_d2.create_dataset("pooled_latent", data=all_pooled_d2_cat)
+        logger.info(
+            f"Decoder2 pooled latent embeddings for {args.exp_label}/{args.epoch_folder} saved to {pooled_latent_path_d2} with shape {all_pooled_d2_cat.shape}"
+        )
+    else:
+        logger.info(f"No Decoder2 pooled latent embeddings generated for {args.exp_label}/{args.epoch_folder}.")
+    sys.stdout.flush()
+    """
+    logger.info(f"All tasks completed successfully for {args.exp_label}/{args.embedding_base_folder}/{args.epoch_folder}!")
+    sys.stdout.flush()

LD-FPG-main/residue/chebnet_res.py

@@ -0,0 +1,1251 @@
+import os
+import sys
+import json
+import yaml
+import argparse
+import logging
+import h5py
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.data import Data
+from torch_geometric.loader import DataLoader
+from torch_geometric.nn import ChebConv
+from torch_cluster import knn_graph
+from sklearn.model_selection import train_test_split
+
+################################################################################
+# Argument Parsing
+################################################################################
+parser = argparse.ArgumentParser(
+    description="All-Atom Protein Reconstruction with Contiguous Indexing & Optional Debug (Optimized Decoder)"
+)
+parser.add_argument(
+    "--config", type=str, required=True, help="Path to the YAML configuration file."
+)
+parser.add_argument("--debug", action="store_true", help="Enable debug-level logging.")
+parser.add_argument(
+    "--log_file", type=str, default="logfile_optimized.log", help="Path to the log file."
+)
+args = parser.parse_args()
+
+################################################################################
+# Logging Setup
+################################################################################
+logger = logging.getLogger("ProteinReconstructionOptimized") # Changed logger name
+logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+fh = logging.FileHandler(args.log_file, mode="w")
+fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
+ch = logging.StreamHandler(sys.stdout)
+ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+fh.setFormatter(formatter)
+ch.setFormatter(formatter)
+
+logger.addHandler(fh)
+logger.addHandler(ch)
+
+logger.info("Logger initialized.")
+if args.debug:
+    logger.debug("Debug mode is ON.")
+else:
+    logger.info("Debug mode is OFF; minimal logs will be shown.")
+
+################################################################################
+# Load YAML Configuration
+################################################################################
+def load_config(config_path):
+    with open(config_path, "r") as f:
+        conf = yaml.safe_load(f)
+    return conf
+
+try:
+    config = load_config(args.config)
+    logger.info(f"Loaded configuration from {args.config}")
+except Exception as e:
+    logger.error(f"Error loading config: {e}")
+    sys.exit(1)
+
+# Extract main parameters
+json_path = config["json_path"]
+knn_value = config["knn_value"]
+cheb_order = config["cheb_order"]
+hidden_dim = config["hidden_dim"]
+recon_output = config["recon_output"]
+
+# Decoder 1 (HNO) parameters
+decoder1_lr = config["decoder1"]["learning_rate"]
+decoder1_epochs = config["decoder1"]["num_epochs"]
+decoder1_bsize = config["decoder1"]["batch_size"]
+
+# Decoder 2 parameters
+decoder2_lr = config["decoder2"]["learning_rate"]
+decoder2_epochs = config["decoder2"]["num_epochs"]
+decoder2_bsize = config["decoder2"]["batch_size"]
+
+# Decoder 2 settings
+d2_output_height = config["decoder2_settings"]["output_height"]
+d2_output_width = config["decoder2_settings"]["output_width"]
+d2_pooling_type = config["decoder2_settings"]["pooling_type"]  # 'blind' or 'residue'
+d2_weight_value = config["decoder2_settings"]["weight_value"]
+d2_output_height2 = config["decoder2_settings"].get("output_height2", None)
+d2_output_width2 = config["decoder2_settings"].get("output_width2", None)
+
+use_second_level_pooling = config["decoder2_settings"].get(
+    "use_second_level_pooling", False
+)
+use_cross_attention = config["decoder2_settings"].get("use_cross_attention", False)
+cross_attention_type = config["decoder2_settings"].get(
+    "cross_attention_type", "global"
+)
+conditioner_mode = config["decoder2_settings"].get(
+    "conditioner_mode", "X_ref"
+)
+d2_num_hidden_layers = config["decoder2_settings"].get(
+    "num_hidden_layers", 2
+)
+
+# Override settings for ProteinStateReconstructor2D
+override_residues_config = config["decoder2_settings"].get("override_residues", None) # Expect list or null
+special_res_file_config = config["decoder2_settings"].get("special_res_file", None) # Expect path string or null
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+logger.info(f"Using device: {device}")
+
+################################################################################
+# Directory Setup
+################################################################################
+current_dir = os.getcwd()
+checkpoint_dir = os.path.join(current_dir, "checkpoints") # Changed dir name
+latent_reps_dir = os.path.join(current_dir, "latent_reps") # Changed dir name
+structures_dir = os.path.join(current_dir, "structures")   # Changed dir name
+
+os.makedirs(checkpoint_dir, exist_ok=True)
+os.makedirs(latent_reps_dir, exist_ok=True)
+os.makedirs(structures_dir, exist_ok=True)
+
+logger.debug(
+    f"Directories:\n  checkpoints: {checkpoint_dir}\n  latent_reps: {latent_reps_dir}\n  structures: {structures_dir}"
+)
+
+################################################################################
+# Utility Functions
+################################################################################
+def save_checkpoint(state, filename):
+    torch.save(state, filename)
+    logger.debug(f"Checkpoint saved to {filename}")
+    sys.stdout.flush()
+
+def load_checkpoint(model, optimizer, filename):
+    start_epoch = 0
+    if os.path.isfile(filename):
+        logger.info(f"Loading checkpoint from '{filename}'")
+        sys.stdout.flush()
+        checkpoint = torch.load(filename, map_location=device)
+        start_epoch = checkpoint["epoch"]
+        try:
+            model.load_state_dict(checkpoint["model_state_dict"])
+        except RuntimeError as e:
+            logger.warning(f"Could not load model state_dict strictly: {e}. Trying non-strict loading.")
+            model.load_state_dict(checkpoint["model_state_dict"], strict=False)
+
+        if optimizer and "optimizer_state_dict" in checkpoint:
+            optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+            # Move optimizer state to device
+            for state in optimizer.state.values():
+                for k, v in state.items():
+                    if isinstance(v, torch.Tensor):
+                        state[k] = v.to(device)
+        logger.info(f"Loaded checkpoint at epoch {start_epoch}")
+        sys.stdout.flush()
+    else:
+        logger.info(f"No checkpoint found at '{filename}'. Training from scratch.")
+        sys.stdout.flush()
+    return model, optimizer, start_epoch
+
+def compute_centroid(X):
+    return X.mean(dim=0)
+
+def kabsch_algorithm(P, Q):
+    centroid_P = compute_centroid(P)
+    centroid_Q = compute_centroid(Q)
+    P_centered = P - centroid_P
+    Q_centered = Q - centroid_Q
+
+    C = torch.mm(Q_centered.T, P_centered)
+    try:
+        V, S, W = torch.linalg.svd(C) # More modern SVD
+    except AttributeError: # Fallback for older PyTorch
+        V, S, W = torch.svd(C)
+
+
+    d = torch.det(torch.mm(V, W.T))
+    if d < 0:
+        V[:, -1] = -V[:, -1]
+
+    U = torch.mm(V, W.T)
+    Q_aligned = torch.mm(Q_centered, U) + centroid_P
+    return U, Q_aligned
+
+################################################################################
+# Reindexing Residue Indices
+################################################################################
+def remap_residue_indices(residue_atom_indices):
+    flattened = [atom for residue in residue_atom_indices for atom in residue]
+    if not flattened: # Handle empty case
+        logger.warning("Residue_atom_indices is empty or contains only empty residues.")
+        return [], {}
+    unique_atoms = sorted(set(flattened))
+    logger.debug(
+        f"Unique atoms found: {len(unique_atoms)}. "
+        f"Max original ID = {max(unique_atoms)}, Min = {min(unique_atoms)}"
+    )
+    sys.stdout.flush()
+
+    old2new_map = {old_id: idx for idx, old_id in enumerate(unique_atoms)}
+    if args.debug:
+        first_few_items = list(old2new_map.items())[:5]
+        logger.debug(f"[old2new_map sample] -> {first_few_items}")
+        sys.stdout.flush()
+
+    new_residue_indices = []
+    for residue in residue_atom_indices:
+        new_list = [old2new_map[a] for a in residue if a in old2new_map] # Ensure atom is in map
+        new_residue_indices.append(new_list)
+    
+    # Filter out empty lists that might result if a residue had no mappable atoms
+    new_residue_indices = [res for res in new_residue_indices if res]
+
+    return new_residue_indices, old2new_map
+
+################################################################################
+# Data Loading & Alignment
+################################################################################
+def load_heavy_atom_coords_from_json(json_file):
+    logger.info(f"Loading JSON from {json_file}")
+    sys.stdout.flush()
+    with open(json_file, "r") as f:
+        data = json.load(f)
+
+    if not data:
+        logger.error(f"JSON file {json_file} is empty or invalid.")
+        return [], []
+
+    residue_keys_sorted = sorted(data.keys(), key=lambda x: int(x)) # Assuming keys are numeric strings
+    if not residue_keys_sorted:
+        logger.error("No residue keys found in JSON data.")
+        return [], []
+    logger.debug(f"Number of residues in JSON: {len(residue_keys_sorted)}")
+    sys.stdout.flush()
+
+    num_frames = len(data[residue_keys_sorted[0]]["heavy_atom_coords_per_frame"])
+    logger.info(f"Number of frames = {num_frames}")
+    sys.stdout.flush()
+
+    original_residue_atom_indices = []
+    for res_key in residue_keys_sorted:
+        idx_list = data[res_key]["heavy_atom_indices"]
+        original_residue_atom_indices.append(idx_list)
+
+    coords_per_frame = []
+    for frame_idx in range(num_frames):
+        frame_coords_list = []
+        for res_key in residue_keys_sorted:
+            coords_this_res = data[res_key]["heavy_atom_coords_per_frame"][frame_idx]
+            frame_coords_list.append(np.array(coords_this_res, dtype=np.float32))
+        if not frame_coords_list: # If a frame has no coordinates
+            logger.warning(f"Frame {frame_idx} resulted in no coordinates. Skipping.")
+            continue
+        try:
+            frame_coords = np.concatenate(frame_coords_list, axis=0)
+            coords_per_frame.append(torch.tensor(frame_coords, dtype=torch.float32))
+        except ValueError as e:
+             logger.error(f"Error concatenating coordinates for frame {frame_idx}: {e}. Check for empty coord lists.")
+             # Potentially skip this frame or handle error
+             continue
+
+
+    return coords_per_frame, original_residue_atom_indices
+
+def align_frames_to_first(coords_list):
+    if not coords_list:
+        logger.warning("Coordinate list is empty. Cannot align.")
+        return []
+    logger.info("Aligning all frames to the first frame via Kabsch...")
+    sys.stdout.flush()
+    reference = coords_list[0].to(device) # Move reference to device for Kabsch
+    aligned = [coords_list[0]] # First frame is the reference, keep on CPU
+
+    for i, coords in enumerate(coords_list[1:], 1): # Start from the second frame
+        coords_dev = coords.to(device)
+        try:
+            _, coords_aligned_dev = kabsch_algorithm(reference, coords_dev)
+            aligned.append(coords_aligned_dev.cpu()) # Move aligned back to CPU
+        except Exception as e:
+            logger.error(f"Kabsch alignment failed for frame {i}: {e}. Appending original.")
+            aligned.append(coords) # Append original if alignment fails
+
+        if args.debug and i < 5:
+            logger.debug(f"Frame {i}: aligned shape={aligned[-1].shape}")
+            sys.stdout.flush()
+    return aligned
+
+################################################################################
+# Build Graph Dataset
+################################################################################
+def build_graph_dataset(coords_list, knn_neighbors=4):
+    logger.info("Building PyG dataset with knn_graph.")
+    sys.stdout.flush()
+    dataset = []
+    for idx, coords_cpu in enumerate(coords_list):
+        coords_dev = coords_cpu.to(device) # Move to device for knn_graph
+        try:
+            edge_index = knn_graph(coords_dev, k=knn_neighbors, batch=None, loop=False)
+            # Create Data object with tensors on CPU
+            data = Data(x=coords_cpu, edge_index=edge_index.cpu(), y=coords_cpu)
+            dataset.append(data)
+        except Exception as e:
+            logger.error(f"Failed to build graph for frame {idx}: {e}. Skipping this frame.")
+            continue
+
+        if args.debug and idx < 5:
+            logger.debug(
+                f"[Dataset] Frame {idx}: x.shape={coords_cpu.shape}, edge_index.shape={edge_index.cpu().shape}"
+            )
+            sys.stdout.flush()
+    return dataset
+
+################################################################################
+# HNO Model
+################################################################################
+class HNO(nn.Module):
+    _logged_forward_once = False
+
+    def __init__(self, hidden_dim, K):
+        super().__init__()
+        logger.debug(f"Initializing HNO with hidden_dim={hidden_dim}, K={K}")
+        sys.stdout.flush()
+        self.conv1 = ChebConv(3, hidden_dim, K=K)
+        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
+        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
+
+        self.bano1 = nn.BatchNorm1d(hidden_dim)
+        self.bano2 = nn.BatchNorm1d(hidden_dim)
+        self.bano3 = nn.BatchNorm1d(hidden_dim)
+        self.mlpRep = nn.Linear(hidden_dim, 3)
+
+    def forward(self, x, edge_index):
+        if args.debug and (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] Input x.shape={x.shape}")
+            sys.stdout.flush()
+
+        x = self.conv1(x, edge_index)
+        if args.debug and (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] After conv1 => {x.shape}")
+            sys.stdout.flush()
+        x = F.leaky_relu(x)
+        x = self.bano1(x)
+
+        x = self.conv2(x, edge_index)
+        x = F.leaky_relu(x)
+        x = self.bano2(x)
+
+        x = self.conv3(x, edge_index)
+        x = F.relu(x) # Note: Original uses F.relu here
+        x = self.bano3(x)
+
+        x_repr = self.conv4(x, edge_index) # Representation before normalization for mlpRep
+        x_norm_repr = F.normalize(x_repr, p=2, dim=1) # Normalized for potential use as z_ref
+        
+        if args.debug and (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] After conv4 (before mlpRep) => {x_repr.shape}")
+            sys.stdout.flush()
+            
+        # In original Code 1, mlpRep was applied to the output of conv4 *before* normalization
+        # if it was for the main forward pass, but to the *normalized* output in forward_representation.
+        # Let's use the un-normalized for direct reconstruction, and forward_representation will give normalized.
+        x_out = self.mlpRep(x_repr) # Use un-normalized for reconstruction
+        
+        if args.debug and (not HNO._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[HNO:forward] Output => {x_out.shape}")
+            HNO._logged_forward_once = True # Log only once
+            sys.stdout.flush()
+        return x_out
+
+
+    def forward_representation(self, x, edge_index):
+        # This explicitly returns the L2 normalized representation after conv4
+        x = self.conv1(x, edge_index)
+        x = F.leaky_relu(x)
+        x = self.bano1(x)
+
+        x = self.conv2(x, edge_index)
+        x = F.leaky_relu(x)
+        x = self.bano2(x)
+
+        x = self.conv3(x, edge_index)
+        x = F.relu(x)
+        x = self.bano3(x)
+
+        x = self.conv4(x, edge_index)
+        x = F.normalize(x, p=2, dim=1) # Key: normalize for z_ref
+        return x
+
+################################################################################
+# Train HNO
+################################################################################
+def train_hno_model(
+    model,
+    train_loader,
+    test_loader,
+    num_epochs,
+    learning_rate,
+    checkpoint_path,
+    save_interval=10,
+):
+    model = model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    criterion = nn.MSELoss()
+
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path)
+    if start_epoch >= num_epochs:
+        logger.info(f"HNO training already completed up to epoch {start_epoch}/{num_epochs}. Skipping training.")
+        model.eval()
+        return model
+
+    logger.info(
+        f"Starting HNO from epoch {start_epoch + 1}, total epochs={num_epochs}, LR={learning_rate}"
+    )
+    sys.stdout.flush()
+
+    for epoch in range(start_epoch, num_epochs):
+        model.train()
+        total_loss = 0
+        for data in train_loader:
+            data = data.to(device)
+            optimizer.zero_grad()
+            pred = model(data.x, data.edge_index)
+            loss = criterion(pred, data.y) # Target is data.y (ground truth coordinates)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        avg_loss = total_loss / len(train_loader) if len(train_loader) > 0 else 0
+
+        model.eval()
+        test_loss = 0
+        with torch.no_grad():
+            for data in test_loader:
+                data = data.to(device)
+                pred = model(data.x, data.edge_index)
+                val_loss = criterion(pred, data.y) # Target is data.y
+                test_loss += val_loss.item()
+        avg_test_loss = test_loss / len(test_loader) if len(test_loader) > 0 else 0
+
+        logger.info(
+            f"[HNO] Epoch {epoch+1}/{num_epochs} => Train Loss={avg_loss:.6f}, Test Loss={avg_test_loss:.6f}"
+        )
+        sys.stdout.flush()
+
+        if (epoch + 1) % save_interval == 0 or (epoch + 1) == num_epochs:
+            checkpoint_state = {
+                "epoch": epoch + 1,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+            }
+            save_checkpoint(checkpoint_state, checkpoint_path)
+            logger.info(f"HNO checkpoint saved at epoch {epoch+1} -> {checkpoint_path}")
+            sys.stdout.flush()
+    model.eval()
+    return model
+
+################################################################################
+# Simple Cross-Attention Module (Kept for structural consistency with original Code 1)
+################################################################################
+class CrossAttentionBlock(nn.Module):
+    def __init__(self, query_dim, kv_dim, attention_dim=64):
+        super().__init__()
+        self.query_layer = nn.Linear(query_dim, attention_dim, bias=False)
+        self.key_layer = nn.Linear(kv_dim, attention_dim, bias=False)
+        self.value_layer = nn.Linear(kv_dim, attention_dim, bias=False)
+        self.scale = attention_dim**-0.5
+
+    def forward(self, query, key, value):
+        original_shape = query.shape
+        if query.dim() == 3:
+            B, N_seg, q_dim = query.shape
+            query = query.view(B * N_seg, q_dim)
+        else:
+            B, q_dim = query.shape
+            N_seg = 1
+
+        B_kv, num_kv, kv_d = key.shape
+        Q = self.query_layer(query).unsqueeze(1)
+        K = self.key_layer(key)
+        V = self.value_layer(value)
+        scores = torch.matmul(Q, K.transpose(-1, -2)) * self.scale
+        attn = F.softmax(scores, dim=-1)
+        out = torch.matmul(attn, V)
+        out = out.squeeze(1)
+        if N_seg > 1:
+            out = out.view(B, N_seg, -1)
+        return out
+
+################################################################################
+# MLP Builder for Decoder2 (Kept as is)
+################################################################################
+def build_decoder_mlp(input_dim, output_dim, num_hidden_layers, hidden_dim_mlp=128): # Renamed hidden_dim for clarity
+    layers = []
+    current_dim = input_dim
+    if num_hidden_layers < 1: # Direct connection
+        layers.append(nn.Linear(current_dim, output_dim))
+    else:
+        for i in range(num_hidden_layers -1): # Corrected loop for num_hidden_layers
+            layers.append(nn.Linear(current_dim, hidden_dim_mlp))
+            layers.append(nn.ReLU())
+            layers.append(nn.BatchNorm1d(hidden_dim_mlp))
+            current_dim = hidden_dim_mlp
+        layers.append(nn.Linear(current_dim, output_dim))
+    return nn.Sequential(*layers)
+
+################################################################################
+# ProteinStateReconstructor2D (MODIFIED with atom_to_residue_map)
+################################################################################
+class ProteinStateReconstructor2D(nn.Module):
+    _logged_forward_once = False
+
+    def __init__(
+        self,
+        input_dim,        # HNO's hidden_dim
+        num_nodes,        # Total number of unique atoms after remapping
+        pooling_type="blind",
+        residue_atom_indices=None, # List of lists (remapped atom indices per residue)
+        output_size_per_segment=(1, 10),
+        second_level_output_size=None,
+        use_second_level_pooling=False,
+        use_cross_attention=False, # Not actively used in this optimized version's core logic
+        cross_attention_type=None, # Not actively used
+        conditioner_mode="z_ref",
+        num_hidden_layers=2,
+        mlp_hidden_dim=128, # Added for clarity
+        override_residues=None,
+        special_res_file=None,
+    ):
+        super().__init__()
+        self.pooling_type = pooling_type
+        self.num_nodes = num_nodes
+        self.input_dim = input_dim # This is the dimension of HNO embeddings
+        self.conditioner_mode = conditioner_mode # 'X_ref' or 'z_ref'
+        self.use_second_level_pooling = use_second_level_pooling
+        self.output_size_per_segment = output_size_per_segment
+        self.second_level_output_size = second_level_output_size
+
+        self.override_residues = override_residues if override_residues is not None else []
+        self.generated_arr = None
+
+        if special_res_file is not None and len(self.override_residues) > 0:
+            logger.info(f"Attempting to load override embeddings from: {special_res_file}")
+            try:
+                with h5py.File(special_res_file, "r") as f:
+                    # Assuming dataset name, adjust if different
+                    arr = f["generated_embeddings"][:] # Or "pooled_latent" etc.
+                if np.isnan(arr).any():
+                    logger.error("Generated override embeddings contain NaN values!")
+                else:
+                    logger.info(f"Generated embeddings loaded with shape {arr.shape} and appear valid.")
+                    self.generated_arr = arr
+                    if self.generated_arr.shape[1] != len(self.override_residues):
+                        logger.error(
+                            f"Mismatch: special_res_file has {self.generated_arr.shape[1]} residues for override, "
+                            f"but override_residues has length {len(self.override_residues)}. Disabling override."
+                        )
+                        self.generated_arr = None # Disable if mismatch
+            except Exception as e:
+                logger.error(f"Could not load or process special_res_file {special_res_file}: {e}. Override disabled.")
+                self.generated_arr = None
+        elif special_res_file is not None and not self.override_residues:
+            logger.info(f"special_res_file '{special_res_file}' provided, but override_residues list is empty. No override will occur.")
+
+
+        # Determine conditioner dimension based on mode and input_dim (HNO's output)
+        # This is used for the final MLP's input size calculation.
+        # The actual conditioner tensor is passed during forward.
+        self.conditioner_dim_expected = 3 if conditioner_mode == "X_ref" else self.input_dim
+
+        if pooling_type == "blind":
+            # For blind pooling, all atoms effectively belong to one segment
+            self.segments_indices_map = [list(range(num_nodes))] # A single segment containing all atoms
+            self.segment_pools = nn.ModuleList(
+                [nn.AdaptiveAvgPool2d(self.output_size_per_segment)]
+            )
+            self.num_effective_segments = 1
+            seg_pooled_size = self.output_size_per_segment[0] * self.output_size_per_segment[1]
+            self.pooled_dim_per_segment = seg_pooled_size # This is D_pool_level1
+            self.final_effective_pooled_dim = self.pooled_dim_per_segment # No second level for blind
+            self.global_pool2 = None
+            # For blind pooling, atom_to_residue_map maps all atoms to segment 0
+            self.register_buffer('atom_to_segment_map', torch.zeros(num_nodes, dtype=torch.long), persistent=False)
+
+        elif pooling_type == "residue":
+            if residue_atom_indices is None or not any(residue_atom_indices): # Check if empty or list of empty lists
+                raise ValueError("residue_atom_indices is required and must not be empty for residue-level pooling.")
+            
+            self.segments_indices_map = residue_atom_indices # Store the list of lists of atom indices
+            self.num_effective_segments = len(self.segments_indices_map)
+            self.segment_pools = nn.ModuleList()
+            for _ in self.segments_indices_map:
+                pool = nn.AdaptiveAvgPool2d(self.output_size_per_segment)
+                self.segment_pools.append(pool)
+            
+            self.pooled_dim_per_segment = self.output_size_per_segment[0] * self.output_size_per_segment[1] # D_pool_level1
+
+            if use_second_level_pooling and second_level_output_size is not None and self.num_effective_segments > 0 :
+                self.global_pool2 = nn.AdaptiveAvgPool2d(second_level_output_size)
+                self.final_effective_pooled_dim = second_level_output_size[0] * second_level_output_size[1]
+            else:
+                self.global_pool2 = None
+                self.final_effective_pooled_dim = self.pooled_dim_per_segment
+
+            # --- Create atom_to_residue_map for 'residue' pooling ---
+            atom_to_res_map_list = [-1] * num_nodes
+            valid_map = True
+            for res_idx, atom_indices_in_res in enumerate(self.segments_indices_map):
+                for atom_idx in atom_indices_in_res:
+                    if 0 <= atom_idx < num_nodes:
+                        if atom_to_res_map_list[atom_idx] != -1:
+                            logger.warning(f"Atom {atom_idx} assigned to multiple residues. Using first assignment (res {atom_to_res_map_list[atom_idx]}). Check residue_atom_indices for overlaps.")
+                        else:
+                            atom_to_res_map_list[atom_idx] = res_idx
+                    else:
+                        logger.error(f"Atom index {atom_idx} in residue {res_idx} is out of bounds (0-{num_nodes-1}).")
+                        valid_map = False
+            
+            if not valid_map:
+                raise ValueError("Invalid atom indices found in residue_atom_indices. See logs.")
+
+            if -1 in atom_to_res_map_list:
+                unmapped_indices = [i for i, x in enumerate(atom_to_res_map_list) if x == -1]
+                logger.warning(f"{len(unmapped_indices)} atoms not mapped to any residue (e.g., {unmapped_indices[:5]}). "
+                               f"These atoms will effectively not receive specific residue-pooled features if not handled.")
+                # Decide on a strategy: error, or assign to a dummy residue index, or ensure all atoms are covered.
+                # For now, we proceed, but if an atom with map value -1 is accessed, it will error.
+                # It's better to ensure residue_atom_indices covers all 0..num_nodes-1 atoms.
+
+            self.register_buffer('atom_to_segment_map', torch.tensor(atom_to_res_map_list, dtype=torch.long), persistent=False)
+        else:
+            raise ValueError(f"Unknown pooling_type={pooling_type}")
+
+        # Final MLP input dimension: effective pooled dimension + conditioner dimension
+        self.final_mlp_in_dim = self.final_effective_pooled_dim + self.conditioner_dim_expected
+        
+        self.decoder = build_decoder_mlp(
+            input_dim=self.final_mlp_in_dim,
+            output_dim=3, # Predicts 3D coordinates
+            num_hidden_layers=num_hidden_layers,
+            hidden_dim_mlp=mlp_hidden_dim, # Pass the specific hidden_dim for MLP
+        )
+        logger.info(f"ProteinStateReconstructor2D initialized. Pooling: {self.pooling_type}, "
+                    f"Num Segments: {self.num_effective_segments}, "
+                    f"Pooled dim per seg: {self.pooled_dim_per_segment}, "
+                    f"Final effective pooled dim: {self.final_effective_pooled_dim}, "
+                    f"Conditioner dim expected: {self.conditioner_dim_expected}, "
+                    f"MLP input dim: {self.final_mlp_in_dim}")
+
+
+    def get_pooled_latent(self, x, conditioner=None): # x is [B*N_nodes, input_dim]
+        """
+        Standard pooling step without overrides. conditioner is not used here.
+        Returns pooled_latent of shape [B, NumEffectiveSegments, FinalEffectivePooledDim]
+        """
+        B_times_N, _ = x.shape
+        batch_size = B_times_N // self.num_nodes
+        x_reshaped = x.view(batch_size, self.num_nodes, -1) # [B, N, D_in]
+
+        if self.pooling_type == "blind":
+            # x_reshaped[:, self.segments_indices_map[0], :] is equivalent to x_reshaped
+            seg_x = x_reshaped.unsqueeze(1)  # [B, 1, N_nodes, D_in]
+            p_2d = self.segment_pools[0](seg_x)  # [B, 1, H, W] (here D_in is pooled as W)
+            pooled_flat = p_2d.squeeze(1).view(batch_size, -1) # [B, H*W]
+            # Result shape [B, 1 segment, pooled_dim_per_segment]
+            pooled_latent_to_return = pooled_flat.unsqueeze(1)
+        
+        elif self.pooling_type == "residue":
+            pooled_segments_level1_list = []
+            for i, atom_indices_in_segment in enumerate(self.segments_indices_map):
+                if not atom_indices_in_segment: # Skip empty segments
+                     # Append zeros or handle as error. For shape consistency, append zeros.
+                     pooled_segments_level1_list.append(torch.zeros(batch_size, self.pooled_dim_per_segment, device=x.device, dtype=x.dtype))
+                     continue
+                # Select atoms for this segment: [B, N_atoms_in_seg, D_in]
+                seg_x_atoms = x_reshaped[:, atom_indices_in_segment, :]
+                seg_x_atoms_unsqueezed = seg_x_atoms.unsqueeze(1) # [B, 1, N_atoms_in_seg, D_in]
+                
+                p_2d = self.segment_pools[i](seg_x_atoms_unsqueezed) # [B, 1, H, W] (D_in pooled as W)
+                p_2d_flat = p_2d.squeeze(1).view(batch_size, -1) # [B, pooled_dim_per_segment]
+                pooled_segments_level1_list.append(p_2d_flat)
+            
+            if not pooled_segments_level1_list: # Should not happen if init checks pass
+                 return torch.empty(batch_size, 0, self.final_effective_pooled_dim, device=x.device, dtype=x.dtype)
+
+            level1_concat = torch.stack(pooled_segments_level1_list, dim=1)  # [B, NumResidues, pooled_dim_per_segment]
+
+            if self.global_pool2 is not None:
+                level1_concat_4d = level1_concat.unsqueeze(1) # [B, 1, NumResidues, pooled_dim_per_segment]
+                # global_pool2 pools over NumResidues (dim 2) and pooled_dim_per_segment (dim 3)
+                pooled_2d_level2 = self.global_pool2(level1_concat_4d) # [B, 1, H2, W2]
+                pooled_2d_level2_flat = pooled_2d_level2.squeeze(1).view(batch_size, -1) # [B, final_effective_pooled_dim]
+                # Repeat this global vector for each segment "slot"
+                pooled_latent_to_return = pooled_2d_level2_flat.unsqueeze(1).repeat(1, self.num_effective_segments, 1)
+            else:
+                pooled_latent_to_return = level1_concat
+        else:
+            raise ValueError(f"Unknown pooling_type: {self.pooling_type}")
+            
+        return pooled_latent_to_return
+
+
+    def forward(self, x, batch, conditioner_ref_frame, use_override=True):
+        """
+        x: Input atom embeddings [B*N_nodes, input_dim] from HNO.
+        batch: PyG batch object (not directly used if B*N_nodes is given).
+        conditioner_ref_frame: Conditioner tensor [num_nodes, conditioner_dim_expected] (e.g., X_ref or z_ref).
+        """
+        current_dev = x.device
+        B_times_N, _ = x.shape # x is [B*N, D_in]
+        
+        if B_times_N == 0: # Handle empty batch
+            logger.warning("Decoder2 forward received an empty input tensor x.")
+            return torch.empty(0, 3, device=current_dev, dtype=x.dtype)
+            
+        batch_size = B_times_N // self.num_nodes
+        if batch_size * self.num_nodes != B_times_N:
+            raise ValueError(f"Mismatch in x.shape ({x.shape}) vs. num_nodes ({self.num_nodes}) & inferred batch_size ({batch_size})")
+
+        # x_reshaped: [B, num_nodes, input_dim]
+        x_reshaped = x.view(batch_size, self.num_nodes, self.input_dim)
+
+        # Expand conditioner_ref_frame: [num_nodes, D_cond] -> [B, num_nodes, D_cond]
+        conditioner_expanded = conditioner_ref_frame.to(current_dev).unsqueeze(0).expand(batch_size, -1, -1)
+        if conditioner_expanded.shape[2] != self.conditioner_dim_expected:
+            raise ValueError(f"Conditioner dimension mismatch. Expected {self.conditioner_dim_expected}, "
+                             f"got {conditioner_expanded.shape[2]} from conditioner_ref_frame.")
+
+        # 1. Get pooled latent features (before override)
+        # This call uses x, which is the full [B*N, D_in] tensor
+        pooled_latent_for_map = self.get_pooled_latent(x)
+        # pooled_latent_for_map shape: [B, NumEffectiveSegments, FinalEffectivePooledDim]
+
+        # 2. Apply override if specified
+        if use_override and self.generated_arr is not None and self.override_residues:
+            num_avail_override_samples = self.generated_arr.shape[0]
+            if batch_size > num_avail_override_samples:
+                logger.warning(
+                    f"Batch size ({batch_size}) > available override samples ({num_avail_override_samples}). "
+                    f"Using modulo for override indices or disabling. For safety, disabling for this batch."
+                ) # Or implement a strategy like modulo
+            else:
+                arr_slice = self.generated_arr[:batch_size] # Take first B samples
+                arr_tensor = torch.from_numpy(arr_slice).to(current_dev).float() # [B, M, embed_dim_override]
+                
+                # Ensure override embedding dim matches pooled_latent_for_map's feature dim
+                if arr_tensor.shape[2] != pooled_latent_for_map.shape[2]:
+                    logger.error(f"Override embedding dimension ({arr_tensor.shape[2]}) mismatch with "
+                                 f"pooled_latent_for_map dimension ({pooled_latent_for_map.shape[2]}). Skipping override.")
+                else:
+                    for i, r_idx in enumerate(self.override_residues):
+                        if 0 <= r_idx < pooled_latent_for_map.shape[1]: # Check if residue index is valid
+                            pooled_latent_for_map[:, r_idx, :] = arr_tensor[:, i, :]
+                        else:
+                            logger.warning(f"Override residue index {r_idx} is out of bounds for "
+                                           f"pooled_latent_for_map with {pooled_latent_for_map.shape[1]} segments.")
+        
+        # 3. Assemble MLP Input using atom_to_segment_map
+        # atom_to_segment_map has shape [num_nodes]
+        # Its values range from 0 to NumEffectiveSegments-1
+        current_atom_map = self.atom_to_segment_map.to(current_dev)
+        
+        # Filter map if it contains -1 (unmapped atoms) before gathering
+        # This is a safety check; ideally, the map is dense and correct.
+        if (current_atom_map < 0).any():
+            logger.error("atom_to_segment_map contains invalid (negative) indices. This will cause an error.")
+            # Raise error or handle: e.g., create a default feature for these atoms
+            raise IndexError("Invalid indices in atom_to_segment_map")
+
+        # Gather:
+        # pooled_latent_for_map shape: [B, NumEffectiveSegments, FinalEffectivePooledDim]
+        # current_atom_map shape:    [num_nodes]
+        # Result per_atom_pooled_rep: [B, num_nodes, FinalEffectivePooledDim]
+        try:
+            per_atom_pooled_rep = pooled_latent_for_map[:, current_atom_map, :]
+        except IndexError as e:
+            logger.error(f"IndexError during gather operation. pooled_latent_for_map.shape={pooled_latent_for_map.shape}, "
+                         f"max(current_atom_map)={current_atom_map.max() if current_atom_map.numel() > 0 else 'N/A'}. Error: {e}")
+            raise
+
+        # Concatenate with conditioner
+        # conditioner_expanded shape: [B, num_nodes, D_cond]
+        combined_features = torch.cat([per_atom_pooled_rep, conditioner_expanded], dim=-1)
+        # combined_features shape: [B, num_nodes, FinalEffectivePooledDim + D_cond]
+        
+        if combined_features.shape[2] != self.final_mlp_in_dim:
+             raise ValueError(f"MLP input dimension mismatch. Expected {self.final_mlp_in_dim}, "
+                              f"got {combined_features.shape[2]}. Check pooled and conditioner dims.")
+
+        final_mlp_input_flat = combined_features.view(B_times_N, self.final_mlp_in_dim)
+        
+        # 4. Decode
+        X_pred = self.decoder(final_mlp_input_flat)  # [B*N_nodes, 3]
+
+        if args.debug and (not ProteinStateReconstructor2D._logged_forward_once) and logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"[Decoder2:forward] x_in.shape={x.shape}, conditioner_ref_frame.shape={conditioner_ref_frame.shape}")
+            logger.debug(f"  x_reshaped.shape={x_reshaped.shape}, conditioner_expanded.shape={conditioner_expanded.shape}")
+            logger.debug(f"  pooled_latent_for_map.shape={pooled_latent_for_map.shape}")
+            logger.debug(f"  per_atom_pooled_rep.shape={per_atom_pooled_rep.shape}")
+            logger.debug(f"  combined_features.shape={combined_features.shape}")
+            logger.debug(f"  final_mlp_input_flat.shape={final_mlp_input_flat.shape}")
+            logger.debug(f"  X_pred.shape={X_pred.shape}")
+            ProteinStateReconstructor2D._logged_forward_once = True
+            sys.stdout.flush()
+
+        return X_pred
+
+
+################################################################################
+# Train Decoder2
+################################################################################
+def train_protein_state_reconstructor(
+    model,
+    train_loader,
+    test_loader,
+    num_epochs,
+    learning_rate,
+    checkpoint_path,
+    conditioner_data, # This is the reference frame data (X_ref or z_ref) [N_nodes, D_cond]
+    save_interval=10,
+    weight_value=1.0, # Not explicitly used in this version's loss, but kept for signature
+):
+    model = model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    criterion = nn.MSELoss()
+
+    model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path)
+    if start_epoch >= num_epochs:
+        logger.info(f"Decoder2 training already completed up to epoch {start_epoch}/{num_epochs}. Skipping training.")
+        model.eval()
+        return model
+
+    logger.info(
+        f"Starting Decoder2 from epoch {start_epoch + 1}, total epochs={num_epochs}, LR={learning_rate}"
+    )
+    sys.stdout.flush()
+
+    # conditioner_data is already on CPU, move to device once if static, or pass as is
+    # The model's forward pass will move it to x.device
+
+    for epoch in range(start_epoch, num_epochs):
+        model.train()
+        total_loss = 0
+        num_batches = len(train_loader)
+        if num_batches == 0:
+            logger.warning("Train loader is empty for Decoder2. Skipping epoch.")
+            continue
+
+        for data in train_loader: # data.x is HNO embeddings, data.coords is GT
+            data = data.to(device)
+            optimizer.zero_grad()
+            # Pass the single reference frame conditioner_data
+            X_pred = model(data.x, data.batch, conditioner_data)
+            coords_gt = data.coords
+            loss = criterion(X_pred, coords_gt)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        avg_loss = total_loss / num_batches
+
+        model.eval()
+        test_loss = 0
+        num_test_batches = len(test_loader)
+        if num_test_batches == 0:
+            logger.warning("Test loader is empty for Decoder2.")
+            avg_test_loss = 0.0
+        else:
+            with torch.no_grad():
+                for data in test_loader:
+                    data = data.to(device)
+                    X_pred = model(data.x, data.batch, conditioner_data)
+                    coords_gt = data.coords
+                    val_loss = criterion(X_pred, coords_gt)
+                    test_loss += val_loss.item()
+            avg_test_loss = test_loss / num_test_batches
+
+        logger.info(
+            f"[Decoder2] Epoch {epoch+1}/{num_epochs} => Train Loss={avg_loss:.6f}, Test Loss={avg_test_loss:.6f}"
+        )
+        sys.stdout.flush()
+
+        if (epoch + 1) % save_interval == 0 or (epoch+1) == num_epochs:
+            checkpoint_state = {
+                "epoch": epoch + 1,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+            }
+            save_checkpoint(checkpoint_state, checkpoint_path)
+            logger.info(
+                f"Decoder2 checkpoint saved at epoch {epoch+1} -> {checkpoint_path}"
+            )
+            sys.stdout.flush()
+    model.eval()
+    return model
+
+################################################################################
+# Main Execution
+################################################################################
+if __name__ == "__main__":
+    logger.info("Starting main script execution (Optimized Decoder)...")
+    sys.stdout.flush()
+
+    coords_per_frame, original_residue_atom_indices = load_heavy_atom_coords_from_json(json_path)
+    if not coords_per_frame:
+        logger.error("Failed to load coordinates. Exiting.")
+        sys.exit(1)
+
+    logger.info("Remapping residue_atom_indices to contiguous IDs...")
+    sys.stdout.flush()
+    # new_residue_indices contains atom indices remapped from 0 to N-1
+    # old2new_map maps original atom IDs to these new 0..N-1 indices
+    new_residue_indices, old2new_map = remap_residue_indices(original_residue_atom_indices)
+    num_unique_atoms = len(old2new_map)
+    if num_unique_atoms == 0:
+        logger.error("No unique atoms found after remapping. Exiting.")
+        sys.exit(1)
+    logger.info(f"Number of unique atoms after reindexing: {num_unique_atoms}")
+    sys.stdout.flush()
+    
+    if not new_residue_indices and d2_pooling_type == "residue":
+        logger.error("Residue pooling selected, but no residue definitions found after remapping. Exiting.")
+        sys.exit(1)
+
+
+    aligned_frames = align_frames_to_first(coords_per_frame)
+    if not aligned_frames:
+        logger.error("Frame alignment failed. Exiting.")
+        sys.exit(1)
+
+    dataset = build_graph_dataset(aligned_frames, knn_neighbors=knn_value)
+    if not dataset:
+        logger.error("Dataset construction failed. Exiting.")
+        sys.exit(1)
+        
+    first_data = dataset[0]
+    if args.debug:
+        logger.debug(f"Atom Indices Mapping (old -> new, sample): {list(old2new_map.items())[:5]}")
+        logger.debug(f"First 5 atoms in data.x (remapped coords): {first_data.x[:5]}")
+        sys.stdout.flush()
+
+    logger.info(f"Dataset size: {len(dataset)} frames.")
+    sys.stdout.flush()
+
+    train_dataset_hno, test_dataset_hno = train_test_split(dataset, test_size=0.1, random_state=42)
+    # Ensure num_workers and pin_memory are used if configured globally
+    num_workers_config = config.get("num_workers", 0)
+    pin_memory_config = True if device == "cuda" else False
+
+    train_loader_hno = DataLoader(
+        train_dataset_hno, batch_size=decoder1_bsize, shuffle=True, # Shuffle train
+        num_workers=num_workers_config, pin_memory=pin_memory_config, drop_last=True
+    )
+    test_loader_hno = DataLoader(
+        test_dataset_hno, batch_size=decoder1_bsize, shuffle=False,
+        num_workers=num_workers_config, pin_memory=pin_memory_config
+    )
+
+    hno_model = HNO(hidden_dim, cheb_order)
+    hno_ckpt_path = os.path.join(checkpoint_dir, "hno_checkpoint.pth")
+    logger.info(
+        f"Training HNO => epochs={decoder1_epochs}, LR={decoder1_lr}, bsize={decoder1_bsize}"
+    )
+    sys.stdout.flush()
+    hno_model = train_hno_model( # Reassign to get the potentially loaded/trained model
+        hno_model,
+        train_loader_hno,
+        test_loader_hno,
+        num_epochs=decoder1_epochs,
+        learning_rate=decoder1_lr,
+        checkpoint_path=hno_ckpt_path,
+        save_interval=config.get("hno_save_interval", 10),
+    )
+
+    if recon_output == 1: # Save HNO outputs
+        logger.info("Generating HNO reconstructions & latent embeddings for entire dataset...")
+        sys.stdout.flush()
+        hno_model.eval()
+        hno_recon_path = os.path.join(structures_dir, "hno_reconstructed_coords.h5")
+        hno_latent_path = os.path.join(latent_reps_dir, "hno_latent_embeddings.h5")
+        
+        # Use the full dataset for HNO output generation for consistency, not just train split
+        num_samples_hno_output = len(dataset) 
+        hno_output_loader = DataLoader(dataset, batch_size=decoder1_bsize, shuffle=False, 
+                                       num_workers=num_workers_config, pin_memory=pin_memory_config)
+
+        pooled_dim_hno = hidden_dim
+
+        with h5py.File(hno_recon_path, "w") as recon_h5, h5py.File(hno_latent_path, "w") as latent_h5:
+            recon_dset_hno = recon_h5.create_dataset(
+                "reconstructions", shape=(num_samples_hno_output, num_unique_atoms, 3), dtype="float32"
+            )
+            latent_dset_hno = latent_h5.create_dataset(
+                "latent_embeddings", shape=(num_samples_hno_output, num_unique_atoms, pooled_dim_hno), dtype="float32"
+            )
+            
+            current_idx_hno = 0
+            with torch.no_grad():
+                for data_batch in hno_output_loader:
+                    data_batch = data_batch.to(device)
+                    # HNO's forward_representation gives normalized embeddings
+                    latent_batch = hno_model.forward_representation(data_batch.x, data_batch.edge_index)
+                    # HNO's forward gives reconstructed coordinates
+                    reconstruction_batch = hno_model(data_batch.x, data_batch.edge_index)
+
+                    batch_actual_size = data_batch.num_graphs # Number of graphs in this batch
+
+                    # Correctly slice and store batched outputs
+                    start = current_idx_hno
+                    end = current_idx_hno + batch_actual_size
+                    
+                    # Assuming data_batch.x are ground truth coordinates for these reconstructions
+                    # This might be slightly off if recon_output==2's intent was to save GT as well.
+                    # The original code saved data.x, which could be ground truth or a previous reconstruction.
+                    # Let's save the actual reconstructions.
+                    recon_dset_hno[start:end] = reconstruction_batch.view(batch_actual_size, num_unique_atoms, 3).cpu().numpy()
+                    latent_dset_hno[start:end] = latent_batch.view(batch_actual_size, num_unique_atoms, pooled_dim_hno).cpu().numpy()
+                    current_idx_hno = end
+        logger.info(f"HNO outputs saved. Reconstructions: {hno_recon_path}, Latents: {hno_latent_path}")
+
+
+    logger.info("Preparing dataset for Decoder2 using HNO latent embeddings...")
+    sys.stdout.flush()
+    decoder2_input_dataset = [] # data.x will be HNO embeddings, data.coords GT coords
+    hno_model.eval() # Ensure HNO is in eval mode
+    
+    # Use a DataLoader for efficient batch processing for generating decoder inputs
+    decoder_input_gen_loader = DataLoader(dataset, batch_size=decoder1_bsize, shuffle=False,
+                                          num_workers=num_workers_config, pin_memory=pin_memory_config)
+    with torch.no_grad():
+        for data_batch in decoder_input_gen_loader:
+            # data_batch contains original x (coords), edge_index, y (coords)
+            data_batch_dev = data_batch.to(device)
+            # Generate latent embeddings (these will be input 'x' to the decoder)
+            latent_embeddings_batch = hno_model.forward_representation(data_batch_dev.x, data_batch_dev.edge_index)
+            
+            # Split batched embeddings and original coordinates (data.y) back into individual Data objects
+            # batch.ptr is [0, N1, N1+N2, ...], counts are N1, N2, ...
+            counts = data_batch.ptr[1:] - data_batch.ptr[:-1]
+            num_graphs_in_batch = data_batch.num_graphs
+
+            current_pos_emb = 0
+            current_pos_y = 0
+            for i in range(num_graphs_in_batch):
+                num_nodes_this_graph = counts[i].item()
+                
+                emb_this_graph = latent_embeddings_batch[current_pos_emb : current_pos_emb + num_nodes_this_graph]
+                coords_this_graph = data_batch.y[current_pos_y : current_pos_y + num_nodes_this_graph] # Original y from dataset
+                edge_idx_this_graph = data_batch.edge_index # This needs careful handling if edge_indices are different per graph
+                                                          # For kNN on full graphs, they are different.
+                                                          # PyG DataLoader handles batching of edge_index.
+                                                          # When splitting, we need to get the original edge_index for this graph.
+                                                          # This is complex if not careful.
+                                                          # Simpler: iterate original dataset if edge_index is critical for decoder directly.
+                                                          # However, decoder2 here doesn't use edge_index.
+
+                # Create new Data object for decoder: x=embedding, coords=original_coords_GT
+                # We don't need edge_index for ProteinStateReconstructor2D's forward pass
+                d = Data(x=emb_this_graph.cpu(), coords=coords_this_graph.cpu())
+                decoder2_input_dataset.append(d)
+                
+                current_pos_emb += num_nodes_this_graph
+                current_pos_y += num_nodes_this_graph
+
+
+    if not decoder2_input_dataset:
+        logger.error("Decoder2 input dataset is empty. Exiting.")
+        sys.exit(1)
+
+    train_data_d2, test_data_d2 = train_test_split(decoder2_input_dataset, test_size=0.1, random_state=42)
+    train_loader_d2 = DataLoader(
+        train_data_d2, batch_size=decoder2_bsize, shuffle=True, # Shuffle train
+        num_workers=num_workers_config, pin_memory=pin_memory_config, drop_last=True
+    )
+    test_loader_d2 = DataLoader(
+        test_data_d2, batch_size=decoder2_bsize, shuffle=False,
+        num_workers=num_workers_config, pin_memory=pin_memory_config
+    )
+
+    # Prepare the "conditioner" data (single reference frame)
+    X_ref_raw_coords = dataset[0].x.cpu() # Shape [num_unique_atoms, 3], on CPU
+    conditioner_data_for_training = None # This will be [N_nodes, D_cond] on CPU
+
+    if conditioner_mode == "X_ref":
+        conditioner_data_for_training = X_ref_raw_coords
+        logger.info(f"Using raw X_ref (shape {X_ref_raw_coords.shape}) as conditioner.")
+        sys.stdout.flush()
+    elif conditioner_mode == "z_ref":
+        hno_model.eval() # Ensure HNO is in eval mode
+        with torch.no_grad():
+            # Compute z_ref using the first graph from the original dataset
+            ref_graph_dev = dataset[0].to(device)
+            X_ref_emb = hno_model.forward_representation(ref_graph_dev.x, ref_graph_dev.edge_index)
+        conditioner_data_for_training = X_ref_emb.cpu() # Keep on CPU
+        logger.info(f"Using z_ref (shape {conditioner_data_for_training.shape}) as conditioner.")
+        sys.stdout.flush()
+    else:
+        logger.error(f"Invalid conditioner_mode: {conditioner_mode}. Choose 'X_ref' or 'z_ref'.")
+        sys.exit(1)
+
+    # num_nodes for the decoder is num_unique_atoms
+    np.save(os.path.join(structures_dir, "X_ref_coords.npy"), X_ref_raw_coords.numpy())
+    if conditioner_mode == "z_ref":
+        np.save(os.path.join(latent_reps_dir, "z_ref_embedding.npy"), conditioner_data_for_training.numpy())
+
+
+    d2_ckpt_path = os.path.join(checkpoint_dir, f"decoder2_{d2_pooling_type}.pth")
+    if d2_pooling_type == "residue" and use_second_level_pooling:
+         d2_ckpt_path = os.path.join(checkpoint_dir, f"decoder2_{d2_pooling_type}_2level.pth")
+
+
+    logger.info(
+        f"Creating ProteinStateReconstructor2D with pooling_type={d2_pooling_type}, "
+        f"num_nodes={num_unique_atoms}, "
+        f"conditioner_mode={conditioner_mode}, second_level_pooling={use_second_level_pooling}."
+    )
+    sys.stdout.flush()
+
+    protein_state_model_2d = ProteinStateReconstructor2D(
+        input_dim=hidden_dim, # HNO's output embedding dim
+        num_nodes=num_unique_atoms,
+        pooling_type=d2_pooling_type,
+        residue_atom_indices=new_residue_indices if d2_pooling_type == "residue" else None,
+        output_size_per_segment=(d2_output_height, d2_output_width),
+        second_level_output_size=(d2_output_height2, d2_output_width2) if d2_output_height2 and d2_output_width2 else None,
+        use_second_level_pooling=use_second_level_pooling,
+        use_cross_attention=use_cross_attention, # Retained for signature
+        cross_attention_type=cross_attention_type, # Retained for signature
+        conditioner_mode=conditioner_mode,
+        num_hidden_layers=d2_num_hidden_layers,
+        mlp_hidden_dim=config["decoder2_settings"].get("mlp_hidden_dim", 128), # Get mlp hidden dim from config
+        override_residues=override_residues_config,
+        special_res_file=special_res_file_config
+    )
+
+    logger.info(
+        f"Training Decoder2 => epochs={decoder2_epochs}, LR={decoder2_lr}, bsize={decoder2_bsize}"
+    )
+    sys.stdout.flush()
+    protein_state_model_2d = train_protein_state_reconstructor( # Reassign
+        protein_state_model_2d,
+        train_loader_d2,
+        test_loader_d2,
+        num_epochs=decoder2_epochs,
+        learning_rate=decoder2_lr,
+        checkpoint_path=d2_ckpt_path,
+        conditioner_data=conditioner_data_for_training, # Pass the CPU tensor
+        save_interval=config.get("decoder2_save_interval", 10),
+        weight_value=d2_weight_value,
+    )
+
+    if recon_output == 1: # Save Decoder2 outputs
+        logger.info("Generating Decoder2 reconstructions on the full dataset (using optimized model)...")
+        sys.stdout.flush()
+
+        dec2_recon_path = os.path.join(
+            structures_dir, f"decoder2_output_{d2_pooling_type}_{conditioner_mode}.h5"
+        )
+        protein_state_model_2d.eval() # Ensure model is in eval mode
+
+        # Use the full decoder2_input_dataset for generating outputs
+        num_samples_dec2_output = len(decoder2_input_dataset)
+        dec2_output_loader = DataLoader(decoder2_input_dataset, batch_size=decoder2_bsize, shuffle=False,
+                                        num_workers=num_workers_config, pin_memory=pin_memory_config)
+
+
+        with h5py.File(dec2_recon_path, "w") as recon_h5:
+            dset_with_override = recon_h5.create_dataset(
+                "reconstructions_with_override", shape=(num_samples_dec2_output, num_unique_atoms, 3), dtype="float32"
+            )
+            dset_no_override = recon_h5.create_dataset(
+                "reconstructions_no_override", shape=(num_samples_dec2_output, num_unique_atoms, 3), dtype="float32"
+            )
+            dset_ground_truth = recon_h5.create_dataset(
+                "ground_truth_coords", shape=(num_samples_dec2_output, num_unique_atoms, 3), dtype="float32"
+            )
+
+
+            logger.debug(f"HDF5 dataset for Decoder2 outputs created.")
+            sys.stdout.flush()
+
+            current_idx_d2 = 0
+            with torch.no_grad():
+                for data_batch in dec2_output_loader: # data_batch.x are embeddings, data_batch.coords are GT
+                    data_batch_dev = data_batch.to(device)
+                    
+                    # Call forward with override
+                    X_pred_override = protein_state_model_2d(
+                        data_batch_dev.x, data_batch_dev.batch, conditioner_data_for_training, use_override=True
+                    )
+                    # Call forward without override
+                    X_pred_no_override = protein_state_model_2d(
+                        data_batch_dev.x, data_batch_dev.batch, conditioner_data_for_training, use_override=False
+                    )
+
+                    batch_actual_size = X_pred_override.shape[0] // num_unique_atoms # Infer from output
+
+                    start = current_idx_d2
+                    end = current_idx_d2 + batch_actual_size
+                    
+                    dset_with_override[start:end] = X_pred_override.view(batch_actual_size, num_unique_atoms, 3).cpu().numpy()
+                    dset_no_override[start:end] = X_pred_no_override.view(batch_actual_size, num_unique_atoms, 3).cpu().numpy()
+                    dset_ground_truth[start:end] = data_batch.coords.view(batch_actual_size, num_unique_atoms, 3).cpu().numpy() # Save GT
+                    
+                    current_idx_d2 = end
+
+                    if args.debug and current_idx_d2 % (10 * decoder2_bsize) < decoder2_bsize : # Log roughly every 10 batches
+                        logger.debug(f"[Decoder2:Generation] Processed {current_idx_d2}/{num_samples_dec2_output} samples.")
+                        sys.stdout.flush()
+            logger.info(f"Decoder2 reconstructions saved to {dec2_recon_path}.")
+            sys.stdout.flush()
+
+    # Generate and Save Pooled Latent Embeddings from Decoder2 (if needed)
+    # This uses the get_pooled_latent method which might show different performance characteristics
+    # if it's not as optimized as the main forward pass, but it's for post-hoc analysis.
+    if config.get("save_decoder2_pooled_latent", True): # Add a config toggle for this
+        logger.info("Generating and saving Decoder2 pooled latent embeddings (full dataset)...")
+        pooled_latent_path_d2 = os.path.join(latent_reps_dir, "decoder2_pooled_latent_embeddings.h5")
+        all_pooled_latents_list = []
+        protein_state_model_2d.eval()
+
+        dec2_pooled_loader = DataLoader(decoder2_input_dataset, batch_size=decoder2_bsize, shuffle=False,
+                                        num_workers=num_workers_config, pin_memory=pin_memory_config)
+        with torch.no_grad():
+            for data_batch in dec2_pooled_loader: # data_batch.x are HNO embeddings
+                data_batch_dev_x = data_batch.x.to(device) # Only need x for get_pooled_latent
+                
+                # get_pooled_latent expects [B*N, D_in] and handles reshape internally
+                # Its output is [B, NumEffectiveSegs, FinalEffectivePooledDim]
+                pooled_lat_batch = protein_state_model_2d.get_pooled_latent(data_batch_dev_x, None)
+                all_pooled_latents_list.append(pooled_lat_batch.cpu().numpy())
+        
+        if all_pooled_latents_list:
+            all_pooled_cat = np.concatenate(all_pooled_latents_list, axis=0)
+            with h5py.File(pooled_latent_path_d2, "w") as latent_h5_d2:
+                latent_h5_d2.create_dataset("pooled_latent", data=all_pooled_cat)
+            logger.info(f"Decoder2 pooled latent embeddings saved to {pooled_latent_path_d2} with shape {all_pooled_cat.shape}")
+        else:
+            logger.warning("No pooled latents generated for Decoder2.")
+        sys.stdout.flush()
+
+
+    logger.info("All tasks completed successfully!")
+    sys.stdout.flush()

LD-FPG-main/residue/helper/backbone_heavy_chain.pdb

@@ -0,0 +1,1093 @@
+HEADER    HEAVY ATOMS - FIRST FRAME
+ATOM      0    N PRO A   1      54.270  48.780  27.280  1.00  0.00            N
+ATOM      6   CA PRO A   1      55.720  48.730  27.580  1.00  0.00           CA
+ATOM     14    C PRO A   1      55.860  48.240  29.020  1.00  0.00            C
+ATOM     15    O PRO A   1      54.930  48.080  29.780  1.00  0.00            O
+ATOM     16    N TYR A   3      57.130  48.190  29.460  1.00  0.00            N
+ATOM     18   CA TYR A   3      57.490  47.630  30.770  1.00  0.00           CA
+ATOM     35    C TYR A   3      58.270  48.630  31.600  1.00  0.00            C
+ATOM     36    O TYR A   3      58.790  48.280  32.670  1.00  0.00            O
+ATOM     37    N ASN A   4      58.270  49.910  31.170  1.00  0.00            N
+ATOM     39   CA ASN A   4      58.800  51.020  31.990  1.00  0.00           CA
+ATOM     49    C ASN A   4      58.040  51.130  33.270  1.00  0.00            C
+ATOM     50    O ASN A   4      58.790  51.480  34.220  1.00  0.00            O
+ATOM     51    N TYR A   5      56.740  50.840  33.400  1.00  0.00            N
+ATOM     53   CA TYR A   5      56.140  50.610  34.650  1.00  0.00           CA
+ATOM     70    C TYR A   5      56.910  49.800  35.740  1.00  0.00            C
+ATOM     71    O TYR A   5      57.240  50.350  36.820  1.00  0.00            O
+ATOM     72    N TYR A   6      57.310  48.530  35.380  1.00  0.00            N
+ATOM     74   CA TYR A   6      58.130  47.700  36.280  1.00  0.00           CA
+ATOM     91    C TYR A   6      59.520  48.280  36.530  1.00  0.00            C
+ATOM     92    O TYR A   6      59.970  48.410  37.670  1.00  0.00            O
+ATOM     93    N ALA A   7      60.260  48.850  35.560  1.00  0.00            N
+ATOM     95   CA ALA A   7      61.450  49.630  35.830  1.00  0.00           CA
+ATOM    101    C ALA A   7      61.260  50.860  36.650  1.00  0.00            C
+ATOM    102    O ALA A   7      62.230  51.190  37.320  1.00  0.00            O
+ATOM    103    N THR A   8      60.100  51.480  36.690  1.00  0.00            N
+ATOM    105   CA THR A   8      59.850  52.500  37.730  1.00  0.00           CA
+ATOM    115    C THR A   8      59.860  51.910  39.160  1.00  0.00            C
+ATOM    116    O THR A   8      60.520  52.430  40.060  1.00  0.00            O
+ATOM    117    N LEU A   9      59.160  50.790  39.390  1.00  0.00            N
+ATOM    119   CA LEU A   9      59.060  50.130  40.690  1.00  0.00           CA
+ATOM    134    C LEU A   9      60.400  49.640  41.240  1.00  0.00            C
+ATOM    135    O LEU A   9      60.720  49.850  42.400  1.00  0.00            O
+ATOM    136    N LEU A  10      61.230  49.030  40.410  1.00  0.00            N
+ATOM    138   CA LEU A  10      62.620  48.670  40.720  1.00  0.00           CA
+ATOM    153    C LEU A  10      63.430  49.950  41.050  1.00  0.00            C
+ATOM    154    O LEU A  10      64.230  49.960  41.950  1.00  0.00            O
+ATOM    155    N THR A  11      63.230  50.990  40.280  1.00  0.00            N
+ATOM    157   CA THR A  11      63.860  52.260  40.480  1.00  0.00           CA
+ATOM    167    C THR A  11      63.520  52.880  41.870  1.00  0.00            C
+ATOM    168    O THR A  11      64.330  53.310  42.680  1.00  0.00            O
+ATOM    169    N LEU A  12      62.320  52.840  42.290  1.00  0.00            N
+ATOM    171   CA LEU A  12      61.910  53.120  43.670  1.00  0.00           CA
+ATOM    186    C LEU A  12      62.330  52.110  44.700  1.00  0.00            C
+ATOM    187    O LEU A  12      62.660  52.520  45.800  1.00  0.00            O
+ATOM    188    N LEU A  13      62.410  50.810  44.450  1.00  0.00            N
+ATOM    190   CA LEU A  13      62.760  49.720  45.380  1.00  0.00           CA
+ATOM    205    C LEU A  13      64.260  49.880  45.810  1.00  0.00            C
+ATOM    206    O LEU A  13      64.580  49.590  46.960  1.00  0.00            O
+ATOM    207    N ILE A  14      65.170  50.270  44.820  1.00  0.00            N
+ATOM    209   CA ILE A  14      66.570  50.580  45.050  1.00  0.00           CA
+ATOM    224    C ILE A  14      66.700  51.720  46.110  1.00  0.00            C
+ATOM    225    O ILE A  14      67.440  51.570  47.060  1.00  0.00            O
+ATOM    226    N ALA A  15      65.850  52.750  45.890  1.00  0.00            N
+ATOM    228   CA ALA A  15      65.730  53.890  46.830  1.00  0.00           CA
+ATOM    234    C ALA A  15      65.300  53.520  48.230  1.00  0.00            C
+ATOM    235    O ALA A  15      65.740  54.120  49.210  1.00  0.00            O
+ATOM    236    N VAL A  16      64.320  52.590  48.440  1.00  0.00            N
+ATOM    238   CA VAL A  16      63.850  52.120  49.730  1.00  0.00           CA
+ATOM    250    C VAL A  16      64.990  51.360  50.410  1.00  0.00            C
+ATOM    251    O VAL A  16      65.370  51.640  51.570  1.00  0.00            O
+ATOM    252    N ILE A  17      65.560  50.420  49.670  1.00  0.00            N
+ATOM    254   CA ILE A  17      66.820  49.650  50.100  1.00  0.00           CA
+ATOM    269    C ILE A  17      67.930  50.630  50.580  1.00  0.00            C
+ATOM    270    O ILE A  17      68.340  50.560  51.710  1.00  0.00            O
+ATOM    271    N VAL A  18      68.340  51.650  49.750  1.00  0.00            N
+ATOM    273   CA VAL A  18      69.370  52.610  50.070  1.00  0.00           CA
+ATOM    285    C VAL A  18      69.060  53.430  51.300  1.00  0.00            C
+ATOM    286    O VAL A  18      69.890  53.590  52.200  1.00  0.00            O
+ATOM    287    N PHE A  19      67.810  54.000  51.370  1.00  0.00            N
+ATOM    289   CA PHE A  19      67.440  54.800  52.570  1.00  0.00           CA
+ATOM    305    C PHE A  19      67.450  54.000  53.900  1.00  0.00            C
+ATOM    306    O PHE A  19      68.110  54.430  54.830  1.00  0.00            O
+ATOM    307    N GLY A  20      66.810  52.860  53.900  1.00  0.00            N
+ATOM    309   CA GLY A  20      66.840  51.890  55.040  1.00  0.00           CA
+ATOM    312    C GLY A  20      68.130  51.570  55.690  1.00  0.00            C
+ATOM    313    O GLY A  20      68.340  51.620  56.900  1.00  0.00            O
+ATOM    314    N ASN A  21      69.110  51.170  54.910  1.00  0.00            N
+ATOM    316   CA ASN A  21      70.270  50.470  55.390  1.00  0.00           CA
+ATOM    326    C ASN A  21      71.450  51.370  55.750  1.00  0.00            C
+ATOM    327    O ASN A  21      72.410  50.990  56.400  1.00  0.00            O
+ATOM    328    N VAL A  22      71.290  52.620  55.360  1.00  0.00            N
+ATOM    330   CA VAL A  22      72.110  53.740  55.810  1.00  0.00           CA
+ATOM    342    C VAL A  22      71.900  54.050  57.320  1.00  0.00            C
+ATOM    343    O VAL A  22      72.830  54.130  58.140  1.00  0.00            O
+ATOM    344    N LEU A  23      70.580  54.150  57.730  1.00  0.00            N
+ATOM    346   CA LEU A  23      70.190  54.210  59.120  1.00  0.00           CA
+ATOM    361    C LEU A  23      70.650  53.040  59.910  1.00  0.00            C
+ATOM    362    O LEU A  23      71.140  53.250  61.030  1.00  0.00            O
+ATOM    363    N VAL A  24      70.560  51.750  59.400  1.00  0.00            N
+ATOM    365   CA VAL A  24      71.160  50.630  60.200  1.00  0.00           CA
+ATOM    377    C VAL A  24      72.680  50.750  60.450  1.00  0.00            C
+ATOM    378    O VAL A  24      73.130  50.550  61.580  1.00  0.00            O
+ATOM    379    N CYS A  25      73.420  51.250  59.400  1.00  0.00            N
+ATOM    381   CA CYS A  25      74.850  51.430  59.460  1.00  0.00           CA
+ATOM    388    C CYS A  25      75.260  52.500  60.490  1.00  0.00            C
+ATOM    389    O CYS A  25      76.250  52.440  61.260  1.00  0.00            O
+ATOM    390    N MET A  26      74.450  53.600  60.470  1.00  0.00            N
+ATOM    392   CA MET A  26      74.620  54.720  61.380  1.00  0.00           CA
+ATOM    405    C MET A  26      74.130  54.440  62.750  1.00  0.00            C
+ATOM    406    O MET A  26      74.730  55.040  63.610  1.00  0.00            O
+ATOM    407    N ALA A  27      73.120  53.590  63.020  1.00  0.00            N
+ATOM    409   CA ALA A  27      72.530  53.360  64.320  1.00  0.00           CA
+ATOM    415    C ALA A  27      73.350  52.510  65.220  1.00  0.00            C
+ATOM    416    O ALA A  27      73.600  52.960  66.310  1.00  0.00            O
+ATOM    417    N VAL A  28      73.990  51.430  64.740  1.00  0.00            N
+ATOM    419   CA VAL A  28      75.070  50.740  65.410  1.00  0.00           CA
+ATOM    431    C VAL A  28      76.280  51.640  65.650  1.00  0.00            C
+ATOM    432    O VAL A  28      77.020  51.370  66.620  1.00  0.00            O
+ATOM    433    N SER A  29      76.570  52.660  64.780  1.00  0.00            N
+ATOM    435   CA SER A  29      77.680  53.600  64.920  1.00  0.00           CA
+ATOM    442    C SER A  29      77.330  54.610  66.080  1.00  0.00            C
+ATOM    443    O SER A  29      78.200  54.980  66.890  1.00  0.00            O
+ATOM    444    N ARG A  30      76.140  55.160  66.140  1.00  0.00            N
+ATOM    446   CA ARG A  30      75.750  56.320  66.870  1.00  0.00           CA
+ATOM    466    C ARG A  30      75.110  56.040  68.190  1.00  0.00            C
+ATOM    467    O ARG A  30      74.990  56.860  69.100  1.00  0.00            O
+ATOM    468    N GLU A  31      74.430  54.870  68.290  1.00  0.00            N
+ATOM    470   CA GLU A  31      73.770  54.400  69.470  1.00  0.00           CA
+ATOM    481    C GLU A  31      74.560  53.350  70.240  1.00  0.00            C
+ATOM    482    O GLU A  31      74.910  52.280  69.750  1.00  0.00            O
+ATOM    483    N LYS A  32      74.880  53.620  71.530  1.00  0.00            N
+ATOM    485   CA LYS A  32      75.550  52.690  72.350  1.00  0.00           CA
+ATOM    503    C LYS A  32      74.690  51.530  72.760  1.00  0.00            C
+ATOM    504    O LYS A  32      75.250  50.450  73.060  1.00  0.00            O
+ATOM    505    N ALA A  33      73.370  51.590  72.850  1.00  0.00            N
+ATOM    507   CA ALA A  33      72.460  50.510  73.130  1.00  0.00           CA
+ATOM    513    C ALA A  33      72.520  49.390  72.090  1.00  0.00            C
+ATOM    514    O ALA A  33      72.180  48.210  72.370  1.00  0.00            O
+ATOM    515    N LEU A  34      72.950  49.760  70.820  1.00  0.00            N
+ATOM    517   CA LEU A  34      72.880  48.930  69.650  1.00  0.00           CA
+ATOM    532    C LEU A  34      74.260  48.270  69.360  1.00  0.00            C
+ATOM    533    O LEU A  34      74.510  47.650  68.330  1.00  0.00            O
+ATOM    534    N GLN A  35      75.270  48.550  70.150  1.00  0.00            N
+ATOM    536   CA GLN A  35      76.650  47.980  70.130  1.00  0.00           CA
+ATOM    549    C GLN A  35      76.850  46.730  70.990  1.00  0.00            C
+ATOM    550    O GLN A  35      77.130  46.760  72.180  1.00  0.00            O
+ATOM    551    N THR A  36      76.490  45.570  70.250  1.00  0.00            N
+ATOM    553   CA THR A  36      76.560  44.190  70.700  1.00  0.00           CA
+ATOM    563    C THR A  36      76.800  43.290  69.480  1.00  0.00            C
+ATOM    564    O THR A  36      76.470  43.690  68.380  1.00  0.00            O
+ATOM    565    N THR A  37      77.300  42.060  69.720  1.00  0.00            N
+ATOM    567   CA THR A  37      77.860  41.190  68.710  1.00  0.00           CA
+ATOM    577    C THR A  37      76.960  40.940  67.580  1.00  0.00            C
+ATOM    578    O THR A  37      77.400  40.990  66.470  1.00  0.00            O
+ATOM    579    N THR A  38      75.730  40.640  67.840  1.00  0.00            N
+ATOM    581   CA THR A  38      74.740  40.410  66.820  1.00  0.00           CA
+ATOM    591    C THR A  38      74.540  41.510  65.840  1.00  0.00            C
+ATOM    592    O THR A  38      74.340  41.340  64.610  1.00  0.00            O
+ATOM    593    N ASN A  39      74.740  42.820  66.290  1.00  0.00            N
+ATOM    595   CA ASN A  39      74.350  43.970  65.520  1.00  0.00           CA
+ATOM    605    C ASN A  39      75.460  44.470  64.600  1.00  0.00            C
+ATOM    606    O ASN A  39      75.320  45.100  63.560  1.00  0.00            O
+ATOM    607    N TYR A  40      76.690  44.030  64.950  1.00  0.00            N
+ATOM    609   CA TYR A  40      77.870  44.100  64.140  1.00  0.00           CA
+ATOM    626    C TYR A  40      77.690  43.250  62.860  1.00  0.00            C
+ATOM    627    O TYR A  40      78.020  43.790  61.750  1.00  0.00            O
+ATOM    628    N LEU A  41      77.230  42.060  62.910  1.00  0.00            N
+ATOM    630   CA LEU A  41      77.080  41.170  61.750  1.00  0.00           CA
+ATOM    645    C LEU A  41      75.900  41.590  60.980  1.00  0.00            C
+ATOM    646    O LEU A  41      75.870  41.410  59.790  1.00  0.00            O
+ATOM    647    N ILE A  42      74.910  42.320  61.620  1.00  0.00            N
+ATOM    649   CA ILE A  42      73.760  42.990  60.910  1.00  0.00           CA
+ATOM    664    C ILE A  42      74.200  44.140  60.040  1.00  0.00            C
+ATOM    665    O ILE A  42      73.630  44.310  58.970  1.00  0.00            O
+ATOM    666    N VAL A  43      75.240  44.880  60.420  1.00  0.00            N
+ATOM    668   CA VAL A  43      75.760  45.960  59.600  1.00  0.00           CA
+ATOM    680    C VAL A  43      76.500  45.450  58.380  1.00  0.00            C
+ATOM    681    O VAL A  43      76.420  45.910  57.240  1.00  0.00            O
+ATOM    682    N SER A  44      77.280  44.400  58.620  1.00  0.00            N
+ATOM    684   CA SER A  44      77.820  43.580  57.550  1.00  0.00           CA
+ATOM    691    C SER A  44      76.880  42.930  56.580  1.00  0.00            C
+ATOM    692    O SER A  44      77.130  42.910  55.370  1.00  0.00            O
+ATOM    693    N LEU A  45      75.680  42.430  57.070  1.00  0.00            N
+ATOM    695   CA LEU A  45      74.430  42.060  56.330  1.00  0.00           CA
+ATOM    710    C LEU A  45      73.880  43.290  55.520  1.00  0.00            C
+ATOM    711    O LEU A  45      73.540  43.140  54.340  1.00  0.00            O
+ATOM    712    N ALA A  46      73.750  44.450  56.180  1.00  0.00            N
+ATOM    714   CA ALA A  46      73.220  45.700  55.540  1.00  0.00           CA
+ATOM    720    C ALA A  46      74.120  46.300  54.510  1.00  0.00            C
+ATOM    721    O ALA A  46      73.600  46.810  53.570  1.00  0.00            O
+ATOM    722    N VAL A  47      75.450  46.150  54.610  1.00  0.00            N
+ATOM    724   CA VAL A  47      76.440  46.500  53.590  1.00  0.00           CA
+ATOM    736    C VAL A  47      76.350  45.600  52.410  1.00  0.00            C
+ATOM    737    O VAL A  47      76.370  46.090  51.280  1.00  0.00            O
+ATOM    738    N ALA A  48      76.070  44.300  52.630  1.00  0.00            N
+ATOM    740   CA ALA A  48      75.720  43.440  51.460  1.00  0.00           CA
+ATOM    746    C ALA A  48      74.450  43.930  50.670  1.00  0.00            C
+ATOM    747    O ALA A  48      74.490  43.950  49.430  1.00  0.00            O
+ATOM    748    N ASP A  49      73.400  44.280  51.420  1.00  0.00            N
+ATOM    750   CA ASP A  49      72.220  44.890  50.920  1.00  0.00           CA
+ATOM    758    C ASP A  49      72.500  46.240  50.180  1.00  0.00            C
+ATOM    759    O ASP A  49      71.900  46.590  49.190  1.00  0.00            O
+ATOM    760    N LEU A  50      73.400  47.070  50.740  1.00  0.00            N
+ATOM    762   CA LEU A  50      73.930  48.230  50.070  1.00  0.00           CA
+ATOM    777    C LEU A  50      74.700  47.910  48.800  1.00  0.00            C
+ATOM    778    O LEU A  50      74.400  48.550  47.810  1.00  0.00            O
+ATOM    779    N LEU A  51      75.560  46.910  48.690  1.00  0.00            N
+ATOM    781   CA LEU A  51      76.250  46.560  47.490  1.00  0.00           CA
+ATOM    796    C LEU A  51      75.310  45.880  46.460  1.00  0.00            C
+ATOM    797    O LEU A  51      75.520  46.170  45.290  1.00  0.00            O
+ATOM    798    N VAL A  52      74.170  45.220  46.910  1.00  0.00            N
+ATOM    800   CA VAL A  52      73.080  44.810  46.010  1.00  0.00           CA
+ATOM    812    C VAL A  52      72.500  46.090  45.320  1.00  0.00            C
+ATOM    813    O VAL A  52      72.350  46.120  44.120  1.00  0.00            O
+ATOM    814    N ALA A  53      72.210  47.140  46.150  1.00  0.00            N
+ATOM    816   CA ALA A  53      71.530  48.390  45.700  1.00  0.00           CA
+ATOM    822    C ALA A  53      72.380  49.270  44.750  1.00  0.00            C
+ATOM    823    O ALA A  53      71.940  50.010  43.850  1.00  0.00            O
+ATOM    824    N THR A  54      73.720  49.190  44.950  1.00  0.00            N
+ATOM    826   CA THR A  54      74.670  50.090  44.280  1.00  0.00           CA
+ATOM    836    C THR A  54      75.230  49.550  42.960  1.00  0.00            C
+ATOM    837    O THR A  54      75.360  50.240  41.970  1.00  0.00            O
+ATOM    838    N LEU A  55      75.390  48.170  42.860  1.00  0.00            N
+ATOM    840   CA LEU A  55      76.220  47.480  41.840  1.00  0.00           CA
+ATOM    855    C LEU A  55      75.520  46.280  41.220  1.00  0.00            C
+ATOM    856    O LEU A  55      76.080  45.570  40.360  1.00  0.00            O
+ATOM    857    N VAL A  56      74.350  45.880  41.640  1.00  0.00            N
+ATOM    859   CA VAL A  56      73.570  44.810  41.010  1.00  0.00           CA
+ATOM    871    C VAL A  56      72.410  45.520  40.350  1.00  0.00            C
+ATOM    872    O VAL A  56      72.210  45.500  39.130  1.00  0.00            O
+ATOM    873    N MET A  57      71.650  46.220  41.160  1.00  0.00            N
+ATOM    875   CA MET A  57      70.380  46.800  40.800  1.00  0.00           CA
+ATOM    888    C MET A  57      70.210  47.810  39.660  1.00  0.00            C
+ATOM    889    O MET A  57      69.220  47.660  38.960  1.00  0.00            O
+ATOM    890    N PRO A  58      71.020  48.820  39.420  1.00  0.00            N
+ATOM    894   CA PRO A  58      70.920  49.760  38.300  1.00  0.00           CA
+ATOM    902    C PRO A  58      71.140  49.000  37.010  1.00  0.00            C
+ATOM    903    O PRO A  58      70.660  49.400  36.000  1.00  0.00            O
+ATOM    904    N TRP A  59      71.850  47.800  37.050  1.00  0.00            N
+ATOM    906   CA TRP A  59      71.930  46.940  35.940  1.00  0.00           CA
+ATOM    926    C TRP A  59      70.780  46.130  35.830  1.00  0.00            C
+ATOM    927    O TRP A  59      70.380  45.940  34.680  1.00  0.00            O
+ATOM    928    N VAL A  60      70.170  45.610  36.940  1.00  0.00            N
+ATOM    930   CA VAL A  60      68.950  44.880  36.850  1.00  0.00           CA
+ATOM    942    C VAL A  60      67.810  45.700  36.350  1.00  0.00            C
+ATOM    943    O VAL A  60      67.070  45.330  35.440  1.00  0.00            O
+ATOM    944    N VAL A  61      67.690  46.990  36.760  1.00  0.00            N
+ATOM    946   CA VAL A  61      66.800  47.940  36.130  1.00  0.00           CA
+ATOM    958    C VAL A  61      66.890  48.100  34.690  1.00  0.00            C
+ATOM    959    O VAL A  61      65.990  47.940  33.900  1.00  0.00            O
+ATOM    960    N TYR A  62      68.100  48.360  34.120  1.00  0.00            N
+ATOM    962   CA TYR A  62      68.410  48.560  32.730  1.00  0.00           CA
+ATOM    979    C TYR A  62      67.950  47.440  31.860  1.00  0.00            C
+ATOM    980    O TYR A  62      67.310  47.650  30.840  1.00  0.00            O
+ATOM    981    N LEU A  63      68.200  46.170  32.220  1.00  0.00            N
+ATOM    983   CA LEU A  63      67.800  44.920  31.600  1.00  0.00           CA
+ATOM    998    C LEU A  63      66.250  44.780  31.590  1.00  0.00            C
+ATOM    999    O LEU A  63      65.730  44.240  30.610  1.00  0.00            O
+ATOM   1000    N GLU A  64      65.550  45.200  32.580  1.00  0.00            N
+ATOM   1002   CA GLU A  64      64.130  45.340  32.620  1.00  0.00           CA
+ATOM   1013    C GLU A  64      63.530  46.460  31.690  1.00  0.00            C
+ATOM   1014    O GLU A  64      62.560  46.160  31.000  1.00  0.00            O
+ATOM   1015    N VAL A  65      64.170  47.590  31.400  1.00  0.00            N
+ATOM   1017   CA VAL A  65      63.770  48.650  30.510  1.00  0.00           CA
+ATOM   1029    C VAL A  65      63.740  48.180  29.090  1.00  0.00            C
+ATOM   1030    O VAL A  65      62.770  48.280  28.300  1.00  0.00            O
+ATOM   1031    N VAL A  66      64.800  47.410  28.730  1.00  0.00            N
+ATOM   1033   CA VAL A  66      64.910  47.010  27.290  1.00  0.00           CA
+ATOM   1045    C VAL A  66      64.270  45.640  27.030  1.00  0.00            C
+ATOM   1046    O VAL A  66      64.070  45.260  25.870  1.00  0.00            O
+ATOM   1047    N GLY A  67      63.940  44.930  28.110  1.00  0.00            N
+ATOM   1049   CA GLY A  67      63.170  43.620  27.940  1.00  0.00           CA
+ATOM   1052    C GLY A  67      63.890  42.380  27.510  1.00  0.00            C
+ATOM   1053    O GLY A  67      63.200  41.370  27.250  1.00  0.00            O
+ATOM   1054    N GLU A  68      65.180  42.470  27.260  1.00  0.00            N
+ATOM   1056   CA GLU A  68      65.990  41.400  26.730  1.00  0.00           CA
+ATOM   1067    C GLU A  68      67.490  41.670  27.080  1.00  0.00            C
+ATOM   1068    O GLU A  68      67.790  42.800  27.410  1.00  0.00            O
+ATOM   1069    N TRP A  69      68.330  40.620  27.020  1.00  0.00            N
+ATOM   1071   CA TRP A  69      69.720  40.830  27.550  1.00  0.00           CA
+ATOM   1091    C TRP A  69      70.580  41.540  26.590  1.00  0.00            C
+ATOM   1092    O TRP A  69      70.800  40.980  25.510  1.00  0.00            O
+ATOM   1093    N LYS A  70      71.050  42.790  26.950  1.00  0.00            N
+ATOM   1095   CA LYS A  70      71.680  43.670  25.910  1.00  0.00           CA
+ATOM   1113    C LYS A  70      73.080  44.090  26.320  1.00  0.00            C
+ATOM   1114    O LYS A  70      73.620  45.110  25.780  1.00  0.00            O
+ATOM   1115    N PHE A  71      73.690  43.460  27.290  1.00  0.00            N
+ATOM   1117   CA PHE A  71      75.080  43.710  27.750  1.00  0.00           CA
+ATOM   1133    C PHE A  71      76.080  43.050  26.890  1.00  0.00            C
+ATOM   1134    O PHE A  71      75.970  41.880  26.530  1.00  0.00            O
+ATOM   1135    N SER A  72      77.200  43.790  26.730  1.00  0.00            N
+ATOM   1137   CA SER A  72      78.560  43.230  26.360  1.00  0.00           CA
+ATOM   1144    C SER A  72      79.050  42.050  27.250  1.00  0.00            C
+ATOM   1145    O SER A  72      78.440  41.680  28.280  1.00  0.00            O
+ATOM   1146    N ARG A  73      80.100  41.280  26.910  1.00  0.00            N
+ATOM   1148   CA ARG A  73      80.470  40.150  27.650  1.00  0.00           CA
+ATOM   1168    C ARG A  73      81.140  40.410  28.970  1.00  0.00            C
+ATOM   1169    O ARG A  73      81.270  39.570  29.850  1.00  0.00            O
+ATOM   1170    N ILE A  74      81.270  41.740  29.330  1.00  0.00            N
+ATOM   1172   CA ILE A  74      81.490  42.240  30.670  1.00  0.00           CA
+ATOM   1187    C ILE A  74      80.270  41.990  31.530  1.00  0.00            C
+ATOM   1188    O ILE A  74      80.180  42.260  32.740  1.00  0.00            O
+ATOM   1189    N CYS A  76      79.270  41.320  30.910  1.00  0.00            N
+ATOM   1191   CA CYS A  76      78.160  40.710  31.630  1.00  0.00           CA
+ATOM   1197    C CYS A  76      78.510  39.690  32.650  1.00  0.00            C
+ATOM   1198    O CYS A  76      77.850  39.550  33.670  1.00  0.00            O
+ATOM   1199    N ASP A  77      79.600  38.910  32.400  1.00  0.00            N
+ATOM   1201   CA ASP A  77      80.200  37.970  33.260  1.00  0.00           CA
+ATOM   1209    C ASP A  77      80.470  38.730  34.640  1.00  0.00            C
+ATOM   1210    O ASP A  77      80.130  38.240  35.710  1.00  0.00            O
+ATOM   1211    N ILE A  78      80.990  39.960  34.690  1.00  0.00            N
+ATOM   1213   CA ILE A  78      81.260  40.720  35.870  1.00  0.00           CA
+ATOM   1228    C ILE A  78      80.020  41.010  36.680  1.00  0.00            C
+ATOM   1229    O ILE A  78      80.100  40.780  37.910  1.00  0.00            O
+ATOM   1230    N PHE A  79      79.000  41.470  36.040  1.00  0.00            N
+ATOM   1232   CA PHE A  79      77.620  41.780  36.530  1.00  0.00           CA
+ATOM   1248    C PHE A  79      76.960  40.500  37.120  1.00  0.00            C
+ATOM   1249    O PHE A  79      76.500  40.610  38.210  1.00  0.00            O
+ATOM   1250    N VAL A  80      76.940  39.320  36.430  1.00  0.00            N
+ATOM   1252   CA VAL A  80      76.450  37.990  36.910  1.00  0.00           CA
+ATOM   1264    C VAL A  80      77.240  37.510  38.130  1.00  0.00            C
+ATOM   1265    O VAL A  80      76.650  37.070  39.100  1.00  0.00            O
+ATOM   1266    N THR A  81      78.550  37.720  38.130  1.00  0.00            N
+ATOM   1268   CA THR A  81      79.370  37.480  39.280  1.00  0.00           CA
+ATOM   1278    C THR A  81      79.050  38.310  40.440  1.00  0.00            C
+ATOM   1279    O THR A  81      79.030  37.910  41.620  1.00  0.00            O
+ATOM   1280    N LEU A  82      78.700  39.610  40.210  1.00  0.00            N
+ATOM   1282   CA LEU A  82      78.270  40.570  41.230  1.00  0.00           CA
+ATOM   1297    C LEU A  82      76.960  40.090  41.840  1.00  0.00            C
+ATOM   1298    O LEU A  82      76.890  39.980  43.050  1.00  0.00            O
+ATOM   1299    N ASP A  83      75.940  39.710  41.010  1.00  0.00            N
+ATOM   1301   CA ASP A  83      74.640  39.360  41.380  1.00  0.00           CA
+ATOM   1309    C ASP A  83      74.680  38.100  42.290  1.00  0.00            C
+ATOM   1310    O ASP A  83      74.190  38.140  43.450  1.00  0.00            O
+ATOM   1311    N VAL A  84      75.470  37.100  41.900  1.00  0.00            N
+ATOM   1313   CA VAL A  84      75.670  35.960  42.660  1.00  0.00           CA
+ATOM   1325    C VAL A  84      76.460  36.130  43.960  1.00  0.00            C
+ATOM   1326    O VAL A  84      76.200  35.570  45.040  1.00  0.00            O
+ATOM   1327    N MET A  85      77.530  36.940  43.920  1.00  0.00            N
+ATOM   1329   CA MET A  85      78.320  37.340  45.050  1.00  0.00           CA
+ATOM   1342    C MET A  85      77.560  38.020  46.140  1.00  0.00            C
+ATOM   1343    O MET A  85      77.600  37.530  47.260  1.00  0.00            O
+ATOM   1344    N MET A  86      76.770  39.110  45.910  1.00  0.00            N
+ATOM   1346   CA MET A  86      76.020  39.790  46.890  1.00  0.00           CA
+ATOM   1359    C MET A  86      74.820  38.900  47.350  1.00  0.00            C
+ATOM   1360    O MET A  86      74.430  38.970  48.500  1.00  0.00            O
+ATOM   1361    N CYS A  87      74.250  37.970  46.510  1.00  0.00            N
+ATOM   1363   CA CYS A  87      73.310  36.980  46.940  1.00  0.00           CA
+ATOM   1370    C CYS A  87      73.920  35.990  47.970  1.00  0.00            C
+ATOM   1371    O CYS A  87      73.400  35.700  49.030  1.00  0.00            O
+ATOM   1372    N THR A  88      75.160  35.530  47.690  1.00  0.00            N
+ATOM   1374   CA THR A  88      75.930  34.570  48.460  1.00  0.00           CA
+ATOM   1384    C THR A  88      76.250  35.180  49.840  1.00  0.00            C
+ATOM   1385    O THR A  88      76.060  34.550  50.960  1.00  0.00            O
+ATOM   1386    N ALA A  89      76.770  36.430  49.750  1.00  0.00            N
+ATOM   1388   CA ALA A  89      77.180  37.210  50.970  1.00  0.00           CA
+ATOM   1394    C ALA A  89      76.080  37.480  51.900  1.00  0.00            C
+ATOM   1395    O ALA A  89      76.340  37.590  53.130  1.00  0.00            O
+ATOM   1396    N SER A  90      74.860  37.810  51.360  1.00  0.00            N
+ATOM   1398   CA SER A  90      73.700  37.990  52.150  1.00  0.00           CA
+ATOM   1405    C SER A  90      73.250  36.700  52.960  1.00  0.00            C
+ATOM   1406    O SER A  90      73.130  36.790  54.200  1.00  0.00            O
+ATOM   1407    N ILE A  91      73.120  35.550  52.240  1.00  0.00            N
+ATOM   1409   CA ILE A  91      72.850  34.260  52.870  1.00  0.00           CA
+ATOM   1424    C ILE A  91      73.960  33.790  53.890  1.00  0.00            C
+ATOM   1425    O ILE A  91      73.630  33.320  54.960  1.00  0.00            O
+ATOM   1426    N LEU A  92      75.260  34.030  53.600  1.00  0.00            N
+ATOM   1428   CA LEU A  92      76.310  33.920  54.510  1.00  0.00           CA
+ATOM   1443    C LEU A  92      76.330  34.820  55.740  1.00  0.00            C
+ATOM   1444    O LEU A  92      76.510  34.310  56.830  1.00  0.00            O
+ATOM   1445    N ASN A  93      76.070  36.120  55.620  1.00  0.00            N
+ATOM   1447   CA ASN A  93      75.850  37.010  56.720  1.00  0.00           CA
+ATOM   1457    C ASN A  93      74.660  36.560  57.580  1.00  0.00            C
+ATOM   1458    O ASN A  93      74.760  36.570  58.790  1.00  0.00            O
+ATOM   1459    N LEU A  94      73.510  36.180  57.020  1.00  0.00            N
+ATOM   1461   CA LEU A  94      72.360  35.690  57.700  1.00  0.00           CA
+ATOM   1476    C LEU A  94      72.640  34.450  58.550  1.00  0.00            C
+ATOM   1477    O LEU A  94      72.170  34.350  59.710  1.00  0.00            O
+ATOM   1478    N CYS A  95      73.410  33.520  57.970  1.00  0.00            N
+ATOM   1480   CA CYS A  95      73.940  32.340  58.660  1.00  0.00           CA
+ATOM   1487    C CYS A  95      74.810  32.830  59.820  1.00  0.00            C
+ATOM   1488    O CYS A  95      74.630  32.450  60.970  1.00  0.00            O
+ATOM   1489    N ALA A  96      75.770  33.710  59.640  1.00  0.00            N
+ATOM   1491   CA ALA A  96      76.800  34.200  60.570  1.00  0.00           CA
+ATOM   1497    C ALA A  96      76.210  34.900  61.760  1.00  0.00            C
+ATOM   1498    O ALA A  96      76.570  34.630  62.910  1.00  0.00            O
+ATOM   1499    N ILE A  97      75.160  35.790  61.540  1.00  0.00            N
+ATOM   1501   CA ILE A  97      74.190  36.230  62.460  1.00  0.00           CA
+ATOM   1516    C ILE A  97      73.520  35.170  63.300  1.00  0.00            C
+ATOM   1517    O ILE A  97      73.570  35.160  64.550  1.00  0.00            O
+ATOM   1518    N SER A  98      73.020  34.130  62.650  1.00  0.00            N
+ATOM   1520   CA SER A  98      72.340  32.970  63.250  1.00  0.00           CA
+ATOM   1527    C SER A  98      73.280  32.220  64.190  1.00  0.00            C
+ATOM   1528    O SER A  98      73.000  31.940  65.430  1.00  0.00            O
+ATOM   1529    N ILE A  99      74.560  31.990  63.750  1.00  0.00            N
+ATOM   1531   CA ILE A  99      75.610  31.390  64.570  1.00  0.00           CA
+ATOM   1546    C ILE A  99      75.880  32.200  65.830  1.00  0.00            C
+ATOM   1547    O ILE A  99      75.890  31.590  66.940  1.00  0.00            O
+ATOM   1548    N ASP A 100      75.980  33.540  65.710  1.00  0.00            N
+ATOM   1550   CA ASP A 100      76.090  34.460  66.860  1.00  0.00           CA
+ATOM   1558    C ASP A 100      74.900  34.340  67.860  1.00  0.00            C
+ATOM   1559    O ASP A 100      75.110  34.170  69.060  1.00  0.00            O
+ATOM   1560    N ARG A 101      73.710  34.200  67.380  1.00  0.00            N
+ATOM   1562   CA ARG A 101      72.580  33.890  68.170  1.00  0.00           CA
+ATOM   1582    C ARG A 101      72.680  32.500  68.960  1.00  0.00            C
+ATOM   1583    O ARG A 101      72.560  32.470  70.180  1.00  0.00            O
+ATOM   1584    N TYR A 102      73.020  31.450  68.270  1.00  0.00            N
+ATOM   1586   CA TYR A 102      73.180  30.170  68.840  1.00  0.00           CA
+ATOM   1603    C TYR A 102      74.350  30.180  69.880  1.00  0.00            C
+ATOM   1604    O TYR A 102      74.270  29.620  70.920  1.00  0.00            O
+ATOM   1605    N THR A 103      75.460  31.020  69.600  1.00  0.00            N
+ATOM   1607   CA THR A 103      76.480  31.190  70.560  1.00  0.00           CA
+ATOM   1617    C THR A 103      76.130  31.840  71.900  1.00  0.00            C
+ATOM   1618    O THR A 103      76.430  31.260  72.930  1.00  0.00            O
+ATOM   1619    N ALA A 104      75.320  32.960  71.840  1.00  0.00            N
+ATOM   1621   CA ALA A 104      74.760  33.760  72.920  1.00  0.00           CA
+ATOM   1627    C ALA A 104      73.680  33.040  73.670  1.00  0.00            C
+ATOM   1628    O ALA A 104      73.600  33.080  74.900  1.00  0.00            O
+ATOM   1629    N VAL A 105      72.900  32.180  73.000  1.00  0.00            N
+ATOM   1631   CA VAL A 105      71.940  31.240  73.540  1.00  0.00           CA
+ATOM   1643    C VAL A 105      72.680  30.160  74.340  1.00  0.00            C
+ATOM   1644    O VAL A 105      72.290  29.770  75.410  1.00  0.00            O
+ATOM   1645    N ALA A 106      73.860  29.660  73.830  1.00  0.00            N
+ATOM   1647   CA ALA A 106      74.650  28.560  74.370  1.00  0.00           CA
+ATOM   1653    C ALA A 106      75.280  28.830  75.730  1.00  0.00            C
+ATOM   1654    O ALA A 106      75.250  28.000  76.640  1.00  0.00            O
+ATOM   1655    N MET A 107      75.770  30.060  75.960  1.00  0.00            N
+ATOM   1657   CA MET A 107      76.370  30.580  77.170  1.00  0.00           CA
+ATOM   1670    C MET A 107      76.040  32.050  77.480  1.00  0.00            C
+ATOM   1671    O MET A 107      76.080  32.840  76.510  1.00  0.00            O
+ATOM   1672    N PRO A 108      75.660  32.410  78.660  1.00  0.00            N
+ATOM   1676   CA PRO A 108      75.580  33.760  79.100  1.00  0.00           CA
+ATOM   1684    C PRO A 108      76.980  34.470  78.940  1.00  0.00            C
+ATOM   1685    O PRO A 108      78.060  33.830  78.820  1.00  0.00            O
+ATOM   1686    N MET A 109      77.030  35.840  78.860  1.00  0.00            N
+ATOM   1688   CA MET A 109      78.230  36.570  78.520  1.00  0.00           CA
+ATOM   1701    C MET A 109      79.100  36.720  79.740  1.00  0.00            C
+ATOM   1702    O MET A 109      78.740  37.130  80.840  1.00  0.00            O
+ATOM   1703    N LEU A 110      80.400  36.450  79.570  1.00  0.00            N
+ATOM   1705   CA LEU A 110      81.280  36.410  80.680  1.00  0.00           CA
+ATOM   1720    C LEU A 110      82.490  37.380  80.390  1.00  0.00            C
+ATOM   1721    O LEU A 110      82.470  37.950  79.310  1.00  0.00            O
+ATOM   1722    N TYR A 111      83.510  37.550  81.290  1.00  0.00            N
+ATOM   1724   CA TYR A 111      84.700  38.380  81.190  1.00  0.00           CA
+ATOM   1741    C TYR A 111      85.580  38.110  79.980  1.00  0.00            C
+ATOM   1742    O TYR A 111      86.030  39.020  79.280  1.00  0.00            O
+ATOM   1743    N ASN A 112      85.870  36.800  79.660  1.00  0.00            N
+ATOM   1745   CA ASN A 112      86.670  36.340  78.530  1.00  0.00           CA
+ATOM   1755    C ASN A 112      85.850  36.660  77.270  1.00  0.00            C
+ATOM   1756    O ASN A 112      86.480  36.980  76.310  1.00  0.00            O
+ATOM   1757    N THR A 113      84.520  36.540  77.260  1.00  0.00            N
+ATOM   1759   CA THR A 113      83.660  36.840  76.090  1.00  0.00           CA
+ATOM   1769    C THR A 113      83.740  38.240  75.560  1.00  0.00            C
+ATOM   1770    O THR A 113      83.870  38.490  74.370  1.00  0.00            O
+ATOM   1771    N ARG A 114      83.720  39.230  76.460  1.00  0.00            N
+ATOM   1773   CA ARG A 114      83.880  40.630  76.230  1.00  0.00           CA
+ATOM   1793    C ARG A 114      85.380  41.020  75.860  1.00  0.00            C
+ATOM   1794    O ARG A 114      85.610  42.080  75.320  1.00  0.00            O
+ATOM   1795    N TYR A 115      86.400  40.230  76.130  1.00  0.00            N
+ATOM   1797   CA TYR A 115      87.720  40.530  75.670  1.00  0.00           CA
+ATOM   1814    C TYR A 115      88.010  39.790  74.350  1.00  0.00            C
+ATOM   1815    O TYR A 115      89.170  39.530  73.900  1.00  0.00            O
+ATOM   1816    N SER A 116      86.970  39.190  73.760  1.00  0.00            N
+ATOM   1818   CA SER A 116      87.190  38.280  72.670  1.00  0.00           CA
+ATOM   1825    C SER A 116      86.090  38.450  71.700  1.00  0.00            C
+ATOM   1826    O SER A 116      86.240  37.960  70.570  1.00  0.00            O
+ATOM   1827    N SER A 117      85.030  39.220  72.020  1.00  0.00            N
+ATOM   1829   CA SER A 117      83.760  39.280  71.270  1.00  0.00           CA
+ATOM   1836    C SER A 117      83.980  39.870  69.920  1.00  0.00            C
+ATOM   1837    O SER A 117      83.480  39.420  68.930  1.00  0.00            O
+ATOM   1838    N LYS A 118      84.670  40.990  69.870  1.00  0.00            N
+ATOM   1840   CA LYS A 118      84.840  41.650  68.570  1.00  0.00           CA
+ATOM   1858    C LYS A 118      86.010  40.980  67.810  1.00  0.00            C
+ATOM   1859    O LYS A 118      86.050  41.000  66.580  1.00  0.00            O
+ATOM   1860    N ARG A 119      86.870  40.180  68.570  1.00  0.00            N
+ATOM   1862   CA ARG A 119      87.890  39.370  68.050  1.00  0.00           CA
+ATOM   1882    C ARG A 119      87.370  38.220  67.220  1.00  0.00            C
+ATOM   1883    O ARG A 119      87.810  37.940  66.050  1.00  0.00            O
+ATOM   1884    N ARG A 120      86.330  37.610  67.730  1.00  0.00            N
+ATOM   1886   CA ARG A 120      85.510  36.650  67.050  1.00  0.00           CA
+ATOM   1906    C ARG A 120      84.820  37.280  65.880  1.00  0.00            C
+ATOM   1907    O ARG A 120      84.860  36.690  64.800  1.00  0.00            O
+ATOM   1908    N VAL A 121      84.110  38.430  66.080  1.00  0.00            N
+ATOM   1910   CA VAL A 121      83.230  39.000  65.100  1.00  0.00           CA
+ATOM   1922    C VAL A 121      83.980  39.400  63.850  1.00  0.00            C
+ATOM   1923    O VAL A 121      83.500  39.080  62.760  1.00  0.00            O
+ATOM   1924    N THR A 122      85.130  40.120  64.010  1.00  0.00            N
+ATOM   1926   CA THR A 122      85.890  40.410  62.790  1.00  0.00           CA
+ATOM   1936    C THR A 122      86.390  39.220  61.910  1.00  0.00            C
+ATOM   1937    O THR A 122      86.410  39.250  60.680  1.00  0.00            O
+ATOM   1938    N VAL A 123      86.840  38.110  62.610  1.00  0.00            N
+ATOM   1940   CA VAL A 123      87.130  36.870  61.940  1.00  0.00           CA
+ATOM   1952    C VAL A 123      85.940  36.230  61.180  1.00  0.00            C
+ATOM   1953    O VAL A 123      86.040  35.830  59.970  1.00  0.00            O
+ATOM   1954    N MET A 124      84.730  36.230  61.770  1.00  0.00            N
+ATOM   1956   CA MET A 124      83.560  35.770  61.050  1.00  0.00           CA
+ATOM   1969    C MET A 124      83.220  36.490  59.830  1.00  0.00            C
+ATOM   1970    O MET A 124      82.750  35.890  58.870  1.00  0.00            O
+ATOM   1971    N ILE A 125      83.320  37.820  59.870  1.00  0.00            N
+ATOM   1973   CA ILE A 125      82.970  38.820  58.810  1.00  0.00           CA
+ATOM   1988    C ILE A 125      83.970  38.630  57.570  1.00  0.00            C
+ATOM   1989    O ILE A 125      83.630  38.570  56.430  1.00  0.00            O
+ATOM   1990    N SER A 126      85.240  38.530  57.920  1.00  0.00            N
+ATOM   1992   CA SER A 126      86.360  38.190  57.030  1.00  0.00           CA
+ATOM   1999    C SER A 126      86.120  36.840  56.360  1.00  0.00            C
+ATOM   2000    O SER A 126      86.220  36.740  55.160  1.00  0.00            O
+ATOM   2001    N ILE A 127      85.730  35.800  57.200  1.00  0.00            N
+ATOM   2003   CA ILE A 127      85.340  34.470  56.620  1.00  0.00           CA
+ATOM   2018    C ILE A 127      84.100  34.540  55.720  1.00  0.00            C
+ATOM   2019    O ILE A 127      84.240  33.890  54.650  1.00  0.00            O
+ATOM   2020    N VAL A 128      83.090  35.330  56.040  1.00  0.00            N
+ATOM   2022   CA VAL A 128      81.940  35.630  55.140  1.00  0.00           CA
+ATOM   2034    C VAL A 128      82.310  36.220  53.760  1.00  0.00            C
+ATOM   2035    O VAL A 128      82.030  35.680  52.740  1.00  0.00            O
+ATOM   2036    N TRP A 129      83.110  37.340  53.750  1.00  0.00            N
+ATOM   2038   CA TRP A 129      83.580  37.920  52.470  1.00  0.00           CA
+ATOM   2058    C TRP A 129      84.470  37.070  51.580  1.00  0.00            C
+ATOM   2059    O TRP A 129      84.280  37.060  50.360  1.00  0.00            O
+ATOM   2060    N VAL A 130      85.430  36.300  52.250  1.00  0.00            N
+ATOM   2062   CA VAL A 130      86.340  35.360  51.590  1.00  0.00           CA
+ATOM   2074    C VAL A 130      85.510  34.170  51.010  1.00  0.00            C
+ATOM   2075    O VAL A 130      85.750  33.740  49.860  1.00  0.00            O
+ATOM   2076    N LEU A 131      84.590  33.620  51.840  1.00  0.00            N
+ATOM   2078   CA LEU A 131      83.720  32.520  51.470  1.00  0.00           CA
+ATOM   2093    C LEU A 131      82.810  32.910  50.360  1.00  0.00            C
+ATOM   2094    O LEU A 131      82.790  32.280  49.300  1.00  0.00            O
+ATOM   2095    N SER A 132      82.190  34.090  50.420  1.00  0.00            N
+ATOM   2097   CA SER A 132      81.530  34.630  49.250  1.00  0.00           CA
+ATOM   2104    C SER A 132      82.480  34.850  48.020  1.00  0.00            C
+ATOM   2105    O SER A 132      82.030  34.520  46.920  1.00  0.00            O
+ATOM   2106    N PHE A 133      83.640  35.390  48.140  1.00  0.00            N
+ATOM   2108   CA PHE A 133      84.620  35.430  47.010  1.00  0.00           CA
+ATOM   2124    C PHE A 133      84.870  34.010  46.410  1.00  0.00            C
+ATOM   2125    O PHE A 133      84.620  33.850  45.240  1.00  0.00            O
+ATOM   2126    N THR A 134      85.350  32.980  47.180  1.00  0.00            N
+ATOM   2128   CA THR A 134      85.650  31.670  46.640  1.00  0.00           CA
+ATOM   2138    C THR A 134      84.500  30.980  45.910  1.00  0.00            C
+ATOM   2139    O THR A 134      84.600  30.340  44.870  1.00  0.00            O
+ATOM   2140    N ILE A 135      83.260  31.100  46.490  1.00  0.00            N
+ATOM   2142   CA ILE A 135      82.030  30.620  45.790  1.00  0.00           CA
+ATOM   2157    C ILE A 135      81.780  31.420  44.500  1.00  0.00            C
+ATOM   2158    O ILE A 135      81.410  30.810  43.470  1.00  0.00            O
+ATOM   2159    N SER A 136      81.960  32.740  44.380  1.00  0.00            N
+ATOM   2161   CA SER A 136      81.640  33.540  43.120  1.00  0.00           CA
+ATOM   2168    C SER A 136      82.850  33.500  42.170  1.00  0.00            C
+ATOM   2169    O SER A 136      82.570  33.570  40.970  1.00  0.00            O
+ATOM   2170    N CYS A 137      84.090  33.360  42.610  1.00  0.00            N
+ATOM   2172   CA CYS A 137      85.220  33.350  41.730  1.00  0.00           CA
+ATOM   2179    C CYS A 137      85.130  32.410  40.540  1.00  0.00            C
+ATOM   2180    O CYS A 137      85.520  32.850  39.470  1.00  0.00            O
+ATOM   2181    N PRO A 138      84.550  31.200  40.490  1.00  0.00            N
+ATOM   2185   CA PRO A 138      84.280  30.410  39.320  1.00  0.00           CA
+ATOM   2193    C PRO A 138      83.570  31.130  38.140  1.00  0.00            C
+ATOM   2194    O PRO A 138      83.900  30.980  36.990  1.00  0.00            O
+ATOM   2195    N LEU A 139      82.570  32.060  38.460  1.00  0.00            N
+ATOM   2197   CA LEU A 139      81.810  32.660  37.350  1.00  0.00           CA
+ATOM   2212    C LEU A 139      82.590  33.550  36.300  1.00  0.00            C
+ATOM   2213    O LEU A 139      82.590  33.350  35.080  1.00  0.00            O
+ATOM   2214    N LEU A 140      83.430  34.450  36.860  1.00  0.00            N
+ATOM   2216   CA LEU A 140      84.310  35.250  35.970  1.00  0.00           CA
+ATOM   2231    C LEU A 140      85.290  34.490  35.150  1.00  0.00            C
+ATOM   2232    O LEU A 140      85.510  34.870  34.060  1.00  0.00            O
+ATOM   2233    N PHE A 141      85.790  33.360  35.630  1.00  0.00            N
+ATOM   2235   CA PHE A 141      86.800  32.530  34.980  1.00  0.00           CA
+ATOM   2251    C PHE A 141      86.270  31.430  34.100  1.00  0.00            C
+ATOM   2252    O PHE A 141      86.990  30.620  33.620  1.00  0.00            O
+ATOM   2253    N GLY A 142      84.910  31.380  33.980  1.00  0.00            N
+ATOM   2255   CA GLY A 142      84.260  30.450  33.110  1.00  0.00           CA
+ATOM   2258    C GLY A 142      83.530  29.320  33.670  1.00  0.00            C
+ATOM   2259    O GLY A 142      83.020  28.520  32.930  1.00  0.00            O
+ATOM   2260    N LEU A 143      83.480  29.180  35.010  1.00  0.00            N
+ATOM   2262   CA LEU A 143      82.670  28.190  35.760  1.00  0.00           CA
+ATOM   2277    C LEU A 143      83.320  26.850  35.600  1.00  0.00            C
+ATOM   2278    O LEU A 143      82.720  25.790  35.570  1.00  0.00            O
+ATOM   2279    N ASN A 144      84.640  26.810  35.460  1.00  0.00            N
+ATOM   2281   CA ASN A 144      85.500  25.600  35.250  1.00  0.00           CA
+ATOM   2291    C ASN A 144      85.160  24.720  34.080  1.00  0.00            C
+ATOM   2292    O ASN A 144      85.130  23.500  34.090  1.00  0.00            O
+ATOM   2293    N ASN A 145      84.530  25.310  33.080  1.00  0.00            N
+ATOM   2295   CA ASN A 145      84.010  24.460  31.990  1.00  0.00           CA
+ATOM   2305    C ASN A 145      84.190  25.220  30.710  1.00  0.00            C
+ATOM   2306    O ASN A 145      85.090  26.040  30.540  1.00  0.00            O
+ATOM   2307    N ALA A 146      83.390  24.900  29.720  1.00  0.00            N
+ATOM   2309   CA ALA A 146      83.380  25.630  28.470  1.00  0.00           CA
+ATOM   2315    C ALA A 146      82.600  26.920  28.620  1.00  0.00            C
+ATOM   2316    O ALA A 146      81.390  26.980  28.770  1.00  0.00            O
+ATOM   2317    N ASP A 147      83.350  28.040  28.600  1.00  0.00            N
+ATOM   2319   CA ASP A 147      82.690  29.320  28.960  1.00  0.00           CA
+ATOM   2327    C ASP A 147      81.950  29.980  27.910  1.00  0.00            C
+ATOM   2328    O ASP A 147      81.170  30.880  28.110  1.00  0.00            O
+ATOM   2329    N GLN A 148      81.950  29.360  26.690  1.00  0.00            N
+ATOM   2331   CA GLN A 148      81.020  29.650  25.640  1.00  0.00           CA
+ATOM   2344    C GLN A 148      81.150  31.010  25.020  1.00  0.00            C
+ATOM   2345    O GLN A 148      81.920  31.810  25.510  1.00  0.00            O
+ATOM   2346    N ASN A 149      80.500  31.340  23.900  1.00  0.00            N
+ATOM   2348   CA ASN A 149      80.530  32.620  23.400  1.00  0.00           CA
+ATOM   2358    C ASN A 149      79.310  33.340  23.830  1.00  0.00            C
+ATOM   2359    O ASN A 149      78.570  33.990  23.040  1.00  0.00            O
+ATOM   2360    N GLU A 150      78.940  33.170  25.150  1.00  0.00            N
+ATOM   2362   CA GLU A 150      77.810  33.730  25.760  1.00  0.00           CA
+ATOM   2373    C GLU A 150      78.030  33.960  27.290  1.00  0.00            C
+ATOM   2374    O GLU A 150      78.660  33.150  27.980  1.00  0.00            O
+ATOM   2375    N CYS A 151      77.470  35.100  27.820  1.00  0.00            N
+ATOM   2377   CA CYS A 151      77.530  35.510  29.230  1.00  0.00           CA
+ATOM   2383    C CYS A 151      77.040  34.420  30.150  1.00  0.00            C
+ATOM   2384    O CYS A 151      76.030  33.710  29.950  1.00  0.00            O
+ATOM   2385    N ILE A 152      77.890  34.200  31.230  1.00  0.00            N
+ATOM   2387   CA ILE A 152      77.860  33.160  32.190  1.00  0.00           CA
+ATOM   2402    C ILE A 152      76.600  32.810  33.040  1.00  0.00            C
+ATOM   2403    O ILE A 152      76.450  31.770  33.640  1.00  0.00            O
+ATOM   2404    N ILE A 153      75.520  33.530  32.800  1.00  0.00            N
+ATOM   2406   CA ILE A 153      74.190  33.130  33.200  1.00  0.00           CA
+ATOM   2421    C ILE A 153      73.540  32.130  32.290  1.00  0.00            C
+ATOM   2422    O ILE A 153      72.600  31.430  32.710  1.00  0.00            O
+ATOM   2423    N ALA A 154      74.090  31.920  31.020  1.00  0.00            N
+ATOM   2425   CA ALA A 154      73.640  31.050  30.000  1.00  0.00           CA
+ATOM   2431    C ALA A 154      74.400  29.740  29.890  1.00  0.00            C
+ATOM   2432    O ALA A 154      74.320  28.860  29.020  1.00  0.00            O
+ATOM   2433    N ASN A 155      75.300  29.610  30.870  1.00  0.00            N
+ATOM   2435   CA ASN A 155      76.170  28.390  31.040  1.00  0.00           CA
+ATOM   2445    C ASN A 155      75.470  27.200  31.710  1.00  0.00            C
+ATOM   2446    O ASN A 155      74.820  27.500  32.710  1.00  0.00            O
+ATOM   2447    N PRO A 156      75.560  25.980  31.270  1.00  0.00            N
+ATOM   2451   CA PRO A 156      74.720  24.870  31.660  1.00  0.00           CA
+ATOM   2459    C PRO A 156      75.220  24.220  32.960  1.00  0.00            C
+ATOM   2460    O PRO A 156      74.800  23.150  33.190  1.00  0.00            O
+ATOM   2461    N ALA A 157      76.060  24.910  33.730  1.00  0.00            N
+ATOM   2463   CA ALA A 157      76.360  24.610  35.140  1.00  0.00           CA
+ATOM   2469    C ALA A 157      76.000  25.790  36.000  1.00  0.00            C
+ATOM   2470    O ALA A 157      76.180  25.680  37.240  1.00  0.00            O
+ATOM   2471    N PHE A 158      75.450  26.880  35.410  1.00  0.00            N
+ATOM   2473   CA PHE A 158      74.980  28.030  36.150  1.00  0.00           CA
+ATOM   2489    C PHE A 158      74.020  27.890  37.220  1.00  0.00            C
+ATOM   2490    O PHE A 158      74.400  28.100  38.350  1.00  0.00            O
+ATOM   2491    N VAL A 159      72.740  27.450  36.890  1.00  0.00            N
+ATOM   2493   CA VAL A 159      71.720  27.280  37.840  1.00  0.00           CA
+ATOM   2505    C VAL A 159      72.000  26.260  38.930  1.00  0.00            C
+ATOM   2506    O VAL A 159      71.740  26.550  40.090  1.00  0.00            O
+ATOM   2507    N VAL A 160      72.670  25.170  38.600  1.00  0.00            N
+ATOM   2509   CA VAL A 160      72.850  24.100  39.640  1.00  0.00           CA
+ATOM   2521    C VAL A 160      73.950  24.410  40.580  1.00  0.00            C
+ATOM   2522    O VAL A 160      73.880  24.230  41.820  1.00  0.00            O
+ATOM   2523    N TYR A 161      75.070  24.990  40.080  1.00  0.00            N
+ATOM   2525   CA TYR A 161      76.140  25.460  40.870  1.00  0.00           CA
+ATOM   2542    C TYR A 161      75.590  26.530  41.840  1.00  0.00            C
+ATOM   2543    O TYR A 161      75.890  26.440  43.020  1.00  0.00            O
+ATOM   2544    N SER A 162      74.820  27.530  41.370  1.00  0.00            N
+ATOM   2546   CA SER A 162      74.160  28.560  42.180  1.00  0.00           CA
+ATOM   2553    C SER A 162      73.160  28.010  43.150  1.00  0.00            C
+ATOM   2554    O SER A 162      73.310  28.250  44.360  1.00  0.00            O
+ATOM   2555    N SER A 163      72.250  27.060  42.820  1.00  0.00            N
+ATOM   2557   CA SER A 163      71.240  26.440  43.680  1.00  0.00           CA
+ATOM   2564    C SER A 163      71.860  25.640  44.860  1.00  0.00            C
+ATOM   2565    O SER A 163      71.440  25.710  45.990  1.00  0.00            O
+ATOM   2566    N ILE A 164      72.960  24.970  44.590  1.00  0.00            N
+ATOM   2568   CA ILE A 164      73.690  24.140  45.550  1.00  0.00           CA
+ATOM   2583    C ILE A 164      74.640  24.910  46.420  1.00  0.00            C
+ATOM   2584    O ILE A 164      74.460  24.910  47.640  1.00  0.00            O
+ATOM   2585    N VAL A 165      75.680  25.570  45.820  1.00  0.00            N
+ATOM   2587   CA VAL A 165      76.740  26.090  46.580  1.00  0.00           CA
+ATOM   2599    C VAL A 165      76.360  27.470  47.140  1.00  0.00            C
+ATOM   2600    O VAL A 165      76.710  27.700  48.260  1.00  0.00            O
+ATOM   2601    N SER A 166      75.600  28.350  46.500  1.00  0.00            N
+ATOM   2603   CA SER A 166      75.210  29.740  46.940  1.00  0.00           CA
+ATOM   2610    C SER A 166      73.830  29.900  47.500  1.00  0.00            C
+ATOM   2611    O SER A 166      73.340  30.970  47.920  1.00  0.00            O
+ATOM   2612    N PHE A 167      73.180  28.750  47.780  1.00  0.00            N
+ATOM   2614   CA PHE A 167      71.920  28.720  48.430  1.00  0.00           CA
+ATOM   2630    C PHE A 167      71.870  27.580  49.260  1.00  0.00            C
+ATOM   2631    O PHE A 167      71.920  27.660  50.460  1.00  0.00            O
+ATOM   2632    N TYR A 168      71.570  26.400  48.780  1.00  0.00            N
+ATOM   2634   CA TYR A 168      71.310  25.220  49.580  1.00  0.00           CA
+ATOM   2651    C TYR A 168      72.330  24.820  50.660  1.00  0.00            C
+ATOM   2652    O TYR A 168      71.940  24.390  51.810  1.00  0.00            O
+ATOM   2653    N VAL A 169      73.690  24.970  50.390  1.00  0.00            N
+ATOM   2655   CA VAL A 169      74.800  24.610  51.260  1.00  0.00           CA
+ATOM   2667    C VAL A 169      74.820  25.470  52.540  1.00  0.00            C
+ATOM   2668    O VAL A 169      74.770  24.850  53.630  1.00  0.00            O
+ATOM   2669    N PRO A 170      74.660  26.820  52.480  1.00  0.00            N
+ATOM   2673   CA PRO A 170      74.350  27.640  53.640  1.00  0.00           CA
+ATOM   2681    C PRO A 170      72.890  27.640  54.040  1.00  0.00            C
+ATOM   2682    O PRO A 170      72.660  27.740  55.280  1.00  0.00            O
+ATOM   2683    N PHE A 171      71.870  27.590  53.170  1.00  0.00            N
+ATOM   2685   CA PHE A 171      70.430  27.610  53.600  1.00  0.00           CA
+ATOM   2701    C PHE A 171      70.130  26.450  54.600  1.00  0.00            C
+ATOM   2702    O PHE A 171      69.730  26.630  55.740  1.00  0.00            O
+ATOM   2703    N ILE A 172      70.680  25.250  54.340  1.00  0.00            N
+ATOM   2705   CA ILE A 172      70.510  24.110  55.170  1.00  0.00           CA
+ATOM   2720    C ILE A 172      71.150  24.190  56.500  1.00  0.00            C
+ATOM   2721    O ILE A 172      70.530  23.980  57.550  1.00  0.00            O
+ATOM   2722    N VAL A 173      72.420  24.650  56.600  1.00  0.00            N
+ATOM   2724   CA VAL A 173      73.240  24.910  57.810  1.00  0.00           CA
+ATOM   2736    C VAL A 173      72.590  26.020  58.660  1.00  0.00            C
+ATOM   2737    O VAL A 173      72.530  25.950  59.860  1.00  0.00            O
+ATOM   2738    N THR A 174      72.160  27.080  58.010  1.00  0.00            N
+ATOM   2740   CA THR A 174      71.400  28.120  58.760  1.00  0.00           CA
+ATOM   2750    C THR A 174      70.160  27.540  59.320  1.00  0.00            C
+ATOM   2751    O THR A 174      69.850  27.830  60.440  1.00  0.00            O
+ATOM   2752    N LEU A 175      69.380  26.740  58.630  1.00  0.00            N
+ATOM   2754   CA LEU A 175      68.310  26.040  59.260  1.00  0.00           CA
+ATOM   2769    C LEU A 175      68.590  25.170  60.500  1.00  0.00            C
+ATOM   2770    O LEU A 175      68.010  25.340  61.550  1.00  0.00            O
+ATOM   2771    N LEU A 176      69.630  24.290  60.370  1.00  0.00            N
+ATOM   2773   CA LEU A 176      70.100  23.410  61.390  1.00  0.00           CA
+ATOM   2788    C LEU A 176      70.540  24.160  62.620  1.00  0.00            C
+ATOM   2789    O LEU A 176      70.230  23.790  63.760  1.00  0.00            O
+ATOM   2790    N VAL A 177      71.220  25.300  62.570  1.00  0.00            N
+ATOM   2792   CA VAL A 177      71.600  26.200  63.630  1.00  0.00           CA
+ATOM   2804    C VAL A 177      70.360  26.700  64.420  1.00  0.00            C
+ATOM   2805    O VAL A 177      70.210  26.520  65.660  1.00  0.00            O
+ATOM   2806    N TYR A 178      69.350  27.220  63.720  1.00  0.00            N
+ATOM   2808   CA TYR A 178      68.100  27.670  64.190  1.00  0.00           CA
+ATOM   2825    C TYR A 178      67.270  26.610  64.840  1.00  0.00            C
+ATOM   2826    O TYR A 178      66.640  26.880  65.870  1.00  0.00            O
+ATOM   2827    N ILE A 179      67.240  25.360  64.330  1.00  0.00            N
+ATOM   2829   CA ILE A 179      66.660  24.270  65.070  1.00  0.00           CA
+ATOM   2844    C ILE A 179      67.330  24.080  66.470  1.00  0.00            C
+ATOM   2845    O ILE A 179      66.670  23.850  67.520  1.00  0.00            O
+ATOM   2846    N LYS A 180      68.680  24.080  66.480  1.00  0.00            N
+ATOM   2848   CA LYS A 180      69.480  23.970  67.710  1.00  0.00           CA
+ATOM   2866    C LYS A 180      69.180  25.100  68.720  1.00  0.00            C
+ATOM   2867    O LYS A 180      68.990  24.820  69.920  1.00  0.00            O
+ATOM   2868    N ILE A 181      69.030  26.400  68.240  1.00  0.00            N
+ATOM   2870   CA ILE A 181      68.640  27.530  69.020  1.00  0.00           CA
+ATOM   2885    C ILE A 181      67.320  27.310  69.790  1.00  0.00            C
+ATOM   2886    O ILE A 181      67.180  27.570  70.980  1.00  0.00            O
+ATOM   2887    N TYR A 182      66.350  26.640  69.170  1.00  0.00            N
+ATOM   2889   CA TYR A 182      65.130  26.210  69.900  1.00  0.00           CA
+ATOM   2906    C TYR A 182      65.190  25.190  70.990  1.00  0.00            C
+ATOM   2907    O TYR A 182      64.680  25.440  72.110  1.00  0.00            O
+ATOM   2908    N ILE A 183      65.960  24.060  70.740  1.00  0.00            N
+ATOM   2910   CA ILE A 183      66.250  22.930  71.650  1.00  0.00           CA
+ATOM   2925    C ILE A 183      66.940  23.430  72.900  1.00  0.00            C
+ATOM   2926    O ILE A 183      66.620  22.960  73.990  1.00  0.00            O
+ATOM   2927    N VAL A 184      67.890  24.390  72.750  1.00  0.00            N
+ATOM   2929   CA VAL A 184      68.500  24.990  73.980  1.00  0.00           CA
+ATOM   2941    C VAL A 184      67.570  25.810  74.840  1.00  0.00            C
+ATOM   2942    O VAL A 184      67.360  25.630  76.060  1.00  0.00            O
+ATOM   2943    N LEU A 185      66.900  26.810  74.200  1.00  0.00            N
+ATOM   2945   CA LEU A 185      66.030  27.670  74.950  1.00  0.00           CA
+ATOM   2960    C LEU A 185      64.770  26.890  75.530  1.00  0.00            C
+ATOM   2961    O LEU A 185      64.330  27.170  76.670  1.00  0.00            O
+ATOM   2962    N ARG A 186      64.170  25.890  74.780  1.00  0.00            N
+ATOM   2964   CA ARG A 186      63.110  25.040  75.420  1.00  0.00           CA
+ATOM   2984    C ARG A 186      63.560  24.280  76.640  1.00  0.00            C
+ATOM   2985    O ARG A 186      62.810  24.040  77.540  1.00  0.00            O
+ATOM   2986    N ARG A 187      64.840  23.790  76.680  1.00  0.00            N
+ATOM   2988   CA ARG A 187      65.380  23.060  77.870  1.00  0.00           CA
+ATOM   3008    C ARG A 187      65.750  23.960  79.100  1.00  0.00            C
+ATOM   3009    O ARG A 187      65.510  23.600  80.230  1.00  0.00            O
+ATOM   3010    N ARG A 188      66.300  25.190  78.800  1.00  0.00            N
+ATOM   3012   CA ARG A 188      66.410  26.130  79.860  1.00  0.00           CA
+ATOM   3032    C ARG A 188      65.080  26.530  80.380  1.00  0.00            C
+ATOM   3033    O ARG A 188      64.830  26.600  81.560  1.00  0.00            O
+ATOM   3034    N ARG A 189      64.100  26.850  79.490  1.00  0.00            N
+ATOM   3036   CA ARG A 189      62.730  27.200  79.890  1.00  0.00           CA
+ATOM   3056    C ARG A 189      61.960  26.130  80.680  1.00  0.00            C
+ATOM   3057    O ARG A 189      61.300  26.440  81.700  1.00  0.00            O
+ATOM   3058    N LYS A 190      61.990  24.830  80.210  1.00  0.00            N
+ATOM   3060   CA LYS A 190      61.450  23.690  80.930  1.00  0.00           CA
+ATOM   3078    C LYS A 190      61.970  23.590  82.390  1.00  0.00            C
+ATOM   3079    O LYS A 190      61.220  23.360  83.340  1.00  0.00            O
+ATOM   3080    N ARG A 191      63.260  23.770  82.590  1.00  0.00            N
+ATOM   3082   CA ARG A 191      63.920  23.880  83.900  1.00  0.00           CA
+ATOM   3102    C ARG A 191      63.600  25.140  84.710  1.00  0.00            C
+ATOM   3103    O ARG A 191      63.350  25.200  85.900  1.00  0.00            O
+ATOM   3104    N VAL A 192      63.600  26.400  84.090  1.00  0.00            N
+ATOM   3106   CA VAL A 192      63.420  27.650  84.770  1.00  0.00           CA
+ATOM   3118    C VAL A 192      62.080  27.780  85.530  1.00  0.00            C
+ATOM   3119    O VAL A 192      62.000  28.270  86.620  1.00  0.00            O
+ATOM   3120    N ASN A 193      60.970  27.320  84.870  1.00  0.00            N
+ATOM   3122   CA ASN A 193      59.630  27.450  85.320  1.00  0.00           CA
+ATOM   3132    C ASN A 193      59.140  28.880  85.660  1.00  0.00            C
+ATOM   3133    O ASN A 193      58.430  29.030  86.660  1.00  0.00            O
+ATOM   3134    N THR A 194      59.580  29.940  84.970  1.00  0.00            N
+ATOM   3136   CA THR A 194      59.140  31.330  85.200  1.00  0.00           CA
+ATOM   3146    C THR A 194      59.470  32.190  84.040  1.00  0.00            C
+ATOM   3147    O THR A 194      60.500  32.030  83.440  1.00  0.00            O
+ATOM   3148    N LYS A 195      58.650  33.210  83.780  1.00  0.00            N
+ATOM   3150   CA LYS A 195      58.800  34.150  82.770  1.00  0.00           CA
+ATOM   3168    C LYS A 195      59.610  35.390  83.130  1.00  0.00            C
+ATOM   3169    O LYS A 195      59.790  36.340  82.400  1.00  0.00            O
+ATOM   3170    N ARG A 196      60.170  35.450  84.380  1.00  0.00            N
+ATOM   3172   CA ARG A 196      60.770  36.640  84.940  1.00  0.00           CA
+ATOM   3192    C ARG A 196      62.330  36.670  84.840  1.00  0.00            C
+ATOM   3193    O ARG A 196      63.020  37.410  85.560  1.00  0.00            O
+ATOM   3194    N LYS A 197      62.950  35.750  83.990  1.00  0.00            N
+ATOM   3196   CA LYS A 197      64.380  35.820  83.690  1.00  0.00           CA
+ATOM   3214    C LYS A 197      64.690  36.780  82.570  1.00  0.00            C
+ATOM   3215    O LYS A 197      65.020  36.420  81.390  1.00  0.00            O
+ATOM   3216    N LEU A 198      64.700  38.030  82.950  1.00  0.00            N
+ATOM   3218   CA LEU A 198      64.550  39.260  82.180  1.00  0.00           CA
+ATOM   3233    C LEU A 198      65.630  39.370  81.070  1.00  0.00            C
+ATOM   3234    O LEU A 198      65.410  39.810  79.940  1.00  0.00            O
+ATOM   3235    N SER A 199      66.870  38.940  81.420  1.00  0.00            N
+ATOM   3237   CA SER A 199      68.030  38.900  80.490  1.00  0.00           CA
+ATOM   3244    C SER A 199      67.720  37.930  79.360  1.00  0.00            C
+ATOM   3245    O SER A 199      67.960  38.170  78.190  1.00  0.00            O
+ATOM   3246    N GLN A 200      67.240  36.740  79.760  1.00  0.00            N
+ATOM   3248   CA GLN A 200      66.840  35.680  78.850  1.00  0.00           CA
+ATOM   3261    C GLN A 200      65.690  36.100  78.060  1.00  0.00            C
+ATOM   3262    O GLN A 200      65.690  36.000  76.850  1.00  0.00            O
+ATOM   3263    N GLN A 201      64.660  36.730  78.670  1.00  0.00            N
+ATOM   3265   CA GLN A 201      63.640  37.420  77.910  1.00  0.00           CA
+ATOM   3278    C GLN A 201      64.180  38.300  76.870  1.00  0.00            C
+ATOM   3279    O GLN A 201      63.660  38.130  75.720  1.00  0.00            O
+ATOM   3280    N LYS A 202      65.090  39.290  77.210  1.00  0.00            N
+ATOM   3282   CA LYS A 202      65.640  40.200  76.190  1.00  0.00           CA
+ATOM   3300    C LYS A 202      66.440  39.500  75.050  1.00  0.00            C
+ATOM   3301    O LYS A 202      66.320  39.870  73.890  1.00  0.00            O
+ATOM   3302    N GLU A 203      67.180  38.440  75.380  1.00  0.00            N
+ATOM   3304   CA GLU A 203      68.010  37.690  74.430  1.00  0.00           CA
+ATOM   3315    C GLU A 203      67.040  36.910  73.490  1.00  0.00            C
+ATOM   3316    O GLU A 203      67.170  36.770  72.280  1.00  0.00            O
+ATOM   3317    N LYS A 204      65.920  36.350  74.060  1.00  0.00            N
+ATOM   3319   CA LYS A 204      64.790  35.810  73.330  1.00  0.00           CA
+ATOM   3337    C LYS A 204      64.080  36.670  72.370  1.00  0.00            C
+ATOM   3338    O LYS A 204      63.850  36.190  71.240  1.00  0.00            O
+ATOM   3339    N LYS A 205      63.770  37.910  72.700  1.00  0.00            N
+ATOM   3341   CA LYS A 205      63.270  38.920  71.770  1.00  0.00           CA
+ATOM   3359    C LYS A 205      64.110  39.220  70.570  1.00  0.00            C
+ATOM   3360    O LYS A 205      63.600  39.290  69.440  1.00  0.00            O
+ATOM   3361    N ALA A 206      65.440  39.300  70.780  1.00  0.00            N
+ATOM   3363   CA ALA A 206      66.450  39.360  69.690  1.00  0.00           CA
+ATOM   3369    C ALA A 206      66.480  38.130  68.810  1.00  0.00            C
+ATOM   3370    O ALA A 206      66.620  38.220  67.600  1.00  0.00            O
+ATOM   3371    N THR A 207      66.320  36.940  69.420  1.00  0.00            N
+ATOM   3373   CA THR A 207      66.440  35.680  68.700  1.00  0.00           CA
+ATOM   3383    C THR A 207      65.150  35.460  67.860  1.00  0.00            C
+ATOM   3384    O THR A 207      65.210  35.090  66.660  1.00  0.00            O
+ATOM   3385    N GLN A 208      63.950  35.740  68.390  1.00  0.00            N
+ATOM   3387   CA GLN A 208      62.670  35.860  67.580  1.00  0.00           CA
+ATOM   3400    C GLN A 208      62.700  36.920  66.510  1.00  0.00            C
+ATOM   3401    O GLN A 208      62.180  36.700  65.350  1.00  0.00            O
+ATOM   3402    N MET A 209      63.310  38.170  66.700  1.00  0.00            N
+ATOM   3404   CA MET A 209      63.440  39.220  65.710  1.00  0.00           CA
+ATOM   3417    C MET A 209      64.330  38.810  64.530  1.00  0.00            C
+ATOM   3418    O MET A 209      63.930  39.000  63.400  1.00  0.00            O
+ATOM   3419    N LEU A 210      65.500  38.200  64.730  1.00  0.00            N
+ATOM   3421   CA LEU A 210      66.250  37.700  63.620  1.00  0.00           CA
+ATOM   3436    C LEU A 210      65.660  36.330  63.000  1.00  0.00            C
+ATOM   3437    O LEU A 210      65.780  36.150  61.800  1.00  0.00            O
+ATOM   3438    N ALA A 211      64.960  35.550  63.810  1.00  0.00            N
+ATOM   3440   CA ALA A 211      64.230  34.420  63.260  1.00  0.00           CA
+ATOM   3446    C ALA A 211      63.150  34.830  62.290  1.00  0.00            C
+ATOM   3447    O ALA A 211      62.980  34.200  61.290  1.00  0.00            O
+ATOM   3448    N ILE A 212      62.400  35.860  62.660  1.00  0.00            N
+ATOM   3450   CA ILE A 212      61.520  36.580  61.760  1.00  0.00           CA
+ATOM   3465    C ILE A 212      62.360  37.150  60.550  1.00  0.00            C
+ATOM   3466    O ILE A 212      61.860  37.090  59.420  1.00  0.00            O
+ATOM   3467    N VAL A 213      63.590  37.680  60.680  1.00  0.00            N
+ATOM   3469   CA VAL A 213      64.410  38.130  59.500  1.00  0.00           CA
+ATOM   3481    C VAL A 213      64.760  36.960  58.520  1.00  0.00            C
+ATOM   3482    O VAL A 213      64.490  36.970  57.350  1.00  0.00            O
+ATOM   3483    N LEU A 214      65.120  35.790  59.090  1.00  0.00            N
+ATOM   3485   CA LEU A 214      65.260  34.560  58.390  1.00  0.00           CA
+ATOM   3500    C LEU A 214      63.960  34.010  57.870  1.00  0.00            C
+ATOM   3501    O LEU A 214      63.810  33.500  56.730  1.00  0.00            O
+ATOM   3502    N GLY A 215      62.840  34.240  58.610  1.00  0.00            N
+ATOM   3504   CA GLY A 215      61.390  34.020  58.190  1.00  0.00           CA
+ATOM   3507    C GLY A 215      60.950  34.820  56.950  1.00  0.00            C
+ATOM   3508    O GLY A 215      60.240  34.370  56.070  1.00  0.00            O
+ATOM   3509    N VAL A 216      61.400  36.040  56.840  1.00  0.00            N
+ATOM   3511   CA VAL A 216      61.450  36.910  55.660  1.00  0.00           CA
+ATOM   3523    C VAL A 216      62.250  36.420  54.530  1.00  0.00            C
+ATOM   3524    O VAL A 216      61.820  36.470  53.340  1.00  0.00            O
+ATOM   3525    N PHE A 217      63.470  35.900  54.750  1.00  0.00            N
+ATOM   3527   CA PHE A 217      64.300  35.380  53.720  1.00  0.00           CA
+ATOM   3543    C PHE A 217      63.700  34.090  53.070  1.00  0.00            C
+ATOM   3544    O PHE A 217      63.820  33.900  51.860  1.00  0.00            O
+ATOM   3545    N ILE A 218      63.110  33.240  53.980  1.00  0.00            N
+ATOM   3547   CA ILE A 218      62.330  32.100  53.570  1.00  0.00           CA
+ATOM   3562    C ILE A 218      61.150  32.370  52.630  1.00  0.00            C
+ATOM   3563    O ILE A 218      61.040  31.740  51.600  1.00  0.00            O
+ATOM   3564    N ILE A 219      60.280  33.340  52.970  1.00  0.00            N
+ATOM   3566   CA ILE A 219      59.180  33.840  52.120  1.00  0.00           CA
+ATOM   3581    C ILE A 219      59.680  34.360  50.800  1.00  0.00            C
+ATOM   3582    O ILE A 219      59.080  34.150  49.740  1.00  0.00            O
+ATOM   3583    N CYS A 220      60.710  35.170  50.940  1.00  0.00            N
+ATOM   3585   CA CYS A 220      61.270  35.850  49.790  1.00  0.00           CA
+ATOM   3592    C CYS A 220      62.030  34.960  48.770  1.00  0.00            C
+ATOM   3593    O CYS A 220      61.750  35.080  47.570  1.00  0.00            O
+ATOM   3594    N TRP A 221      62.970  34.070  49.160  1.00  0.00            N
+ATOM   3596   CA TRP A 221      63.910  33.340  48.270  1.00  0.00           CA
+ATOM   3616    C TRP A 221      63.850  31.820  48.080  1.00  0.00            C
+ATOM   3617    O TRP A 221      64.430  31.270  47.160  1.00  0.00            O
+ATOM   3618    N LEU A 222      63.130  31.120  48.920  1.00  0.00            N
+ATOM   3620   CA LEU A 222      62.780  29.730  48.710  1.00  0.00           CA
+ATOM   3635    C LEU A 222      61.860  29.570  47.530  1.00  0.00            C
+ATOM   3636    O LEU A 222      62.260  28.820  46.670  1.00  0.00            O
+ATOM   3637    N PRO A 223      60.670  30.220  47.280  1.00  0.00            N
+ATOM   3641   CA PRO A 223      59.960  30.290  46.020  1.00  0.00           CA
+ATOM   3649    C PRO A 223      60.860  30.300  44.770  1.00  0.00            C
+ATOM   3650    O PRO A 223      60.610  29.480  43.890  1.00  0.00            O
+ATOM   3651    N PHE A 224      61.840  31.260  44.670  1.00  0.00            N
+ATOM   3653   CA PHE A 224      62.750  31.300  43.550  1.00  0.00           CA
+ATOM   3669    C PHE A 224      63.600  30.030  43.430  1.00  0.00            C
+ATOM   3670    O PHE A 224      63.630  29.460  42.340  1.00  0.00            O
+ATOM   3671    N PHE A 225      64.290  29.530  44.510  1.00  0.00            N
+ATOM   3673   CA PHE A 225      65.230  28.380  44.470  1.00  0.00           CA
+ATOM   3689    C PHE A 225      64.430  27.060  44.670  1.00  0.00            C
+ATOM   3690    O PHE A 225      64.980  25.940  44.880  1.00  0.00            O
+ATOM   3691    N ILE A 226      63.030  27.040  44.490  1.00  0.00            N
+ATOM   3693   CA ILE A 226      62.310  25.790  44.270  1.00  0.00           CA
+ATOM   3708    C ILE A 226      61.570  25.950  42.920  1.00  0.00            C
+ATOM   3709    O ILE A 226      60.990  24.970  42.400  1.00  0.00            O
+ATOM   3710    N THR A 227      61.540  27.160  42.390  1.00  0.00            N
+ATOM   3712   CA THR A 227      61.180  27.320  40.990  1.00  0.00           CA
+ATOM   3722    C THR A 227      62.320  26.820  40.180  1.00  0.00            C
+ATOM   3723    O THR A 227      63.090  27.580  39.650  1.00  0.00            O
+ATOM   3724    N ILE A 229      62.400  25.470  40.010  1.00  0.00            N
+ATOM   3726   CA ILE A 229      63.390  24.670  39.250  1.00  0.00           CA
+ATOM   3741    C ILE A 229      62.670  24.100  38.000  1.00  0.00            C
+ATOM   3742    O ILE A 229      63.030  23.200  37.290  1.00  0.00            O
+ATOM   3743    N LEU A 230      61.420  24.570  37.780  1.00  0.00            N
+ATOM   3745   CA LEU A 230      60.580  24.130  36.590  1.00  0.00           CA
+ATOM   3760    C LEU A 230      61.360  24.050  35.310  1.00  0.00            C
+ATOM   3761    O LEU A 230      61.260  23.120  34.520  1.00  0.00            O
+ATOM   3762    N ASN A 231      62.280  24.970  35.080  1.00  0.00            N
+ATOM   3764   CA ASN A 231      63.130  25.140  33.950  1.00  0.00           CA
+ATOM   3774    C ASN A 231      64.250  24.070  33.930  1.00  0.00            C
+ATOM   3775    O ASN A 231      64.770  23.850  32.880  1.00  0.00            O
+ATOM   3776    N ILE A 232      64.530  23.400  35.030  1.00  0.00            N
+ATOM   3778   CA ILE A 232      65.450  22.250  35.070  1.00  0.00           CA
+ATOM   3793    C ILE A 232      64.730  21.130  34.450  1.00  0.00            C
+ATOM   3794    O ILE A 232      65.240  20.300  33.660  1.00  0.00            O
+ATOM   3795    N CYS A 234      63.450  21.060  34.660  1.00  0.00            N
+ATOM   3797   CA CYS A 234      62.780  19.870  34.180  1.00  0.00           CA
+ATOM   3803    C CYS A 234      62.170  19.890  32.730  1.00  0.00            C
+ATOM   3804    O CYS A 234      61.670  18.820  32.290  1.00  0.00            O
+ATOM   3805    N ASP A 235      62.170  21.010  32.020  1.00  0.00            N
+ATOM   3807   CA ASP A 235      61.330  21.160  30.840  1.00  0.00           CA
+ATOM   3815    C ASP A 235      59.900  21.410  31.300  1.00  0.00            C
+ATOM   3816    O ASP A 235      58.960  21.000  30.710  1.00  0.00            O
+ATOM   3817    N CYS A 236      59.640  21.990  32.470  1.00  0.00            N
+ATOM   3819   CA CYS A 236      58.330  22.180  32.960  1.00  0.00           CA
+ATOM   3825    C CYS A 236      57.900  23.710  32.900  1.00  0.00            C
+ATOM   3826    O CYS A 236      58.800  24.540  32.840  1.00  0.00            O
+ATOM   3827    N ASN A 237      56.590  24.060  32.810  1.00  0.00            N
+ATOM   3829   CA ASN A 237      56.150  25.360  32.340  1.00  0.00           CA
+ATOM   3839    C ASN A 237      55.950  26.240  33.520  1.00  0.00            C
+ATOM   3840    O ASN A 237      55.000  26.130  34.250  1.00  0.00            O
+ATOM   3841    N ILE A 238      56.850  27.260  33.640  1.00  0.00            N
+ATOM   3843   CA ILE A 238      56.700  28.370  34.590  1.00  0.00           CA
+ATOM   3858    C ILE A 238      56.340  29.640  33.750  1.00  0.00            C
+ATOM   3859    O ILE A 238      57.010  29.920  32.730  1.00  0.00            O
+ATOM   3860    N PRO A 239      55.250  30.330  33.950  1.00  0.00            N
+ATOM   3864   CA PRO A 239      54.870  31.450  33.110  1.00  0.00           CA
+ATOM   3872    C PRO A 239      55.940  32.580  33.190  1.00  0.00            C
+ATOM   3873    O PRO A 239      56.510  32.700  34.230  1.00  0.00            O
+ATOM   3874    N PRO A 240      56.210  33.340  32.210  1.00  0.00            N
+ATOM   3878   CA PRO A 240      57.420  34.140  32.190  1.00  0.00           CA
+ATOM   3886    C PRO A 240      57.300  35.330  33.170  1.00  0.00            C
+ATOM   3887    O PRO A 240      58.320  35.670  33.730  1.00  0.00            O
+ATOM   3888    N VAL A 241      56.150  36.070  33.320  1.00  0.00            N
+ATOM   3890   CA VAL A 241      55.950  37.190  34.250  1.00  0.00           CA
+ATOM   3902    C VAL A 241      56.080  36.720  35.720  1.00  0.00            C
+ATOM   3903    O VAL A 241      56.770  37.290  36.560  1.00  0.00            O
+ATOM   3904    N LEU A 242      55.510  35.530  36.070  1.00  0.00            N
+ATOM   3906   CA LEU A 242      55.620  34.660  37.290  1.00  0.00           CA
+ATOM   3921    C LEU A 242      57.110  34.230  37.570  1.00  0.00            C
+ATOM   3922    O LEU A 242      57.540  34.290  38.730  1.00  0.00            O
+ATOM   3923    N TYR A 243      57.920  33.900  36.530  1.00  0.00            N
+ATOM   3925   CA TYR A 243      59.330  33.840  36.710  1.00  0.00           CA
+ATOM   3942    C TYR A 243      60.040  35.120  37.150  1.00  0.00            C
+ATOM   3943    O TYR A 243      60.650  35.080  38.240  1.00  0.00            O
+ATOM   3944    N SER A 244      59.890  36.300  36.500  1.00  0.00            N
+ATOM   3946   CA SER A 244      60.170  37.610  37.020  1.00  0.00           CA
+ATOM   3953    C SER A 244      59.550  37.970  38.390  1.00  0.00            C
+ATOM   3954    O SER A 244      60.260  38.440  39.250  1.00  0.00            O
+ATOM   3955    N ALA A 245      58.270  37.630  38.750  1.00  0.00            N
+ATOM   3957   CA ALA A 245      57.590  37.830  40.100  1.00  0.00           CA
+ATOM   3963    C ALA A 245      58.440  37.160  41.240  1.00  0.00            C
+ATOM   3964    O ALA A 245      58.570  37.700  42.290  1.00  0.00            O
+ATOM   3965    N PHE A 246      58.950  35.930  40.960  1.00  0.00            N
+ATOM   3967   CA PHE A 246      59.710  35.190  41.920  1.00  0.00           CA
+ATOM   3983    C PHE A 246      61.090  35.750  42.130  1.00  0.00            C
+ATOM   3984    O PHE A 246      61.690  35.680  43.220  1.00  0.00            O
+ATOM   3985    N THR A 247      61.580  36.280  41.040  1.00  0.00            N
+ATOM   3987   CA THR A 247      62.860  37.010  41.030  1.00  0.00           CA
+ATOM   3997    C THR A 247      62.750  38.290  41.840  1.00  0.00            C
+ATOM   3998    O THR A 247      63.550  38.490  42.740  1.00  0.00            O
+ATOM   3999    N TRP A 248      61.610  39.090  41.530  1.00  0.00            N
+ATOM   4001   CA TRP A 248      61.350  40.300  42.300  1.00  0.00           CA
+ATOM   4021    C TRP A 248      60.970  40.270  43.760  1.00  0.00            C
+ATOM   4022    O TRP A 248      61.360  41.140  44.540  1.00  0.00            O
+ATOM   4023    N LEU A 249      60.280  39.230  44.150  1.00  0.00            N
+ATOM   4025   CA LEU A 249      59.930  38.830  45.450  1.00  0.00           CA
+ATOM   4040    C LEU A 249      61.220  38.580  46.320  1.00  0.00            C
+ATOM   4041    O LEU A 249      61.290  39.000  47.490  1.00  0.00            O
+ATOM   4042    N GLY A 250      62.300  37.950  45.790  1.00  0.00            N
+ATOM   4044   CA GLY A 250      63.610  37.840  46.460  1.00  0.00           CA
+ATOM   4047    C GLY A 250      64.130  39.140  46.920  1.00  0.00            C
+ATOM   4048    O GLY A 250      64.430  39.390  48.090  1.00  0.00            O
+ATOM   4049    N TYR A 251      64.060  40.140  46.060  1.00  0.00            N
+ATOM   4051   CA TYR A 251      64.530  41.470  46.260  1.00  0.00           CA
+ATOM   4068    C TYR A 251      63.700  42.300  47.270  1.00  0.00            C
+ATOM   4069    O TYR A 251      64.310  43.270  47.770  1.00  0.00            O
+ATOM   4070    N VAL A 252      62.430  41.960  47.660  1.00  0.00            N
+ATOM   4072   CA VAL A 252      61.800  42.600  48.810  1.00  0.00           CA
+ATOM   4084    C VAL A 252      62.600  42.390  50.060  1.00  0.00            C
+ATOM   4085    O VAL A 252      62.660  43.330  50.820  1.00  0.00            O
+ATOM   4086    N ASN A 253      63.300  41.180  50.230  1.00  0.00            N
+ATOM   4088   CA ASN A 253      64.060  40.880  51.400  1.00  0.00           CA
+ATOM   4098    C ASN A 253      64.920  42.020  51.850  1.00  0.00            C
+ATOM   4099    O ASN A 253      65.050  42.350  53.050  1.00  0.00            O
+ATOM   4100    N SER A 254      65.600  42.660  50.950  1.00  0.00            N
+ATOM   4102   CA SER A 254      66.680  43.600  51.390  1.00  0.00           CA
+ATOM   4109    C SER A 254      66.100  44.960  51.730  1.00  0.00            C
+ATOM   4110    O SER A 254      66.810  45.790  52.310  1.00  0.00            O
+ATOM   4111    N ALA A 255      64.840  45.300  51.310  1.00  0.00            N
+ATOM   4113   CA ALA A 255      64.140  46.580  51.740  1.00  0.00           CA
+ATOM   4119    C ALA A 255      63.420  46.290  53.040  1.00  0.00            C
+ATOM   4120    O ALA A 255      63.200  47.150  53.860  1.00  0.00            O
+ATOM   4121    N VAL A 256      62.920  45.040  53.290  1.00  0.00            N
+ATOM   4123   CA VAL A 256      62.210  44.650  54.500  1.00  0.00           CA
+ATOM   4135    C VAL A 256      63.120  44.370  55.680  1.00  0.00            C
+ATOM   4136    O VAL A 256      62.720  44.470  56.860  1.00  0.00            O
+ATOM   4137    N ASN A 257      64.430  44.060  55.410  1.00  0.00            N
+ATOM   4139   CA ASN A 257      65.430  44.010  56.410  1.00  0.00           CA
+ATOM   4149    C ASN A 257      65.410  45.210  57.430  1.00  0.00            C
+ATOM   4150    O ASN A 257      65.230  44.950  58.620  1.00  0.00            O
+ATOM   4151    N PRO A 258      65.480  46.540  57.150  1.00  0.00            N
+ATOM   4155   CA PRO A 258      65.510  47.540  58.240  1.00  0.00           CA
+ATOM   4163    C PRO A 258      64.080  47.710  58.940  1.00  0.00            C
+ATOM   4164    O PRO A 258      64.070  47.940  60.150  1.00  0.00            O
+ATOM   4165    N ILE A 259      62.990  47.460  58.190  1.00  0.00            N
+ATOM   4167   CA ILE A 259      61.610  47.430  58.620  1.00  0.00           CA
+ATOM   4182    C ILE A 259      61.410  46.480  59.810  1.00  0.00            C
+ATOM   4183    O ILE A 259      60.820  46.850  60.810  1.00  0.00            O
+ATOM   4184    N ILE A 260      62.010  45.290  59.660  1.00  0.00            N
+ATOM   4186   CA ILE A 260      61.860  44.370  60.840  1.00  0.00           CA
+ATOM   4201    C ILE A 260      62.380  44.920  62.100  1.00  0.00            C
+ATOM   4202    O ILE A 260      61.760  44.880  63.190  1.00  0.00            O
+ATOM   4203    N TYR A 261      63.610  45.540  62.000  1.00  0.00            N
+ATOM   4205   CA TYR A 261      64.160  46.120  63.180  1.00  0.00           CA
+ATOM   4222    C TYR A 261      63.390  47.270  63.870  1.00  0.00            C
+ATOM   4223    O TYR A 261      63.270  47.370  65.090  1.00  0.00            O
+ATOM   4224    N THR A 262      62.720  48.170  63.030  1.00  0.00            N
+ATOM   4226   CA THR A 262      62.020  49.280  63.640  1.00  0.00           CA
+ATOM   4236    C THR A 262      60.600  48.890  64.080  1.00  0.00            C
+ATOM   4237    O THR A 262      59.900  49.640  64.740  1.00  0.00            O
+ATOM   4238    N THR A 263      60.220  47.620  63.710  1.00  0.00            N
+ATOM   4240   CA THR A 263      58.860  47.160  63.960  1.00  0.00           CA
+ATOM   4250    C THR A 263      58.920  46.510  65.290  1.00  0.00            C
+ATOM   4251    O THR A 263      58.200  46.900  66.200  1.00  0.00            O
+ATOM   4252    N PHE A 264      59.850  45.500  65.570  1.00  0.00            N
+ATOM   4254   CA PHE A 264      59.920  44.850  66.850  1.00  0.00           CA
+ATOM   4270    C PHE A 264      60.720  45.440  67.970  1.00  0.00            C
+ATOM   4271    O PHE A 264      60.470  45.240  69.170  1.00  0.00            O
+ATOM   4272    N ASN A 265      61.730  46.290  67.630  1.00  0.00            N
+ATOM   4274   CA ASN A 265      62.680  46.800  68.570  1.00  0.00           CA
+ATOM   4284    C ASN A 265      62.740  48.400  68.660  1.00  0.00            C
+ATOM   4285    O ASN A 265      63.070  49.190  67.750  1.00  0.00            O
+ATOM   4286    N ILE A 266      62.440  48.900  69.920  1.00  0.00            N
+ATOM   4288   CA ILE A 266      62.490  50.270  70.280  1.00  0.00           CA
+ATOM   4303    C ILE A 266      63.860  50.820  70.040  1.00  0.00            C
+ATOM   4304    O ILE A 266      64.020  51.870  69.440  1.00  0.00            O
+ATOM   4305    N GLU A 267      64.910  50.070  70.460  1.00  0.00            N
+ATOM   4307   CA GLU A 267      66.190  50.650  70.470  1.00  0.00           CA
+ATOM   4318    C GLU A 267      66.770  51.110  69.130  1.00  0.00            C
+ATOM   4319    O GLU A 267      67.330  52.210  69.050  1.00  0.00            O
+ATOM   4320    N PHE A 268      66.600  50.260  68.040  1.00  0.00            N
+ATOM   4322   CA PHE A 268      66.790  50.570  66.640  1.00  0.00           CA
+ATOM   4338    C PHE A 268      65.940  51.750  66.190  1.00  0.00            C
+ATOM   4339    O PHE A 268      66.400  52.650  65.480  1.00  0.00            O
+ATOM   4340    N ARG A 269      64.640  51.660  66.560  1.00  0.00            N
+ATOM   4342   CA ARG A 269      63.690  52.670  66.050  1.00  0.00           CA
+ATOM   4362    C ARG A 269      63.980  54.060  66.560  1.00  0.00            C
+ATOM   4363    O ARG A 269      63.960  55.060  65.850  1.00  0.00            O
+ATOM   4364    N LYS A 270      64.300  54.220  67.890  1.00  0.00            N
+ATOM   4366   CA LYS A 270      64.790  55.430  68.550  1.00  0.00           CA
+ATOM   4384    C LYS A 270      66.060  56.050  68.010  1.00  0.00            C
+ATOM   4385    O LYS A 270      66.160  57.240  67.760  1.00  0.00            O
+ATOM   4386    N ALA A 271      67.010  55.200  67.700  1.00  0.00            N
+ATOM   4388   CA ALA A 271      68.290  55.550  67.040  1.00  0.00           CA
+ATOM   4394    C ALA A 271      68.130  55.920  65.610  1.00  0.00            C
+ATOM   4395    O ALA A 271      68.880  56.750  65.110  1.00  0.00            O
+ATOM   4396    N PHE A 272      67.160  55.320  64.830  1.00  0.00            N
+ATOM   4398   CA PHE A 272      66.810  55.790  63.490  1.00  0.00           CA
+ATOM   4414    C PHE A 272      66.250  57.270  63.680  1.00  0.00            C
+ATOM   4415    O PHE A 272      66.670  58.170  62.970  1.00  0.00            O
+ATOM   4416    N LEU A 273      65.360  57.450  64.710  1.00  0.00            N
+ATOM   4418   CA LEU A 273      64.710  58.720  64.890  1.00  0.00           CA
+ATOM   4433    C LEU A 273      65.620  59.900  65.270  1.00  0.00            C
+ATOM   4434    O LEU A 273      65.380  61.050  64.930  1.00  0.00            O
+ATOM   4435    N LYS A 274      66.680  59.520  66.020  1.00  0.00            N
+ATOM   4437   CA LYS A 274      67.810  60.340  66.440  1.00  0.00           CA
+ATOM   4455    C LYS A 274      68.630  60.970  65.320  1.00  0.00            C
+ATOM   4456    O LYS A 274      68.980  62.130  65.300  1.00  0.00            O
+ATOM   4457    N ILE A 275      68.970  60.170  64.300  1.00  0.00            N
+ATOM   4459   CA ILE A 275      69.640  60.610  63.070  1.00  0.00           CA
+ATOM   4474    C ILE A 275      68.820  61.610  62.310  1.00  0.00            C
+ATOM   4475    O ILE A 275      69.410  62.560  61.850  1.00  0.00            O
+ATOM   4476    N LEU A 276      67.490  61.430  62.140  1.00  0.00            N
+ATOM   4478   CA LEU A 276      66.540  62.220  61.350  1.00  0.00           CA
+ATOM   4493    C LEU A 276      66.490  63.690  61.810  1.00  0.00            C
+ATOM   4494    O LEU A 276      66.540  64.520  60.970  1.00  0.00            O
+ATOM   4495    N CYS A 278      66.460  63.930  63.110  1.00  0.00            N
+ATOM   4497   CA CYS A 278      66.430  65.250  63.610  1.00  0.00           CA
+ATOM   4504    C CYS A 278      67.300  65.310  64.810  1.00  0.00            C
+END