def create_model(target_sequence, target_species_id, require_resnum=None, chosen_template_id=None):
target_species_id = target_species_id.upper()
sequence_id = model_storage.get_sequence_id(target_sequence)
lock_name = "lock_search_%s_%s_%s_%s" % (sequence_id,
target_species_id,
str(require_resnum),
str(chosen_template_id))
if model_storage.model_dir is None:
raise InitError("model directory is not set")
lock_path = os.path.join(model_storage.model_dir, lock_name)
with FileLock(lock_path):
model_paths = model_storage.list_models(target_sequence, target_species_id,
require_resnum, chosen_template_id)
if len(model_paths) > 0:
return select_best_model(model_paths, target_sequence, require_resnum)
else:
ModelLogger.get_current().clear()
domain_alignments = \
domain_aligner.get_domain_alignments(target_sequence,
require_resnum,
chosen_template_id)
if len(domain_alignments) <= 0:
_log.warn("no domain alignments for target={} resnum={} template={}"
.format(target_sequence, require_resnum, chosen_template_id))
return None
domain_alignment = select_best_domain_alignment(domain_alignments)
return modeler.build_model(target_sequence, target_species_id,
domain_alignment, require_resnum)
def create_model(target_sequence, target_species_id, require_resnum=None, chosen_template_id=None):
target_species_id = target_species_id.upper()
sequence_id = model_storage.get_sequence_id(target_sequence)
lock_name = "lock_search_%s_%s_%s_%s" % (sequence_id,
target_species_id,
str(require_resnum),
str(chosen_template_id))
if model_storage.model_dir is None:
raise InitError("model directory is not set")
lock_path = os.path.join(model_storage.model_dir, lock_name)
with FileLock(lock_path):
model_paths = model_storage.list_models(target_sequence, target_species_id,
require_resnum, chosen_template_id)
if len(model_paths) > 0:
return select_best_model(model_paths)
else:
ModelLogger.get_current().clear()
domain_alignments = \
domain_aligner.get_domain_alignments(target_sequence,
require_resnum,
chosen_template_id)
if len(domain_alignments) <= 0:
_log.warn("no domain alignments for target={} resnum={} template={}"
.format(target_sequence, require_resnum, chosen_template_id))
return None
domain_alignment = select_best_domain_alignment(domain_alignments)
return modeler.build_model(target_sequence, target_species_id,
domain_alignment, require_resnum)
def build_model(self,
main_target_sequence,
target_species_id,
main_domain_alignment,
require_resnum=None):
tar_path = model_storage.get_tar_path(
main_target_sequence, target_species_id, main_domain_alignment,
main_domain_alignment.template_id)
with model_storage.get_model_lock(main_target_sequence,
target_species_id,
main_domain_alignment,
main_domain_alignment.template_id):
if not os.path.isfile(tar_path):
context = self._prepare_context(
main_domain_alignment.template_id.pdbid)
# If the template is the same as the target, do no modeling:
if main_domain_alignment.get_template_sequence() == context.get_sequence(main_domain_alignment.template_id.chain_id) and \
main_domain_alignment.get_percentage_identity() >= 100.0:
main_domain_alignment.target_id = model_storage.get_sequence_id(
main_target_sequence)
tar_path = self._wrap_template(
main_target_sequence, target_species_id,
main_domain_alignment,
main_domain_alignment.template_id)
return tar_path
context.set_main_target(
main_target_sequence, target_species_id,
main_domain_alignment.template_id.chain_id)
chain_alignments = self._make_alignments(
main_target_sequence, target_species_id,
main_domain_alignment, context, require_resnum)
# Delete chains that aren't in the alignment set:
for chain_id in context.get_chain_ids():
if chain_id not in chain_alignments:
context.delete_chain(chain_id)
_log.debug("final alignments: {}".format([
(chain_id, chain_alignments[chain_id])
for chain_id in context.get_chain_ids()
]))
_log.debug("final template {} {}".format(
context.template_pdbid,
[(chain_id, context.get_sequence(chain_id))
for chain_id in context.get_chain_ids()]))
tar_path = self._model_run(main_domain_alignment,
chain_alignments, context)
return tar_path
def build_model(self, main_target_sequence, target_species_id, main_domain_alignment, require_resnum=None):
ModelLogger.get_current().add("building model with sequence {}, species {}, alignment {} and resnum {}"
.format(main_target_sequence, target_species_id, main_domain_alignment, require_resnum))
tar_path = model_storage.get_tar_path(main_target_sequence,
target_species_id,
main_domain_alignment,
main_domain_alignment.template_id)
with model_storage.get_model_lock(main_target_sequence, target_species_id,
main_domain_alignment, main_domain_alignment.template_id):
if not os.path.isfile(tar_path):
if self.yasara_dir is None:
raise InitError("yasara dir is not set")
with ModelingContext(self.yasara_dir) as context:
self._prepare_template(context, main_domain_alignment.template_id.pdbid)
# If the template is the same as the target, do no modeling:
if main_domain_alignment.get_template_sequence() == context.get_sequence(main_domain_alignment.template_id.chain_id) and \
main_domain_alignment.get_percentage_identity() >= 100.0:
main_domain_alignment.target_id = model_storage.get_sequence_id(main_target_sequence)
tar_path = self._wrap_template(main_target_sequence, target_species_id,
main_domain_alignment, main_domain_alignment.template_id)
return tar_path
context.set_main_target(main_target_sequence, target_species_id,
main_domain_alignment.template_id.chain_id)
chain_alignments = self._make_alignments(main_target_sequence, target_species_id,
main_domain_alignment, context, require_resnum)
# Delete chains that aren't in the alignment set:
for chain_id in context.get_chain_ids():
if chain_id not in chain_alignments:
context.delete_chain(chain_id)
_log.debug("final alignments: {}".format([(chain_id, chain_alignments[chain_id])
for chain_id in context.get_chain_ids()]))
_log.debug("final template {} {}".format(context.template_pdbid,
[(chain_id, context.get_sequence(chain_id))
for chain_id in context.get_chain_ids()]))
tar_path = self._model_run(main_domain_alignment, chain_alignments, context, main_target_sequence, require_resnum)
return tar_path
def build_model(self, main_target_sequence, target_species_id, main_domain_alignment, require_resnum=None):
ModelLogger.get_current().add("building model with sequence {}, species {}, alignment {} and resnum {}"
.format(main_target_sequence, target_species_id, main_domain_alignment, require_resnum))
tar_path = model_storage.get_tar_path(main_target_sequence,
target_species_id,
main_domain_alignment,
main_domain_alignment.template_id)
with model_storage.get_model_lock(main_target_sequence, target_species_id,
main_domain_alignment, main_domain_alignment.template_id):
if not os.path.isfile(tar_path):
context = self._prepare_context(main_domain_alignment.template_id.pdbid)
# If the template is the same as the target, do no modeling:
if main_domain_alignment.get_template_sequence() == context.get_sequence(main_domain_alignment.template_id.chain_id) and \
main_domain_alignment.get_percentage_identity() >= 100.0:
main_domain_alignment.target_id = model_storage.get_sequence_id(main_target_sequence)
tar_path = self._wrap_template(main_target_sequence, target_species_id,
main_domain_alignment, main_domain_alignment.template_id)
return tar_path
context.set_main_target(main_target_sequence, target_species_id,
main_domain_alignment.template_id.chain_id)
chain_alignments = self._make_alignments(main_target_sequence, target_species_id,
main_domain_alignment, context, require_resnum)
# Delete chains that aren't in the alignment set:
for chain_id in context.get_chain_ids():
if chain_id not in chain_alignments:
context.delete_chain(chain_id)
_log.debug("final alignments: {}".format([(chain_id, chain_alignments[chain_id])
for chain_id in context.get_chain_ids()]))
_log.debug("final template {} {}".format(context.template_pdbid,
[(chain_id, context.get_sequence(chain_id))
for chain_id in context.get_chain_ids()]))
tar_path = self._model_run(main_domain_alignment, chain_alignments, context)
return tar_path
def _make_alignments(self, main_target_sequence, target_species_id,
main_domain_alignment, context, require_resnum):
alignments = {}
# Choose what chains to align the main_target_on
main_target_chain_ids = self._pick_identical_chains(main_domain_alignment.template_id.chain_id,
context)
ModelLogger.get_current().add("using template chains {} for the main target sequence".format(main_target_chain_ids))
for chain_id in main_target_chain_ids:
template_chain_sequence = context.get_sequence(chain_id)
template_chain_secstr = context.get_secondary_structure(chain_id)
local_alignment = kmad_aligner.align(template_chain_sequence, template_chain_secstr,
main_domain_alignment.get_target_sequence())
alignments[chain_id] = DomainAlignment(local_alignment.target_alignment,
local_alignment.template_alignment,
main_domain_alignment.range,
main_domain_alignment.template_id)
alignments[chain_id].target_id = model_storage.get_sequence_id(main_target_sequence)
if require_resnum is not None and \
not alignments[main_domain_alignment.template_id.chain_id].is_target_residue_covered(require_resnum):
raise RuntimeError("Cannot align to chain {} so that residue {} is covered"
.format(main_domain_alignment.template_id.chain_id, require_resnum))
# Try to find and align target sequences for interacting chains in the template,
# while keeping in mind which residues interact and must thus be covered by the alignment.
# We expand the set of involved template chains with every iteration,
# until all template chains have been added.
while len(alignments) < len(context.get_chain_ids()):
# First, make python remember to which chains the candidate chains interact:
candidate_chains_interacts_with = {}
for aligned_chain_id in alignments:
for interacting_chain_id in context.list_interacting_chains(aligned_chain_id):
ModelLogger.get_current().add("template chain {} interacts with {}"
.format(aligned_chain_id, interacting_chain_id))
# Skip those that we've already aligned, to prevent infinite loops:
if interacting_chain_id in alignments:
continue
if interacting_chain_id not in candidate_chains_interacts_with:
candidate_chains_interacts_with[interacting_chain_id] = []
candidate_chains_interacts_with[interacting_chain_id].append(aligned_chain_id)
if len(candidate_chains_interacts_with) <= 0:
break # Nothing more to add
# iterate over chains that might interact with the chains that are already in the set:
for candidate_chain_id in candidate_chains_interacts_with:
interacting_chain_alignments = {interacting_chain_id: alignments[interacting_chain_id]
for interacting_chain_id in candidate_chains_interacts_with[candidate_chain_id]}
template_chain_sequence = context.get_sequence(candidate_chain_id)
template_chain_secstr = context.get_secondary_structure(candidate_chain_id)
potential_target_sequences = self._find_target_sequences(template_chain_sequence,
target_species_id)
ModelLogger.get_current().add("choosing target sequence for template chain {} from {}"
.format(candidate_chain_id, potential_target_sequences.keys()))
alignments[candidate_chain_id] = self._choose_best_target_alignment(context,
interacting_chain_alignments,
potential_target_sequences,
candidate_chain_id)
if alignments[candidate_chain_id] is None:
alignments[candidate_chain_id] = self._make_poly_A_alignment(context, candidate_chain_id)
alignments[candidate_chain_id].target_id = "poly-A"
ModelLogger.get_current().add("found no target for template chain {}, placing poly-A"
.format(candidate_chain_id))
return alignments
def _make_alignments(self, main_target_sequence, target_species_id,
main_domain_alignment, context, require_resnum):
alignments = {}
# Choose what chains to align the main_target_on
main_target_chain_ids = self._pick_identical_chains(main_domain_alignment.template_id.chain_id,
context)
ModelLogger.get_current().add("using template chains {} for the main target sequence".format(main_target_chain_ids))
for chain_id in main_target_chain_ids:
template_chain_sequence = context.get_sequence(chain_id)
template_chain_secstr = context.get_secondary_structure(chain_id)
local_alignment = kmad_aligner.align(template_chain_sequence, template_chain_secstr,
main_domain_alignment.get_target_sequence())
alignments[chain_id] = DomainAlignment(local_alignment.target_alignment,
local_alignment.template_alignment,
main_domain_alignment.range,
main_domain_alignment.template_id)
alignments[chain_id].target_id = model_storage.get_sequence_id(main_target_sequence)
if require_resnum is not None and \
not alignments[main_domain_alignment.template_id.chain_id].is_target_residue_covered(require_resnum):
raise RuntimeError("Cannot align to chain {} so that residue {} is covered"
.format(main_domain_alignment.template_id.chain_id, require_resnum))
# Try to find and align target sequences for interacting chains in the template,
# while keeping in mind which residues interact and must thus be covered by the alignment.
# We expand the set of involved template chains with every iteration,
# until all template chains have been added.
while len(alignments) < len(context.get_chain_ids()):
# First, make python remember to which chains the candidate chains interact:
candidate_chains_interacts_with = {}
for aligned_chain_id in alignments:
for interacting_chain_id in context.list_interacting_chains(aligned_chain_id):
ModelLogger.get_current().add("template chain {} interacts with {}"
.format(aligned_chain_id, interacting_chain_id))
# Skip those that we've already aligned, to prevent infinite loops:
if interacting_chain_id in alignments:
continue
if interacting_chain_id not in candidate_chains_interacts_with:
candidate_chains_interacts_with[interacting_chain_id] = []
candidate_chains_interacts_with[interacting_chain_id].append(aligned_chain_id)
if len(candidate_chains_interacts_with) <= 0:
break # Nothing more to add
# iterate over chains that might interact with the chains that are already in the set:
for candidate_chain_id in candidate_chains_interacts_with:
interacting_chain_alignments = {interacting_chain_id: alignments[interacting_chain_id]
for interacting_chain_id in candidate_chains_interacts_with[candidate_chain_id]}
template_chain_sequence = context.get_sequence(candidate_chain_id)
template_chain_secstr = context.get_secondary_structure(candidate_chain_id)
potential_target_sequences = self._find_target_sequences(template_chain_sequence,
target_species_id)
ModelLogger.get_current().add("choosing target sequence for template chain {} from {}"
.format(candidate_chain_id, potential_target_sequences.keys()))
alignments[candidate_chain_id] = self._choose_best_target_alignment(context,
interacting_chain_alignments,
potential_target_sequences,
candidate_chain_id)
if alignments[candidate_chain_id] is None:
alignments[candidate_chain_id] = self._make_poly_A_alignment(context, candidate_chain_id)
alignments[candidate_chain_id].target_id = "poly-A"
ModelLogger.get_current().add("found no target for template chain {}, placing poly-A"
.format(candidate_chain_id))
return alignments