Merge pull request #797 from molstar/ignore-hydrogens-interactions

support ignoreHydrogens for interactions

CHANGELOG.md

@@ -15,6 +15,7 @@ Note that since we don't clearly distinguish between a public and private interf
 - Add `SbNcbrPartialCharges` extension for coloring and labeling atoms and residues by partial atomic charges
   - uses custom mmcif categories `_sb_ncbr_partial_atomic_charges_meta` and `_sb_ncbr_partial_atomic_charges` (more info in [README.md](./src/extensions/sb-ncbr/README.md))
 - Parse HEADER record when reading PDB file
+- Support `ignoreHydrogens` in interactions representation
 
 ## [v3.34.0] - 2023-04-16
 

src/mol-model-props/computed/representations/interactions-inter-unit-cylinder.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -19,11 +19,13 @@ import { Interval, OrderedSet, SortedArray } from '../../../mol-data/int';
 import { Interactions } from '../interactions/interactions';
 import { InteractionsProvider } from '../interactions';
 import { LocationIterator } from '../../../mol-geo/util/location-iterator';
-import { InteractionFlag } from '../interactions/common';
+import { InteractionFlag, InteractionType } from '../interactions/common';
 import { Unit } from '../../../mol-model/structure/structure';
 import { Sphere3D } from '../../../mol-math/geometry';
 import { assertUnreachable } from '../../../mol-util/type-helpers';
 import { InteractionsSharedParams } from './shared';
+import { eachBondedAtom } from '../chemistry/util';
+import { isHydrogen } from '../../../mol-repr/structure/visual/util/common';
 
 function createInterUnitInteractionCylinderMesh(ctx: VisualContext, structure: Structure, theme: Theme, props: PD.Values<InteractionsInterUnitParams>, mesh?: Mesh) {
     if (!structure.hasAtomic) return Mesh.createEmpty(mesh);
@@ -33,26 +35,66 @@ function createInterUnitInteractionCylinderMesh(ctx: VisualContext, structure: S
     const { contacts, unitsFeatures } = interactions;
 
     const { edgeCount, edges } = contacts;
-    const { sizeFactor, parentDisplay } = props;
+    const { sizeFactor, ignoreHydrogens, ignoreHydrogensVariant, parentDisplay } = props;
 
     if (!edgeCount) return Mesh.createEmpty(mesh);
 
     const { child } = structure;
+    const p = Vec3();
+    const pA = Vec3();
+    const pB = Vec3();
 
     const builderProps = {
         linkCount: edgeCount,
         position: (posA: Vec3, posB: Vec3, edgeIndex: number) => {
-            const { unitA, indexA, unitB, indexB } = edges[edgeIndex];
+            const { unitA, indexA, unitB, indexB, props: { type: t } } = edges[edgeIndex];
             const fA = unitsFeatures.get(unitA);
             const fB = unitsFeatures.get(unitB);
-            const uA = structure.unitMap.get(unitA);
-            const uB = structure.unitMap.get(unitB);
-
-            Vec3.set(posA, fA.x[indexA], fA.y[indexA], fA.z[indexA]);
-            Vec3.transformMat4(posA, posA, uA.conformation.operator.matrix);
+            const uA = structure.unitMap.get(unitA) as Unit.Atomic;
+            const uB = structure.unitMap.get(unitB) as Unit.Atomic;
+
+            if ((!ignoreHydrogens || ignoreHydrogensVariant !== 'all') && (
+                t === InteractionType.HydrogenBond || t === InteractionType.WeakHydrogenBond)
+            ) {
+                const idxA = fA.members[fA.offsets[indexA]];
+                const idxB = fB.members[fB.offsets[indexB]];
+                uA.conformation.position(uA.elements[idxA], pA);
+                uB.conformation.position(uB.elements[idxB], pB);
+                let minDistA = Vec3.distance(pA, pB);
+                let minDistB = minDistA;
+                Vec3.copy(posA, pA);
+                Vec3.copy(posB, pB);
+
+                eachBondedAtom(structure, uA, idxA, (u, idx) => {
+                    const eI = u.elements[idx];
+                    if (isHydrogen(structure, u, eI, 'polar')) {
+                        u.conformation.position(eI, p);
+                        const dist = Vec3.distance(p, pB);
+                        if (dist < minDistA) {
+                            minDistA = dist;
+                            Vec3.copy(posA, p);
+                        }
+                    }
+                });
+
+                eachBondedAtom(structure, uB, idxB, (u, idx) => {
+                    const eI = u.elements[idx];
+                    if (isHydrogen(structure, u, eI, 'polar')) {
+                        u.conformation.position(eI, p);
+                        const dist = Vec3.distance(p, pA);
+                        if (dist < minDistB) {
+                            minDistB = dist;
+                            Vec3.copy(posB, p);
+                        }
+                    }
+                });
+            } else {
+                Vec3.set(posA, fA.x[indexA], fA.y[indexA], fA.z[indexA]);
+                Vec3.transformMat4(posA, posA, uA.conformation.operator.matrix);
 
-            Vec3.set(posB, fB.x[indexB], fB.y[indexB], fB.z[indexB]);
-            Vec3.transformMat4(posB, posB, uB.conformation.operator.matrix);
+                Vec3.set(posB, fB.x[indexB], fB.y[indexB], fB.z[indexB]);
+                Vec3.transformMat4(posB, posB, uB.conformation.operator.matrix);
+            }
         },
         style: (edgeIndex: number) => LinkStyle.Dashed,
         radius: (edgeIndex: number) => {
@@ -155,6 +197,8 @@ export function InteractionsInterUnitVisual(materialId: number): ComplexVisual<I
                 newProps.dashScale !== currentProps.dashScale ||
                 newProps.dashCap !== currentProps.dashCap ||
                 newProps.radialSegments !== currentProps.radialSegments ||
+                newProps.ignoreHydrogens !== currentProps.ignoreHydrogens ||
+                newProps.ignoreHydrogensVariant !== currentProps.ignoreHydrogensVariant ||
                 newProps.parentDisplay !== currentProps.parentDisplay
             );
 

src/mol-model-props/computed/representations/interactions-intra-unit-cylinder.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -21,9 +21,11 @@ import { LocationIterator } from '../../../mol-geo/util/location-iterator';
 import { Interactions } from '../interactions/interactions';
 import { InteractionFlag } from '../interactions/common';
 import { Sphere3D } from '../../../mol-math/geometry';
-import { StructureGroup } from '../../../mol-repr/structure/visual/util/common';
+import { StructureGroup, isHydrogen } from '../../../mol-repr/structure/visual/util/common';
 import { assertUnreachable } from '../../../mol-util/type-helpers';
 import { InteractionsSharedParams } from './shared';
+import { InteractionType } from '../interactions/common';
+import { eachIntraBondedAtom } from '../chemistry/util';
 
 async function createIntraUnitInteractionsCylinderMesh(ctx: VisualContext, unit: Unit, structure: Structure, theme: Theme, props: PD.Values<InteractionsIntraUnitParams>, mesh?: Mesh) {
     if (!Unit.isAtomic(unit)) return Mesh.createEmpty(mesh);
@@ -39,22 +41,64 @@ async function createIntraUnitInteractionsCylinderMesh(ctx: VisualContext, unit:
     const contacts = interactions.unitsContacts.get(unit.id);
 
     const { x, y, z, members, offsets } = features;
-    const { edgeCount, a, b, edgeProps: { flag } } = contacts;
-    const { sizeFactor, parentDisplay } = props;
+    const { edgeCount, a, b, edgeProps: { flag, type } } = contacts;
+    const { sizeFactor, ignoreHydrogens, ignoreHydrogensVariant, parentDisplay } = props;
 
     if (!edgeCount) return Mesh.createEmpty(mesh);
 
+    const pos = unit.conformation.invariantPosition;
+    const { elements } = unit;
+    const p = Vec3();
+    const pA = Vec3();
+    const pB = Vec3();
+
     const builderProps = {
         linkCount: edgeCount * 2,
         position: (posA: Vec3, posB: Vec3, edgeIndex: number) => {
-            Vec3.set(posA, x[a[edgeIndex]], y[a[edgeIndex]], z[a[edgeIndex]]);
-            Vec3.set(posB, x[b[edgeIndex]], y[b[edgeIndex]], z[b[edgeIndex]]);
+            const t = type[edgeIndex];
+            if ((!ignoreHydrogens || ignoreHydrogensVariant !== 'all') && (
+                t === InteractionType.HydrogenBond || t === InteractionType.WeakHydrogenBond)
+            ) {
+                const idxA = members[offsets[a[edgeIndex]]];
+                const idxB = members[offsets[b[edgeIndex]]];
+                pos(elements[idxA], pA);
+                pos(elements[idxB], pB);
+                let minDistA = Vec3.distance(pA, pB);
+                let minDistB = minDistA;
+                Vec3.copy(posA, pA);
+                Vec3.copy(posB, pB);
+
+                eachIntraBondedAtom(unit, idxA, (_, idx) => {
+                    if (isHydrogen(structure, unit, elements[idx], 'polar')) {
+                        pos(elements[idx], p);
+                        const dist = Vec3.distance(p, pB);
+                        if (dist < minDistA) {
+                            minDistA = dist;
+                            Vec3.copy(posA, p);
+                        }
+                    }
+                });
+
+                eachIntraBondedAtom(unit, idxB, (_, idx) => {
+                    if (isHydrogen(structure, unit, elements[idx], 'polar')) {
+                        pos(elements[idx], p);
+                        const dist = Vec3.distance(p, pA);
+                        if (dist < minDistB) {
+                            minDistB = dist;
+                            Vec3.copy(posB, p);
+                        }
+                    }
+                });
+            } else {
+                Vec3.set(posA, x[a[edgeIndex]], y[a[edgeIndex]], z[a[edgeIndex]]);
+                Vec3.set(posB, x[b[edgeIndex]], y[b[edgeIndex]], z[b[edgeIndex]]);
+            }
         },
         style: (edgeIndex: number) => LinkStyle.Dashed,
         radius: (edgeIndex: number) => {
-            location.element = unit.elements[members[offsets[a[edgeIndex]]]];
+            location.element = elements[members[offsets[a[edgeIndex]]]];
             const sizeA = theme.size.size(location);
-            location.element = unit.elements[members[offsets[b[edgeIndex]]]];
+            location.element = elements[members[offsets[b[edgeIndex]]]];
             const sizeB = theme.size.size(location);
             return Math.min(sizeA, sizeB) * sizeFactor;
         },
@@ -65,7 +109,7 @@ async function createIntraUnitInteractionsCylinderMesh(ctx: VisualContext, unit:
                 if (parentDisplay === 'stub') {
                     const f = a[edgeIndex];
                     for (let i = offsets[f], il = offsets[f + 1]; i < il; ++i) {
-                        const e = unit.elements[members[offsets[i]]];
+                        const e = elements[members[offsets[i]]];
                         if (!SortedArray.has(childUnit.elements, e)) return true;
                     }
                 } else if (parentDisplay === 'full' || parentDisplay === 'between') {
@@ -74,13 +118,13 @@ async function createIntraUnitInteractionsCylinderMesh(ctx: VisualContext, unit:
 
                     const fA = a[edgeIndex];
                     for (let i = offsets[fA], il = offsets[fA + 1]; i < il; ++i) {
-                        const eA = unit.elements[members[offsets[i]]];
+                        const eA = elements[members[offsets[i]]];
                         if (!SortedArray.has(childUnit.elements, eA)) flagA = true;
                     }
 
                     const fB = b[edgeIndex];
                     for (let i = offsets[fB], il = offsets[fB + 1]; i < il; ++i) {
-                        const eB = unit.elements[members[offsets[i]]];
+                        const eB = elements[members[offsets[i]]];
                         if (!SortedArray.has(childUnit.elements, eB)) flagB = true;
                     }
 
@@ -127,6 +171,8 @@ export function InteractionsIntraUnitVisual(materialId: number): UnitsVisual<Int
                 newProps.dashScale !== currentProps.dashScale ||
                 newProps.dashCap !== currentProps.dashCap ||
                 newProps.radialSegments !== currentProps.radialSegments ||
+                newProps.ignoreHydrogens !== currentProps.ignoreHydrogens ||
+                newProps.ignoreHydrogensVariant !== currentProps.ignoreHydrogensVariant ||
                 newProps.parentDisplay !== currentProps.parentDisplay
             );
 

src/mol-model-props/computed/representations/shared.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2022-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,6 +10,8 @@ export const InteractionsSharedParams = {
     sizeFactor: PD.Numeric(0.3, { min: 0, max: 10, step: 0.01 }),
     dashCount: PD.Numeric(6, { min: 2, max: 10, step: 2 }),
     dashScale: PD.Numeric(0.4, { min: 0, max: 2, step: 0.1 }),
+    ignoreHydrogens: PD.Boolean(false),
+    ignoreHydrogensVariant: PD.Select('all', PD.arrayToOptions(['all', 'non-polar'] as const)),
     includeParent: PD.Boolean(false),
     parentDisplay: PD.Select('stub', PD.arrayToOptions(['stub', 'full', 'between'] as const), { description: 'Only has an effect when "includeParent" is enabled. "Stub" shows just the child side of interactions to the parent. "Full" shows both sides of interactions to the parent. "Between" shows only interactions to the parent.' }),
 };

src/mol-repr/structure/visual/util/common.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author David Sehnal <david.sehnal@gmail.com>
@@ -314,12 +314,14 @@ export function getStructureConformationAndRadius(structure: Structure, sizeThem
 }
 
 const _H = AtomicNumbers['H'];
-export function isHydrogen(structure: Structure, unit: Unit, element: ElementIndex, variant: 'all' | 'non-polar') {
+export function isHydrogen(structure: Structure, unit: Unit, element: ElementIndex, variant: 'all' | 'non-polar' | 'polar') {
     if (Unit.isCoarse(unit)) return false;
-    return (
-        unit.model.atomicHierarchy.derived.atom.atomicNumber[element] === _H &&
-        (variant === 'all' || !hasPolarNeighbour(structure, unit, SortedArray.indexOf(unit.elements, element) as StructureElement.UnitIndex))
-    );
+    if (unit.model.atomicHierarchy.derived.atom.atomicNumber[element] !== _H) return false;
+    if (variant === 'all') return true;
+    const polar = hasPolarNeighbour(structure, unit, SortedArray.indexOf(unit.elements, element) as StructureElement.UnitIndex);
+    if (polar && variant === 'polar') return true;
+    if (!polar && variant === 'non-polar') return true;
+    return false;
 }
 export function isH(atomicNumber: ArrayLike<number>, element: ElementIndex) {
     return atomicNumber[element] === _H;