/**
* identify additional groups that are not directly attached to amino acids.
*
* @param mc {@link ModifiedCompound}.
* @param chain a {@link Chain}.
* @return a list of added groups.
*/
private void identifyAdditionalAttachments(
ModifiedCompound mc, List<Group> ligands, Map<String, Chain> mapChainIdChain) {
if (ligands.isEmpty()) {
return;
}
// TODO: should the additional groups only be allowed to the identified
// ligands or both amino acids and ligands? Currently only on ligands
// ligands to amino acid bonds for same modification of unknown category
// will be combined in mergeModComps()
// TODO: how about chain-chain links?
List<Group> identifiedGroups = new ArrayList<Group>();
for (StructureGroup num : mc.getGroups(false)) {
Group group;
try {
// String numIns = "" + num.getResidueNumber();
// if (num.getInsCode() != null) {
// numIns += num.getInsCode();
// }
ResidueNumber resNum = new ResidueNumber();
resNum.setChainId(num.getChainId());
resNum.setSeqNum(num.getResidueNumber());
resNum.setInsCode(num.getInsCode());
// group = chain.getGroupByPDB(numIns);
group = mapChainIdChain.get(num.getChainId()).getGroupByPDB(resNum);
} catch (StructureException e) {
e.printStackTrace();
// should not happen
continue;
}
identifiedGroups.add(group);
}
int start = 0;
int n = identifiedGroups.size();
while (n > start) {
for (Group group1 : ligands) {
for (int i = start; i < n; i++) {
Group group2 = identifiedGroups.get(i);
if (!identifiedGroups.contains(group1)) {
List<Atom[]> linkedAtoms =
StructureUtil.findAtomLinkages(group1, group2, false, bondLengthTolerance);
if (!linkedAtoms.isEmpty()) {
for (Atom[] atoms : linkedAtoms) {
mc.addAtomLinkage(
StructureUtil.getStructureAtomLinkage(atoms[0], false, atoms[1], false));
}
identifiedGroups.add(group1);
break;
}
}
}
}
start = n;
n = identifiedGroups.size();
}
}
/**
* Record unidentifiable atom linkages in a chain. Only linkages between two residues or one
* residue and one ligand will be recorded.
*/
private void recordUnidentifiableAtomLinkages(
List<ModifiedCompound> modComps, List<Group> ligands) {
// first put identified linkages in a map for fast query
Set<StructureAtomLinkage> identifiedLinkages = new HashSet<StructureAtomLinkage>();
for (ModifiedCompound mc : modComps) {
identifiedLinkages.addAll(mc.getAtomLinkages());
}
// record
// cross link
int nRes = residues.size();
for (int i = 0; i < nRes - 1; i++) {
Group group1 = residues.get(i);
for (int j = i + 1; j < nRes; j++) {
Group group2 = residues.get(j);
List<Atom[]> linkages =
StructureUtil.findAtomLinkages(group1, group2, true, bondLengthTolerance);
for (Atom[] atoms : linkages) {
StructureAtomLinkage link =
StructureUtil.getStructureAtomLinkage(atoms[0], true, atoms[1], true);
unidentifiableAtomLinkages.add(link);
}
}
}
// attachment
int nLig = ligands.size();
for (int i = 0; i < nRes; i++) {
Group group1 = residues.get(i);
for (int j = 0; j < nLig; j++) {
Group group2 = ligands.get(j);
if (group1.equals(group2)) { // overlap between residues and ligands
continue;
}
List<Atom[]> linkages =
StructureUtil.findAtomLinkages(group1, group2, false, bondLengthTolerance);
for (Atom[] atoms : linkages) {
StructureAtomLinkage link =
StructureUtil.getStructureAtomLinkage(atoms[0], true, atoms[1], false);
unidentifiableAtomLinkages.add(link);
}
}
}
}
/**
* Assembly the matched linkages.
*
* @param matchedAtomsOfLinkages
* @param mod
* @param condition
* @param ret ModifiedCompound will be stored here.
*/
private void assembleLinkages(
List<List<Atom[]>> matchedAtomsOfLinkages,
ProteinModification mod,
List<ModifiedCompound> ret) {
ModificationCondition condition = mod.getCondition();
List<ModificationLinkage> modLinks = condition.getLinkages();
int nLink = matchedAtomsOfLinkages.size();
int[] indices = new int[nLink];
Set<ModifiedCompound> identifiedCompounds = new HashSet<ModifiedCompound>();
while (indices[0] < matchedAtomsOfLinkages.get(0).size()) {
List<Atom[]> atomLinkages = new ArrayList<Atom[]>(nLink);
for (int iLink = 0; iLink < nLink; iLink++) {
Atom[] atoms = matchedAtomsOfLinkages.get(iLink).get(indices[iLink]);
atomLinkages.add(atoms);
}
if (matchLinkages(modLinks, atomLinkages)) {
// matched
int n = atomLinkages.size();
List<StructureAtomLinkage> linkages = new ArrayList<StructureAtomLinkage>(n);
for (int i = 0; i < n; i++) {
Atom[] linkage = atomLinkages.get(i);
StructureAtomLinkage link =
StructureUtil.getStructureAtomLinkage(
linkage[0], residues.contains(linkage[0].getGroup()),
linkage[1], residues.contains(linkage[1].getGroup()));
linkages.add(link);
}
ModifiedCompound mc = new ModifiedCompoundImpl(mod, linkages);
if (!identifiedCompounds.contains(mc)) {
ret.add(mc);
identifiedCompounds.add(mc);
}
}
// indices++ (e.g. [0,0,1]=>[0,0,2]=>[1,2,0])
int i = nLink - 1;
while (i >= 0) {
if (i == 0 || indices[i] < matchedAtomsOfLinkages.get(i).size() - 1) {
indices[i]++;
break;
} else {
indices[i] = 0;
i--;
}
}
}
}
