Merge pull request #611 from carlocamilloni/new_dih

extended fix to learning

Author: carlocamilloni

src/multiego/ensemble.py

@@ -775,26 +775,21 @@ def init_LJ_datasets(meGO_ensemble, matrices, pairs14, exclusion_bonds14, args):
     OO_mask = masking.create_linearized_mask(
         type_ai_mapped.to_numpy(),
         type_aj_mapped.to_numpy(),
-        [("O", "O"), ("OM", "OM"), ("O", "OM")],
+        [("O", "O"), ("O", "OM")],
         symmetrize=True,
     )
-
-    # hydrongen-oxygen attraction
-    HO_mask = masking.create_linearized_mask(
+    OMOM_mask = masking.create_linearized_mask(
         type_ai_mapped.to_numpy(),
         type_aj_mapped.to_numpy(),
-        [("H", "O"), ("H", "OM"), ("H", "OA")],
+        [("OM", "OM")],
         symmetrize=True,
     )
 
-    # oxygen-nitrogen repulsion (when not attractive)
-    ON_mask = masking.create_linearized_mask(
+    # hydrongen-oxygen attraction
+    HO_mask = masking.create_linearized_mask(
         type_ai_mapped.to_numpy(),
         type_aj_mapped.to_numpy(),
-        [
-            ("O", "N"),
-            ("OM", "N"),
-        ],
+        [("H", "O"), ("H", "OM"), ("H", "OA")],
         symmetrize=True,
     )
 
@@ -805,11 +800,11 @@ def init_LJ_datasets(meGO_ensemble, matrices, pairs14, exclusion_bonds14, args):
 
     # TODO
     # here we should iterate over the pairs in type definition amd generate the repulsions
-    # NL-NZ repulsion
+    # NL-NL repulsion
     NN_mask = masking.create_linearized_mask(
         type_ai_mapped.to_numpy(),
         type_aj_mapped.to_numpy(),
-        [("NL", "NL"), ("NZ", "NZ"), ("NL", "NZ")],
+        [("NL", "NL")],
         symmetrize=True,
     )
 
@@ -822,8 +817,8 @@ def init_LJ_datasets(meGO_ensemble, matrices, pairs14, exclusion_bonds14, args):
     train_dataset.loc[OO_mask & ((train_dataset["bond_distance"] != 3) | (~train_dataset["same_chain"])), "rep"] = (
         type_definitions.mg_OO_c12_rep
     )
-    train_dataset.loc[ON_mask & ((train_dataset["bond_distance"] != 3) | (~train_dataset["same_chain"])), "rep"] = (
-        type_definitions.mg_ON_c12_rep
+    train_dataset.loc[OMOM_mask & ((train_dataset["bond_distance"] != 3) | (~train_dataset["same_chain"])), "rep"] = (
+        type_definitions.mg_OMOM_c12_rep
     )
     train_dataset.loc[HH_mask & ((train_dataset["bond_distance"] != 3) | (~train_dataset["same_chain"])), "rep"] = (
         type_definitions.mg_HH_c12_rep
@@ -844,6 +839,7 @@ def init_LJ_datasets(meGO_ensemble, matrices, pairs14, exclusion_bonds14, args):
     train_dataset["mg_sigma"] = pd.Series(pairwise_mg_sigma)
     # special mg sigma cases:
     train_dataset.loc[OO_mask, "mg_sigma"] = (type_definitions.mg_OO_c12_rep) ** (1 / 12) / 2 ** (1 / 6)
+    train_dataset.loc[OMOM_mask, "mg_sigma"] = (type_definitions.mg_OMOM_c12_rep) ** (1 / 12) / 2 ** (1 / 6)
     train_dataset.loc[HH_mask, "mg_sigma"] = type_definitions.mg_HH_c12_rep ** (1 / 12) / 2 ** (1 / 6)
     train_dataset.loc[NN_mask, "mg_sigma"] = (type_definitions.mg_NN_c12_rep) ** (1 / 12) / 2 ** (1 / 6)
     train_dataset.loc[HO_mask, "mg_sigma"] = type_definitions.mg_HO_sigma
@@ -1074,6 +1070,7 @@ def set_sig_epsilon(meGO_LJ, parameters):
         (meGO_LJ["probability"] <= meGO_LJ["limit_rc_att"] * np.maximum(meGO_LJ["rc_probability"], meGO_LJ["rc_threshold"]))
         & (meGO_LJ["probability"] > meGO_LJ["md_threshold"])
         & (meGO_LJ["rc_probability"] > meGO_LJ["md_threshold"])
+        & (meGO_LJ["epsilon_prior"] < 0.0)
     )
     meGO_LJ.loc[condition, "epsilon"] = (-meGO_LJ["rep"] * (meGO_LJ["distance"] / meGO_LJ["rc_distance"]) ** 12).clip(
         lower=-20 * meGO_LJ["rep"], upper=-0.05 * meGO_LJ["rep"]
@@ -1612,12 +1609,8 @@ def make_pairs_exclusion_topology(meGO_ensemble, meGO_LJ_14, args):
             ] = type_definitions.mg_OO_c12_rep
 
             df.loc[
-                (
-                    (df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "OM")
-                )
-                & (
-                    (df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "OM")
-                ),
+                ((df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "OM"))
+                & ((df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "OM")),
                 "c12",
             ] = type_definitions.mg_OMOM_c12_rep
 
@@ -1628,29 +1621,19 @@ def make_pairs_exclusion_topology(meGO_ensemble, meGO_LJ_14, args):
             ] = type_definitions.mg_HH_c12_rep
 
             df.loc[
-                (
-                    (df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "NL")
-                )
-                & (
-                    (df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "NL")
-                ),
+                ((df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "NL"))
+                & ((df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "NL")),
                 "c12",
             ] = type_definitions.mg_NN_c12_rep
 
             df.loc[
                 (
-                    (
-                        (df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "OM")
-                        | (df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "O")
-                    )
-                    & ((df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "N"))
+                    (df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "O")
+                    & (df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "N")
                 )
                 | (
-                    ((df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "N"))
-                    & (
-                        (df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "OM")
-                        | (df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "O")
-                    )
+                    (df["ai"].map(meGO_ensemble["sbtype_type_dict"]) == "N")
+                    & (df["aj"].map(meGO_ensemble["sbtype_type_dict"]) == "O")
                 ),
                 "c12",
             ] = type_definitions.mg_ON_c12_rep

src/multiego/resources/type_definitions.py

@@ -204,23 +204,12 @@ def lj14_generator(df):
 # List of atom type combinations for LJ14 pairs
 atom_type_combinations = [
     # Tuple of atom type combinations for LJ14 pairs
-    #   ("backbone_carbonyl", "sidechain_cb", 0.275, 1.299682e-06, 1),
-    #   ("backbone_oxygen", "sidechain_cb", 1, 1.5e-6, 0),
-    #   ("ct_oxygen", "sidechain_cb", None, 5.0e-7, 0),
     ("backbone_nitrogen", "sidechain_cb", None, 5.0e-7, -1),
     ("first_backbone_nitrogen", "backbone_nitrogen", None, 4.0e-6, 1),
-    #    ("backbone_nitrogen", "backbone_nitrogen", 0.343, None, 1),
-    #    ("backbone_carbonyl", "backbone_carbonyl", 0.5, None, -1),
-    #    ("sidechain_cgs", "backbone_carbonyl", 0.250, 1.2e-6, 0),
-    #    ("sidechain_cgs", "backbone_nitrogen", 0.200, 5.5e-7, 0),
-    #    ("sidechain_cgs", "first_backbone_nitrogen", 0.200, 5.5e-7, 0),
-    #    ("sidechain_cds", "backbone_calpha", 0.100, 5e-7, 0),
 ]
 
 # Special non-local interactions different from basic mg combination rules
 # PROTEIN
-polar_sbtype = ["O", "OA", "OM", "N", "NL", "NT", "NR", "NZ", "NE", "C", "S"]
-hyd_sbtype = ["CH3", "CH2", "CH2r", "CH1", "CAH", "CAH2"]
 special_non_local = [
     {
         "atomtypes": (["O"], ["O"]),  # charged oxygen-oxygen repulsion

tools/make_mat/make_mat.py

@@ -609,28 +609,25 @@ def main_routine(mol_i, mol_j, topology_mego, topology_ref, molecules_name, pref
     OO_mask = masking.create_matrix_mask(
         topology_df_i["mego_type"].to_numpy(),
         topology_df_j["mego_type"].to_numpy(),
-        [("OM", "OM"), ("O", "O"), ("OM", "O")],
+        [("O", "O"), ("OM", "O")],
         symmetrize=True,
     )
-    HH_mask = masking.create_matrix_mask(
+    OMOM_mask = masking.create_matrix_mask(
         topology_df_i["mego_type"].to_numpy(),
         topology_df_j["mego_type"].to_numpy(),
-        [("H", "H")],
+        [("OM", "OM")],
         symmetrize=True,
     )
-    NN_mask = masking.create_matrix_mask(
+    HH_mask = masking.create_matrix_mask(
         topology_df_i["mego_type"].to_numpy(),
         topology_df_j["mego_type"].to_numpy(),
-        [("NL", "NL"), ("NZ", "NZ"), ("NL", "NZ")],
+        [("H", "H")],
         symmetrize=True,
     )
-    ON_mask = masking.create_matrix_mask(
+    NN_mask = masking.create_matrix_mask(
         topology_df_i["mego_type"].to_numpy(),
         topology_df_j["mego_type"].to_numpy(),
-        [
-            ("O", "N"),
-            ("OM", "N"),
-        ],
+        [("NL", "NL")],
         symmetrize=True,
     )
 
@@ -665,10 +662,10 @@ def main_routine(mol_i, mol_j, topology_mego, topology_ref, molecules_name, pref
 
         # define all cutoff using combination rule values and OO_mask
         c12_cutoff = CUTOFF_FACTOR * np.power(np.where(OO_mask, type_definitions.mg_OO_c12_rep, c12_values), 1.0 / 12.0)
+        # apply OMOM correction
+        c12_cutoff = np.where(OMOM_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_OMOM_c12_rep, 1.0 / 12.0), c12_cutoff)
         # apply HH correction
         c12_cutoff = np.where(HH_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_HH_c12_rep, 1.0 / 12.0), c12_cutoff)
-        # apply ON correction
-        c12_cutoff = np.where(ON_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_ON_c12_rep, 1.0 / 12.0), c12_cutoff)
         # apply NN correction
         c12_cutoff = np.where(NN_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_NN_c12_rep, 1.0 / 12.0), c12_cutoff)
 
@@ -691,8 +688,8 @@ def main_routine(mol_i, mol_j, topology_mego, topology_ref, molecules_name, pref
                 1.0 / 12.0,
             ),
         )
+        c12_cutoff = np.where(OMOM_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_OMOM_c12_rep, 1.0 / 12.0), c12_cutoff)
         c12_cutoff = np.where(HH_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_HH_c12_rep, 1.0 / 12.0), c12_cutoff)
-        c12_cutoff = np.where(ON_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_ON_c12_rep, 1.0 / 12.0), c12_cutoff)
         c12_cutoff = np.where(NN_mask, CUTOFF_FACTOR * np.power(type_definitions.mg_NN_c12_rep, 1.0 / 12.0), c12_cutoff)
 
     mismatched = topology_df_i.loc[topology_df_i["ref_type"].str[0] != topology_df_i["mego_name"].str[0]]