/*
* BioJava development code
*
* This code may be freely distributed and modified under the
* terms of the GNU Lesser General Public Licence. This should
* be distributed with the code. If you do not have a copy,
* see:
*
* http://www.gnu.org/copyleft/lesser.html
*
* Copyright for this code is held jointly by the individual
* authors. These should be listed in @author doc comments.
*
* For more information on the BioJava project and its aims,
* or to join the biojava-l mailing list, visit the home page
* at:
*
* http://www.biojava.org/
*
* Created on Aug 2, 2010
* Author: Jianjiong Gao
*
*/
package org.biojava.nbio.protmod.structure;
import org.biojava.nbio.structure.*;
import org.biojava.nbio.structure.io.mmcif.MetalBondParser;
import org.biojava.nbio.structure.io.mmcif.chem.MetalBondDistance;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public final class StructureUtil {
private StructureUtil() {
throw new AssertionError();
}
/**
*
* @param group a {@link Group} in structure.
* @param isAminoAcid true if it is an amino acid.
* @return the {@link StructureGroup} of the group.
*/
public static StructureGroup getStructureGroup(Group group, boolean isAminoAcid) {
ResidueNumber resNum = group.getResidueNumber();
return new StructureGroup(resNum, group.getPDBName(), isAminoAcid);
}
/**
*
* @param atom a {@link Atom} in structure.
* @param isParentAminoAcid true if the containing group is an amino acid.
* @return the {@link StructureAtom} of the atom.
*/
public static StructureAtom getStructureAtom(Atom atom, boolean isParentAminoAcid) {
Group g = atom.getGroup();
String chainId = g.getChainId();
StructureGroup strucGroup = getStructureGroup(g, isParentAminoAcid);
strucGroup.setChainId(chainId);
return new StructureAtom(strucGroup, atom.getName());
}
/**
*
* @param atom1 the first {@link Atom} in structure.
* @param isParentAminoAcid1 true if the first containing group is an amino acid..
* @param atom2 the second {@link Atom} in structure.
* @param isParentAminoAcid2 true if the second containing group is an amino acid..
* @return the {@link StructureAtomLinkage} of the two atoms.
*/
public static StructureAtomLinkage getStructureAtomLinkage(Atom atom1,
boolean isParentAminoAcid1, Atom atom2, boolean isParentAminoAcid2) {
StructureAtom strucAtom1 = getStructureAtom(atom1, isParentAminoAcid1);
StructureAtom strucAtom2 = getStructureAtom(atom2, isParentAminoAcid2);
double distance = getAtomDistance(atom1, atom2);
return new StructureAtomLinkage(strucAtom1, strucAtom2, distance);
}
/**
*
* @param atom1 the first {@link Atom} in structure.
* @param atom2 the second {@link Atom} in structure.
* @return the distance between the two atoms in Angstrom.
*/
public static double getAtomDistance(Atom atom1, Atom atom2) {
double distance;
distance = Calc.getDistance(atom1, atom2);
return distance;
}
/**
* Find a linkage between two groups within tolerance of bond length,
* from potential atoms.
* @param group1 the first {@link Group}.
* @param group2 the second {@link Group}.
* @param potentialNamesOfAtomOnGroup1 potential names of the atom on the first group.
* If null, search all atoms on the first group.
* @param potentialNamesOfAtomOnGroup2 potential names of the atom on the second group.
* If null, search all atoms on the second group.
* @param ignoreNCLinkage true to ignore all N-C linkages
* @param bondLengthTolerance bond length error tolerance.
* @return an array of two Atoms that form bond between each other
* if found; null, otherwise.
*/
public static Atom[] findNearestAtomLinkage(final Group group1, final Group group2,
List<String> potentialNamesOfAtomOnGroup1, List<String> potentialNamesOfAtomOnGroup2,
final boolean ignoreNCLinkage, double bondLengthTolerance) {
List<Atom[]> linkages = findAtomLinkages(group1, group2,
potentialNamesOfAtomOnGroup1, potentialNamesOfAtomOnGroup2,
ignoreNCLinkage, bondLengthTolerance);
Atom[] ret = null;
double minDistance = Double.POSITIVE_INFINITY;
for (Atom[] linkage : linkages) {
double distance;
distance = Calc.getDistance(linkage[0], linkage[1]);
if (distance < minDistance) {
minDistance = distance;
ret = linkage;
}
}
return ret;
}
/**
* Find linkages between two groups within tolerance of bond length,
* from potential atoms.
* @param group1 the first {@link Group}.
* @param group2 the second {@link Group}.
* @param ignoreNCLinkage true to ignore all N-C linkages
* @param bondLengthTolerance bond length error tolerance.
* @return a list, each element of which is an array of two Atoms that form bond
* between each other.
*/
public static List<Atom[]> findAtomLinkages(final Group group1,
final Group group2, final boolean ignoreNCLinkage,
final double bondLengthTolerance) {
return findAtomLinkages(group1, group2,
null, null, ignoreNCLinkage, bondLengthTolerance);
}
/**
* Find linkages between two groups within tolerance of bond length,
* from potential atoms.
* @param group1 the first {@link Group}.
* @param group2 the second {@link Group}.
* @param potentialNamesOfAtomOnGroup1 potential names of the atom on the first group.
* If null, search all atoms on the first group.
* @param potentialNamesOfAtomOnGroup2 potential names of the atom on the second group.
* If null, search all atoms on the second group.
* @param ignoreNCLinkage true to ignore all N-C linkages
* @param bondLengthTolerance bond length error tolerance.
* @return a list, each element of which is an array of two Atoms that form bond
* between each other.
*/
public static List<Atom[]> findAtomLinkages(final Group group1,
final Group group2,
List<String> potentialNamesOfAtomOnGroup1,
List<String> potentialNamesOfAtomOnGroup2,
final boolean ignoreNCLinkage,
final double bondLengthTolerance) {
if (group1==null || group2==null) {
throw new IllegalArgumentException("Null group(s).");
}
if (bondLengthTolerance<0) {
throw new IllegalArgumentException("bondLengthTolerance cannot be negative.");
}
List<Atom[]> ret = new ArrayList<Atom[]>();
if (potentialNamesOfAtomOnGroup1 == null) {
// if empty name, search for all atoms
potentialNamesOfAtomOnGroup1 = getAtomNames(group1);
}
if (potentialNamesOfAtomOnGroup2 == null) {
// if empty name, search for all atoms
potentialNamesOfAtomOnGroup2 = getAtomNames(group2);
}
for (String namesOfAtomOnGroup1 : potentialNamesOfAtomOnGroup1) {
for (String namesOfAtomOnGroup2 : potentialNamesOfAtomOnGroup2) {
Atom[] atoms = findLinkage(group1, group2, namesOfAtomOnGroup1,
namesOfAtomOnGroup2, bondLengthTolerance);
if (atoms != null) {
if (ignoreNCLinkage &&
((atoms[0].getName().equals("N") && atoms[1].getName().equals("C"))
|| (atoms[0].getName().equals("C") && atoms[1].getName().equals("N")))
) {
continue;
}
ret.add(atoms);
}
}
}
return ret;
}
/**
* Find a linkage between two groups within tolerance of bond length.
* @param group1 the first {@link Group}.
* @param group2 the second {@link Group}.
* @param nameOfAtomOnGroup1 atom name of the first group.
* @param nameOfAtomOnGroup2 atom name of the second group.
* @param bondLengthTolerance bond length error tolerance.
* @return an array of two Atoms that form bond between each other
* if found; null, otherwise.
*/
public static Atom[] findLinkage(final Group group1, final Group group2,
String nameOfAtomOnGroup1, String nameOfAtomOnGroup2,
double bondLengthTolerance) {
Atom[] ret = new Atom[2];
ret[0] = group1.getAtom(nameOfAtomOnGroup1);
ret[1] = group2.getAtom(nameOfAtomOnGroup2);
if (ret[0]==null || ret[1]==null) {
return null;
}
Atom a1 = ret[0];
Atom a2 = ret[1];
boolean hasBond = a1.hasBond(a2);
if ( hasBond ) {
return ret;
}
// is it a metal ?
if ( a1.getElement().isMetal() || a2.getElement().isMetal()){
MetalBondDistance defined = getMetalDistanceCutoff(a1.getElement().name(),a2.getElement().name());
if ( defined != null) {
if (hasMetalBond(a1, a2, defined))
return ret;
else
return null;
}
}
// not a metal
double distance = Calc.getDistance(a1, a2);
float radiusOfAtom1 = ret[0].getElement().getCovalentRadius();
float radiusOfAtom2 = ret[1].getElement().getCovalentRadius();
if (Math.abs(distance - radiusOfAtom1 - radiusOfAtom2)
> bondLengthTolerance) {
return null;
}
return ret;
}
private static boolean hasMetalBond(Atom a1, Atom a2, MetalBondDistance definition) {
double distance = Calc.getDistance(a1,a2);
Float min = definition.getLowerLimit();
Float max = definition.getUpperLimit();
return ( min < distance && max > distance);
}
private static MetalBondDistance getMetalDistanceCutoff(String name1, String name2) {
Map<String,List<MetalBondDistance>> defs= MetalBondParser.getMetalBondDefinitions();
List<MetalBondDistance> distances = defs.get(name1);
if ( distances == null){
distances = defs.get(name2);
String tmp = name1;
name2 = name1;
name1 = tmp;
}
if ( distances == null){
return null;
}
for ( MetalBondDistance d : distances){
if ( name1.equalsIgnoreCase(d.getAtomType1()) && name2.equalsIgnoreCase(d.getAtomType2()) )
return d;
}
// no matching atom definitions found
return null;
}
/**
*
* @param group a {@link Group}.
* @return all atom names of the group.
*/
public static List<String> getAtomNames(Group group) {
List<Atom> atoms = group.getAtoms();
if (atoms == null) {
return Collections.emptyList();
}
int n = atoms.size();
List<String> ret = new ArrayList<String>(n);
for (int i=0; i<n; i++) {
ret.add(atoms.get(i).getName());
}
return ret;
}
/**
* Get all amino acids in a chain.
* @param chain
* @return
*/
public static List<Group> getAminoAcids(Chain chain) {
List<Group> gs = new ArrayList<>();
for ( Group g : chain.getAtomGroups()){
if ( g.isAminoAcid())
gs.add(g);
}
return gs;
}
}