class LightdockFromFileInitializer(Initializer):
"""This initializer takes into account the complex provided by the adapter"""
def __init__(self, adapters, scoring_functions, number_of_glowworms,
gso_parameters, dimensions, initial_population_file,
step_translation, step_rotation, random_number_generator,
step_nmodes, anm_rec, anm_lig):
super(LightdockFromFileInitializer,
self).__init__(scoring_functions, number_of_glowworms,
gso_parameters)
self.dimensions = dimensions
self.initial_population_file = initial_population_file
self.adapters = adapters
self.step_translation = step_translation
self.step_rotation = step_rotation
self.step_nmodes = step_nmodes
# Patch to not mess with old simulations
self.random_number_generator = MTGenerator(
random_number_generator.seed)
self.anm_rec = anm_rec
self.anm_lig = anm_lig
def generate_landscape_positions(self):
"""Generates a list of landscape positions that have been read
from initial_population_file.
"""
reader = CoordinatesFileReader(self.dimensions)
coordinates = reader.get_coordinates_from_file(
self.initial_population_file)
if not coordinates:
raise GSOCoordinatesError(
"No coordinates have been read from %s file" %
self.initial_population_file)
if len(coordinates) != self.number_of_glowworms:
raise GSOCoordinatesError(
"Number of coordinates read and number of glowworms does not correspond"
)
positions = []
for i, adapter in enumerate(self.adapters):
positions.append([])
for index in range(self.number_of_glowworms):
receptor_index = self.random_number_generator.randint(
0,
len(self.adapters[0].receptor_model) - 1)
ligand_index = self.random_number_generator.randint(
0,
len(self.adapters[0].ligand_model) - 1)
positions[i].append(
DockingLandscapePosition(
self.objective_functions[i], coordinates[index],
adapter.receptor_model, adapter.ligand_model,
receptor_index, ligand_index, self.step_translation,
self.step_rotation, self.step_nmodes, self.anm_rec,
self.anm_lig))
return positions
def test_populate_poses_restraints_only_receptor(self):
to_generate = 3
center = [15., 15., 15.]
radius = 10.
seed = 1984
number_generator = MTGenerator(seed)
# No needed if no restraints are provided
rec_translation = [0., 0., 0.]
lig_translation = [-15.0, -15.0, -15.0]
# Restraints
receptor_restraints = [Residue.dummy(1.0, 1.0, 1.0)]
ligand_diameter = 10.
poses = populate_poses(to_generate, center, radius, number_generator, rec_translation, lig_translation,
receptor_restraints=receptor_restraints, ligand_diameter=ligand_diameter)
expected = [[12.270567117106161, 14.884113636383933, 11.792201743436038, -0.6725323168859286, 0.5755106199757826, -0.37756439233549577, 0.27190612107759393],
[12.715708176897868, 9.881149636072841, 18.262252550718056, -0.6132005094145724, 0.757439137867041, -0.0367297456106423, -0.22118321244687617],
[17.906625032282104, 11.374830853855302, 8.903837618881248, -0.8727759595729266, -0.22555077047578467, -0.2572320124803007, 0.3481675833340481]]
# We generate 3 poses
assert len(poses) == 3
# We generate poses with ANM
assert len(poses[0]) == 7
# We generate the expected poses
assert np.allclose(expected, poses)
def test_populate_poses_restraints_only_ligand(self):
to_generate = 3
center = [15., 15., 15.]
radius = 10.
seed = 1984
number_generator = MTGenerator(seed)
# No needed if no restraints are provided
rec_translation = [0., 0., 0.]
lig_translation = [-15.0, -15.0, -15.0]
# Restraints
ligand_restraints = [Residue.dummy(16.0, 16.0, 16.0)]
ligand_diameter = 30.
poses = populate_poses(to_generate, center, radius, number_generator, rec_translation, lig_translation,
ligand_restraints=ligand_restraints, ligand_diameter=ligand_diameter)
expected = [[12.270567117106161, 14.884113636383933, 11.792201743436038, 0.7092076459798842, 0.5346980891115, -0.08272585379354264, -0.4519722353179574],
[22.833743558777538, 15.523806353077699, 17.906625032282104, 0.24053986913227657, -0.25327548418133206, -0.5237151871050496, 0.7769906712863817],
[8.903837618881248, 8.747779486586737, 19.195006601282643, 0.7560980480558669, -0.46621474071247004, 0.45925053854810693, 0.00696420216436307]]
# We generate 3 poses
assert len(poses) == 3
# We generate poses with ANM
assert len(poses[0]) == 7
# We generate the expected poses
assert np.allclose(expected, poses)
def test_GSO_with_report_in_file_and_saving_intermediary_files(self):
objective_function = J5()
self.gso_parameters.initial_vision_range = 3.0
self.gso_parameters.max_vision_range = 3.0
bounding_box = BoundingBox(
[Boundary(-2.0 * pi, 2.0 * pi),
Boundary(-2.0 * pi, 2.0 * pi)])
number_of_glowworms = 5
random_number_generator = MTGenerator(324324)
builder = GSOBuilder()
gso = builder.create_from_file(
number_of_glowworms, random_number_generator, self.gso_parameters,
objective_function, bounding_box,
self.golden_data_path + 'initial_positions_redux.txt')
gso.run(5,
saving_path=self.test_path,
save_intermediary=True,
save_all_intermediary=True)
for i in range(5):
assert os.path.exists(self.test_path + 'gso_%d.out' % (i + 1))
gso.report(self.test_path + 'report.out')
lines = open(self.test_path + 'report.out').readlines()
assert 14 == len(lines)
def test_populate_poses_both_restraints(self):
to_generate = 3
center = [15., 15., 15.]
radius = 10.
seed = 1984
number_generator = MTGenerator(seed)
# No needed if no restraints are provided
rec_translation = [0., 0., 0.]
lig_translation = [-15.0, -15.0, -15.0]
# Restraints
receptor_restraints = [Residue.dummy(1.0, 1.0, 1.0)]
ligand_restraints = [Residue.dummy(16.0, 16.0, 16.0)]
ligand_diameter = 10.
poses = populate_poses(to_generate, center, radius, number_generator, rec_translation, lig_translation,
receptor_restraints=receptor_restraints, ligand_restraints=ligand_restraints,
ligand_diameter=ligand_diameter)
expected = [[12.270567117106161, 14.884113636383933, 11.792201743436038, 0.05643308208136652, 0.7572287178886188, -0.11715469622945059, -0.6400740216591683],
[21.986658842426436, 12.715708176897868, 9.881149636072841, 0.17754420770338322, 0.179865123253213, -0.7681474466249519, 0.5882823233717389],
[22.833743558777538, 15.523806353077699, 17.906625032282104, 0.0847943426151146, -0.2599970108635702, -0.5376137514110186, 0.7976107622745888]]
# We generate 3 poses
assert len(poses) == 3
# We generate poses with ANM
assert len(poses[0]) == 7
# We generate the expected poses
assert np.allclose(expected, poses)
def set_gso(number_of_glowworms,
adapters,
scoring_functions,
initial_positions,
seed,
step_translation,
step_rotation,
configuration_file=None,
use_anm=False,
nmodes_step=0.1,
anm_rec=DEFAULT_NMODES_REC,
anm_lig=DEFAULT_NMODES_LIG,
local_minimization=False):
"""Creates a lightdock GSO simulation object"""
bounding_box = get_default_box(use_anm, anm_rec, anm_lig)
random_number_generator = MTGenerator(seed)
if configuration_file:
gso_parameters = GSOParameters(configuration_file)
else:
gso_parameters = GSOParameters()
builder = LightdockGSOBuilder()
if not use_anm:
anm_rec = anm_lig = 0
gso = builder.create_from_file(number_of_glowworms,
random_number_generator, gso_parameters,
adapters, scoring_functions, bounding_box,
initial_positions, step_translation,
step_rotation, nmodes_step,
local_minimization, anm_rec, anm_lig)
return gso
def setUp(self):
self.golden_data_path = os.path.normpath(os.path.dirname(os.path.realpath(__file__))) + '/golden_data/'
self.gso_parameters = GSOParameters()
self.objective_function = J1()
self.bounding_box = BoundingBox([Boundary(1, 2), Boundary(10, 15)])
self.number_of_glowworms = 50
self.random_number_generator = MTGenerator(324324)
def __init__(self):
self.golden_data_path = Path(
__file__).absolute().parent / 'golden_data'
self.gso_parameters = GSOParameters()
self.objective_function = J1()
self.bounding_box = BoundingBox([Boundary(1, 2), Boundary(10, 15)])
self.number_of_glowworms = 50
self.random_number_generator = MTGenerator(324324)
def test_get_random(self):
q1 = Quaternion.random()
assert_almost_equals(1.0, q1.norm())
rng = MTGenerator(1379)
q2 = Quaternion.random(rng)
expected = Quaternion(0.53224081, -0.00589472, 0.84280352, 0.07979471)
assert expected == q2
def __init__(self, adapters, scoring_functions, number_of_glowworms,
gso_parameters, dimensions, initial_population_file,
step_translation, step_rotation, random_number_generator,
step_nmodes, anm_rec, anm_lig):
super(LightdockFromFileInitializer,
self).__init__(scoring_functions, number_of_glowworms,
gso_parameters)
self.dimensions = dimensions
self.initial_population_file = initial_population_file
self.adapters = adapters
self.step_translation = step_translation
self.step_rotation = step_rotation
self.step_nmodes = step_nmodes
# Patch to not mess with old simulations
self.random_number_generator = MTGenerator(
random_number_generator.seed)
self.anm_rec = anm_rec
self.anm_lig = anm_lig
class LightdockFromFileInitializer(Initializer):
"""This initializer takes into account the complex provided by the adapter"""
def __init__(self, adapters, scoring_functions, number_of_glowworms, gso_parameters,
dimensions, initial_population_file, step_translation, step_rotation,
random_number_generator, step_nmodes, anm_rec, anm_lig):
super(LightdockFromFileInitializer, self).__init__(scoring_functions, number_of_glowworms, gso_parameters)
self.dimensions = dimensions
self.initial_population_file = initial_population_file
self.adapters = adapters
self.step_translation = step_translation
self.step_rotation = step_rotation
self.step_nmodes = step_nmodes
# Patch to not mess with old simulations
self.random_number_generator = MTGenerator(random_number_generator.seed)
self.anm_rec = anm_rec
self.anm_lig = anm_lig
def generate_landscape_positions(self):
"""Generates a list of landscape positions that have been read
from initial_population_file.
"""
reader = CoordinatesFileReader(self.dimensions)
coordinates = reader.get_coordinates_from_file(self.initial_population_file)
if not coordinates:
raise GSOCoordinatesError("No coordinates have been read from %s file" % self.initial_population_file)
if len(coordinates) != self.number_of_glowworms:
raise GSOCoordinatesError("Number of coordinates read and number of glowworms does not correspond")
positions = []
for i, adapter in enumerate(self.adapters):
positions.append([])
for index in range(self.number_of_glowworms):
receptor_index = self.random_number_generator.randint(0, len(self.adapters[0].receptor_model)-1)
ligand_index = self.random_number_generator.randint(0, len(self.adapters[0].ligand_model)-1)
positions[i].append(DockingLandscapePosition(self.objective_functions[i], coordinates[index],
adapter.receptor_model, adapter.ligand_model,
receptor_index, ligand_index,
self.step_translation, self.step_rotation,
self.step_nmodes, self.anm_rec, self.anm_lig))
return positions
def test_generate_landscape_positions_num_glowworms_different(self):
gso_parameters = GSOParameters()
number_of_glowworms = 10
seed = 324324
random_number_generator = MTGenerator(seed)
initializer = LightdockFromFileInitializer(
self.adapter, self.scoring_function, number_of_glowworms,
gso_parameters, 7,
self.golden_data_path / 'initial_positions_1PPE.txt', 0.5, 0.5,
random_number_generator, 0.5, 10, 10)
swarm = initializer.generate_glowworms()
assert swarm.get_size() > 0
def test_create_swarm(self):
gso_parameters = GSOParameters()
number_of_glowworms = 5
seed = 324324
random_number_generator = MTGenerator(seed)
initializer = LightdockFromFileInitializer(
[self.adapter], [self.scoring_function], number_of_glowworms,
gso_parameters, 7,
self.golden_data_path / 'initial_positions_1PPE.txt', 0.5, 0.5,
random_number_generator, 0.5, 10, 10)
swarm = initializer.generate_glowworms()
assert number_of_glowworms == swarm.get_size()
def test_get_random_point_within_sphere(self):
seed = 1984
rng = MTGenerator(seed)
to_generate = 10
radius = 10.0
points = [get_random_point_within_sphere(rng, radius) for _ in range(to_generate)]
# Check all generated points are within a sphere of a given radius and
# centered at the origin
for p in points:
assert p[0] <= radius and p[0] >= -radius
assert p[1] <= radius and p[1] >= -radius
assert p[2] <= radius and p[2] >= -radius
def __init__(self, adapters, scoring_functions, number_of_glowworms, gso_parameters,
dimensions, initial_population_file, step_translation, step_rotation,
random_number_generator, step_nmodes, anm_rec, anm_lig):
super(LightdockFromFileInitializer, self).__init__(scoring_functions, number_of_glowworms, gso_parameters)
self.dimensions = dimensions
self.initial_population_file = initial_population_file
self.adapters = adapters
self.step_translation = step_translation
self.step_rotation = step_rotation
self.step_nmodes = step_nmodes
# Patch to not mess with old simulations
self.random_number_generator = MTGenerator(random_number_generator.seed)
self.anm_rec = anm_rec
self.anm_lig = anm_lig
def __init__(self):
self.path = Path(__file__).absolute().parent
self.test_path = self.path / 'scratch_lightdockbuilder'
self.golden_data_path = self.path / 'golden_data'
self.gso_parameters = GSOParameters()
self.bounding_box = BoundingBox([
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION)
])
self.random_number_generator = MTGenerator(324324)
def test_GSO_with_J1(self):
objective_function = J1()
bounding_box = BoundingBox([Boundary(-3.0, 3.0), Boundary(-3.0, 3.0)])
number_of_glowworms = 50
random_number_generator = MTGenerator(324324)
builder = GSOBuilder()
gso = builder.create(number_of_glowworms, random_number_generator,
self.gso_parameters, objective_function,
bounding_box)
gso.run(200)
# Function peak coordinates
peak_coordinates = [[1.28, 0.0], [0.0, 1.58], [-0.46, -0.63]]
# Check with auxiliar function the position of the glowworms
assert self.found_peaks(peak_coordinates, 2, gso.swarm.glowworms)
def test_create_swarm(self):
objective_function = J1()
gso_parameters = GSOParameters()
number_of_glowworms = 15
seed = 324324
random_number_generator = MTGenerator(seed)
bounding_box = BoundingBox([Boundary(1, 2), Boundary(10, 15)])
initializer = RandomInitializer([objective_function],
number_of_glowworms, gso_parameters,
bounding_box, random_number_generator)
swarm = initializer.generate_glowworms()
assert number_of_glowworms == swarm.get_size()
for glowworm in swarm.glowworms:
coordinates = glowworm.landscape_positions[0].coordinates
assert coordinates[0] < 2 and coordinates[0] >= 1
assert coordinates[1] < 15 and coordinates[1] >= 10
def test_GSO_with_J2(self):
objective_function = J2()
self.gso_parameters.initial_vision_range = 2.0
self.gso_parameters.max_vision_range = 2.0
bounding_box = BoundingBox([Boundary(-1.0, 1.0), Boundary(-1.0, 1.0)])
number_of_glowworms = 70
random_number_generator = MTGenerator(324324)
builder = GSOBuilder()
gso = builder.create(number_of_glowworms, random_number_generator,
self.gso_parameters, objective_function,
bounding_box)
gso.run(200)
# Function peak coordinates
peak_coordinates = [[-0.5, -0.5], [-0.5, 0.5], [0.5, -0.5], [0.5, 0.5]]
# Check with auxiliar function the position of the glowworms
assert self.found_peaks(peak_coordinates, 2, gso.swarm.glowworms, 3)
def test_GSO_with_report(self):
objective_function = J5()
self.gso_parameters.initial_vision_range = 3.0
self.gso_parameters.max_vision_range = 3.0
bounding_box = BoundingBox(
[Boundary(-2.0 * pi, 2.0 * pi),
Boundary(-2.0 * pi, 2.0 * pi)])
number_of_glowworms = 5
random_number_generator = MTGenerator(324324)
builder = GSOBuilder()
gso = builder.create(number_of_glowworms, random_number_generator,
self.gso_parameters, objective_function,
bounding_box)
gso.run(5)
report = gso.report()
assert 14 == len(report.split(os.linesep))
assert str(gso) == report
def test_GSO_with_J4(self):
objective_function = J4()
self.gso_parameters.initial_vision_range = 0.75
self.gso_parameters.max_vision_range = 0.75
bounding_box = BoundingBox([Boundary(-2.0, 2.0), Boundary(-2.0, 2.0)])
number_of_glowworms = 100
random_number_generator = MTGenerator(324324)
builder = GSOBuilder()
gso = builder.create(number_of_glowworms, random_number_generator,
self.gso_parameters, objective_function,
bounding_box)
gso.run(50)
# Save last step
gso.swarm.save(50, self.test_path, 'gso_j4_50.out')
assert filecmp.cmp(self.test_path + 'gso_j4_50.out',
self.golden_data_path + 'gso_j4_50.out')
def setUp(self):
self.path = os.path.dirname(os.path.realpath(__file__))
self.test_path = self.path + '/scratch/'
try:
shutil.rmtree(self.test_path)
except:
pass
os.mkdir(self.test_path)
self.golden_data_path = os.path.normpath(
os.path.dirname(os.path.realpath(__file__))) + '/golden_data/'
self.gso_parameters = GSOParameters()
self.bounding_box = BoundingBox([
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION)
])
self.random_number_generator = MTGenerator(324324)
def test_populate_poses(self):
to_generate = 3
center = [0., 0., 0.]
radius = 10.
seed = 1984
number_generator = MTGenerator(seed)
# No needed if no restraints are provided
rec_translation = [0., 0., 0.]
lig_translation = [-15.0, -15.0, -15.0]
poses = populate_poses(to_generate, center, radius, number_generator, rec_translation, lig_translation)
expected = [[-2.7294328828938386, -0.11588636361606675, -3.2077982565639607, -0.6725323168859286, 0.5755106199757826, -0.37756439233549577, 0.27190612107759393],
[-2.2842918231021314, -5.118850363927159, 3.2622525507180566, -0.6132005094145724, 0.757439137867041, -0.0367297456106423, -0.22118321244687617],
[2.906625032282104, -3.6251691461446978, -6.096162381118752, -0.8727759595729266, -0.22555077047578467, -0.2572320124803007, 0.3481675833340481]]
# We generate 3 poses
assert len(poses) == 3
# We generate poses without ANM
assert len(poses[0]) == 7
# We generate the expected poses
assert np.allclose(expected, poses)
def test_get_random_number(self):
gen = MTGenerator(25)
for i in range(50):
assert_almost_equals(self.generated[i], gen())
def calculate_initial_poses(receptor,
ligand,
num_swarms,
num_glowworms,
seed,
receptor_restraints,
ligand_restraints,
rec_translation,
lig_translation,
surface_density,
dest_folder,
nm_mode=False,
nm_seed=0,
rec_nm=0,
lig_nm=0,
is_membrane=False,
is_transmembrane=False,
writing_starting_positions=False,
swarm_radius=10.):
"""Calculates the starting points for each of the glowworms using the center of swarms"""
# Random number generator for poses
rng = MTGenerator(seed)
# Random number generator for NM
if nm_mode:
rng_nm = NormalGenerator(nm_seed,
mu=DEFAULT_EXTENT_MU,
sigma=DEFAULT_EXTENT_SIGMA)
else:
rng_nm = None
# Calculate swarm centers
has_membrane = is_membrane or is_transmembrane
swarm_centers, receptor_diameter, ligand_diameter = calculate_surface_points(
receptor,
ligand,
num_swarms,
rec_translation,
surface_density,
seed=seed,
has_membrane=has_membrane)
# Filter swarms far from the restraints
if receptor_restraints:
regular_restraints = receptor_restraints[
'active'] + receptor_restraints['passive']
swarm_centers = apply_restraints(swarm_centers, regular_restraints,
receptor_restraints['blocked'],
ligand_diameter / 2., rec_translation)
# Filter out swarms which are not compatible with the explicit membrane
if has_membrane:
membrane_beads = [
residue for residue in receptor.residues if residue.name == 'MMB'
]
swarm_centers = apply_membrane(swarm_centers, membrane_beads,
rec_translation, is_transmembrane)
pdb_file_name = os.path.join(dest_folder, SWARM_CENTERS_FILE)
create_pdb_from_points(pdb_file_name, swarm_centers)
ligand_center = ligand.center_of_coordinates()
positions_files = []
for swarm_id, swarm_center in enumerate(swarm_centers):
poses = populate_poses(num_glowworms, swarm_center, swarm_radius, rng,
rec_translation, lig_translation, rng_nm,
rec_nm, lig_nm, receptor_restraints,
ligand_restraints, ligand_diameter)
if writing_starting_positions:
# Save poses as pdb file
pdb_file_name = os.path.join(
dest_folder,
'%s_%s.pdb' % (DEFAULT_PDB_STARTING_PREFIX, swarm_id))
create_pdb_from_points(pdb_file_name,
[[pose[0], pose[1], pose[2]]
for pose in poses[:num_glowworms]])
# Generate bild files for glowworm orientations
bild_file_name = os.path.join(
dest_folder,
'%s_%s.bild' % (DEFAULT_BILD_STARTING_PREFIX, swarm_id))
create_bild_file(bild_file_name, poses)
# Save poses as initial_positions file
pos_file_name = os.path.join(
dest_folder, '%s_%s.dat' % (DEFAULT_STARTING_PREFIX, swarm_id))
create_file_from_poses(pos_file_name, poses[:num_glowworms])
positions_files.append(pos_file_name)
return positions_files
#!/usr/bin/env python3
# coding: utf-8
from lightdock.gso.parameters import GSOParameters
from lightdock.gso.searchspace.benchmark_ofunctions import J2
from lightdock.gso.algorithm import GSOBuilder
from lightdock.gso.boundaries import Boundary, BoundingBox
from lightdock.mathutil.lrandom import MTGenerator
gso_parameters = GSOParameters()
objective_function = J2()
bounding_box = BoundingBox([Boundary(-4.0, 4.0), Boundary(-4.0, 4.0)])
number_of_glowworms = 200
random_number_generator = MTGenerator(324324324)
builder = GSOBuilder()
gso = builder.create(number_of_glowworms,
random_number_generator,
gso_parameters,
objective_function,
bounding_box)
gso.swarm.save(0, '.', file_name='gso_0.out')
for glowworm in gso.swarm.glowworms:
print(glowworm.landscape_positions[0])
print('Step 1')
gso.run(100)
print('Step 100')
def calculate_initial_poses(receptor,
ligand,
num_clusters,
num_glowworms,
seed,
receptor_restraints,
ligand_restraints,
rec_translation,
lig_translation,
dest_folder,
ftdock_file='',
nm_mode=False,
nm_seed=0,
rec_nm=0,
lig_nm=0,
is_membrane=False):
"""Calculates the starting points for each of the glowworms using the center of swarms"""
# Random number generator for poses
rng = MTGenerator(seed)
# Random number generator for NM
if nm_mode:
rng_nm = NormalGenerator(nm_seed,
mu=DEFAULT_EXTENT_MU,
sigma=DEFAULT_EXTENT_SIGMA)
else:
rng_nm = None
# Calculate swarm centers
swarm_centers, receptor_diameter, ligand_diameter = calculate_surface_points(
receptor,
ligand,
num_clusters,
distance_step=1.0,
is_membrane=is_membrane)
# Filter swarms far from the restraints
if receptor_restraints:
regular_restraints = receptor_restraints[
'active'] + receptor_restraints['passive']
swarm_centers = apply_restraints(swarm_centers, regular_restraints,
receptor_restraints['blocked'],
ligand_diameter / 2., rec_translation)
# Filter out swarms which are not compatible with the explicit membrane
if is_membrane:
membrane_beads = [
residue for residue in receptor.residues if residue.name == 'MMB'
]
swarm_centers = apply_membrane(swarm_centers, membrane_beads,
rec_translation)
pdb_file_name = os.path.join(dest_folder, CLUSTERS_CENTERS_FILE)
create_pdb_from_points(pdb_file_name, swarm_centers)
ligand_center = ligand.center_of_coordinates()
radius = 10. # ligand_diameter / 2.
positions_files = []
# Populate the clusters using the FTDock poses
if ftdock_file:
if nm_mode:
raise NotImplementedError(
'Using FTDock poses with NM is not supported')
poses = FTDockCoordinatesParser.get_list_of_poses(
ftdock_file, ligand_center)
clusters = classify_ftdock_poses(poses, swarm_centers, radius)
for cluster_id, ftdock_poses in clusters.items():
# Translate FTDock poses into lightdock poses
poses = []
for pose in ftdock_poses:
poses.append([
pose.translation[0], pose.translation[1],
pose.translation[2], pose.q.w, pose.q.x, pose.q.y, pose.q.z
])
# Populate new poses if needed
if len(poses) < num_glowworms:
needed = num_glowworms - len(poses)
poses.extend(
populate_poses(needed, swarm_centers[cluster_id], radius,
rng, rec_translation, lig_translation))
# Save poses as pdb file
pdb_file_name = os.path.join(
dest_folder,
'%s_%s.pdb' % (DEFAULT_PDB_STARTING_PREFIX, cluster_id))
create_pdb_from_points(pdb_file_name,
[[pose[0], pose[1], pose[2]]
for pose in poses[:num_glowworms]])
# Save poses as initial_positions file
pos_file_name = os.path.join(
dest_folder,
'%s_%s.dat' % (DEFAULT_STARTING_PREFIX, cluster_id))
bild_file_name = os.path.join(
dest_folder,
'%s_%s.bild' % (DEFAULT_BILD_STARTING_PREFIX, cluster_id))
create_file_from_poses(pos_file_name, poses[:num_glowworms])
positions_files.append(pos_file_name)
create_bild_file(bild_file_name, poses)
else:
for swarm_id, swarm_center in enumerate(swarm_centers):
poses = populate_poses(num_glowworms, swarm_center, radius, rng,
rec_translation, lig_translation, rng_nm,
rec_nm, lig_nm, receptor_restraints,
ligand_restraints, ligand_diameter)
# Save poses as pdb file
pdb_file_name = os.path.join(
dest_folder,
'%s_%s.pdb' % (DEFAULT_PDB_STARTING_PREFIX, swarm_id))
create_pdb_from_points(pdb_file_name,
[[pose[0], pose[1], pose[2]]
for pose in poses[:num_glowworms]])
# Save poses as initial_positions file
pos_file_name = os.path.join(
dest_folder, '%s_%s.dat' % (DEFAULT_STARTING_PREFIX, swarm_id))
bild_file_name = os.path.join(
dest_folder,
'%s_%s.bild' % (DEFAULT_BILD_STARTING_PREFIX, swarm_id))
create_file_from_poses(pos_file_name, poses[:num_glowworms])
positions_files.append(pos_file_name)
create_bild_file(bild_file_name, poses)
return positions_files
log.info("%d glowworms loaded" % num_glowworms)
adapter = DFIREAdapter(receptor, ligand)
scoring_function = DFIRE()
log.info("Loaded DFIRE scoring function")
bounding_box = BoundingBox([
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_TRANSLATION, MAX_TRANSLATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION),
Boundary(-MAX_ROTATION, MAX_ROTATION)
])
random_number_generator = MTGenerator(GSO_SEED)
gso_parameters = GSOParameters(configuration_file)
log.info("Parameters read")
positions = []
for i in range(num_glowworms):
coordinates = [
translations[i][0], translations[i][1], translations[i][2],
rotations[i].w, rotations[i].x, rotations[i].y, rotations[i].z
]
positions.append(
DockingLandscapePosition(scoring_function, coordinates,
adapter.receptor_model,
adapter.ligand_model))
log.info("%d positions loaded" % len(positions))
