simplify post_processing by not having a seq_coverage.png

Author: keiran-rowell-unsw

bin/generate_report.py

@@ -40,7 +40,7 @@ def get_template_path():
 
     return str(template_path)
 
-def generate_report(name, out_dir, structures, num_structs_limit=5, msa_files=None, pae_files=None, prog="proteinfold", type="standard", html_template=None, write_htmls=True):
+def generate_report(name, out_dir, structures, num_structs_limit=5, msa_files=None, pae_files=None, prog="proteinfold", type="standard", html_template=None):
 
     PLOTLY_CONFIG = {"displayModeBar": True, "displaylogo": False, "scrollZoom": True}
 
@@ -122,13 +122,6 @@ def generate_report(name, out_dir, structures, num_structs_limit=5, msa_files=No
     else:
         html = re.sub(r'<!-- BEGIN_PAE_SECTION -->.*?<!-- END_PAE_SECTION -->', '', html, flags=re.DOTALL)
 
-    if write_htmls:
-        with open(f"{out_dir}/{name}_coverage_pLDDT.html", "w") as out_file:
-            out_file.write(plddt_html)
-        if seq_cov_html:
-            with open(f"{out_dir}/{name}_coverage_MSA.html", "w") as out_file:
-                out_file.write(seq_cov_html)
-
     # Write the final HTML report
     with open(f"{out_dir}/{name}_{type}_report.html", "w") as out_file:
         out_file.write(html)
@@ -143,7 +136,6 @@ def main():
     parser.add_argument("--prog", default="proteinfold", choices=["proteinfold", "alphafold2", "alphafold3", "esmfold", "colabfold", "rosettafold-all-atom", "rosettafold2na", "helixfold3", "boltz", "comparison"], type=str.lower, help="The program used to generate the structures.")
     parser.add_argument("--type", default="standard", choices=["standard", "comparison"], help="The type of report to generate.")
     parser.add_argument("--html_template", default=None, help="Path to the HTML report template.")
-    parser.add_argument("--write_htmls", default=True, help="Write out separate files for each html plot.")
 
     args = parser.parse_args()
 
@@ -172,7 +164,6 @@ def main():
         prog=args.prog,
         type=args.type,
         html_template=html_template,
-        write_htmls=args.write_htmls,
     )
 
 if __name__ == "__main__":

modules/local/generate_report/main.nf

@@ -13,8 +13,6 @@ process GENERATE_REPORT {
 
     output:
     tuple val(meta), path ("*report.html")     , emit: report
-    tuple val(meta), path ("*seq_coverage.png"), optional: true, emit: sequence_coverage
-    tuple val(meta), path ("*_pLDDT.html")     , emit: plddt
     path "versions.yml"                        , emit: versions
 
     when:
@@ -45,8 +43,6 @@ process GENERATE_REPORT {
     stub:
     """
     touch test_alphafold2_report.html
-    touch test_seq_coverage.png
-    touch test_pLDDT.html
 
     cat <<-END_VERSIONS > versions.yml
     "${task.process}":

subworkflows/local/post_processing.nf

@@ -40,53 +40,43 @@ workflow POST_PROCESSING {
     ch_comparison_report_files = channel.empty()
 
     if (!skip_visualisation){
+        ch_report_input
+            .multiMap { meta, pdbs, msa, pae ->
+                full:     [meta, pdbs, msa, pae]
+                msa_only: [meta, msa]
+            }
+            .set { ch_report_split }
+
         GENERATE_REPORT(
-            ch_report_input,
+            ch_report_split.full,
             ch_report_template
         )
         ch_versions = ch_versions.mix(GENERATE_REPORT.out.versions)
 
         if (requested_modes_size > 1){
-            // Multi-mode comparison: group structures and coverage data from all modes
+            // Multi-mode comparison: group top-ranked structures and MSA data from all modes
             ch_top_ranked_model
-                .map { meta, pdb ->
-                    [["id": meta.id], meta, pdb]
+                .join(ch_report_split.msa_only)
+                .map { meta, pdb, msa ->
+                    [["id": meta.id], meta, pdb, msa]
                 }
-                .join(
-                    GENERATE_REPORT.out.sequence_coverage,
-                    by: [0],
-                    remainder: true  // Include models without coverage (e.g., ESMFold)
-                )
                 .groupTuple(by: [0], size: requested_modes_size)
-                .map { key, model_meta_list, coverage_list ->
-                    key.models = model_meta_list.collect { meta, pdb -> meta.model }.join(',')
-                    [key, model_meta_list.collect { meta, pdb -> pdb }, coverage_list]
-                }
-                .set { ch_comparison_report_input }
-
-            // Separate channel components for clarity
-            ch_comparison_report_input
-                .map { meta, structures, coverage ->
-                    [meta, structures.collect { f -> f.name }]
+                .map { key, model_meta_list, pdbs, msas ->
+                    def models_str = model_meta_list.collect { it.model }.join(',')
+                    [key + [models: models_str], pdbs, msas]
                 }
-                .set { ch_pdb_input }
-
-            ch_comparison_report_input
-                .map { meta, structures, coverage ->
-                    [meta, coverage.findAll { f -> f != null }.collect { f -> f.name }]
-                }
-                .set { ch_msa_input }
-
-            ch_comparison_report_input
-                .map { meta, structures, coverage ->
-                    (structures + coverage.findAll { f -> f != null }).unique()
+                .multiMap { meta, pdbs, msas ->
+                    def valid_msas = msas.findAll { !it.name.startsWith("DUMMY_") }
+                    pdbs:     [meta, pdbs.collect { it.name }]
+                    msas:     [meta, valid_msas.collect { it.name }]
+                    allfiles: (pdbs + valid_msas).unique()
                 }
-                .set { ch_all_files }
+                .set { ch_split }
 
             COMPARE_STRUCTURES(
-                ch_pdb_input,
-                ch_msa_input,
-                ch_all_files,
+                ch_split.pdbs,
+                ch_split.msas,
+                ch_split.allfiles,
                 ch_report_template
             )
             ch_versions = ch_versions.mix(COMPARE_STRUCTURES.out.versions)
@@ -127,26 +117,21 @@ workflow POST_PROCESSING {
         ch_workflow_summary      = channel.value(paramsSummaryMultiqc(summary_params))
         ch_methods_description   = channel.value(methodsDescriptionText(ch_multiqc_methods_description))
 
-        ch_multiqc_files = channel.empty()
-        ch_multiqc_files = ch_multiqc_files.mix(ch_workflow_summary.collectFile(name: 'workflow_summary_mqc.yaml'))
-        ch_multiqc_files = ch_multiqc_files.mix(ch_methods_description.collectFile(name: 'methods_description_mqc.yaml'))
-        ch_multiqc_files = ch_multiqc_files.mix(ch_collated_versions)
+        ch_multiqc_files = ch_workflow_summary.collectFile(name: 'workflow_summary_mqc.yaml')
+            .mix(ch_methods_description.collectFile(name: 'methods_description_mqc.yaml'))
+            .mix(ch_collated_versions)
 
         MULTIQC (
             ch_multiqc_rep
                 .combine(
                     ch_multiqc_files
                         .collect()
-                        .map { it -> [it] }
+                        .map { [it] }
                 )
                 .map { meta, report_files, multiqc_files -> [ meta, report_files + multiqc_files ] },
             ch_multiqc_config,
-            ch_multiqc_custom_config
-                .collect()
-                .ifEmpty([]),
-            ch_multiqc_logo
-                .collect()
-                .ifEmpty([]),
+            ch_multiqc_custom_config.toList(),
+            ch_multiqc_logo.toList(),
             [],
             []
         )