/*
* 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 05.03.2004
* @author Andreas Prlic
*
*/
package org.biojava.nbio.structure;
import org.biojava.nbio.structure.io.GroupToSDF;
import org.biojava.nbio.structure.io.mmcif.ChemCompGroupFactory;
import org.biojava.nbio.structure.io.mmcif.chem.PolymerType;
import org.biojava.nbio.structure.io.mmcif.chem.ResidueType;
import org.biojava.nbio.structure.io.mmcif.model.ChemComp;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.Serializable;
import java.util.*;
/**
*
* Generic Implementation of a Group interface.
* AminoAcidImpl and NucleotideImpl are closely related classes.
* @see AminoAcidImpl
* @see NucleotideImpl
* @author Andreas Prlic
* @author Horvath Tamas
* @version %I% %G%
* @since 1.4
*/
public class HetatomImpl implements Group,Serializable {
private static final Logger logger = LoggerFactory.getLogger(HetatomImpl.class);
private static final long serialVersionUID = 4491470432023820382L;
/**
* The GroupType is HETATM
*/
public static final GroupType type = GroupType.HETATM ;
private Map<String, Object> properties ;
private long id;
/** stores if 3d coordinates are available. */
protected boolean pdb_flag ;
/** 3 letter name of amino acid in pdb file. */
protected String pdb_name ;
protected ResidueNumber residueNumber;
protected List<Atom> atoms ;
private Chain parent;
private boolean isHetAtomInFile;
/**
* Behaviors for how to balance memory vs. performance.
* @author Andreas Prlic
*/
public static enum PerformanceBehavior {
/** use a built-in HashMap for faster access to memory, at the price of more memory consumption */
BETTER_PERFORMANCE_MORE_MEMORY,
/** Try to minimize memory consumption, at the price of slower speed when accessing atoms by name */
LESS_MEMORY_SLOWER_PERFORMANCE
}
public static PerformanceBehavior performanceBehavior=PerformanceBehavior.LESS_MEMORY_SLOWER_PERFORMANCE;
private Map<String,Atom> atomNameLookup;
protected ChemComp chemComp ;
private List<Group> altLocs;
/**
* Construct a Hetatom instance.
*/
public HetatomImpl() {
super();
pdb_flag = false;
pdb_name = null ;
residueNumber = null;
atoms = new ArrayList<Atom>();
properties = new HashMap<String,Object>();
parent = null;
chemComp = null;
altLocs = null;
if ( performanceBehavior == PerformanceBehavior.BETTER_PERFORMANCE_MORE_MEMORY)
atomNameLookup = new HashMap<String,Atom>();
else
atomNameLookup = null;
}
/**
* returns true or false, depending if this group has 3D coordinates or not.
* @return true if Group has 3D coordinates
*/
@Override
public boolean has3D() {
return pdb_flag;
}
/** flag if group has 3D data.
*
* @param flag true to set flag that this Group has 3D coordinates
*/
@Override
public void setPDBFlag(boolean flag){
pdb_flag = flag ;
}
/** Set three character name of Group .
*
* @param s a String specifying the PDBName value
* @see #getPDBName
*/
@Override
public void setPDBName(String s) {
// hetatoms can have pdb_name length < 3. e.g. CU (see 1a4a position 1200 )
//if (s.length() != 3) {
//throw new PDBParseException("amino acid name is not of length 3!");
//}
if (s != null && s.equals("?")) logger.info("invalid pdbname: ?");
pdb_name =s ;
}
/**
* Returns the PDBName.
*
* @return a String representing the PDBName value
* @see #setPDBName
*/
@Override
public String getPDBName() { return pdb_name;}
/**
* {@inheritDoc}
*/
@Override
public void addAtom(Atom atom){
atom.setGroup(this);
atoms.add(atom);
// TODO this check is useless, coords are always !=null since they are initialized to 0,0,0 in AtomImpl constructor. We need to review this - JD 2016-09-14
if (atom.getCoordsAsPoint3d() != null){
// we have got coordinates!
setPDBFlag(true);
}
if (atomNameLookup != null){
Atom existingAtom = atomNameLookup.put(atom.getName(), atom);
// if an atom with same name is added to the group that has to be some kind of problem,
// we need to warn properly
if (existingAtom != null) {
String altLocStr = "";
char altLoc = atom.getAltLoc();
if (altLoc != ' ') altLocStr = "(alt loc '" + altLoc + "')";
logger.warn("An atom with name " + atom.getName() + " " + altLocStr + " is already present in group: " + this.toString() + ". The atom with serial " + atom.getPDBserial() + " will be ignored in look-ups.");
}
}
};
/** remove all atoms
*
*/
@Override
public void clearAtoms() {
atoms.clear();
setPDBFlag(false);
if ( atomNameLookup != null)
atomNameLookup.clear();
}
/**
* {@inheritDoc}
*/
@Override
public int size(){ return atoms.size(); }
/**
* {@inheritDoc}
*/
@Override
public List<Atom> getAtoms(){
return atoms ;
}
/**
* {@inheritDoc}
*/
@Override
public void setAtoms(List<Atom> atoms) {
// important we are resetting atoms to a new list, we need to reset the lookup too!
if ( atomNameLookup != null)
atomNameLookup.clear();
for (Atom a: atoms){
a.setGroup(this);
if ( atomNameLookup != null)
atomNameLookup.put(a.getName(),a);
}
this.atoms = atoms;
if (!atoms.isEmpty()) {
pdb_flag = true;
}
}
/**
* {@inheritDoc}
*/
@Override
public Atom getAtom(String name) {
if ( atomNameLookup != null)
return atomNameLookup.get(name);
else {
/** This is the performance penalty we pay for NOT using the atomnameLookup in PerformanceBehaviour.LESS_MEMORY_SLOWER_PERFORMANCE
*/
for (Atom a : atoms) {
if (a.getName().equals(name)) {
return a;
}
}
return null;
}
}
/**
* {@inheritDoc}
*/
@Override
public Atom getAtom(int position) {
if ((position < 0)|| ( position >= atoms.size())) {
//throw new StructureException("No atom found at position "+position);
return null;
}
return atoms.get(position);
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasAtom(String fullName) {
if ( atomNameLookup != null) {
Atom a = atomNameLookup.get(fullName.trim());
return a != null;
} else {
/** This is the performance penalty we pay for NOT using the atomnameLookup in PerformanceBehaviour.LESS_MEMORY_SLOWER_PERFORMANCE
*/
for (Atom a : atoms) {
if (a.getName().equals(fullName)) {
return true;
}
}
return false;
}
}
/**
* {@inheritDoc}
*/
@Override
public GroupType getType(){ return type;}
@Override
public String toString(){
String str = "Hetatom "+ residueNumber + " " + pdb_name + " "+ pdb_flag;
if (pdb_flag) {
str = str + " atoms: "+atoms.size();
}
if ( altLocs != null)
str += " has altLocs :" + altLocs.size();
return str ;
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasAminoAtoms(){
// if this method call is performed too often, it should become a
// private method and provide a flag for Group object ...
return hasAtom(StructureTools.CA_ATOM_NAME) &&
hasAtom(StructureTools.C_ATOM_NAME) &&
hasAtom(StructureTools.N_ATOM_NAME) &&
hasAtom(StructureTools.O_ATOM_NAME);
}
@Override
public boolean isPolymeric() {
ChemComp cc = getChemComp();
if ( cc == null)
return getType().equals(GroupType.AMINOACID) || getType().equals(GroupType.NUCLEOTIDE);
ResidueType rt = cc.getResidueType();
if ( rt.equals(ResidueType.nonPolymer))
return false;
PolymerType pt = rt.getPolymerType();
return PolymerType.PROTEIN_ONLY.contains(pt) ||
PolymerType.POLYNUCLEOTIDE_ONLY.contains(pt) ||
ResidueType.lPeptideLinking.equals(rt);
}
@Override
public boolean isAminoAcid() {
ChemComp cc = getChemComp();
if ( cc == null)
return getType().equals(GroupType.AMINOACID);
ResidueType rt = cc.getResidueType();
if ( rt.equals(ResidueType.nonPolymer))
return false;
PolymerType pt = rt.getPolymerType();
return PolymerType.PROTEIN_ONLY.contains(pt);
}
@Override
public boolean isNucleotide() {
ChemComp cc = getChemComp();
if ( cc == null)
return getType().equals(GroupType.NUCLEOTIDE);
ResidueType rt = cc.getResidueType();
if ( rt.equals(ResidueType.nonPolymer))
return false;
PolymerType pt = rt.getPolymerType();
return PolymerType.POLYNUCLEOTIDE_ONLY.contains(pt);
}
/**
* {@inheritDoc}
*/
@Override
public void setProperties(Map<String,Object> props) {
properties = props ;
}
/** return properties.
*
* @return a HashMap object representing the properties value
* @see #setProperties
*/
@Override
public Map<String, Object> getProperties() {
return properties ;
}
/** set a single property .
*
* @see #getProperties
* @see #getProperty
*/
@Override
public void setProperty(String key, Object value){
properties.put(key,value);
}
/** get a single property .
* @param key a String
* @return an Object
* @see #setProperty
* @see #setProperties
*/
@Override
public Object getProperty(String key){
return properties.get(key);
}
/** return an AtomIterator.
*
* @return an Iterator object
*/
@Override
public Iterator<Atom> iterator() {
return new AtomIterator(this);
}
/** returns and identical copy of this Group object .
* @return and identical copy of this Group object
*/
@Override
public Object clone() {
HetatomImpl n = new HetatomImpl();
n.setPDBFlag(has3D());
n.setResidueNumber(residueNumber);
n.setPDBName(getPDBName());
// copy the atoms
for (Atom atom1 : atoms) {
Atom atom = (Atom) atom1.clone();
n.addAtom(atom);
atom.setGroup(n);
}
// copying the alt loc groups if present, otherwise they stay null
if (altLocs!=null) {
for (Group altLocGroup:this.altLocs) {
Group nAltLocGroup = (Group)altLocGroup.clone();
n.addAltLoc(nAltLocGroup);
}
}
if (chemComp!=null)
n.setChemComp(chemComp);
return n;
}
/** the Hibernate database ID
*
* @return the id
*/
public long getId() {
return id;
}
/** the Hibernate database ID
*
* @param id the hibernate id
*/
public void setId(long id) {
this.id = id;
}
@Override
public ChemComp getChemComp() {
if ( chemComp == null ) {
chemComp = ChemCompGroupFactory.getChemComp(pdb_name);
if (chemComp == null) logger.info("getChemComp: " + pdb_name);
}
return chemComp;
}
@Override
public void setChemComp(ChemComp cc) {
chemComp = cc;
}
/**
* {@inheritDoc}
*/
@Override
public void setChain(Chain chain) {
this.parent = chain;
//TODO: setChain(), getChainName() and ResidueNumber.set/getChainName() are
//duplicating functionality at present and could give different values.
if (residueNumber != null) {
residueNumber.setChainName(chain.getName());
}
}
/**
* {@inheritDoc}
*/
@Override
public Chain getChain() {
return parent;
}
/**
* {@inheritDoc}
*/
@Override
public String getChainId() {
if (parent == null) {
return "";
}
return parent.getId();
}
/**
* {@inheritDoc}
*/
@Override
public ResidueNumber getResidueNumber() {
return residueNumber;
}
@Override
public void setResidueNumber(ResidueNumber residueNumber) {
this.residueNumber = residueNumber;
}
@Override
public void setResidueNumber(String chainId, Integer resNum, Character iCode) {
this.residueNumber = new ResidueNumber(chainId, resNum, iCode);
}
@Override
public boolean hasAltLoc() {
if ( altLocs == null)
return false;
return !altLocs.isEmpty();
}
@Override
public List<Group> getAltLocs() {
if ( altLocs == null)
return new ArrayList<Group>();
return altLocs;
}
@Override
public Group getAltLocGroup(Character altLoc) {
Atom a = getAtom(0);
if ( a == null) {
return null;
}
// maybe the alt loc group in question is myself
if (a.getAltLoc().equals(altLoc)) {
return this;
}
if (altLocs == null || altLocs.isEmpty())
return null;
for (Group group : altLocs) {
if (group.getAtoms().isEmpty())
continue;
// determine this group's alt-loc character code by looking
// at its first atom's alt-loc character
Atom b = group.getAtom(0);
if ( b == null)
continue;
if (b.getAltLoc().equals(altLoc)) {
return group;
}
}
return null;
}
@Override
public void addAltLoc(Group group) {
if ( altLocs == null) {
altLocs = new ArrayList<Group>();
}
altLocs.add(group);
}
@Override
public boolean isWater() {
return GroupType.WATERNAMES.contains(pdb_name);
}
/** attempts to reduce the memory imprint of this group by trimming
* all internal Collection objects to the required size.
*
*/
@Override
public void trimToSize(){
if ( atoms instanceof ArrayList<?>) {
ArrayList<Atom> myatoms = (ArrayList<Atom>) atoms;
myatoms.trimToSize();
}
if ( altLocs instanceof ArrayList<?>){
ArrayList<Group> myAltLocs = (ArrayList<Group>) altLocs;
myAltLocs.trimToSize();
}
if ( hasAltLoc()) {
for (Group alt : getAltLocs()){
alt.trimToSize();
}
}
// now let's fit the hashmaps to size
properties = new HashMap<String, Object>(properties);
if ( atomNameLookup != null)
atomNameLookup = new HashMap<String,Atom>(atomNameLookup);
}
@Override
public String toSDF() {
// Function to return the SDF of a given strucutre
GroupToSDF gts = new GroupToSDF();
return gts.getText(this);
}
@Override
public boolean isHetAtomInFile() {
return isHetAtomInFile;
}
@Override
public void setHetAtomInFile(boolean isHetAtomInFile) {
this.isHetAtomInFile = isHetAtomInFile;
}
}