/** * Tell whether the given group pair is a contact in this GroupContactSet, * the comparison is done by matching residue numbers and chain identifiers * @param group1 * @param group2 * @return */ public boolean hasContact(Group group1, Group group2) { return hasContact(group1.getResidueNumber(),group2.getResidueNumber()); }
/** * Returns the corresponding GroupContact or null if no contact exists between the 2 given groups * @param group1 * @param group2 * @return */ public GroupContact getContact(Group group1, Group group2) { return contacts.get( new Pair<ResidueNumber>(group1.getResidueNumber(),group2.getResidueNumber())); }
@Override public String toString() { return pair.getFirst().getResidueNumber()+","+pair.getSecond().getResidueNumber(); } }
public void setSecondGroupAsa(GroupAsa groupAsa) { groupAsas2.put(groupAsa.getGroup().getResidueNumber(), groupAsa); }
public void setFirstGroupAsa(GroupAsa groupAsa) { groupAsas1.put(groupAsa.getGroup().getResidueNumber(), groupAsa); }
@Override public String toString() { StringBuilder stringBuilder = new StringBuilder("SITE "); stringBuilder.append(siteID).append(" ").append(groups.size()).append(" "); for (Group group : groups) { // 012345678910 //'ARG H 221A ' String groupString = String.format("%s %s", group.getPDBName(), group.getResidueNumber().toPDB()); stringBuilder.append(groupString); } stringBuilder.append(lineEnd); return stringBuilder.toString(); }
/** * Auxiliary method to reset chain ids of residue numbers in a chain. * Used when cloning chains and resetting their ids: one needs to take care of * resetting the ids within residue numbers too. * @param c * @param newChainName */ private static void setChainIdsInResidueNumbers(Chain c, String newChainName) { for (Group g:c.getAtomGroups()) { g.setResidueNumber(newChainName, g.getResidueNumber().getSeqNum(), g.getResidueNumber().getInsCode()); } for (Group g:c.getSeqResGroups()) { if (g.getResidueNumber()==null) continue; g.setResidueNumber(newChainName, g.getResidueNumber().getSeqNum(), g.getResidueNumber().getInsCode()); } }
private ResidueNumber findResNumInOtherChains(int i, Chain chain) { // note that getChains contains all chains from all models, we'll just use first model found and skip the others for (Chain c: getFirstModelChains()) { if (c == chain) continue; Group seqResGroup = c.getSeqResGroup(i); if (seqResGroup==null) { logger.warn("The SEQRES group is null for index {} in chain with asym_id {}, whilst it wasn't null in chain with asym_id {}", i, c.getId(), chain.getId()); continue; } if (seqResGroup.getResidueNumber()!=null) return seqResGroup.getResidueNumber(); } return null; }
/** * * @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); }
/** * Calculates ASA for all atoms and return them as a GroupAsa * array (one element per residue in structure) containing ASAs per residue * and per atom. * The sorting of Groups in returned array is as specified by {@link org.biojava.nbio.structure.ResidueNumber} * @return */ public GroupAsa[] getGroupAsas() { TreeMap<ResidueNumber, GroupAsa> asas = new TreeMap<>(); double[] asasPerAtom = calculateAsas(); for (int i=0;i<atomCoords.length;i++) { Group g = atoms[i].getGroup(); if (!asas.containsKey(g.getResidueNumber())) { GroupAsa groupAsa = new GroupAsa(g); groupAsa.addAtomAsaU(asasPerAtom[i]); asas.put(g.getResidueNumber(), groupAsa); } else { GroupAsa groupAsa = asas.get(g.getResidueNumber()); groupAsa.addAtomAsaU(asasPerAtom[i]); } } return asas.values().toArray(new GroupAsa[asas.size()]); }
/** * * @return */ private Group getGroupWithSameResNumButDiffPDBName() { // If this chain already has this group number for (Group g : chain.getAtomGroups() ) { if (g.getResidueNumber().equals(group.getResidueNumber())) { if( ! g.getPDBName().equals(group.getPDBName() )){ return g; } } } return null; }
/** * Creates a new AtomPositionMap containing only atoms matched by {@code matcher}. * * If multiple atoms are present from a group, the first atom encountered will * be used. * @param atoms */ public AtomPositionMap(Atom[] atoms, GroupMatcher matcher) { hashMap = new HashMap<ResidueNumber, Integer>(); for (int i = 0; i < atoms.length; i++) { Group group = atoms[i].getGroup(); ResidueNumber rn = group.getResidueNumber(); if (matcher.matches(group)) { if (!hashMap.containsKey(rn)) { hashMap.put(rn, i); } } } Comparator<ResidueNumber> vc = new ValueComparator<ResidueNumber, Integer>(hashMap); treeMap = new TreeMap<ResidueNumber, Integer>(vc); treeMap.putAll(hashMap); }
/** * Returns true if the given group is part of the main chain, i.e. if it is * a peptide-linked group or a nucleotide * @param g * @return */ private static boolean isInChain(Group g) { ChemComp chemComp = g.getChemComp(); if (chemComp==null) { logger.warn("Warning: can't determine PolymerType for group "+g.getResidueNumber()+" ("+g.getPDBName()+"). Will consider it as non-nucleotide/non-protein type."); return false; } PolymerType polyType = chemComp.getPolymerType(); for (PolymerType protOnlyType: PolymerType.PROTEIN_ONLY) { if (polyType==protOnlyType) return true; } for (PolymerType protOnlyType: PolymerType.POLYNUCLEOTIDE_ONLY) { if (polyType==protOnlyType) return true; } return false; }
/** * The method will return a new reference to a Chain with any consecutive groups * having same residue numbers removed. * This is necessary to solve the microheterogeneity issue in entries like 3u7t (see github issue #160) * @param c * @return */ private static Chain removeSeqResHeterogeneity(Chain c) { Chain trimmedChain = new ChainImpl(); ResidueNumber lastResNum = null; for (Group g:c.getAtomGroups()) { // note we have to deep copy this, otherwise they stay linked and would get altered in addGroup(g) ResidueNumber currentResNum = new ResidueNumber( g.getResidueNumber().getChainName(), g.getResidueNumber().getSeqNum(), g.getResidueNumber().getInsCode()); if (lastResNum == null || !lastResNum.equals(currentResNum) ) { trimmedChain.addGroup(g); } else { logger.debug("Removing seqres group because it seems to be repeated in entity_poly_seq, most likely has hetero='y': "+g); } lastResNum = currentResNum; } return trimmedChain; }
/** * Calculate the HBonds between different groups. * see Creighton page 147 f * Modified to use only the contact map */ private void calculateHBonds() { /** * More efficient method for calculating C-Alpha pairs */ if (groups.length < 5) return; Iterator<AtomContact> otu = contactSet.iterator(); while(otu.hasNext()){ AtomContact ac = otu.next(); Pair<Atom> pair = ac.getPair(); Group g1 = pair.getFirst().getGroup(); Group g2 = pair.getSecond().getGroup(); // Now I need to get the index of the Group in the list groups int i = indResMap.get(g1.getResidueNumber()); int j = indResMap.get(g2.getResidueNumber()); // Now check this checkAddHBond(i,j); //"backwards" hbonds are not allowed if (j!=(i+1)) checkAddHBond(j,i); } }
private void getPdbRegions(Atom[] ca1, Atom[] ca2){ pdbresnum1 = new String[idx1.length]; pdbresnum2 = new String[idx2.length]; for (int i =0 ; i < idx1.length;i++){ Atom a1 = ca1[idx1[i]]; Atom a2 = ca2[idx2[i]]; Group p1 = a1.getGroup(); Group p2 = a2.getGroup(); Chain c1 = p1.getChain(); Chain c2 = p2.getChain(); String cid1 = c1.getId(); String cid2 = c2.getId(); String pdb1 = p1.getResidueNumber().toString(); String pdb2 = p2.getResidueNumber().toString(); if ( ! cid1.equals(" ")) pdb1 += ":" + cid1; if ( ! cid2.equals(" ")) pdb2 += ":" + cid2; pdbresnum1[i] = pdb1; pdbresnum2[i] = pdb2; } }
private static CharSequence getPDBPos(Atom atom) { Group g = atom.getGroup(); if ( g!= null){ Chain c = g.getChain(); if (c != null){ return g.getResidueNumber().toString()+":" + c.getName() ; //return g.getPDBCode()+":" + c.getName() + "." + getOneLetter(g) ; } } return "!"; }
/** * Return the symmetric repeats as structure identifiers, if the result is * symmetric and it was refined, return null otherwise. * * @return List of StructureIdentifiers or null if not defined * @throws StructureException */ public List<StructureIdentifier> getRepeatsID() throws StructureException { if (!isRefined()) return null; List<StructureIdentifier> repeats = new ArrayList<StructureIdentifier>( numRepeats); String pdbId = structureId.toCanonical().getPdbId(); Block align = multipleAlignment.getBlocks().get(0); for (int su = 0; su < numRepeats; su++) { // Get the start and end residues of the repeat ResidueNumber res1 = atoms[align.getStartResidue(su)].getGroup() .getResidueNumber(); ResidueNumber res2 = atoms[align.getFinalResidue(su)].getGroup() .getResidueNumber(); ResidueRange range = new ResidueRange(res1.getChainName(), res1, res2); StructureIdentifier id = new SubstructureIdentifier(pdbId, Arrays.asList(range)); repeats.add(id); } return repeats; }
public static Set<Group> getGroupsWithinShell(Structure structure, Atom atom, Set<ResidueNumber> excludeResidues, double distance, boolean includeWater) { // square the distance to use as a comparison against getDistanceFast // which returns the square of a distance. distance = distance * distance; Set<Group> returnSet = new LinkedHashSet<Group>(); for (Chain chain : structure.getChains()) { groupLoop: for (Group chainGroup : chain.getAtomGroups()) { if (!includeWater && chainGroup.isWater()) continue; for (ResidueNumber rn : excludeResidues) { if (rn.equals(chainGroup.getResidueNumber())) continue groupLoop; } for (Atom atomB : chainGroup.getAtoms()) { // use getDistanceFast as we are doing a lot of comparisons double dist = Calc.getDistanceFast(atom, atomB); if (dist <= distance) { returnSet.add(chainGroup); break; } } } } return returnSet; }
public static void printXMLEQRInferPositions(PrettyXMLWriter xml, AFPChain afpChain, int bk, Atom[] ca1, Atom[] ca2) throws IOException{ int[] optLen = afpChain.getOptLen(); if ( optLen == null) return; int[][][] optAln = afpChain.getOptAln(); for ( int pos=0;pos< optLen[bk];pos++){ int pos1 = optAln[bk][0][pos]; int pos2 = optAln[bk][1][pos]; xml.openTag("eqr"); xml.attribute("eqrNr", String.valueOf(pos)); xml.attribute("pdbres1",ca1[pos1].getGroup().getResidueNumber().toString()); xml.attribute("chain1", ca1[pos1].getGroup().getChain().getName()); xml.attribute("pdbres2",ca2[pos2].getGroup().getResidueNumber().toString()); xml.attribute("chain2", ca2[pos2].getGroup().getChain().getName()); xml.closeTag("eqr"); //System.out.println("aligned position: " + pos1 + ":" + pos2 + //" pdbresnum " + ca1[pos1].getGroup().getResidueNumber().toString() + " " + //ca1[pos1].getParent().getPDBName()+":" + //ca2[pos2].getGroup().getResidueNumber().toString() + " " + ca2[pos2].getParent().getPDBName()); } }