diff --git a/actions/ost-compare-structures b/actions/ost-compare-structures
index fc0e08fbf6e5655185d05cf680ff4643089e71da..3562b2c6cc5e4d273d4d9ba640561125e2d91eae 100644
--- a/actions/ost-compare-structures
+++ b/actions/ost-compare-structures
@@ -738,12 +738,7 @@ def _Main():
                 ost.LogInfo("lDDT settings: ")
                 ost.LogInfo(str(lddt_settings).rstrip())
                 ost.LogInfo("===")
-                oligo_lddt_scorer = qsscoring.OligoLDDTScorer(
-                    qs_scorer.qs_ent_1.ent,
-                    qs_scorer.qs_ent_2.ent,
-                    qs_scorer.alignments,
-                    qs_scorer.calpha_only,
-                    lddt_settings)
+                oligo_lddt_scorer = qs_scorer.GetOligoLDDTScorer(lddt_settings)
                 for scorer_index, lddt_scorer in enumerate(
                         oligo_lddt_scorer.sc_lddt_scorers):
                     # Get chains and renumber according to alignment (for lDDT)
diff --git a/modules/mol/alg/pymod/qsscoring.py b/modules/mol/alg/pymod/qsscoring.py
index f33b21707bbbaf61353f6470966b08bd89770298..aa37d37da25555a9749c95fec0f205fc8fb4f8f6 100644
--- a/modules/mol/alg/pymod/qsscoring.py
+++ b/modules/mol/alg/pymod/qsscoring.py
@@ -448,6 +448,13 @@ class QSscorer:
       self._clustalw_bin = settings.Locate(('clustalw', 'clustalw2'))
     return self._clustalw_bin
 
+  def GetOligoLDDTScorer(self, settings):
+    """
+    :return: :class:`OligoLDDTScorer` object, setup for this QS scoring problem.
+    """
+    return OligoLDDTScorer(self.qs_ent_1.ent, self.qs_ent_2.ent,
+                           self.alignments, self.calpha_only, settings)
+
   ##############################################################################
   # Class internal helpers (anything that doesnt easily work without this class)
   ##############################################################################
@@ -829,11 +836,13 @@ def GetContacts(entity, calpha_only, dist_thr=12.0):
 class OligoLDDTScorer(object):
   """A simple class to calculate oligomeric lDDT score."""
 
+  # TODO: DOCUMENT
+
   def __init__(self, ref, mdl, alignments, calpha_only, settings):
     if mdl.chain_count > ref.chain_count:
       LogWarning('MODEL contains more chains than REFERENCE, '
                  'lDDT is not considering them')
-    # get single chain reference and model
+    # prepare fields
     self.ref = ref
     self.mdl = mdl
     self.alignments = alignments
@@ -852,19 +861,13 @@ class OligoLDDTScorer(object):
   @property
   def lddt_ref(self):
     if self._lddt_ref is None:
-      self._lddt_ref, self._lddt_mdl = _MergeAlignedChains(self.alignments,
-                                                           self.ref,
-                                                           self.mdl,
-                                                           self.calpha_only)
+      self._PrepareOligoEntities()
     return self._lddt_ref
 
   @property
   def lddt_mdl(self):
     if self._lddt_mdl is None:
-      self._lddt_ref, self._lddt_mdl = _MergeAlignedChains(self.alignments,
-                                                           self.ref,
-                                                           self.mdl,
-                                                           self.calpha_only)
+      self._PrepareOligoEntities()
     return self._lddt_mdl
 
   @property
@@ -982,6 +985,17 @@ class OligoLDDTScorer(object):
         self._weighted_lddt = 0.0
     return self._weighted_lddt
 
+  ##############################################################################
+  # Class internal helpers (anything that doesnt easily work without this class)
+  ##############################################################################
+
+  def _PrepareOligoEntities(self):
+    # simple wrapper to avoid code duplication
+    self._lddt_ref, self._lddt_mdl = _MergeAlignedChains(self.alignments,
+                                                         self.ref,
+                                                         self.mdl,
+                                                         self.calpha_only)
+
 
 ###############################################################################
 # HELPERS
diff --git a/modules/mol/alg/tests/test_qsscoring.py b/modules/mol/alg/tests/test_qsscoring.py
index 161d004020e2a1cb1b1d8d5d7ce0a0bea02df952..7e63de558791de2da4ab2701d56a046df1f17efb 100644
--- a/modules/mol/alg/tests/test_qsscoring.py
+++ b/modules/mol/alg/tests/test_qsscoring.py
@@ -380,13 +380,9 @@ class TestQSscore(unittest.TestCase):
     # lDDT is not symmetrical and does not account for overprediction!
     ref = _LoadFile('4br6.1.pdb').Select('cname=A,B')
     mdl = _LoadFile('4br6.1.pdb')
+    lddt_settings = lDDTSettings(structural_checks=False)
     qs_scorer = QSscorer(ref, mdl)
-    lddt_oligo_scorer = OligoLDDTScorer(
-        qs_scorer.qs_ent_1.ent,
-        qs_scorer.qs_ent_2.ent,
-        qs_scorer.alignments,
-        qs_scorer.calpha_only,
-        settings=lDDTSettings(structural_checks=False))
+    lddt_oligo_scorer = qs_scorer.GetOligoLDDTScorer(lddt_settings)
     self.assertAlmostEqual(qs_scorer.global_score, 0.171, 2)
     self.assertAlmostEqual(qs_scorer.best_score, 1.00, 2)
     self.assertAlmostEqual(lddt_oligo_scorer.oligo_lddt, 1.00, 2)
@@ -394,12 +390,7 @@ class TestQSscore(unittest.TestCase):
     qs_scorer2 = QSscorer(qs_scorer.qs_ent_2,
                           qs_scorer.qs_ent_1,
                           res_num_alignment=True)
-    lddt_oligo_scorer2 = OligoLDDTScorer(
-        qs_scorer2.qs_ent_1.ent,
-        qs_scorer2.qs_ent_2.ent,
-        qs_scorer2.alignments,
-        qs_scorer2.calpha_only,
-        settings=lDDTSettings(structural_checks=False))
+    lddt_oligo_scorer2 = qs_scorer2.GetOligoLDDTScorer(lddt_settings)
     self.assertAlmostEqual(qs_scorer2.global_score, 0.171, 2)
     self.assertAlmostEqual(qs_scorer2.best_score, 1.00, 2)
     self.assertAlmostEqual(lddt_oligo_scorer2.oligo_lddt, 0.4496, 2)