Merge branch 'master' into plugin

package.json

@@ -64,20 +64,20 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@graphql-codegen/add": "^1.11.2",
-    "@graphql-codegen/cli": "^1.11.2",
-    "@graphql-codegen/time": "^1.11.2",
-    "@graphql-codegen/typescript": "^1.11.2",
-    "@graphql-codegen/typescript-graphql-files-modules": "^1.11.2",
-    "@graphql-codegen/typescript-graphql-request": "^1.11.2",
-    "@graphql-codegen/typescript-operations": "^1.11.2",
+    "@graphql-codegen/add": "^1.12.2",
+    "@graphql-codegen/cli": "^1.12.2",
+    "@graphql-codegen/time": "^1.12.2",
+    "@graphql-codegen/typescript": "^1.12.2",
+    "@graphql-codegen/typescript-graphql-files-modules": "^1.12.2",
+    "@graphql-codegen/typescript-graphql-request": "^1.12.2",
+    "@graphql-codegen/typescript-operations": "^1.12.2",
     "@types/cors": "^2.8.6",
-    "@typescript-eslint/eslint-plugin": "^2.17.0",
-    "@typescript-eslint/eslint-plugin-tslint": "^2.17.0",
-    "@typescript-eslint/parser": "^2.17.0",
+    "@typescript-eslint/eslint-plugin": "^2.19.2",
+    "@typescript-eslint/eslint-plugin-tslint": "^2.19.2",
+    "@typescript-eslint/parser": "^2.19.2",
     "benchmark": "^2.1.4",
     "circular-dependency-plugin": "^5.2.0",
-    "concurrently": "^5.0.2",
+    "concurrently": "^5.1.0",
     "cpx2": "^2.0.0",
     "css-loader": "^3.4.2",
     "eslint": "^6.8.0",
@@ -93,9 +93,9 @@
     "raw-loader": "^4.0.0",
     "resolve-url-loader": "^3.1.1",
     "sass-loader": "^8.0.2",
-    "simple-git": "^1.130.0",
+    "simple-git": "^1.131.0",
     "style-loader": "^1.1.3",
-    "ts-jest": "^25.0.0",
+    "ts-jest": "^25.2.0",
     "typescript": "^3.7.5",
     "webpack": "^4.41.5",
     "webpack-cli": "^3.3.10"
@@ -103,10 +103,10 @@
   "dependencies": {
     "@types/argparse": "^1.0.38",
     "@types/benchmark": "^1.0.31",
-    "@types/compression": "1.0.1",
+    "@types/compression": "1.7.0",
     "@types/express": "^4.17.2",
-    "@types/jest": "^24.9.0",
-    "@types/node": "^13.1.8",
+    "@types/jest": "^25.1.2",
+    "@types/node": "^13.7.0",
     "@types/node-fetch": "^2.5.4",
     "@types/react": "^16.9.19",
     "@types/react-dom": "^16.9.5",
@@ -116,7 +116,7 @@
     "compression": "^1.7.4",
     "cors": "^2.8.5",
     "express": "^4.17.1",
-    "graphql": "^14.5.8",
+    "graphql": "^14.6.0",
     "immutable": "^3.8.2",
     "node-fetch": "^2.6.0",
     "react": "^16.12.0",

src/mol-data/db/column.ts

@@ -317,7 +317,8 @@ function windowColumn<T>(column: Column<T>, start: number, end: number): Column<
 
 function windowTyped<T>(c: Column<T>, start: number, end: number): Column<T> {
     const array = ColumnHelpers.typedArrayWindow(c.__array, { start, end });
-    return arrayColumn({ array, schema: c.schema, valueKind: c.valueKind }) as any;
+    const vk = c.valueKind;
+    return arrayColumn({ array, schema: c.schema, valueKind: row => vk(start + row) }) as any;
 }
 
 function windowFull<T>(c: Column<T>, start: number, end: number): Column<T> {
@@ -359,7 +360,8 @@ function arrayView<T>(c: Column<T>, map: ArrayLike<number>): Column<T> {
     const array = c.__array!;
     const ret = new (array as any).constructor(map.length);
     for (let i = 0, _i = map.length; i < _i; i++) ret[i] = array[map[i]];
-    return arrayColumn({ array: ret, schema: c.schema, valueKind: c.valueKind });
+    const vk = c.valueKind;
+    return arrayColumn({ array: ret, schema: c.schema, valueKind: row => vk(map[row]) });
 }
 
 function viewFull<T>(c: Column<T>, map: ArrayLike<number>): Column<T> {

src/mol-io/common/typed-array.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * Taken/adapted from DensityServer (https://github.com/dsehnal/DensityServer)
  *
@@ -10,15 +10,16 @@
 import { FileHandle } from '../../mol-io/common/file-handle';
 import { SimpleBuffer } from '../../mol-io/common/simple-buffer';
 
-export type TypedArrayValueType = 'float32' | 'int8' | 'int16'
+export type TypedArrayValueType = 'float32' | 'int8' | 'int16' | 'uint16'
 
 export namespace TypedArrayValueType {
     export const Float32: TypedArrayValueType = 'float32';
     export const Int8: TypedArrayValueType = 'int8';
     export const Int16: TypedArrayValueType = 'int16';
+    export const Uint16: TypedArrayValueType = 'uint16';
 }
 
-export type TypedArrayValueArray = Float32Array | Int8Array | Int16Array
+export type TypedArrayValueArray = Float32Array | Int8Array | Int16Array | Uint16Array
 
 export interface TypedArrayBufferContext {
     type: TypedArrayValueType,
@@ -31,12 +32,14 @@ export interface TypedArrayBufferContext {
 export function getElementByteSize(type: TypedArrayValueType) {
     if (type === TypedArrayValueType.Float32) return 4;
     if (type === TypedArrayValueType.Int16) return 2;
+    if (type === TypedArrayValueType.Uint16) return 2;
     return 1;
 }
 
 export function makeTypedArray(type: TypedArrayValueType, buffer: ArrayBuffer, byteOffset = 0, length?: number): TypedArrayValueArray {
     if (type === TypedArrayValueType.Float32) return new Float32Array(buffer, byteOffset, length);
     if (type === TypedArrayValueType.Int16) return new Int16Array(buffer, byteOffset, length);
+    if (type === TypedArrayValueType.Uint16) return new Uint16Array(buffer, byteOffset, length);
     return new Int8Array(buffer, byteOffset, length);
 }
 
@@ -45,6 +48,7 @@ export function createTypedArray(type: TypedArrayValueType, size: number) {
         case TypedArrayValueType.Float32: return new Float32Array(new ArrayBuffer(4 * size));
         case TypedArrayValueType.Int8: return new Int8Array(new ArrayBuffer(1 * size));
         case TypedArrayValueType.Int16: return new Int16Array(new ArrayBuffer(2 * size));
+        case TypedArrayValueType.Uint16: return new Uint16Array(new ArrayBuffer(2 * size));
     }
     throw Error(`${type} is not a supported value format.`);
 }

src/mol-io/reader/_spec/ccp4.spec.ts

@@ -16,10 +16,15 @@ function createCcp4Data() {
     dv.setInt8(52 * 4 + 2, 'P'.charCodeAt(0))
     dv.setInt8(52 * 4 + 3, ' '.charCodeAt(0))
 
+    dv.setUint8(53 * 4, 17)
+    dv.setUint8(53 * 4 + 1, 17)
+
     dv.setInt32(0 * 4, 1) // NC
     dv.setInt32(1 * 4, 2) // NR
     dv.setInt32(2 * 4, 3) // NS
 
+    dv.setInt32(3 * 4, 0) // MODE
+
     return data
 }
 

src/mol-io/reader/ccp4/parser.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -27,10 +27,14 @@ export async function readCcp4Header(file: FileHandle): Promise<{ header: Ccp4He
     // 54  MACHST      Machine stamp indicating machine type which wrote file
     //                 17 and 17 for big-endian or 68 and 65 for little-endian
     const MACHST = [ buffer.readUInt8(53 * 4), buffer.readUInt8(53 * 4 + 1) ]
-    let littleEndian = true
-    // found MRC files that don't have the MACHST stamp set and are big-endian
-    if (MACHST[0] !== 68 && MACHST[1] !== 65) {
+    let littleEndian = false
+    if (MACHST[0] === 68 && MACHST[1] === 65) {
+        littleEndian = true;
+    } else if (MACHST[0] === 17 && MACHST[1] === 17) {
         littleEndian = false;
+    } else {
+        const modeLE = buffer.readInt32LE(3 * 4)
+        if (modeLE <= 16) littleEndian = true;
     }
 
     const readInt = littleEndian ? (o: number) => buffer.readInt32LE(o * 4) : (o: number) => buffer.readInt32BE(o * 4)
@@ -117,11 +121,15 @@ export async function readCcp4Slices(header: Ccp4Header, buffer: TypedArrayBuffe
 
 function getCcp4DataType(mode: number) {
     switch (mode) {
-        case 2: return TypedArrayValueType.Float32
-        case 1: return TypedArrayValueType.Int16
         case 0: return TypedArrayValueType.Int8
+        case 1: return TypedArrayValueType.Int16
+        case 2: return TypedArrayValueType.Float32
+        case 3: throw new Error('mode 3 unsupported, complex 16-bit integers')
+        case 4: throw new Error('mode 4 unsupported, complex 32-bit reals')
+        case 6: TypedArrayValueType.Uint16
+        case 16: throw new Error('mode 16 unsupported, unsigned char * 3 (for rgb data, non-standard)')
     }
-    throw new Error(`ccp4 mode '${mode}' unsupported`);
+    throw new Error(`unknown mode '${mode}'`);
 }
 
 /** check if the file was converted by mapmode2to0, see https://github.com/uglymol/uglymol */

src/mol-io/reader/ccp4/schema.ts

@@ -115,5 +115,5 @@ export interface Ccp4Header {
  */
 export interface Ccp4File {
     header: Ccp4Header
-    values: Float32Array | Int16Array | Int8Array
+    values: Float32Array | Int16Array | Int8Array | Uint16Array
 }

src/mol-model-formats/structure/mmcif/atomic.ts

@@ -62,6 +62,7 @@ function createHierarchyData(atom_site: AtomSite, sourceIndex: Column<number>, o
     });
 
     const residues = Table.view(atom_site, ResiduesSchema, offsets.residues);
+
     // Optimize the numeric columns
     Table.columnToArray(residues, 'label_seq_id', Int32Array);
     Table.columnToArray(residues, 'auth_seq_id', Int32Array);

src/mol-model-formats/volume/ccp4.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -12,16 +12,19 @@ import { Ccp4File, Ccp4Header } from '../../mol-io/reader/ccp4/schema';
 import { degToRad } from '../../mol-math/misc';
 import { getCcp4ValueType } from '../../mol-io/reader/ccp4/parser';
 import { TypedArrayValueType } from '../../mol-io/common/typed-array';
+import { arrayMin, arrayRms, arrayMean, arrayMax } from '../../mol-util/array';
 
 /** When available (e.g. in MRC files) use ORIGIN records instead of N[CRS]START */
-export function getCcp4Origin(header: Ccp4Header) {
-    let gridOrigin: number[]
+export function getCcp4Origin(header: Ccp4Header): Vec3 {
     if (header.originX === 0.0 && header.originY === 0.0 && header.originZ === 0.0) {
-        gridOrigin = [header.NCSTART, header.NRSTART, header.NSSTART];
+        return Vec3.create(header.NCSTART, header.NRSTART, header.NSSTART)
     } else {
-        gridOrigin = [header.originX, header.originY, header.originZ];
+        return Vec3.create(
+            header.originX / (header.xLength / header.NX),
+            header.originY / (header.yLength / header.NY),
+            header.originZ / (header.zLength / header.NZ)
+        )
     }
-    return gridOrigin
 }
 
 function getTypedArrayCtor(header: Ccp4Header) {
@@ -30,25 +33,28 @@ function getTypedArrayCtor(header: Ccp4Header) {
         case TypedArrayValueType.Float32: return Float32Array;
         case TypedArrayValueType.Int8: return Int8Array;
         case TypedArrayValueType.Int16: return Int16Array;
+        case TypedArrayValueType.Uint16: return Uint16Array;
     }
     throw Error(`${valueType} is not a supported value format.`);
 }
 
-export function volumeFromCcp4(source: Ccp4File, params?: { voxelSize?: Vec3 }): Task<VolumeData> {
+export function volumeFromCcp4(source: Ccp4File, params?: { voxelSize?: Vec3, offset?: Vec3 }): Task<VolumeData> {
     return Task.create<VolumeData>('Create Volume Data', async ctx => {
         const { header, values } = source;
-        console.log({ header, values })
         const size = Vec3.create(header.xLength, header.yLength, header.zLength)
         if (params && params.voxelSize) Vec3.mul(size, size, params.voxelSize)
         const angles = Vec3.create(degToRad(header.alpha), degToRad(header.beta), degToRad(header.gamma))
-        const cell = SpacegroupCell.create(header.ISPG || 'P 1', size, angles);
+        const spacegroup = header.ISPG > 65536 ? 0 : header.ISPG
+        const cell = SpacegroupCell.create(spacegroup || 'P 1', size, angles);
 
         const axis_order_fast_to_slow = Vec3.create(header.MAPC - 1, header.MAPR - 1, header.MAPS - 1);
         const normalizeOrder = Tensor.convertToCanonicalAxisIndicesFastToSlow(axis_order_fast_to_slow);
 
         const grid = [header.NX, header.NY, header.NZ];
         const extent = normalizeOrder([header.NC, header.NR, header.NS]);
-        const gridOrigin = normalizeOrder(getCcp4Origin(header));
+        const origin = getCcp4Origin(header)
+        if (params?.offset) Vec3.add(origin, origin, params.offset)
+        const gridOrigin = normalizeOrder(origin);
 
         const origin_frac = Vec3.create(gridOrigin[0] / grid[0], gridOrigin[1] / grid[1], gridOrigin[2] / grid[2]);
         const dimensions_frac = Vec3.create(extent[0] / grid[0], extent[1] / grid[1], extent[2] / grid[2]);
@@ -65,10 +71,10 @@ export function volumeFromCcp4(source: Ccp4File, params?: { voxelSize?: Vec3 }):
             fractionalBox: Box3D.create(origin_frac, Vec3.add(Vec3.zero(), origin_frac, dimensions_frac)),
             data,
             dataStats: {
-                min: header.AMIN,
-                max: header.AMAX,
-                mean: header.AMEAN,
-                sigma: header.ARMS
+                min: isNaN(header.AMIN) ? arrayMin(values) : header.AMIN,
+                max: isNaN(header.AMAX) ? arrayMax(values) : header.AMAX,
+                mean: isNaN(header.AMEAN) ? arrayMean(values) : header.AMEAN,
+                sigma: (isNaN(header.ARMS) || header.ARMS === 0) ? arrayRms(values) : header.ARMS
             }
         };
     });

src/mol-model-props/rcsb/assembly-symmetry.ts

@@ -9,26 +9,42 @@ import query from './graphql/symmetry.gql';
 
 import { ParamDefinition as PD } from '../../mol-util/param-definition'
 import { CustomPropertyDescriptor, Structure } from '../../mol-model/structure';
-import { Database as _Database } from '../../mol-data/db'
+import { Database as _Database, Column } from '../../mol-data/db'
 import { GraphQLClient } from '../../mol-util/graphql-client';
 import { CustomProperty } from '../common/custom-property';
 import { NonNullableArray } from '../../mol-util/type-helpers';
 import { CustomStructureProperty } from '../common/custom-structure-property';
 
+const BiologicalAssemblyNames = new Set([
+    'author_and_software_defined_assembly',
+    'author_defined_assembly',
+    'complete icosahedral assembly',
+    'complete point assembly',
+    'representative helical assembly',
+    'software_defined_assembly'
+])
+
 export namespace AssemblySymmetry {
     export const DefaultServerUrl = 'http://data-beta.rcsb.org/graphql'
 
     export function isApplicable(structure?: Structure): boolean {
-        return (
-            !!structure &&
-            structure.models.length === 1 &&
-            structure.models[0].sourceData.kind === 'mmCIF' &&
-            (structure.models[0].sourceData.data.database_2.database_id.isDefined ||
-                structure.models[0].entryId.length === 4)
-        )
+        // check if structure is from pdb entry
+        if (!structure || structure.models.length !== 1 || structure.models[0].sourceData.kind !== 'mmCIF' || (!structure.models[0].sourceData.data.database_2.database_id.isDefined &&
+        structure.models[0].entryId.length !== 4)) return false
+
+        // check if assembly is 'biological'
+        const mmcif = structure.models[0].sourceData.data
+        if (!mmcif.pdbx_struct_assembly.details.isDefined) return false
+        const id = structure.units[0].conformation.operator.assembly.id
+        const indices = Column.indicesOf(mmcif.pdbx_struct_assembly.id, e => e === id)
+        if (indices.length !== 1) return false
+        const details = mmcif.pdbx_struct_assembly.details.value(indices[0])
+        return BiologicalAssemblyNames.has(details)
     }
 
     export async function fetch(ctx: CustomProperty.Context, structure: Structure, props: AssemblySymmetryProps): Promise<AssemblySymmetryValue> {
+        if (!isApplicable(structure)) return []
+
         const client = new GraphQLClient(props.serverUrl, ctx.fetch)
         const variables: AssemblySymmetryQueryVariables = {
             assembly_id: structure.units[0].conformation.operator.assembly.id,

src/mol-model-props/rcsb/validation-report.ts

@@ -6,7 +6,6 @@
 
 import { ParamDefinition as PD } from '../../mol-util/param-definition'
 import { CustomPropertyDescriptor, Structure, Unit } from '../../mol-model/structure';
-// import { Database as _Database } from '../../mol-data/db'
 import { CustomProperty } from '../common/custom-property';
 import { CustomModelProperty } from '../common/custom-model-property';
 import { Model, ElementIndex, ResidueIndex } from '../../mol-model/structure/model';
@@ -203,7 +202,7 @@ function createInterUnitClashes(structure: Structure, clashes: ValidationReport[
                     builder.add(indexA as UnitIndex, indexB as UnitIndex, {
                         id: id[i],
                         magnitude: magnitude[i],
-                        distance: distance[i]
+                        distance: distance[i],
                     })
                 }
             }
@@ -335,11 +334,12 @@ function ClashesBuilder(elementsCount: number) {
     const magnitudes: number[] = []
     const distances: number[] = []
 
-    const seen = new Map<number, ElementIndex>()
+    const seen = new Map<string, ElementIndex>()
 
     return {
-        add(element: ElementIndex, id: number, magnitude: number, distance: number) {
-            const other = seen.get(id)
+        add(element: ElementIndex, id: number, magnitude: number, distance: number, isSymop: boolean) {
+            const hash = `${id}|${isSymop ? 's' : ''}`
+            const other = seen.get(hash)
             if (other !== undefined) {
                 aIndices[aIndices.length] = element
                 bIndices[bIndices.length] = other
@@ -347,7 +347,7 @@ function ClashesBuilder(elementsCount: number) {
                 magnitudes[magnitudes.length] = magnitude
                 distances[distances.length] = distance
             } else {
-                seen.set(id, element)
+                seen.set(hash, element)
             }
         },
         get() {
@@ -513,7 +513,22 @@ function parseValidationReportXml(xml: XMLDocument, model: Model): ValidationRep
             const label_atom_id = getItem(ca, 'atom')
             const element = index.findAtomOnResidue(rI, label_atom_id, label_alt_id)
             if (element !== -1) {
-                clashesBuilder.add(element, id, magnitude, distance)
+                clashesBuilder.add(element, id, magnitude, distance, false)
+            }
+        }
+
+        const symmClashes = g.getElementsByTagName('symm-clash')
+        if (symmClashes.length) issues.add('symm-clash')
+
+        for (let j = 0, jl = symmClashes.length; j < jl; ++j) {
+            const sca = symmClashes[j].attributes
+            const id = parseInt(getItem(sca, 'scid'))
+            const magnitude = parseFloat(getItem(sca, 'clashmag'))
+            const distance = parseFloat(getItem(sca, 'dist'))
+            const label_atom_id = getItem(sca, 'atom')
+            const element = index.findAtomOnResidue(rI, label_atom_id, label_alt_id)
+            if (element !== -1) {
+                clashesBuilder.add(element, id, magnitude, distance, true)
             }
         }
 
@@ -527,7 +542,6 @@ function parseValidationReportXml(xml: XMLDocument, model: Model): ValidationRep
         bondOutliers, angleOutliers,
         clashes
     }
-    console.log(validationReport)
 
     return validationReport
 }

src/mol-model/structure/export/categories/atom_site.ts

@@ -36,7 +36,10 @@ const atom_site_fields = CifWriter.fields<StructureElement.Location, Structure>(
     .float('Cartn_y', P.atom.y, { digitCount: 3, encoder: E.fixedPoint3 })
     .float('Cartn_z', P.atom.z, { digitCount: 3, encoder: E.fixedPoint3 })
     .float('occupancy', P.atom.occupancy, { digitCount: 2, encoder: E.fixedPoint2 })
-    .int('pdbx_formal_charge', P.atom.pdbx_formal_charge, { encoder: E.deltaRLE })
+    .int('pdbx_formal_charge', P.atom.pdbx_formal_charge, { 
+        encoder: E.deltaRLE,
+        valueKind: (k, d) =>  k.unit.model.atomicHierarchy.atoms.pdbx_formal_charge.valueKind(k.element)
+    })
 
     .str('auth_atom_id', P.atom.auth_atom_id)
     .str('auth_comp_id', P.residue.auth_comp_id)

src/mol-model/structure/structure/carbohydrates/compute.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 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>
@@ -10,9 +10,9 @@ import { combinations } from '../../../../mol-data/util/combination';
 import { IntAdjacencyGraph } from '../../../../mol-math/graph';
 import { Vec3 } from '../../../../mol-math/linear-algebra';
 import { PrincipalAxes } from '../../../../mol-math/linear-algebra/matrix/principal-axes';
-import { fillSerial } from '../../../../mol-util/array';
+import { fillSerial, arraySetAdd } from '../../../../mol-util/array';
 import { ResidueIndex, Model } from '../../model';
-import { ElementSymbol } from '../../model/types';
+import { ElementSymbol, BondType } from '../../model/types';
 import { getPositions } from '../../util';
 import StructureElement from '../element';
 import Structure from '../structure';
@@ -20,6 +20,7 @@ import Unit from '../unit';
 import { CarbohydrateElement, CarbohydrateLink, Carbohydrates, CarbohydrateTerminalLink, PartialCarbohydrateElement, EmptyCarbohydrates } from './data';
 import { UnitRings, UnitRing } from '../unit/rings';
 import { ElementIndex } from '../../model/indexing';
+import { cantorPairing } from '../../../../mol-data/util';
 
 const C = ElementSymbol('C'), O = ElementSymbol('O');
 const SugarRingFps = [
@@ -67,18 +68,6 @@ function getAnomericCarbon(unit: Unit.Atomic, ringAtoms: ArrayLike<StructureElem
                     : elements[ringAtoms[0]]) as ElementIndex
 }
 
-/** Return first non-empty label_alt_id or an empty string */
-function getRingAltId(unit: Unit.Atomic, ringAtoms: SortedArray<StructureElement.UnitIndex>) {
-    const { elements } = unit
-    const { label_alt_id } = unit.model.atomicHierarchy.atoms
-    for (let i = 0, il = ringAtoms.length; i < il; ++i) {
-        const ei = elements[ringAtoms[i]]
-        const altId = label_alt_id.value(ei)
-        if (altId) return altId
-    }
-    return ''
-}
-
 function getAltId(unit: Unit.Atomic, index: StructureElement.UnitIndex) {
     const { elements } = unit
     const { label_alt_id } = unit.model.atomicHierarchy.atoms
@@ -100,12 +89,14 @@ function getAtomId(unit: Unit.Atomic, index: StructureElement.UnitIndex) {
 function filterFusedRings(unitRings: UnitRings, rings: UnitRings.Index[] | undefined) {
     if (!rings || !rings.length) return
 
+    const { unit, all } = unitRings
     const fusedRings = new Set<UnitRings.Index>()
     const ringCombinations = combinations(fillSerial(new Array(rings.length) as number[]), 2)
     for (let i = 0, il = ringCombinations.length; i < il; ++i) {
         const rc = ringCombinations[i];
-        const r0 = unitRings.all[rings[rc[0]]], r1 = unitRings.all[rings[rc[1]]];
-        if (SortedArray.areIntersecting(r0, r1)) {
+        const r0 = all[rings[rc[0]]], r1 = all[rings[rc[1]]];
+        if (SortedArray.areIntersecting(r0, r1) &&
+                UnitRing.getAltId(unit, r0) === UnitRing.getAltId(unit, r1)) {
             fusedRings.add(rings[rc[0]])
             fusedRings.add(rings[rc[1]])
         }
@@ -136,11 +127,14 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
     const elements: CarbohydrateElement[] = []
     const partialElements: PartialCarbohydrateElement[] = []
 
-    const elementsWithRingMap = new Map<string, number>()
-
+    const elementsWithRingMap = new Map<string, number[]>()
     function ringElementKey(residueIndex: number, unitId: number, altId: string) {
         return `${residueIndex}|${unitId}|${altId}`
     }
+    function addRingElement(key: string, elementIndex: number) {
+        if (elementsWithRingMap.has(key)) elementsWithRingMap.get(key)!.push(elementIndex)
+        else elementsWithRingMap.set(key, [elementIndex])
+    }
 
     function fixLinkDirection(iA: number, iB: number) {
         Vec3.sub(elements[iA].geometry.direction, elements[iB].geometry.center, elements[iA].geometry.center)
@@ -159,7 +153,7 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
         const unit = structure.units[i]
         if (!Unit.isAtomic(unit)) continue
 
-        const { model } = unit
+        const { model, rings } = unit
         const { chainAtomSegments, residueAtomSegments, residues } = model.atomicHierarchy
         const { label_comp_id } = residues
 
@@ -178,17 +172,16 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
                 if (!saccharideComp) continue
 
                 if (!sugarResidueMap) {
-                    sugarResidueMap = UnitRings.byFingerprintAndResidue(unit.rings, SugarRingFps);
+                    sugarResidueMap = UnitRings.byFingerprintAndResidue(rings, SugarRingFps);
                 }
 
-                const sugarRings = filterFusedRings(unit.rings, sugarResidueMap.get(residueIndex));
+                const sugarRings = filterFusedRings(rings, sugarResidueMap.get(residueIndex));
 
                 if (!sugarRings || !sugarRings.length) {
                     partialElements.push({ unit, residueIndex, component: saccharideComp })
                     continue;
                 }
 
-                const rings = unit.rings;
                 const ringElements: number[] = []
 
                 for (let j = 0, jl = sugarRings.length; j < jl; ++j) {
@@ -201,15 +194,19 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
                     const direction = getDirection(Vec3.zero(), unit, anomericCarbon, center)
                     Vec3.orthogonalize(direction, normal, direction)
 
-                    const ringAltId = getRingAltId(unit, ringAtoms)
+                    const ringAltId = UnitRing.getAltId(unit, ringAtoms)
                     const elementIndex = elements.length
                     ringElements.push(elementIndex)
-                    elementsWithRingMap.set(ringElementKey(residueIndex, unit.id, ringAltId), elementIndex)
+
+                    addRingElement(ringElementKey(residueIndex, unit.id, ringAltId), elementIndex)
+                    if (ringAltId) addRingElement(ringElementKey(residueIndex, unit.id, ''), elementIndex)
+
                     elements.push({
                         geometry: { center, normal, direction },
                         component: saccharideComp,
-                        unit, residueIndex, anomericCarbon, ringAltId,
-                        ringMemberCount: ringAtoms.length
+                        ringIndex: sugarRings[j],
+                        altId: ringAltId,
+                        unit, residueIndex
                     })
                 }
 
@@ -223,9 +220,9 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
                     if (IntAdjacencyGraph.areVertexSetsConnected(unit.bonds, r0, r1, 3)) {
                         const re0 = ringElements[rc[0]]
                         const re1 = ringElements[rc[1]]
-                        if (elements[re0].ringAltId === elements[re1].ringAltId) {
+                        if (elements[re0].altId === elements[re1].altId) {
                             // TODO handle better, for now fix both directions as it is unclear where the C1 atom is
-                            //  would need to know the path connecting the two rings
+                            //      would need to know the path connecting the two rings
                             fixLinkDirection(re0, re1)
                             fixLinkDirection(re1, re0)
                             links.push({ carbohydrateIndexA: re0, carbohydrateIndexB: re1 })
@@ -237,80 +234,86 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
         }
     }
 
-    function getRingElementIndex(unit: Unit.Atomic, index: StructureElement.UnitIndex) {
-        return elementsWithRingMap.get(ringElementKey(unit.getResidueIndex(index), unit.id, getAltId(unit, index)))
+    function getRingElementIndices(unit: Unit.Atomic, index: StructureElement.UnitIndex) {
+        return elementsWithRingMap.get(ringElementKey(unit.getResidueIndex(index), unit.id, getAltId(unit, index))) || []
     }
 
     // add carbohydrate links induced by intra-unit bonds
     // (e.g. for structures from the PDB archive __after__ carbohydrate remediation)
     for (let i = 0, il = elements.length; i < il; ++i) {
-        const carbohydrate = elements[i]
-        const { unit, residueIndex, anomericCarbon } = carbohydrate
-        const { offset, b } = unit.bonds
-        const ac = SortedArray.indexOf(unit.elements, anomericCarbon) as StructureElement.UnitIndex
-
-        for (let j = offset[ac], jl = offset[ac + 1]; j < jl; ++j) {
-            const bj = b[j] as StructureElement.UnitIndex
-            if (residueIndex !== unit.getResidueIndex(bj)) {
-                const ringElementIndex = getRingElementIndex(unit, bj)
-                if (ringElementIndex !== undefined && ringElementIndex !== i) {
-                    fixLinkDirection(i, ringElementIndex)
-                    links.push({
-                        carbohydrateIndexA: i,
-                        carbohydrateIndexB: ringElementIndex
-                    })
-                    links.push({
-                        carbohydrateIndexA: ringElementIndex,
-                        carbohydrateIndexB: i
-                    })
-                }
+        const cA = elements[i]
+        const { unit } = cA
+
+        for (let j = i + 1; j < il; ++j) {
+            const cB = elements[j]
+            if (unit !== cB.unit || cA.residueIndex === cB.residueIndex) continue
+            const rA = unit.rings.all[cA.ringIndex]
+            const rB = unit.rings.all[cB.ringIndex]
+
+            if (IntAdjacencyGraph.areVertexSetsConnected(unit.bonds, rA, rB, 3)) {
+                // TODO handle better, for now fix both directions as it is unclear where the C1 atom is
+                //      would need to know the path connecting the two rings
+                fixLinkDirection(i, j)
+                fixLinkDirection(j, i)
+                links.push({ carbohydrateIndexA: i, carbohydrateIndexB: j })
+                links.push({ carbohydrateIndexA: j, carbohydrateIndexB: i })
             }
         }
-
     }
 
     // get carbohydrate links induced by inter-unit bonds, that is
-    // terminal links plus inter monosaccharide links for structures from the
+    // inter monosaccharide links for structures from the
     // PDB archive __before__ carbohydrate remediation
+    // plus terminal links for __before__ and __after__
     for (let i = 0, il = structure.units.length; i < il; ++i) {
         const unit = structure.units[i]
         if (!Unit.isAtomic(unit)) continue
 
         structure.interUnitBonds.getConnectedUnits(unit).forEach(pairBonds => {
             pairBonds.connectedIndices.forEach(indexA => {
-                pairBonds.getEdges(indexA).forEach(bondInfo => {
+                pairBonds.getEdges(indexA).forEach(({ props, indexB }) => {
+                    if (!BondType.isCovalent(props.flag)) return
+
                     const { unitA, unitB } = pairBonds
-                    const indexB = bondInfo.indexB
-                    const ringElementIndexA = getRingElementIndex(unitA, indexA)
-                    const ringElementIndexB = getRingElementIndex(unitB, indexB)
-
-                    if (ringElementIndexA !== undefined && ringElementIndexB !== undefined) {
-                        const atomIdA = getAtomId(unitA, indexA)
-                        if (atomIdA.startsWith('O1') || atomIdA.startsWith('C1')) {
-                            fixLinkDirection(ringElementIndexA, ringElementIndexB)
+                    const ringElementIndicesA = getRingElementIndices(unitA, indexA)
+                    const ringElementIndicesB = getRingElementIndices(unitB, indexB)
+                    if (ringElementIndicesA.length > 0 && ringElementIndicesB.length > 0) {
+                        const lA = ringElementIndicesA.length
+                        const lB = ringElementIndicesB.length
+                        for (let j = 0, jl = Math.max(lA, lB); j < jl; ++j) {
+                            const ringElementIndexA = ringElementIndicesA[Math.min(j, lA - 1)]
+                            const ringElementIndexB = ringElementIndicesB[Math.min(j, lB - 1)]
+                            const atomIdA = getAtomId(unitA, indexA)
+                            if (atomIdA.startsWith('O1') || atomIdA.startsWith('C1')) {
+                                fixLinkDirection(ringElementIndexA, ringElementIndexB)
+                            }
+                            links.push({
+                                carbohydrateIndexA: ringElementIndexA,
+                                carbohydrateIndexB: ringElementIndexB
+                            })
                         }
-                        links.push({
-                            carbohydrateIndexA: ringElementIndexA,
-                            carbohydrateIndexB: ringElementIndexB
-                        })
-                    } else if (ringElementIndexA !== undefined) {
-                        const atomIdA = getAtomId(unitA, indexA)
-                        if (atomIdA.startsWith('O1') || atomIdA.startsWith('C1')) {
-                            fixTerminalLinkDirection(ringElementIndexA, indexB, unitB)
+                    } else if (ringElementIndicesB.length === 0) {
+                        for (const ringElementIndexA of ringElementIndicesA) {
+                            const atomIdA = getAtomId(unitA, indexA)
+                            if (atomIdA.startsWith('O1') || atomIdA.startsWith('C1')) {
+                                fixTerminalLinkDirection(ringElementIndexA, indexB, unitB)
+                            }
+                            terminalLinks.push({
+                                carbohydrateIndex: ringElementIndexA,
+                                elementIndex: indexB,
+                                elementUnit: unitB,
+                                fromCarbohydrate: true
+                            })
+                        }
+                    } else if (ringElementIndicesA.length === 0) {
+                        for (const ringElementIndexB of ringElementIndicesB) {
+                            terminalLinks.push({
+                                carbohydrateIndex: ringElementIndexB,
+                                elementIndex: indexA,
+                                elementUnit: unitA,
+                                fromCarbohydrate: false
+                            })
                         }
-                        terminalLinks.push({
-                            carbohydrateIndex: ringElementIndexA,
-                            elementIndex: indexB,
-                            elementUnit: unitB,
-                            fromCarbohydrate: true
-                        })
-                    } else if (ringElementIndexB !== undefined) {
-                        terminalLinks.push({
-                            carbohydrateIndex: ringElementIndexB,
-                            elementIndex: indexA,
-                            elementUnit: unitA,
-                            fromCarbohydrate: false
-                        })
                     }
                 })
             })
@@ -321,128 +324,82 @@ export function computeCarbohydrates(structure: Structure): Carbohydrates {
 }
 
 function buildLookups (elements: CarbohydrateElement[], links: CarbohydrateLink[], terminalLinks: CarbohydrateTerminalLink[]) {
-    // element lookup
 
-    function elementKey(unit: Unit, anomericCarbon: ElementIndex) {
-        return `${unit.id}|${anomericCarbon}`
+    function key(unit: Unit, element: ElementIndex) {
+        return cantorPairing(unit.id, element)
     }
 
-    const elementMap = new Map<string, number>()
-    for (let i = 0, il = elements.length; i < il; ++i) {
-        const { unit, anomericCarbon } = elements[i]
-        elementMap.set(elementKey(unit, anomericCarbon), i)
-    }
-
-    function getElementIndex(unit: Unit, anomericCarbon: ElementIndex) {
-        return elementMap.get(elementKey(unit, anomericCarbon))
+    function getIndices(map: Map<number, number[]>, unit: Unit.Atomic, index: ElementIndex): ReadonlyArray<number> {
+        const indices: number[] = []
+        const il = map.get(key(unit, index))
+        if (il !== undefined) {
+            for (const i of il) arraySetAdd(indices, i)
+        }
+        return indices
     }
 
-    // link lookup
+    // elements
 
-    function linkKey(unitA: Unit, anomericCarbonA: ElementIndex, unitB: Unit, anomericCarbonB: ElementIndex) {
-        return `${unitA.id}|${anomericCarbonA}|${unitB.id}|${anomericCarbonB}`
-    }
-
-    const linkMap = new Map<string, number>()
-    for (let i = 0, il = links.length; i < il; ++i) {
-        const l = links[i]
-        const { unit: unitA, anomericCarbon: anomericCarbonA } = elements[l.carbohydrateIndexA]
-        const { unit: unitB, anomericCarbon: anomericCarbonB } = elements[l.carbohydrateIndexB]
-        linkMap.set(linkKey(unitA, anomericCarbonA, unitB, anomericCarbonB), i)
+    const elementsMap = new Map<number, number[]>()
+    for (let i = 0, il = elements.length; i < il; ++i) {
+        const { unit, ringIndex } = elements[i]
+        const ring = unit.rings.all[ringIndex]
+        for (let j = 0, jl = ring.length; j < jl; ++j) {
+            const k = key(unit, unit.elements[ring[j]])
+            const e = elementsMap.get(k)
+            if (e === undefined) elementsMap.set(k, [i])
+            else e.push(i)
+        }
     }
 
-    function getLinkIndex(unitA: Unit, anomericCarbonA: ElementIndex, unitB: Unit, anomericCarbonB: ElementIndex) {
-        return linkMap.get(linkKey(unitA, anomericCarbonA, unitB, anomericCarbonB))
+    function getElementIndices(unit: Unit.Atomic, index: ElementIndex) {
+        return getIndices(elementsMap, unit, index)
     }
 
-    // links lookup
+    // links
 
-    function linksKey(unit: Unit, anomericCarbon: ElementIndex) {
-        return `${unit.id}|${anomericCarbon}`
-    }
-
-    const linksMap = new Map<string, number[]>()
+    const linksMap = new Map<number, number[]>()
     for (let i = 0, il = links.length; i < il; ++i) {
         const l = links[i]
-        const { unit, anomericCarbon } = elements[l.carbohydrateIndexA]
-        const k = linksKey(unit, anomericCarbon)
-        const e = linksMap.get(k)
-        if (e === undefined) linksMap.set(k, [i])
-        else e.push(i)
-    }
-
-    function getLinkIndices(unit: Unit, anomericCarbon: ElementIndex): ReadonlyArray<number> {
-        return linksMap.get(linksKey(unit, anomericCarbon)) || []
-    }
-
-    // terminal link lookup
-
-    function terminalLinkKey(unitA: Unit, elementA: ElementIndex, unitB: Unit, elementB: ElementIndex) {
-        return `${unitA.id}|${elementA}|${unitB.id}|${elementB}`
-    }
-
-    const terminalLinkMap = new Map<string, number>()
-    for (let i = 0, il = terminalLinks.length; i < il; ++i) {
-        const { fromCarbohydrate, carbohydrateIndex, elementUnit, elementIndex } = terminalLinks[i]
-        const { unit, anomericCarbon } = elements[carbohydrateIndex]
-        if (fromCarbohydrate) {
-            terminalLinkMap.set(terminalLinkKey(unit, anomericCarbon, elementUnit, elementUnit.elements[elementIndex]), i)
-        } else {
-            terminalLinkMap.set(terminalLinkKey(elementUnit, elementUnit.elements[elementIndex], unit, anomericCarbon), i)
+        const { unit, ringIndex } = elements[l.carbohydrateIndexA]
+        const ring = unit.rings.all[ringIndex]
+        for (let j = 0, jl = ring.length; j < jl; ++j) {
+            const k = key(unit, unit.elements[ring[j]])
+            const e = linksMap.get(k)
+            if (e === undefined) linksMap.set(k, [i])
+            else e.push(i)
         }
     }
 
-    function getTerminalLinkIndex(unitA: Unit, elementA: ElementIndex, unitB: Unit, elementB: ElementIndex) {
-        return terminalLinkMap.get(terminalLinkKey(unitA, elementA, unitB, elementB))
+    function getLinkIndices(unit: Unit.Atomic, index: ElementIndex) {
+        return getIndices(linksMap, unit, index)
     }
 
-    // terminal links lookup
+    // terminal links
 
-    function terminalLinksKey(unit: Unit, element: ElementIndex) {
-        return `${unit.id}|${element}`
-    }
-
-    const terminalLinksMap = new Map<string, number[]>()
+    const terminalLinksMap = new Map<number, number[]>()
     for (let i = 0, il = terminalLinks.length; i < il; ++i) {
         const { fromCarbohydrate, carbohydrateIndex, elementUnit, elementIndex } = terminalLinks[i]
-        const { unit, anomericCarbon } = elements[carbohydrateIndex]
-        let k: string
         if (fromCarbohydrate) {
-            k = terminalLinksKey(unit, anomericCarbon)
-        } else {
-            k = terminalLinksKey(elementUnit, elementUnit.elements[elementIndex])
-        }
-        const e = terminalLinksMap.get(k)
-        if (e === undefined) terminalLinksMap.set(k, [i])
-        else e.push(i)
-    }
-
-    function getTerminalLinkIndices(unit: Unit, element: ElementIndex): ReadonlyArray<number> {
-        return terminalLinksMap.get(terminalLinksKey(unit, element)) || []
-    }
-
-    // anomeric carbon lookup
-
-    function anomericCarbonKey(unit: Unit, residueIndex: ResidueIndex) {
-        return `${unit.id}|${residueIndex}`
-    }
-
-    const anomericCarbonMap = new Map<string, ElementIndex[]>()
-    for (let i = 0, il = elements.length; i < il; ++i) {
-        const { unit, anomericCarbon } = elements[i]
-        const residueIndex = unit.model.atomicHierarchy.residueAtomSegments.index[anomericCarbon]
-        const k = anomericCarbonKey(unit, residueIndex)
-        if (anomericCarbonMap.has(k)) {
-            anomericCarbonMap.get(k)!.push(anomericCarbon)
+            const { unit, ringIndex } = elements[carbohydrateIndex]
+            const ring = unit.rings.all[ringIndex]
+            for (let j = 0, jl = ring.length; j < jl; ++j) {
+                const k = key(unit, unit.elements[ring[j]])
+                const e = terminalLinksMap.get(k)
+                if (e === undefined) terminalLinksMap.set(k, [i])
+                else e.push(i)
+            }
         } else {
-            anomericCarbonMap.set(k, [anomericCarbon])
+            const k = key(elementUnit, elementUnit.elements[elementIndex])
+            const e = terminalLinksMap.get(k)
+            if (e === undefined) terminalLinksMap.set(k, [i])
+            else e.push(i)
         }
     }
 
-    const EmptyArray: ReadonlyArray<any> = []
-    function getAnomericCarbons(unit: Unit, residueIndex: ResidueIndex) {
-        return anomericCarbonMap.get(anomericCarbonKey(unit, residueIndex)) || EmptyArray
+    function getTerminalLinkIndices(unit: Unit.Atomic, index: ElementIndex) {
+        return getIndices(terminalLinksMap, unit, index)
     }
 
-    return { getElementIndex, getLinkIndex, getLinkIndices, getTerminalLinkIndex, getTerminalLinkIndices, getAnomericCarbons }
+    return { getElementIndices, getLinkIndices, getTerminalLinkIndices }
 }

src/mol-model/structure/structure/carbohydrates/data.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -9,6 +9,7 @@ import { Vec3 } from '../../../../mol-math/linear-algebra';
 import { ResidueIndex, ElementIndex } from '../../model';
 import { SaccharideComponent } from './constants';
 import StructureElement from '../element';
+import { UnitRings } from '../unit/rings';
 
 export interface CarbohydrateLink {
     readonly carbohydrateIndexA: number
@@ -18,19 +19,18 @@ export interface CarbohydrateLink {
 export interface CarbohydrateTerminalLink {
     readonly carbohydrateIndex: number
     readonly elementIndex: StructureElement.UnitIndex
-    readonly elementUnit: Unit
+    readonly elementUnit: Unit.Atomic
     /** specifies direction of the link */
     readonly fromCarbohydrate: boolean
 }
 
 export interface CarbohydrateElement {
     readonly geometry: { readonly center: Vec3, readonly normal: Vec3, readonly direction: Vec3 },
-    readonly anomericCarbon: ElementIndex,
     readonly unit: Unit.Atomic,
     readonly residueIndex: ResidueIndex,
     readonly component: SaccharideComponent,
-    readonly ringAltId: string,
-    readonly ringMemberCount: number,
+    readonly ringIndex: UnitRings.Index,
+    readonly altId: string
 }
 
 /** partial carbohydrate with no ring present */
@@ -45,12 +45,10 @@ export interface Carbohydrates {
     terminalLinks: ReadonlyArray<CarbohydrateTerminalLink>
     elements: ReadonlyArray<CarbohydrateElement>
     partialElements: ReadonlyArray<PartialCarbohydrateElement>
-    getElementIndex: (unit: Unit, anomericCarbon: ElementIndex) => number | undefined
-    getLinkIndex: (unitA: Unit, anomericCarbonA: ElementIndex, unitB: Unit, anomericCarbonB: ElementIndex) => number | undefined
-    getLinkIndices: (unit: Unit, anomericCarbon: ElementIndex) => ReadonlyArray<number>
-    getTerminalLinkIndex: (unitA: Unit, elementA: ElementIndex, unitB: Unit, elementB: ElementIndex) => number | undefined
-    getTerminalLinkIndices: (unit: Unit, element: ElementIndex) => ReadonlyArray<number>
-    getAnomericCarbons: (unit: Unit, residueIndex: ResidueIndex) => ReadonlyArray<ElementIndex>
+
+    getElementIndices: (unit: Unit.Atomic, element: ElementIndex) => ReadonlyArray<number>
+    getLinkIndices: (unit: Unit.Atomic, element: ElementIndex) => ReadonlyArray<number>
+    getTerminalLinkIndices: (unit: Unit.Atomic, element: ElementIndex) => ReadonlyArray<number>
 }
 
 const EmptyArray: ReadonlyArray<any> = []
@@ -59,10 +57,8 @@ export const EmptyCarbohydrates: Carbohydrates = {
     terminalLinks: EmptyArray,
     elements: EmptyArray,
     partialElements: EmptyArray,
-    getElementIndex: () => undefined,
-    getLinkIndex: () => undefined,
+
+    getElementIndices: () => EmptyArray,
     getLinkIndices: () => EmptyArray,
-    getTerminalLinkIndex: () => undefined,
     getTerminalLinkIndices: () => EmptyArray,
-    getAnomericCarbons: () => [],
 }

src/mol-model/structure/structure/element/location.ts

@@ -49,4 +49,12 @@ namespace Location {
         b.unit.conformation.position(b.element, pB);
         return Vec3.distance(pA, pB);
     }
+
+    export function residueIndex(l: Location) {
+        return l.unit.model.atomicHierarchy.residueAtomSegments.index[l.element];
+    }
+
+    export function chainIndex(l: Location) {
+        return l.unit.model.atomicHierarchy.chainAtomSegments.index[l.element];
+    }
 }

src/mol-model/structure/structure/unit/bonds/inter-compute.ts

@@ -81,7 +81,7 @@ function findPairBonds(unitA: Unit.Atomic, unitB: Unit.Atomic, props: BondComput
             for (const se of structConnEntries) {
                 for (const p of se.partners) {
                     const _bI = SortedArray.indexOf(unitB.elements, p.atomIndex) as StructureElement.UnitIndex;
-                    if (_bI < 0) continue;
+                    if (_bI < 0 || _aI === _bI) continue;
                     // check if the bond is within MAX_RADIUS for this pair of units
                     if (getDistance(unitA, aI, unitB, p.atomIndex) > MAX_RADIUS) continue;
                     builder.add(_aI, _bI, { order: se.order, flag: se.flags });

src/mol-model/structure/structure/unit/bonds/intra-compute.ts

@@ -67,15 +67,17 @@ function _computeBonds(unit: Unit.Atomic, props: BondComputationProps): IntraUni
         }
 
         const structConnEntries = props.forceCompute ? void 0 : structConn && structConn.getAtomEntries(aI);
+        const structConnAdded = new Set<StructureElement.UnitIndex>()
         if (structConnEntries) {
             for (const se of structConnEntries) {
                 for (const p of se.partners) {
                     const _bI = SortedArray.indexOf(unit.elements, p.atomIndex) as StructureElement.UnitIndex;
-                    if (_bI < 0) continue;
+                    if (_bI < 0 || _aI === _bI) continue;
                     atomA[atomA.length] = _aI;
                     atomB[atomB.length] = _bI;
                     flags[flags.length] = se.flags;
                     order[order.length] = se.order;
+                    structConnAdded.add(_bI)
                 }
             }
         }
@@ -104,6 +106,8 @@ function _computeBonds(unit: Unit.Atomic, props: BondComputationProps): IntraUni
 
         for (let ni = 0; ni < count; ni++) {
             const _bI = indices[ni];
+            if (structConnAdded.has(_bI)) continue;
+
             const bI = atoms[_bI];
             if (bI <= aI) continue;
 

src/mol-model/structure/structure/unit/rings.ts

@@ -97,7 +97,7 @@ namespace UnitRing {
     ] as ElementSymbol[])
     const AromaticRingPlanarityThreshold = 0.05
 
-    export function isAromatic(unit: Unit.Atomic, ring: SortedArray<StructureElement.UnitIndex>): boolean {
+    export function isAromatic(unit: Unit.Atomic, ring: UnitRing): boolean {
         const { elements, bonds: { b, offset, edgeProps: { flags } } } = unit;
         const { type_symbol } = unit.model.atomicHierarchy.atoms;
         const { label_comp_id } = unit.model.atomicHierarchy.residues;
@@ -128,6 +128,20 @@ namespace UnitRing {
         const ma = PrincipalAxes.calculateMomentsAxes(getPositions(unit, ring))
         return Vec3.magnitude(ma.dirC) < AromaticRingPlanarityThreshold
     }
+
+    /** Get the alternate location of the 1st non '' alt loc atom. */
+    export function getAltId(unit: Unit.Atomic, ring: UnitRing) {
+        const { label_alt_id } = unit.model.atomicHierarchy.atoms;
+        const { elements } = unit;
+
+        for (let i = 0, il = ring.length; i < il; ++i) {
+            const eI = elements[ring[i]];
+            const altId = label_alt_id.value(eI);
+            if (altId) return altId;
+        }
+
+        return '';
+    }
 }
 
 namespace UnitRings {
@@ -143,9 +157,11 @@ namespace UnitRings {
     /** Creates a mapping ResidueIndex -> list or rings that are on that residue and have one of the specified fingerprints. */
     export function byFingerprintAndResidue(rings: UnitRings, fingerprints: ReadonlyArray<UnitRing.Fingerprint>) {
         const map = new Map<ResidueIndex, Index[]>();
-        for (const fp of fingerprints) {
+    
+        for (let fI = 0, _fI = fingerprints.length; fI < _fI; fI++) {
+            const fp = fingerprints[fI];
             addSingleResidueRings(rings, fp, map);
-        }
+        }        
         return map;
     }
 }
@@ -153,7 +169,8 @@ namespace UnitRings {
 function createByFingerprint(unit: Unit.Atomic, rings: ReadonlyArray<UnitRing>) {
     const byFingerprint = new Map<UnitRing.Fingerprint, UnitRings.Index[]>();
     let idx = 0 as UnitRings.Index;
-    for (const r of rings) {
+    for (let rI = 0, _rI = rings.length; rI < _rI; rI++) {
+        const r = rings[rI];
         const fp = UnitRing.fingerprint(unit, r);
         if (byFingerprint.has(fp)) byFingerprint.get(fp)!.push(idx);
         else byFingerprint.set(fp, [idx]);
@@ -175,7 +192,8 @@ function ringResidueIdx(unit: Unit.Atomic, ring: ArrayLike<StructureElement.Unit
 function addSingleResidueRings(rings: UnitRings, fp: UnitRing.Fingerprint, map: Map<ResidueIndex, UnitRings.Index[]>) {
     const byFp = rings.byFingerprint.get(fp);
     if (!byFp) return;
-    for (const r of byFp) {
+    for (let rI = 0, _rI = byFp.length; rI < _rI; rI++) {
+        const r = byFp[rI];
         const idx = ringResidueIdx(rings.unit, rings.all[r]);
         if (idx >= 0) {
             if (map.has(idx)) map.get(idx)!.push(r);

src/mol-model/structure/structure/unit/rings/compute.ts

@@ -11,6 +11,8 @@ import { StructureElement } from '../../../structure';
 import Unit from '../../unit';
 import { IntraUnitBonds } from '../bonds/data';
 import { sortArray } from '../../../../../mol-data/util';
+import { Column } from '../../../../../mol-data/db';
+import { arraySetAdd, arraySetRemove } from '../../../../../mol-util/array';
 
 export function computeRings(unit: Unit.Atomic) {
     const size = largestResidue(unit);
@@ -42,10 +44,14 @@ interface State {
     right: Int32Array,
 
     currentColor: number,
+    currentAltLoc: string,
+    hasAltLoc: boolean,
 
     rings: SortedArray<StructureElement.UnitIndex>[],
+    currentRings: SortedArray<StructureElement.UnitIndex>[],
     bonds: IntraUnitBonds,
-    unit: Unit.Atomic
+    unit: Unit.Atomic,
+    altLoc: Column<string>
 }
 
 function State(unit: Unit.Atomic, capacity: number): State {
@@ -60,9 +66,13 @@ function State(unit: Unit.Atomic, capacity: number): State {
         right: new Int32Array(Constants.MaxDepth),
         color: new Int32Array(capacity),
         currentColor: 0,
+        currentAltLoc: '',
+        hasAltLoc: false,
         rings: [],
+        currentRings: [],
         unit,
-        bonds: unit.bonds
+        bonds: unit.bonds,
+        altLoc: unit.model.atomicHierarchy.atoms.label_alt_id
     };
 }
 
@@ -75,6 +85,8 @@ function resetState(state: State) {
         color[i] = 0;
     }
     state.currentColor = 0;
+    state.currentAltLoc = '';
+    state.hasAltLoc = false;
 }
 
 function largestResidue(unit: Unit.Atomic) {
@@ -95,17 +107,48 @@ function processResidue(state: State, start: number, end: number) {
     // no two atom rings
     if (state.endVertex - state.startVertex < 3) return;
 
-    resetState(state);
+    state.currentRings = [];
 
-    for (let i = 0; i < state.count; i++) {
-        if (visited[i] >= 0) continue;
-        findRings(state, i);
+    const { elements } = state.unit;
+    const altLocs: string[] = [];
+    for (let i = state.startVertex; i < state.endVertex; i++) {
+        const altLoc = state.altLoc.value(elements[i]);
+        arraySetAdd(altLocs, altLoc);
+    }
+    arraySetRemove(altLocs, '');
+    
+    if (altLocs.length === 0) {
+        resetState(state);
+        for (let i = 0; i < state.count; i++) {
+            if (visited[i] >= 0) continue;
+            findRings(state, i);
+        }
+    } else {
+        for (let aI = 0; aI < altLocs.length; aI++) {
+            resetState(state);
+            state.hasAltLoc = true;
+            state.currentAltLoc = altLocs[aI];
+            for (let i = 0; i < state.count; i++) {
+                if (visited[i] >= 0) continue;
+                const altLoc = state.altLoc.value(elements[state.startVertex + i]);
+                if (altLoc && altLoc !== state.currentAltLoc) {
+                    continue;
+                }
+                findRings(state, i);
+            }
+        }
+    }
+
+    for (let i = 0, _i = state.currentRings.length; i < _i; i++) {
+        state.rings.push(state.currentRings[i]);
     }
 }
 
 function addRing(state: State, a: number, b: number) {
     // only "monotonous" rings
-    if (b < a) return;
+    if (b < a) {
+        return;
+    }
 
     const { pred, color, left, right } = state;
     const nc = ++state.currentColor;
@@ -132,7 +175,9 @@ function addRing(state: State, a: number, b: number) {
         current = pred[current];
         if (current < 0) break;
     }
-    if (!found) return;
+    if (!found) {
+        return;
+    }
 
     current = a;
     for (let t = 0; t < Constants.MaxDepth; t++) {
@@ -144,7 +189,9 @@ function addRing(state: State, a: number, b: number) {
 
     const len = leftOffset + rightOffset
     // rings must have at least three elements
-    if (len < 3) return
+    if (len < 3) {
+        return;
+    }
 
     const ring = new Int32Array(len);
     let ringOffset = 0;
@@ -152,11 +199,34 @@ function addRing(state: State, a: number, b: number) {
     for (let t = rightOffset - 1; t >= 0; t--) ring[ringOffset++] = state.startVertex + right[t];
 
     sortArray(ring);
-    state.rings.push(SortedArray.ofSortedArray(ring));
+
+    if (state.hasAltLoc) {
+        // we need to check if the ring was already added because alt locs are present.
+
+        for (let rI = 0, _rI = state.currentRings.length; rI < _rI; rI++) {
+            const r = state.currentRings[rI];
+            if (ring[0] !== r[0]) continue;
+            if (ring.length !== r.length) continue;
+
+            let areSame = true;
+            for (let aI = 0, _aI = ring.length; aI < _aI; aI++) {
+                if (ring[aI] !== r[aI]) {
+                    areSame = false;
+                    break;
+                }
+            }
+            if (areSame) {
+                return;
+            }
+        }
+    }
+
+    state.currentRings.push(SortedArray.ofSortedArray(ring));
 }
 
 function findRings(state: State, from: number) {
     const { bonds, startVertex, endVertex, visited, queue, pred } = state;
+    const { elements } = state.unit;
     const { b: neighbor, edgeProps: { flags: bondFlags }, offset } = bonds;
     visited[from] = 1;
     queue[0] = from;
@@ -171,10 +241,19 @@ function findRings(state: State, from: number) {
             const b = neighbor[i];
             if (b < startVertex || b >= endVertex || !BondType.isCovalent(bondFlags[i])) continue;
 
+            if (state.hasAltLoc) {
+                const altLoc = state.altLoc.value(elements[b]);
+                if (altLoc && state.currentAltLoc !== altLoc) {
+                    continue;
+                }
+            }
+
             const other = b - startVertex;
 
             if (visited[other] > 0) {
-                if (pred[other] !== top && pred[top] !== other) addRing(state, top, other);
+                if (pred[other] !== top && pred[top] !== other) {
+                    addRing(state, top, other);
+                }
                 continue;
             }
 

src/mol-plugin-ui/state/snapshots.tsx

@@ -7,7 +7,7 @@
 import { PluginCommands } from '../../mol-plugin/command';
 import * as React from 'react';
 import { PluginUIComponent, PurePluginUIComponent } from '../base';
-import { shallowEqual } from '../../mol-util';
+import { shallowEqualObjects } from '../../mol-util';
 import { OrderedMap } from 'immutable';
 import { ParameterControls } from '../controls/parameters';
 import { ParamDefinition as PD} from '../../mol-util/param-definition';
@@ -81,7 +81,7 @@ class LocalStateSnapshots extends PluginUIComponent<
     }
 
     shouldComponentUpdate(nextProps: any, nextState: any) {
-        return !shallowEqual(this.props, nextProps) || !shallowEqual(this.state, nextState);
+        return !shallowEqualObjects(this.props, nextProps) || !shallowEqualObjects(this.state, nextState);
     }
 
     render() {

src/mol-plugin/behavior/behavior.ts

@@ -11,7 +11,7 @@ import { PluginContext } from '../../mol-plugin/context';
 import { PluginCommand } from '../command';
 import { Observable } from 'rxjs';
 import { ParamDefinition } from '../../mol-util/param-definition';
-import { shallowEqual } from '../../mol-util';
+import { shallowEqualObjects } from '../../mol-util';
 
 export { PluginBehavior }
 
@@ -128,7 +128,7 @@ namespace PluginBehavior {
             this.subs = [];
         }
         update(params: P): boolean | Promise<boolean> {
-            if (shallowEqual(params, this.params)) return false;
+            if (shallowEqualObjects(params, this.params)) return false;
             this.params = params;
             return true;
         }

src/mol-plugin/behavior/dynamic/custom-props/computed/accessible-surface-area.ts

@@ -76,14 +76,14 @@ function accessibleSurfaceAreaLabel(loci: Loci): string | undefined {
             })
         }
         if (seen.size === 0) return
-        const residueCount = `<small>(${seen.size} ${seen.size > 1 ? 'Residues Sum' : 'Residue'})</small>`
+        const residueCount = `<small>(${seen.size} ${seen.size > 1 ? 'Residues sum' : 'Residue'})</small>`
 
-        return `Accessible Surface Area ${residueCount}: ${cummulativeArea.toFixed(2)} \u212B<sup>3</sup>`;
+        return `Accessible Surface Area ${residueCount}: ${cummulativeArea.toFixed(2)} \u212B<sup>2</sup>`;
 
     } else if(loci.kind === 'structure-loci') {
         const accessibleSurfaceArea = AccessibleSurfaceAreaProvider.get(loci.structure).value
         if (!accessibleSurfaceArea) return;
 
-        return `Accessible Surface Area <small>(Whole Structure)</small>: ${arraySum(accessibleSurfaceArea.area).toFixed(2)} \u212B<sup>3</sup>`;
+        return `Accessible Surface Area <small>(Whole Structure)</small>: ${arraySum(accessibleSurfaceArea.area).toFixed(2)} \u212B<sup>2</sup>`;
     }
 }

src/mol-plugin/behavior/dynamic/custom-props/rcsb/assembly-symmetry.ts

@@ -12,7 +12,7 @@ import { AssemblySymmetryClusterColorThemeProvider } from '../../../../../mol-mo
 import { PluginStateTransform, PluginStateObject } from '../../../../state/objects';
 import { Task } from '../../../../../mol-task';
 import { PluginContext } from '../../../../context';
-import { StateTransformer } from '../../../../../mol-state';
+import { StateTransformer, StateAction, StateObject } from '../../../../../mol-state';
 
 export const RCSBAssemblySymmetry = PluginBehavior.create<{ autoAttach: boolean }>({
     name: 'rcsb-assembly-symmetry-prop',
@@ -22,7 +22,7 @@ export const RCSBAssemblySymmetry = PluginBehavior.create<{ autoAttach: boolean
         private provider = AssemblySymmetryProvider
 
         register(): void {
-            this.ctx.state.dataState.actions.add(AssemblySymmetry3D)
+            this.ctx.state.dataState.actions.add(InitAssemblySymmetry3D)
             this.ctx.customStructureProperties.register(this.provider, this.params.autoAttach);
             this.ctx.structureRepresentation.themeCtx.colorThemeRegistry.add('rcsb-assembly-symmetry-cluster', AssemblySymmetryClusterColorThemeProvider)
         }
@@ -35,7 +35,7 @@ export const RCSBAssemblySymmetry = PluginBehavior.create<{ autoAttach: boolean
         }
 
         unregister() {
-            this.ctx.state.dataState.actions.remove(AssemblySymmetry3D)
+            this.ctx.state.dataState.actions.remove(InitAssemblySymmetry3D)
             this.ctx.customStructureProperties.unregister(this.provider.descriptor.name);
             this.ctx.structureRepresentation.themeCtx.colorThemeRegistry.remove('rcsb-assembly-symmetry-cluster')
         }
@@ -46,13 +46,28 @@ export const RCSBAssemblySymmetry = PluginBehavior.create<{ autoAttach: boolean
     })
 });
 
+const InitAssemblySymmetry3D = StateAction.build({
+    display: { name: 'RCSB Assembly Symmetry' },
+    from: PluginStateObject.Molecule.Structure,
+    isApplicable: (a) => AssemblySymmetry.isApplicable(a.data)
+})(({ a, ref, state }, plugin: PluginContext) => Task.create('Init RCSB Assembly Symmetry', async ctx => {
+    try {
+        await AssemblySymmetryProvider.attach({ runtime: ctx, fetch: plugin.fetch }, a.data)
+    } catch(e) {
+        plugin.log.error(`RCSB Assembly Symmetry: ${e}`)
+        return
+    }
+    const tree = state.build().to(ref).apply(AssemblySymmetry3D);
+    await state.updateTree(tree).runInContext(ctx);
+}));
+
 type AssemblySymmetry3D = typeof AssemblySymmetry3D
 const AssemblySymmetry3D = PluginStateTransform.BuiltIn({
     name: 'rcsb-assembly-symmetry-3d',
     display: 'RCSB Assembly Symmetry',
     from: PluginStateObject.Molecule.Structure,
     to: PluginStateObject.Shape.Representation3D,
-    params: (a, ctx: PluginContext) => {
+    params: (a) => {
         return {
             ...AssemblySymmetryParams,
             symmetryIndex: getSymmetrySelectParam(a?.data),
@@ -66,6 +81,9 @@ const AssemblySymmetry3D = PluginStateTransform.BuiltIn({
         return Task.create('RCSB Assembly Symmetry', async ctx => {
             await AssemblySymmetryProvider.attach({ runtime: ctx, fetch: plugin.fetch }, a.data)
             const assemblySymmetry = AssemblySymmetryProvider.get(a.data).value
+            if (!assemblySymmetry || assemblySymmetry.length === 0) {
+                return StateObject.Null;
+            }
             const repr = AssemblySymmetryRepresentation({ webgl: plugin.canvas3d?.webgl, ...plugin.structureRepresentation.themeCtx }, () => AssemblySymmetryParams)
             await repr.createOrUpdate(params, a.data).runInContext(ctx);
             const { type, kind, symbol } = assemblySymmetry![params.symmetryIndex]
@@ -76,6 +94,9 @@ const AssemblySymmetry3D = PluginStateTransform.BuiltIn({
         return Task.create('RCSB Assembly Symmetry', async ctx => {
             await AssemblySymmetryProvider.attach({ runtime: ctx, fetch: plugin.fetch }, a.data)
             const assemblySymmetry = AssemblySymmetryProvider.get(a.data).value
+            if (!assemblySymmetry || assemblySymmetry.length === 0) {
+                return StateTransformer.UpdateResult.Recreate
+            }
             const props = { ...b.data.repr.props, ...newParams }
             await b.data.repr.createOrUpdate(props, a.data).runInContext(ctx);
             const { type, kind, symbol } = assemblySymmetry![newParams.symmetryIndex]

src/mol-plugin/behavior/dynamic/custom-props/rcsb/validation-report.ts

@@ -191,12 +191,12 @@ function densityFitLabel(loci: Loci): string | undefined {
         const summary: string[] = []
 
         if (rsrzSeen.size) {
-            const rsrzCount = `<small>(${rsrzSeen.size} ${rsrzSeen.size > 1 ? 'Residues Avg.' : 'Residue'})</small>`
+            const rsrzCount = `<small>(${rsrzSeen.size} ${rsrzSeen.size > 1 ? 'Residues avg.' : 'Residue'})</small>`
             const rsrzAvg = rsrzSum / rsrzSeen.size
             summary.push(`Real Space R ${rsrzCount}: ${rsrzAvg.toFixed(2)}`)
         }
         if (rsccSeen.size) {
-            const rsccCount = `<small>(${rsccSeen.size} ${rsccSeen.size > 1 ? 'Residues Avg.' : 'Residue'})</small>`
+            const rsccCount = `<small>(${rsccSeen.size} ${rsccSeen.size > 1 ? 'Residues avg.' : 'Residue'})</small>`
             const rsccAvg = rsccSum / rsccSeen.size
             summary.push(`Real Space Correlation Coefficient ${rsccCount}: ${rsccAvg.toFixed(2)}`)
         }
@@ -239,7 +239,7 @@ function randomCoilIndexLabel(loci: Loci): string | undefined {
 
         if (seen.size === 0) return
 
-        const residueCount = `<small>(${seen.size} ${seen.size > 1 ? 'Residues Avg.' : 'Residue'})</small>`
+        const residueCount = `<small>(${seen.size} ${seen.size > 1 ? 'Residues avg.' : 'Residue'})</small>`
         const rciAvg = sum / seen.size
 
         return `Random Coil Index ${residueCount}: ${rciAvg.toFixed(2)}`

src/mol-plugin/config.ts

@@ -14,13 +14,13 @@ function item<T>(key: string, defaultValue?: T) { return new PluginConfigItem(ke
 
 export const PluginConfig = {
     item,
-    State: { 
+    State: {
         DefaultServer: item('plugin-state.server', 'https://webchem.ncbr.muni.cz/molstar-state'),
         CurrentServer: item('plugin-state.server', 'https://webchem.ncbr.muni.cz/molstar-state')
     }
 }
 
-export class PluginConfigManager {    
+export class PluginConfigManager {
     private _config = new Map<PluginConfigItem<any>, unknown>();
 
     get<T>(key: PluginConfigItem<T>) {

src/mol-plugin/context.ts

@@ -90,7 +90,7 @@ export class PluginContext {
             selectionUpdated: this.ev()
         }
     } as const
-    
+
     readonly config = new PluginConfigManager(this.spec.config);
 
     readonly behaviors = {

src/mol-plugin/state/actions/volume.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -28,7 +28,7 @@ export const Ccp4Provider: DataFormatProvider<any> = {
     },
     getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, options: DataFormatBuilderOptions, state: State) => {
         return Task.create('CCP4/MRC/BRIX default builder', async taskCtx => {
-            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParseCcp4)
+            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParseCcp4, {}, { state: { isGhost: true } })
                 .apply(StateTransforms.Volume.VolumeFromCcp4)
             if (options.visuals) {
                 tree = tree.apply(StateTransforms.Representation.VolumeRepresentation3D)
@@ -48,7 +48,7 @@ export const Dsn6Provider: DataFormatProvider<any> = {
     },
     getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, options: DataFormatBuilderOptions, state: State) => {
         return Task.create('DSN6/BRIX default builder', async taskCtx => {
-            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParseDsn6)
+            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParseDsn6, {}, { state: { isGhost: true } })
                 .apply(StateTransforms.Volume.VolumeFromDsn6)
             if (options.visuals) {
                 tree = tree.apply(StateTransforms.Representation.VolumeRepresentation3D)

src/mol-plugin/state/transforms/misc.ts

@@ -5,7 +5,7 @@
  */
 
 import { StateTransformer } from '../../../mol-state';
-import { shallowEqual } from '../../../mol-util';
+import { shallowEqualObjects } from '../../../mol-util';
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { PluginStateObject as SO, PluginStateTransform } from '../objects';
 
@@ -25,7 +25,7 @@ const CreateGroup = PluginStateTransform.BuiltIn({
         return new SO.Group({}, params);
     },
     update({ oldParams, newParams, b }) {
-        if (shallowEqual(oldParams, newParams)) return StateTransformer.UpdateResult.Unchanged;
+        if (shallowEqualObjects(oldParams, newParams)) return StateTransformer.UpdateResult.Unchanged;
         b.label = newParams.label;
         b.description = newParams.description;
         return StateTransformer.UpdateResult.Updated;

src/mol-plugin/state/transforms/volume.ts

@@ -25,7 +25,8 @@ const VolumeFromCcp4 = PluginStateTransform.BuiltIn({
     to: SO.Volume.Data,
     params(a) {
         return {
-            voxelSize: PD.Vec3(Vec3.create(1, 1, 1))
+            voxelSize: PD.Vec3(Vec3.create(1, 1, 1)),
+            offset: PD.Vec3(Vec3.create(0, 0, 0))
         };
     }
 })({

src/mol-plugin/util/loci-label-manager.ts

@@ -8,6 +8,7 @@
 import { PluginContext } from '../../mol-plugin/context';
 import { Loci } from '../../mol-model/loci';
 import { Representation } from '../../mol-repr/representation';
+import { MarkerAction } from '../../mol-util/marker-action';
 
 export type LociLabelEntry = JSX.Element | string
 export type LociLabelProvider = (info: Loci, repr?: Representation<any>) => LociLabelEntry | undefined
@@ -24,9 +25,9 @@ export class LociLabelManager {
         // Event.Interactivity.Highlight.dispatch(this.ctx, []);
     }
 
-    private empty: any[] = [];
-    private getInfo({ loci, repr }: Representation.Loci) {
-        if (!loci || loci.kind === 'empty-loci') return this.empty;
+    private empty: LociLabelEntry[] = [];
+    private getInfo({ loci, repr }: Representation.Loci, action: MarkerAction) {
+        if (Loci.isEmpty(loci) || action !== MarkerAction.Highlight) return this.empty;
         const info: LociLabelEntry[] = [];
         for (let p of this.providers) {
             const e = p(loci, repr);
@@ -36,6 +37,6 @@ export class LociLabelManager {
     }
 
     constructor(public ctx: PluginContext) {
-        ctx.interactivity.lociHighlights.addProvider((loci) => ctx.behaviors.labels.highlight.next({ entries: this.getInfo(loci) }))
+        ctx.interactivity.lociHighlights.addProvider((loci, action) => ctx.behaviors.labels.highlight.next({ entries: this.getInfo(loci, action) }))
     }
 }

src/mol-repr/structure/visual/carbohydrate-link-cylinder.ts

@@ -4,7 +4,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import { Structure, Bond, StructureElement } from '../../../mol-model/structure';
+import { Structure, StructureElement, Unit } from '../../../mol-model/structure';
 import { Loci, EmptyLoci } from '../../../mol-model/loci';
 import { Vec3 } from '../../../mol-math/linear-algebra';
 import { createLinkCylinderMesh, LinkCylinderParams } from './util/link';
@@ -18,6 +18,7 @@ import { PickingId } from '../../../mol-geo/geometry/picking';
 import { VisualUpdateState } from '../../util';
 import { VisualContext } from '../../../mol-repr/visual';
 import { Theme } from '../../../mol-theme/theme';
+import { getAltResidueLociFromId } from './util/common';
 
 function createCarbohydrateLinkCylinderMesh(ctx: VisualContext, structure: Structure, theme: Theme, props: PD.Values<CarbohydrateLinkParams>, mesh?: Mesh) {
     const { links, elements } = structure.carbohydrates
@@ -34,8 +35,10 @@ function createCarbohydrateLinkCylinderMesh(ctx: VisualContext, structure: Struc
         },
         radius: (edgeIndex: number) => {
             const l = links[edgeIndex]
-            location.unit = elements[l.carbohydrateIndexA].unit
-            location.element = elements[l.carbohydrateIndexA].anomericCarbon
+            const carbA = elements[l.carbohydrateIndexA]
+            const ringA = carbA.unit.rings.all[carbA.ringIndex]
+            location.unit = carbA.unit
+            location.element = carbA.unit.elements[ringA[0]]
             return theme.size.size(location) * linkSizeFactor
         },
     }
@@ -71,17 +74,13 @@ function CarbohydrateLinkIterator(structure: Structure): LocationIterator {
     const { elements, links } = structure.carbohydrates
     const groupCount = links.length
     const instanceCount = 1
-    const location = Bond.Location()
+    const location = StructureElement.Location.create()
     const getLocation = (groupIndex: number) => {
         const link = links[groupIndex]
         const carbA = elements[link.carbohydrateIndexA]
-        const carbB = elements[link.carbohydrateIndexB]
-        const indexA = OrderedSet.indexOf(carbA.unit.elements, carbA.anomericCarbon)
-        const indexB = OrderedSet.indexOf(carbB.unit.elements, carbB.anomericCarbon)
-        location.aUnit = carbA.unit
-        location.aIndex = indexA as StructureElement.UnitIndex
-        location.bUnit = carbB.unit
-        location.bIndex = indexB as StructureElement.UnitIndex
+        const ringA = carbA.unit.rings.all[carbA.ringIndex]
+        location.unit = carbA.unit
+        location.element = carbA.unit.elements[ringA[0]]
         return location
     }
     return LocationIterator(groupCount, instanceCount, getLocation, true)
@@ -94,51 +93,30 @@ function getLinkLoci(pickingId: PickingId, structure: Structure, id: number) {
         const l = links[groupId]
         const carbA = elements[l.carbohydrateIndexA]
         const carbB = elements[l.carbohydrateIndexB]
-        const indexA = OrderedSet.indexOf(carbA.unit.elements, carbA.anomericCarbon)
-        const indexB = OrderedSet.indexOf(carbB.unit.elements, carbB.anomericCarbon)
-        if (indexA !== -1 && indexB !== -1) {
-            return Bond.Loci(structure, [
-                Bond.Location(
-                    carbA.unit, indexA as StructureElement.UnitIndex,
-                    carbB.unit, indexB as StructureElement.UnitIndex
-                ),
-                Bond.Location(
-                    carbB.unit, indexB as StructureElement.UnitIndex,
-                    carbA.unit, indexA as StructureElement.UnitIndex
-                )
-            ])
-        }
+        return StructureElement.Loci.union(
+            getAltResidueLociFromId(structure, carbA.unit, carbA.residueIndex, carbA.altId),
+            getAltResidueLociFromId(structure, carbB.unit, carbB.residueIndex, carbB.altId)
+        )
     }
     return EmptyLoci
 }
 
 function eachCarbohydrateLink(loci: Loci, structure: Structure, apply: (interval: Interval) => boolean) {
     let changed = false
-    if (Bond.isLoci(loci)) {
-        if (!Structure.areEquivalent(loci.structure, structure)) return false
-        const { getLinkIndex } = structure.carbohydrates
-        for (const l of loci.bonds) {
-            const idx = getLinkIndex(l.aUnit, l.aUnit.elements[l.aIndex], l.bUnit, l.bUnit.elements[l.bIndex])
-            if (idx !== undefined) {
-                if (apply(Interval.ofSingleton(idx))) changed = true
+    if (!StructureElement.Loci.is(loci)) return false
+    if (!Structure.areEquivalent(loci.structure, structure)) return false
+
+    const { getLinkIndices } = structure.carbohydrates
+    for (const { unit, indices } of loci.elements) {
+        if (!Unit.isAtomic(unit)) continue
+
+        OrderedSet.forEach(indices, v => {
+            // TODO avoid duplicate calls to apply
+            const linkIndices = getLinkIndices(unit, unit.elements[v])
+            for (let i = 0, il = linkIndices.length; i < il; ++i) {
+                if (apply(Interval.ofSingleton(linkIndices[i]))) changed = true
             }
-        }
-    } else if (StructureElement.Loci.is(loci)) {
-        if (!Structure.areEquivalent(loci.structure, structure)) return false
-        // TODO mark link only when both of the link elements are in a StructureElement.Loci
-        const { getElementIndex, getLinkIndices, elements } = structure.carbohydrates
-        for (const e of loci.elements) {
-            OrderedSet.forEach(e.indices, v => {
-                const carbI = getElementIndex(e.unit, e.unit.elements[v])
-                if (carbI !== undefined) {
-                    const carb = elements[carbI]
-                    const indices = getLinkIndices(carb.unit, carb.anomericCarbon)
-                    for (let i = 0, il = indices.length; i < il; ++i) {
-                        if (apply(Interval.ofSingleton(indices[i]))) changed = true
-                    }
-                }
-            })
-        }
+        })
     }
     return changed
 }

src/mol-repr/structure/visual/carbohydrate-symbol-mesh.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -10,7 +10,7 @@ import { OctagonalPyramid, PerforatedOctagonalPyramid } from '../../../mol-geo/p
 import { Star } from '../../../mol-geo/primitive/star';
 import { Octahedron, PerforatedOctahedron } from '../../../mol-geo/primitive/octahedron';
 import { DiamondPrism, PentagonalPrism, ShiftedHexagonalPrism, HexagonalPrism, HeptagonalPrism } from '../../../mol-geo/primitive/prism';
-import { Structure, StructureElement } from '../../../mol-model/structure';
+import { Structure, StructureElement, Unit } from '../../../mol-model/structure';
 import { Mesh } from '../../../mol-geo/geometry/mesh/mesh';
 import { MeshBuilder } from '../../../mol-geo/geometry/mesh/mesh-builder';
 import { getSaccharideShape, SaccharideShape } from '../../../mol-model/structure/structure/carbohydrates/constants';
@@ -25,7 +25,7 @@ import { OrderedSet, Interval } from '../../../mol-data/int';
 import { EmptyLoci, Loci } from '../../../mol-model/loci';
 import { VisualContext } from '../../../mol-repr/visual';
 import { Theme } from '../../../mol-theme/theme';
-import { getAltResidueLoci } from './util/common';
+import { getAltResidueLociFromId } from './util/common';
 
 const t = Mat4.identity()
 const sVec = Vec3.zero()
@@ -57,10 +57,11 @@ function createCarbohydrateSymbolMesh(ctx: VisualContext, structure: Structure,
 
     for (let i = 0; i < n; ++i) {
         const c = carbohydrates.elements[i];
-        const shapeType = getSaccharideShape(c.component.type, c.ringMemberCount)
+        const ring = c.unit.rings.all[c.ringIndex]
+        const shapeType = getSaccharideShape(c.component.type, ring.length)
 
         l.unit = c.unit
-        l.element = c.unit.elements[c.anomericCarbon]
+        l.element = c.unit.elements[ring[0]]
         const size = theme.size.size(l)
         const radius = size * sizeFactor
         const side = size * sizeFactor * SideFactor
@@ -189,8 +190,9 @@ function CarbohydrateElementIterator(structure: Structure): LocationIterator {
     const location = StructureElement.Location.create()
     function getLocation (groupIndex: number, instanceIndex: number) {
         const carb = carbElements[Math.floor(groupIndex / 2)]
+        const ring = carb.unit.rings.all[carb.ringIndex]
         location.unit = carb.unit
-        location.element = carb.anomericCarbon
+        location.element = carb.unit.elements[ring[0]]
         return location
     }
     function isSecondary (elementIndex: number, instanceIndex: number) {
@@ -204,32 +206,26 @@ function getCarbohydrateLoci(pickingId: PickingId, structure: Structure, id: num
     const { objectId, groupId } = pickingId
     if (id === objectId) {
         const carb = structure.carbohydrates.elements[Math.floor(groupId / 2)]
-        return getAltResidueLoci(structure, carb.unit, carb.anomericCarbon)
+        return getAltResidueLociFromId(structure, carb.unit, carb.residueIndex, carb.altId)
     }
     return EmptyLoci
 }
 
 /** For each carbohydrate (usually a monosaccharide) when all its residue's elements are in a loci. */
 function eachCarbohydrate(loci: Loci, structure: Structure, apply: (interval: Interval) => boolean) {
-    const { getElementIndex, getAnomericCarbons } = structure.carbohydrates
+    const { getElementIndices } = structure.carbohydrates
     let changed = false
     if (!StructureElement.Loci.is(loci)) return false
     if (!Structure.areEquivalent(loci.structure, structure)) return false
-    for (const e of loci.elements) {
-        // TODO make more efficient by handling/grouping `e.indices` by residue index
-        // TODO only call apply when the full alt-residue of the unit is part of `e`
-        OrderedSet.forEach(e.indices, v => {
-            const { model, elements } = e.unit
-            const { index } = model.atomicHierarchy.residueAtomSegments
-            const rI = index[elements[v]]
-            const eIndices = getAnomericCarbons(e.unit, rI)
-            for (let i = 0, il = eIndices.length; i < il; ++i) {
-                const eI = eIndices[i]
-                if (!OrderedSet.has(e.indices, OrderedSet.indexOf(elements, eI))) continue
-                const idx = getElementIndex(e.unit, eI)
-                if (idx !== undefined) {
-                    if (apply(Interval.ofBounds(idx * 2, idx * 2 + 2))) changed = true
-                }
+
+    for (const { unit, indices } of loci.elements) {
+        if (!Unit.isAtomic(unit)) continue
+
+        OrderedSet.forEach(indices, v => {
+            // TODO avoid duplicate calls to apply
+            const elementIndices = getElementIndices(unit, unit.elements[v])
+            for (let i = 0, il = elementIndices.length; i < il; ++i) {
+                if (apply(Interval.ofSingleton(elementIndices[i] * 2))) changed = true
             }
         })
     }

src/mol-repr/structure/visual/carbohydrate-terminal-link-cylinder.ts

@@ -6,7 +6,7 @@
 
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { VisualContext } from '../../visual';
-import { Structure, StructureElement, Bond } from '../../../mol-model/structure';
+import { Structure, StructureElement, Unit } from '../../../mol-model/structure';
 import { Theme } from '../../../mol-theme/theme';
 import { Mesh } from '../../../mol-geo/geometry/mesh/mesh';
 import { Vec3 } from '../../../mol-math/linear-algebra';
@@ -19,6 +19,7 @@ import { OrderedSet, Interval } from '../../../mol-data/int';
 import { PickingId } from '../../../mol-geo/geometry/picking';
 import { EmptyLoci, Loci } from '../../../mol-model/loci';
 import { getElementIdx, MetalsSet } from '../../../mol-model/structure/structure/unit/bonds/common';
+import { getAltResidueLociFromId, getAltResidueLoci } from './util/common';
 
 function createCarbohydrateTerminalLinkCylinderMesh(ctx: VisualContext, structure: Structure, theme: Theme, props: PD.Values<CarbohydrateTerminalLinkParams>, mesh?: Mesh) {
     const { terminalLinks, elements } = structure.carbohydrates
@@ -41,8 +42,10 @@ function createCarbohydrateTerminalLinkCylinderMesh(ctx: VisualContext, structur
         radius: (edgeIndex: number) => {
             const l = terminalLinks[edgeIndex]
             if (l.fromCarbohydrate) {
-                location.unit = elements[l.carbohydrateIndex].unit
-                location.element = elements[l.carbohydrateIndex].anomericCarbon
+                const carb = elements[l.carbohydrateIndex]
+                const ring = carb.unit.rings.all[carb.ringIndex]
+                location.unit = carb.unit
+                location.element = carb.unit.elements[ring[0]]
             } else {
                 location.unit = l.elementUnit
                 location.element = l.elementUnit.elements[l.elementIndex]
@@ -88,21 +91,17 @@ function CarbohydrateTerminalLinkIterator(structure: Structure): LocationIterato
     const { elements, terminalLinks } = structure.carbohydrates
     const groupCount = terminalLinks.length
     const instanceCount = 1
-    const location = Bond.Location()
+    const location = StructureElement.Location.create()
     const getLocation = (groupIndex: number) => {
         const terminalLink = terminalLinks[groupIndex]
-        const carb = elements[terminalLink.carbohydrateIndex]
-        const indexCarb = OrderedSet.indexOf(carb.unit.elements, carb.anomericCarbon)
         if (terminalLink.fromCarbohydrate) {
-            location.aUnit = carb.unit
-            location.aIndex = indexCarb as StructureElement.UnitIndex
-            location.bUnit = terminalLink.elementUnit
-            location.bIndex = terminalLink.elementIndex
+            const carb = elements[terminalLink.carbohydrateIndex]
+            const ring = carb.unit.rings.all[carb.ringIndex]
+            location.unit = carb.unit
+            location.element = carb.unit.elements[ring[0]]
         } else {
-            location.aUnit = terminalLink.elementUnit
-            location.aIndex = terminalLink.elementIndex
-            location.bUnit = carb.unit
-            location.bIndex = indexCarb as StructureElement.UnitIndex
+            location.unit = terminalLink.elementUnit
+            location.element = terminalLink.elementUnit.elements[terminalLink.elementIndex]
         }
         return location
     }
@@ -115,54 +114,31 @@ function getTerminalLinkLoci(pickingId: PickingId, structure: Structure, id: num
         const { terminalLinks, elements } = structure.carbohydrates
         const l = terminalLinks[groupId]
         const carb = elements[l.carbohydrateIndex]
-        const carbIndex = OrderedSet.indexOf(carb.unit.elements, carb.anomericCarbon)
 
-        return Bond.Loci(structure, [
-            Bond.Location(
-                carb.unit, carbIndex as StructureElement.UnitIndex,
-                l.elementUnit, l.elementIndex
-            ),
-            Bond.Location(
-                l.elementUnit, l.elementIndex,
-                carb.unit, carbIndex as StructureElement.UnitIndex
-            )
-        ])
+        return StructureElement.Loci.union(
+            getAltResidueLociFromId(structure, carb.unit, carb.residueIndex, carb.altId),
+            getAltResidueLoci(structure, l.elementUnit, l.elementUnit.elements[l.elementIndex])
+        )
     }
     return EmptyLoci
 }
 
 function eachTerminalLink(loci: Loci, structure: Structure, apply: (interval: Interval) => boolean) {
-    const { getTerminalLinkIndex } = structure.carbohydrates
     let changed = false
-    if (Bond.isLoci(loci)) {
-        if (!Structure.areEquivalent(loci.structure, structure)) return false
-        for (const l of loci.bonds) {
-            const idx = getTerminalLinkIndex(l.aUnit, l.aUnit.elements[l.aIndex], l.bUnit, l.bUnit.elements[l.bIndex])
-            if (idx !== undefined) {
-                if (apply(Interval.ofSingleton(idx))) changed = true
+    if (!StructureElement.Loci.is(loci)) return false
+    if (!Structure.areEquivalent(loci.structure, structure)) return false
+
+    const { getTerminalLinkIndices } = structure.carbohydrates
+    for (const { unit, indices } of loci.elements) {
+        if (!Unit.isAtomic(unit)) continue
+
+        OrderedSet.forEach(indices, v => {
+            // TODO avoid duplicate calls to apply
+            const linkIndices = getTerminalLinkIndices(unit, unit.elements[v])
+            for (let i = 0, il = linkIndices.length; i < il; ++i) {
+                if (apply(Interval.ofSingleton(linkIndices[i]))) changed = true
             }
-        }
-    } else if (StructureElement.Loci.is(loci)) {
-        if (!Structure.areEquivalent(loci.structure, structure)) return false
-        // TODO mark link only when both of the link elements are in a StructureElement.Loci
-        const { getElementIndex, getTerminalLinkIndices, elements } = structure.carbohydrates
-        for (const e of loci.elements) {
-            OrderedSet.forEach(e.indices, v => {
-                const carbI = getElementIndex(e.unit, e.unit.elements[v])
-                if (carbI !== undefined) {
-                    const carb = elements[carbI]
-                    const indices = getTerminalLinkIndices(carb.unit, carb.anomericCarbon)
-                    for (let i = 0, il = indices.length; i < il; ++i) {
-                        if (apply(Interval.ofSingleton(indices[i]))) changed = true
-                    }
-                } else {
-                    const indices = getTerminalLinkIndices(e.unit, e.unit.elements[v])
-                    for (let i = 0, il = indices.length; i < il; ++i) {
-                        if (apply(Interval.ofSingleton(indices[i]))) changed = true
-                    }
-                }
-            })
-        }
+        })
     }
     return changed
 }

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

@@ -4,7 +4,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import { Unit, Structure, ElementIndex, StructureElement } from '../../../../mol-model/structure';
+import { Unit, Structure, ElementIndex, StructureElement, ResidueIndex } from '../../../../mol-model/structure';
 import { Mat4 } from '../../../../mol-math/linear-algebra';
 import { TransformData, createTransform } from '../../../../mol-geo/geometry/transform-data';
 import { OrderedSet, SortedArray } from '../../../../mol-data/int';
@@ -34,27 +34,35 @@ export function getResidueLoci(structure: Structure, unit: Unit.Atomic, elementI
  * Return a Loci for the elements of a whole residue the elementIndex belongs to but
  * restrict to elements that have the same label_alt_id or none
  */
-export function getAltResidueLoci(structure: Structure, unit: Unit.Atomic, elementIndex: ElementIndex): Loci {
+export function getAltResidueLoci(structure: Structure, unit: Unit.Atomic, elementIndex: ElementIndex) {
     const { elements, model } = unit
     const { label_alt_id } = model.atomicHierarchy.atoms
     const elementAltId = label_alt_id.value(elementIndex)
     if (OrderedSet.indexOf(elements, elementIndex) !== -1) {
-        const { index, offsets } = model.atomicHierarchy.residueAtomSegments
+        const { index } = model.atomicHierarchy.residueAtomSegments
         const rI = index[elementIndex]
-        const _indices: number[] = []
-        for (let i = offsets[rI], il = offsets[rI + 1]; i < il; ++i) {
-            const unitIndex = OrderedSet.indexOf(elements, i)
-            if (unitIndex !== -1) {
-                const altId = label_alt_id.value(i)
-                if (elementAltId === altId || altId === '') {
-                    _indices.push(unitIndex)
-                }
+        return getAltResidueLociFromId(structure, unit, rI, elementAltId)
+    }
+    return StructureElement.Loci(structure, [])
+}
+
+export function getAltResidueLociFromId(structure: Structure, unit: Unit.Atomic, residueIndex: ResidueIndex, elementAltId: string) {
+    const { elements, model } = unit
+    const { label_alt_id } = model.atomicHierarchy.atoms
+    const { offsets } = model.atomicHierarchy.residueAtomSegments
+
+    const _indices: number[] = []
+    for (let i = offsets[residueIndex], il = offsets[residueIndex + 1]; i < il; ++i) {
+        const unitIndex = OrderedSet.indexOf(elements, i)
+        if (unitIndex !== -1) {
+            const altId = label_alt_id.value(i)
+            if (elementAltId === altId || altId === '') {
+                _indices.push(unitIndex)
             }
         }
-        const indices = OrderedSet.ofSortedArray<StructureElement.UnitIndex>(SortedArray.ofSortedArray(_indices))
-        return StructureElement.Loci(structure, [{ unit, indices }])
     }
-    return EmptyLoci
+    const indices = OrderedSet.ofSortedArray<StructureElement.UnitIndex>(SortedArray.ofSortedArray(_indices))
+    return StructureElement.Loci(structure, [{ unit, indices }])
 }
 
 //

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

@@ -170,10 +170,7 @@ export function eachAtomicUnitTracedElement(offset: number, groupSize: number, e
 
 function selectPolymerElements(u: Unit) { return u.polymerElements; }
 
-/**
- * Mark a polymer element (e.g. part of a cartoon trace)
- * - for atomic units mark only when all its residue's elements are in a loci
- */
+/** Mark a polymer element (e.g. part of a cartoon trace) */
 export function eachPolymerElement(loci: Loci, structureGroup: StructureGroup, apply: (interval: Interval) => boolean) {
     let changed = false
     if (!StructureElement.Loci.is(loci)) return false

src/mol-theme/color/carbohydrate-symbol.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -26,16 +26,12 @@ export function CarbohydrateSymbolColorTheme(ctx: ThemeDataContext, props: PD.Va
     let color: LocationColor
 
     if (ctx.structure) {
-        const { elements, getElementIndex, getAnomericCarbons } = ctx.structure.carbohydrates
+        const { elements, getElementIndices } = ctx.structure.carbohydrates
 
         const getColor = (unit: Unit, index: ElementIndex) => {
-            const residueIndex = unit.model.atomicHierarchy.residueAtomSegments.index[index]
-            const anomericCarbons = getAnomericCarbons(unit, residueIndex)
-            if (anomericCarbons.length > 0) {
-                const idx = getElementIndex(unit, anomericCarbons[0])
-                if (idx !== undefined) return elements[idx].component.color
-            }
-            return DefaultColor
+            if (!Unit.isAtomic(unit)) return DefaultColor
+            const carbs = getElementIndices(unit, index)
+            return carbs.length > 0 ? elements[carbs[0]].component.color : DefaultColor
         }
 
         color = (location: Location, isSecondary: boolean) => {

src/mol-theme/label.ts

@@ -198,9 +198,11 @@ function _elementLabel(location: StructureElement.Location, granularity: LabelGr
 }
 
 function _atomicElementLabel(location: StructureElement.Location<Unit.Atomic>, granularity: LabelGranularity): string[] {
+    const rI = StructureElement.Location.residueIndex(location);
+
     const label_asym_id = Props.chain.label_asym_id(location)
     const auth_asym_id = Props.chain.auth_asym_id(location)
-    const has_label_seq_id = location.unit.model.atomicHierarchy.residues.label_seq_id.valueKind(location.element) === Column.ValueKind.Present;
+    const has_label_seq_id = location.unit.model.atomicHierarchy.residues.label_seq_id.valueKind(rI) === Column.ValueKind.Present;
     const label_seq_id = Props.residue.label_seq_id(location)
     const auth_seq_id = Props.residue.auth_seq_id(location)
     const ins_code = Props.residue.pdbx_PDB_ins_code(location)

src/mol-util/index.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -79,19 +79,36 @@ export function deepEqual(a: any, b: any) {
     return false
 }
 
-export function shallowEqual<T>(a: T, b: T) {
-    if (!a) {
-        if (!b) return true;
-        return false;
+export function shallowEqual(a: any, b: any) {
+    if (a === b) return true;
+    const arrA = Array.isArray(a)
+    const arrB = Array.isArray(b)
+    if (arrA && arrB) return shallowEqualArrays(a, b)
+    if (arrA !== arrB) return false
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        return shallowEqualObjects(a, b)
     }
-    if (!b) return false;
+    return false
+}
 
-    let keys = Object.keys(a);
+export function shallowEqualObjects(a: {}, b: {}) {
+    if (a === b) return true;
+    if (!a || !b) return false;
+    const keys = Object.keys(a);
     if (Object.keys(b).length !== keys.length) return false;
-    for (let k of keys) {
+    for (const k of keys) {
         if (!hasOwnProperty.call(a, k) || (a as any)[k] !== (b as any)[k]) return false;
     }
+    return true;
+}
 
+export default function shallowEqualArrays(a: any[], b: any[]) {
+    if (a === b) return true;
+    if (!a || !b) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0, il = a.length; i < il; ++i) {
+        if (a[i] !== b[i]) return false;
+    }
     return true;
 }
 

src/mol-util/param-definition.ts

@@ -6,7 +6,7 @@
  */
 
 import { Color as ColorData } from './color';
-import { shallowEqual } from './index';
+import { shallowEqualObjects } from './index';
 import { Vec2 as Vec2Data, Vec3 as Vec3Data } from '../mol-math/linear-algebra';
 import { deepClone } from './object';
 import { Script as ScriptData } from '../mol-script/script';
@@ -356,7 +356,7 @@ export namespace ParamDefinition {
             }
             return true;
         } else if (typeof a === 'object' && typeof b === 'object') {
-            return shallowEqual(a, b);
+            return shallowEqualObjects(a, b);
         }
 
         // a === b was checked at the top.