/* * api/coot-molecule-merge-molecules.cc * * Copyright 2020 by Medical Research Council * Author: Paul Emsley * * This file is part of Coot * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation; either version 3 of the License, or (at * your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copies of the GNU General Public License and * the GNU Lesser General Public License along with this program; if not, * write to the Free Software Foundation, Inc., 51 Franklin Street, * Fifth Floor, Boston, MA, 02110-1301, USA. * See http://www.gnu.org/licenses/ * */ #include "coot-molecule.hh" // merge molecules // Return +1 as status of pair if we did indeed do a merge // Return a list of new chain ids as the second. // // Note, very often add_molecules will only be of size 1. // // Recall that we will often be merging ligands into (otherwise quite // complete) proteins. In that case, in which we add a single residue // it would be The Right Thing to Do if we could find a chain that // consisted only of the same residue type as is the new ligand and // add it to that chain. If that is the case, we should return a spec // for the residue, not just the chain id. // // If we can't find a chain like that - or the new molecule contains // more than one residue, we simply add new chains (with new chain // ids) to this molecule. // // Question to self: how do I deal with different models? // std::pair > coot::molecule_t::merge_molecules(const std::vector &add_molecules) { // pass this? coot::residue_spec_t merge_molecules_ligand_spec; const coot::residue_spec_t &spec = merge_molecules_ligand_spec; int istat = 0; make_backup("merge_molecules"); // could be more clever, by doing this only when needed. std::vector resulting_merge_info; std::pair done_merge_ligand_to_near_chain; done_merge_ligand_to_near_chain.first = false; std::vector this_model_chains = coot::util::chains_in_molecule(atom_sel.mol); atom_sel.delete_atom_selection(); for (unsigned int imol=0; imol 0) { int nresidues = coot::util::number_of_residues_in_molecule(add_molecules[imol].mol); // We need to set multi_residue_add_flag appropriately. We // unset it if the molecule to be added has only one residue // bool multi_residue_add_flag = true; std::vector adding_model_chains = coot::util::chains_in_molecule(add_molecules[imol].mol); if (nresidues == 1) { bool done_add_specific = merge_molecules_just_one_residue_at_given_spec(add_molecules[imol], spec); bool done_homogeneous_addition_flag = false; // by "homogeneous" I mean is there a chain of residues of the same type as that we are adding // e.g. an SO4 to a chain of SO4s? This don't happen (much?) these days. // These days, with one residue, we expect to call merge_ligand_to_near_chain() if (! done_add_specific) done_homogeneous_addition_flag = merge_molecules_just_one_residue_homogeneous(add_molecules[imol]); if (done_add_specific) multi_residue_add_flag = false; else multi_residue_add_flag = ! done_homogeneous_addition_flag; if (! done_homogeneous_addition_flag) { if (! done_add_specific) done_merge_ligand_to_near_chain = merge_ligand_to_near_chain(adding_mol); if (done_merge_ligand_to_near_chain.first) { merge_molecule_results_info_t mmr; mmr.is_chain = false; mmr.spec = done_merge_ligand_to_near_chain.second; resulting_merge_info.push_back(mmr); istat = 1; } else { if (done_add_specific) { // JED ligand addition merge_molecule_results_info_t mmr; mmr.is_chain = false; mmr.spec = spec; // std::cout << "---- JED case pushing back mmr " << mmr.spec << std::endl; resulting_merge_info.push_back(mmr); istat = 1; } } // set multi_residue_add_flag if that was not a successful merge if (! done_add_specific) multi_residue_add_flag = ! done_merge_ligand_to_near_chain.first; } } // Now that multi_residue_add_flag has been set properly, we use it... if (multi_residue_add_flag) { // return state std::pair > add_state = try_add_by_consolidation(adding_mol); // some mild hacking, but we need to return a proper state and the added chains istat = 0; for (unsigned int i=0; i mapped_chains = map_chains_to_new_chains(adding_model_chains, this_model_chains); std::cout << "INFO:: Merge From chains: " << std::endl; for (unsigned int ich=0; ichGetModel(i_add_model); mmdb::Model *this_model_p = atom_sel.mol->GetModel(i_this_model); int n_add_chains = model_p->GetNumberOfChains(); for (int iaddchain=0; iaddchainGetChain(iaddchain); mmdb::Chain *copy_chain_p = new mmdb::Chain; copy_chain_p->Copy(chain_p); copy_chain_p->SetChainID(mapped_chains[iaddchain].c_str()); this_model_p->AddChain(copy_chain_p); this_model_chains.push_back(mapped_chains[iaddchain].c_str()); merge_molecule_results_info_t mmr; mmr.is_chain = true; mmr.chain_id = mapped_chains[iaddchain]; resulting_merge_info.push_back(mmr); } if (n_add_chains > 0) { atom_sel.mol->FinishStructEdit(); // update_molecule_after_additions(); // if (graphics_info_t::show_symmetry == 1) // update_symmetry(); coot::util::pdbcleanup_serial_residue_numbers(atom_sel.mol); } istat = 1; } } } } atom_sel = make_asc(atom_sel.mol); // fill_ghost_info(true, 0.7); // std::cout << "------- resulting_merge_info has size " << resulting_merge_info.size() << std::endl; if (false) if (!resulting_merge_info.empty()) std::cout << "-------- resulting_merge_info[0] " << resulting_merge_info[0].spec << std::endl; return std::pair > (istat, resulting_merge_info); } // return the multi_residue_add_flag // done_homogeneous_addition_flag // bool coot::molecule_t::merge_molecules_just_one_residue_homogeneous(atom_selection_container_t molecule_to_add) { // If there is a chain that has only residues of the same // type as is the (single) residue in the new adding // molecule then we add by residue addition to chain // rather than add by chain (to molecule). // Are there chains in this model that only consist of // residues of type adding_model_chains[0]? // bool done_homogeneous_addition_flag = false; bool has_single_residue_type_chain_flag = false; int i_this_model = 1; mmdb::Chain *add_residue_to_this_chain = NULL; mmdb::Model *this_model_p = atom_sel.mol->GetModel(i_this_model); int n_this_mol_chains = this_model_p->GetNumberOfChains(); for (int ithischain=0; ithischainGetChain(ithischain); std::vector r = coot::util::residue_types_in_chain(this_chain_p); if (r.size() == 1) { std::string adding_model_resname(molecule_to_add.atom_selection[0]->residue->GetResName()); if (r[0] == adding_model_resname) { // poly-ala helices (say) should not go into concatenated residues in the same chain if (adding_model_resname != "ALA") { add_residue_to_this_chain = this_chain_p; has_single_residue_type_chain_flag = true; break; } } } } if (has_single_residue_type_chain_flag) { if (molecule_to_add.n_selected_atoms > 0) { mmdb::Residue *add_model_residue = molecule_to_add.atom_selection[0]->residue; copy_and_add_residue_to_chain(add_residue_to_this_chain, add_model_residue); done_homogeneous_addition_flag = true; atom_sel.mol->FinishStructEdit(); // update_molecule_after_additions(); // if (graphics_info_t::show_symmetry == 1) // update_symmetry(); } } return done_homogeneous_addition_flag; } bool coot::molecule_t::merge_molecules_just_one_residue_at_given_spec(atom_selection_container_t molecule_to_add, coot::residue_spec_t target_spec) { bool status = false; if (! target_spec.empty()) { mmdb::Residue *residue_p = get_residue(target_spec); if (! residue_p) { // more checks: does molecule_to_add have only one residue? int i_model = 1; int n_res = coot::util::number_of_residues_in_molecule(molecule_to_add.mol); if (n_res == 1) { mmdb::Model *this_model_p = atom_sel.mol->GetModel(i_model); mmdb::Chain *this_chain_p = this_model_p->GetChain(target_spec.chain_id.c_str()); if (! this_chain_p) { this_chain_p = new mmdb::Chain; this_chain_p->SetChainID(target_spec.chain_id.c_str()); this_model_p->AddChain(this_chain_p); } else { std::cout << "INFO:: merge_molecules_just_one_residue_at_given_spec() " << " this chain not found in molecule (good)" << std::endl; } mmdb::Residue *r = coot::util::get_first_residue(molecule_to_add.mol); if (r) { make_backup("merge_molecules_just_one_residue_at_given_spec"); mmdb::Residue *new_residue_p = copy_and_add_residue_to_chain(this_chain_p, r); new_residue_p->seqNum = target_spec.res_no; status = true; } } else { if (true) // debug std::cout << "debug:: merge_molecules_just_one_residue_at_given_spec() oops " << " n_res is " << n_res << std::endl; } } else { std::cout << "WARNING:: merge_molecules_just_one_residue_at_given_spec() residue already exists " << "in molecule " << target_spec << std::endl; } } else { if (false) // debug std::cout << "merge_molecules_just_one_residue_at_given_spec() null residue spec" << std::endl; } if (status) { atom_sel.mol->FinishStructEdit(); // update_molecule_after_additions(); // if (graphics_info_t::show_symmetry == 1) // update_symmetry(); } if (false) // debug std::cout << "merge_molecules_just_one_residue_at_given_spec() returns " << status << std::endl; return status; } // This doesn't do a backup or finalise model. // new_resno_by_hundreds_flag is an optional argument. mmdb::Residue * coot::molecule_t::copy_and_add_residue_to_chain(mmdb::Chain *this_model_chain, mmdb::Residue *add_model_residue, bool new_resno_by_hundreds_flag) { mmdb::Residue *res_copied = NULL; if (add_model_residue) { bool whole_res_flag = true; int udd_atom_index_handle = 1; // does this matter? bool add_this = true; // check for overlapping water (could be generalised for same residue type?! std::vector close_residues; close_residues = coot::residues_near_residue(add_model_residue, atom_sel.mol, 0.05); for (unsigned int i=0; iisSolvent() && add_model_residue->isSolvent()) { add_this = false; std::cout<<"INFO:: not adding water because of overlap\n"< res_info = next_residue_number_in_chain(this_model_chain, new_resno_by_hundreds_flag); int new_res_resno = 9999; if (res_info.first) new_res_resno = res_info.second; residue_copy->seqNum = new_res_resno; // try changing the seqNum before AddResidue(). this_model_chain->AddResidue(residue_copy); res_copied = residue_copy; } } } return res_copied; } // Copy residues of new_chain into this_model_chain void coot::molecule_t::copy_and_add_chain_residues_to_chain(mmdb::Chain *new_chain, mmdb::Chain *this_molecule_chain) { // remove TER record of current last residue (if it has a TER). remove_TER_on_last_residue(this_molecule_chain); int nres = new_chain->GetNumberOfResidues(); for (int ires=0; iresGetResidue(ires)); } } // Merge molecules helper function. // // What we want to do is map chains ids in the new (adding) molecules // to chain ids that are unused in thid model: // // e.g. adding: B,C,D // this: A,B,C // // return: D,E,F // std::vector coot::molecule_t::map_chains_to_new_chains(const std::vector &adding_model_chains, const std::vector &this_model_chains) const { std::vector rv; // we dont want ! [] or *, they are mmdb specials. // 20200110-PE no more specials at all // std::string r("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%^&@?/~|-+=(){}:;.,'"); std::string r("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); // first remove from r, all the chain that already exist in this molecule. for (unsigned int i=0; i 0) { t = r[0]; r = r.substr(1); // return r starting at position 1; } else { t = "A"; } rv.push_back(t); } return rv; } // return "" on failure std::string coot::molecule_t::suggest_new_chain_id(const std::string ¤t_chain_id) const { // current_chain_id is the chain_id in the molecule that we are adding to this one. std::string new_chain_id; // 20200110-PE no more specials at all // std::string r("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%^&@?/~|-+=(){}:;.,'"); std::string r("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); std::vector existing; int imod = 1; mmdb::Model *model_p = atom_sel.mol->GetModel(imod); mmdb::Chain *chain_p; int n_chains = model_p->GetNumberOfChains(); // do we have current_chain_id in our list of chains already? If not, then simply // choose current_chain_id. bool found_it = false; for (int ichain=0; ichainGetChain(ichain); std::string chid = chain_p->GetChainID(); if (chid == current_chain_id) { found_it = true; break; } } if (! found_it) new_chain_id = current_chain_id; // all done! // how about a multichar post-fix? We only want to do that if current_chain_id // what multichar to begin with (from a pdbx file): // (Wolfram Tempel) // if (new_chain_id.empty()) { if (current_chain_id.length() > 1) { std::string trial_chain_id = current_chain_id + "2"; if (trial_chain_id.length() < (10-1)) { // magic mmdb chain id max length (mmdb_defs.h) // (we need a space for the terminal NULL too). bool found_it = false; for (int ichain=0; ichainGetChain(ichain); std::string chid = chain_p->GetChainID(); if (chid == trial_chain_id) { found_it = true; break; } } if (! found_it) new_chain_id = trial_chain_id; // all done! } } } if (new_chain_id.empty()) { // not set yet for (int ichain=0; ichainGetChain(ichain); existing.push_back(chain_p->GetChainID()); } unsigned int l = r.length(); std::vector candidates(l); for (unsigned int i=0; iGetAtomTable(residue_atoms, n_residue_atoms); for(int iat=0; iatisTer()) { if (at->Het) { status = true; break; } } } } return status; } // return state, max_resno + 1, or 0, 1 of no residues in chain. // // new_res_no_by_hundreds is default false std::pair coot::molecule_t::next_residue_number_in_chain(mmdb::Chain *w, bool new_res_no_by_hundreds) const { std::pair p(0,1); int max_res_no = -9999; if (w) { int nres = w->GetNumberOfResidues(); mmdb::Residue *residue_p; if (nres > 0) { for (int ires=nres-1; ires>=0; ires--) { residue_p = w->GetResidue(ires); if (residue_p->seqNum > max_res_no) { max_res_no = residue_p->seqNum; bool is_het_residue_flag = is_het_residue(residue_p); if (is_het_residue_flag) { p = std::pair(1, residue_p->seqNum+1); } else { if (new_res_no_by_hundreds) { if (max_res_no < 9999) { int res_no = coot::util::round_up_by_hundreds(max_res_no+1); p = std::pair(1, res_no+1); } } else { if (max_res_no < 9999) { p = std::pair(1, max_res_no+1); } } } } } if (! p.first) { // first the first space starting from the front int test_resno_start = 1001; bool is_clear = false; while (! is_clear) { is_clear = true; for (int iser=0; iserGetResidue(iser)->seqNum; if (resno_res >= test_resno_start) { if (resno_res <= (test_resno_start+10)) { is_clear = false; } } if (! is_clear) break; } test_resno_start += 100; } p = std::pair (1, test_resno_start); } } } return p; } // There is (or should be) only one residue in mol std::pair coot::molecule_t::merge_ligand_to_near_chain(mmdb::Manager *mol) { bool done_merge = false; coot::residue_spec_t res_spec; mmdb::Residue *adding_residue_p = 0; { // set adding_residue int imod = 1; mmdb::Model *model_p = mol->GetModel(imod); if (model_p) { mmdb::Chain *chain_p; int n_chains = model_p->GetNumberOfChains(); for (int ichain=0; ichainGetChain(ichain); if (chain_p) { int nres = chain_p->GetNumberOfResidues(); if (nres > 0) adding_residue_p = chain_p->GetResidue(0); } } } } if (adding_residue_p) { // OK, what atoms in this molecule are close to adding_residue? // First, we need a vector of atoms in adding_residue // Then a set of atoms that are close to those positions // Then find the chain that has most atoms in that set // Then find a suitable residue number // Then add the residue std::vector ligand_atom_positions; mmdb::Atom **residue_atoms = 0; int n_residue_atoms = 0; adding_residue_p->GetAtomTable(residue_atoms, n_residue_atoms); for (int i=0; iisTer()) { clipper::Coord_orth pt = coot::co(atom); ligand_atom_positions.push_back(pt); } } std::set near_atoms; // atoms in the protein (this molecule) double dist_crit = 4.2; double dist_crit_sqrd = dist_crit * dist_crit; // this is a slow position by position check. It can be speeded up, if needed, // by fiddling with residue and molecules (i.e. copying and merging) and using // SelectAtoms(). // int imod = 1; mmdb::Model *model_p = atom_sel.mol->GetModel(imod); if (model_p) { int n_chains = model_p->GetNumberOfChains(); for (int ichain=0; ichainGetChain(ichain); if (chain_p) { int nres = chain_p->GetNumberOfResidues(); for (int ires=0; iresGetResidue(ires); if (residue_p) { int n_atoms = residue_p->GetNumberOfAtoms(); for (int iat=0; iatGetAtom(iat); if (at) { if (! at->isTer()) { clipper::Coord_orth this_at_co = coot::co(at); for (std::size_t j=0; j 1) { // make a map of the number of residue in each chain that are close to the ligand atoms std::map chain_map; std::set::const_iterator it; for (it=near_atoms.begin(); it!=near_atoms.end(); it++) { mmdb::Chain *this_chain = (*it)->GetChain(); if (chain_map.find(this_chain) == chain_map.end()) { chain_map[this_chain] = 1; } else { chain_map[this_chain]++; } } // find the "best" chain for this added residue/ligand mmdb::Chain *max_atom_chain = 0; int n_atoms_max = 0; std::map::const_iterator chain_it; for (chain_it=chain_map.begin(); chain_it!=chain_map.end(); chain_it++) { int n = chain_it->second; if (n > n_atoms_max) { n_atoms_max = n; max_atom_chain = chain_it->first; } } if (n_atoms_max > 0) { if (max_atom_chain) { // does not backup or finalize or update bool new_res_no_by_hundreds = true; mmdb::Residue *new_residue_p = copy_and_add_residue_to_chain(max_atom_chain, adding_residue_p, new_res_no_by_hundreds); done_merge = true; res_spec = coot::residue_spec_t(new_residue_p); } } } } } if (done_merge) { atom_sel.mol->PDBCleanup(mmdb::PDBCLEAN_SERIAL|mmdb::PDBCLEAN_INDEX); atom_sel.mol->FinishStructEdit(); // update_molecule_after_additions(); // if (graphics_info_t::show_symmetry == 1) // update_symmetry(); } return std::pair (done_merge, res_spec); } // return status and vector of resulting chain ids. // std::pair > coot::molecule_t::try_add_by_consolidation(mmdb::Manager *adding_mol) { bool status = false; std::vector chain_ids; // 20180104 Don't merge molecules made of ALA. // for this molecule molecule, make a map of chains that have one // residue type. Could well be empty (or perhaps consist of just a // water chain) // std::map > single_res_type_map; for(int imod = 1; imod<=atom_sel.mol->GetNumberOfModels(); imod++) { mmdb::Model *model_p = atom_sel.mol->GetModel(imod); int n_chains = model_p->GetNumberOfChains(); for (int ichain=0; ichainGetChain(ichain); int nres = chain_p->GetNumberOfResidues(); std::vector residue_types; mmdb::Residue *residue_p; for (int ires=0; iresGetResidue(ires); std::string res_name(residue_p->GetResName()); if (std::find(residue_types.begin(), residue_types.end(), res_name) == residue_types.end()) residue_types.push_back(res_name); if (residue_types.size() > 1) break; } if (residue_types.size() == 1) single_res_type_map[residue_types[0]] = std::pair (imod, chain_p); } } for(int imod = 1; imod<=adding_mol->GetNumberOfModels(); imod++) { mmdb::Model *model_p = adding_mol->GetModel(imod); int n_chains = model_p->GetNumberOfChains(); for (int ichain=0; ichainGetChain(ichain); int nres = chain_p->GetNumberOfResidues(); std::vector residue_types; mmdb::Residue *residue_p; for (int ires=0; iresGetResidue(ires); std::string res_name(residue_p->GetResName()); if (std::find(residue_types.begin(), residue_types.end(), res_name) == residue_types.end()) residue_types.push_back(res_name); } if (residue_types.size() == 1) { if (residue_types[0] != "ALA") { std::map >::const_iterator it = single_res_type_map.find(residue_types[0]); if (it != single_res_type_map.end()) { if (it->second.first == imod) { // We got a match, now add all of adding_mol chain_p // to this molecule's chain // BL says:: we check in copy_and_add_chain_residues_to_chain if there // are overlapping waters. Alternativley we could do it here already. copy_and_add_chain_residues_to_chain(chain_p, it->second.second); done_this_chain = true; std::string cid = it->second.second->GetChainID(); if (std::find(chain_ids.begin(), chain_ids.end(), cid) == chain_ids.end()) chain_ids.push_back(cid); } } } } if (! done_this_chain) { // copy whole chain to a new chain mmdb::Model *this_model_p = atom_sel.mol->GetModel(imod); if (this_model_p) { std::string current_chain_id = chain_p->GetChainID(); std::string new_chain_id = suggest_new_chain_id(current_chain_id); mmdb::Chain *copy_chain_p = new mmdb::Chain; copy_chain_p->Copy(chain_p); copy_chain_p->SetChainID(new_chain_id.c_str()); this_model_p->AddChain(copy_chain_p); if (std::find(chain_ids.begin(), chain_ids.end(), new_chain_id) == chain_ids.end()) chain_ids.push_back(new_chain_id); } } atom_sel.mol->FinishStructEdit(); status = true; } } return std::pair > (status, chain_ids); }