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