Skip to content

Using hasAminoAtoms() for modified AA #337

Closed

Description

@lafita

Since the pull request #314 the ReducedChemCompProvider is the default behaviour. This generated some problems in parsing structures with modified aminoacids, because they are stored in Hetatom objects instead of AminoAcids. This was a problem when trying to extract the representative Atom Array of a Structure, the array being of different length when using the DownloadChemCompProvider (includes the modified AA) or the ReducedChemCompProvider (does not include them).

A possible solution to this issue could be to use the method Group.hasAminoAtoms(), instead of instanceof AminoAcid, since the method is independent of the Group implementation. From my point of view, the use of the ChemCompProvider should only affect the information of the aminoacid properties, but not fundamental methods like the representative array of a Structure.

I propose to use the method Group.hasAminoAtoms() consistently every time a Group needs to be checked for AminoAcid type, instead of the instanceof AminoAcid (which should only be used if the specific methods of the AminoAcid interface need to be used). This is currently done in the secondary structure annotation. Anyone sees a problem in the change?

Activity

  1. andreasprlic commented on Oct 19, 2015

    @andreasprlic
    Member

    One concern are C-alpha only protein structures. The proposed behavior would not work for those.

  2. pwrose commented on Oct 19, 2015

    @pwrose
    Member

    Proper handling of polymer chains (and non-polymers) will also be very
    important for our data compression project. Perhaps we can discuss the
    various issues around handling polymers and come up with a solution in our
    meeting on Wed.

    On Mon, Oct 19, 2015 at 10:21 AM, Andreas Prlic [email protected]
    wrote:

    One concern is C-alpha only protein structures. The proposed behavior
    would not work for those.

    —
    Reply to this email directly or view it on GitHub
    #337 (comment).

    Peter Rose, Ph.D.
    Site Head, RCSB Protein Data Bank West (http://www.rcsb.org)
    San Diego Supercomputer Center (http://bioinformatics.sdsc.edu)
    University of California, San Diego
    +1-858-822-5497

  3. josemduarte commented on Oct 19, 2015

    @josemduarte
    Contributor

    I'd also have some other concerns about that:

    • C-terminal aminoacids won't have all of the amino atoms as defined in Group.hasAminoAtoms() (C, N, CA, O) since O is replaced by OXT
    • Non-standard aminoacids must not necessarily follow the convention of naming the amino atoms as C, N, CA, O
    • Other compounds that are not aminoacid-related might use the names just by chance (nothing prohibits that)

    So in general it can be inaccurate to use that method. I'd say we should really try to stick to the ChemComp providers because they should provide the best descriptions. The issue we really need to address here is what we discussed in #314 and #315. Let's talk about it on the meeting and summarize here whatever we agree.

    One additional comment regarding the specific case of secondary structure you mention above: even if we identify aminoacids through the ChemComp provider, we are anyway still going to need to check for the existence of the 4 atoms (some atom might be missing for some reason, for instance unobserved in the density)

  4. lafita commented on Oct 20, 2015

    @lafita
    MemberAuthor

    OK! Thank you all for the explanations. I see the problems it might generate.

    In that case, I think we should use the same convention for the secondary structure, because the current implementation might take into account residues that happen to have the same Atom names (as @josemduarte pointed), but that are not in the backbone (so they should be discarded for SS prediction, because they might create confusing H-Bonds). Because we also don't want to consider residues with missing Atoms, the solution would be to check for both conditions:

    if ((group instanceof AminoAcid) && goup.hasAminoAtoms()) {
         //Do something with the SS
    }

    This assumes that the Chemical Component information was complete when loading the Structure (which implies that all backbone AA are stored in an AminoAcid instance), discussion still open in the #315 issue.

  5. andreasprlic commented on Oct 20, 2015

    @andreasprlic
    Member

    Actually for the DSSP implementation it is probably sufficient to just look at group.hasAminoAtoms() in order to decide if you can do calculations. If it has all the required atoms, why not let non-amino acids form hydrogen bonds and have secondary structure?

  6. lafita commented on Oct 21, 2015

    @lafita
    MemberAuthor

    I agree! It is probably less important in the SS than in the representative Atom array. So then the things stay as they are.

  7. sbliven commented on Oct 21, 2015

    @sbliven
    Member

    So, to summarize our skype discussion:

    1. We should switch the default to DownloadChemCompProvider, since that is the only consistent way of determining the polymer type. Unit tests should explicitly use the ReducedChemCompProvider to reduce IO, as should some other IO-sensitive applications where the ChemComp info doesn't matter (e.g. one-vs-all database searches).
    2. For the moment, accept the false negative for modified AAs if the use is choosing to use the Reduced provider.
    3. Keep this issue open with the intent to improve these non-default cases. Have a central method for determining the polymer type of a chain, which would use the following fallback strategy:
      a. If ChemComp data are available, use them
      b. Assume AminoAcid instances are polypeptides.
      c. Use atom names (hasAminoAtoms) as a final determinator for HetAtoms
  8. added this to the BioJava 4.2.0 milestone on Jan 31, 2016
  9. lafita commented on Feb 25, 2016

    @lafita
    MemberAuthor

    This issue has already been fixed in commit 51e10ed, where the DownloadChemCompProvider is set as the default. See also #397. Now that chemical component information is complete, the problem of determining the modified aminoacids is solved (because they will always be AminoAcid instances).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions