:> reduction adjustments

:> search configs

Author: InfluenceFunctional

mxtaltools/dataset_utils/construction/featurization_utils.py

@@ -315,7 +315,7 @@ def crystal_filter(crystal,
     if any([len(component.atoms) == 0 for component in crystal.molecule.components]):
         return False, None, None, "Not all components have atoms"
     if len(reduced_crystal.asymmetric_unit_molecule.heavy_atoms) != len(
-            crystal.molecule.heavy_atoms):  # could make this done Z'-by-Z'
+            crystal.asymmetric_unit_molecule.heavy_atoms):  # could make this done Z'-by-Z'
         return False, None, None, "Aunit and mol heavy atoms disagree"
     if len(reduced_crystal.molecule.components) != crystal.z_prime:
         return False, None, None, "Z' != mol components"

mxtaltools/dataset_utils/construction/featurize_cif_chunks.py

@@ -124,7 +124,7 @@ def process_chunk(chunk, chunk_ind, use_filenames_for_identifiers, protonation_s
             crystal_dict = extract_custom_cif_data(cif_path, crystal_dict)
 
             "check sym ops"
-            try:
+            try:  # todo upgrade this to detect if sym ops are identical but out of order
                 sym_ops_are_standard = np.all(np.stack(SYM_OPS[crystal_dict['space_group_number']]) == np.stack(
                     crystal_dict['symmetry_operators']))
             except ValueError:  # sometimes, there are not even the correct multiplicity of space group indexing
@@ -399,14 +399,23 @@ def crystal_rebuild_checks(aunit_centroid,
     #                        protonation_state='deprotonated')
 
     process_cifs_to_chunks(n_chunks=1,
-                           cifs_path=r"D:\crystal_datasets\nehzor",
-                           chunks_path='D:/crystal_datasets/nehzor/',
-                           chunk_prefix='nehzor',
+                           cifs_path=r"D:\crystal_datasets\nacjaf\nikos\round_2_cc_optimized_filtered",
+                           chunks_path='D:/crystal_datasets/nacjaf/',
+                           chunk_prefix='nacjaf',
                            use_filenames_for_identifiers=False,
-                           target_identifiers=['NEHZOR','NEHZOR01'],
+                           target_identifiers=None,
                            filter_by_targets=False,
                            protonation_state='protonated')
 
+    # process_cifs_to_chunks(n_chunks=1,
+    #                        cifs_path=r"D:\crystal_datasets\nehzor",
+    #                        chunks_path='D:/crystal_datasets/nehzor/',
+    #                        chunk_prefix='nehzor',
+    #                        use_filenames_for_identifiers=False,
+    #                        target_identifiers=['NEHZOR','NEHZOR01'],
+    #                        filter_by_targets=False,
+    #                        protonation_state='protonated')
+
     # process_cifs_to_chunks(n_chunks=1,
     #                        cifs_path=r"D:\crystal_datasets\mipcas",
     #                        chunks_path='D:/crystal_datasets/',

mxtaltools/dataset_utils/data_class_methods/crystal_analysis.py

@@ -441,7 +441,7 @@ def mono_reduction_penalty(self, cell_lengths, cell_angles, margin):
         # enforces our reduction scheme
         a, b, c = cell_lengths.unbind(dim=1)
         al, be, ga = cell_angles.unbind(dim=1)
-        be_min_cos = (- a / 2 / c).clamp(min=-1)
+        be_min_cos = (- a / c).clamp(min=-1)
         be_max_cos = 0
         beta_error = self.bounding_penalty(be.cos(), be_min_cos, be_max_cos, margin=margin)
 

mxtaltools/dataset_utils/data_class_methods/crystal_ops.py

@@ -8,7 +8,7 @@
 
 from mxtaltools.common.ase_interface import ase_write_cif
 from mxtaltools.common.geometry_utils import enforce_crystal_system, batch_compute_fractional_transform, \
-    cart2sph_rotvec, sph2cart_rotvec, crystal_parameter_distmat, sph_rotvec2lat, lat2sph_rotvec
+    cart2sph_rotvec, sph2cart_rotvec, crystal_parameter_distmat, sph_rotvec2lat, lat2sph_rotvec, fractional_transform
 from mxtaltools.common.utils import softplus_shift, log_rescale_positive, get_point_density
 from mxtaltools.constants.asymmetric_units import ASYM_UNITS
 from mxtaltools.constants.space_group_info import SYM_OPS, LATTICE_TYPE
@@ -1513,26 +1513,27 @@ def compute_standard_cell(self, return_transform: bool = False):
         target_params = self.full_cell_parameters()
         std_params = []
         permutations = []
-
-        for p in target_params:
+        self.pose_aunit()
+        self.build_unit_cell()
+        for ind, p in enumerate(target_params):
             cellpar = p[:6].clone().numpy()
             cellpar[3:] *= (180 / np.pi)
 
             lattice = cellpar_to_cell(cellpar)
             # dummy atom (needed for spglib)
-            positions = [[0, 0, 0]]
-            numbers = [1]
+            # positions = [[0, 0, 0]]
+            # numbers = [1]
+            positions = fractional_transform(self.unit_cell_pos[self.unit_cell_batch == ind], self.T_cf[ind])
+            numbers = self.z[self.batch == ind].repeat(self.sym_mult[ind]).numpy().tolist()
             cell = (lattice, positions, numbers)
             lattice_std, positions_std, numbers_std = spglib.standardize_cell(
                 cell,
                 to_primitive=False,
                 no_idealize=False
             )
-            #lengths_old = np.linalg.norm(lattice, axis=1)
-            #lengths_new = np.linalg.norm(lattice_std, axis=1)
-            #perm = [np.argmin(np.abs(lengths_old - l)) for l in lengths_new]
-            P = np.linalg.inv(lattice) @ lattice_std
             cellpar_std = cell_to_cellpar(lattice_std)
+
+            P = np.linalg.inv(lattice) @ lattice_std
             std_params.append(cellpar_std)
             permutations.append(P)
         if return_transform:
@@ -1544,7 +1545,10 @@ def write_to_cif(self, inds, mode, path):
         ase_write_cif(self, inds, path, mode)
 
 '''
-positions = fractional_transform(self.unit_cell_pos[self.unit_cell_batch == ind], self.T_cf[0])
+from mxtaltools.common.geometry_utils import fractional_transform
+self.pose_aunit()
+self.build_unit_cell()
+positions = fractional_transform(self.unit_cell_pos[self.unit_cell_batch == ind], self.T_cf[ind])
 numbers = self.z[self.batch == ind].repeat(self.sym_mult[ind]).numpy().tolist()
 cell = (lattice, positions, numbers)
 lattice_std, positions_std, numbers_std = spglib.standardize_cell(