PiStacking fails on intra-protein detection

[pbuslaev]

I considered using ProLIF to study intra-protein interactions. So I essentially provided identical ligand and protein selections for interaction calculation. My selection inluded TYR, so ProLIF started detection for PiStacking, but ligand and protein residues were identical, Thus, Direction calculation here failed.

I thought, that the easiest way to overcome the error is to intercept here:

        for lresid, lres in lig.residues.items():
            if residues is None:
                prot_residues = get_residues_near_ligand(
                    lres,
                    prot,
                    self.vicinity_cutoff,
                    use_segid=self.use_segid or False,
                )
            for prot_key in prot_residues:  # type:ignore[union-attr]
                pres = prot[prot_key]
                # Avoid processing residue with itself, since it is anyway useless
                if pres.resid == lres.resid:
                    continue
                key = (lresid, pres.resid)
                interactions = get_interactions(lres, pres)
                if any(interactions):
                    ifp[key] = interactions  # type: ignore[assignment]

I tested the solution locally and it worked fine. Let me know, if you are up for this change. I, then, can create MR

[cbouy]

Hi @pbuslaev,

Overall this sounds like a great idea and I'd definitely accept a PR!
Since I haven't seen much intra-protein user stories and you're essentially the first one I might as well ask:
In your use case, do you think it could be useful to also ignore interactions between 2 residues that are covalently bonded?
I'm thinking that rather than only ignoring the self-interaction, it could be beneficial to introduce a new ignore parameter to the Fingerprint class that would expect a user-defined function in the form ResidueId, ResidueId -> bool. This would allow masking out any undesired interaction rather just the self interaction, e.g. we could have for your original issue:

Fingerprint(ignore=lambda resid1, resid2: resid1 == resid2)

As well as this for ignoring any interaction between covalently bonded residues (and the residue with itself):

Fingerprint(ignore=lambda resid1, resid2: resid1.chain == resid2.chain and abs(resid1.number - resid2.number) <= 1)

What do you think, unnecessary complication?

[pbuslaev]

also ignore interactions between 2 residues that are covalently bonded

In general, I can imagine how two neighbouring amino-acids interact, so not sure how general this would be.

a new ignore parameter to the Fingerprint class that would expect a user-defined function in the form ResidueId, ResidueId -> bool

While I think this is a good idea, I believe that self-interactions for all protein residues should be always excluded. I can imagine, self-interactions being of interest for some ligands though.

[batch2k]

@pbuslaev wow, that's the same problem I encountered with)
Analyzing intraprotein interactions, I receive:

...
--> 363 c1c2 = lig_centroid.DirectionVector(res_centroid)
364 c2c1 = res_centroid.DirectionVector(lig_centroid)
365 n1c1c2 = lig_normal.AngleTo(c1c2)

RuntimeError: Cannot normalize a zero length vector

The only solution working so far for me was excluding three stacking terms from the analysis, which is a pity.

[batch2k]

@cbouy As far as I see, the mentioned ignore parameter was not added?