From 457af368835d548a34100ba500f7f07e052d944d Mon Sep 17 00:00:00 2001
From: Jules Jacobsen <j.jacobsen@qmul.ac.uk>
Date: Fri, 24 Oct 2025 18:51:54 +0100
Subject: [PATCH 1/6] Integrate BOQA into exomiser-core, exomiser-autoconfigure
 and exomiser-rest-prioritiser

---
 exomiser-core/pom.xml                         |   6 +
 .../core/analysis/AnalysisBuilder.java        |   6 +
 .../core/analysis/AnalysisProtoBuilder.java   |   8 +-
 .../analysis/AnalysisSampleValidator.java     |   2 +-
 .../core/analysis/FluentAnalysisBuilder.java  |   2 +
 .../exomiser/core/analysis/JobParser.java     |   2 +
 .../core/analysis/PassOnlyAnalysisRunner.java |   2 +-
 .../core/prioritisers/BoqaPrioritiser.java    | 228 ++++++++++++++++++
 .../core/prioritisers/PriorityFactory.java    |   2 +
 .../prioritisers/PriorityFactoryImpl.java     |   9 +-
 .../core/prioritisers/PriorityType.java       |   1 +
 .../prioritisers/dao/DefaultDiseaseDao.java   |  22 +-
 .../core/prioritisers/dao/DiseaseDao.java     |   4 +-
 .../prioritisers/service/PriorityService.java |   4 +
 .../exomiser/api/v1/analysis.proto            |   1 +
 .../exomiser/api/v1/prioritisers.proto        |   4 +
 .../exomiser/core/ExomiserTest.java           |   3 +-
 .../prioritisers/BoqaPrioritiserTest.java     |  98 ++++++++
 .../NoneTypePriorityFactoryStub.java          |   5 +
 .../prioritisers/PriorityFactoryImplTest.java |   5 +
 .../core/prioritisers/dao/TestDiseaseDao.java |   5 +
 .../PrioritiserAutoConfiguration.java         |  52 +++-
 .../web/controller/SubmitJobController.java   |  16 +-
 23 files changed, 465 insertions(+), 22 deletions(-)
 create mode 100644 exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
 create mode 100644 exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiserTest.java

diff --git a/exomiser-core/pom.xml b/exomiser-core/pom.xml
index b7c4fe3a4..ba09a7324 100644
--- a/exomiser-core/pom.xml
+++ b/exomiser-core/pom.xml
@@ -69,6 +69,12 @@
             <artifactId>jblas</artifactId>
             <version>1.2.3</version>
         </dependency>
+        <!--BOQA dependencies -->
+        <dependency>
+            <groupId>org.p2gx.boqa</groupId>
+            <artifactId>boqa-core</artifactId>
+            <version>0.1.0-SNAPSHOT</version>
+        </dependency>
         <!--Phenix dependencies:-->
         <!-- possibly could be replaced by org.monarchinitiative.phenol. If these artefacts are missing from the
         local .m2 repo they can be installed using the phenix-repository module. This should however happen in the
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisBuilder.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisBuilder.java
index d8b85a1ff..88ecb3e27 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisBuilder.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisBuilder.java
@@ -245,6 +245,12 @@ public AnalysisBuilder addExomeWalkerPrioritiser(List<Integer> seedGenes) {
         return this;
     }
 
+    @Override
+    public AnalysisBuilder addBoqaPrioritiser() {
+        analysisSteps.add(priorityFactory.makeBoqaPrioritiser());
+        return this;
+    }
+
     public AnalysisBuilder addAnalysisStep(AnalysisStep analysisStep) {
         analysisSteps.add(analysisStep);
         return this;
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisProtoBuilder.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisProtoBuilder.java
index 92eece613..023a22ac8 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisProtoBuilder.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisProtoBuilder.java
@@ -141,7 +141,7 @@ public AnalysisProtoBuilder addIntervalFilter(Collection<ChromosomalRegion> chro
         chromosomalRegions.stream()
                 .map(region -> new GeneticInterval(region.contigId(), region.start(), region.end()))
                 .forEach(geneticInterval -> intervalFilterBuilder.addIntervals(geneticInterval.toString()));
-        this.builder.addSteps(stepBuilder().setIntervalFilter(intervalFilterBuilder));
+        builder.addSteps(stepBuilder().setIntervalFilter(intervalFilterBuilder));
         return this;
     }
 
@@ -274,6 +274,12 @@ public AnalysisProtoBuilder addExomeWalkerPrioritiser(List<Integer> seedGenes) {
         return this;
     }
 
+    @Override
+    public AnalysisProtoBuilder addBoqaPrioritiser() {
+        builder.addSteps(stepBuilder().setBoqaPrioritiser(PrioritisersProto.BoqaPrioritiser.getDefaultInstance()));
+        return this;
+    }
+
     public AnalysisProtoBuilder addAnalysisStep(AnalysisProto.AnalysisStep analysisStep) {
         builder.addSteps(analysisStep);
         return this;
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisSampleValidator.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisSampleValidator.java
index 2ba9892c7..98c55163b 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisSampleValidator.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/AnalysisSampleValidator.java
@@ -95,7 +95,7 @@ private static boolean isHpoDependent(AnalysisStep analysisStep) {
         if (analysisStep instanceof Prioritiser<? extends PriorityResult> prioritiser) {
             PriorityType priorityType = prioritiser.priorityType();
             return switch (priorityType) {
-                case HIPHIVE_PRIORITY, PHENIX_PRIORITY, PHIVE_PRIORITY -> true;
+                case HIPHIVE_PRIORITY, PHENIX_PRIORITY, PHIVE_PRIORITY, BOQA_PRIORITY -> true;
                 case EXOMEWALKER_PRIORITY, OMIM_PRIORITY, NONE -> false;
             };
         }
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/FluentAnalysisBuilder.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/FluentAnalysisBuilder.java
index 3c165730f..d34cf09b2 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/FluentAnalysisBuilder.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/FluentAnalysisBuilder.java
@@ -117,4 +117,6 @@ interface FluentAnalysisBuilder<R> {
 
     public FluentAnalysisBuilder addExomeWalkerPrioritiser(List<Integer> seedGenes);
 
+    public FluentAnalysisBuilder addBoqaPrioritiser();
+
 }
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/JobParser.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/JobParser.java
index 0f057f0e8..6ffa30aa1 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/JobParser.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/JobParser.java
@@ -288,6 +288,8 @@ private void addAnalysisStep(AnalysisBuilder analysisBuilder, InheritanceModeOpt
             analysisBuilder.addPhenixPrioritiser();
         } else if (protoAnalysisStep.hasExomeWalkerPrioritiser()) {
             analysisBuilder.addExomeWalkerPrioritiser(protoAnalysisStep.getExomeWalkerPrioritiser().getSeedGeneIdsList());
+        } else if (protoAnalysisStep.hasBoqaPrioritiser()) {
+            analysisBuilder.addBoqaPrioritiser();
         }
     }
 
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/PassOnlyAnalysisRunner.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/PassOnlyAnalysisRunner.java
index f5ef00098..0967f65af 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/PassOnlyAnalysisRunner.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/analysis/PassOnlyAnalysisRunner.java
@@ -71,7 +71,7 @@ protected List<Gene> getGenesWithVariants(Map<String, Gene> allGenes) {
                 .map(removeFailedVariants())
                 .filter(Gene::hasVariants)
                 .filter(Gene::passedFilters)
-                .collect(Collectors.toUnmodifiableList());
+                .toList();
     }
 
     private UnaryOperator<Gene> removeFailedVariants() {
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
new file mode 100644
index 000000000..b3699df79
--- /dev/null
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
@@ -0,0 +1,228 @@
+package org.monarchinitiative.exomiser.core.prioritisers;
+
+import org.monarchinitiative.exomiser.core.model.Gene;
+import org.monarchinitiative.exomiser.core.prioritisers.model.Disease;
+import org.monarchinitiative.exomiser.core.prioritisers.service.PriorityService;
+import org.monarchinitiative.phenol.ontology.data.TermId;
+import org.p2gx.boqa.core.Counter;
+import org.p2gx.boqa.core.DiseaseData;
+import org.p2gx.boqa.core.PatientData;
+import org.p2gx.boqa.core.analysis.BoqaAnalysisResult;
+import org.p2gx.boqa.core.analysis.BoqaPatientAnalyzer;
+import org.p2gx.boqa.core.analysis.BoqaResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.*;
+
+public class BoqaPrioritiser implements Prioritiser<BoqaPriorityResult> {
+
+    private static final Logger logger = LoggerFactory.getLogger(BoqaPrioritiser.class);
+
+    private final PriorityService priorityService;
+    private final Counter counter;
+
+    public BoqaPrioritiser(PriorityService priorityService, Counter counter) {
+        // TODO: add getCounter(): Counter to Priority Service, then initialise the Counter @Lazy in the exomiser-config
+        // or make a @Lazy Counter bean to inject along with the Priority Service in the PriorityFactoryImpl
+        // The Counter takes about 1 minute to create, so we only want to do that once and only if we really want to use
+        // it. The Counter now takes ~ 300ms to create, but still, it would be best to move it's creation into the config code.
+        this.priorityService = priorityService;
+        this.counter = counter;
+    }
+
+    @Override
+    public PriorityType priorityType() {
+        return PriorityType.BOQA_PRIORITY;
+    }
+
+    @Override
+    public Stream<BoqaPriorityResult> prioritise(List<String> hpoIds, List<Gene> genes) {
+        logger.info("Running BOQA prioritiser...");
+        var observedHpoIds = hpoIds.stream().map(TermId::of).collect(toUnmodifiableSet());
+        PatientData patientData = new ExomiserPatientData(observedHpoIds, Collections.emptySet());
+        BoqaAnalysisResult boqaAnalysisResult = BoqaPatientAnalyzer.computeBoqaResults(patientData, counter, Integer.MAX_VALUE);
+        List<BoqaResult> rescaledBoqaResults = softMaxScaledBoqaResultScores(boqaAnalysisResult.boqaResults());
+        logger.debug("Top 10 BOQA results:");
+        rescaledBoqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).limit(10).forEach(b -> logger.debug("BOQA score: {} {} {}", b.counts().diseaseId(), b.boqaScore(), b.counts().diseaseLabel()));
+        Map<String, BoqaResult> boqaResultsByDiseaseId = rescaledBoqaResults.stream()
+                .collect(toUnmodifiableMap(boqaResult -> boqaResult.counts().diseaseId(), Function.identity()));
+        return genes.stream().map(prioritiseGene(boqaResultsByDiseaseId));
+    }
+
+    /**
+     * Rescales the BOQA result scores to adjust their range. The method normalizes the scores so that
+     * the highest scoring result is scaled to 1.0, while preserving the relative differences between
+     * score values.
+     *
+     * @return the list of rescaled BOQA results with updated scores
+     * @param boqaResults
+     */
+    private static List<BoqaResult> minMaxScaledBoqaResultScores(List<BoqaResult> boqaResults) {
+        // BoqaResult scores are normalised so that they sum to 1 across all results. This leads to tiny, tiny scores.
+        // This uses min-max scaling, which doesn't perform well with outliers. It seems like BOQA produces data with
+        // extreme outliers, so this needs to use a different scaling method.
+        // Min-max scaled score:
+        //   scaled_score = (score - min_score) / (max_score - min_score)
+        // Equivalent to:
+        //   scale_factor = 1 / (max_score - min_score)
+        //   scaled_score = (score - min_score) * scale_factor
+        double minScore = boqaResults.stream().mapToDouble(BoqaResult::boqaScore).min().orElse(0d);
+        double maxScore = boqaResults.stream().mapToDouble(BoqaResult::boqaScore).max().orElse(0d);
+        double scaleFactor = 1 / (maxScore - minScore);
+        return boqaResults.stream()
+                .map(boqaResult -> new BoqaResult(boqaResult.counts(), (boqaResult.boqaScore() - minScore) * scaleFactor))
+                .toList();
+    }
+
+    // TODO: use softmax?
+    private static List<BoqaResult> softMaxScaledBoqaResultScores(List<BoqaResult> boqaResults) {
+        // Apply temperature scaling first
+        double maxScore = boqaResults.stream()
+                .mapToDouble(BoqaResult::boqaScore)
+                .max()
+                .orElse(0.0);
+
+        double total = boqaResults.stream()
+                .mapToDouble(b -> Math.exp(b.boqaScore() - maxScore))
+                .sum();
+        double scaleFactor = 1 / total;
+
+//        return (Math.exp(input) / total) == (Math.expt(score) * ( 1 / total))
+        return boqaResults.stream()
+                .map(boqaResult -> new BoqaResult(boqaResult.counts(), Math.exp(boqaResult.boqaScore() - maxScore) * scaleFactor))
+                .toList();
+    }
+
+    // 1 - ( rank / numTotalDiseases) // rank-scaled score
+    private static List<BoqaResult> rankScaledBoqaResultScores(List<BoqaResult> boqaResults) {
+        int numBoqaResults = boqaResults.size();
+        List<BoqaResult> rankedBoqaResults = boqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).toList();
+        List<BoqaResult> rankScaledResults = new ArrayList<>(numBoqaResults);
+        for (int i = 0; i < numBoqaResults; i++) {
+            BoqaResult boqaResult = rankedBoqaResults.get(i);
+            rankScaledResults.add(new BoqaResult(boqaResult.counts(), 1.0 - (i / (double) numBoqaResults)));
+        }
+        return rankScaledResults;
+    }
+
+
+    /**
+     * If the gene is not contained in the database, we return an empty
+     * but initialized RelevanceScore object. Otherwise, we retrieve a list of
+     * all OMIM and Orphanet diseases associated with the entrez Gene.
+     *
+     **/
+    private Function<Gene, BoqaPriorityResult> prioritiseGene(Map<String, BoqaResult> boqaResultsByDiseaseId) {
+        return gene -> {
+            List<Disease> diseases = priorityService.getDiseaseDataAssociatedWithGeneId(gene.entrezGeneId());
+
+            // n.b. BOQA uses the HPOA phenotypes to generate a score and does not use any gene or MOI specific information,
+            // so the results will be identical for all diseases with the same OMIM id, irrespective of their gene/MOI association
+            // An Exomiser Disease is a disease-gene-moi concept, but again these will all have the same phenotypic
+            // features extracted from the HPOA
+            // new disease table: id, label, source (e.g. HPOA, DDD2G), geneId, geneSymbol, moi, validity (ClinGen/GENCC), triplosensitivity, haploinsufficient, observedPhenotypes, excludedPhenotypes
+            Map<Disease, BoqaResult> boqaResults = diseases.stream()
+                    .filter(disease -> disease.id().startsWith("OMIM"))
+                    .collect(toUnmodifiableMap(Function.identity(), disease -> boqaResultsByDiseaseId.get(disease.diseaseId()), (first, second) -> first));
+
+            double score = boqaResults.values().stream().mapToDouble(BoqaResult::boqaScore).max().orElse(0d);
+            BoqaPriorityResult boqaPriorityResult = new BoqaPriorityResult(gene.entrezGeneId(), gene.geneSymbol(), score, boqaResults);
+            logger.trace("BOQA score for {} is {} {}", gene.geneSymbol(), score, boqaResults);
+            return boqaPriorityResult;
+        };
+    }
+
+    @Override
+    public String toString() {
+        return "BoqaPrioritiser{}";
+    }
+
+    record ExomiserPatientData(Set<TermId> observedTerms,  Set<TermId> excludedTerms) implements PatientData {
+
+        @Override
+        public String getID() {
+            return "";
+        }
+
+        @Override
+        public Set<TermId> getObservedTerms() {
+            return observedTerms;
+        }
+
+        @Override
+        public Set<TermId> getExcludedTerms() {
+            return excludedTerms;
+        }
+
+    }
+
+    private static class ExomiserDiseaseData implements DiseaseData {
+
+        private final Map<String, String> diseaseIdToLabel;
+        private final Map<String, Set<String>> diseaseObservedPhenotypes;
+        private final Map<String, Set<String>> diseaseGeneIds;
+        private final Map<String, Set<String>> diseaseGeneSymbols;
+
+        // TODO: check if there are multiple D2G mappings in the HPO disease2Gene.tsv
+        public ExomiserDiseaseData(List<Disease> diseases) {
+            diseaseIdToLabel = diseases.stream()
+                    .filter(disease -> disease.diseaseId().startsWith("OMIM"))
+                    .collect(toMap(Disease::diseaseId, Disease::diseaseName, (first, second) -> first));
+
+            diseaseObservedPhenotypes = diseases.stream()
+                    .filter(disease -> disease.diseaseId().startsWith("OMIM"))
+                    .collect(toMap(Disease::diseaseId, disease -> Set.copyOf(disease.phenotypeIds()), (first, second) -> first));
+
+            diseaseGeneIds = diseases.stream()
+                    .filter(disease -> disease.diseaseId().startsWith("OMIM"))
+                    .collect(groupingBy(Disease::diseaseId, mapping(disease -> Integer.toString(disease.associatedGeneId()), toUnmodifiableSet())));
+
+            diseaseGeneSymbols = diseases.stream()
+                    .filter(disease -> disease.diseaseId().startsWith("OMIM"))
+                    .collect(groupingBy(Disease::diseaseId, mapping(Disease::associateGeneSymbol, toUnmodifiableSet())));
+
+        }
+
+        @Override
+        public int size() {
+            return diseaseIdToLabel.size();
+        }
+
+        @Override
+        public Set<String> getDiseaseIds() {
+            return diseaseIdToLabel.keySet();
+        }
+
+        @Override
+        public Set<String> getObservedDiseaseFeatures(String diseaseId) {
+            return diseaseObservedPhenotypes.getOrDefault(diseaseId, Set.of());
+        }
+
+        @Override
+        public Set<String> getExcludedDiseaseFeatures(String diseaseId) {
+            return Set.of();
+        }
+
+        @Override
+        public Set<String> getDiseaseGeneIds(String diseaseId) {
+            return diseaseGeneIds.getOrDefault(diseaseId, Set.of());
+        }
+
+        @Override
+        public Set<String> getDiseaseGeneSymbols(String diseaseId) {
+            return diseaseGeneSymbols.getOrDefault(diseaseId, Set.of());
+        }
+
+        @Override
+        public Map<String, String> getIdToLabel() {
+            return diseaseIdToLabel;
+        }
+    }
+
+}
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactory.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactory.java
index da3ce2711..b7ef15fd4 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactory.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactory.java
@@ -43,4 +43,6 @@ public interface PriorityFactory {
 
     HiPhivePriority makeHiPhivePrioritiser(HiPhiveOptions hiPhiveOptions);
 
+    BoqaPrioritiser makeBoqaPrioritiser();
+
 }
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImpl.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImpl.java
index 715952302..fe2ee9c44 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImpl.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImpl.java
@@ -27,6 +27,7 @@
 
 import org.monarchinitiative.exomiser.core.prioritisers.service.PriorityService;
 import org.monarchinitiative.exomiser.core.prioritisers.util.DataMatrix;
+import org.p2gx.boqa.core.Counter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -48,12 +49,14 @@ public class PriorityFactoryImpl implements PriorityFactory {
     private final PriorityService priorityService;
     private final DataMatrix randomWalkMatrix;
     private final Path phenixDataDirectory;
+    private final Counter counter;
 
     @Autowired
-    public PriorityFactoryImpl(PriorityService priorityService, DataMatrix randomWalkMatrix, Path phenixDataDirectory) {
+    public PriorityFactoryImpl(PriorityService priorityService, DataMatrix randomWalkMatrix, Path phenixDataDirectory, Counter boqaCounter) {
         this.priorityService = priorityService;
         this.randomWalkMatrix = randomWalkMatrix;
         this.phenixDataDirectory = phenixDataDirectory;
+        this.counter = boqaCounter;
     }
 
     @Override
@@ -82,4 +85,8 @@ public HiPhivePriority makeHiPhivePrioritiser(HiPhiveOptions hiPhiveOptions) {
         return new HiPhivePriority(hiPhiveOptions, randomWalkMatrix, priorityService);
     }
 
+    @Override
+    public BoqaPrioritiser makeBoqaPrioritiser() {
+        return new BoqaPrioritiser(priorityService, counter);
+    }
 }
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityType.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityType.java
index 9b2800922..bd39c1b41 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityType.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityType.java
@@ -36,6 +36,7 @@ public enum PriorityType {
     PHIVE_PRIORITY,
     //Prioritises against OMIM data
     OMIM_PRIORITY,
+    BOQA_PRIORITY,
     //None - for when you don't want to run any prioritisation
     NONE
 
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DefaultDiseaseDao.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DefaultDiseaseDao.java
index 9d9240d4c..9578f747d 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DefaultDiseaseDao.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DefaultDiseaseDao.java
@@ -71,7 +71,7 @@ private Set<String> parseHpoIds(ResultSet rs) throws SQLException {
         return Set.of();
     }
 
-    @Cacheable(value = "diseases")
+    @Cacheable(value = "geneDiseaseAssociations")
     @Override
     public List<Disease> getDiseaseDataAssociatedWithGeneId(int geneId) {
         String query = "SELECT" +
@@ -90,6 +90,26 @@ public List<Disease> getDiseaseDataAssociatedWithGeneId(int geneId) {
         return jdbcTemplate.query(query, diseaseRowMapper, geneId);
     }
 
+    @Cacheable(value = "allDiseases")
+    @Override
+    public List<Disease> getAllDiseases() {
+        String query = """
+                SELECT\
+                 gene_id AS entrez_id\
+                , symbol AS human_gene_symbol\
+                , d.disease_id AS disease_id\
+                , d.diseasename AS disease_name\
+                , d.type AS disease_type\
+                , d.inheritance AS inheritance_code\
+                , hp_id AS pheno_ids \
+                FROM entrez2sym e, disease_hp dhp, disease d \
+                WHERE dhp.disease_id = d.disease_id \
+                AND e.entrezid = d.gene_id \
+                AND d.type in ('D', 'C', 'S', '?')""";
+
+        return jdbcTemplate.query(query, diseaseRowMapper);
+    }
+
     private final RowMapper<Disease> diseaseRowMapper = (ResultSet rs, int rowNum) -> {
         List<String> phenotypes = List.of(rs.getString("pheno_ids").split(","));
         return Disease.builder()
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DiseaseDao.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DiseaseDao.java
index 5b54d3695..578155190 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DiseaseDao.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/dao/DiseaseDao.java
@@ -35,7 +35,9 @@
  * @author Jules Jacobsen <jules.jacobsen@sanger.ac.uk>
  */
 public interface DiseaseDao {
-        
+
+    List<Disease> getAllDiseases();
+
     Set<String> getHpoIdsForDiseaseId(String diseaseId);
 
     List<Disease> getDiseaseDataAssociatedWithGeneId(int geneId);
diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/service/PriorityService.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/service/PriorityService.java
index cabffbc80..c8adf81ca 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/service/PriorityService.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/service/PriorityService.java
@@ -98,4 +98,8 @@ public List<Disease> getDiseaseDataAssociatedWithGeneId(int geneId) {
         return diseaseDao.getDiseaseDataAssociatedWithGeneId(geneId);
     }
 
+    public List<Disease> getAllDiseaseData() {
+        return diseaseDao.getAllDiseases();
+    }
+
 }
diff --git a/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/analysis.proto b/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/analysis.proto
index 4afe63e3b..447efcded 100644
--- a/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/analysis.proto
+++ b/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/analysis.proto
@@ -73,6 +73,7 @@ message AnalysisStep {
         PhenixPrioritiser phenix_prioritiser = 14;
         PriorityScoreFilter priority_score_filter = 15;
         ExomeWalkerPrioritiser exome_walker_prioritiser = 16;
+        BoqaPrioritiser boqa_prioritiser = 18;
     }
 }
 
diff --git a/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/prioritisers.proto b/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/prioritisers.proto
index 02b542200..9051fd143 100644
--- a/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/prioritisers.proto
+++ b/exomiser-core/src/main/proto/org/monarchinitiative/exomiser/api/v1/prioritisers.proto
@@ -26,4 +26,8 @@ message PhenixPrioritiser {
 
 message ExomeWalkerPrioritiser {
     repeated int32 seed_gene_ids = 1;
+}
+
+message BoqaPrioritiser {
+
 }
\ No newline at end of file
diff --git a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/ExomiserTest.java b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/ExomiserTest.java
index 532999905..d104d328f 100644
--- a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/ExomiserTest.java
+++ b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/ExomiserTest.java
@@ -37,6 +37,7 @@
 import org.monarchinitiative.exomiser.core.model.pathogenicity.PathogenicitySource;
 import org.monarchinitiative.exomiser.core.phenotype.service.OntologyService;
 import org.monarchinitiative.exomiser.core.phenotype.service.TestOntologyService;
+import org.monarchinitiative.exomiser.core.prioritisers.BoqaCounterStub;
 import org.monarchinitiative.exomiser.core.prioritisers.PriorityFactory;
 import org.monarchinitiative.exomiser.core.prioritisers.PriorityFactoryImpl;
 import org.monarchinitiative.exomiser.core.prioritisers.service.TestPriorityServiceFactory;
@@ -58,7 +59,7 @@ public class ExomiserTest {
 
     private final GenomeAnalysisServiceProvider genomeAnalysisServiceProvider = new GenomeAnalysisServiceProvider(TestFactory
             .buildDefaultHg19GenomeAnalysisService());
-    private final PriorityFactory priorityFactory = new PriorityFactoryImpl(TestPriorityServiceFactory.testPriorityService(), DataMatrix.empty(), null);
+    private final PriorityFactory priorityFactory = new PriorityFactoryImpl(TestPriorityServiceFactory.testPriorityService(), DataMatrix.empty(), null, new BoqaCounterStub());
     private final OntologyService ontologyService = TestOntologyService.builder().build();
 
     private final AnalysisFactory analysisFactory = new AnalysisFactory(genomeAnalysisServiceProvider, priorityFactory, ontologyService);
diff --git a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiserTest.java b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiserTest.java
new file mode 100644
index 000000000..f69cd22e8
--- /dev/null
+++ b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiserTest.java
@@ -0,0 +1,98 @@
+package org.monarchinitiative.exomiser.core.prioritisers;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.monarchinitiative.exomiser.core.model.Gene;
+import org.monarchinitiative.exomiser.core.phenotype.PhenotypeMatchService;
+import org.monarchinitiative.exomiser.core.phenotype.dao.HumanPhenotypeOntologyDao;
+import org.monarchinitiative.exomiser.core.phenotype.dao.MousePhenotypeOntologyDao;
+import org.monarchinitiative.exomiser.core.phenotype.dao.ZebraFishPhenotypeOntologyDao;
+import org.monarchinitiative.exomiser.core.phenotype.service.HpoIdChecker;
+import org.monarchinitiative.exomiser.core.phenotype.service.OntologyServiceImpl;
+import org.monarchinitiative.exomiser.core.prioritisers.config.TestDataSourceConfig;
+import org.monarchinitiative.exomiser.core.prioritisers.dao.DefaultDiseaseDao;
+import org.monarchinitiative.exomiser.core.prioritisers.service.ModelServiceImpl;
+import org.monarchinitiative.exomiser.core.prioritisers.service.PriorityService;
+import org.p2gx.boqa.core.Counter;
+import org.p2gx.boqa.core.PatientData;
+import org.p2gx.boqa.core.algorithm.BoqaCounts;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.context.jdbc.Sql;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        BoqaPrioritiserTest.BoqaPriotiserTestConfig.class,
+        TestDataSourceConfig.class,
+        PriorityFactoryImpl.class,
+        PriorityFactoryTestConfig.class,
+        PriorityService.class,
+        OntologyServiceImpl.class,
+        PhenotypeMatchService.class,
+        ModelServiceImpl.class,
+        DefaultDiseaseDao.class,
+        HumanPhenotypeOntologyDao.class,
+        MousePhenotypeOntologyDao.class,
+        ZebraFishPhenotypeOntologyDao.class,
+        HpoIdChecker.class
+})
+@Sql(scripts = {
+        "file:src/test/resources/sql/create_hpo.sql",
+        "file:src/test/resources/sql/create_disease.sql",
+        "file:src/test/resources/sql/create_disease_hp.sql",
+        "file:src/test/resources/sql/create_entrez2sym.sql",
+        "file:src/test/resources/sql/diseaseDaoTestData.sql",
+        "file:src/test/resources/sql/humanPhenotypeOntologyDaoTestData.sql"
+})
+class BoqaPrioritiserTest {
+
+    @Configuration
+    static class BoqaPriotiserTestConfig {
+        @Bean
+        Counter counter() {
+            return new BoqaCounterStub();
+        }
+    }
+
+    @Autowired
+    private PriorityService priorityService;
+    @Autowired
+    private Counter counter;
+
+    private List<String> patientHpoIds() {
+        return List.of(
+                "HP:0010055",
+                "HP:0001363",
+                "HP:0001156",
+                "HP:0011304");
+    }
+
+    private List<Gene> buildGenes() {
+        return List.of(
+                new Gene("FGFR2", 2263),
+                new Gene("ROR2", 4920),
+                new Gene("FREM2", 341640),
+                new Gene("ZNF738", 148203)
+        );
+    }
+
+
+    @Disabled("Non-functional and useless")
+    @Test
+    void testPrioritise() {
+        BoqaPrioritiser instance = new BoqaPrioritiser(priorityService, counter);
+        List<String> patientPhenotypes = patientHpoIds();
+        List<Gene> genes = buildGenes();
+        List<BoqaPriorityResult> results = instance.prioritise(patientPhenotypes, genes).peek(System.out::println).toList();
+    }
+
+}
\ No newline at end of file
diff --git a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/NoneTypePriorityFactoryStub.java b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/NoneTypePriorityFactoryStub.java
index 4bc10ebd7..455acbe74 100644
--- a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/NoneTypePriorityFactoryStub.java
+++ b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/NoneTypePriorityFactoryStub.java
@@ -60,4 +60,9 @@ public ExomeWalkerPriority makeExomeWalkerPrioritiser(List<Integer> entrezSeedGe
     public HiPhivePriority makeHiPhivePrioritiser(HiPhiveOptions hiPhiveOptions) {
         return new HiPhivePriority(hiPhiveOptions, DataMatrix.empty(), TestPriorityServiceFactory.stubPriorityService());
     }
+
+    @Override
+    public BoqaPrioritiser makeBoqaPrioritiser() {
+        return new BoqaPrioritiser(TestPriorityServiceFactory.stubPriorityService(), new BoqaCounterStub());
+    }
 }
diff --git a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImplTest.java b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImplTest.java
index b6165fee4..5a129843d 100644
--- a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImplTest.java
+++ b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/PriorityFactoryImplTest.java
@@ -38,8 +38,10 @@
 import org.monarchinitiative.exomiser.core.prioritisers.dao.DefaultDiseaseDao;
 import org.monarchinitiative.exomiser.core.prioritisers.service.ModelServiceImpl;
 import org.monarchinitiative.exomiser.core.prioritisers.service.PriorityService;
+import org.p2gx.boqa.core.Counter;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
 import org.springframework.test.context.jdbc.Sql;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
@@ -79,6 +81,9 @@ public class PriorityFactoryImplTest {
     @Autowired
     private PriorityFactoryImpl instance;
 
+    @MockitoBean
+    private Counter counter;
+
     @Test
     public void testMakeOmimPrioritiser() {
         assertThat(instance.makeOmimPrioritiser(), instanceOf(OmimPriority.class));
diff --git a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/dao/TestDiseaseDao.java b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/dao/TestDiseaseDao.java
index 5e1a03b40..97c43d995 100644
--- a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/dao/TestDiseaseDao.java
+++ b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/dao/TestDiseaseDao.java
@@ -52,4 +52,9 @@ public Set<String> getHpoIdsForDiseaseId(String diseaseId) {
     public List<Disease> getDiseaseDataAssociatedWithGeneId(int geneId) {
         return geneDiseaseAssociations.getOrDefault(geneId, Collections.emptyList());
     }
+
+    @Override
+    public List<Disease> getAllDiseases() {
+        return List.copyOf(diseases);
+    }
 }
diff --git a/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java b/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java
index 26b906128..6b7f620bd 100644
--- a/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java
+++ b/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java
@@ -25,25 +25,26 @@
 import org.monarchinitiative.exomiser.core.prioritisers.PriorityFactory;
 import org.monarchinitiative.exomiser.core.prioritisers.util.DataMatrix;
 import org.monarchinitiative.exomiser.core.prioritisers.util.DataMatrixIO;
+import org.monarchinitiative.phenol.io.OntologyLoader;
+import org.monarchinitiative.phenol.ontology.data.Ontology;
+import org.p2gx.boqa.core.Counter;
+import org.p2gx.boqa.core.DiseaseData;
+import org.p2gx.boqa.core.algorithm.BoqaSetCounter;
+import org.p2gx.boqa.core.diseases.DiseaseDataParser;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.ComponentScan;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.*;
 
 import java.io.IOException;
 import java.nio.file.DirectoryIteratorException;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
+import java.util.*;
 
 /**
  * @author Jules Jacobsen <j.jacobsen@qmul.ac.uk>
@@ -148,6 +149,43 @@ public Path hpoAnnotationFilePath() {
         return hpoAnnotationFilePath;
     }
 
+    @Bean
+    @Lazy
+    @ConditionalOnMissingBean(name = "hpoOntology")
+    public Ontology hpoOntology() {
+        Path hpoFilePath = phenotypeDataDirectory().resolve("hp.json");
+        Ontology hpoOntology = OntologyLoader.loadOntology(hpoFilePath.toFile());
+        logger.debug("Ontology loaded successfully from {}", hpoFilePath);
+        return hpoOntology;
+    }
+
+    @Bean
+    @Lazy
+    @ConditionalOnMissingBean(name = "boqaCounter")
+    Counter boqaCounter(Ontology hpoOntology) {
+        // Parse disease-HPO associations into DiseaseData object
+        Path hpoaFilePath = phenotypeDataDirectory().resolve("phenotype.hpoa");
+        logger.debug("Importing disease phenotype associations from file: {} ...", hpoaFilePath);
+        DiseaseData diseaseData = null;
+        try {
+            diseaseData = DiseaseDataParser.parseDiseaseDataFromHpoa(hpoaFilePath);
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+        logger.debug("Disease data parsed from {}", hpoaFilePath);
+
+        // n.b. the OMIM entries in the Exomiser database are a subset of the entire HPOA as there are approximately
+        // 1950 OMIM entries without a confirmed gene association
+//        List<Disease> diseases = priorityService.getAllDiseaseData();
+//        DiseaseData exomiserDiseaseData = new BoqaPrioritiser.ExomiserDiseaseData(diseases);
+
+        // Initialize Counter
+        var counter = new BoqaSetCounter(diseaseData, hpoOntology);
+
+        logger.debug("Initialized BoqaSetCounter with {} diseases.", diseaseData.size());
+        return counter;
+    }
+
     /**
      * This needs a lot of RAM and is slow to create from the randomWalkFile, so
      * it's set as lazy use on the command-line.
diff --git a/exomiser-web/src/main/java/org/monarchinitiative/exomiser/web/controller/SubmitJobController.java b/exomiser-web/src/main/java/org/monarchinitiative/exomiser/web/controller/SubmitJobController.java
index b26527bcb..3f39c300f 100644
--- a/exomiser-web/src/main/java/org/monarchinitiative/exomiser/web/controller/SubmitJobController.java
+++ b/exomiser-web/src/main/java/org/monarchinitiative/exomiser/web/controller/SubmitJobController.java
@@ -246,14 +246,14 @@ private void addFilters(AnalysisBuilder analysisBuilder, Float minimumQuality, b
     private void addPrioritiser(AnalysisBuilder analysisBuilder, String prioritiser) {
         PriorityType priorityType = PriorityType.valueOf(prioritiser);
 
-        if (priorityType == PHENIX_PRIORITY) {
-            analysisBuilder.addPhenixPrioritiser();
-        }
-        else if (priorityType == HIPHIVE_PRIORITY) {
-            analysisBuilder.addHiPhivePrioritiser();
-        }
-        else if (priorityType == PHIVE_PRIORITY) {
-            analysisBuilder.addPhivePrioritiser();
+        switch (priorityType) {
+            case PHENIX_PRIORITY -> analysisBuilder.addPhenixPrioritiser();
+            case HIPHIVE_PRIORITY -> analysisBuilder.addHiPhivePrioritiser();
+            case PHIVE_PRIORITY -> analysisBuilder.addPhivePrioritiser();
+            case BOQA_PRIORITY -> analysisBuilder.addBoqaPrioritiser();
+            case EXOMEWALKER_PRIORITY, OMIM_PRIORITY, NONE -> {
+                // Not HPO dependant
+            }
         }
     }
 

From a688324e28eb36b45faf7cd9756164d3fe2464ae Mon Sep 17 00:00:00 2001
From: Jules Jacobsen <j.jacobsen@qmul.ac.uk>
Date: Tue, 28 Oct 2025 16:03:20 +0000
Subject: [PATCH 2/6] Add missing BoqaPriorityResult and BoqaCounterStub
 classes

---
 .../core/prioritisers/BoqaPriorityResult.java | 24 +++++++++++++++++++
 .../core/prioritisers/BoqaCounterStub.java    | 19 +++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPriorityResult.java
 create mode 100644 exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaCounterStub.java

diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPriorityResult.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPriorityResult.java
new file mode 100644
index 000000000..f85227c8a
--- /dev/null
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPriorityResult.java
@@ -0,0 +1,24 @@
+package org.monarchinitiative.exomiser.core.prioritisers;
+
+import org.monarchinitiative.exomiser.core.prioritisers.model.Disease;
+import org.p2gx.boqa.core.analysis.BoqaResult;
+
+import java.util.Map;
+
+/**
+ * This class groups {@link org.p2gx.boqa.core.analysis.BoqaResult} objects by associated gene.
+ *
+ * @param geneId      The NCBI gene id for this gene
+ * @param geneSymbol  The gene symbol for this gene
+ * @param score       The maximum score for all the {@link BoqaResult} linked to this gene
+ * @param boqaResults A map of {@link Disease} to {@link BoqaResult} linked to this gene
+ */
+public record BoqaPriorityResult(int geneId, String geneSymbol, double score,
+                                 Map<Disease, BoqaResult> boqaResults) implements PriorityResult {
+
+    @Override
+    public PriorityType priorityType() {
+        return PriorityType.BOQA_PRIORITY;
+    }
+
+}
diff --git a/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaCounterStub.java b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaCounterStub.java
new file mode 100644
index 000000000..371efea9c
--- /dev/null
+++ b/exomiser-core/src/test/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaCounterStub.java
@@ -0,0 +1,19 @@
+package org.monarchinitiative.exomiser.core.prioritisers;
+
+import org.p2gx.boqa.core.Counter;
+import org.p2gx.boqa.core.PatientData;
+import org.p2gx.boqa.core.algorithm.BoqaCounts;
+
+import java.util.Set;
+
+public class BoqaCounterStub implements Counter {
+    @Override
+    public BoqaCounts computeBoqaCounts(String s, PatientData patientData) {
+        return new BoqaCounts("", "", 0, 0, 0, 0 );
+    }
+
+    @Override
+    public Set<String> getDiseaseIds() {
+        return Set.of();
+    }
+}

From a8ea1d2577e2efff8c6f299934d7185144a3b3b7 Mon Sep 17 00:00:00 2001
From: hansenp <10495485+hansenp@users.noreply.github.com>
Date: Tue, 25 Nov 2025 16:56:33 +0100
Subject: [PATCH 3/6] Implemented rescaling of unnormalized log BOQA scores.

---
 .../core/prioritisers/BoqaPrioritiser.java    | 41 +++++++++++++++++--
 1 file changed, 38 insertions(+), 3 deletions(-)

diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
index b3699df79..ad400cdd9 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
@@ -7,6 +7,7 @@
 import org.p2gx.boqa.core.Counter;
 import org.p2gx.boqa.core.DiseaseData;
 import org.p2gx.boqa.core.PatientData;
+import org.p2gx.boqa.core.algorithm.AlgorithmParameters;
 import org.p2gx.boqa.core.analysis.BoqaAnalysisResult;
 import org.p2gx.boqa.core.analysis.BoqaPatientAnalyzer;
 import org.p2gx.boqa.core.analysis.BoqaResult;
@@ -46,8 +47,11 @@ public Stream<BoqaPriorityResult> prioritise(List<String> hpoIds, List<Gene> gen
         logger.info("Running BOQA prioritiser...");
         var observedHpoIds = hpoIds.stream().map(TermId::of).collect(toUnmodifiableSet());
         PatientData patientData = new ExomiserPatientData(observedHpoIds, Collections.emptySet());
-        BoqaAnalysisResult boqaAnalysisResult = BoqaPatientAnalyzer.computeBoqaResults(patientData, counter, Integer.MAX_VALUE);
-        List<BoqaResult> rescaledBoqaResults = softMaxScaledBoqaResultScores(boqaAnalysisResult.boqaResults());
+        double alpha = 1.0/19077;
+        double beta = 0.9;
+        AlgorithmParameters params = AlgorithmParameters.create(alpha, beta);
+        BoqaAnalysisResult boqaAnalysisResult = BoqaPatientAnalyzer.computeBoqaExomiserResults(patientData, counter, params);
+        List<BoqaResult> rescaledBoqaResults = reScaledRawLogExomiserScores(boqaAnalysisResult.boqaResults());
         logger.debug("Top 10 BOQA results:");
         rescaledBoqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).limit(10).forEach(b -> logger.debug("BOQA score: {} {} {}", b.counts().diseaseId(), b.boqaScore(), b.counts().diseaseLabel()));
         Map<String, BoqaResult> boqaResultsByDiseaseId = rescaledBoqaResults.stream()
@@ -55,6 +59,37 @@ public Stream<BoqaPriorityResult> prioritise(List<String> hpoIds, List<Gene> gen
         return genes.stream().map(prioritiseGene(boqaResultsByDiseaseId));
     }
 
+    /**
+     * Takes a list of BOQA results and transforms the raw BOQA log scores as follows:
+     *
+     *      boqaExomiserScore_i = (boqaRawLogScore_i + abs(min(boqaRawLogScore))) / (max(boqaRawLogScore) + abs(min(boqaRawLogScore)))
+     *
+     * @param boqaResults
+     * @return reScaledBoqaResults
+     */
+    private static List<BoqaResult> reScaledRawLogExomiserScores(List<BoqaResult> boqaResults) {
+
+        int numBoqaResults = boqaResults.size();
+        List<BoqaResult> rankedBoqaResults = boqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).toList();
+        List<BoqaResult> rescaledBoqaResults = new ArrayList<>(numBoqaResults);
+
+        List<Double> rawLogBoqaScores = new ArrayList<>(numBoqaResults);
+        for (int i = 0; i < numBoqaResults; i++) {
+            BoqaResult boqaResult = rankedBoqaResults.get(i);
+            double rawLogBoqaScore = boqaResult.boqaScore();
+            rawLogBoqaScores.add(rawLogBoqaScore);
+        }
+        double x = Math.abs(Collections.min(rawLogBoqaScores));
+        double y = Collections.max(rawLogBoqaScores) + x;
+        for (int i = 0; i < numBoqaResults; i++) {
+            BoqaResult boqaResult = rankedBoqaResults.get(i);
+            double rawLogBoqaScore = rawLogBoqaScores.get(i);
+            double boqaExomiserScore = (rawLogBoqaScore + x) / y;
+            rescaledBoqaResults.add(new BoqaResult(boqaResult.counts(), boqaExomiserScore));
+        }
+        return rescaledBoqaResults;
+    }
+
     /**
      * Rescales the BOQA result scores to adjust their range. The method normalizes the scores so that
      * the highest scoring result is scaled to 1.0, while preserving the relative differences between
@@ -95,7 +130,7 @@ private static List<BoqaResult> softMaxScaledBoqaResultScores(List<BoqaResult> b
 
 //        return (Math.exp(input) / total) == (Math.expt(score) * ( 1 / total))
         return boqaResults.stream()
-                .map(boqaResult -> new BoqaResult(boqaResult.counts(), Math.exp(boqaResult.boqaScore() - maxScore) * scaleFactor))
+                .map(boqaResult -> new BoqaResult(boqaResult.counts(), 0.5))
                 .toList();
     }
 

From 0c8de5baf9688267a32409b2c71eebb840129ed7 Mon Sep 17 00:00:00 2001
From: hansenp <10495485+hansenp@users.noreply.github.com>
Date: Tue, 25 Nov 2025 18:54:07 +0100
Subject: [PATCH 4/6] Cleaned up and simplified (#614).

---
 .../core/prioritisers/BoqaPrioritiser.java    | 64 ++++++++++---------
 1 file changed, 35 insertions(+), 29 deletions(-)

diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
index ad400cdd9..ece7e16c5 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
@@ -14,7 +14,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Stream;
@@ -27,6 +26,8 @@ public class BoqaPrioritiser implements Prioritiser<BoqaPriorityResult> {
 
     private final PriorityService priorityService;
     private final Counter counter;
+    private final double alpha;
+    private final double beta;
 
     public BoqaPrioritiser(PriorityService priorityService, Counter counter) {
         // TODO: add getCounter(): Counter to Priority Service, then initialise the Counter @Lazy in the exomiser-config
@@ -35,6 +36,8 @@ public BoqaPrioritiser(PriorityService priorityService, Counter counter) {
         // it. The Counter now takes ~ 300ms to create, but still, it would be best to move it's creation into the config code.
         this.priorityService = priorityService;
         this.counter = counter;
+        this.alpha = 1.0/19077; // TODO: Make alpha and beta constructor parameters
+        this.beta = 0.9;
     }
 
     @Override
@@ -47,11 +50,9 @@ public Stream<BoqaPriorityResult> prioritise(List<String> hpoIds, List<Gene> gen
         logger.info("Running BOQA prioritiser...");
         var observedHpoIds = hpoIds.stream().map(TermId::of).collect(toUnmodifiableSet());
         PatientData patientData = new ExomiserPatientData(observedHpoIds, Collections.emptySet());
-        double alpha = 1.0/19077;
-        double beta = 0.9;
         AlgorithmParameters params = AlgorithmParameters.create(alpha, beta);
         BoqaAnalysisResult boqaAnalysisResult = BoqaPatientAnalyzer.computeBoqaExomiserResults(patientData, counter, params);
-        List<BoqaResult> rescaledBoqaResults = reScaledRawLogExomiserScores(boqaAnalysisResult.boqaResults());
+        List<BoqaResult> rescaledBoqaResults = reScaledRawLogBoqaExomiserScores(boqaAnalysisResult.boqaResults());
         logger.debug("Top 10 BOQA results:");
         rescaledBoqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).limit(10).forEach(b -> logger.debug("BOQA score: {} {} {}", b.counts().diseaseId(), b.boqaScore(), b.counts().diseaseLabel()));
         Map<String, BoqaResult> boqaResultsByDiseaseId = rescaledBoqaResults.stream()
@@ -59,35 +60,41 @@ public Stream<BoqaPriorityResult> prioritise(List<String> hpoIds, List<Gene> gen
         return genes.stream().map(prioritiseGene(boqaResultsByDiseaseId));
     }
 
+
     /**
-     * Takes a list of BOQA results and transforms the raw BOQA log scores as follows:
+     * Transforms a list of BOQA results by rescaling their raw log scores into the range [0, 1].
      *
-     *      boqaExomiserScore_i = (boqaRawLogScore_i + abs(min(boqaRawLogScore))) / (max(boqaRawLogScore) + abs(min(boqaRawLogScore)))
+     * <p>The transformation is done as follows:</p>
+     * <pre>
+     * boqaExomiserScore_i =
+     *     (boqaRawLogScore_i + abs(min(boqaRawLogScore)))
+     *     / (max(boqaRawLogScore) + abs(min(boqaRawLogScore)))
+     * </pre>
      *
-     * @param boqaResults
-     * @return reScaledBoqaResults
+     * <p>This ensures that the minimum raw score maps to 0, and the maximum maps to 1.</p>
+     *
+     * @param boqaResults the list of BOQA results to rescale
+     * @return a list of BOQA results with rescaled scores
      */
-    private static List<BoqaResult> reScaledRawLogExomiserScores(List<BoqaResult> boqaResults) {
+    private static List<BoqaResult> reScaledRawLogBoqaExomiserScores(List<BoqaResult> boqaResults) {
 
-        int numBoqaResults = boqaResults.size();
-        List<BoqaResult> rankedBoqaResults = boqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).toList();
-        List<BoqaResult> rescaledBoqaResults = new ArrayList<>(numBoqaResults);
+        // Extract raw BOQA log scores
+        List<Double> rawLogBoqaScores =
+                boqaResults.stream()
+                        .map(BoqaResult::boqaScore)
+                        .toList();
 
-        List<Double> rawLogBoqaScores = new ArrayList<>(numBoqaResults);
-        for (int i = 0; i < numBoqaResults; i++) {
-            BoqaResult boqaResult = rankedBoqaResults.get(i);
-            double rawLogBoqaScore = boqaResult.boqaScore();
-            rawLogBoqaScores.add(rawLogBoqaScore);
-        }
-        double x = Math.abs(Collections.min(rawLogBoqaScores));
-        double y = Collections.max(rawLogBoqaScores) + x;
-        for (int i = 0; i < numBoqaResults; i++) {
-            BoqaResult boqaResult = rankedBoqaResults.get(i);
-            double rawLogBoqaScore = rawLogBoqaScores.get(i);
-            double boqaExomiserScore = (rawLogBoqaScore + x) / y;
-            rescaledBoqaResults.add(new BoqaResult(boqaResult.counts(), boqaExomiserScore));
-        }
-        return rescaledBoqaResults;
+        // Compute offset and normalization factor
+        double offset = Math.abs(Collections.min(rawLogBoqaScores));
+        double scale = Collections.max(rawLogBoqaScores) + offset;
+
+        // Rescale
+        return boqaResults.stream()
+                .map(br -> {
+                    double boqaExomiserScore = (br.boqaScore() + offset) / scale;
+                    return new BoqaResult(br.counts(), boqaExomiserScore);
+                })
+                .toList();
     }
 
     /**
@@ -135,6 +142,7 @@ private static List<BoqaResult> softMaxScaledBoqaResultScores(List<BoqaResult> b
     }
 
     // 1 - ( rank / numTotalDiseases) // rank-scaled score
+    // TODO: Produces slightly different phenotype scores when run multiple times in a row.
     private static List<BoqaResult> rankScaledBoqaResultScores(List<BoqaResult> boqaResults) {
         int numBoqaResults = boqaResults.size();
         List<BoqaResult> rankedBoqaResults = boqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).toList();
@@ -146,7 +154,6 @@ private static List<BoqaResult> rankScaledBoqaResultScores(List<BoqaResult> boqa
         return rankScaledResults;
     }
 
-
     /**
      * If the gene is not contained in the database, we return an empty
      * but initialized RelevanceScore object. Otherwise, we retrieve a list of
@@ -259,5 +266,4 @@ public Map<String, String> getIdToLabel() {
             return diseaseIdToLabel;
         }
     }
-
 }

From b5bc3b92af89bff9e7f3dce6015822a4e6700922 Mon Sep 17 00:00:00 2001
From: hansenp <10495485+hansenp@users.noreply.github.com>
Date: Thu, 27 Nov 2025 17:28:47 +0100
Subject: [PATCH 5/6] Switched DiseaseData from DiseaseDataParser to
 DiseaseDataPhenolIngest (#614).

---
 .../PrioritiserAutoConfiguration.java         | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java b/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java
index 6b7f620bd..a95d7fdc8 100644
--- a/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java
+++ b/exomiser-spring-boot-autoconfigure/src/main/java/org/monarchinitiative/exomiser/autoconfigure/phenotype/PrioritiserAutoConfiguration.java
@@ -25,12 +25,17 @@
 import org.monarchinitiative.exomiser.core.prioritisers.PriorityFactory;
 import org.monarchinitiative.exomiser.core.prioritisers.util.DataMatrix;
 import org.monarchinitiative.exomiser.core.prioritisers.util.DataMatrixIO;
+import org.monarchinitiative.phenol.annotations.formats.hpo.HpoDiseases;
+import org.monarchinitiative.phenol.annotations.io.hpo.DiseaseDatabase;
+import org.monarchinitiative.phenol.annotations.io.hpo.HpoDiseaseLoader;
+import org.monarchinitiative.phenol.annotations.io.hpo.HpoDiseaseLoaderOptions;
+import org.monarchinitiative.phenol.annotations.io.hpo.HpoDiseaseLoaders;
 import org.monarchinitiative.phenol.io.OntologyLoader;
 import org.monarchinitiative.phenol.ontology.data.Ontology;
 import org.p2gx.boqa.core.Counter;
 import org.p2gx.boqa.core.DiseaseData;
 import org.p2gx.boqa.core.algorithm.BoqaSetCounter;
-import org.p2gx.boqa.core.diseases.DiseaseDataParser;
+import org.p2gx.boqa.core.diseases.DiseaseDataPhenolIngest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
@@ -45,6 +50,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * @author Jules Jacobsen <j.jacobsen@qmul.ac.uk>
@@ -166,9 +172,16 @@ Counter boqaCounter(Ontology hpoOntology) {
         // Parse disease-HPO associations into DiseaseData object
         Path hpoaFilePath = phenotypeDataDirectory().resolve("phenotype.hpoa");
         logger.debug("Importing disease phenotype associations from file: {} ...", hpoaFilePath);
-        DiseaseData diseaseData = null;
+        DiseaseData diseaseData;
         try {
-            diseaseData = DiseaseDataParser.parseDiseaseDataFromHpoa(hpoaFilePath);
+            //diseaseData = DiseaseDataParser.parseDiseaseDataFromHpoa(hpoaFilePath);
+            Set<DiseaseDatabase> diseaseDatabase = Set.of("OMIM").stream()
+                    .map(DiseaseDatabase::fromString)
+                    .collect(Collectors.toSet());
+            HpoDiseaseLoaderOptions options = HpoDiseaseLoaderOptions.of(diseaseDatabase,false, 100);
+            HpoDiseaseLoader loader = HpoDiseaseLoaders.defaultLoader(hpoOntology(), options);
+            HpoDiseases diseases = loader.load(hpoaFilePath);
+            diseaseData = DiseaseDataPhenolIngest.of(hpoOntology(), diseases);
         } catch (IOException e) {
             throw new IllegalStateException(e);
         }

From b5b65e0061c79d6c01a347b8eda053b936326c33 Mon Sep 17 00:00:00 2001
From: hansenp <10495485+hansenp@users.noreply.github.com>
Date: Tue, 2 Dec 2025 12:47:34 +0100
Subject: [PATCH 6/6] Adjusted BOQA method name to computeBoqaResultsRawLog
 (#614).

---
 .../exomiser/core/prioritisers/BoqaPrioritiser.java           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
index ece7e16c5..d3269e506 100644
--- a/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
+++ b/exomiser-core/src/main/java/org/monarchinitiative/exomiser/core/prioritisers/BoqaPrioritiser.java
@@ -47,11 +47,11 @@ public PriorityType priorityType() {
 
     @Override
     public Stream<BoqaPriorityResult> prioritise(List<String> hpoIds, List<Gene> genes) {
-        logger.info("Running BOQA prioritiser...");
+        logger.info("Running BOQA prioritiser...XXX");
         var observedHpoIds = hpoIds.stream().map(TermId::of).collect(toUnmodifiableSet());
         PatientData patientData = new ExomiserPatientData(observedHpoIds, Collections.emptySet());
         AlgorithmParameters params = AlgorithmParameters.create(alpha, beta);
-        BoqaAnalysisResult boqaAnalysisResult = BoqaPatientAnalyzer.computeBoqaExomiserResults(patientData, counter, params);
+        BoqaAnalysisResult boqaAnalysisResult = BoqaPatientAnalyzer.computeBoqaResultsRawLog(patientData, counter, params);
         List<BoqaResult> rescaledBoqaResults = reScaledRawLogBoqaExomiserScores(boqaAnalysisResult.boqaResults());
         logger.debug("Top 10 BOQA results:");
         rescaledBoqaResults.stream().sorted(Comparator.comparing(BoqaResult::boqaScore)).limit(10).forEach(b -> logger.debug("BOQA score: {} {} {}", b.counts().diseaseId(), b.boqaScore(), b.counts().diseaseLabel()));