wip, renamed links to contacts for interactions

src/mol-model-props/computed/interactions/charged.ts

@@ -16,7 +16,7 @@ import { Elements } from '../../../mol-model/structure/model/properties/atomic/t
 import { ValenceModelProvider } from '../valence-model';
 import { degToRad } from '../../../mol-math/misc';
 import { FeatureType, FeatureGroup, InteractionType } from './common';
-import { LinkProvider } from './links';
+import { ContactProvider } from './contacts';
 import { Segmentation, SortedArray } from '../../../mol-data/int';
 import { isGuanidine, isAcetamidine, isPhosphate, isSulfonicAcid, isSulfate, isCarboxylate } from '../chemistry/functional-group';
 import { PrincipalAxes } from '../../../mol-math/linear-algebra/matrix/principal-axes';
@@ -375,7 +375,7 @@ export const NegativChargeProvider = Features.Provider([FeatureType.NegativeChar
 export const PositiveChargeProvider = Features.Provider([FeatureType.PositiveCharge], addUnitPositiveCharges)
 export const AromaticRingProvider = Features.Provider([FeatureType.AromaticRing], addUnitAromaticRings)
 
-export const IonicProvider: LinkProvider<IonicParams> = {
+export const IonicProvider: ContactProvider<IonicParams> = {
     name: 'ionic',
     params: IonicParams,
     createTester: (props: IonicProps) => {
@@ -388,7 +388,7 @@ export const IonicProvider: LinkProvider<IonicParams> = {
     }
 }
 
-export const PiStackingProvider: LinkProvider<PiStackingParams> = {
+export const PiStackingProvider: ContactProvider<PiStackingParams> = {
     name: 'pi-stacking',
     params: PiStackingParams,
     createTester: (props: PiStackingProps) => {
@@ -401,7 +401,7 @@ export const PiStackingProvider: LinkProvider<PiStackingParams> = {
     }
 }
 
-export const CationPiProvider: LinkProvider<CationPiParams> = {
+export const CationPiProvider: ContactProvider<CationPiParams> = {
     name: 'cation-pi',
     params: CationPiParams,
     createTester: (props: CationPiProps) => {

src/mol-model-props/computed/interactions/common.ts

@@ -8,11 +8,11 @@ import { IntAdjacencyGraph } from '../../../mol-math/graph'
 import { InterUnitGraph } from '../../../mol-math/graph/inter-unit-graph'
 import { Unit } from '../../../mol-model/structure'
 
-export type InteractionsIntraLinks = IntAdjacencyGraph<{ readonly type: ArrayLike<InteractionType> }>
+export type InteractionsIntraContacts = IntAdjacencyGraph<{ readonly type: ArrayLike<InteractionType> }>
 
-export { InteractionsInterLinks }
-type InteractionsInterLinks = InterUnitGraph<Unit, number, { type: InteractionType }>
-namespace InteractionsInterLinks {
+export { InteractionsInterContacts }
+type InteractionsInterContacts = InterUnitGraph<Unit, number, { type: InteractionType }>
+namespace InteractionsInterContacts {
     export class Pair extends InterUnitGraph.UnitPairEdges<Unit, number, { type: InteractionType }> {}
     export type Info = InterUnitGraph.EdgeInfo<number, { type: InteractionType }>
 }

src/mol-model-props/computed/interactions/links-builder.ts → src/mol-model-props/computed/interactions/contacts-builder.ts

@@ -6,20 +6,20 @@
 
 import { Features } from './features';
 import { IntAdjacencyGraph } from '../../../mol-math/graph';
-import { InteractionType, InteractionsIntraLinks, InteractionsInterLinks } from './common';
+import { InteractionType, InteractionsIntraContacts, InteractionsInterContacts } from './common';
 import { Unit, StructureElement } from '../../../mol-model/structure/structure';
 import { InterUnitGraph } from '../../../mol-math/graph/inter-unit-graph';
 import { UniqueArray } from '../../../mol-data/generic';
 
-export { IntraLinksBuilder }
+export { IntraContactsBuilder }
 
-interface IntraLinksBuilder {
+interface IntraContactsBuilder {
     add: (indexA: number, indexB: number, type: InteractionType) => void
-    getLinks: () => InteractionsIntraLinks
+    getLinks: () => InteractionsIntraContacts
 }
 
-namespace IntraLinksBuilder {
-    export function create(features: Features, elementsCount: number): IntraLinksBuilder {
+namespace IntraContactsBuilder {
+    export function create(features: Features, elementsCount: number): IntraContactsBuilder {
         const aIndices: number[] = []
         const bIndices: number[] = []
         const types: number[] = []
@@ -43,31 +43,31 @@ namespace IntraLinksBuilder {
     }
 }
 
-export { InterLinksBuilder }
+export { InterContactsBuilder }
 
-interface InterLinksBuilder {
+interface InterContactsBuilder {
     startUnitPair: (unitA: Unit, unitB: Unit) => void
     finishUnitPair: () => void
     add: (indexA: number, indexB: number, type: InteractionType) => void
-    getLinks: () => InteractionsInterLinks
+    getLinks: () => InteractionsInterContacts
 }
 
-namespace InterLinksBuilder {
+namespace InterContactsBuilder {
     function addMapEntry<A, B>(map: Map<A, B[]>, a: A, b: B) {
         if (map.has(a)) map.get(a)!.push(b);
         else map.set(a, [b]);
     }
 
-    export function create(): InterLinksBuilder {
+    export function create(): InterContactsBuilder {
         let uA: Unit
         let uB: Unit
-        let mapAB: Map<number, InteractionsInterLinks.Info[]>
-        let mapBA: Map<number, InteractionsInterLinks.Info[]>
+        let mapAB: Map<number, InteractionsInterContacts.Info[]>
+        let mapBA: Map<number, InteractionsInterContacts.Info[]>
         let bondedA: UniqueArray<StructureElement.UnitIndex, StructureElement.UnitIndex>
         let bondedB: UniqueArray<StructureElement.UnitIndex, StructureElement.UnitIndex>
         let bondCount: number
 
-        const map = new Map<number, InteractionsInterLinks.Pair[]>();
+        const map = new Map<number, InteractionsInterContacts.Pair[]>();
 
         return {
             startUnitPair(unitA: Unit, unitB: Unit) {
@@ -81,8 +81,8 @@ namespace InterLinksBuilder {
             },
             finishUnitPair() {
                 if (bondCount === 0) return
-                addMapEntry(map, uA.id, new InteractionsInterLinks.Pair(uA, uB, bondCount, bondedA.array, mapAB))
-                addMapEntry(map, uB.id, new InteractionsInterLinks.Pair(uB, uA, bondCount, bondedB.array, mapBA))
+                addMapEntry(map, uA.id, new InteractionsInterContacts.Pair(uA, uB, bondCount, bondedA.array, mapAB))
+                addMapEntry(map, uB.id, new InteractionsInterContacts.Pair(uB, uA, bondCount, bondedB.array, mapBA))
             },
             add(indexA: number, indexB: number, type: InteractionType) {
                 addMapEntry(mapAB, indexA, { indexB, props: { type } })

src/mol-model-props/computed/interactions/links.ts → src/mol-model-props/computed/interactions/contacts.ts

@@ -8,20 +8,20 @@ import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { Structure, Unit } from '../../../mol-model/structure';
 import { Features } from './features';
 import { InteractionType, FeatureType } from './common';
-import { IntraLinksBuilder, InterLinksBuilder } from './links-builder';
+import { IntraContactsBuilder, InterContactsBuilder } from './contacts-builder';
 import { Mat4, Vec3 } from '../../../mol-math/linear-algebra';
 import { altLoc, connectedTo } from '../chemistry/util';
 import { OrderedSet } from '../../../mol-data/int';
 
 const MAX_DISTANCE = 5
 
-export interface LinkProvider<P extends PD.Params> {
+export interface ContactProvider<P extends PD.Params> {
     readonly name: string
     readonly params: P
-    createTester(props: PD.Values<P>): LinkTester
+    createTester(props: PD.Values<P>): ContactTester
 }
 
-export interface LinkTester {
+export interface ContactTester {
     readonly maxDistance: number
     readonly requiredFeatures: ReadonlySet<FeatureType>
     getType: (structure: Structure, infoA: Features.Info, infoB: Features.Info, distanceSq: number) => InteractionType | undefined
@@ -42,16 +42,16 @@ function validPair(structure: Structure, infoA: Features.Info, infoB: Features.I
 }
 
 /**
- * Add all intra-unit links, i.e. pairs of features
+ * Add all intra-unit contacts, i.e. pairs of features
  */
-export function addUnitLinks(structure: Structure, unit: Unit.Atomic, features: Features, builder: IntraLinksBuilder, testers: ReadonlyArray<LinkTester>) {
+export function addUnitContacts(structure: Structure, unit: Unit.Atomic, features: Features, builder: IntraContactsBuilder, testers: ReadonlyArray<ContactTester>) {
 
     for (const tester of testers) {
-        _addUnitLinks(structure, unit, features, builder, tester)
+        _addUnitContacts(structure, unit, features, builder, tester)
     }
 }
 
-function _addUnitLinks(structure: Structure, unit: Unit.Atomic, features: Features, builder: IntraLinksBuilder, tester: LinkTester) {
+function _addUnitContacts(structure: Structure, unit: Unit.Atomic, features: Features, builder: IntraContactsBuilder, tester: ContactTester) {
     const { x, y, z } = features
     const { lookup3d, indices: subsetIndices } = features.subset(tester.requiredFeatures)
 
@@ -81,9 +81,9 @@ function _addUnitLinks(structure: Structure, unit: Unit.Atomic, features: Featur
 const _imageTransform = Mat4()
 
 /**
- * Add all inter-unit links, i.e. pairs of features
+ * Add all inter-unit contacts, i.e. pairs of features
  */
-export function addStructureLinks(structure: Structure, unitA: Unit.Atomic, featuresA: Features, unitB: Unit.Atomic, featuresB: Features, builder: InterLinksBuilder, testers: ReadonlyArray<LinkTester>) {
+export function addStructureContacts(structure: Structure, unitA: Unit.Atomic, featuresA: Features, unitB: Unit.Atomic, featuresB: Features, builder: InterContactsBuilder, testers: ReadonlyArray<ContactTester>) {
     const { count, x: xA, y: yA, z: zA } = featuresA;
     const { lookup3d } = featuresB;
 

src/mol-model-props/computed/interactions/halogen-bonds.ts

@@ -16,7 +16,7 @@ import { typeSymbol, eachBondedAtom } from '../chemistry/util';
 import { Elements } from '../../../mol-model/structure/model/properties/atomic/types';
 import { degToRad } from '../../../mol-math/misc';
 import { FeatureType, FeatureGroup, InteractionType } from './common';
-import { LinkProvider } from './links';
+import { ContactProvider } from './contacts';
 
 const HalogenBondsParams = {
     distanceMax: PD.Numeric(4.0, { min: 1, max: 5, step: 0.1 }),
@@ -115,7 +115,7 @@ function testHalogenBond(structure: Structure, infoA: Features.Info, infoB: Feat
 export const HalogenDonorProvider = Features.Provider([FeatureType.HalogenDonor], addUnitHalogenDonors)
 export const HalogenAcceptorProvider = Features.Provider([FeatureType.HalogenAcceptor], addUnitHalogenAcceptors)
 
-export const HalogenBondsProvider: LinkProvider<HalogenBondsParams> = {
+export const HalogenBondsProvider: ContactProvider<HalogenBondsParams> = {
     name: 'halogen-bonds',
     params: HalogenBondsParams,
     createTester: (props: HalogenBondsProps) => {

src/mol-model-props/computed/interactions/hydrogen-bonds.ts

@@ -16,7 +16,7 @@ import { Elements } from '../../../mol-model/structure/model/properties/atomic/t
 import { ValenceModelProvider } from '../valence-model';
 import { degToRad } from '../../../mol-math/misc';
 import { FeatureType, FeatureGroup, InteractionType } from './common';
-import { LinkProvider } from './links';
+import { ContactProvider } from './contacts';
 import { MoleculeType, ProteinBackboneAtoms } from '../../../mol-model/structure/model/types';
 
 const GeometryParams = {
@@ -307,7 +307,7 @@ export const HydrogenDonorProvider = Features.Provider([FeatureType.HydrogenDono
 export const WeakHydrogenDonorProvider = Features.Provider([FeatureType.WeakHydrogenDonor], addUnitWeakHydrogenDonors)
 export const HydrogenAcceptorProvider = Features.Provider([FeatureType.HydrogenAcceptor], addUnitHydrogenAcceptors)
 
-export const HydrogenBondsProvider: LinkProvider<HydrogenBondsParams> = {
+export const HydrogenBondsProvider: ContactProvider<HydrogenBondsParams> = {
     name: 'hydrogen-bonds',
     params: HydrogenBondsParams,
     createTester: (props: HydrogenBondsProps) => {
@@ -321,7 +321,7 @@ export const HydrogenBondsProvider: LinkProvider<HydrogenBondsParams> = {
     }
 }
 
-export const WeakHydrogenBondsProvider: LinkProvider<WeakHydrogenBondsParams> = {
+export const WeakHydrogenBondsProvider: ContactProvider<WeakHydrogenBondsParams> = {
     name: 'weak-hydrogen-bonds',
     params: WeakHydrogenBondsParams,
     createTester: (props: WeakHydrogenBondsProps) => {

src/mol-model-props/computed/interactions/hydrophobic.ts

@@ -13,7 +13,7 @@ import { FeaturesBuilder, Features } from './features';
 import { typeSymbol, eachBondedAtom } from '../chemistry/util';
 import { Elements } from '../../../mol-model/structure/model/properties/atomic/types';
 import { FeatureType, FeatureGroup, InteractionType } from './common';
-import { LinkProvider } from './links';
+import { ContactProvider } from './contacts';
 
 const HydrophobicParams = {
     distanceMax: PD.Numeric(4.0, { min: 1, max: 5, step: 0.1 }),
@@ -70,7 +70,7 @@ function testHydrophobic(structure: Structure, infoA: Features.Info, infoB: Feat
 
 export const HydrophobicAtomProvider = Features.Provider([FeatureType.HydrophobicAtom], addHydrophobicAtom)
 
-export const HydrophobicProvider: LinkProvider<HydrophobicParams> = {
+export const HydrophobicProvider: ContactProvider<HydrophobicParams> = {
     name: 'hydrophobic',
     params: HydrophobicParams,
     createTester: (props: HydrophobicProps) => {

src/mol-model-props/computed/interactions/interactions.ts

@@ -9,11 +9,11 @@ import { Structure, Unit } from '../../../mol-model/structure';
 import { RuntimeContext } from '../../../mol-task';
 import { Features, FeaturesBuilder } from './features';
 import { ValenceModelProvider } from '../valence-model';
-import { InteractionsIntraLinks, InteractionsInterLinks, FeatureType } from './common';
-import { IntraLinksBuilder, InterLinksBuilder } from './links-builder';
+import { InteractionsIntraContacts, InteractionsInterContacts, FeatureType } from './common';
+import { IntraContactsBuilder, InterContactsBuilder } from './contacts-builder';
 import { IntMap } from '../../../mol-data/int';
 import { Vec3 } from '../../../mol-math/linear-algebra';
-import { addUnitLinks, LinkTester, addStructureLinks, LinkProvider } from './links';
+import { addUnitContacts, ContactTester, addStructureContacts, ContactProvider } from './contacts';
 import { HalogenDonorProvider, HalogenAcceptorProvider, HalogenBondsProvider } from './halogen-bonds';
 import { HydrogenDonorProvider, WeakHydrogenDonorProvider, HydrogenAcceptorProvider, HydrogenBondsProvider, WeakHydrogenBondsProvider } from './hydrogen-bonds';
 import { NegativChargeProvider, PositiveChargeProvider, AromaticRingProvider, IonicProvider, PiStackingProvider, CationPiProvider } from './charged';
@@ -27,9 +27,9 @@ interface Interactions {
     /** Features of each unit */
     unitsFeatures: IntMap<Features>
     /** Interactions of each unit */
-    unitsLinks: IntMap<InteractionsIntraLinks>
+    unitsLinks: IntMap<InteractionsIntraContacts>
     /** Interactions between units */
-    links: InteractionsInterLinks
+    links: InteractionsInterContacts
 }
 
 namespace Interactions {
@@ -149,7 +149,7 @@ export async function computeInteractions(runtime: RuntimeContext, structure: St
     const p = { ...PD.getDefaultValues(InteractionsParams), ...props }
     await ValenceModelProvider.attach(structure).runInContext(runtime)
 
-    const linkProviders: LinkProvider<any>[] = []
+    const linkProviders: ContactProvider<any>[] = []
     Object.keys(LinkProviders).forEach(k => {
         if (p.types.includes(k)) linkProviders.push(LinkProviders[k as keyof typeof LinkProviders])
     })
@@ -160,7 +160,7 @@ export async function computeInteractions(runtime: RuntimeContext, structure: St
     const featureProviders = FeatureProviders.filter(f => SetUtils.areIntersecting(requiredFeatures, f.types))
 
     const unitsFeatures = IntMap.Mutable<Features>()
-    const unitsLinks = IntMap.Mutable<InteractionsIntraLinks>()
+    const unitsLinks = IntMap.Mutable<InteractionsIntraContacts>()
 
     for (let i = 0, il = structure.unitSymmetryGroups.length; i < il; ++i) {
         const group = structure.unitSymmetryGroups[i]
@@ -192,16 +192,16 @@ function findUnitFeatures(structure: Structure, unit: Unit, featureProviders: Fe
     return featuresBuilder.getFeatures(count)
 }
 
-function findIntraUnitLinks(structure: Structure, unit: Unit, features: Features, linkTesters: ReadonlyArray<LinkTester>) {
-    const linksBuilder = IntraLinksBuilder.create(features, unit.elements.length)
+function findIntraUnitLinks(structure: Structure, unit: Unit, features: Features, linkTesters: ReadonlyArray<ContactTester>) {
+    const linksBuilder = IntraContactsBuilder.create(features, unit.elements.length)
     if (Unit.isAtomic(unit)) {
-        addUnitLinks(structure, unit, features, linksBuilder, linkTesters)
+        addUnitContacts(structure, unit, features, linksBuilder, linkTesters)
     }
     return linksBuilder.getLinks()
 }
 
-function findInterUnitLinks(structure: Structure, unitsFeatures: IntMap<Features>, linkTesters: ReadonlyArray<LinkTester>) {
-    const builder = InterLinksBuilder.create()
+function findInterUnitLinks(structure: Structure, unitsFeatures: IntMap<Features>, linkTesters: ReadonlyArray<ContactTester>) {
+    const builder = InterContactsBuilder.create()
 
     const maxDistance = Math.max(...linkTesters.map(t => t.maxDistance))
 
@@ -224,9 +224,9 @@ function findInterUnitLinks(structure: Structure, unitsFeatures: IntMap<Features
             const featuresB = unitsFeatures.get(unitB.id)
 
             if (unitB.elements.length >= unitA.elements.length) {
-                addStructureLinks(structure, unitA, featuresA, unitB, featuresB, builder, linkTesters)
+                addStructureContacts(structure, unitA, featuresA, unitB, featuresB, builder, linkTesters)
             } else {
-                addStructureLinks(structure, unitB, featuresB, unitA, featuresA, builder, linkTesters)
+                addStructureContacts(structure, unitB, featuresB, unitA, featuresA, builder, linkTesters)
             }
         }
     }

src/mol-model-props/computed/interactions/metal.ts

@@ -12,7 +12,7 @@ import { FeaturesBuilder, Features } from './features';
 import { typeSymbol, compId, atomId } from '../chemistry/util';
 import { Elements, isTransitionMetal, isHalogen } from '../../../mol-model/structure/model/properties/atomic/types';
 import { FeatureType, FeatureGroup, InteractionType } from './common';
-import { LinkProvider } from './links';
+import { ContactProvider } from './contacts';
 import { ElementSymbol, AminoAcidNames, BaseNames, ProteinBackboneAtoms, NucleicBackboneAtoms } from '../../../mol-model/structure/model/types';
 
 export const MetalCoordinationParams = {
@@ -152,7 +152,7 @@ function testMetalCoordination(structure: Structure, infoA: Features.Info, infoB
 export const MetalProvider = Features.Provider([FeatureType.IonicTypeMetal, FeatureType.TransitionMetal], addMetal)
 export const MetalBindingProvider = Features.Provider([FeatureType.IonicTypePartner, FeatureType.DativeBondPartner], addMetalBinding)
 
-export const MetalCoordinationProvider: LinkProvider<MetalCoordinationParams> = {
+export const MetalCoordinationProvider: ContactProvider<MetalCoordinationParams> = {
     name: 'metal-coordination',
     params: MetalCoordinationParams,
     createTester: (props: MetalCoordinationProps) => {