OMF: refactoring with breaking changes

- parameters for rotamers are derived from PDB structures by ourselves
- removed LOSSY and INFER_POSITIONS options. User can now just give a
  max error and OMF will figure out by itself the best strategy.
- Increased accuracy by storing angle differences in rotamer compression.
  That means: instead of blindly using the angles from the derived parameters,
  we sacrifice 4 bits to store differences to that optimal angle.
- CANNOT LOAD OMF FILES FROM PREVIOUS VERSIONS ANYMORE

modules/io/pymod/export_omf_io.cc

@@ -56,20 +56,19 @@ void export_omf_io() {
 
   enum_<OMF::OMFOption>("OMFOption")
     .value("DEFAULT_PEPLIB", OMF::DEFAULT_PEPLIB)
-    .value("LOSSY", OMF::LOSSY)
     .value("AVG_BFACTORS", OMF::AVG_BFACTORS)
     .value("ROUND_BFACTORS", OMF::ROUND_BFACTORS)
     .value("SKIP_SS", OMF::SKIP_SS)
     .value("INFER_PEP_BONDS", OMF::INFER_PEP_BONDS)
-    .value("INFER_POS", OMF::INFER_POS)
   ;
 
   class_<OMF, OMFPtr>("OMF",no_init)
-    .def("FromEntity", &OMF::FromEntity, (arg("ent"), arg("options")=0)).staticmethod("FromEntity")
+    .def("FromEntity", &OMF::FromEntity, (arg("ent"), arg("max_error")=0.0, arg("options")=0)).staticmethod("FromEntity")
     .def("FromFile", &OMF::FromFile).staticmethod("FromFile")
     .def("FromBytes", &wrap_from_bytes).staticmethod("FromBytes")
     .def("ToFile", &OMF::ToFile)
     .def("ToBytes", &wrap_to_bytes)
+    .def("GetMaxError", &OMF::GetMaxError)
     .def("GetAU", &OMF::GetAU)
     .def("GetEntity", &OMF::GetEntity)
     .def("GetAUChain", &OMF::GetAUChain)

modules/io/src/mol/omf.hh

@@ -116,6 +116,7 @@ struct ResidueDefinition {
   std::set<int> rotameric_atoms;
   std::vector<ChiDefinition> chi_definitions;
   std::vector<SidechainAtomRule> sidechain_atom_rules;
+  std::set<int> critical_sidechain_angles;
 };
 
 struct ChainData {
@@ -132,13 +133,13 @@ struct ChainData {
 
   void ToStream(std::ostream& stream,
                 const std::vector<ResidueDefinition>& res_def,
-                bool lossy, bool avg_bfactors, bool round_bfactors,
-                bool skip_ss, bool infer_pos) const;
+                Real max_error, bool avg_bfactors, bool round_bfactors,
+                bool skip_ss) const;
 
   void FromStream(std::istream& stream,
                   const std::vector<ResidueDefinition>& res_def,
-                  int version, bool lossy, bool avg_bfactors,
-                  bool round_bfactors, bool skip_ss, bool infer_pos);
+                  int version, Real max_error, bool avg_bfactors,
+                  bool round_bfactors, bool skip_ss);
 
   // chain features
   String ch_name;
@@ -180,15 +181,15 @@ class OMF {
 
 public:
 
-  enum OMFOption {DEFAULT_PEPLIB = 1, LOSSY = 2, AVG_BFACTORS = 4,
-                  ROUND_BFACTORS = 8, SKIP_SS = 16, INFER_PEP_BONDS = 32,
-                  INFER_POS = 64};
+  enum OMFOption {DEFAULT_PEPLIB = 1, AVG_BFACTORS = 2, ROUND_BFACTORS = 4,
+                  SKIP_SS = 8, INFER_PEP_BONDS = 16};
 
   bool OptionSet(OMFOption opt) const {
     return (opt & options_) == opt;
   }
 
   static OMFPtr FromEntity(const ost::mol::EntityHandle& ent,
+                           Real max_error = 0.0,
                            uint8_t options = 0);
 
   static OMFPtr FromFile(const String& fn);
@@ -211,12 +212,12 @@ public:
     return this->GetAUChain(name);
   }
 
-  ost::mol::EntityHandle GetBU(int bu_idx) const;
-
   int GetVersion() const { return version_; }
 
   static int GetCurrentOMFVersion() { return OMF_VERSION; }
 
+  Real GetMaxError() const { return 0.001 * max_error_; }
+
   // data access without requirement of generating a full
   // OpenStructure entity
 
@@ -244,6 +245,7 @@ private:
                  ost::mol::ChainHandle& chain) const;
 
   String name_;
+  uint16_t max_error_;
   std::vector<ResidueDefinition> residue_definitions_;
   std::map<String, ChainDataPtr> chain_data_;
 

modules/io/tests/test_io_omf.py

@@ -127,7 +127,7 @@ class TestOMF(unittest.TestCase):
     def test_default_peplib(self):
         omf = io.OMF.FromEntity(self.ent)
         omf_bytes = omf.ToBytes()
-        omf_def_pep = io.OMF.FromEntity(self.ent, io.OMFOption.DEFAULT_PEPLIB)
+        omf_def_pep = io.OMF.FromEntity(self.ent, options = io.OMFOption.DEFAULT_PEPLIB)
         omf_def_pep_bytes = omf_def_pep.ToBytes()
         loaded_omf_def_pep = io.OMF.FromBytes(omf_def_pep_bytes)
         loaded_ent = loaded_omf_def_pep.GetAU()
@@ -135,24 +135,10 @@ class TestOMF(unittest.TestCase):
         self.assertTrue(len(omf_def_pep_bytes) < len(omf_bytes))
         self.assertTrue(compare_ent(self.ent, loaded_ent))
 
-    def test_lossy(self):
-        omf = io.OMF.FromEntity(self.ent)
-        omf_bytes = omf.ToBytes()
-        omf_lossy = io.OMF.FromEntity(self.ent, io.OMFOption.LOSSY)
-        omf_lossy_bytes = omf_lossy.ToBytes()
-        loaded_omf_lossy = io.OMF.FromBytes(omf_lossy_bytes)
-        loaded_ent = loaded_omf_lossy.GetAU()
-
-        self.assertTrue(len(omf_lossy_bytes) < len(omf_bytes))
-        self.assertFalse(compare_ent(self.ent, loaded_ent))
-        max_dist = math.sqrt(3*0.05*0.05)
-        self.assertTrue(compare_ent(self.ent, loaded_ent,
-                                    at_dist_thresh=max_dist))
-
     def test_avg_bfactors(self):
         omf = io.OMF.FromEntity(self.ent)
         omf_bytes = omf.ToBytes()
-        omf_avg_bfac = io.OMF.FromEntity(self.ent, io.OMFOption.AVG_BFACTORS)
+        omf_avg_bfac = io.OMF.FromEntity(self.ent, options = io.OMFOption.AVG_BFACTORS)
         omf_avg_bfac_bytes = omf_avg_bfac.ToBytes()
         loaded_omf_avg_bfac = io.OMF.FromBytes(omf_avg_bfac_bytes)
         loaded_ent = loaded_omf_avg_bfac.GetAU()
@@ -173,7 +159,7 @@ class TestOMF(unittest.TestCase):
     def test_round_bfactors(self):
         omf = io.OMF.FromEntity(self.ent)
         omf_bytes = omf.ToBytes()
-        omf_round_bfac = io.OMF.FromEntity(self.ent, io.OMFOption.ROUND_BFACTORS)
+        omf_round_bfac = io.OMF.FromEntity(self.ent, options = io.OMFOption.ROUND_BFACTORS)
         omf_round_bfac_bytes = omf_round_bfac.ToBytes()
         loaded_omf_round_bfac = io.OMF.FromBytes(omf_round_bfac_bytes)
         loaded_ent = loaded_omf_round_bfac.GetAU()
@@ -186,7 +172,7 @@ class TestOMF(unittest.TestCase):
     def test_skip_ss(self):
         omf = io.OMF.FromEntity(self.ent)
         omf_bytes = omf.ToBytes()
-        omf_skip_ss = io.OMF.FromEntity(self.ent, io.OMFOption.SKIP_SS)
+        omf_skip_ss = io.OMF.FromEntity(self.ent, options = io.OMFOption.SKIP_SS)
         omf_skip_ss_bytes = omf_skip_ss.ToBytes()
         loaded_omf_skip_ss = io.OMF.FromBytes(omf_skip_ss_bytes)
         loaded_ent = loaded_omf_skip_ss.GetAU()
@@ -199,7 +185,7 @@ class TestOMF(unittest.TestCase):
         omf = io.OMF.FromEntity(self.ent)
         omf_bytes = omf.ToBytes()
         omf_infer_pep_bonds = io.OMF.FromEntity(self.ent,
-                                                io.OMFOption.INFER_PEP_BONDS)
+                                                options = io.OMFOption.INFER_PEP_BONDS)
         omf_infer_pep_bonds_bytes = omf_infer_pep_bonds.ToBytes()
         loaded_omf_infer_pep_bonds = io.OMF.FromBytes(omf_infer_pep_bonds_bytes)
         loaded_ent = loaded_omf_infer_pep_bonds.GetAU()