def get_ccp4_map(xmap_path):
m = gemmi.read_ccp4_map(str(xmap_path))
m.grid.spacegroup = gemmi.find_spacegroup_by_name("P 1")
m.setup()
return m
def main():
config = Config.from_config()
m = gemmi.read_ccp4_map(str(config.xmap_in))
print(dir(m))
# m.spacegroup = gemmi.find_spacegroup_by_name('P1')
print(m.grid.spacegroup)
m.grid.spacegroup = gemmi.find_spacegroup_by_name('P1')
print(m.grid.spacegroup)
m.setup()
print(m.grid.spacegroup)
m.grid.spacegroup = gemmi.find_spacegroup_by_name('P1')
print(m.grid.spacegroup)
sf = gemmi.transform_map_to_f_phi(m.grid, half_l=True)
print(sf.spacegroup)
# data = sf
print(dir(sf))
data = sf.prepare_asu_data(dmin=config.resolution, with_000=True)
mtz = gemmi.Mtz(with_base=True)
# mtz = gemmi.Mtz()
print(dir(mtz))
mtz.spacegroup = sf.spacegroup
# mtz.spacegroup = gemmi.find_spacegroup_by_name('P1')
# mtz.set_cell_for_all(sf.unit_cell)
mtz.cell = sf.unit_cell
mtz.add_dataset('unknown')
mtz.add_column('FWT', 'F')
mtz.add_column('PHWT', 'P')
mtz.set_data(data)
mtz.write_to_file(str(config.mtz_out))
def test_reading(self):
path = os.path.join(os.path.dirname(__file__), '5i55_tiny.ccp4')
m = gemmi.read_ccp4_map(path)
self.assertEqual(m.grid.nu, 8)
self.assertEqual(m.grid.nv, 6)
self.assertEqual(m.grid.nw, 10)
self.assertEqual(m.header_i32(28), 0)
m.set_header_i32(28, 20140) # set NVERSION
self.assertEqual(m.header_i32(28), 20140)
dmax = m.header_float(21)
self.assertEqual(dmax, max(p.value for p in m.grid))
self.assertNotEqual(m.grid.axis_order, gemmi.AxisOrder.XYZ)
m.setup()
self.assertEqual(m.grid.axis_order, gemmi.AxisOrder.XYZ)
self.assertEqual(m.grid.nu, 60)
self.assertEqual(m.grid.nv, 24)
self.assertEqual(m.grid.nw, 60)
self.assertEqual(m.grid.point_count, 60 * 24 * 60)
self.assertEqual(m.header_float(14), 90.0) # 14 - alpha angle
self.assertEqual(m.grid.unit_cell.alpha, 90.0)
self.assertEqual(m.grid.spacegroup.ccp4, 4) # P21
pos = gemmi.Position(19.4, 3., 21.)
frac = m.grid.unit_cell.fractionalize(pos)
pos_value = 2.1543798446655273
self.assertAlmostEqual(m.grid.interpolate_value(pos), pos_value)
self.assertAlmostEqual(m.grid.interpolate_value(frac), pos_value)
# this spacegroup has symop -x, y+1/2, -z
m.grid.set_value(60 - 3, 24 // 2 + 4, 60 - 5,
100) # image of (3, 4, 5)
self.assertEqual(m.grid.get_value(60 - 3, 24 // 2 + 4, 60 - 5), 100)
self.assertTrue(math.isnan(m.grid.get_value(3, 4, 5)))
m.grid.symmetrize_max()
self.assertEqual(m.grid.get_value(3, 4, 5), 100)
m.grid.set_value(3, 4, 5, float('nan'))
self.assertTrue(math.isnan(m.grid.get_value(3, 4, 5)))
m.grid.symmetrize_min()
self.assertEqual(m.grid.get_value(3, 4, 5), 100)
m.grid.set_value(60 - 3, 24 // 2 + 4, 60 - 5, float('nan'))
m.grid.symmetrize_max()
self.assertEqual(m.grid.get_value(60 - 3, 24 // 2 + 4, 60 - 5), 100)
if numpy:
arr = numpy.array(m.grid, copy=False)
self.assertEqual(arr.shape, (60, 24, 60))
self.assertEqual(arr[3][4][5], 100)
grid2 = gemmi.FloatGrid(arr)
self.assertTrue(
numpy.allclose(m.grid, grid2, atol=0.0, rtol=0,
equal_nan=True))
def test_reading(self):
path = os.path.join(os.path.dirname(__file__), '5i55_tiny.ccp4')
m = gemmi.read_ccp4_map(path)
self.assertEqual(m.grid.nu, 8)
self.assertEqual(m.grid.nv, 6)
self.assertEqual(m.grid.nw, 10)
self.assertEqual(m.header_i32(28), 0)
m.set_header_i32(28, 20140) # set NVERSION
self.assertEqual(m.header_i32(28), 20140)
dmax = m.header_float(21)
self.assertEqual(dmax, max(m.grid))
m.setup()
self.assertEqual(m.grid.nu, 60)
self.assertEqual(m.grid.nv, 24)
self.assertEqual(m.grid.nw, 60)
self.assertEqual(m.header_float(14), 90.0) # 14 - alpha angle
self.assertEqual(m.grid.unit_cell.alpha, 90.0)
def test_reading(self):
path = os.path.join(os.path.dirname(__file__), '5i55_tiny.ccp4')
m = gemmi.read_ccp4_map(path)
self.assertEqual(m.grid.nu, 8)
self.assertEqual(m.grid.nv, 6)
self.assertEqual(m.grid.nw, 10)
self.assertEqual(m.header_i32(28), 0)
m.set_header_i32(28, 20140) # set NVERSION
self.assertEqual(m.header_i32(28), 20140)
dmax = m.header_float(21)
self.assertEqual(dmax, max(m.grid))
self.assertFalse(m.grid.full_canonical)
m.setup()
self.assertTrue(m.grid.full_canonical)
self.assertEqual(m.grid.nu, 60)
self.assertEqual(m.grid.nv, 24)
self.assertEqual(m.grid.nw, 60)
self.assertEqual(m.grid.point_count, 60 * 24 * 60)
self.assertEqual(m.header_float(14), 90.0) # 14 - alpha angle
self.assertEqual(m.grid.unit_cell.alpha, 90.0)
self.assertEqual(m.grid.spacegroup.ccp4, 4) # P21
# this spacegroup has symop -x, y+1/2, -z
m.grid.set_value(60 - 3, 24 // 2 + 4, 60 - 5,
100) # image of (3, 4, 5)
self.assertEqual(m.grid.get_value(60 - 3, 24 // 2 + 4, 60 - 5), 100)
self.assertTrue(math.isnan(m.grid.get_value(3, 4, 5)))
m.grid.symmetrize_max()
self.assertEqual(m.grid.get_value(3, 4, 5), 100)
m.grid.set_value(3, 4, 5, float('nan'))
self.assertTrue(math.isnan(m.grid.get_value(3, 4, 5)))
m.grid.symmetrize_min()
self.assertEqual(m.grid.get_value(3, 4, 5), 100)
m.grid.set_value(60 - 3, 24 // 2 + 4, 60 - 5, float('nan'))
m.grid.symmetrize_max()
self.assertEqual(m.grid.get_value(60 - 3, 24 // 2 + 4, 60 - 5), 100)
if numpy:
arr = numpy.array(m.grid, copy=False)
self.assertEqual(arr.shape, (60, 24, 60))
self.assertEqual(arr[3][4][5], 100)
def get_event_map(event_map_file: Path) -> gemmi.FloatGrid:
m = gemmi.read_ccp4_map(str(event_map_file))
print(m.grid.spacegroup.xhm())
# m.grid.spacegroup = gemmi.find_spacegroup_by_name("P 21 21 21")
m.grid.spacegroup = gemmi.find_spacegroup_by_name("P 1")
print(m.grid.spacegroup.xhm())
m.setup()
grid_array = np.array(m.grid, copy=True)
print(m.grid.spacegroup.xhm())
print(m.grid)
print(grid_array.shape)
new_grid = gemmi.FloatGrid(*grid_array.shape)
new_grid.spacegroup = m.grid.spacegroup # gemmi.find_spacegroup_by_name("P 1")
new_grid.set_unit_cell(m.grid.unit_cell)
new_grid_array = np.array(new_grid, copy=False)
new_grid_array[:, :, :] = grid_array[:, :, :]
return new_grid
#!/usr/bin/env python
import numpy
from matplotlib import pyplot
import gemmi
# toxd_aupatt.map is generated by $CCP4/examples/unix/runnable/patterson
ccp4 = gemmi.read_ccp4_map('/tmp/wojdyr/toxd_aupatt.map')
ccp4.setup()
arr = numpy.array(ccp4.grid, copy=False)
x = numpy.linspace(0, ccp4.grid.unit_cell.a, num=arr.shape[0], endpoint=False)
y = numpy.linspace(0, ccp4.grid.unit_cell.b, num=arr.shape[1], endpoint=False)
X, Y = numpy.meshgrid(x, y, indexing='ij')
pyplot.contour(X, Y, arr[:, :, 40])
pyplot.gca().set_aspect('equal', adjustable='box')
pyplot.show()
def __getitem__(self, item):
event_record = self.table.iloc[item]
event = Event.from_record(event_record)
# print(event.viewed)
# print(type(event.viewed))
if bool(event.viewed) is False:
sample_dict = {
"id": {
"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data":
np.zeros(
(
2,
self.sample_shape[0],
self.sample_shape[1],
self.sample_shape[2],
),
dtype=np.float32,
),
"label":
np.array([1, 0], dtype=np.float32),
"event_map_path":
str(event.event_map_path),
"model_path":
str(event.initial_model_path),
"coords":
str([event.x, event.y, event.z])
}
return sample_dict
try:
event_centroid = np.array([
event.x,
event.y,
event.z,
])
data_map = get_map_from_mtz_path(event.data_path)
event_map: gemmi.Grid = gemmi.read_ccp4_map(event.event_map_path)
rotation = sample_rotation()
translation = sample_translation()
data_map_layer = sample_map(
data_map,
event_centroid,
rotation,
translation,
self.sample_shape,
)
event_map_layer = sample_event_map(
event_map,
event_centroid,
rotation,
translation,
self.sample_shape,
)
data = np.stack(
[data_map_layer, event_map_layer],
axis=0,
)
label = get_label(event)
sample_dict = {
"id": {
"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data": data,
"label": label,
"event_map_path": str(event.event_map_path),
"model_path": str(event.initial_model_path),
"coords": str([event.x, event.y, event.z])
}
return sample_dict
except Exception as e:
# Null result
# print(e)
sample_dict = {
"id": {
"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
# "initial_model_dir": ,
},
"data":
np.zeros(
(
2,
self.sample_shape[0],
self.sample_shape[1],
self.sample_shape[2],
),
dtype=np.float32,
),
"label":
np.array([1, 0], dtype=np.float32),
"event_map_path":
str(event.event_map_path),
"model_path":
str(event.initial_model_path),
"coords":
str([event.x, event.y, event.z])
}
return sample_dict
def prepare_training_data(
mtz_directory: str,
mtz_file: str,
xyz_limits: List[int],
output_directory: str,
db_file: str,
delete_temp: bool = True,
):
"""Convert both the original and inverse hands of a structure into a regular map file based on information
about the cell info and space group and the xyz dimensions. Return True if no exceptions"""
logging.info("Preparing training data")
# Check all directories exist
try:
mtz_dir = Path(mtz_directory)
assert mtz_dir.exists()
except Exception:
logging.error(f"Could not find mtz directory at {mtz_directory}")
raise
try:
output_dir = Path(output_directory)
assert output_dir.exists()
except Exception:
logging.error(f"Could not find output directory at {output_directory}")
raise
# Check xyz limits are of correct format
try:
assert type(xyz_limits) == list or type(xyz_limits) == tuple
assert len(xyz_limits) == 3
assert all(type(values) == int for values in xyz_limits)
except AssertionError:
logging.error(
"xyz_limits muste be provided as a list or tupls of three integer values"
)
raise
# Innitialise connection to database
try:
conn = sqlite3.connect(db_file)
cur = conn.cursor()
except Exception:
logging.error(f"Could not connect to database at {db_file}")
raise
if not os.path.exists(os.path.join(output_dir, "conv_map_list.csv")):
with open(os.path.join(output_dir, "conv_map_list.csv"),
"w") as out_csv:
writer = csv.writer(out_csv)
writer.writerow(["filename", "ai_lable"])
# Get lists of child directories
mtz_structs = [struct.stem for struct in mtz_dir.iterdir()]
mtz_structs = sorted(mtz_structs)
logging.debug(f"Following structures found to transform: {mtz_structs}")
#this below works but runs serial
for struct in mtz_structs:
struct_dir = Path(os.path.join(mtz_dir, struct))
homo_lst = [h**o.stem for h**o in struct_dir.iterdir()]
for h**o in homo_lst:
homo_dir = os.path.join(struct_dir, h**o)
logging.info(
f"Converting results for structure {struct}, {mtz_structs.index(struct)+1}/{len(mtz_structs)}"
)
if mtz_file in os.listdir(homo_dir):
logging.info(
f"Collecting info for {h**o}, {homo_lst.index(h**o)+1}/{len(homo_lst)}"
)
homo_mtz = Path(os.path.join(homo_dir, mtz_file))
try:
homo_mtz = Path(os.path.join(homo_dir, mtz_file))
assert homo_mtz.exists()
except Exception:
logging.error(
f"Could not find homologue phased MTZ file {homo_mtz}")
raise
try:
data = gemmi.read_mtz_file(str(homo_mtz))
cell = data.cell
sg = data.spacegroup
except Exception:
logging.error(f"Could not read {homo_mtz}")
# raise
pass
temp_out_file = os.path.join(
output_dir, "temp_" + struct + "_" + h**o + ".ccp4")
try:
data_to_map = gemmi.Ccp4Map()
print("Grid of MTZ file", data_to_map.grid)
data_to_map.grid = data.transform_f_phi_to_map(
'FWT', 'PHWT', sample_rate=4)
# shape = [round(a/1.2/2)*2 for a in data.cell.parameters[:3]]
# data_to_map.grid = data.transform_f_phi_to_map('FWT', 'PHWT', exact_size=shape)
print("Grid after converting MTZ to MAP", data_to_map.grid)
data_to_map.update_ccp4_header(2, True)
data_to_map.write_ccp4_map(temp_out_file)
except Exception:
logging.error(f"Could not create map from {homo_mtz}")
raise
try:
# opening temporary map file which shouldn't be neccessary to be written out
map_to_map = gemmi.read_ccp4_map(temp_out_file)
map_to_map.setup()
print("Grid after loading temp file", map_to_map.grid)
#this bit here expands the unit cell to be 200A^3;
#Can I expand the unit cell to standard volume and then extract a
#grid cube (200, 200, 200)
# xyz_limits = [200, 200, 200]
# xyz_limits = [100, 100, 100]
xyz_limits = [50, 50, 50]
upper_limit = gemmi.Position(*xyz_limits)
box = gemmi.FractionalBox()
box.minimum = gemmi.Fractional(0, 0, 0)
box.maximum = map_to_map.grid.unit_cell.fractionalize(
upper_limit)
# box.maximum = map_to_map.grid.point_to_fractional(map_to_map.grid.get_point(200, 200, 200))
# box.maximum = map_to_map.grid.point_to_fractional(map_to_map.grid.get_point(100, 100, 100))
box.maximum = map_to_map.grid.point_to_fractional(
map_to_map.grid.get_point(50, 50, 50))
box.add_margin(1e-5)
map_to_map.set_extent(box)
print("Grid after setting XYZ limits for MAP",
map_to_map.grid)
#create a grid with extend x=0-->200, y=0-->200, z=0-->200
#currently problems as the 200 limit not always reached for all axes;
#adding a margin maybe that will help
# new_map.setup()
# box1 = gemmi.FractionalBox()
# box1.minimum = gemmi.Fractional(0, 0, 0)
# box1.maximum = new_map.grid.point_to_fractional(new_map.grid.get_point(200, 200, 200))
# map_to_map.setup()
# new_map.set_extent(box1)
# print("Grid after setting grid dimensions", new_map.grid)
except Exception:
logging.error(f"Could not expand map {map_to_map}")
raise
#
# try:
# map_to_map = gemmi.read_ccp4_map(temp_out_file)
# map_to_map.setup()
# print(map_to_map.grid)
# grid = map_to_map.grid
# print(grid)
# new_grid = grid.set_value(200, 200, 200, 4.0)
# print(new_grid.get_value)
# xyz_limits = [200, 200, 200]
# upper_limit = gemmi.Position(*xyz_limits)
# box = gemmi.FractionalBox()
# box.minimum = gemmi.Fractional(0, 0, 0)
# box.maximum = map_to_map.grid.unit_cell.fractionalize(upper_limit)
# map_to_map.set_extent(box)
# except Exception:
# logging.error(f"Could not expand map {map_to_map}")
# raise
mtz_state = str(mtz_file).strip(".mtz")
final_name = struct + "_" + h**o + "_" + mtz_state + ".ccp4"
final = os.path.join(output_dir, final_name)
# final = os.path.join(output_dir, struct+"_"+h**o+"_"+mtz_state+".ccp4")
try:
map_to_map.write_ccp4_map(final)
# data_to_map.write_ccp4_map(final)
cur.execute('''
SELECT refinement_success_lable, homologue_name_id
FROM homologue_stats
INNER JOIN homologue_name
ON homologue_name.id = homologue_stats.homologue_name_id
INNER JOIN pdb_id
ON pdb_id.id = homologue_name.pdb_id_id
WHERE homologue_name = "%s"
AND pdb_id.pdb_id = "%s"
''' % (h**o, struct))
lable = (cur.fetchone())[0]
print(lable)
#set for MR works and building works
if lable == "1a":
new_lable = 1
else:
new_lable = 0
#focus on the MR solution with building first and then work on the other options
# #set for MR works and building doesn't work
# if lable == "1b":
# new_lable = 1
# else:
# new_lable = 0
# #set for superpositioning works and building works
# if lable == "2a":
# new_lable = 1
# else:
# new_lable = 0
# #set for superpositioning works and building doesn't work
# if lable == "2b":
# new_lable = 1
# else:
# new_lable = 0
print(new_lable)
with open(os.path.join(output_dir, "conv_map_list.csv"),
"a",
newline="") as out_csv:
writer = csv.writer(out_csv)
writer.writerow([final, new_lable])
# writer.writerow([final_name, new_lable])
except Exception:
logging.error(f"Could not write final map {final}")
return True
#!/usr/bin/env python
# Convert CCP4 map to map coefficients in MTZ
import sys
import gemmi
RESOLUTION_LIMIT = 1.5 # set 0 for no limit
if len(sys.argv) != 3:
sys.exit('Usage: map2mtz.py input.ccp4 output.mtz')
m = gemmi.read_ccp4_map(sys.argv[1])
m.setup()
sf = gemmi.transform_map_to_f_phi(m.grid, half_l=True)
data = sf.prepare_asu_data(dmin=RESOLUTION_LIMIT)
mtz = gemmi.Mtz(with_base=True)
mtz.spacegroup = sf.spacegroup
mtz.set_cell_for_all(sf.unit_cell)
mtz.add_dataset('unknown')
mtz.add_column('FWT', 'F')
mtz.add_column('PHWT', 'P')
mtz.set_data(data)
mtz.write_to_file(sys.argv[2])
def __getitem__(self, item):
event_record = self.table.iloc[item]
event = Event.from_record(event_record)
rscc = self.rscc_dict[(event.pandda_name, event.dtag, event.event_idx)]
# if bool(event.viewed) is False:
# sample_dict = {"id": {"pandda_name": event.pandda_name,
# "dtag": event.dtag,
# "event_idx": event.event_idx,
# },
# "data": np.zeros((2,
# self.sample_shape[0],
# self.sample_shape[1],
# self.sample_shape[2],
# ),
# dtype=np.float32,
# ),
# "label": np.array([1, 0], dtype=np.float32),
# "event_map_path": str(event.event_map_path),
# "model_path": str(event.initial_model_path),
# "coords": str([event.x, event.y, event.z]),
# "rscc": 0,
# }
#
# return sample_dict
if float(rscc) == 0.0:
sample_dict = {"id": {"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data": np.zeros((2,
self.sample_shape[0],
self.sample_shape[1],
self.sample_shape[2],
),
dtype=np.float32,
),
"label": np.array([1, 0], dtype=np.float32),
"event_map_path": str(event.event_map_path),
"model_path": str(event.initial_model_path),
"coords": str([event.x, event.y, event.z]),
"rscc": 0.0,
"rscc_class": np.array([1.0,0.0], dtype=np.float32),
}
return sample_dict
try:
event_centroid = np.array([event.x,
event.y,
event.z,
])
data_map = get_map_from_mtz_path(event.data_path)
event_map: gemmi.Grid = gemmi.read_ccp4_map(event.event_map_path)
rotation = sample_rotation()
translation = sample_translation()
data_map_layer = sample_map(data_map,
event_centroid,
rotation,
translation,
self.sample_shape,
)
event_map_layer = sample_event_map(event_map,
event_centroid,
rotation,
translation,
self.sample_shape,
)
data = np.stack([data_map_layer, event_map_layer],
axis=0,
)
label = get_label(event)
if rscc <0.7:
rscc_class = np.array([1.0, 0.0], dtype=np.float32)
else:
rscc_class = np.array([0.0,1.0], dtype=np.float32)
sample_dict = {"id": {"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data": data,
"label": label,
"event_map_path": str(event.event_map_path),
"model_path": str(event.initial_model_path),
"coords": str([event.x, event.y, event.z]),
"rscc": rscc,
"rscc_class": rscc_class,
}
return sample_dict
except Exception as e:
# Null result
# print(e)
sample_dict = {"id": {"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
# "initial_model_dir": ,
},
"data": np.zeros((2,
self.sample_shape[0],
self.sample_shape[1],
self.sample_shape[2],
),
dtype=np.float32,
),
"label": np.array([1, 0], dtype=np.float32),
"event_map_path": str(event.event_map_path),
"model_path": str(event.initial_model_path),
"coords": str([event.x, event.y, event.z]),
"rscc": 0.0,
"rscc_class": np.array([1, 0], dtype=np.float32),
}
return sample_dict
resolution_key = 'high_resolution=' + str(high_res)
file_name_key = 'map_file_name = k_patt_plot_' + str(kk) + '.ccp4'
label_key = 'labels =' + '\'' + I_base + str(kk) + ',' + sig_base + str(
kk) + '\''
if generate_maps == 'y':
subprocess.call([
'cctbx.patterson_map', mtz_name, file_name_key, label_key,
resolution_key
])
else:
break
k = k + 1
#Read in CCP4 format Patterson maps as 3D Numpy arrays and
ccp4 = gemmi.read_ccp4_map('k_patt_plot_000.ccp4')
ccp4.setup()
arr = np.array(ccp4.grid, copy=False)
x = np.linspace(0, ccp4.grid.unit_cell.a, num=arr.shape[0], endpoint=False)
y = np.linspace(0, ccp4.grid.unit_cell.b, num=arr.shape[1], endpoint=False)
plt.plot(y, arr[0, :, 0], label='k = 0')
ccp4 = gemmi.read_ccp4_map('k_patt_plot_015.ccp4')
ccp4.setup()
arr = np.array(ccp4.grid, copy=False)
plt.plot(y, arr[0, :, 0], label='k = 15')
ccp4 = gemmi.read_ccp4_map('k_patt_plot_018.ccp4')
ccp4.setup()
arr = np.array(ccp4.grid, copy=False)
plt.plot(y, arr[0, :, 0], label='k = 18')
def __getitem__(self, item):
event_record = self.table.iloc[item]
event = Event.from_record(event_record)
# print(event.viewed)
# print(type(event.viewed))
if bool(event.viewed) is False:
sample_dict = {
"id": {
"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data": np.zeros(
self.sample_shape,
dtype=np.float32,
),
"label": np.array([1, 0], dtype=np.float32),
}
return sample_dict
try:
event_centroid = np.array([
event.x,
event.y,
event.z,
])
event_map: gemmi.Grid = gemmi.read_ccp4_map(event.event_map_path)
rotation = sample_rotation()
translation = sample_translation()
event_map_layer = sample_event_map(
event_map,
event_centroid,
rotation,
translation,
self.sample_shape,
)
data = event_map_layer
label = get_label(event)
sample_dict = {
"id": {
"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data": data,
"label": label,
}
return sample_dict
except:
# Null result
sample_dict = {
"id": {
"pandda_name": event.pandda_name,
"dtag": event.dtag,
"event_idx": event.event_idx,
},
"data": np.zeros(
self.sample_shape,
dtype=np.float32,
),
"label": np.array([1, 0], dtype=np.float32),
}
return sample_dict
def __getitem__(self, item):
build_record = self.table.iloc[item]
build: Build = Build(
system=build_record["system"],
dtag=build_record["dtag"],
event_idx=build_record["event_idx"],
resolution=float(build_record["resolution"]),
ligand_build_path=Path(build_record["ligand_build_path"]),
stripped_receptor_path=Path(
build_record["stripped_receptor_path"]),
x=float(build_record["x"]),
y=float(build_record["y"]),
z=float(build_record["z"]),
data_path=Path(build_record["data_path"]),
human_build=bool(build_record["human_build"]),
rmsd=float(build_record["rmsd"]),
)
event_centroid = np.array([
build.x,
build.y,
build.z,
])
event_map: gemmi.Grid = gemmi.read_ccp4_map(build.data_path)
if build.human_build:
receptor_model, ligand_model = get_human_build_models(
build.ligand_build_path,
event_centroid=event_centroid,
)
else:
receptor_model = get_receptor_model(build.stripped_receptor_path)
ligand_model = get_ligand_model(build.ligand_build_path)
rotation = sample_rotation()
translation = sample_translation()
event_map_layer = sample_event_map(
event_map,
event_centroid,
rotation,
translation,
self.shape,
)
receptor_layers = sample_receptor_layers(
event_map,
receptor_model,
event_centroid,
rotation,
translation,
self.shape,
)
ligand_layers = sample_ligand_layers(
event_map,
ligand_model,
event_centroid,
rotation,
translation,
self.shape,
)
data = np.concatenate([event_map_layer] + receptor_layers +
ligand_layers)
label = get_label(
build.human_build,
build.rmsd,
event_centroid,
ligand_model,
)
return {
"id": {
"dtag": build.dtag,
"event_idx": build.event_idx
},
"data": data,
"label": label
}
