Options
All
  • Public
  • Public/Protected
  • All
Menu

catana-backend

Index

Namespaces

Enumerations

Classes

Interfaces

Type aliases

Events

Variables

Functions

Object literals

Type aliases

AcceptedComponents

AcceptedComponents: StructureComponent | CgStructureComponent

AcceptedObjectTypes

AcceptedObjectTypes: CgNucleicAcidStrand

AminoAcidStructuresMap

AminoAcidStructuresMap: Map<AminoAcidType, Structure>

Map returning reference to all-atom structure for the provided amino acid type

ArrowBufferParameters

ArrowBufferParameters: typeof ArrowBufferDefaultParameters

AtomPair

AtomPair: (string | number)[][]

AtomicComponent

AtomicComponent: StructureComponent | CgStructureComponent

AxisType

AxisType: null | "x" | "y" | "z"

BarChartParameters

BarChartParameters: typeof BarChartDefaultParameters

BufferMaterials

BufferMaterials: "material" | "wireframeMaterial" | "pickingMaterial"

BufferParameters

BufferParameters: typeof BufferDefaultParameters

BufferSide

BufferSide: "front" | "back" | "double"

BufferTypes

BufferTypes: "picking" | "background"

CacheData

CacheData<PipelineType>: { module: GPUShaderModule; pipeline: PipelineType }

Type parameters

  • PipelineType: GPUPipelineBase

Type declaration

  • module: GPUShaderModule
  • pipeline: PipelineType

Camera

Camera: PerspectiveCamera | OrthographicCamera

CameraType

CameraType: "perspective" | "orthographic" | "stereo"

CatanaMouseActionType

CatanaMouseActionType: "downPick" | "upPick" | "dragPick"

CgStructureColormakerParams

CgStructureColormakerParams: { cgStructure: CgStructure } & Partial<ColormakerParameters>

CgStructureElementType

CgStructureElementType: RESIDUE | CHAIN

Lists structure elements available in coarse-grained data model

ChainidDict

ChainidDict: {}

Type declaration

  • [k: string]: number

ChainnameDict

ChainnameDict: {}

Type declaration

  • [k: string]: number

ColorDefinition

ColorDefinition: Color | string | number | undefined

ColorMode

ColorMode: "rgb" | "hsv" | "hsl" | "hsi" | "lab" | "hcl"

ColormakerScale

ColormakerScale: (v: number) => number

Type declaration

    • (v: number): number

    • Parameters

      • v: number

      Returns number

ComponentParameters

ComponentParameters: typeof ComponentDefaultParameters

ConeBufferParameters

ConeBufferParameters: typeof ConeBufferDefaultParameters

ContactDataParams

ContactDataParams: typeof ContactDataDefaultParams | { filterSele: string | [string, string] }

ContactLabelParams

ContactLabelParams: typeof ContactLabelDefaultParams

CylinderBufferParameters

CylinderBufferParameters: typeof CylinderBufferDefaultParameters

CylinderGeometryBufferParameters

CylinderGeometryBufferParameters: typeof CylinderGeometryBufferDefaultParameters

CylinderImpostorBufferParameters

CylinderImpostorBufferParameters: typeof CylinderImpostorBufferDefaultParameters

D3_HtmlElement

D3_HtmlElement: Selection<HTMLElement, unknown, null, undefined>

DnaNucleobaseType

DnaNucleobaseType: SpecificDnaNucleobaseType | ANY

DNA-compatible nucleobase types

DnaRnaCommonNucleobaseType

DnaRnaCommonNucleobaseType: (A | C | G) | ANY

Nucleobases shared amongst DNA & RNA

DragCallback

DragCallback: (stage: Stage, dx: number, dy: number) => void

Type declaration

    • (stage: Stage, dx: number, dy: number): void

    • Parameters

      • stage: Stage
      • dx: number
      • dy: number

      Returns void

ElementParameters

ElementParameters: typeof ElementDefaultParameters

EllipsoidBufferParameters

EllipsoidBufferParameters: typeof EllipsoidBufferDefaultParameters

EncodeFun

EncodeFun: (commandEncoder: GPUCommandEncoder, debug?: undefined | string) => void

Type declaration

    • (commandEncoder: GPUCommandEncoder, debug?: undefined | string): void

    • Parameters

      • commandEncoder: GPUCommandEncoder
      • Optional debug: undefined | string

      Returns void

EntityTypeString

EntityTypeString: keyof typeof EntityTypeString

FilterFn

FilterFn: (s: FilteringRule) => boolean

Type declaration

FilterSchemeData

FilterSchemeData: [any, string, ColormakerParameters | undefined]

FilterSignals

FilterSignals: { stringChanged: Signal }

Type declaration

  • stringChanged: Signal

FilteredSelectionObject

FilteredSelectionObject: { c: Component; f: string; r: StructureRepresentation | CgStructureRepresentation }

Type declaration

FilteringOperator

FilteringOperator: "AND" | "OR"

FilteringTest

FilteringTest: false | ((e: ProxyEntity) => boolean | -1)

FunctionWithDeps

FunctionWithDeps: { __deps?: Function[] } & Function

GizmoSignals

GizmoSignals: { materialChanged: Signal }

Type declaration

  • materialChanged: Signal

HistorySignals

HistorySignals: { commandDone: Signal }

Type declaration

  • commandDone: Signal

HyperballStickBufferParameters

HyperballStickBufferParameters: typeof HyperballStickBufferDefaultParameters

HyperballStickImpostorBufferParameters

HyperballStickImpostorBufferParameters: typeof HyperballStickImpostorBufferDefaultParameters

ImageBufferParameters

ImageBufferParameters: typeof ImageBufferDefaultParameters

ImageFilterTypes

ImageFilterTypes: "nearest" | "linear" | "cubic-bspline" | "cubic-catmulrom" | "cubic-mitchell"

ImageParameters

ImageParameters: typeof ImageDefaultParameters

InterBaseRigidbodyParams

InterBaseRigidbodyParams: { baseRise: number; baseRoll: number; baseShift: number; baseSlide: number; baseTilt: number; baseTwist: number }

Inter-base params are applied onto individual bases when assembling the nucleic acid single strand

Type declaration

  • baseRise: number

    Z-axis translation

  • baseRoll: number

    Y-axis rotation

  • baseShift: number

    X-axis translation

    remark

    Not currently used when generating DNA geometry.

  • baseSlide: number

    Y-axis translation

  • baseTilt: number

    X-axis rotation

    remark

    Not currently used when generating DNA geometry.

  • baseTwist: number

    Z-axis rotation

IntraBaseRigidbodyParams

IntraBaseRigidbodyParams: { buckle: number; opening: number; propeller: number; shear: number; stagger: number; stretch: number }

Intra-base params are applied on complementary bases only, after the locations of nucleotides in the source single strand are generated. In other words, these parameters are used to adjust orientation of complementary bases without influencing the geometry of the whole strand.

Type declaration

  • buckle: number

    X-axis rotation

    remark

    Not currently used when generating DNA geometry.

  • opening: number

    Z-axis rotation

    remark

    Not currently used when generating DNA geometry.

  • propeller: number

    Y-axis rotation

  • shear: number

    X-axis translation

    remark

    Not currently used when generating DNA geometry.

  • stagger: number

    Z-axis translation

    remark

    Not currently used when generating DNA geometry.

  • stretch: number

    Y-axis translation

    remark

    Not currently used when generating DNA geometry.

KeyActionCallback

KeyActionCallback: (stage: Stage) => void

Type declaration

    • Parameters

      Returns void

KeyActionPreset

KeyActionPreset: [string, KeyActionCallback][]

KeyControlPreset

KeyControlPreset: keyof typeof KeyActionPresets

LabelType

LabelType: keyof typeof LabelFactoryTypes

LineChartParameters

LineChartParameters: typeof LineChartDefaultParameters

LoaderInput

LoaderInput: File | Blob | string

MappingType

MappingType: "v2" | "v3"

MonomerSetDict

MonomerSetDict: Map<number, BitArray_Legacy>

MonomerType

MonomerType: NucleobaseType | AminoAcidType

Supported monomer/residue types

MouseActionCallback

MouseActionCallback: ScrollCallback | DragCallback | PickCallback

MouseActionPreset

MouseActionPreset: [string, MouseActionCallback][]

MouseActionType

MouseActionType: "" | "scroll" | "drag" | "click" | "doubleClick" | "hover" | "clickPick" | "hoverPick" | CatanaMouseActionType

MouseControlPreset

MouseControlPreset: keyof typeof MouseActionPresets

NucleotideStructuresMap

NucleotideStructuresMap: Map<NucleicAcidType, Map<NucleobaseType, ReferenceStructureData>>

NumberArray

NumberArray: number[] | TypedArray

Output

Output: { byteSize: number; dst: WgBuffer<any>; dstOffset: number; src: WgBuffer<any>; srcOffset: number }

Type declaration

  • byteSize: number
  • dst: WgBuffer<any>
  • dstOffset: number
  • src: WgBuffer<any>
  • srcOffset: number

Partial

Partial<T>: {}

Type parameters

  • T

Type declaration

PickCallback

PickCallback: (stage: Stage, pickingProxy: PickingProxy) => void

Type declaration

PickingSelectionObject

PickingSelectionObject: { objectId: number; pickingId: number }

Type declaration

  • objectId: number
  • pickingId: number

PluginUIElemType

PluginUIElemType: keyof typeof PluginUIElemDefinitions

Defines supported types of plugin UI elements

PointBufferParameters

PointBufferParameters: typeof PointBufferDefaultParameters

PolymerBufferType

PolymerBufferType: SphereImpostorBuffer | BoxBuffer | CylinderImpostorBuffer

Positions

Positions: { count?: undefined | number; x: ArrayLike<number>; y: ArrayLike<number>; z: ArrayLike<number> }

Type declaration

  • Optional count?: undefined | number
  • x: ArrayLike<number>
  • y: ArrayLike<number>
  • z: ArrayLike<number>

PrimitiveFields

PrimitiveFields: {}

Type declaration

  • [k: string]: string

ProcessData

ProcessData: { c: AtomicComponent; matrix: Matrix4 }

Type declaration

ProxyEntity

ProxyEntity: AtomProxy | ResidueProxy | ChainProxy | ModelProxy | CgMonomerProxy

RadiusType

RadiusType: keyof typeof RadiusFactoryTypes

ReferenceStructureData

ReferenceStructureData: { originToBackboneCenter: Vector3; originToBaseCenter: Vector3; originToC1: Vector3; originToCenterOfMass: Vector3; structure: Structure; structureFivePrime: Structure }

Type used for storing the reference to all-atom nucleotide structure together with some additional computed values

Type declaration

  • originToBackboneCenter: Vector3

    Vector from the origin of the base-pair to the center of mass of the backbone

  • originToBaseCenter: Vector3

    Vector from the origin of the base-pair to the center of mass of the nucleobase

  • originToC1: Vector3

    Vector from the origin of the base-pair to the C1' atom

  • originToCenterOfMass: Vector3

    Vector from the origin of the base-pair to the center of mass of the nucleotide

  • structure: Structure

    Reference to all-atom structure of this nucleotide

  • structureFivePrime: Structure

    Reference to all-atom structure of this nucleotide that should be used at the 5' end of the strand (as it contains no phosphate group)

RenderQualityType

RenderQualityType: "auto" | "low" | "medium" | "high"

RepresentationElementParameters

RepresentationElementParameters: typeof RepresentationElementDefaultParameters

RnaNucleobaseType

RnaNucleobaseType: SpecificRnaNucleobaseType | ANY

RNA-compatible nuclebase types

RotationCallback

RotationCallback: (deltaRotation: Quaternion) => void

Type declaration

    • (deltaRotation: Quaternion): void

    • Parameters

      • deltaRotation: Quaternion

      Returns void

ScaleParameters

ScaleParameters: typeof ScaleDefaultParameters

ScrollCallback

ScrollCallback: (stage: Stage, delta: number) => void

Type declaration

    • (stage: Stage, delta: number): void

    • Parameters

      • stage: Stage
      • delta: number

      Returns void

SelectionSignals

SelectionSignals: { selectionChanged: Signal }

Type declaration

  • selectionChanged: Signal

ShaderDefine

ShaderDefine: ShaderDefine

ShaderDefines

ShaderDefines: {}

Type declaration

ShapeParameters

ShapeParameters: typeof ShapeDefaultParameters

ShapeRepresentationType

ShapeRepresentationType: "buffer"

SpecificDnaNucleobaseType

SpecificDnaNucleobaseType: A | T | C | G

Valid/well-defined DNA nucleobase types

SpecificDnaRnaCommonNucleobaseType

SpecificDnaRnaCommonNucleobaseType: SpecificDnaNucleobaseType & SpecificRnaNucleobaseType

Valid/well-defined (D)(R)NA nucleobase types

SpecificRnaNucleobaseType

SpecificRnaNucleobaseType: A | U | C | G

Valid/well-defined RNA nucleobase types

SphereBufferParameters

SphereBufferParameters: typeof SphereBufferDefaultParameters

SphereGeometryBufferParameters

SphereGeometryBufferParameters: typeof SphereGeometryBufferDefaultParameters

StageParameters

StageParameters: typeof StageDefaultParameters

StoreField

StoreField: [string, number, TypedArrayString]

StructureColormakerParams

StructureColormakerParams: { structure: Structure } & Partial<ColormakerParameters>

StructureComponentParameters

StructureComponentParameters: typeof StructureComponentDefaultParameters

StructureExtraData

StructureExtraData: { cif?: undefined | object; sdf?: object[] }

Type declaration

  • Optional cif?: undefined | object
  • Optional sdf?: object[]

StructureHeader

StructureHeader: { depositionDate?: undefined | string; experimentalMethods?: string[]; rFree?: undefined | number; rWork?: undefined | number; releaseDate?: undefined | string; resolution?: undefined | number }

Type declaration

  • Optional depositionDate?: undefined | string
  • Optional experimentalMethods?: string[]
  • Optional rFree?: undefined | number
  • Optional rWork?: undefined | number
  • Optional releaseDate?: undefined | string
  • Optional resolution?: undefined | number

StructureRepresentationType

StructureRepresentationType: keyof StructureRepresentationParametersMap

StructureSignals

StructureSignals: { refreshed: Signal }

Type declaration

  • refreshed: Signal

SubstitutionMatrix

SubstitutionMatrix: "" | "blosum62" | "blosum62x" | "ednaFull"

SurfaceDataFields

SurfaceDataFields: { color: boolean; index: boolean; normal: boolean; position: boolean; radius: boolean }

Type declaration

  • color: boolean
  • index: boolean
  • normal: boolean
  • position: boolean
  • radius: boolean

SurfaceRepresentationType

SurfaceRepresentationType: "surface" | "dot"

TObj

TObj: Structure | Surface | Volume | Shape | CgStructure | Lattice

TestEntityFn

TestEntityFn: (e: ProxyEntity, s: FilteringRule) => boolean | -1

Type declaration

TextAtlasMap

TextAtlasMap: { h: number; w: number; x: number; y: number }

Type declaration

  • h: number
  • w: number
  • x: number
  • y: number

TextAtlasParams

TextAtlasParams: typeof TextAtlasDefaultParams

TextAttachments

TextAttachments: "bottom-left" | "bottom-center" | "bottom-right" | "middle-left" | "middle-center" | "middle-right" | "top-left" | "top-center" | "top-right"

TextBufferParameters

TextBufferParameters: typeof TextBufferDefaultParameters

TextFonts

TextFonts: "sans-serif" | "monospace" | "serif"

TextStyles

TextStyles: "normal" | "italic"

TextVariants

TextVariants: "normal"

TextWeights

TextWeights: "normal" | "bold"

TorusBufferParameters

TorusBufferParameters: typeof TorusBufferDefaultParameters

TrajectoryElementParameters

TrajectoryElementParameters: typeof TrajectoryElementDefaultParameters

TrajectoryPlayerDirection

TrajectoryPlayerDirection: "forward" | "backward" | "bounce"

TrajectoryPlayerInterpolateType

TrajectoryPlayerInterpolateType: "" | "linear" | "spline"

TrajectoryPlayerMode

TrajectoryPlayerMode: "loop" | "once"

TrajectoryPlayerParameters

TrajectoryPlayerParameters: typeof TrajectoryPlayerDefaultParameters

TransformOrientation

TransformOrientation: "global" | "local" | "principal"

TranslationCallback

TranslationCallback: (deltaPosition: Vector3) => void

Type declaration

    • (deltaPosition: Vector3): void

    • Parameters

      • deltaPosition: Vector3

      Returns void

TubeMeshBufferParameters

TubeMeshBufferParameters: typeof TubeMeshBufferDefaultParameters

TypedArray

TypedArray: TypedArray

TypedArrayString

TypedArrayString: "int8" | "int16" | "int32" | "uint8" | "uint16" | "uint32" | "float32"

Uniforms

Uniforms: {}

Type declaration

  • [k: string]: Uniform | { value: any }

VectorBufferParameters

VectorBufferParameters: typeof VectorBufferDefaultParameters

VolumeColormakerParams

VolumeColormakerParams: { volume: Volume } & Partial<ColormakerParameters>

VolumeRepresentationType

VolumeRepresentationType: "surface" | "slice" | "dot"

VolumeSize

VolumeSize: "value" | "abs-value" | "value-min" | "deviation"

WgBufferDataType

WgBufferDataType: Float32Array | Uint32Array

WideLineBufferParameters

WideLineBufferParameters: typeof WideLineBufferDefaultParameters

Private XMLNodeAttributes

XMLNodeAttributes: {}
file

Parse Xml

author

Alexander Rose alexander.rose@weirdbyte.de

Type declaration

  • [k: string]: any

Events

CounterSignals

CounterSignals:

{@link Signal}, dispatched when the count changes

example

counter.signals.countChanged.add( function( delta ){ ... } );

countChanged

countChanged: signalsWrapper.Signal

Variables

Const AA3

AA3: string[] = Object.keys(AA1)

Const AcidicResname

AcidicResname: string[] = [ 'ASP', 'GLU' ]

Const AliphaticResname

AliphaticResname: string[] = [ 'ALA', 'GLY', 'ILE', 'LEU', 'VAL' ]

Const AlkaliMetals

AlkaliMetals: number[] = [ 3, 11, 19, 37, 55, 87 ]

Const AlkalineEarthMetals

AlkalineEarthMetals: number[] = [ 4, 12, 20, 38, 56, 88 ]

Const AmideResname

AmideResname: string[] = [ 'ASN', 'GLN' ]

Const AngleMode

AngleMode: 4 = 4

Const Angles

Angles: Map<AtomGeometry, number> = new Map<AtomGeometry, number>([[ AtomGeometry.Linear, degToRad(180) ],[ AtomGeometry.Trigonal, degToRad(120) ],[ AtomGeometry.Tetrahedral, degToRad(109.4721) ],[ AtomGeometry.Octahedral, degToRad(90) ]])

Const AromaticResname

AromaticResname: string[] = [ 'PHE', 'TRP', 'TYR', 'HIS' ]

Const AromaticRingElements

AromaticRingElements: Elements[] = [Elements.B, Elements.C, Elements.N, Elements.O,Elements.SI, Elements.P, Elements.S,Elements.GE, Elements.AS,Elements.SN, Elements.SB,Elements.BI]

Const AromaticRingPlanarityThreshold

AromaticRingPlanarityThreshold: 0.05 = 0.05

Const ArrowBufferDefaultParameters

ArrowBufferDefaultParameters: { aspectRatio: number; disableImpostor: false; openEnded: false; radialSegments: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({aspectRatio: 1.5,radialSegments: 50,openEnded: false,disableImpostor: false}, BufferDefaultParameters)

Const AtomFormat

AtomFormat: "ATOM %5d %-4s %3s %1s%4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s%2s" = "ATOM %5d %-4s %3s %1s%4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s%2s"

Const AtomLine

AtomLine: "%10.4f%10.4f%10.4f %-3s 0%3i 0 0 0" = "%10.4f%10.4f%10.4f %-3s 0%3i 0 0 0"

Const AtomMode

AtomMode: 2 = 2

Const AtomOnlyKeywords

AtomOnlyKeywords: kwd[] = [kwd.BACKBONE, kwd.SIDECHAIN, kwd.BONDED, kwd.RING, kwd.AROMATICRING, kwd.METAL, kwd.POLARH]

Const Bases

Bases: string[] = RnaBases.concat(DnaBases)

Const BasicResname

BasicResname: string[] = [ 'ARG', 'HIS', 'LYS' ]

Const BondFormat

BondFormat: "%3i%3i%3i 0 0 0" = "%3i%3i%3i 0 0 0"

Const BondMode

BondMode: 3 = 3

Const Browser

Browser: false | "Opera" | "Chrome" | "Firefox" | "Mobile Safari" | "Internet Explorer" | "Safari" = getBrowser()

The browser name: "Opera", "Chrome", "Firefox", "Mobile Safari", "Internet Explorer", "Safari" or false.

Const BufferRegistry

BufferRegistry: Registry = new Registry('buffer')

Const CgDnaBackboneType

CgDnaBackboneType: 6 = 6

Const CgProteinBackboneType

CgProteinBackboneType: 4 = 4

Const CgRnaBackboneType

CgRnaBackboneType: 5 = 5

Const ChainKeywords

ChainKeywords: kwd[] = [kwd.POLYMER, kwd.WATER]

Const ChainnameAlphabet

ChainnameAlphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ" = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Const ChargedResname

ChargedResname: string[] = [ 'ARG', 'ASP', 'GLU', 'HIS', 'LYS' ]

Const ChemCompDna

ChemCompDna: string[] = ['DNA OH 3 PRIME TERMINUS', 'DNA OH 5 PRIME TERMINUS', 'DNA LINKING','L-DNA LINKING', 'L-RNA LINKING']

Const ChemCompHetero

ChemCompHetero: string[] = ChemCompNonPolymer.concat(ChemCompOther, ChemCompSaccharide)

Const ChemCompNonPolymer

ChemCompNonPolymer: string[] = ['NON-POLYMER']

Const ChemCompOther

ChemCompOther: string[] = ['OTHER']

Const ChemCompProtein

ChemCompProtein: string[] = ['D-BETA-PEPTIDE, C-GAMMA LINKING', 'D-GAMMA-PEPTIDE, C-DELTA LINKING','D-PEPTIDE COOH CARBOXY TERMINUS', 'D-PEPTIDE NH3 AMINO TERMINUS', 'D-PEPTIDE LINKING','L-BETA-PEPTIDE, C-GAMMA LINKING', 'L-GAMMA-PEPTIDE, C-DELTA LINKING','L-PEPTIDE COOH CARBOXY TERMINUS', 'L-PEPTIDE NH3 AMINO TERMINUS', 'L-PEPTIDE LINKING','PEPTIDE LINKING', 'PEPTIDE-LIKE']

Const ChemCompRna

ChemCompRna: string[] = ['RNA OH 3 PRIME TERMINUS', 'RNA OH 5 PRIME TERMINUS', 'RNA LINKING']

Const ChemCompSaccharide

ChemCompSaccharide: string[] = ['D-SACCHARIDE', 'D-SACCHARIDE 1,4 AND 1,4 LINKING', 'D-SACCHARIDE 1,4 AND 1,6 LINKING','L-SACCHARIDE', 'L-SACCHARIDE 1,4 AND 1,4 LINKING', 'L-SACCHARIDE 1,4 AND 1,6 LINKING','SACCHARIDE']

CircleSignals

CircleSignals: any

Const CoarseGrainedRepresentationRegistry

CoarseGrainedRepresentationRegistry: Registry = new Registry("cg-representation")

Const ComponentRegistry

ComponentRegistry: Registry = new Registry('component')

Const ConeBufferDefaultParameters

ConeBufferDefaultParameters: { openEnded: false; radialSegments: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({radialSegments: 60,openEnded: false}, BufferDefaultParameters)

Const CountFormat

CountFormat: "%3i%3i 0 0 0 0 0 0 0 0999 V2000" = "%3i%3i 0 0 0 0 0 0 0 0999 V2000"

Const CyclicResname

CyclicResname: string[] = [ 'HIS', 'PHE', 'PRO', 'TRP', 'TYR' ]

Const CylinderBufferDefaultParameters

CylinderBufferDefaultParameters: { disableImpostor: false } & { openEnded: true; radialSegments: number; thetaLength: number; thetaStart: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } & { openEnded: false } = Object.assign({disableImpostor: false}, CylinderGeometryBufferDefaultParameters, CylinderImpostorBufferDefaultParameters)

Const CylinderGeometryBufferDefaultParameters

CylinderGeometryBufferDefaultParameters: { openEnded: true; radialSegments: number; thetaLength: number; thetaStart: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({radialSegments: 1,openEnded: true,thetaStart: 0,thetaLength: 2 * Math.PI}, BufferDefaultParameters)

Const CylinderImpostorBufferDefaultParameters

CylinderImpostorBufferDefaultParameters: { openEnded: false } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({openEnded: false}, BufferDefaultParameters)

Const CylinderImpostorBufferParameterTypes

CylinderImpostorBufferParameterTypes: { openEnded: object } & { matrix: {}; background: object; clipCenter: object; clipNear: object; clipRadius: object; depthWrite: object; diffuse: object; diffuseInterior: object; flatShaded: object; interiorColor: object; interiorDarkening: object; metalness: object; opacity: object; opaqueBack: object; roughness: object; side: object; useInteriorColor: object; wireframe: object } = Object.assign({openEnded: { updateShader: true }}, BufferParameterTypes)

Const DEG2RAD

DEG2RAD: number = Math.PI / 180

Const DNA_VALUES

DNA_VALUES: string[] = ["C", "A", "T", "G"]

Const DNA_VALUES_REGEX

DNA_VALUES_REGEX: RegExp = new RegExp("[" + DNA_VALUES.join("|") + "]", "g")

Const DatasourceRegistry

DatasourceRegistry: Registry = new Registry('datasource')

Let Debug

Debug: boolean = boolean(getQuery('debug'))

Const DecompressorRegistry

DecompressorRegistry: Registry = new Registry('decompressor')

Const DefaultAtomWeight

DefaultAtomWeight: 10.81 = 10.81

Const DefaultAtomicNumber

DefaultAtomicNumber: 0 = 0

Const DefaultCovalentRadius

DefaultCovalentRadius: 1.6 = 1.6

Const DefaultElementColor

DefaultElementColor: 16777215 = 16777215

Const DefaultOuterShellElectronCount

DefaultOuterShellElectronCount: 2 = 2

Const DefaultResidueColor

DefaultResidueColor: 16711935 = 16711935

Const DefaultResidueHydrophobicity

DefaultResidueHydrophobicity: number[] = [0.00, 0.00, 0.00]

Const DefaultResidueRadius

DefaultResidueRadius: 5 = 5

Const DefaultStructureColor

DefaultStructureColor: 8421504 = 8421504

Const DefaultValence

DefaultValence: -1 = -1

Const DefaultVdwRadius

DefaultVdwRadius: 2 = 2

Const DiatomicNonmetals

DiatomicNonmetals: number[] = [ 1, 7, 8, 9, 17, 35, 53 ]

Const DihedralMode

DihedralMode: 5 = 5

Const DnaBackboneType

DnaBackboneType: 3 = 3

Const DnaBases

DnaBases: string[] = ['DA', 'DC', 'DT', 'DG', 'DU', 'DI']

Const DnaType

DnaType: 5 = 5

Private Const EPS

EPS: 1e-7 = 1e-7
file

Math Constants

author

Alexander Rose alexander.rose@weirdbyte.de

Const EPSILON

EPSILON: 1.192092896e-7 = 1.192092896e-7

Const EPSLON

EPSLON: 0.001 = 0.001

Const EllipsoidBufferDefaultParameters

EllipsoidBufferDefaultParameters: { sphereDetail: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({sphereDetail: 2,}, BufferDefaultParameters)

Const ExampleRegistry

ExampleRegistry: Registry = new Registry("example-registry")

Let ExtensionFragDepth

ExtensionFragDepth: boolean = false

Flag indicating support for the EXT_frag_depth WebGL extension (Always present in WebGL2)

Const FLT_MIN

FLT_MIN: 1e-37 = 1e-37

Const FilterAllKeyword

FilterAllKeyword: string[] = [ '*', '', 'ALL' ]

Const FilterNoneKeyword

FilterNoneKeyword: string[] = [ 'NONE' ]

Const FirstIdx

FirstIdx: 9 = 9

Const Halogens

Halogens: number[] = [ 9, 17, 35, 53, 85 ]

Const HetatmFormat

HetatmFormat: "HETATM%5d %-4s %3s %1s%4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s%2s" = "HETATM%5d %-4s %3s %1s%4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s%2s"

Const HydrophobicResname

HydrophobicResname: string[] = [ 'ALA', 'ILE', 'LEU', 'MET', 'PHE', 'PRO', 'TRP', 'VAL' ]

Const HyperballStickBufferDefaultParameters

HyperballStickBufferDefaultParameters: { disableImpostor: false } & { openEnded: true; radialSegments: number; thetaLength: number; thetaStart: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } & { shrink: number } = Object.assign({disableImpostor: false}, CylinderGeometryBufferDefaultParameters, HyperballStickImpostorBufferDefaultParameters)

Const HyperballStickImpostorBufferDefaultParameters

HyperballStickImpostorBufferDefaultParameters: { shrink: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({shrink: 0.14}, BufferDefaultParameters)

Const HyperballStickImpostorBufferParameterTypes

HyperballStickImpostorBufferParameterTypes: { shrink: object } & { matrix: {}; background: object; clipCenter: object; clipNear: object; clipRadius: object; depthWrite: object; diffuse: object; diffuseInterior: object; flatShaded: object; interiorColor: object; interiorDarkening: object; metalness: object; opacity: object; opaqueBack: object; roughness: object; side: object; useInteriorColor: object; wireframe: object } = Object.assign({shrink: { uniform: true }}, BufferParameterTypes)

Const ImageBufferDefaultParameters

ImageBufferDefaultParameters: { filter: ImageFilterTypes; forceTransparent: true } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({filter: 'nearest' as ImageFilterTypes,forceTransparent: true}, BufferDefaultParameters)

Const ImageBufferParameterTypes

ImageBufferParameterTypes: { filter: object } & { matrix: {}; background: object; clipCenter: object; clipNear: object; clipRadius: object; depthWrite: object; diffuse: object; diffuseInterior: object; flatShaded: object; interiorColor: object; interiorDarkening: object; metalness: object; opacity: object; opaqueBack: object; roughness: object; side: object; useInteriorColor: object; wireframe: object } = Object.assign({filter: { updateShader: true, uniform: true }}, BufferParameterTypes)

Const ImproperMode

ImproperMode: 6 = 6

Const IonNames

IonNames: string[] = ['118', '119', '1AL', '1CU', '2FK', '2HP', '2OF', '3CO','3MT', '3NI', '3OF', '3P8', '4MO', '4PU', '543', '6MO', 'ACT', 'AG', 'AL','ALF', 'AM', 'ATH', 'AU', 'AU3', 'AUC', 'AZI', 'BA', 'BCT', 'BEF', 'BF4', 'BO4','BR', 'BS3', 'BSY', 'CA', 'CAC', 'CD', 'CD1', 'CD3', 'CD5', 'CE', 'CHT', 'CL','CO', 'CO3', 'CO5', 'CON', 'CR', 'CS', 'CSB', 'CU', 'CU1', 'CU3', 'CUA', 'CUZ','CYN', 'DME', 'DMI', 'DSC', 'DTI', 'DY', 'E4N', 'EDR', 'EMC', 'ER3', 'EU','EU3', 'F', 'FE', 'FE2', 'FPO', 'GA', 'GD3', 'GEP', 'HAI', 'HG', 'HGC', 'IN','IOD', 'IR', 'IR3', 'IRI', 'IUM', 'K', 'KO4', 'LA', 'LCO', 'LCP', 'LI', 'LU','MAC', 'MG', 'MH2', 'MH3', 'MLI', 'MLT', 'MMC', 'MN', 'MN3', 'MN5', 'MN6','MO1', 'MO2', 'MO3', 'MO4', 'MO5', 'MO6', 'MOO', 'MOS', 'MOW', 'MW1', 'MW2','MW3', 'NA', 'NA2', 'NA5', 'NA6', 'NAO', 'NAW', 'NCO', 'NET', 'NH4', 'NI','NI1', 'NI2', 'NI3', 'NO2', 'NO3', 'NRU', 'O4M', 'OAA', 'OC1', 'OC2', 'OC3','OC4', 'OC5', 'OC6', 'OC7', 'OC8', 'OCL', 'OCM', 'OCN', 'OCO', 'OF1', 'OF2','OF3', 'OH', 'OS', 'OS4', 'OXL', 'PB', 'PBM', 'PD', 'PDV', 'PER', 'PI', 'PO3','PO4', 'PR', 'PT', 'PT4', 'PTN', 'RB', 'RH3', 'RHD', 'RU', 'SB', 'SCN', 'SE4','SEK', 'SM', 'SMO', 'SO3', 'SO4', 'SR', 'T1A', 'TB', 'TBA', 'TCN', 'TEA', 'TH','THE', 'TL', 'TMA', 'TRA', 'UNX', 'V', 'VN3', 'VO4', 'W', 'WO5', 'Y1', 'YB','YB2', 'YH', 'YT3', 'ZCM', 'ZN', 'ZN2', 'ZN3', 'ZNO', 'ZO3',// additional ion names'OHX']

Const IonType

IonType: 2 = 2

Const IonicTypeMetals

IonicTypeMetals: Elements[] = [Elements.LI, Elements.NA, Elements.K, Elements.RB, Elements.CS,Elements.MG, Elements.CA, Elements.SR, Elements.BA, Elements.AL,Elements.GA, Elements.IN, Elements.TL, Elements.SC, Elements.SN,Elements.PB, Elements.BI, Elements.SB, Elements.HG]

Const JitterVectors

JitterVectors: number[][][] = [[[ 0, 0 ]],[[ 4, 4 ], [ -4, -4 ]],[[ -2, -6 ], [ 6, -2 ], [ -6, 2 ], [ 2, 6 ]],[[ 1, -3 ], [ -1, 3 ], [ 5, 1 ], [ -3, -5 ],[ -5, 5 ], [ -7, -1 ], [ 3, 7 ], [ 7, -7 ]],[[ 1, 1 ], [ -1, -3 ], [ -3, 2 ], [ 4, -1 ],[ -5, -2 ], [ 2, 5 ], [ 5, 3 ], [ 3, -5 ],[ -2, 6 ], [ 0, -7 ], [ -4, -6 ], [ -6, 4 ],[ -8, 0 ], [ 7, -4 ], [ 6, 7 ], [ -7, -8 ]],[[ -4, -7 ], [ -7, -5 ], [ -3, -5 ], [ -5, -4 ],[ -1, -4 ], [ -2, -2 ], [ -6, -1 ], [ -4, 0 ],[ -7, 1 ], [ -1, 2 ], [ -6, 3 ], [ -3, 3 ],[ -7, 6 ], [ -3, 6 ], [ -5, 7 ], [ -1, 7 ],[ 5, -7 ], [ 1, -6 ], [ 6, -5 ], [ 4, -4 ],[ 2, -3 ], [ 7, -2 ], [ 1, -1 ], [ 4, -1 ],[ 2, 1 ], [ 6, 2 ], [ 0, 4 ], [ 4, 4 ],[ 2, 5 ], [ 7, 5 ], [ 5, 6 ], [ 3, 7 ]]]

Const JsPyScriptExtensions

JsPyScriptExtensions: string[] = ["jspy"]

Const JsScriptExtensions

JsScriptExtensions: string[] = ["ngl", "js"]

List of file extensions to be recognized as scripts

Const KwdsGeneral

KwdsGeneral: {}

Type declaration

  • [id: string]: string

Const KwdsGeneralDescriptions

KwdsGeneralDescriptions: {}

Type declaration

  • [id: string]: string

Private Const LeftMouseButton

LeftMouseButton: 1 = 1
file

Constants

author

Alexander Rose alexander.rose@weirdbyte.de

Let ListingDatasource

ListingDatasource: any

Const MacrolideEntity

MacrolideEntity: 3 = 3

Const MagicInts

MagicInts: Uint32Array = new Uint32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 10, 12, 16, 20, 25, 32, 40, 50, 64,80, 101, 128, 161, 203, 256, 322, 406, 512, 645, 812, 1024, 1290,1625, 2048, 2580, 3250, 4096, 5060, 6501, 8192, 10321, 13003,16384, 20642, 26007, 32768, 41285, 52015, 65536, 82570, 104031,131072, 165140, 208063, 262144, 330280, 416127, 524287, 660561,832255, 1048576, 1321122, 1664510, 2097152, 2642245, 3329021,4194304, 5284491, 6658042, 8388607, 10568983, 13316085, 16777216])

Const Metalloids

Metalloids: number[] = [ 5, 14, 32, 33, 51, 52, 85 ]

Const MiddleMouseButton

MiddleMouseButton: 2 = 2

Const Mobile

Mobile: boolean = typeof window !== 'undefined' ? typeof window.orientation !== 'undefined' : false

Flag indicating a mobile browser

Const NA_ATOMS

NA_ATOMS: string[] = [...NA_BACKBONE_ATOMS, ...NA_BASE_ATOMS]

Const NA_BACKBONE_ATOMS

NA_BACKBONE_ATOMS: string[] = ["BB1", "BB2", "BB3"]

Const NA_BASE_ATOMS

NA_BASE_ATOMS: string[] = ["SC1", "SC2", "SC3", "SC4"]

Const NC_ATTRIBUTE

NC_ATTRIBUTE: 12 = 12

Const NC_DIMENSION

NC_DIMENSION: 10 = 10

Const NC_VARIABLE

NC_VARIABLE: 11 = 11

Const NegativelyCharged

NegativelyCharged: string[] = [ 'GLU', 'ASP' ]

Const NobleGases

NobleGases: number[] = [ 2, 10, 18, 36, 54, 86 ]

Const NonPolymerEntity

NonPolymerEntity: 2 = 2

Const NonpolarResname

NonpolarResname: string[] = [ 'ALA', 'ILE', 'LEU', 'MET', 'PHE', 'PRO', 'TRP', 'VAL' ]

Const NucleicBackboneAtoms

NucleicBackboneAtoms: string[] = ['P', 'OP1', 'OP2', 'HOP2', 'HOP3',"O2'", "O3'", "O4'", "O5'", "C1'", "C2'", "C3'", "C4'", "C5'","H1'", "H2'", "H2''", "HO2'", "H3'", "H4'", "H5'", "H5''", "HO3'", "HO5'",'O2*', 'O3*', 'O4*', 'O5*', 'C1*', 'C2*', 'C3*', 'C4*', 'C5*','O1P', 'O2P' // Catana extension to handle non-standard atom names]

Const NucleobaseTypeAtoms

NucleobaseTypeAtoms: {}

Type declaration

  • [k: number]: {}
    • [k: string]: string | string[]

Const NucleophilicResname

NucleophilicResname: string[] = [ 'CYS', 'SER', 'THR' ]

Private Const OBJLoader

OBJLoader: _OBJLoaderConstructor = (function OBJLoader (this: _OBJLoader) {this.regexp = {// v float float floatvertex_pattern: /^v\s+([\d.+\-eE]+)\s+([\d.+\-eE]+)\s+([\d.+\-eE]+)/,// vn float float floatnormal_pattern: /^vn\s+([\d.+\-eE]+)\s+([\d.+\-eE]+)\s+([\d.+\-eE]+)/,// vt float floatuv_pattern: /^vt\s+([\d.+\-eE]+)\s+([\d.+\-eE]+)/,// f vertex vertex vertexface_vertex: /^f\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)(?:\s+(-?\d+))?/,// f vertex/uv vertex/uv vertex/uvface_vertex_uv: /^f\s+(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)(?:\s+(-?\d+)\/(-?\d+))?/,// f vertex/uv/normal vertex/uv/normal vertex/uv/normalface_vertex_uv_normal: /^f\s+(-?\d+)\/(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\/(-?\d+)\s+(-?\d+)\/(-?\d+)\/(-?\d+)(?:\s+(-?\d+)\/(-?\d+)\/(-?\d+))?/,// f vertex//normal vertex//normal vertex//normalface_vertex_normal: /^f\s+(-?\d+)\/\/(-?\d+)\s+(-?\d+)\/\/(-?\d+)\s+(-?\d+)\/\/(-?\d+)(?:\s+(-?\d+)\/\/(-?\d+))?/,// o object_name | g group_nameobject_pattern: /^[og]\s*(.+)?/,// s booleansmoothing_pattern: /^s\s+(\d+|on|off)/,// mtllib file_referencematerial_library_pattern: /^mtllib /,// usemtl material_namematerial_use_pattern: /^usemtl /}}) as _OBJLoaderConstructor

OBJLoader

author

mrdoob / http://mrdoob.com/

Const OptimalAcceptorAngle

OptimalAcceptorAngle: number = degToRad(120)

Const OptimalHalogenAngle

OptimalHalogenAngle: number = degToRad(180)

Const PLYLoader

PLYLoader: _PLYLoaderConstructor = (function PLYLoader (this: _PLYLoader) {this.propertyNameMapping = {}}) as _PLYLoaderConstructor

Const PROTEIN_VALUES_ONE_LETTER

PROTEIN_VALUES_ONE_LETTER: string[] = ["A", "R", "N", "D", "C", "E", "Q", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"]

Const PROTEIN_VALUES_ONE_LETTER_REGEX

PROTEIN_VALUES_ONE_LETTER_REGEX: RegExp = new RegExp("[" + PROTEIN_VALUES_ONE_LETTER.join("") + "]", "g")

Const PROTEIN_VALUES_THREE_LETTER

PROTEIN_VALUES_THREE_LETTER: string[] = ["ALA", "ARG", "ASN", "ASP","CYS", "GLU", "GLN", "GLY","HIS", "ILE", "LEU", "LYS","MET", "PHE", "PRO", "SER","THR", "TRP", "TYR", "VAL"]

Const PROT_ATOMS

PROT_ATOMS: string[] = [...PROT_BACKBONE_ATOMS, ...PROT_SIDECHAIN_ATOMS]

Const PROT_BACKBONE_ATOMS

PROT_BACKBONE_ATOMS: string[] = ["BB"]

Const PROT_SIDECHAIN_ATOMS

PROT_SIDECHAIN_ATOMS: string[] = ["SC1", "SC2", "SC3", "SC4"]

Const ParserParametersRegistry

ParserParametersRegistry: Registry = new Registry("parser-parameters")

Const PickerRegistry

PickerRegistry: Registry = new Registry('picker')

Const PluginExtension

PluginExtension: "catplg" = "catplg"

Const PointBufferDefaultParameters

PointBufferDefaultParameters: { alphaTest: number; edgeBleach: number; forceTransparent: false; pointSize: number; sizeAttenuation: true; sortParticles: false; useTexture: false } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({pointSize: 1,sizeAttenuation: true,sortParticles: false,alphaTest: 0.5,useTexture: false,forceTransparent: false,edgeBleach: 0.0}, BufferDefaultParameters)

Const PointBufferParameterTypes

PointBufferParameterTypes: { forceTransparent: {}; sortParticles: {}; alphaTest: object; edgeBleach: object; pointSize: object; sizeAttenuation: object; useTexture: object } & { matrix: {}; background: object; clipCenter: object; clipNear: object; clipRadius: object; depthWrite: object; diffuse: object; diffuseInterior: object; flatShaded: object; interiorColor: object; interiorDarkening: object; metalness: object; opacity: object; opaqueBack: object; roughness: object; side: object; useInteriorColor: object; wireframe: object } = Object.assign({pointSize: { uniform: 'size' },sizeAttenuation: { updateShader: true },sortParticles: {},alphaTest: { updateShader: true },useTexture: { updateShader: true },forceTransparent: {},edgeBleach: { uniform: true }}, BufferParameterTypes)

Const PolarElements

PolarElements: Elements[] = [Elements.N, Elements.O, Elements.S,Elements.F, Elements.CL, Elements.BR, Elements.I]

Const PolarResname

PolarResname: string[] = [ 'ASN', 'ARG', 'ASP', 'CYS', 'GLY', 'GLN', 'GLU', 'HIS', 'LYS', 'SER', 'THR', 'TYR' ]

Const PolyatomicNonmetals

PolyatomicNonmetals: number[] = [ 6, 15, 16, 34, ]

Const PolymerEntity

PolymerEntity: 1 = 1

Const PositvelyCharged

PositvelyCharged: string[] = [ 'ARG', 'HIS', 'LYS' ]

Const PostTransitionMetals

PostTransitionMetals: number[] = [ 13, 30, 31, 48, 49, 50, 80, 81, 82, 83, 84, 85, 112 ]

Const Primitives

Primitives: (CylinderPrimitive | PointPrimitive | WidelinePrimitive)[] = [ArrowPrimitive, BoxPrimitive, ConePrimitive, CylinderPrimitive,EllipsoidPrimitive, OctahedronPrimitive, SpherePrimitive, TetrahedronPrimitive,TextPrimitive, TorusPrimitive, PointPrimitive, WidelinePrimitive]

Const ProteinBackboneAtoms

ProteinBackboneAtoms: string[] = ['CA', 'C', 'N', 'O','O1', 'O2', 'OC1', 'OC2', 'OX1', 'OXT', 'OT1', 'OT2','H', 'H1', 'H2', 'H3', 'HA', 'HN','BB']

Const ProteinBackboneType

ProteinBackboneType: 1 = 1

Const ProteinType

ProteinType: 3 = 3

Const PurineNucleobaseType

PurineNucleobaseType: 1 = 1

Const PyrimidineNucleobaseType

PyrimidineNucleobaseType: 2 = 2

Const RAD2DEG

RAD2DEG: number = 180 / Math.PI

Const RepresentationElementDefaultParameters

RepresentationElementDefaultParameters: { visible: true } & { name: string; status: string } = Object.assign({visible: true}, ElementDefaultParameters)

Const RepresentationRegistry

RepresentationRegistry: Registry = new Registry('representatation')

Const ResidueTypeAtoms

ResidueTypeAtoms: {}

Type declaration

  • [k: number]: {}
    • [k: string]: string | string[]

Const RightMouseButton

RightMouseButton: 3 = 3

Const RingFinderMaxDepth

RingFinderMaxDepth: 4 = 4

Const RnaBackboneType

RnaBackboneType: 2 = 2

Const RnaBases

RnaBases: string[] = ['A', 'C', 'T', 'G', 'U', 'I']

Const RnaType

RnaType: 4 = 4

Const SaccharideNames

SaccharideNames: string[] = ['045', '0AT', '0BD', '0MK', '0NZ', '0TS', '0V4', '0XY', '0YT', '10M','147', '149', '14T', '15L', '16G', '18T', '18Y', '1AR', '1BW', '1GL', '1GN','1JB', '1LL', '1NA', '1S3', '26M', '26Q', '26R', '26V', '26W', '26Y', '27C','289', '291', '293', '2DG', '2F8', '2FG', '2FL', '2FP', '2GL', '2M4', '2M5','32O', '34V', '3CM', '3DO', '3DY', '3FM', '3LR', '3MF', '3MG', '3SA', '3ZW','46D', '46M', '46Z', '48Z', '4CQ', '4GC', '4NN', '50A', '5DI', '5GF', '5MM','5RP', '5SA', '5SP', '64K', '6PG', '6SA', '7JZ', '7SA', 'A1Q', 'A2G', 'AAB','AAL', 'AAO', 'ABC', 'ABD', 'ABE', 'ABF', 'ABL', 'ACG', 'ACI', 'ACR', 'ACX','ADA', 'ADG', 'ADR', 'AF1', 'AFD', 'AFL', 'AFO', 'AFP', 'AFR', 'AGC', 'AGH','AGL', 'AHR', 'AIG', 'ALL', 'ALX', 'AMU', 'AOG', 'AOS', 'ARA', 'ARB', 'ARE','ARI', 'ASG', 'ASO', 'AXP', 'AXR', 'B0D', 'B16', 'B2G', 'B4G', 'B6D', 'B8D','B9D', 'BBK', 'BCD', 'BDG', 'BDP', 'BDR', 'BEM', 'BFP', 'BGC', 'BGL', 'BGP','BGS', 'BHG', 'BMA', 'BMX', 'BNG', 'BNX', 'BOG', 'BRI', 'BXF', 'BXP', 'BXX','BXY', 'C3X', 'C4X', 'C5X', 'CAP', 'CBI', 'CBK', 'CBS', 'CDR', 'CEG', 'CGF','CHO', 'CR1', 'CR6', 'CRA', 'CT3', 'CTO', 'CTR', 'CTT', 'D6G', 'DAF', 'DAG','DDA', 'DDB', 'DDL', 'DEL', 'DFR', 'DFX', 'DG0', 'DGC', 'DGD', 'DGM', 'DGS','DIG', 'DLF', 'DLG', 'DMU', 'DNO', 'DOM', 'DP5', 'DQQ', 'DQR', 'DR2', 'DR3','DR4', 'DRI', 'DSR', 'DT6', 'DVC', 'E4P', 'E5G', 'EAG', 'EBG', 'EBQ', 'EGA','EJT', 'EPG', 'ERE', 'ERI', 'F1P', 'F1X', 'F6P', 'FBP', 'FCA', 'FCB', 'FCT','FDP', 'FDQ', 'FFC', 'FIX', 'FMO', 'FRU', 'FSI', 'FU4', 'FUB', 'FUC', 'FUD','FUL', 'FXP', 'G16', 'G1P', 'G2F', 'G3I', 'G4D', 'G4S', 'G6D', 'G6P', 'G6S','GAC', 'GAD', 'GAL', 'GC1', 'GC4', 'GCD', 'GCN', 'GCO', 'GCS', 'GCT', 'GCU','GCV', 'GCW', 'GCX', 'GE1', 'GFG', 'GFP', 'GIV', 'GL0', 'GL2', 'GL5', 'GL6','GL7', 'GL9', 'GLA', 'GLB', 'GLC', 'GLD', 'GLF', 'GLG', 'GLO', 'GLP', 'GLS','GLT', 'GLW', 'GMH', 'GN1', 'GNX', 'GP1', 'GP4', 'GPH', 'GPM', 'GQ1', 'GQ2','GQ4', 'GS1', 'GS4', 'GSA', 'GSD', 'GTE', 'GTH', 'GTK', 'GTR', 'GTZ', 'GU0','GU1', 'GU2', 'GU3', 'GU4', 'GU5', 'GU6', 'GU8', 'GU9', 'GUF', 'GUP', 'GUZ','GYP', 'GYV', 'H2P', 'HDL', 'HMS', 'HS2', 'HSD', 'HSG', 'HSH', 'HSJ', 'HSQ','HSR', 'HSU', 'HSX', 'HSY', 'HSZ', 'IAB', 'IDG', 'IDR', 'IDS', 'IDT', 'IDU','IDX', 'IDY', 'IMK', 'IN1', 'IPT', 'ISL', 'KBG', 'KD2', 'KDA', 'KDM', 'KDO','KFN', 'KO1', 'KO2', 'KTU', 'L6S', 'LAG', 'LAI', 'LAK', 'LAO', 'LAT', 'LB2','LBT', 'LCN', 'LDY', 'LGC', 'LGU', 'LM2', 'LMT', 'LMU', 'LOG', 'LOX', 'LPK','LSM', 'LTM', 'LVZ', 'LXB', 'LXZ', 'M1F', 'M3M', 'M6P', 'M8C', 'MA1', 'MA2','MA3', 'MAB', 'MAG', 'MAL', 'MAN', 'MAT', 'MAV', 'MAW', 'MBG', 'MCU', 'MDA','MDM', 'MDP', 'MFA', 'MFB', 'MFU', 'MG5', 'MGA', 'MGL', 'MLB', 'MMA', 'MMN','MN0', 'MRP', 'MTT', 'MUG', 'MVP', 'MXY', 'N1L', 'N9S', 'NAA', 'NAG', 'NBG','NDG', 'NED', 'NG1', 'NG6', 'NGA', 'NGB', 'NGC', 'NGE', 'NGF', 'NGL', 'NGS','NGY', 'NHF', 'NM6', 'NM9', 'NTF', 'NTO', 'NTP', 'NXD', 'NYT', 'OPG', 'OPM','ORP', 'OX2', 'P3M', 'P53', 'P6P', 'PA5', 'PNA', 'PNG', 'PNW', 'PRP', 'PSJ','PSV', 'PTQ', 'QDK', 'QPS', 'QV4', 'R1P', 'R1X', 'R2B', 'R5P', 'RAA', 'RAE','RAF', 'RAM', 'RAO', 'RAT', 'RB5', 'RBL', 'RCD', 'RDP', 'REL', 'RER', 'RF5','RG1', 'RGG', 'RHA', 'RIB', 'RIP', 'RNS', 'RNT', 'ROB', 'ROR', 'RPA', 'RST','RUB', 'RUU', 'RZM', 'S6P', 'S7P', 'SA0', 'SCR', 'SDD', 'SF6', 'SF9', 'SG4','SG5', 'SG6', 'SG7', 'SGA', 'SGC', 'SGD', 'SGN', 'SGS', 'SHB', 'SHG', 'SI3','SIO', 'SOE', 'SOL', 'SSG', 'SUC', 'SUP', 'SUS', 'T6P', 'T6T', 'TAG', 'TCB','TDG', 'TGK', 'TGY', 'TH1', 'TIA', 'TM5', 'TM6', 'TM9', 'TMR', 'TMX', 'TOA','TOC', 'TRE', 'TYV', 'UCD', 'UDC', 'VG1', 'X0X', 'X1X', 'X2F', 'X4S', 'X5S','X6X', 'XBP', 'XDN', 'XDP', 'XIF', 'XIM', 'XLF', 'XLS', 'XMM', 'XUL', 'XXR','XYP', 'XYS', 'YO5', 'Z3Q', 'Z6J', 'Z9M', 'ZDC', 'ZDM']

Const SaccharideType

SaccharideType: 6 = 6

Const ScriptExtensions

ScriptExtensions: string[] = [...JsScriptExtensions, ...JsPyScriptExtensions]

Const SecStrucHelix

SecStrucHelix: string[] = ['h', 'g', 'i']

Const SecStrucSheet

SecStrucSheet: string[] = ['e', 'b']

Const SecStrucTurn

SecStrucTurn: string[] = ['s', 't', 'l', '']

SelectionShaderMode

SelectionShaderMode: SelectionShaderMode

Const ShaderRegistry

ShaderRegistry: Registry = new Registry('shader')

Const SmallResname

SmallResname: string[] = [ 'ALA', 'GLY', 'SER' ]

Const SphereBufferDefaultParameters

SphereBufferDefaultParameters: { disableImpostor: false } & { sphereDetail: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({disableImpostor: false}, SphereGeometryBufferDefaultParameters)

Const SphereGeometryBufferDefaultParameters

SphereGeometryBufferDefaultParameters: { sphereDetail: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({sphereDetail: 1}, BufferDefaultParameters)

Const StructureComponentDefaultParameters

StructureComponentDefaultParameters: { defaultAssembly: string; filt: string } & { backendOnly: boolean; locked: boolean; name: string; status: string; visible: boolean } = Object.assign({filt: '',defaultAssembly: ''}, ComponentDefaultParameters)

Const SubstitutionMatrices

SubstitutionMatrices: { blosum62: {}; blosum62x: {}; ednaFull: {} } = (function () {return {blosum62: prepareMatrix(aminoacids, blosum62),blosum62x: prepareMatrix(aminoacidsX, blosum62x),ednaFull: prepareMatrix(nucleotides, ednaFull)}}())

Type declaration

  • blosum62: {}
    • [k: string]: {}
      • [k: string]: number
  • blosum62x: {}
    • [k: string]: {}
      • [k: string]: number
  • ednaFull: {}
    • [k: string]: {}
      • [k: string]: number

Let SupportsPassiveEventHandler

SupportsPassiveEventHandler: boolean = false

Flag indicating support for the 'passive' option for event handler

Let SupportsReadPixelsFloat

SupportsReadPixelsFloat: boolean = false

Const TerFormat

TerFormat: "TER %5d %3s %1s%4d " = "TER %5d %3s %1s%4d "

Const TextAtlasCache

TextAtlasCache: {}

Type declaration

Const TextBufferDefaultParameters

TextBufferDefaultParameters: { attachment: TextAttachments; backgroundColor: string | number; backgroundMargin: number; backgroundOpacity: number; borderColor: string | number; borderWidth: number; fixedSize: false; fontFamily: TextFonts; fontSize: number; fontStyle: TextStyles; fontWeight: TextWeights; forceTransparent: true; showBackground: false; showBorder: false; xOffset: number; yOffset: number; zOffset: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({fontFamily: 'sans-serif' as TextFonts,fontStyle: 'normal' as TextStyles,fontWeight: 'bold' as TextWeights,fontSize: 36,xOffset: 0.0,yOffset: 0.0,zOffset: 0.5,attachment: 'bottom-left' as TextAttachments,showBorder: false,borderColor: 'lightgrey' as number|string,borderWidth: 0.15,showBackground: false,backgroundColor: 'lightgrey' as number|string,backgroundMargin: 0.5,backgroundOpacity: 1.0,forceTransparent: true,fixedSize: false}, BufferDefaultParameters)

Const TextBufferParameterTypes

TextBufferParameterTypes: { backgroundColor: object; backgroundOpacity: object; borderColor: object; borderWidth: object; fixedSize: object; fontFamily: object; fontSize: object; fontStyle: object; fontWeight: object; showBorder: object; xOffset: object; yOffset: object; zOffset: object } & { matrix: {}; background: object; clipCenter: object; clipNear: object; clipRadius: object; depthWrite: object; diffuse: object; diffuseInterior: object; flatShaded: object; interiorColor: object; interiorDarkening: object; metalness: object; opacity: object; opaqueBack: object; roughness: object; side: object; useInteriorColor: object; wireframe: object } = Object.assign({fontFamily: { uniform: true },fontStyle: { uniform: true },fontWeight: { uniform: true },fontSize: { uniform: true },xOffset: { uniform: true },yOffset: { uniform: true },zOffset: { uniform: true },showBorder: { uniform: true },borderColor: { uniform: true },borderWidth: { uniform: true },backgroundColor: { uniform: true },backgroundOpacity: { uniform: true },fixedSize: { updateShader: true }}, BufferParameterTypes)

Const TextureTestFragShader

TextureTestFragShader: "precision mediump float;uniform vec4 u_color;uniform sampler2D u_texture;void main() {gl_FragColor = texture2D(u_texture, vec2(0.5, 0.5)) * u_color;}" = `precision mediump float;uniform vec4 u_color;uniform sampler2D u_texture;void main() {gl_FragColor = texture2D(u_texture, vec2(0.5, 0.5)) * u_color;}`

Const TextureTestTexCoords

TextureTestTexCoords: Float32Array = new Float32Array([-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0])

Const TextureTestVertShader

TextureTestVertShader: "attribute vec4 a_position;void main() {gl_Position = a_position;}" = `attribute vec4 a_position;void main() {gl_Position = a_position;}`

Const TitleMode

TitleMode: 1 = 1

Const TorusBufferDefaultParameters

TorusBufferDefaultParameters: { radialSegments: number; radiusRatio: number; tubularSegments: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({radiusRatio: 0.2,radialSegments: 16,tubularSegments: 32}, BufferDefaultParameters)

Let TrajectoryDatasource

TrajectoryDatasource: any

Const TrajectoryElementDefaultParameters

TrajectoryElementDefaultParameters: { defaultDirection: TrajectoryPlayerDirection; defaultInterpolateStep: number; defaultInterpolateType: TrajectoryPlayerInterpolateType; defaultMode: TrajectoryPlayerMode; defaultStep: number; defaultTimeout: number; initialFrame: number } & { name: string; status: string } = Object.assign({defaultStep: 1,defaultTimeout: 50,defaultInterpolateType: '' as TrajectoryPlayerInterpolateType,defaultInterpolateStep: 5,defaultMode: 'loop' as TrajectoryPlayerMode,defaultDirection: 'forward' as TrajectoryPlayerDirection,initialFrame: 0}, ElementDefaultParameters)

Trajectory component parameter object.

property

{String} name - component name

property

{Integer} initialFrame - initial frame the trajectory is set to

property

{Integer} defaultStep - default step size to be used by trajectory players

property

{Integer} defaultTimeout - default timeout to be used by trajectory players

property

{String} defaultInterpolateType - one of "" (empty string), "linear" or "spline"

property

{Integer} defaultInterpolateStep - window size used for interpolation

property

{String} defaultMode - either "loop" or "once"

property

{String} defaultDirection - either "forward" or "backward"

Const TubeMeshBufferDefaultParameters

TubeMeshBufferDefaultParameters: { arrowEnded: false; arrowEndedLength: number; aspectRatio: number; capped: false; radialSegments: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({radialSegments: 4,capped: false,aspectRatio: 1.0,arrowEnded: false, // Catana extensionarrowEndedLength: 4 // Catana extension}, BufferDefaultParameters)

Const TwoPI

TwoPI: number = 2 * Math.PI

Const UnknownBackboneType

UnknownBackboneType: 0 = 0

Private Const UnknownEntity

UnknownEntity: 0 = 0
file

Structure Constants

author

Alexander Rose alexander.rose@weirdbyte.de

Const UnknownNucleobaseType

UnknownNucleobaseType: 0 = 0

Const UnknownType

UnknownType: 0 = 0

Const VectorBufferDefaultParameters

VectorBufferDefaultParameters: { color: string; scale: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({scale: 1,color: 'grey'}, BufferDefaultParameters)

Const Version

Version: string = (data as any).version as string

Version name

Const WaterEntity

WaterEntity: 4 = 4

Const WaterNames

WaterNames: string[] = ['SOL', 'WAT', 'HOH', 'H2O', 'W', 'DOD', 'D3O', 'TIP3', 'TIP4', 'SPC']

Const WaterType

WaterType: 1 = 1

Const WebglErrorMessage

WebglErrorMessage: "<div style="display:flex;align-items:center;justify-content:center;height:100%;"><p style="padding:15px;text-align:center;">Your browser/graphics card does not seem to support <a target="_blank" href="https://en.wikipedia.org/wiki/WebGL">WebGL</a>.<br/><br/>Find out how to get it <a target="_blank" href="http://get.webgl.org/">here</a>.</p></div>" = "<div style="display:flex;align-items:center;justify-content:center;height:100%;"><p style="padding:15px;text-align:center;">Your browser/graphics card does not seem to support <a target="_blank" href="https://en.wikipedia.org/wiki/WebGL">WebGL</a>.<br/><br/>Find out how to get it <a target="_blank" href="http://get.webgl.org/">here</a>.</p></div>"

Const WideLineBufferDefaultParameters

WideLineBufferDefaultParameters: { linewidth: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean } = Object.assign({linewidth: 2}, BufferDefaultParameters)

Const WideLineBufferParameterTypes

WideLineBufferParameterTypes: { linewidth: object } & { matrix: {}; background: object; clipCenter: object; clipNear: object; clipRadius: object; depthWrite: object; diffuse: object; diffuseInterior: object; flatShaded: object; interiorColor: object; interiorDarkening: object; metalness: object; opacity: object; opaqueBack: object; roughness: object; side: object; useInteriorColor: object; wireframe: object } = Object.assign({linewidth: { uniform: true }}, BufferParameterTypes)

Const X

X: Elements[] = [ Elements.N, Elements.O, Elements.S ]

Const Y

Y: Elements[] = [ Elements.C, Elements.N, Elements.P, Elements.S ]

Const ZERO

ZERO: 0 = 0

Const _m

_m: Matrix4 = new Matrix4()

Const _tmpBytes

_tmpBytes: Uint8Array = new Uint8Array(32)

Const _tmpIntBytes

_tmpIntBytes: Int32Array = new Int32Array(32)

Const _v

_v: Vector3 = new Vector3()

Const amberChargeUnitFactor

amberChargeUnitFactor: 18.2223 = 18.2223

Const aminoacids

aminoacids: "ARNDCQEGHILKMFPSTWYVBZX" = "ARNDCQEGHILKMFPSTWYVBZX"

Const aminoacidsX

aminoacidsX: "ACDEFGHIKLMNPQRSTVWY" = "ACDEFGHIKLMNPQRSTVWY"

Const baseUrl

baseUrl: "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/" = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/"

Const blosum62

blosum62: number[][] = [// A R N D C Q E G H I L K M F P S T W Y V B Z X[4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0, -2, -1, 0], // A[-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3, -1, 0, -1], // R[-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3, 3, 0, -1], // N[-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3, 4, 1, -1], // D[0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1, -3, -3, -2], // C[-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2, 0, 3, -1], // Q[-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2, 1, 4, -1], // E[0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3, -1, -2, -1], // G[-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3, 0, 0, -1], // H[-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3, -3, -3, -1], // I[-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1, -4, -3, -1], // L[-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2, 0, 1, -1], // K[-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1, -3, -1, -1], // M[-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1, -3, -3, -1], // F[-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2, -2, -1, -2], // P[1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2, 0, 0, 0], // S[0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0, -1, -1, 0], // T[-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3, -4, -3, -2], // W[-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1, -3, -2, -1], // Y[0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4, -3, -2, -1], // V[-2, -1, 3, 4, -3, 0, 1, -1, 0, -3, -4, 0, -3, -3, -2, 0, -1, -4, -3, -3, 4, 1, -1], // B[-1, 0, 0, 1, -3, 3, 4, -2, 0, -3, -3, 1, -1, -3, -1, 0, -1, -3, -2, -2, 1, 4, -1], // Z[0, -1, -1, -1, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, 0, 0, -2, -1, -1, -1, -1, -1] // X]

Const blosum62x

blosum62x: number[][] = [[4, 0, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2], // A[0, 9, -3, -4, -2, -3, -3, -1, -3, -1, -1, -3, -3, -3, -3, -1, -1, -1, -2, -2], // C[-2, -3, 6, 2, -3, -1, -1, -3, -1, -4, -3, 1, -1, 0, -2, 0, -1, -3, -4, -3], // D[-1, -4, 2, 5, -3, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -3, -2], // E[-2, -2, -3, -3, 6, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 1, 3], // F[0, -3, -1, -2, -3, 6, -2, -4, -2, -4, -3, 0, -2, -2, -2, 0, -2, -3, -2, -3], // G[-2, -3, -1, 0, -1, -2, 8, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2], // H[-1, -1, -3, -3, 0, -4, -3, 4, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -3, -1], // I[-1, -3, -1, 1, -3, -2, -1, -3, 5, -2, -1, 0, -1, 1, 2, 0, -1, -2, -3, -2], // K[-1, -1, -4, -3, 0, -4, -3, 2, -2, 4, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1], // L[-1, -1, -3, -2, 0, -3, -2, 1, -1, 2, 5, -2, -2, 0, -1, -1, -1, 1, -1, -1], // M[-2, -3, 1, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2], // N[-1, -3, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 7, -1, -2, -1, -1, -2, -4, -3], // P[-1, -3, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 5, 1, 0, -1, -2, -2, -1], // Q[-1, -3, -2, 0, -3, -2, 0, -3, 2, -2, -1, 0, -2, 1, 5, -1, -1, -3, -3, -2], // R[1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2], // S[0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -2, -2], // T[0, -1, -3, -2, -1, -3, -3, 3, -2, 1, 1, -3, -2, -2, -3, -2, 0, 4, -3, -1], // V[-3, -2, -4, -3, 1, -2, -2, -3, -3, -2, -1, -4, -4, -2, -3, -3, -2, -3, 11, 2], // W[-2, -2, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 7] // Y]

Const bohrToAngstromFactor

bohrToAngstromFactor: 0.529177210859 = 0.529177210859

Const calculateSecondaryStructure

calculateSecondaryStructure: calculateSecondaryStructure = (function () {// Implementation for proteins based on "pv"//// assigns secondary structure information based on a simple and very fast// algorithm published by Zhang and Skolnick in their TM-align paper.// Reference://// TM-align: a protein structure alignment algorithm based on the Tm-score// (2005) NAR, 33(7) 2302-2309const zhangSkolnickSS = function (polymer: Polymer, i: number, distances: number[], delta: number) {const structure = polymer.structureconst offset = polymer.residueIndexStartconst rp1 = structure.getResidueProxy()const rp2 = structure.getResidueProxy()const ap1 = structure.getAtomProxy()const ap2 = structure.getAtomProxy()for (let j = Math.max(0, i - 2); j <= i; ++j) {for (let k = 2; k < 5; ++k) {if (j + k >= polymer.residueCount) {continue}rp1.index = offset + jrp2.index = offset + j + kap1.index = rp1.traceAtomIndexap2.index = rp2.traceAtomIndexconst d = ap1.distanceTo(ap2)if (Math.abs(d - distances[k - 2]) > delta) {return false}}}return true}const isHelical = function (polymer: Polymer, i: number) {const helixDistances = [5.45, 5.18, 6.37]const helixDelta = 2.1return zhangSkolnickSS(polymer, i, helixDistances, helixDelta)}const isSheet = function (polymer: Polymer, i: number) {const sheetDistances = [6.1, 10.4, 13.0]const sheetDelta = 1.42return zhangSkolnickSS(polymer, i, sheetDistances, sheetDelta)}const proteinPolymer = function (p: Polymer) {const residueStore = p.residueStoreconst offset = p.residueIndexStartfor (let i = 0, il = p.residueCount; i < il; ++i) {let sstruc = 'c'if (isHelical(p, i)) {sstruc = 'h'} else if (isSheet(p, i)) {sstruc = 'e'}residueStore.sstruc[offset + i] = sstruc.charCodeAt(0)}}const cgPolymer = function (p: Polymer) {const localAngle = 20const centerDist = 2.0const residueStore = p.residueStoreconst offset = p.residueIndexStartconst helixbundle = new Helixbundle(p)const pos = helixbundle.positionconst c1 = new Vector3()const c2 = new Vector3()for (let i = 0, il = p.residueCount; i < il; ++i) {c1.fromArray(pos.center as any, i * 3) // TODOc2.fromArray(pos.center as any, i * 3 + 3) // TODOconst d = c1.distanceTo(c2)if (d < centerDist && d > 1.0 && pos.bending[i] < localAngle) {residueStore.sstruc[offset + i] = 'h'.charCodeAt(0)residueStore.sstruc[offset + i + 1] = 'h'.charCodeAt(0)}}}return function calculateSecondaryStructure(structure: Structure) {if (Debug) Log.time('calculateSecondaryStructure')structure.eachPolymer(function (p) {// assign secondary structure//if (p.residueCount < 4) returnif (p.isCg()) {cgPolymer(p)} else if (p.isProtein()) {proteinPolymer(p)} else {return}// set lone secondary structure assignments to "c"let prevSstruc: stringlet sstrucCount = 0p.eachResidue(function (r: ResidueProxy) {if (r.sstruc === prevSstruc) {sstrucCount += 1} else {if (sstrucCount === 1) {r.index -= 1r.sstruc = 'c'}sstrucCount = 1prevSstruc = r.sstruc}})})if (Debug) Log.timeEnd('calculateSecondaryStructure')}}())

Const charArray

charArray: string[] = []

Const charmmTimeUnitFactor

charmmTimeUnitFactor: 20.45482949774598 = 20.45482949774598

Const chars

chars: string[] = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')

Const dAminoAcids

dAminoAcids: string[] = ['DAL', // D-ALANINE'DAR', // D-ARGININE'DSG', // D-ASPARAGINE'DAS', // D-ASPARTIC ACID'DCY', // D-CYSTEINE'DGL', // D-GLUTAMIC ACID'DGN', // D-GLUTAMINE'DHI', // D-HISTIDINE'DIL', // D-ISOLEUCINE'DLE', // D-LEUCINE'DLY', // D-LYSINE'MED', // D-METHIONINE'DPN', // D-PHENYLALANINE'DPR', // D-PROLINE'DSN', // D-SERINE'DTH', // D-THREONINE'DTR', // D-TRYPTOPHAN'DTY', // D-TYROSINE'DVA', // D-VALINE'DNE' // D-NORLEUCINE// ??? // D-SELENOCYSTEINE]

Const dataSourceStorageRelativePath

dataSourceStorageRelativePath: string = "dist/catana_data/"

Const defaultByteLength

defaultByteLength: number = 1024 * 8

Const ednaFull

ednaFull: number[][] = [// A T G C S W R Y K M B V H D N X U[5, -4, -4, -4, -4, 1, 1, -4, -4, 1, -4, -1, -1, -1, -2, -15, -4], // A[-4, 5, -4, -4, -4, 1, -4, 1, 1, -4, -1, -4, -1, -1, -2, -15, -4], // T[-4, -4, 5, -4, 1, -4, 1, -4, 1, -4, -1, -1, -4, -1, -2, -15, -4], // G[-4, -4, -4, 5, 1, -4, -4, 1, -4, 1, -1, -1, -1, -4, -2, -15, -4], // C[-4, -4, 1, 1, -1, -4, -2, -2, -2, -2, -1, -1, -3, -3, -1, -15, -4], // S[1, 1, -4, -4, -4, -1, -2, -2, -2, -2, -3, -3, -1, -1, -1, -15, 1], // W[1, -4, 1, -4, -2, -2, -1, -4, -2, -2, -3, -1, -3, -1, -1, -15, -4], // R[-4, 1, -4, 1, -2, -2, -4, -1, -2, -2, -1, -3, -1, -3, -1, -15, 1], // Y[-4, 1, 1, -4, -2, -2, -2, -2, -1, -4, -1, -3, -3, -1, -1, -15, 1], // K[1, -4, -4, 1, -2, -2, -2, -2, -4, -1, -3, -1, -1, -3, -1, -15, -4], // M[-4, -1, -1, -1, -1, -3, -3, -1, -1, -3, -1, -2, -2, -2, -1, -15, -1], // B[-1, -4, -1, -1, -1, -3, -1, -3, -3, -1, -2, -1, -2, -2, -1, -15, -4], // V[-1, -1, -4, -1, -3, -1, -3, -1, -3, -1, -2, -2, -1, -2, -1, -15, -1], // H[-1, -1, -1, -4, -3, -1, -1, -3, -1, -3, -2, -2, -2, -1, -1, -15, -1], // D[-2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -15, -2], // N[-15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -5, -15], // X[-4, -4, -4, -4, -4, 1, -4, 1, 1, -4, -1, -4, -1, -1, -2, -15, 5], // U]

Const elm1

elm1: string[] = ['H', 'C', 'O', 'N', 'S', 'P']

Const elm2

elm2: string[] = ['NA', 'CL', 'FE']

Const entityKeyList

entityKeyList: string[] = ['MOL_ID', 'MOLECULE', 'CHAIN', 'FRAGMENT', 'SYNONYM','EC', 'ENGINEERED', 'MUTATION', 'OTHER_DETAILS']

Const eye

eye: Vector3 = new Vector3(0, 0, 0)

Const halBondElements

halBondElements: number[] = [17, 35, 53, 85]

Const mapping

mapping: Float32Array = new Float32Array([-1.0, -1.0, -1.0,1.0, -1.0, -1.0,1.0, -1.0, 1.0,-1.0, -1.0, 1.0,-1.0, 1.0, -1.0,1.0, 1.0, -1.0,1.0, 1.0, 1.0,-1.0, 1.0, 1.0])

Const mappingIndices

mappingIndices: Uint16Array = new Uint16Array([0, 1, 2,0, 2, 3,1, 5, 6,1, 6, 2,4, 6, 5,4, 7, 6,0, 7, 4,0, 3, 7,0, 5, 1,0, 4, 5,3, 2, 6,3, 6, 7])

Const matrix

matrix: Matrix4 = new Matrix4()

Const maxRadius

maxRadius: 12 = 12

Const mmtfBaseUrl

mmtfBaseUrl: "//mmtf.rcsb.org/v1.0/" = "//mmtf.rcsb.org/v1.0/"

Const mmtfFullUrl

mmtfFullUrl: string = mmtfBaseUrl + 'full/'

Const mmtfReducedUrl

mmtfReducedUrl: string = mmtfBaseUrl + 'reduced/'

Const modelViewProjectionMatrix

modelViewProjectionMatrix: Matrix4 = new Matrix4()

Const nHBondDistance

nHBondDistance: 1.04 = 1.04

Const nHCharge

nHCharge: 0.25 = 0.25

Const negateVector

negateVector: Vector3 = new Vector3(-1, -1, -1)

Const normalMatrix

normalMatrix: Matrix3 = new Matrix3()

Const nucleotides

nucleotides: "ATGCSWRYKMBVHDNX" = "ATGCSWRYKMBVHDNX"

Const oxDnaUnitsToAngst

oxDnaUnitsToAngst: 8.518 = 8.518

Multiplier to use when converting from oxDNA units to Angstroms

Const passive

passive: false | { passive: boolean } = SupportsPassiveEventHandler ? { passive: true } : false

Const pixelBufferFloat

pixelBufferFloat: Float32Array = new Float32Array(4 * 25)

Const pixelBufferUint

pixelBufferUint: Uint8Array = new Uint8Array(4 * 25)

Const pixelOrder

pixelOrder: number[] = [12, 7, 13, 17, 11, 6, 8, 18, 16, 2, 14, 22, 10, 1, 3, 9, 19, 23, 21, 15, 5, 0, 4, 24, 20]

Const pointArray

pointArray: Float32Array = new Float32Array(3)

Const pointLength

pointLength: 3 = 3

Const pointsInTriangle

pointsInTriangle: 3 = 3

Const projectionMatrixInverse

projectionMatrixInverse: Matrix4 = new Matrix4()

Const projectionMatrixTranspose

projectionMatrixTranspose: Matrix4 = new Matrix4()

Const quadIndices

quadIndices: Uint16Array = new Uint16Array([0, 1, 2,1, 3, 2])

Const quadUvs

quadUvs: Float32Array = new Float32Array([0, 1,0, 0,1, 1,1, 0])

Const reAttr

reAttr: RegExp = /([\w:-]+)\s*=\s*("[^"]*"|'[^']*'|\w+)\s*/

Const reCollapseEqual

reCollapseEqual: RegExp = /\s*=\s*/g

Const reContent

reContent: RegExp = /^([^<]*)/

Const reCurlyWhitespace

reCurlyWhitespace: RegExp = /[^{}\s]*{[^{}]+}|[^{}\s]+/g

Const reDoubleQuote

reDoubleQuote: RegExp = /"/g

Const reField

reField: RegExp = /\[ (.+) \]/

Const reInclude

reInclude: RegExp = /^(?!\/\/)\s*#include\s+(\S+)/gmi

Const reInteger

reInteger: RegExp = /^[1-9]$/

Const reItem

reItem: RegExp = /> +<(.+)>/

Const reProtocol

reProtocol: RegExp = /^((http|https|ftp):)*\/\//

Const reQuotedWhitespace

reQuotedWhitespace: RegExp = /'((?:(?!'\s).)*)'|"((?:(?!"\s).)*)"|(\S+)/g

Const reScientificNotation

reScientificNotation: RegExp = /-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?/g

Const reStrip

reStrip: RegExp = /^['"]|['"]$/g

Const reTag

reTag: RegExp = /^<([\w-:.]+)\s*/

Const reTitle

reTitle: RegExp = /(^\*|REMARK)*/

Const reTrimCurly

reTrimCurly: RegExp = /^{+|}+$/g

Const reTrimQuotes

reTrimQuotes: RegExp = /^['"]+|['"]+$/g

Const reWhitespace

reWhitespace: RegExp = /\s+/

Const reWhitespaceComma

reWhitespaceComma: RegExp = /[\s,]+/

Const resolution

resolution: Vector2 = new Vector2()

Const scale

scale: Vector3 = new Vector3()

Const shaderCache

shaderCache: {}

Type declaration

  • [k: string]: string

Const suffixUrl

suffixUrl: "/SDF?record_type=3d" = "/SDF?record_type=3d"

Const swap

  • swap(A: NumberArray, i0: number, i1: number, t: number): void

Const target

target: Vector3 = new Vector3()

Const temp

temp: Float32Array = new Float32Array(4)

Const tmpAlignMatrix

tmpAlignMatrix: Matrix4 = new Matrix4()

Const tmpAtomVector

tmpAtomVector: Vector3 = new Vector3()

Const tmpBox

tmpBox: Box3 = new Box3()

Const tmpCanvasVector

tmpCanvasVector: Vector3 = new Vector3()

Const tmpColor

tmpColor: Color = new Color()

Const tmpMatrix

tmpMatrix: Matrix4 = new Matrix4()

Const tmpP

tmpP: Vector3 = new Vector3()

Const tmpPanMatrix

tmpPanMatrix: Matrix4 = new Matrix4()

Const tmpPanVector

tmpPanVector: Vector3 = new Vector3()

Const tmpQ

tmpQ: Quaternion = new Quaternion()

Orientation matrix, a 4x4 transformation matrix with rotation part used for scene rotation, scale part for scene camera distance and position part for scene translation

Const tmpRotateCameraMatrix

tmpRotateCameraMatrix: Matrix4 = new Matrix4()

Const tmpRotateMatrix

tmpRotateMatrix: Matrix4 = new Matrix4()

Const tmpRotateQuaternion

tmpRotateQuaternion: Quaternion = new Quaternion()

Const tmpRotateQuaternion2

tmpRotateQuaternion2: Quaternion = new Quaternion()

Const tmpRotateVector

tmpRotateVector: Vector3 = new Vector3()

Const tmpRotateXMatrix

tmpRotateXMatrix: Matrix4 = new Matrix4()

Const tmpRotateYMatrix

tmpRotateYMatrix: Matrix4 = new Matrix4()

Const tmpRotateZMatrix

tmpRotateZMatrix: Matrix4 = new Matrix4()

Const tmpS

tmpS: Vector3 = new Vector3()

Const tmpScaleVector

tmpScaleVector: Vector3 = new Vector3()

Const tmpVec

tmpVec: Vector3 = new Vector3()

Const tmpZoomVector

tmpZoomVector: Vector3 = new Vector3()

Const up

up: Vector3 = new Vector3()

Const url

url: "https://alphafill.eu/v1/aff/" = "https://alphafill.eu/v1/aff/"

Const urlHead

urlHead: "https://alphafold.ebi.ac.uk/files/AF-" = "https://alphafold.ebi.ac.uk/files/AF-"

Const urlTail

urlTail: "-F1-model_v2.pdb" = "-F1-model_v2.pdb"

Const uuid

uuid: any[] = new Array(36)

Const vMeshNormal

vMeshNormal: Vector3 = new Vector3()

Const vTangent

vTangent: Vector3 = new Vector3()

Const vertex

vertex: Vector3 = new Vector3()

Functions

AVSurface

  • AVSurface(this: AVSurface, coordList: Float32Array, radiusList: Float32Array, indexList: Uint16Array | Uint32Array): void

AccessorInfluencesAtomData

  • AccessorInfluencesAtomData(getStructure: (target: any) => CgStructure | undefined): (Anonymous function)

  • This accessor decorator sets coarse-grained structure's dirty flag to true every time the property setter is used.

    Parameters

    • getStructure: (target: any) => CgStructure | undefined

      callback describing how to access the CgStructure reference from the instance of caller

    Returns (Anonymous function)

    property descriptor function

EDTSurface

  • EDTSurface(this: EDTSurface, coordList: Float32Array, radiusList: Float32Array, indexList: Uint16Array | Uint32Array): void

JacobiSVDImpl

MarchingCubes

  • MarchingCubes(this: MarchingCubes, field: number[], nx: number, ny: number, nz: number, atomindex: number[]): void

MethodInfluencesAtomData

  • MethodInfluencesAtomData(getStructure: (target: any) => CgStructure | undefined): (Anonymous function)

  • This function decorator sets coarse-grained structure's dirty flag to true every time it is executed.

    Parameters

    • getStructure: (target: any) => CgStructure | undefined

      callback describing how to access the CgStructure reference from the instance of caller

    Returns (Anonymous function)

    property descriptor function

RingFinderState

ValenceModel

  • ValenceModel(data: Data, params: ValenceModelParams): { charge: Int8Array; idealGeometry: Int8Array; implicitH: Int8Array; totalH: Int8Array }

VolumeSurface

_ensureClassFromArg

  • _ensureClassFromArg(arg: any, constructor: { constructor: any }): any

_ensureClassFromArray

  • _ensureClassFromArray(array: any, constructor: { constructor: any }): any

_getComplementaryBaseCore

_permutateRecursive

  • _permutateRecursive<Type>(sourceIndex: number, dataArray: Type[], resultingArray: Type[][], currentData: Type[], remainingLength: number): void

_trimCanvas

  • _trimCanvas(canvas: HTMLCanvasElement, r: number, g: number, b: number, a: number): HTMLCanvasElement

addAromaticRings

addAtom

addChargedContacts

addCols

  • addCols(A: Matrix, col: number[]): void

addComponentFromSequence

  • addComponentFromSequence(sequence: string, stage: Stage, params?: Partial<{ compType: "dna" | "protein" | "unknown"; dnaDoubleStranded: boolean }>): Component | undefined

  • Based on the given FASTA sequence, create a new component that has this sequence

    Parameters

    • sequence: string

      The sequence that defines the component to be created. The type of component is auto-detected from the sequence if not overriden by the parameters.

    • stage: Stage

      stage instance

    • Default value params: Partial<{ compType: "dna" | "protein" | "unknown"; dnaDoubleStranded: boolean }> = {}

      parameters providing additional information to the function

    Returns Component | undefined

    true if the component was successfully added, false otherwise

addElement

  • addElement(elm: any, array: any[]): void

addFeature

addHalogenAcceptors

addHalogenBonds

addHalogenDonors

addHydrogenAcceptors

addHydrogenBonds

addHydrogenDonors

addHydrophobic

addHydrophobicContacts

addMetalBinding

addMetalComplexation

addMetals

addNegativeCharges

addPositiveCharges

addRing

addRows

  • addRows(A: Matrix, row: number[]): void

addWeakHydrogenDonors

almostIdentity

  • almostIdentity(value: number, start: number, stop: number): number

aminoAcidTypeToThreeLetterCode

appendAnyStructureComps

appendCgStructures

appendCgStructuresShallow

  • Appends given structure to the parent structure, by changing parent reference of polymers from the structure being appended.

    Parameters

    • parentStructure: CgStructure

      structure to which to append

    • structureToAppend: CgStructure

      Structure to be appended. May contain invalid data after the operation!

    • Optional appendedStructureTransformation: Matrix4

      transformation of the structure to append

    Returns CgStructure

    reference to parentStructure storing polymers from both structures

appendComponentsContainingStructure

  • Appends all-atom structure from one component to all-atom structure from another component.

    Parameters

    • stage: Stage

      stage instance

    • parentStructureComp: Component

      structure to which the other one will be appended -- will be modified

    • structureCompToAppend: Component

      structure to be appended

    • compToStruc: (comp: Component) => Structure

      callback providing reference to structure from provided component

    • parentUpdateCallback: (comp: Component) => void

      function to be called on the {@link parentStructureComp} after the operation

    • Default value removeAppended: boolean = true

      if set to true, the {@link structureCompToAppend} will be removed after the operation

    Returns void

appendResidueToChainManual

  • appendResidueToChainManual(targetStructure: Structure, chainIndex: number, structureWithResToAppend: Structure, appendToChainEnd?: "C" | "N", transformationOfNewResidue: Matrix4, transformationOfNewResidueInverse?: Matrix4, resToAppendNameOverride?: string | undefined, removeHydrogensFromAppendedResidue?: boolean, finalizeBonds?: boolean): Structure

  • Appends given residue to the given chain. Expects to be provided with the desired position and orientation of the new residue. Does not do any removal of atoms automatically (like H2O when peptide bond is created).

    Parameters

    • targetStructure: Structure

      structure to be modified

    • chainIndex: number

      chain to be appended to

    • structureWithResToAppend: Structure

      structure containing the residue to append

    • Default value appendToChainEnd: "C" | "N" = "C"

      chain end (N ~ 5', C ~ 3') to be appended to (determines the placement of a residue in the data structures).

    • transformationOfNewResidue: Matrix4
    • Optional transformationOfNewResidueInverse: Matrix4
    • Default value resToAppendNameOverride: string | undefined = undefined

      name of the newly appended residue

    • Default value removeHydrogensFromAppendedResidue: boolean = true

      determines whether to remove hydrogen atoms from the added residue

    • Default value finalizeBonds: boolean = true

    Returns Structure

appendResiduesToChain

  • appendResiduesToChain(targetStructure: Structure, chainIndex: number, structureWithResToAppend: Structure, appendToChainEnd?: "C" | "N", duplicatesToAppend?: number, resToAppendNameOverride?: string | undefined, removeHydrogensFromAppendedResidue?: boolean, direction?: Vector3): Structure

  • Appends n residues to the C-term or N-term of the desired chain. An important feature of this function is that it tries to preserve the consecutivity of neighboring chains/residues/atoms, i.e., they should still be stored sequentially. Automatically removes corresponding H20 atoms from appended residues.

    Parameters

    • targetStructure: Structure

      structure to be extended with new residues

    • chainIndex: number

      chain to which the residues should be appended

    • structureWithResToAppend: Structure

      structure containing the residue (only one!) to append

    • Default value appendToChainEnd: "C" | "N" = "C"

      chain end to append to (determines 3D coordinates of atoms & placement in data structures)

    • Default value duplicatesToAppend: number = 1

      how many residues to append

    • Default value resToAppendNameOverride: string | undefined = undefined

      the name of new residue (if not set, default name will be used)

    • Default value removeHydrogensFromAppendedResidue: boolean = true

      determines whether all hydrogen (H) atoms should be removed from appended residue

    • Optional direction: Vector3

      direction to which to add the residues

    Returns Structure

appendStructureComponents

  • Appends all-atom structure from one component to all-atom structure from another component

    Parameters

    • stage: Stage

      stage instance

    • parentStructureComp: StructureComponent

      structure (component) to append to

    • structureCompToAppend: StructureComponent

      structure (component) to be appended

    • Default value removeAppended: boolean = true

      if set to true, {@link structureCompToAppend} will be removed after the operation

    Returns void

appendStructures

  • appendStructures(parentStructure: Structure, structureToAppend: Structure, appendedAtomsTransformation?: Matrix4 | undefined): Structure

applyMatrix3toVector3array

  • applyMatrix3toVector3array(m: Float32Array, a: Float32Array): void

applyMatrix4toVector3array

  • applyMatrix4toVector3array(m: Float32Array, a: Float32Array): void

applySuggestion

  • applySuggestion(suggestion: string, filterStr: string): string

arrayMax

arrayMean

  • arrayMean(array: NumberArray, stride?: number, offset?: number): number

arrayMean3

arrayMin

arrayRms

arraySorted

arraySortedCmp

  • arraySortedCmp<T>(array: NumberArray | T[], cmp: (a: number | T, b: number | T) => number): boolean

  • Type parameters

    • T

    Parameters

    • array: NumberArray | T[]
    • cmp: (a: number | T, b: number | T) => number
        • (a: number | T, b: number | T): number

        • Parameters

          • a: number | T
          • b: number | T

          Returns number

    Returns boolean

arraySum

  • arraySum(array: NumberArray, stride?: number, offset?: number): number

assignAtomsToResidue

  • assignAtomsToResidue(targetStructure: Structure, newResidueIndex: number, sourceResidueWithAtoms: ResidueProxy): void

assignGeometry

assignResidueTypeBonds

  • assignResidueTypeBonds(structure: Structure): void

assignSecondaryStructure

atomTestFn

atomTriplePositions

  • atomTriplePositions(sview: StructureView, atomTriple: (string | number)[][]): Float32Array

autoDetectBasePairs

  • autoDetectBasePairs(cgStructure: CgStructure, replaceExisting?: boolean): void

  • This function automatically detects & assigns potential base-pairs. The detection currently considers only valid canonical Watson-Crick pairs.

    Parameters

    • cgStructure: CgStructure

      structure inside which the base-detection should happen

    • Default value replaceExisting: boolean = false

      if set to true, existing base-pairs will be influenced (i.e., they might get removed)

    Returns void

autoLoad

  • Load a file

    example

    // load from URL NGL.autoLoad( "http://files.rcsb.org/download/5IOS.cif" );

    example

    // load binary data in CCP4 format via a Blob var binaryBlob = new Blob( [ ccp4Data ], { type: 'application/octet-binary'} ); NGL.autoLoad( binaryBlob, { ext: "ccp4" } );

    example

    // load string data in PDB format via a Blob var stringBlob = new Blob( [ pdbData ], { type: 'text/plain'} ); NGL.autoLoad( stringBlob, { ext: "pdb" } );

    example

    // load a File object NGL.autoLoad( file );

    Parameters

    Returns any

    Promise resolves to the loaded data

backboneNHPosition

  • backboneNHPosition(ap: AtomProxy, position?: Vector3): undefined | Vector3

  • Populates position vector with location of implicit or explicit H Returns position or undefined if not able to locate H

    Parameters

    • ap: AtomProxy

      the nitrogen atom

    • Default value position: Vector3 = new Vector3()

    Returns undefined | Vector3

    the hydrogen atom position

binarySearchForLeftRange

  • binarySearchForLeftRange(array: number[], leftRange: number): number

binarySearchForRightRange

  • binarySearchForRightRange(array: number[], rightRange: number): number

binarySearchIndexOf

  • Does a binary search to get the index of an element in the input array

    function
    example

    var array = [ 1, 2, 3, 4, 5, 6 ]; var element = 4; binarySearchIndexOf( array, element ); // returns 3

    Type parameters

    • T

    Parameters

    • array: T[]

      sorted array

    • element: T

      element to search for in the array

    • Default value compareFunction: lexicographicCompare = lexicographicCompare

    Returns number

    the index of the element or -1 if not in the array

boolean

  • boolean(value: any): boolean

buildStoreLike

  • buildStoreLike(positions: Vector3[]): { count: number; x: Float32Array; y: Float32Array; z: Float32Array }

  • Takes an array of Vector3 objects and converts to an object that looks like an AtomStore

    Parameters

    • positions: Vector3[]

      array of positions

    Returns { count: number; x: Float32Array; y: Float32Array; z: Float32Array }

    AtomStore-like object

    • count: number
    • x: Float32Array
    • y: Float32Array
    • z: Float32Array

buildUnitcellAssembly

  • buildUnitcellAssembly(structure: Structure): void

calcAngles

calcArcPoint

  • calcArcPoint(out: Float32Array, center: Float32Array, v1: Float32Array, v2: Float32Array, angle: number): void

calcPlaneAngle

  • Find two neighbours of ap1 to define a plane (if possible) and measure angle out of plane to ap2

    Parameters

    Returns number | undefined

    Angle from plane to second atom

calculateAtomBondMap

  • calculateAtomBondMap(structure: Structure): number[][]

calculateBonds

calculateBondsBetween

  • calculateBondsBetween(structure: Structure, onlyAddBackbone?: boolean, useExistingBonds?: boolean): void

calculateBondsWithin

  • calculateBondsWithin(structure: Structure, onlyAddRung?: boolean): void

calculateCenterArray

calculateChainnames

  • calculateChainnames(structure: Structure, useExistingBonds?: boolean): void

calculateContacts

  • calculateContacts(structure: Structure, params?: { lineOfSightDistFactor: number; masterModelIndex: number; maxCationPiDist: number; maxCationPiOffset: number; maxHalogenBondAngle: number; maxHalogenBondDist: number; maxHbondAccAngle: number; maxHbondAccPlaneAngle: number; maxHbondDist: number; maxHbondDonAngle: number; maxHbondDonPlaneAngle: number; maxHbondSulfurDist: number; maxHydrophobicDist: number; maxIonicDist: number; maxMetalDist: number; maxPiStackingAngle: number; maxPiStackingDist: number; maxPiStackingOffset: number; refineSaltBridges: boolean }): FrozenContacts

  • Parameters

    • structure: Structure
    • Default value params: { lineOfSightDistFactor: number; masterModelIndex: number; maxCationPiDist: number; maxCationPiOffset: number; maxHalogenBondAngle: number; maxHalogenBondDist: number; maxHbondAccAngle: number; maxHbondAccPlaneAngle: number; maxHbondDist: number; maxHbondDonAngle: number; maxHbondDonPlaneAngle: number; maxHbondSulfurDist: number; maxHydrophobicDist: number; maxIonicDist: number; maxMetalDist: number; maxPiStackingAngle: number; maxPiStackingDist: number; maxPiStackingOffset: number; refineSaltBridges: boolean } = ContactDefaultParams
      • lineOfSightDistFactor: number
      • masterModelIndex: number
      • maxCationPiDist: number
      • maxCationPiOffset: number
      • maxHalogenBondAngle: number
      • maxHalogenBondDist: number
      • maxHbondAccAngle: number
      • maxHbondAccPlaneAngle: number
      • maxHbondDist: number
      • maxHbondDonAngle: number
      • maxHbondDonPlaneAngle: number
      • maxHbondSulfurDist: number
      • maxHydrophobicDist: number
      • maxIonicDist: number
      • maxMetalDist: number
      • maxPiStackingAngle: number
      • maxPiStackingDist: number
      • maxPiStackingOffset: number
      • refineSaltBridges: boolean

    Returns FrozenContacts

calculateDihedralHistogram

  • calculateDihedralHistogram(histogramData: HistogramData): undefined | { adjacentBondArrows: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; backHistogram: { triangleColors: Float32Array; triangles: Float32Array }; backHistogramBinBorders: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; distantBondArrows: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; frontHistogram: { triangleColors: Float32Array; triangles: Float32Array }; frontHistogramBinBorders: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; opaqueMiddleDisc: { triangleColors: Float32Array; triangles: Float32Array } }

  • Calculates the data required to create {Buffer} objects for one histogram, given positions

    Parameters

    Returns undefined | { adjacentBondArrows: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; backHistogram: { triangleColors: Float32Array; triangles: Float32Array }; backHistogramBinBorders: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; distantBondArrows: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; frontHistogram: { triangleColors: Float32Array; triangles: Float32Array }; frontHistogramBinBorders: { endColors: Float32Array; endPoints: Float32Array; startColors: Float32Array; startPoints: Float32Array }; opaqueMiddleDisc: { triangleColors: Float32Array; triangles: Float32Array } }

    Arrays for building buffers

calculateDirectionArray

calculateFeatures

calculateHydrogensCharge

calculateMeanArray

calculateMeanVector3

calculateMinArray

calculateResidueBonds

  • calculateResidueBonds(r: ResidueProxy): { atomIndices1: number[]; atomIndices2: number[]; bondOrders: number[] }

centerArray3

  • centerArray3(array: NumberArray, center?: Vector3): Vector3

centerPbc

  • centerPbc(coords: NumberArray, mean: number[], box: ArrayLike<number>): void

cgMonomerTestFn

chainTestFn

chargeForAtom

checkProteinBasedAlignment

cifDefaults

  • cifDefaults(value: string, defaultValue: string): string

circularMean

  • circularMean(array: NumberArray, max: number, stride?: number, offset?: number, indices?: NumberArray): number

circularMean3

clamp

  • clamp(value: number, min: number, max: number): number

closer

  • closer(x: Vector3, a: Vector3, b: Vector3): boolean

computeBaseHydrogenFaceDir

  • Computes the direction of the nucleotide's hydrogen face (follows the computation described in the UNF format documentation). This direction is similar to the Y-axis as defined by the standard reference frame for nucleotides (e.g., in 3DNA).

    throws

    Error if atoms necessary for the computation were not found

    Parameters

    Returns Vector3

    hydrogen face direction vector

computeBaseNormal

  • Computes the normal of the base plane (follows the computation described in the UNF format documentation). The normal is similar to the Z-axis as defined by the standard reference frame for nucleotides (e.g., in 3DNA).

    throws

    Error if atoms necessary for the computation were not found

    Parameters

    Returns Vector3

    base normal vector

computeBaseShortAxis

  • Computes the base's short axis (follows the computation described in the UNF format documentation). This direction is similar to the X-axis as defined by the standard reference frame for nucleotides (e.g., in 3DNA).

    throws

    Error if atoms necessary for the computation were not found

    Parameters

    Returns Vector3

    base short axis vector

computeBoundingBox

  • computeBoundingBox(array: NumberArray): Float32Array[]

computeHelicalAxis

computeVertexNormals

  • computeVertexNormals(position: Float32Array, index?: NumberArray, normal?: Float32Array): Float32Array

concatStructures

contactColor

contactTypeName

  • contactTypeName(type: ContactType): "hydrogen bond" | "hydrophobic contact" | "halogen bond" | "ionic interaction" | "metal coordination" | "cation-pi interaction" | "pi-pi stacking" | "weak hydrogen bond" | "unknown contact"

convertAaStrucCompToCgStrucComp

convertAllAtomStructureToCoarseGrained

convertCgStrucCompToAaStrucComp

convertKinTriangleArrays

  • convertKinTriangleArrays(ribbonObject: RibbonObject): { breakArray: boolean[]; colorArray: number[]; labelArray: string[]; masterArray: any[]; name: undefined | string; positionArray: number[] }

  • Parameters

    Returns { breakArray: boolean[]; colorArray: number[]; labelArray: string[]; masterArray: any[]; name: undefined | string; positionArray: number[] }

    • breakArray: boolean[]
    • colorArray: number[]
    • labelArray: string[]
    • masterArray: any[]
    • name: undefined | string
    • positionArray: number[]

copyArray

  • copyArray<T>(src: T, dst: T, srcOffset: number, dstOffset: number, length: number): void

copyWithin

  • copyWithin(array: NumberArray | any[], srcOffset: number, dstOffset: number, length: number): void

countSetBits

  • countSetBits(i: number): number

createAdjacencyList

createBoundingBox

  • createBoundingBox(box?: Box3): LineSegments<BufferGeometry, ShaderMaterial>

createColorArray

  • createColorArray(color: ColorDefinition, arrayLength: number): Float32Array

createContacts

createData

createFeatureState

createFeatures

createFrozenContacts

createParams

  • createParams<T>(params: {}, defaultParams: T): T

Private createProgram

  • createProgram(gl: WebGLRenderingContext, shaders: WebGLShader[], attribs?: string[], locations?: number[]): undefined | null | WebGLProgram

createRingBuffer

  • createRingBuffer<T>(length: number): RingBuffer<T>

createSimpleDict

createSimpleSet

createUpdatedObject

  • createUpdatedObject(o: Object, updateSource: Object): {}

dataURItoImage

  • dataURItoImage(dataURI: string): HTMLImageElement

decodeBits

  • decodeBits(buf: Int32Array, cbuf: Uint8Array, numOfBits: number, buf2: Uint32Array): number

decodeInts

  • decodeInts(buf: Int32Array, cbuf: Uint8Array, numOfInts: number, numOfBits: number, sizes: NumberArray, nums: Float32Array, buf2: Uint32Array): void

deepCopy

  • deepCopy(src: any): any

deepEqual

  • deepEqual(a: any, b: any): boolean

defaults

  • defaults(value: any, defaultValue: any): any

Private degToRad

  • degToRad(deg: number): number

distance

  • distance(x0: number, y0: number, x1: number, y1: number): number

download

  • download(data: Blob | string, downloadName?: string): void

  • Parameters

    • data: Blob | string
    • Default value downloadName: string = "download"

    Returns void

duplicateCgStructure

duplicateComponentContainingStructure

duplicateStructure

edt

edt1d

ensureArray

  • ensureArray(value: any): any[]

ensureBuffer

  • ensureBuffer(a: any): any

ensureFloat32Array

  • ensureFloat32Array(a?: number[] | Float32Array): any

ensureMatrix4

  • ensureMatrix4(m?: number[] | Matrix4): any

ensureQuaternion

  • ensureQuaternion(q?: number[] | Quaternion): any

ensureVector2

  • ensureVector2(v?: number[] | Vector2): any

ensureVector3

  • ensureVector3(v?: number[] | Vector3): any

entityFromType

  • entityFromType(type: number): undefined | "polymer" | "non-polymer" | "macrolide" | "water"

entityTypeFromString

  • entityTypeFromString(string: string): 1 | 0 | 4 | 2 | 3

euclideanDist

  • euclideanDist(a: number[], b: number[]): number

euclideanDistSq

  • euclideanDistSq(a: number[], b: number[]): number

explicitValence

exportFilteringAsNewStructure

fillPositions

  • fillPositions(struc: Structure | CgStructure, positions: number[], aliIdx?: boolean[], alignOnProteins?: undefined | false | true): void

filter

filterFromChains

  • filterFromChains(chainList: string[]): Filter

findRings

flatten

  • flatten(array: any[], ret: any[]): any[]

float

  • float(text: string): number

functionNameToSnakeCase

  • functionNameToSnakeCase(fn: any): string

generateAtomisticStructure

  • Generates atomistic structure for given coarse-grained one.

    Parameters

    • cgStructure: CgStructure

      coarse-grained structure for which the atoms should be generated

    • Optional existingStructureToReplace: Structure

      if defined, the generation will store the data into this structure instance (replacing existing ones). Otherwise, new instance of Structure class is created.

    Returns Promise<Structure>

    promise resolving with the newly generated atomistic structure. If the number of atoms would exceed the maximum limit, the promise is rejected.

generateUUID

  • generateUUID(): string

getAbsolutePath

  • getAbsolutePath(relativePath: string): string

getAllowedContours

  • getAllowedContours(): number[][]

getAminoAcidSequenceType

  • getAminoAcidSequenceType(sequence: string): "three-letter" | "one-letter" | "invalid"

  • Finds out the type of amino acid sequence ('three-letter', 'one-letter', 'invalid') from a given sequence string

    Parameters

    • sequence: string

      The sequence whose type we want to know

    Returns "three-letter" | "one-letter" | "invalid"

    string determining the type of sequence we detected

getAngleData

  • getAngleData(position: Float32Array, params?: Partial<StructureRepresentationParameters>): { arcPosition1: Float32Array; arcPosition2: Float32Array; labelPosition: Float32Array; labelText: any[]; sectorPosition: Float32Array; vectorPosition1: Float32Array; vectorPosition2: Float32Array }

  • Converts triple positions into data required to build various buffers.

    Parameters

    Returns { arcPosition1: Float32Array; arcPosition2: Float32Array; labelPosition: Float32Array; labelText: any[]; sectorPosition: Float32Array; vectorPosition1: Float32Array; vectorPosition2: Float32Array }

    • arcPosition1: Float32Array
    • arcPosition2: Float32Array
    • labelPosition: Float32Array
    • labelText: any[]
    • sectorPosition: Float32Array
    • vectorPosition1: Float32Array
    • vectorPosition2: Float32Array

getApiFunctionsList

  • getApiFunctionsList(): [string, string, (...args: any) => any][]

  • Returns an array of three-element tuples:

    • function name for JSPython (e.g., "add")
    • function description (e.g., "Returns sum of two provided numbers")
    • reference to function itself

    Returns [string, string, (...args: any) => any][]

getAtomFilt

getAtoms

  • getAtoms(component: Component, maxSuggestions?: undefined | number): string[]

getAtomsPlaneNormal

getBondOrder

  • getBondOrder(valueOrder: string): 1 | 0 | 4 | 2 | 3

getBondOrderFromTable

  • getBondOrderFromTable(resname: string, atomname1: string, atomname2: string): number

getBrowser

  • getBrowser(): false | "Opera" | "Chrome" | "Firefox" | "Mobile Safari" | "Internet Explorer" | "Safari"

  • Returns false | "Opera" | "Chrome" | "Firefox" | "Mobile Safari" | "Internet Explorer" | "Safari"

getCWAngleBetween2DVectors

  • getCWAngleBetween2DVectors(v1: Vector2, v2: Vector2): number

getCWAngleBetween3DVectorsWRTAxis

  • getCWAngleBetween3DVectorsWRTAxis(v1: Vector3, v2: Vector3, axis: Vector3): number

getCameraPointOnPlane

  • getCameraPointOnPlane(camera: PerspectiveCamera | OrthographicCamera, worldPos: Vector3, planePos: Vector3): Vector3

getChainTerminusDirection

  • getChainTerminusDirection(chain: ChainProxy, endToReturn: "C" | "N", defaultDir?: Vector3): Vector3

getChainTerminusResidue

getChainname

  • getChainname(index: number): string

getChains

  • getChains(component: Component, maxSuggestions?: undefined | number): string[]

getCharCount

getComplementaryBase

getComplementaryDnaBase

getComplementaryRnaBase

getContactData

getCursorType

  • getCursorType(): string

getData

  • getData(data: BufferData, geo: BufferGeometry): { color: Float32Array; index: undefined | Uint16Array | Uint32Array; normal: Float32Array; picking: undefined | Picker; position: Float32Array; primitiveId: Float32Array }

  • Parameters

    Returns { color: Float32Array; index: undefined | Uint16Array | Uint32Array; normal: Float32Array; picking: undefined | Picker; position: Float32Array; primitiveId: Float32Array }

    • color: Float32Array
    • index: undefined | Uint16Array | Uint32Array
    • normal: Float32Array
    • picking: undefined | Picker
    • position: Float32Array
    • primitiveId: Float32Array

getDataInfo

  • getDataInfo(src: LoaderInput): { base: string; compressed: string | false | true; dir: string; ext: string; name: string; path: string; protocol: string; query: string; src: LoaderInput }

  • Parameters

    Returns { base: string; compressed: string | false | true; dir: string; ext: string; name: string; path: string; protocol: string; query: string; src: LoaderInput }

    • base: string
    • compressed: string | false | true
    • dir: string
    • ext: string
    • name: string
    • path: string
    • protocol: string
    • query: string
    • src: LoaderInput

getDefines

getDihedralData

  • getDihedralData(position: Float32Array, params?: Partial<DihedralRepresentationParameters>): { labelPosition: Float32Array; labelText: any[]; linePosition1: Float32Array; linePosition2: Float32Array; planePosition: Float32Array; sectorPosition: Float32Array }

  • Build the data required to create {Buffer} objects, given positions

    Parameters

    Returns { labelPosition: Float32Array; labelText: any[]; linePosition1: Float32Array; linePosition2: Float32Array; planePosition: Float32Array; sectorPosition: Float32Array }

    Arrays for building buffers

    • labelPosition: Float32Array
    • labelText: any[]
    • linePosition1: Float32Array
    • linePosition2: Float32Array
    • planePosition: Float32Array
    • sectorPosition: Float32Array

getEdgeTable

  • getEdgeTable(): Uint32Array

getElements

  • getElements(component: Component, maxSuggestions?: undefined | number): string[]

getErrorDescription

  • getErrorDescription(gl: WebGLRenderingContext, error: number): "no error" | "invalid enum" | "invalid value" | "invalid operation" | "invalid framebuffer operation" | "out of memory" | "context lost" | "unknown error"

  • Parameters

    • gl: WebGLRenderingContext
    • error: number

    Returns "no error" | "invalid enum" | "invalid value" | "invalid operation" | "invalid framebuffer operation" | "out of memory" | "context lost" | "unknown error"

getExtension

  • getExtension(gl: WebGLRenderingContext, name: string): any

getFastaHeaderLine

  • getFastaHeaderLine(strucName: string, chainName: string, chainLen: number): string

getFastaRecordForStructure

getFileInfo

  • getFileInfo(file: LoaderInput): { base: string; compressed: string | false | true; dir: string; ext: string; name: string; path: string; protocol: string; query: string; src: LoaderInput }

  • Parameters

    Returns { base: string; compressed: string | false | true; dir: string; ext: string; name: string; path: string; protocol: string; query: string; src: LoaderInput }

    • base: string
    • compressed: string | false | true
    • dir: string
    • ext: string
    • name: string
    • path: string
    • protocol: string
    • query: string
    • src: LoaderInput

getFilt

  • getFilt(a: NamedNodeMap, atomname?: undefined | string, useAltcode?: boolean): string

getFixedCountDashData

  • getFixedCountDashData<T>(data: T, segmentCount?: number): T

getFixedLengthDashData

  • getFixedLengthDashData<T>(data: T, segmentLength?: number): T

getFixedLengthWrappedDashData

  • getFixedLengthWrappedDashData<T>(data: T, segmentLength?: number): T

getFullNameForScopeName

  • getFullNameForScopeName(scope: string, name: string): string

getGeo

getHash

  • getHash(resname: string, atomTypeIdList: number[], hetero: boolean, chemCompType?: string): string

getHydrogenBondType

getIntersectionPointOfLineAndPlane

  • getIntersectionPointOfLineAndPlane(line_pos1: Vector3, line_pos2: Vector3, plane_pos: Vector3, plane_normal: Vector3): null | Vector3

  • Returns point of intersection of line and plane

    Parameters

    • line_pos1: Vector3

      point 1 on line

    • line_pos2: Vector3

      point 2 on line

    • plane_pos: Vector3

      point on plane

    • plane_normal: Vector3

      normal of the plane

    Returns null | Vector3

    point of intersection or null if there is no intersection

getKeywords

getLabelData

getLoneAtomSet

getMatrix3FromColumnVectors

  • getMatrix3FromColumnVectors(column1: Vector3, column2: Vector3, column3: Vector3): Matrix3

  • Returns 3x3 matrix assembled from three vectors as columns

    example

    column1 = (1, 2, 3), column2 = (4, 5, 6), column3 = (7, 8, 9) matrix = (1 4 7) (2 5 8) (3 6 9)

    Parameters

    • column1: Vector3

      first column

    • column2: Vector3

      second column

    • column3: Vector3

      third column

    Returns Matrix3

    3x3 matrix

getMatrix3FromRowVectors

  • getMatrix3FromRowVectors(row1: Vector3, row2: Vector3, row3: Vector3): Matrix3

  • Returns 3x3 matrix assembled from three vectors as rows

    example

    row1 = (1, 2, 3), row2 = (4, 5, 6), row3 = (7, 8, 9) matrix = (1 2 3) (4 5 6) (7 8 9)

    Parameters

    • row1: Vector3

      first row

    • row2: Vector3

      second row

    • row3: Vector3

      third row

    Returns Matrix3

    3x3 matrix

getMatrix4FromMatrix3

  • getMatrix4FromMatrix3(m: Matrix3): Matrix4

getModels

  • getModels(component: Component, maxSuggestions?: undefined | number): string[]

getModresId

  • getModresId(resno: number, chainname?: undefined | string, inscode?: undefined | string): string

getMouseButtons

  • getMouseButtons(event: MouseEvent): number

getNamedItem

  • getNamedItem(a: NamedNodeMap, name: string): string

getNucleobaseChangeTransformation

  • Since different nucleobases have differently positioned backbone with respect to the center of the nucleobase, this function returns a matrix for transformation from the coordinate system of one nucleobase to another with a goal to align their origin-C1' vectors.

    Parameters

    • sourceRefStructure: ReferenceStructureData

      reference structure of the current nucleotide

    • targetRefStructure: ReferenceStructureData

      reference structure of the nucleotide to which to transform,

    • Optional srcBasis: Matrix4

      if provided, determines the base/space in which transformation happens

    Returns Quaternion

    quaternion describing transformation from the source to target structure

getParserParameters

  • getParserParameters(ext: string): any

getPerpendicularVector

  • getPerpendicularVector(vct: Vector3): Vector3

getPointOnLine1ClosestToLine2

  • getPointOnLine1ClosestToLine2(line1_pos1: Vector3, line1_pos2: Vector3, line2_pos1: Vector3, line2_pos2: Vector3): Vector3

getProblemCount

  • getProblemCount(clashDict: {}, g: Element, ga: NamedNodeMap): number

getProtocol

  • getProtocol(): string

getQuery

  • getQuery(id: string): undefined | string

getRadiusDict

  • getRadiusDict(radiusList: number[]): {}

getRepresentationByOid

getResFilt

  • getResFilt(a: NamedNodeMap): string

getResidueAtomsFilterString

getResidues

  • getResidues(component: Component, maxSuggestions?: undefined | number): string[]

getSequenceType

  • getSequenceType(sequence: string): "dna" | "protein" | "unknown"

  • Finds out whether the given sequence is a "dna", "protein", or "unknown" sequence

    Parameters

    • sequence: string

      sequence to check

    Returns "dna" | "protein" | "unknown"

    string defining the detected type of sequence

getShader

getSideOfLineForPoint

  • getSideOfLineForPoint(point: Vector2, lineStart: Vector2, lineEnd: Vector2): number

getSize

getStageCameraPointOnPlane

  • getStageCameraPointOnPlane(stage: Stage, planePos: Vector3): Vector3

getStrucSeq

getSuggestions

  • getSuggestions(filterStr: string, component?: Component, maxSuggestions?: undefined | number): null | string[]

getSurfaceGrid

  • getSurfaceGrid(min: Float32Array, max: Float32Array, maxRadius: number, scaleFactor: number, extraMargin: number): { dim: Float32Array; matrix: Float32Array; scaleFactor: number; tran: Float32Array }

  • Parameters

    • min: Float32Array
    • max: Float32Array
    • maxRadius: number
    • scaleFactor: number
    • extraMargin: number

    Returns { dim: Float32Array; matrix: Float32Array; scaleFactor: number; tran: Float32Array }

    • dim: Float32Array
    • matrix: Float32Array
    • scaleFactor: number
    • tran: Float32Array

getSymmetryOperations

  • getSymmetryOperations(spacegroup: string): {}

getTextAtlas

getThreeSide

getTouchDistance

  • getTouchDistance(event: TouchEvent): number
  • example

    mouseObserver.signals.scrolled.add( function( delta ){ ... } );

    property

    {Signal<Integer, Integer>} moved - on move: deltaX, deltaY

    property

    {Signal} scrolled - on scroll: delta

    property

    {Signal<Integer, Integer>} dragged - on drag: deltaX, deltaY

    property

    {Signal} dropped - on drop

    property

    {Signal} clicked - on click

    property

    {Signal} hovered - on hover

    Parameters

    • event: TouchEvent

    Returns number

getTriTable

  • getTriTable(): Int32Array

getTypedArray

  • getTypedArray(arrayType: TypedArrayString, arraySize: number): Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array

getUintArray

  • getUintArray(sizeOrArray: any, maxUint: number): Uint16Array | Uint32Array

getWorkerDeps

guessElement

  • guessElement(atomName: string): string

gzipDecompress

  • gzipDecompress(data: ArrayBuffer | Uint8Array): ArrayBuffer

hammingWeight

  • hammingWeight(v: number): number

  • Compute the Hamming weight of a 32-bit unsigned integer

    Parameters

    • v: number

      a 32-bit unsigned integer

    Returns number

    the Hamming weight

hasAromaticNeighbour

  • hasAromaticNeighbour(a: AtomProxy): boolean

hasAttrValue

  • hasAttrValue(attr: Attr | null, value: string): boolean

hasExactMatch

  • hasExactMatch(str: string, list: string[]): boolean

hasPolarNeighbour

hasValue

  • hasValue(d: string): boolean

hsvToRgb

  • hsvToRgb(h: number, s: number, v: number): number[]

hypot

  • hypot(a: number, b: number): number

inAromaticRingWithElectronNegativeElement

  • inAromaticRingWithElectronNegativeElement(a: AtomProxy): boolean

initialize

  • initialize(stage: Stage): void

insertResidueToStore

  • insertResidueToStore(targetStructure: Structure, targetChainIndex: number, residue: ResidueProxy, newResidueIndex: number): void

int

  • int(text: string): number

interpolateLerp

interpolateSpline

invalidAtomContact

  • invalidAtomContact(ap1: AtomProxy, ap2: AtomProxy, masterIdx: number): false | true | ""

invert3x3

isAcetamidine

isAmide

isBackboneHydrogenBond

isCarbonyl

isCarboxylate

isCationPi

isConjugated

  • Are we involved in some kind of pi system. Either explicitly forming double bond or N, O next to a double bond, except:

    N,O with degree 4 cannot be conjugated. N,O adjacent to P=O or S=O do not qualify (keeps sulfonamide N sp3 geom)

    Parameters

    Returns boolean

isExactMatch

  • isExactMatch(str: string, list: string[]): boolean

isGuanidine

isHalocarbon

isHalogenBond

isHistidineNitrogen

  • isHistidineNitrogen(ap: AtomProxy): boolean

isHydrogenBond

isHydrogenBondType

  • isHydrogenBondType(type: number): boolean

isHydrophobicContact

isImide

isIonicInteraction

isMasterContact

isMetalComplex

isPhosphate

isPiStacking

isPointOnSegment

  • isPointOnSegment(p: Vector3, l1: Vector3, l2: Vector3): boolean

isPolar

isPurineNucleobase

isPyrimidineNucleobase

isQuaternaryAmine

isRingAromatic

isSequenceDna

  • isSequenceDna(s: string): boolean

isSequenceOneLetter

  • isSequenceOneLetter(s: string): boolean

isStructureInOxDnaGeometry

  • isStructureInOxDnaGeometry(cgStructure: CgStructure): boolean

  • Returns boolean determining whether the provided structure is stored in oxDNA geometry or not. The information is deduced from the properties of the (D)(R)NA geometry. Therefore, the function is not guaranteed to be always accurate.

    remark

    While oxDNA uses similar (D)(R)NA positional parameters as Catana, the interpretation of these parameters is slightly different -- oxDNA uses approximations for the location of nucleobase and backbone centers, as it internally works with center of mass, while Catana works with separate nb and bb centers both internally and externally, using precise values for these properties, deduced from reference PDB files.

    Parameters

    Returns boolean

    true if the structure seems to be stored in oxDNA geometry

isSulfate

isSulfonicAcid

isSulfonium

isTertiaryAmine

  • isTertiaryAmine(a: AtomProxy, idealValence: number): boolean

isValidPluginUIElemTypeRecord

isWaterHydrogenBond

isWeakHydrogenBond

laplacianSmooth

  • laplacianSmooth(verts: Float32Array, faces: Float32Array, numiter: number, inflate: boolean): void

len

  • len(data: any): number

lerp

  • lerp(start: number, stop: number, alpha: number): number

lexicographicCompare

  • lexicographicCompare<T>(elm1: T, elm2: T): 1 | -1 | 0

lineLineIntersect

  • lineLineIntersect(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): null | Vector3[]

loadShader

  • loadShader(gl: WebGLRenderingContext, shaderSource: string, shaderType: number): undefined | null | WebGLShader

logReprUnknown

  • logReprUnknown(type: string): void

m3makeNormal

  • m3makeNormal(out: Float32Array, m4: Float32Array): void

m3new

  • m3new(): Float32Array

m4identity

  • m4identity(out: Float32Array): void

m4makeRotationY

  • m4makeRotationY(out: Float32Array, theta: number): void

m4makeScale

  • m4makeScale(out: Float32Array, x: number, y: number, z: number): void

m4makeTranslation

  • m4makeTranslation(out: Float32Array, x: number, y: number, z: number): void

m4multiply

  • m4multiply(out: Float32Array, a: Float32Array, b: Float32Array): void

m4new

  • m4new(): Float32Array

m4set

  • m4set(out: Float32Array, n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number): void

  • Parameters

    • out: Float32Array
    • n11: number
    • n12: number
    • n13: number
    • n14: number
    • n21: number
    • n22: number
    • n23: number
    • n24: number
    • n31: number
    • n32: number
    • n33: number
    • n34: number
    • n41: number
    • n42: number
    • n43: number
    • n44: number

    Returns void

makeAVHash

  • makeAVHash(atomsX: Float32Array, atomsY: Float32Array, atomsZ: Float32Array, atomsR: Float32Array, min: Float32Array, max: Float32Array, maxDistance: number): iAVHash

  • Parameters

    • atomsX: Float32Array
    • atomsY: Float32Array
    • atomsZ: Float32Array
    • atomsR: Float32Array
    • min: Float32Array
    • max: Float32Array
    • maxDistance: number

    Returns iAVHash

makeAtomTest

makeCgMonomerTest

makeChainTest

makeGrid

  • makeGrid(length: number, width: number, height: number, DataCtor: any, elemSize: number): iGrid

makeImage

makeModelTest

makePointTexture

makeRepresentation

  • makeRepresentation(type: string, object: any, viewer: Viewer, params: any): any

makeResidueTest

makeTest

makeTrajectory

makeWorkerBlob

  • makeWorkerBlob(func: Function, deps: Function[]): Blob

makeWorkerString

  • makeWorkerString(vars: any): string

mat3x3determinant

  • mat3x3determinant(M: Matrix): number

match

  • match(str: string, list: string[], maxSuggestions?: undefined | number): string[]

matchName

  • matchName(name: string | RegExp, object: { name: string }): boolean

meanCols

meanRows

mergeComponentsContainingStructureIntoOne

  • Merges all-atom structure components into a new one

    Parameters

    • stage: Stage

      stage instance

    • newComponentTitle: string

      title of the newly created component

    • removeOldComponents: boolean

      if set to true, provided components will be deleted after the operation

    • backendMergeOnly: boolean

      if set to true, the new component will be backend-only, i.e., created only in bacgkround without being shown in the UI

    • compToStruc: (comp: Component) => Structure

      callback providing reference to structure based on the component input

    • parentUpdateCallback: (comp: Component) => void

      callback to be executed on the component into which the structures are merged after every merge step

    • Rest ...components: Component[]

      list of components to be merged

    Returns StructureComponent

    reference to new structure component containing structure with the merged data

mergeStructureComponentsIntoOne

  • Merges all-atom structure components into a new one

    Parameters

    • stage: Stage

      stage instance

    • newComponentTitle: string

      title of the newly created component

    • removeOldComponents: boolean

      if set to true, provided components will be deleted after the operation

    • backendMergeOnly: boolean

      if set to true, the new component will be backend-only, i.e., created only in bacgkround without being shown in the UI

    • Rest ...components: StructureComponent[]

      list of components to be merged

    Returns StructureComponent

    reference to new structure component containing structure with the merged data

mergeStructures

  • mergeStructures(name: string, structures: Structure[], matrices?: (undefined | Matrix4)[]): Structure

  • Merges provided all-atom structures into a new structure

    Parameters

    • name: string

      name of the new structure

    • structures: Structure[]

      array of structures to be merged

    • Optional matrices: (undefined | Matrix4)[]

      array of matrices transforming each of the structures. Structure at index i will be transformed by matrix at index i.

    Returns Structure

    new structure storing the merged data

modelTestFn

monomerTypeToOneLetterCharCode

  • monomerTypeToOneLetterCharCode(monType: MonomerType): number

monomerTypeToOneLetterCode

  • monomerTypeToOneLetterCode(monType: MonomerType): string

multiply

multiply3x3

multiplyABt

multiplyAtB

mutateResidue

  • mutateResidue(targetStructure: Structure, residueIndex: number, structureWithResToMutateTo: Structure, newResNameOverride?: string | undefined, removeHydrogensFromAppendedResidue?: boolean): Structure

  • Replaces given residue with a different one. Atuomatically removes H2O atoms.

    Parameters

    • targetStructure: Structure

      structure to be modified (containing the residue to be mutated)

    • residueIndex: number

      index of residue to be mutated

    • structureWithResToMutateTo: Structure

      structure containing the residue to mutate to

    • Default value newResNameOverride: string | undefined = undefined

      the name of new resulting residue

    • Default value removeHydrogensFromAppendedResidue: boolean = true

      determines whether H atoms should be removed from residue being appended

    Returns Structure

normalize

  • normalize(value: number, min: number, max: number): number

normalizeVector3array

  • normalizeVector3array(a: Float32Array): void

nucleicAcidTypeToString

nucleobaseTypeToPdbResidueCode

onBeforeRender

  • onBeforeRender(this: Object3D, renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera | OrthographicCamera, geometry: Geometry, material: ShaderMaterial): void

  • Parameters

    • this: Object3D
    • renderer: WebGLRenderer
    • scene: Scene
    • camera: PerspectiveCamera | OrthographicCamera
    • geometry: Geometry
    • material: ShaderMaterial

    Returns void

onComponentAdded

  • onComponentAdded(component: Component): void

oneLetterCodeToAminoAcidType

oneLetterCodeToNucleobaseType

oneLetterToThreeLetter

  • oneLetterToThreeLetter(oneLetter: string): null | string

  • Converts a sequence in one-letter type to one-letter type

    Parameters

    • oneLetter: string

    Returns null | string

    converted sequence, or null if some of the elements in the source sequence was not recognized

onmessage

open

  • open(callback: Function, extensionList?: string[]): void

  • Parameters

    • callback: Function
    • Default value extensionList: string[] = ['*']

    Returns void

openUrl

  • openUrl(url: string): void

overrideChainResNamesOfStructure

  • overrideChainResNamesOfStructure(structure: Structure, resName: string, resNo?: number, firstChainName?: string, chainIdStart?: number): void

  • Overrides chain and residue names in the provided structure.

    remark

    Can be used, e.g., for structures loaded from SDF files to provide them with data which are not by default stored in this file format

    Parameters

    • structure: Structure
    • resName: string
    • Default value resNo: number = 0
    • Default value firstChainName: string = "A"
    • Default value chainIdStart: number = 0

    Returns void

parseChemComp

parseCore

parseFilt

parseFlag

  • parseFlag(line: string): undefined | string

parseGroup

  • parseGroup(line: string): { groupFlags: {}; groupMasters: string[]; groupName: string }

  • Parameters

    • line: string

    Returns { groupFlags: {}; groupMasters: string[]; groupName: string }

    • groupFlags: {}
      • [k: string]: string | boolean
    • groupMasters: string[]
    • groupName: string

parseIntSubstr

  • parseIntSubstr(line: string, start: number, length: number): number

parseListDef

  • parseListDef(line: string): { listColor: undefined | number[]; listMasters: string[]; listName: undefined | string; listWidth: undefined | number }

  • Parameters

    • line: string

    Returns { listColor: undefined | number[]; listMasters: string[]; listName: undefined | string; listWidth: undefined | number }

    • listColor: undefined | number[]
    • listMasters: string[]
    • listName: undefined | string
    • listWidth: undefined | number

parseListElm

  • parseListElm(line: string): { color: undefined | number[]; isLineBreak: boolean; isTriangleBreak: boolean; label: string; position: number[]; radius: undefined | number; width: undefined | number }

  • Parameters

    • line: string

    Returns { color: undefined | number[]; isLineBreak: boolean; isTriangleBreak: boolean; label: string; position: number[]; radius: undefined | number; width: undefined | number }

    • color: undefined | number[]
    • isLineBreak: boolean
    • isTriangleBreak: boolean
    • label: string
    • position: number[]
    • radius: undefined | number
    • width: undefined | number

parseNestedAtoms

  • parseNestedAtoms(sview: StructureView, atoms: (string | number)[][]): Float32Array

  • MeasurementRepresentations take atom[Pair|Triple|Quad] parameters.

    Parses nested array of either integer atom indices or selection expressions into a flat array of coordinates.

    Parameters

    • sview: StructureView

      The structure to which the atoms refer

    • atoms: (string | number)[][]

      Nested array of atom pairs|triples|quads as Integer indices or selection expressions

    Returns Float32Array

    Flattened array of position coordinates

parseNumberLine

  • parseNumberLine(line: string): number[]

parseStr

  • parseStr(line: string): string

parseXml

  • parseXml(xml: string): { declaration: undefined | XMLNode; root: undefined | XMLNode }

pclamp

  • pclamp(value: number): number

pdbResidueCodeToNucleobaseType

permutations

  • permutations<Type>(array: Type[], length: number): Type[][]

  • Generates permutations of the given array, where each permutation has a given length.

    Type parameters

    • Type

    Parameters

    • array: Type[]
    • length: number

      length of the permutations

    Returns Type[][]

    array of permutations, each element of this array is an array of length {@link length}

pick

  • pick(object: {}): any

prepareMatrix

  • prepareMatrix(cellNames: string, mat: number[][]): {}

processConnections

  • processConnections(cif: Cif, structure: Structure, asymIdDict: {}): void

processEntities

  • processEntities(cif: Cif, structure: Structure, chainIndexDict: {}): void

processSecondaryStructure

  • processSecondaryStructure(cif: Cif, structure: Structure, asymIdDict: {}): false | { helices: [string, number, string, string, number, string, number][]; sheets: [string, number, string, string, number, string][] }

  • Parameters

    • cif: Cif
    • structure: Structure
    • asymIdDict: {}
      • [k: string]: string

    Returns false | { helices: [string, number, string, string, number, string, number][]; sheets: [string, number, string, string, number, string][] }

processSymmetry

  • processSymmetry(cif: Cif, structure: Structure, asymIdDict: {}): void

projectPointOnVector

  • projectPointOnVector(point: Vector3, vector: Vector3, origin?: Vector3): Vector3

quickselectCmp

  • quickselectCmp<T>(arr: NumberArray | T[], n: number, cmp?: undefined | ((a: number | T, b: number | T) => number), left?: number, right?: undefined | number): number | T

  • Type parameters

    • T

    Parameters

    • arr: NumberArray | T[]
    • n: number
    • Optional cmp: undefined | ((a: number | T, b: number | T) => number)
    • Default value left: number = 0
    • Optional right: undefined | number

    Returns number | T

quicksortCmp

  • quicksortCmp<T>(arr: NumberArray | T[], cmp?: undefined | ((a: number | T, b: number | T) => number), begin?: number, end?: undefined | number): number[] | Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array | Uint8ClampedArray | Float64Array | T[]

  • Type parameters

    • T

    Parameters

    • arr: NumberArray | T[]
    • Optional cmp: undefined | ((a: number | T, b: number | T) => number)
    • Default value begin: number = 0
    • Optional end: undefined | number

    Returns number[] | Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array | Uint8ClampedArray | Float64Array | T[]

quicksortIP

  • quicksortIP(arr: NumberArray, eleSize: number, orderElement: number, begin?: number, end?: undefined | number): NumberArray

radToDeg

  • radToDeg(rad: number): number

randomColor

  • randomColor(): number

randomColorArray

  • randomColorArray(n: number): Float32Array

rangeInSortedArray

  • rangeInSortedArray(array: number[], min: number, max: number): number

recenterAtoms

  • recenterAtoms(structure: Structure, newCenterPosition: Vector3, refreshPosBefore?: boolean, refreshPosAfter?: boolean): void

  • Moves the structure's atoms to have their center of mass located at new location

    Parameters

    • structure: Structure
    • newCenterPosition: Vector3
    • Default value refreshPosBefore: boolean = false
    • Default value refreshPosAfter: boolean = false

    Returns void

refineHydrophobicContacts

refineLineOfSight

refineMetalCoordination

refinePiStacking

refineSaltBridges

refineWeakHydrogenBonds

removePbc

  • removePbc(x: NumberArray, box: ArrayLike<number>): undefined | number[] | Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array | Uint8ClampedArray | Float64Array

  • Parameters

    Returns undefined | number[] | Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array | Uint8ClampedArray | Float64Array

removePeriodicity

  • removePeriodicity(x: NumberArray, box: ArrayLike<number>, mean: number[]): undefined | number[] | Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array | Uint8ClampedArray | Float64Array

  • Parameters

    Returns undefined | number[] | Uint8Array | Int8Array | Int16Array | Int32Array | Uint16Array | Uint32Array | Float32Array | Uint8ClampedArray | Float64Array

removePointBreaksTriangleArrays

  • removePointBreaksTriangleArrays(convertedRibbonObject: RibbonObject): { breakArray: boolean[]; colorArray: number[]; labelArray: string[]; masterArray: any[]; name: undefined | string; positionArray: number[] }

  • Parameters

    Returns { breakArray: boolean[]; colorArray: number[]; labelArray: string[]; masterArray: any[]; name: undefined | string; positionArray: number[] }

    • breakArray: boolean[]
    • colorArray: number[]
    • labelArray: string[]
    • masterArray: any[]
    • name: undefined | string
    • positionArray: number[]

reorderAtoms

replicateArray3Entries

  • replicateArray3Entries(array: NumberArray, m: number): Float32Array

replicateArrayEntries

  • replicateArrayEntries(array: NumberArray, m: number): Float32Array

residueTestFn

rotateAroundAtomsVector

  • rotateAroundAtomsVector(vectorStartAtom: AtomProxy, vectorEndAtom: AtomProxy, ...angles: number[]): Matrix4[]

  • Creates a rotation matrix rotating about vector defined by the two provided atoms. Origin of the rotation is the second atom. Angles are expected to be in degrees. More angles of rotation can be provided. In such a case, one transformation matrix for each angle will be returned.

    Parameters

    Returns Matrix4[]

saturate

  • saturate(value: number): number

serialArray

  • serialArray(n: number): Float32Array

serialBlockArray

setBitDict

  • setBitDict(dict: {}, key: string, bit: number): void

setCursorType

  • setCursorType(newStyle: string): void

setCursorTypeCustom

  • setCursorTypeCustom(newStyle: "change" | "remove" | "plus"): void

setCursorTypeUrl

  • setCursorTypeUrl(newStyleUrl: string): void

setDebug

  • setDebug(value: boolean): void

setExtensionFragDepth

  • setExtensionFragDepth(value: boolean): void

setListingDatasource

  • setListingDatasource(value: boolean): void

setMeasurementDefaultParams

  • setMeasurementDefaultParams(params?: {}): void

setObjectMatrix

  • setObjectMatrix(object: Object3D, matrix: Matrix4): void

setSupportsReadPixelsFloat

  • setSupportsReadPixelsFloat(value: boolean): void

setTrajectoryDatasource

  • setTrajectoryDatasource(value: boolean): void

setVisibilityFalse

  • setVisibilityFalse(m: Object3D): void

setVisibilityTrue

  • setVisibilityTrue(m: Object3D): void

sizeOfInt

  • sizeOfInt(size: number): number

sizeOfInts

  • sizeOfInts(numOfInts: number, sizes: Int32Array): number

smootherstep

  • smootherstep(min: number, max: number, x: number): number

smootheststep

  • smootheststep(min: number, max: number, x: number): number

smoothstep

  • smoothstep(min: number, max: number, x: number): number

sortProjectedPosition

  • sortProjectedPosition(scene: Scene, camera: Camera): void

spatialLookup

spline

  • spline(p0: number, p1: number, p2: number, p3: number, t: number, tension: number): number

  • Spline interpolation. t == 0 -> p1 t == 1 -> p2

    Parameters

    • p0: number
    • p1: number
    • p2: number
    • p3: number
    • t: number
    • tension: number

    Returns number

str

  • str(input: number): string

stringToNucleicAcidType

stringToUnitType

strip

  • strip(val: string): string

subCols

  • subCols(A: Matrix, col: number[]): void

subRows

  • subRows(A: Matrix, row: number[]): void

submit

  • submit(url: string, data: FormData, callback: Function, onerror: Function): void

  • Parameters

    • url: string
    • data: FormData
    • callback: Function
    • onerror: Function

    Returns void

superpose

  • Perform structural superposition of two structures, optionally guided by a sequence alignment

    Parameters

    • s1: Structure | CgStructure

      structure 1 which is superposed onto structure 2

    • s2: Structure | CgStructure

      structure 2 onto which structure 1 is superposed

    • Default value align: boolean = false
    • Default value filt1: string = ""
    • Default value filt2: string = ""

    Returns undefined | number | Matrix4

svd

testTextureSupport

  • testTextureSupport(type: number): boolean

threeLetterCodeToAminoAcidType

threeLetterToOneLetter

  • threeLetterToOneLetter(sequence: string): null | string

  • Converts a sequence from three-letter type to one-letter type

    Parameters

    • sequence: string

    Returns null | string

    converted sequence, or null if some of the elements in the source sequence was not recognized

throttle

  • throttle(func: Function, wait: number, options: { leading?: undefined | false | true; trailing?: undefined | false | true }): throttle

  • Parameters

    • func: Function
    • wait: number
    • options: { leading?: undefined | false | true; trailing?: undefined | false | true }
      • Optional leading?: undefined | false | true
      • Optional trailing?: undefined | false | true

    Returns throttle

toLowerCaseString

  • toLowerCaseString(value: string): any

transformAtoms

transformNucleotideCentroidsFromOxDna

transformNucleotideCentroidsToOxDna

transformNucleotideFromOxDnaGeometry

transformNucleotideToOxDnaGeometry

transformStrandFromOxDnaGeometry

transformStrandToOxDnaGeometry

transformStructureFromOxDnaGeometry

  • transformStructureFromOxDnaGeometry(cgStructure: CgStructure): void

transformStructureToOxDnaGeometry

  • transformStructureToOxDnaGeometry(cgStructure: CgStructure): void

transpose

triggerFromString

trimQuotes

  • trimQuotes(str: string): string

uint8ToLines

  • uint8ToLines(u8a: Uint8Array, chunkSize?: number, newline?: string): string[]

  • Parameters

    • u8a: Uint8Array
    • Default value chunkSize: number = 1024 * 1024 * 10
    • Default value newline: string = ""

    Returns string[]

uint8ToString

  • uint8ToString(u8a: Uint8Array): any

uniformArray

  • uniformArray<T>(n: number, a: number, optionalTarget?: T): T

uniformArray3

uniqueArray

  • uniqueArray(array: any[]): any[]

updateBoundingBox

  • updateBoundingBox(lineSegments: LineSegments, box: Box3): void

updateCameraUniforms

  • updateCameraUniforms(group: Object3D, camera: Camera): void

updateMaterialUniforms

  • updateMaterialUniforms(group: Object3D, camera: Camera, renderer: WebGLRenderer, cDist: number, bRadius: number): void

updateParams

  • updateParams<T>(params: T, newParams: {}): T

v3add

  • v3add(out: Float32Array, a: Float32Array, b: Float32Array): void

v3addScalar

  • v3addScalar(out: Float32Array, a: Float32Array, s: number): void

v3angle

  • v3angle(a: Float32Array, b: Float32Array): number

v3ceil

  • v3ceil(out: Float32Array, a: Float32Array): void

v3cross

  • v3cross(out: Float32Array, a: Float32Array, b: Float32Array): void

v3divide

  • v3divide(out: Float32Array, a: Float32Array, b: Float32Array): void

v3divideScalar

  • v3divideScalar(out: Float32Array, a: Float32Array, s: number): void

v3dot

  • v3dot(a: Float32Array, b: Float32Array): number

v3floor

  • v3floor(out: Float32Array, a: Float32Array): void

v3forEach

  • v3forEach(array: Float32Array, fn: (i: Float32Array, j: Float32Array, k: Float32Array) => void, b: Float32Array): void

  • Parameters

    • array: Float32Array
    • fn: (i: Float32Array, j: Float32Array, k: Float32Array) => void
        • (i: Float32Array, j: Float32Array, k: Float32Array): void

        • Parameters

          • i: Float32Array
          • j: Float32Array
          • k: Float32Array

          Returns void

    • b: Float32Array

    Returns void

v3fromArray

  • v3fromArray(out: Float32Array, array: Float32Array, offset?: number): void

v3length

  • v3length(a: Float32Array): number

v3length2

  • v3length2(a: Float32Array): number

v3multiply

  • v3multiply(out: Float32Array, a: Float32Array, b: Float32Array): void

v3multiplyScalar

  • v3multiplyScalar(out: Float32Array, a: Float32Array, s: number): void

v3negate

  • v3negate(out: Float32Array, a: Float32Array): void

v3new

v3normalize

  • v3normalize(out: Float32Array, a: Float32Array): void

v3round

  • v3round(out: Float32Array, a: Float32Array): void

v3sub

  • v3sub(out: Float32Array, a: Float32Array, b: Float32Array): void

v3subScalar

  • v3subScalar(out: Float32Array, a: Float32Array, s: number): void

v3toArray

  • v3toArray(input: Float32Array, array: Float32Array, offset?: number): void

valenceModel

validatePositions

  • validatePositions(position: Float32Array): Float32Array

Object literals

Const AA1

AA1: object

ALA

ALA: string = "A"

ARG

ARG: string = "R"

ASN

ASN: string = "N"

ASP

ASP: string = "D"

CYS

CYS: string = "C"

GLN

GLN: string = "Q"

GLU

GLU: string = "E"

GLY

GLY: string = "G"

HIS

HIS: string = "H"

ILE

ILE: string = "I"

LEU

LEU: string = "L"

LYS

LYS: string = "K"

MET

MET: string = "M"

PHE

PHE: string = "F"

PRO

PRO: string = "P"

PYL

PYL: string = "O"

SEC

SEC: string = "U"

SER

SER: string = "S"

THR

THR: string = "T"

TRP

TRP: string = "W"

TYR

TYR: string = "Y"

VAL

VAL: string = "V"

Const ADnaForm

ADnaForm: object

A-DNA form defined by parameters extracted from the standard ref. frame paper for nb description by Olson et al., 2001: https://doi.org/10.1006/jmbi.2001.4987

doubleHelixDiameter

doubleHelixDiameter: number = 23

defaultBaseParams

defaultBaseParams: object

baseRise

baseRise: number = 3.32

baseRoll

baseRoll: number = 8

baseShift

baseShift: number = 0

baseSlide

baseSlide: number = -1.53

baseTilt

baseTilt: number = 0.1

baseTwist

baseTwist: number = 31.1

defaultComplBaseParams

defaultComplBaseParams: object

buckle

buckle: number = -0.1

opening

opening: number = 0.6

propeller

propeller: number = -11.8

shear

shear: number = 0.01

stagger

stagger: number = 0.02

stretch

stretch: number = -0.18

Const AminoAcidsPdbsContent

AminoAcidsPdbsContent: object

ALA

ALA: string = alaPdbString

ARG

ARG: string = argPdbString

ASN

ASN: string = asnPdbString

ASP

ASP: string = aspPdbString

CYS

CYS: string = cysPdbString

GLN

GLN: string = glnPdbString

GLU

GLU: string = gluPdbString

GLY

GLY: string = glyPdbString

HIS

HIS: string = hisPdbString

ILE

ILE: string = ilePdbString

LEU

LEU: string = leuPdbString

LYS

LYS: string = lysPdbString

MET

MET: string = metPdbString

PHE

PHE: string = phePdbString

PRO

PRO: string = proPdbString

SEC

SEC: string = secPdbString

SER

SER: string = serPdbString

THR

THR: string = thrPdbString

TRP

TRP: string = trpPdbString

TYR

TYR: string = tyrPdbString

VAL

VAL: string = valPdbString

Const AtomWeights

AtomWeights: object

1

1: number = 1.008

10

10: number = 20.18

100

100: number = 257.095

101

101: number = 258.098

102

102: number = 259.101

103

103: number = 262.11

104

104: number = 267.122

105

105: number = 270.131

106

106: number = 271.134

107

107: number = 270.133

108

108: number = 270.134

109

109: number = 278.156

11

11: number = 22.99

110

110: number = 281.165

111

111: number = 281.166

112

112: number = 285.177

113

113: number = 286.182

114

114: number = 289.19

115

115: number = 289.194

116

116: number = 293.204

117

117: number = 293.208

118

118: number = 294.214

12

12: number = 24.305

13

13: number = 26.982

14

14: number = 28.085

15

15: number = 30.974

16

16: number = 32.06

17

17: number = 35.45

18

18: number = 39.948

19

19: number = 39.098

2

2: number = 4.0026

20

20: number = 40.078

21

21: number = 44.956

22

22: number = 47.867

23

23: number = 50.942

24

24: number = 51.996

25

25: number = 54.938

26

26: number = 55.845

27

27: number = 58.933

28

28: number = 58.693

29

29: number = 63.546

3

3: number = 6.94

30

30: number = 65.38

31

31: number = 69.723

32

32: number = 72.63

33

33: number = 74.922

34

34: number = 78.971

35

35: number = 79.904

36

36: number = 83.798

37

37: number = 85.468

38

38: number = 87.62

39

39: number = 88.906

4

4: number = 9.0122

40

40: number = 91.224

41

41: number = 92.906

42

42: number = 95.95

43

43: number = 96.906

44

44: number = 101.07

45

45: number = 102.91

46

46: number = 106.42

47

47: number = 107.87

48

48: number = 112.41

49

49: number = 114.82

5

5: number = 10.81

50

50: number = 118.71

51

51: number = 121.76

52

52: number = 127.6

53

53: number = 127.6

54

54: number = 131.29

55

55: number = 132.91

56

56: number = 137.33

57

57: number = 138.91

58

58: number = 140.12

59

59: number = 140.91

6

6: number = 10.81

60

60: number = 144.24

61

61: number = 144.912

62

62: number = 150.36

63

63: number = 151.96

64

64: number = 157.25

65

65: number = 158.93

66

66: number = 162.5

67

67: number = 164.93

68

68: number = 167.26

69

69: number = 168.93

7

7: number = 14.007

70

70: number = 173.05

71

71: number = 174.97

72

72: number = 178.49

73

73: number = 180.95

74

74: number = 183.84

75

75: number = 186.21

76

76: number = 190.23

77

77: number = 192.22

78

78: number = 195.08

79

79: number = 196.97

8

8: number = 15.999

80

80: number = 200.59

81

81: number = 204.38

82

82: number = 207.2

83

83: number = 208.98

84

84: number = 1.97

85

85: number = 2.02

86

86: number = 2.2

87

87: number = 3.48

88

88: number = 2.83

89

89: number = 2

9

9: number = 18.998

90

90: number = 232.04

91

91: number = 231.04

92

92: number = 238.03

93

93: number = 237.048

94

94: number = 244.064

95

95: number = 243.061

96

96: number = 247.07

97

97: number = 247.07

98

98: number = 251.079

99

99: number = 252.083

Const AtomicNumbers

AtomicNumbers: object

AC

AC: number = 89

AG

AG: number = 47

AL

AL: number = 13

AM

AM: number = 95

AR

AR: number = 18

AS

AS: number = 33

AT

AT: number = 85

AU

AU: number = 79

B

B: number = 5

BA

BA: number = 56

BE

BE: number = 4

BH

BH: number = 107

BI

BI: number = 83

BK

BK: number = 97

BR

BR: number = 35

C

C: number = 6

CA

CA: number = 20

CD

CD: number = 48

CE

CE: number = 58

CF

CF: number = 98

CL

CL: number = 17

CM

CM: number = 96

CN

CN: number = 112

CO

CO: number = 27

CR

CR: number = 24

CS

CS: number = 55

CU

CU: number = 29

D

D: number = 1

DB

DB: number = 105

DS

DS: number = 110

DY

DY: number = 66

ER

ER: number = 68

ES

ES: number = 99

EU

EU: number = 63

F

F: number = 9

FE

FE: number = 26

FL

FL: number = 114

FM

FM: number = 100

FR

FR: number = 87

GA

GA: number = 31

GD

GD: number = 64

GE

GE: number = 32

H

H: number = 1

HE

HE: number = 2

HF

HF: number = 72

HG

HG: number = 80

HO

HO: number = 67

HS

HS: number = 108

I

I: number = 53

IN

IN: number = 49

IR

IR: number = 77

K

K: number = 19

KR

KR: number = 36

LA

LA: number = 57

LI

LI: number = 3

LR

LR: number = 103

LU

LU: number = 71

LV

LV: number = 116

MC

MC: number = 115

MD

MD: number = 101

MG

MG: number = 12

MN

MN: number = 25

MO

MO: number = 42

MT

MT: number = 109

N

N: number = 7

NA

NA: number = 11

NB

NB: number = 41

ND

ND: number = 60

NE

NE: number = 10

NH

NH: number = 113

NI

NI: number = 28

NO

NO: number = 102

NP

NP: number = 93

O

O: number = 8

OG

OG: number = 118

OS

OS: number = 76

P

P: number = 15

PA

PA: number = 91

PB

PB: number = 82

PD

PD: number = 46

PM

PM: number = 61

PO

PO: number = 84

PR

PR: number = 59

PT

PT: number = 78

PU

PU: number = 94

RA

RA: number = 88

RB

RB: number = 37

RE

RE: number = 75

RF

RF: number = 104

RG

RG: number = 111

RH

RH: number = 45

RN

RN: number = 86

RU

RU: number = 44

S

S: number = 16

SB

SB: number = 51

SC

SC: number = 21

SE

SE: number = 34

SG

SG: number = 106

SI

SI: number = 14

SM

SM: number = 62

SN

SN: number = 50

SR

SR: number = 38

T

T: number = 1

TA

TA: number = 73

TB

TB: number = 65

TC

TC: number = 43

TE

TE: number = 52

TH

TH: number = 90

TI

TI: number = 22

TL

TL: number = 81

TM

TM: number = 69

TS

TS: number = 117

U

U: number = 92

V

V: number = 23

W

W: number = 74

XE

XE: number = 54

Y

Y: number = 39

YB

YB: number = 70

ZN

ZN: number = 30

ZR

ZR: number = 40

Const BDnaForm

BDnaForm: object

B-DNA form with parameters (except twist) extracted from the standard ref. frame paper for nb description by Olson et al., 2001: https://doi.org/10.1006/jmbi.2001.4987

doubleHelixDiameter

doubleHelixDiameter: number = 20

defaultBaseParams

defaultBaseParams: object

baseRise

baseRise: number = 3.32

baseRoll

baseRoll: number = 0

baseShift

baseShift: number = -0.02

baseSlide

baseSlide: number = 1.23

baseTilt

baseTilt: number = -0.1

baseTwist

baseTwist: number = 360 / 10.5

defaultComplBaseParams

defaultComplBaseParams: object

buckle

buckle: number = 0.5

opening

opening: number = 0.6

propeller

propeller: number = -11.4

shear

shear: number = 0

stagger

stagger: number = 0.09

stretch

stretch: number = -0.15

Const BDnaIdealisticForm

BDnaIdealisticForm: object

B-DNA "idealistic" form ignores some of the parameters to have a nicely parallel and regular DNA strand

doubleHelixDiameter

doubleHelixDiameter: number = 20

defaultBaseParams

defaultBaseParams: object

baseRise

baseRise: number = 3.32

baseRoll

baseRoll: number = 0

baseShift

baseShift: number = 0

baseSlide

baseSlide: number = 0

baseTilt

baseTilt: number = 0

baseTwist

baseTwist: number = 360 / 10.5

defaultComplBaseParams

defaultComplBaseParams: object

buckle

buckle: number = 0

opening

opening: number = 0

propeller

propeller: number = 0

shear

shear: number = 0

stagger

stagger: number = 0

stretch

stretch: number = 0

Const BarChartDefaultParameters

BarChartDefaultParameters: object

Default parameters for the D3 bar chart

color

color: string = "currentColor"

bar fill color

height

height: number = 400

Outer height, in pixels

marginBottom

marginBottom: number = 30

Bottom margin, in pixels

marginLeft

marginLeft: number = 40

Left margin, in pixels

marginRight

marginRight: number = 0

Right margin, in pixels

marginTop

marginTop: number = 20

Top margin, in pixels

title

title: (d: any, idx?: any, data?: any) => string = undefined as unknown as (d: any, idx?: any, data?: any) => string

Given d in data, returns the title text

Type declaration

    • (d: any, idx?: any, data?: any): string

    • Parameters

      • d: any
      • Optional idx: any
      • Optional data: any

      Returns string

width

width: number = 640

Outer width, in pixels

xDomain

xDomain: Iterable<any> = undefined as unknown as Iterable<any>

an array of (ordinal) x-values

xPadding

xPadding: number = 0.1

Amount of x-range to reserve to separate bars

xRange

xRange: [any, any] = undefined as unknown as [any, any]

[left, right]

yDomain

yDomain: [any, any] = undefined as unknown as [any, any]

[ymin, ymax]

yFormat

yFormat: string = undefined as unknown as string

a format specifier string for the y-axis

yLabel

yLabel: string = undefined as unknown as string

a label for the y-axis

yRange

yRange: [any, any] = undefined as unknown as [any, any]

[bottom, top]

yType

yType: scaleLinear = d3.scaleLinear

Type of y-scale

x

  • x(d: any, i: any): any

y

  • y(d: any): any

Const BondOrderTable

BondOrderTable: object

ARG|CZ|NH2

ARG|CZ|NH2: number = 2

ASN|CG|OD1

ASN|CG|OD1: number = 2

ASP|CG|OD1

ASP|CG|OD1: number = 2

A|C2|N3

A|C2|N3: number = 2

A|C4|C5

A|C4|C5: number = 2

A|C6|N1

A|C6|N1: number = 2

A|C8|N7

A|C8|N7: number = 2

C|C2|O2

C|C2|O2: number = 2

C|C4|N3

C|C4|N3: number = 2

C|C5|C6

C|C5|C6: number = 2

DA|C2|N3

DA|C2|N3: number = 2

DA|C4|C5

DA|C4|C5: number = 2

DA|C6|N1

DA|C6|N1: number = 2

DA|C8|N7

DA|C8|N7: number = 2

DC|C2|O2

DC|C2|O2: number = 2

DC|C4|N3

DC|C4|N3: number = 2

DC|C5|C6

DC|C5|C6: number = 2

DG|C2|N3

DG|C2|N3: number = 2

DG|C4|C5

DG|C4|C5: number = 2

DG|C6|O6

DG|C6|O6: number = 2

DG|C8|N7

DG|C8|N7: number = 2

DT|C2|O2

DT|C2|O2: number = 2

DT|C4|O4

DT|C4|O4: number = 2

DT|C5|C6

DT|C5|C6: number = 2

GLN|CD|OE1

GLN|CD|OE1: number = 2

GLU|CD|OE1

GLU|CD|OE1: number = 2

G|C2|N3

G|C2|N3: number = 2

G|C4|C5

G|C4|C5: number = 2

G|C6|O6

G|C6|O6: number = 2

G|C8|N7

G|C8|N7: number = 2

HIS|CD2|CG

HIS|CD2|CG: number = 2

HIS|CE1|ND1

HIS|CE1|ND1: number = 2

PHE|CD1|CG

PHE|CD1|CG: number = 2

PHE|CD2|CE2

PHE|CD2|CE2: number = 2

PHE|CE1|CZ

PHE|CE1|CZ: number = 2

TRP|CD1|CG

TRP|CD1|CG: number = 2

TRP|CD2|CE2

TRP|CD2|CE2: number = 2

TRP|CE3|CZ3

TRP|CE3|CZ3: number = 2

TRP|CH2|CZ2

TRP|CH2|CZ2: number = 2

TYR|CD1|CG

TYR|CD1|CG: number = 2

TYR|CD2|CE2

TYR|CD2|CE2: number = 2

TYR|CE1|CZ

TYR|CE1|CZ: number = 2

U|C2|O2

U|C2|O2: number = 2

U|C4|O4

U|C4|O4: number = 2

U|C5|C6

U|C5|C6: number = 2

Const BufferDefaultParameters

BufferDefaultParameters: object

background

background: boolean = false

clipCenter

clipCenter: Vector3 = new Vector3()

clipNear

clipNear: number = 0

clipRadius

clipRadius: number = 0

depthWrite

depthWrite: boolean = true

diffuse

diffuse: number = 16777215

diffuseInterior

diffuseInterior: boolean = false

disablePicking

disablePicking: boolean = false

flatShaded

flatShaded: boolean = false

forceTransparent

forceTransparent: boolean = false

interiorColor

interiorColor: number = 14540253

interiorDarkening

interiorDarkening: number = 0

matrix

matrix: Matrix4 = new Matrix4()

metalness

metalness: number = 0

opacity

opacity: number = 1

opaqueBack

opaqueBack: boolean = false

roughness

roughness: number = 1

side

side: BufferSide = 'double' as BufferSide

sortParticles

sortParticles: boolean = false

useInteriorColor

useInteriorColor: boolean = false

wireframe

wireframe: boolean = false

Const BufferParameterTypes

BufferParameterTypes: object

matrix

matrix: {}

Type declaration

background

background: object

updateShader

updateShader: boolean = true

clipCenter

clipCenter: object

uniform

uniform: boolean = true

clipNear

clipNear: object

property

property: boolean = true

updateShader

updateShader: boolean = true

clipRadius

clipRadius: object

uniform

uniform: boolean = true

updateShader

updateShader: boolean = true

depthWrite

depthWrite: object

property

property: boolean = true

diffuse

diffuse: object

uniform

uniform: boolean = true

diffuseInterior

diffuseInterior: object

updateShader

updateShader: boolean = true

flatShaded

flatShaded: object

updateShader

updateShader: boolean = true

interiorColor

interiorColor: object

uniform

uniform: boolean = true

interiorDarkening

interiorDarkening: object

uniform

uniform: boolean = true

metalness

metalness: object

uniform

uniform: boolean = true

opacity

opacity: object

uniform

uniform: boolean = true

opaqueBack

opaqueBack: object

updateShader

updateShader: boolean = true

roughness

roughness: object

uniform

uniform: boolean = true

side

side: object

property

property: boolean = true

updateShader

updateShader: boolean = true

useInteriorColor

useInteriorColor: object

updateShader

updateShader: boolean = true

wireframe

wireframe: object

updateVisibility

updateVisibility: boolean = true

Const ColorDict

ColorDict: object

blue

blue: number[] = hsvToRgb(240, 70, 100)

bluetint

bluetint: number[] = hsvToRgb(220, 40, 100)

brown

brown: number[] = hsvToRgb(20, 45, 75)

cyan

cyan: number[] = hsvToRgb(180, 100, 85)

deadblack

deadblack: number[] = [ 0, 0, 0 ]

deadwhite

deadwhite: number[] = [ 1, 1, 1 ]

gold

gold: number[] = hsvToRgb(40, 100, 100)

gray

gray: number[] = hsvToRgb(0, 0, 50)

green

green: number[] = hsvToRgb(120, 80, 100)

greentint

greentint: number[] = hsvToRgb(135, 40, 100)

hotpink

hotpink: number[] = hsvToRgb(335, 100, 100)

invisible

invisible: number[] = [ 0, 0, 0 ]

lilac

lilac: number[] = hsvToRgb(275, 55, 100)

lilactint

lilactint: number[] = hsvToRgb(275, 35, 100)

lime

lime: number[] = hsvToRgb(80, 100, 100)

magenta

magenta: number[] = hsvToRgb(300, 95, 100)

orange

orange: number[] = hsvToRgb(20, 100, 100)

peach

peach: number[] = hsvToRgb(25, 75, 100)

peachtint

peachtint: number[] = hsvToRgb(25, 50, 100)

pink

pink: number[] = hsvToRgb(350, 55, 100)

pinktint

pinktint: number[] = hsvToRgb(340, 30, 100)

purple

purple: number[] = hsvToRgb(275, 75, 100)

red

red: number[] = hsvToRgb(0, 100, 100)

sea

sea: number[] = hsvToRgb(150, 100, 100)

sky

sky: number[] = hsvToRgb(210, 75, 95)

white

white: number[] = hsvToRgb(0, 0, 100)

yellow

yellow: number[] = hsvToRgb(60, 100, 100)

yellowtint

yellowtint: number[] = hsvToRgb(60, 50, 100)

Const ColormakerModes

ColormakerModes: object
: string = ""

hcl

hcl: string = "Hue Chroma Lightness"

hsi

hsi: string = "Hue Saturation Intensity"

hsl

hsl: string = "Hue Saturation Lightness"

hsv

hsv: string = "Hue Saturation Value"

lab

lab: string = "CIE L*a*b*"

rgb

rgb: string = "Red Green Blue"

Const ColormakerScales

ColormakerScales: object
: string = ""

Accent

Accent: string = "[Q] Accent"

Blues

Blues: string = "[S] Blues"

BrBG

BrBG: string = "[D] Brown-Bluegreen"

BuGn

BuGn: string = "[S] Blue-Green"

BuPu

BuPu: string = "[S] Blue-Purple"

Dark2

Dark2: string = "[Q] Dark2"

GnBu

GnBu: string = "[S] Green-Blue"

Greens

Greens: string = "[S] Greens"

Greys

Greys: string = "[S] Greys"

OrRd

OrRd: string = "[S] Orange-Red"

Oranges

Oranges: string = "[S] Oranges"

PRGn

PRGn: string = "[D] Purplered-Green"

Paired

Paired: string = "[Q] Paired"

Pastel1

Pastel1: string = "[Q] Pastel1"

Pastel2

Pastel2: string = "[Q] Pastel2"

PiYG

PiYG: string = "[D] Pink-Yellowgreen"

PuBu

PuBu: string = "[S] Purple-Blue"

PuBuGn

PuBuGn: string = "[S] Purple-Blue-Green"

PuOr

PuOr: string = "[D] Purple-Orange"

PuRd

PuRd: string = "[S] Purple-Red"

Purples

Purples: string = "[S] Purples"

RdBu

RdBu: string = "[D] Red-Blue"

RdGy

RdGy: string = "[D] Red-Grey"

RdPu

RdPu: string = "[S] Red-Purple"

RdYlBu

RdYlBu: string = "[D] Red-Yellow-Blue"

RdYlGn

RdYlGn: string = "[D] Red-Yellow-Green"

Reds

Reds: string = "[S] Reds"

Set1

Set1: string = "[Q] Set1"

Set2

Set2: string = "[Q] Set2"

Set3

Set3: string = "[Q] Set3"

Spectral

Spectral: string = "[D] Spectral"

Viridis

Viridis: string = "[D] Viridis"

YlGn

YlGn: string = "[S] Yellow-Green"

YlGnBu

YlGnBu: string = "[S] Yellow-Green-Blue"

YlOrBr

YlOrBr: string = "[S] Yellow-Orange-Brown"

YlOrRd

YlOrRd: string = "[S] Yellow-Orange-Red"

rainbow

rainbow: string = "[?] Rainbow"

rwb

rwb: string = "[?] Red-White-Blue"

Const CommandsDescriptions

CommandsDescriptions: object

[CLICommands.HELP]

[CLICommands.HELP]: string = "Lists all available commands."

[CLICommands.LIST]

[CLICommands.LIST]: string = "Lists all components loaded in the scene and their UUID."

Const CommandsRegexps

CommandsRegexps: object

[CLICommands.HELP]

[CLICommands.HELP]: string = "help(.*)"

[CLICommands.LIST]

[CLICommands.LIST]: string = "list"

Const ComponentDefaultParameters

ComponentDefaultParameters: object

backendOnly

backendOnly: boolean = false

Used for determining whether the component should have its properties visualized on UI or not.

remark

Catana extension

locked

locked: boolean = false

Flag determining whether this component will ignore transformations or not.

remark

Catana extension

name

name: string = ""

status

status: string = ""

visible

visible: boolean = true

Const ContactDataDefaultParams

ContactDataDefaultParams: object

backboneHydrogenBond

backboneHydrogenBond: boolean = true

cationPi

cationPi: boolean = true

filterSele

filterSele: string = ""

halogenBond

halogenBond: boolean = true

hydrogenBond

hydrogenBond: boolean = true

hydrophobic

hydrophobic: boolean = true

ionicInteraction

ionicInteraction: boolean = true

metalCoordination

metalCoordination: boolean = true

piStacking

piStacking: boolean = true

radius

radius: number = 1

waterHydrogenBond

waterHydrogenBond: boolean = true

weakHydrogenBond

weakHydrogenBond: boolean = true

Const ContactDefaultParams

ContactDefaultParams: object

lineOfSightDistFactor

lineOfSightDistFactor: number = 1

masterModelIndex

masterModelIndex: number = -1

maxCationPiDist

maxCationPiDist: number = 6

maxCationPiOffset

maxCationPiOffset: number = 2

maxHalogenBondAngle

maxHalogenBondAngle: number = 30

maxHalogenBondDist

maxHalogenBondDist: number = 4

maxHbondAccAngle

maxHbondAccAngle: number = 45

maxHbondAccPlaneAngle

maxHbondAccPlaneAngle: number = 90

maxHbondDist

maxHbondDist: number = 3.5

maxHbondDonAngle

maxHbondDonAngle: number = 45

maxHbondDonPlaneAngle

maxHbondDonPlaneAngle: number = 30

maxHbondSulfurDist

maxHbondSulfurDist: number = 4.1

maxHydrophobicDist

maxHydrophobicDist: number = 4

maxIonicDist

maxIonicDist: number = 5

maxMetalDist

maxMetalDist: number = 3

maxPiStackingAngle

maxPiStackingAngle: number = 30

maxPiStackingDist

maxPiStackingDist: number = 5.5

maxPiStackingOffset

maxPiStackingOffset: number = 2

refineSaltBridges

refineSaltBridges: boolean = true

Const ContactLabelDefaultParams

ContactLabelDefaultParams: object

size

size: number = 2

unit

unit: string = ""

Const CovalentRadii

CovalentRadii: object

1

1: number = 0.31

10

10: number = 0.58

100

100: number = 1.6

101

101: number = 1.6

102

102: number = 1.6

103

103: number = 1.6

104

104: number = 1.6

105

105: number = 1.6

106

106: number = 1.6

107

107: number = 1.6

108

108: number = 1.6

109

109: number = 1.6

11

11: number = 1.66

110

110: number = 1.6

111

111: number = 1.6

112

112: number = 1.6

113

113: number = 1.6

114

114: number = 1.6

115

115: number = 1.6

116

116: number = 1.6

117

117: number = 1.6

118

118: number = 1.6

12

12: number = 1.41

13

13: number = 1.21

14

14: number = 1.11

15

15: number = 1.07

16

16: number = 1.05

17

17: number = 1.02

18

18: number = 1.06

19

19: number = 2.03

2

2: number = 0.28

20

20: number = 1.76

21

21: number = 1.7

22

22: number = 1.6

23

23: number = 1.53

24

24: number = 1.39

25

25: number = 1.39

26

26: number = 1.32

27

27: number = 1.26

28

28: number = 1.24

29

29: number = 1.32

3

3: number = 1.28

30

30: number = 1.22

31

31: number = 1.22

32

32: number = 1.2

33

33: number = 1.19

34

34: number = 1.2

35

35: number = 1.2

36

36: number = 1.16

37

37: number = 2.2

38

38: number = 1.95

39

39: number = 1.9

4

4: number = 0.96

40

40: number = 1.75

41

41: number = 1.64

42

42: number = 1.54

43

43: number = 1.47

44

44: number = 1.46

45

45: number = 1.42

46

46: number = 1.39

47

47: number = 1.45

48

48: number = 1.44

49

49: number = 1.42

5

5: number = 0.84

50

50: number = 1.39

51

51: number = 1.39

52

52: number = 1.38

53

53: number = 1.39

54

54: number = 1.4

55

55: number = 2.44

56

56: number = 2.15

57

57: number = 2.07

58

58: number = 2.04

59

59: number = 2.03

6

6: number = 0.76

60

60: number = 2.01

61

61: number = 1.99

62

62: number = 1.98

63

63: number = 1.98

64

64: number = 1.96

65

65: number = 1.94

66

66: number = 1.92

67

67: number = 1.92

68

68: number = 1.89

69

69: number = 1.9

7

7: number = 0.71

70

70: number = 1.87

71

71: number = 1.87

72

72: number = 1.75

73

73: number = 1.7

74

74: number = 1.62

75

75: number = 1.51

76

76: number = 1.44

77

77: number = 1.41

78

78: number = 1.36

79

79: number = 1.36

8

8: number = 0.66

80

80: number = 1.32

81

81: number = 1.45

82

82: number = 1.46

83

83: number = 1.48

84

84: number = 1.4

85

85: number = 1.5

86

86: number = 1.5

87

87: number = 2.6

88

88: number = 2.21

89

89: number = 2.15

9

9: number = 0.57

90

90: number = 2.06

91

91: number = 2

92

92: number = 1.96

93

93: number = 1.9

94

94: number = 1.87

95

95: number = 1.8

96

96: number = 1.69

97

97: number = 1.6

98

98: number = 1.6

99

99: number = 1.6

Const DefaultBoxParams

DefaultBoxParams: object

a

a: number = 1

alpha

alpha: number = 90

b

b: number = 1

beta

beta: number = 90

c

c: number = 1

gamma

gamma: number = 90

spacegroup

spacegroup: string = "P 1"

Const DnaPdbsContent

DnaPdbsContent: object

DCDG

DCDG: string = dcdgPdbString

DTDA

DTDA: string = dtdaPdbString

Const ElementColors

ElementColors: object

AC

AC: number = 7384058

AG

AG: number = 12632256

AL

AL: number = 12560038

AM

AM: number = 5528818

AR

AR: number = 8442339

AS

AS: number = 12419299

AT

AT: number = 7688005

AU

AU: number = 16765219

B

B: number = 16758197

BA

BA: number = 51456

BE

BE: number = 12779264

BH

BH: number = 14680120

BI

BI: number = 10375093

BK

BK: number = 9064419

BR

BR: number = 10889513

C

C: number = 9474192

CA

CA: number = 4062976

CD

CD: number = 16767375

CE

CE: number = 16777159

CF

CF: number = 10565332

CL

CL: number = 2093087

CM

CM: number = 7888099

CN

CN: number = 16777215

CO

CO: number = 15765664

CR

CR: number = 9083335

CS

CS: number = 5707663

CU

CU: number = 13140019

D

D: number = 16777152

DB

DB: number = 13697103

DS

DS: number = 16777215

DY

DY: number = 2097095

ER

ER: number = 58997

ES

ES: number = 11739092

EU

EU: number = 6422471

F

F: number = 9494608

FE

FE: number = 14706227

FL

FL: number = 16777215

FM

FM: number = 11739066

FR

FR: number = 4325478

GA

GA: number = 12750735

GD

GD: number = 4587463

GE

GE: number = 6721423

H

H: number = 16777215

HE

HE: number = 14286847

HF

HF: number = 5096191

HG

HG: number = 12105936

HO

HO: number = 65436

HS

HS: number = 15073326

I

I: number = 9699476

IN

IN: number = 10909043

IR

IR: number = 1528967

K

K: number = 9388244

KR

KR: number = 6076625

LA

LA: number = 7394559

LI

LI: number = 13402367

LR

LR: number = 13041766

LU

LU: number = 43812

LV

LV: number = 16777215

MD

MD: number = 11734438

MG

MG: number = 9109248

MN

MN: number = 10255047

MO

MO: number = 5551541

MT

MT: number = 15400998

N

N: number = 3166456

NA

NA: number = 11230450

NB

NB: number = 7586505

ND

ND: number = 13107143

NE

NE: number = 11789301

NI

NI: number = 5296208

NO

NO: number = 12389767

NP

NP: number = 33023

O

O: number = 16715021

OS

OS: number = 2516630

P

P: number = 16744448

PA

PA: number = 41471

PB

PB: number = 5724513

PD

PD: number = 27013

PM

PM: number = 10747847

PO

PO: number = 11230208

PR

PR: number = 14286791

PT

PT: number = 13684960

PU

PU: number = 27647

RA

RA: number = 32000

RB

RB: number = 7351984

RE

RE: number = 2522539

RF

RF: number = 13369433

RG

RG: number = 16777215

RH

RH: number = 687500

RN

RN: number = 4358806

RU

RU: number = 2396047

S

S: number = 16777008

SB

SB: number = 10380213

SC

SC: number = 15132390

SE

SE: number = 16752896

SG

SG: number = 14221381

SI

SI: number = 15780000

SM

SM: number = 9437127

SN

SN: number = 6717568

SR

SR: number = 65280

T

T: number = 16777120

TA

TA: number = 5089023

TB

TB: number = 3211207

TC

TC: number = 3907230

TE

TE: number = 13924864

TH

TH: number = 47871

TI

TI: number = 12567239

TL

TL: number = 10900557

TM

TM: number = 54354

U

U: number = 36863

UUH

UUH: number = 16777215

UUP

UUP: number = 16777215

UUT

UUT: number = 16777215

V

V: number = 10921643

W

W: number = 2200790

XE

XE: number = 9699476

Y

Y: number = 9764863

YB

YB: number = 48952

ZN

ZN: number = 8224944

ZR

ZR: number = 9756896

Const ElementDefaultParameters

ElementDefaultParameters: object

name

name: string = "some element"

status

status: string = ""

Const EncodedSymOp

EncodedSymOp: object

A 1 2 1

A 1 2 1: string = " !#$!& )+$)-"

A b a 2

A b a 2: string = " !#$%#(,#*)# )+$,+(%+*!+"

A b m 2

A b m 2: string = " !#$%# ,#$)# )+$,+ %+$!+"

A m a 2

A m a 2: string = " !#$%#(%#*!# )+$,+(,+*)+"

A m m 2

A m m 2: string = " !#$%# %#$!# )+$,+ ,+$)+"

B 1 1 2

B 1 1 2: string = " !#$%#(g+*%+"

B 1 1 2/b

B 1 1 2/b: string = " !#$,#$%& )&(!+*,+*%-()-"

B 1 1 2/m

B 1 1 2/m: string = " !# !&$%#$%&(!+(!-*%+*%-"

B 1 1 b

B 1 1 b: string = " !# )&(!+()-"

B 1 1 m

B 1 1 m: string = " !# !&(!+(!-"

C 1 2 1

C 1 2 1: string = " !#$!&()#*)&"

C 1 2/c 1

C 1 2/c 1: string = " !#$!-$%& %+()#*)-*,&(,+"

C 1 2/m 1

C 1 2/m 1: string = " !# %#$!&$%&()#(,#*)&*,&"

C 1 21 1

C 1 21 1: string = " !#$)&()#*!&"

C 1 c 1

C 1 c 1: string = " !# %+()#(,+"

C 1 m 1

C 1 m 1: string = " !# %#()#(,#"

C 2 2 2

C 2 2 2: string = " !#$%#$!& %&()#*,#*)&(,&"

C 2 2 21

C 2 2 21: string = " !#$%+$!- %&()#*,+*)-(,&"

C 2 2 21a)

C 2 2 21a): string = " !#*%+(,&$)-()#$,+ %&*!-"

C 2 2 2a

C 2 2 2a: string = " !#*,#.%&$'&()#$%# ,&*!&"

C 2/c 2/c 2/a

C 2/c 2/c 2/a: string = " !#*,#$!&(,&$,-(!- ,+*!+()#$%#*)& %&*%- )-(%+$)+"

C 2/c 2/c 2/m

C 2/c 2/c 2/m: string = " !#$%#$!- %-$%& !& %+$!+()#*,#*)-(,-*,&()&(,+*)+"

C 2/m 2/c 21/a

C 2/m 2/c 21/a: string = " !#$,+$)- %&$%& )- ,+$!#()#*%+*!-(,&*,&(!-(%+*)#"

C 2/m 2/c 21/m

C 2/m 2/c 21/m: string = " !#$%+$!- %&$%& !- %+$!#()#*,+*)-(,&*,&()-(,+*)#"

C 2/m 2/m 2/a

C 2/m 2/m 2/a: string = " !#$,#$)& %&$%& )& ,#$!#()#*%#*!&(,&*,&(!&(%#*)#"

C 2/m 2/m 2/m

C 2/m 2/m 2/m: string = " !#$%#$!& %&$%& !& %#$!#()#*,#*)&(,&*,&()&(,#*)#"

C c c 2

C c c 2: string = " !#$%# %+$!+()#*,#(,+*)+"

C m c 21

C m c 21: string = " !#$%+ %+$!#()#*,+(,+*)#"

C m m 2

C m m 2: string = " !#$%# %#$!#()#*,#(,#*)#"

F -4 3 c

F -4 3 c: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )(+,*+)*-,(-(+)*+,*-)(-,+)(+,*-)*-,( )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-() #,$#)$&, &(#!*#%*&!(&%+! +%$-!$-% (!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&(!(#%*#!*&%(& +!$+%$-! -%#) #,$&)$&, ()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- ! +%$+!$-% - #)$#,$&) &,#!(#%*&!*&%("

F -4 3 m

F -4 3 m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! #%$#!$&% & #!$#%$&! &%#! #%$&!$&% )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-(!(+%*+!*-%(- +)$+,$-) -,#)(#,*&)*&,((!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&() +,$+)$-, -(#)*#,*&)(&,+!(+%*-!*-%(()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- )(#,*#)*&,(&(+!*+%*-!(-%+) +,$-)$-, "

F 2 2 2

F 2 2 2: string = " !#$%#$!& %& )+$,+$)- ,-(!+*%+*!-(%-()#*,#*)&(,&"

F 2 2 2a

F 2 2 2a: string = " !#*,#.%&$'& '/*%/.12$!2.!/$,/ %20'2.'#$%# 1&0!&"

F 2 3

F 2 3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-((!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&(()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- "

F 2/d -3

F 2/d -3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& 64=37=345675=64=375345674=67=3453756 )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-(68>3:>3896:9=<8=;:5;85<:4><7>;49;79<(!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&(<4>;7>;49<79>68>3:93896:8=<:=;85;:5<()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- <8=;:=;8f<:f><4>;79;49<78>6:>3893:96"

F 2/d 2/d 2/d

F 2/d 2/d 2/d: string = " !#$%#$!& %&64=37=345675 )+$,+$)- ,-68>3:>3896:9(!+*%+*!-(%-<4>;7>;49<79()#*,#*)&(,&<8=;:=;85<:5"

F 2/m -3

F 2/m -3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& $%& !& %#$!#&$%& !# %#$!%&$!& %# !#$ )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-($,- )- ,+$)+&*,&()#(,#*)%-*!-(%+(!+*(!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&(*%-(!-(%+*!+-$,- )+ ,+$),&*)&(,#()#*()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- *,&()&(,#*)#-*%-(!+(%+*!,-$)- ,+ )+$"

F 2/m 2/m 2/m

F 2/m 2/m 2/m: string = " !#$%#$!& %&$%& !& %#$!# )+$,+$)- ,-$,- )- ,+$)+(!+*%+*!-(%-*%-(!-(%+*!+()#*,#*)&(,&*,&()&(,#*)#"

F 4 3 2

F 4 3 2: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$ )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-(!(-%*-!*+%(+ +,$+)$-, -)#)*#,(&)(&,*(!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&() -,$-)$+, +(#,*#)*&,(&)+!*+%(-!(-%*()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- )(&,*&)*#,(#(+%*+!*-%(-!+)$+, -) -,$"

F 4/m -3 2/c

F 4/m -3 2/c: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )(-,*-)*+,(+(+,*+)*-,(-)+)*+,(-)(-,*$%& !& %#$!#&$%& !# %#$!%&$!& %# !#$,*+)(+,(-)*-*-)(-,(+)*+,-,(-)*+,*+)( )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-() &,$&)$#, #(#%*#!*&%(&!+!$+% -! -%$$,- )- ,+$)+&*,&()#(,#*)%-*!-(%+(!+*,$#) #, &)$&*&!(&%(#!*#%-% -!$+%$+! (!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&(!(&%*&!*#%(# +%$+!$-% -!#)$#, &) &,$*%-(!-(%+*!+-$,- )+ ,+$),&*)&(,#()#*%*#!(#%(&!*&$-! -% +!$+%&, &)$#,$#) ()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- ! -%$-!$+% + #,$#)$&, &)#!*#%(&!(&%**,&()&(,#*)#-*%-(!+(%+*!,-$)- ,+ )+$%$+! +% -!$-$&) &, #)$#,&%(&!*#%*#!("

F 4/m -3 2/m

F 4/m -3 2/m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$$%& !& %#$!#&$%& !# %#$!%&$!& %# !#$%$#! #% &!$&$&! &% #!$#%&% &!$#%$#! )+$,+$)- ,-#()#*,&*)&(,!+(%+*!-*%-(!(-%*-!*+%(+ +,$+)$-, -)#)*#,(&)(&,*$,- )- ,+$)+&*,&()#(,#*)%-*!-(%+(!+*%*+!(+%(-!*-$-) -, +)$+,&,(&)*#,*#)((!+*%+*!-(%-+ )+$,-$)- ,)#(,#*)&*,&() -,$-)$+, +(#,*#)*&,(&)+!*+%(-!(-%**%-(!-(%+*!+-$,- )+ ,+$),&*)&(,#()#*,$+) +, -)$-*&)(&,(#)*#,-%(-!*+%*+!(()#*,#*)&(,&+(!+*%-*!-(%)+ ,+$)-$,- )(&,*&)*#,(#(+%*+!*-%(-!+)$+, -) -,$*,&()&(,#*)#-*%-(!+(%+*!,-$)- ,+ )+$,*#)(#,(&)*&*-!(-%(+!*+%-, -)$+,$+) "

F 41 3 2

F 41 3 2: string = " !#$,+*)&(%-# !+$,&*)-(%!# ,+$)&*%-(:3>46=7<98;5;58<976=43>:97<58;>:3=46 )+$%#*!-(,&#()+*%&$!- ,!+(,#*)-$%& :;=4<>765839;94<5:6>83=79:6543>7;=8<(!+*,#$)- %&+ )#$%-*!&(,)#(%+*!&$,- 73=86>:<54;935469:<=8;>7576983=:;>4<()#*%+$!& ,-+(!#*,-$)& %)+ %#$!-*,&(7;>8<=:69435398657<>4;=:5:<94;=73>86"

F 41/d -3 2/c

F 41/d -3 2/c: string = " !#$,+*)&(%-# !+$,&*)-(%!# ,+$)&*%-(:3>46=7<98;5;58<976=43>:97<58;>:3=46<8>;7=3496:5><8=;793456:8><7=;493:56%*#)(+, &!$-$-! &,(+)*#%&, -!$#%*+)( )+$%#*!-(,&#()+*%&$!- ,!+(,#*)-$%& :;=4<>765839;94<5:6>83=79:6543>7;=8<<4=;:>385679>64=3:9;85<78=67>345;:9<%$+) #,(-!*&$&) -%(#!*+,&%(-)*#,$+! (!+*,#$)- %&+ )#$%-*!&(,)#(%+*!&$,- 73=86>:<54;935469:<=8;>7576983=:;>4<68=37>;45<:9=<4>;:5389674>6:=389;75<,*+!(#% -)$&*-)(&% +!$#,-,(&!*+%$#) ()#*%+$!& ,-+(!#*,-$)& %)+ %#$!-*,&(7;>8<=:69435398657<>4;=:5:<94;=73>8664>3:=;89<75=68>375;49<:4=<:>;853796,$#! +%(&)*-*&!(-, #)$+%-% &)$+,*#!("

F 41/d -3 2/m

F 41/d -3 2/m: string = " !#$,+*)&(%-# !+$,&*)-(%!# ,+$)&*%-(:3>46=7<98;5;58<976=43>:97<58;>:3=4664=3:>;85<79=64>3:5;89<74=6:>385;79<,$+! #%(-)*&*&)(-% #!$+,-%(&)*+,$#! )+$%#*!-(,&#()+*%&$!- ,!+(,#*)-$%& :;=4<>765839;94<5:6>83=79:6543>7;=8<68>37=;49<:5=<8>;753496:4><:=;893756,*#!(+% &)$-*-!(&, +)$#%-, &!$+%*#)((!+*,#$)- %&+ )#$%-*!&(,)#(%+*!&$,- 73=86>:<54;935469:<=8;>7576983=:;>4<<4>;:=389675>68=379;45<:8=<7>;453:96%$#) +,(&!*-$&! -,(#)*+%&% -)$#,*+!(()#*%+$!& ,-+(!#*,-$)& %)+ %#$!-*,&(7;>8<=:69435398657<>4;=:5:<94;=73>86<8=;7>3456:9><4=;:9385678>67=349;:5<%*+)(#, -!$&$-) &%(+!*#,&,(-!*#%$+) "

F d d 2

F d d 2: string = " !#$%#345675 )+$,+3896:9(!+*%+;49<79()#*,#;85<:5"

F m m 2

F m m 2: string = " !#$%# %#$!# )+$,+ ,+$)+(!+*%+(%+*!+()#*,#(,#*)#"

H -3

H -3: string = " !#%?#@$#$%&!@&? &OPQRSQTUQVWXYZX[]X]Y^W[^ZV^UR_PT_SO_"

H -3 2/c

H -3 2/c: string = " !#%?#@$#! -?%-$@-$%&!@&? &%$+@!+ ?+OPQRSQTUQY]b[WbVZbVWXYZX[]XRU`TP`OS`]Y^W[^ZV^POcSRcUTcUR_PT_SO_WVaZYa][a"

H -3 2/m

H -3 2/m: string = " !#%?#@$#! &?%&$@&$%&!@&? &%$#@!# ?#OPQRSQTUQY]X[WXVZXVWXYZX[]XRUQTPQOSQ]Y^W[^ZV^PO_SR_UT_UR_PT_SO_WV^ZY^][^"

H 3

H 3: string = " !#%?#@$#CDAEFAGHAIJBKLBMNB"

H 3 2

H 3 2: string = " !#%?#@$#! &?%&$@&OPQRSQTUQY]X[WXVZX]Y^W[^ZV^PO_SR_UT_"

H 3 c

H 3 c: string = " !#%?#@$#%$+@!+ ?+OPQRSQTUQRU`TP`OS`]Y^W[^ZV^WVaZYa][a"

H 3 m

H 3 m: string = " !#%?#@$#%$#@!# ?#OPQRSQTUQRUQTPQOSQ]Y^W[^ZV^WV^ZY^][^"

I -4

I -4: string = " !#$%#!$&% &()+*,+)*-,(-"

I -4 2 d

I -4 2 d: string = " !#$%#% &!$&*!>(%>,$9) 9()+*,+,(-)*-$)= ,=%*5!(5"

I -4 2 m

I -4 2 m: string = " !#$%#% &!$&$!& %&%$#! #()+*,+,(-)*-*)-(,-,*+)(+"

I -4 3 d

I -4 3 d: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&(7354<9:6>8;=357<946>:;=857394<>:6=8;()+$,#*!& %-+()#$,&*!- %)+(,#$!&*%- :;98657<=43>;9:658<=73>49:;586=7<>43"

I -4 3 m

I -4 3 m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! #%$#!$&% & #!$#%$&! &%#! #%$&!$&% ()+*,+*)-(,-+()+*,-*)-(,)+(,+*)-*,-()(+,*+)*-,(-(+)*+,*-)(-,+)(+,*-)*-,("

I -4 c 2

I -4 c 2: string = " !#$%#% &!$& %+$!+! -%$-()+*,+,(-)*-(,#*)#)(&,*&"

I -4 m 2

I -4 m 2: string = " !#$%#% &!$& %#$!#! &%$&()+*,+,(-)*-(,+*)+)(-,*-"

I 1 2 1

I 1 2 1: string = " !#$!&.'/0'2"

I 1 21 1

I 1 21 1: string = " !#$)&.'/0!-"

I 2 2 2

I 2 2 2: string = " !#$%# %&$!&.'/01/.120'2"

I 2 2 2a

I 2 2 2a: string = " !#*,#.%&$'&()+$%+*!- ,-"

I 2 3

I 2 3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ()+*,+*)-(,-+()+*,-*)-(,)+(,+*)-*,-("

I 2 3a

I 2 3a: string = " !#*,#.%&$'&!# ,- '&$%/$# !-*!/$%&.%()+$%+ ,-*!-)+(%&(!-*,#*+()&$)#*,- ,"

I 2/b 2/a 2/m

I 2/b 2/a 2/m: string = " !#$%#*)&(,&$%& !&(,#*)#()+*,+$!- %-*,-()- %+$!+"

I 2/m -3

I 2/m -3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& $%& !& %#$!#&$%& !# %#$!%&$!& %# !#$()+*,+*)-(,-+()+*,-*)-(,)+(,+*)-*,-(*,-()-(,+*)+-*,-()+(,+*),-*)-(,+()+*"

I 2/m 2/m 2/m

I 2/m 2/m 2/m: string = " !#$%#$!& %&$%& !& %#$!#()+*,+*)-(,-*,-()-(,+*)+"

I 21 21 21

I 21 21 21: string = " !#*%+$)-(,&()+$,#*!& %-"

I 21 3

I 21 3: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&(()+$,#*!& %-+()#$,&*!- %)+(,#$!&*%- "

I 21/a -3

I 21/a -3: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&($%&(!- ,+*)#&$%-(!+ ,#*)%&$!-(,+ )#*()+$,#*g& %-+()#$,&*!- %)+(,#$!&*%- *,- )&(%#$!+-*,& )#(%+$!,-*)& %#(!+$"

I 21/b 21/c 21/a

I 21/b 21/c 21/a: string = " !#*%+$)-(,&$%&(!- ,+*)#()+$,#*!& %-*,- )&(%#$!+"

I 21/m 21/m 21/a

I 21/m 21/m 21/a: string = " !#$,#$)& %&$%& )& ,#$!#()+*%+*!-(,-*,-(!-(%+*)+"

I 4

I 4: string = " !#$%#% #!$#()+*,+,(+)*+"

I 4 2 2

I 4 2 2: string = " !#$%#% #!$#$!& %&! &%$&()+*,+,(+)*+*)-(,-)(-,*-"

I 4 3 2

I 4 3 2: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$()+*,+*)-(,-+()+*,-*)-(,)+(,+*)-*,-()(-,*-)*+,(+(+,*+)*-,(-)+)*+,(-)(-,*"

I 4 c m

I 4 c m: string = " !#$%#% #!$# %+$!+%$+! +()+*,+,(+)*+(,#*)#,*#)(#"

I 4 m m

I 4 m m: string = " !#$%#% #!$# %#$!#%$#! #()+*,+,(+)*+(,+*)+,*+)(+"

I 4/m

I 4/m: string = " !#$%#% #!$#$%& !&!$&% &()+*,+,(+)*+*,-()-)*-,(-"

I 4/m -3 2/m

I 4/m -3 2/m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$$%& !& %#$!#&$%& !# %#$!%&$!& %# !#$%$#! #% &!$&$&! &% #!$#%&% &!$#%$#! ()+*,+*)-(,-+()+*,-*)-(,)+(,+*)-*,-()(-,*-)*+,(+(+,*+)*-,(-)+)*+,(-)(-,**,-()-(,+*)+-*,-()+(,+*),-*)-(,+()+*,*+)(+,(-)*-*-)(-,(+)*+,-,(-)*+,*+)("

I 4/m 2/c 2/m

I 4/m 2/c 2/m: string = " !#$%#% #!$#$!- %-! -%$-$%& !&!$&% & %+$!+%$+! +()+*,+,(+)*+*)&(,&)(&,*&*,-()-)*-,(-(,#*)#,*#)(#"

I 4/m 2/m 2/m

I 4/m 2/m 2/m: string = " !#$%#% #!$#$!& %&! &%$&$%& !&!$&% & %#$!#%$#! #()+*,+,(+)*+*)-(,-)(-,*-*,-()-)*-,(-(,+*)+,*+)(+"

I 41

I 41: string = " !#*,+%(5)$9()+$%#, 9!*5"

I 41 2 2

I 41 2 2: string = " !#*,+%(5)$9*!> ,=)(-%$&()+$%#, 9!*5$)=(%>! &,*-"

I 41 3 2

I 41 3 2: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&(:3=8<>7694;5;54697<>83=:97654;=:3>8<()+$,#*!& %-+()#$,&*!- %)+(,#$!&*%- 7;>46=:<5839398<5:6=4;>75:<983>7;=46"

I 41 c d

I 41 c d: string = " !#*,+%(5)$9 %+*)#%*9) 5()+$%#, 9!*5(,#$!+,$5!(9"

I 41 m d

I 41 m d: string = " !#*,+%(5)$9 %#*)+%*5) 9()+$%#, 9!*5(,+$!#,$9!(5"

I 41/a

I 41/a: string = " !#*,+%(5)$9$,=(!>!$&,(-()+$%#, 9!*5*%> )=)*-% &"

I 41/a -3 2/d

I 41/a -3 2/d: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&(:3=8<>7694;5;54697<>83=:97654;=:3>8<$%&(!- ,+*)#&$%-(!+ ,#*)%&$!-(,+ )#*4<97358;=:6>6>:;=8357<94=8;>:694<573()+$,#*!& %-+()#$,&*!- %)+(,#$!&*%- 7;>46=:<5839398<5:6=4;>75:<983>7;=46*,- )&(%#$!+-*,& )#(%+$!,-*)& %#(!+$865:;943>7<=<=73>4;9:658>43=7<5869:;"

I 41/a 2/c 2/d

I 41/a 2/c 2/d: string = " !#*,+%(5)$9*!= ,>)(&%$-$,=(!>!$&,(-(,#$!+,$5!(9()+$%#, 9!*5$)>(%=! -,*&*%> )=)*-% & %+*)#%*9) 5"

I 41/a 2/m 2/d

I 41/a 2/m 2/d: string = " !#*,+%(5)$9*!> ,=)(-%$&$,=(!>!$&,(-(,+$!#,$9!(5()+$%#, 9!*5$)=(%>! &,*-*%> )=)*-% & %#*)+%*5) 9"

I b a 2

I b a 2: string = " !#$%#(,#*)#()+*,+ %+$!+"

I m a 2

I m a 2: string = " !#$%#(%#*!#()+*,+ ,+$)+"

I m m 2

I m m 2: string = " !#$%# %#$!#()+*,+(,+*)+"

P -1

P -1: string = " !#$%&"

P -3

P -3: string = " !#%?#@$#$%&!@&? &"

P -3 1 2/c

P -3 1 2/c: string = " !#%?#@$#%$-@!- ?-$%&!@&? &! +?%+$@+"

P -3 1 2/m

P -3 1 2/m: string = " !#%?#@$#%$&@!& ?&$%&!@&? &! #?%#$@#"

P -3 2/c 1

P -3 2/c 1: string = " !#%?#@$#! -?%-$@-$%&!@&? &%$+@!+ ?+"

P -3 2/m 1

P -3 2/m 1: string = " !#%?#@$#! &?%&$@&$%&!@&? &%$#@!# ?#"

P -4

P -4: string = " !#$%#!$&% &"

P -4 2 c

P -4 2 c: string = " !#$%#% &!$&$!- %-%$+! +"

P -4 2 m

P -4 2 m: string = " !#$%#% &!$&$!& %&%$#! #"

P -4 21 c

P -4 21 c: string = " !#$%#% &!$&*)-(,-,*+)(+"

P -4 21 m

P -4 21 m: string = " !#$%#% &!$&*)&(,&,*#)(#"

P -4 3 m

P -4 3 m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! #%$#!$&% & #!$#%$&! &%#! #%$&!$&% "

P -4 3 n

P -4 3 n: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )(+,*+)*-,(-(+)*+,*-)(-,+)(+,*-)*-,("

P -4 b 2

P -4 b 2: string = " !#$%#% &!$&(,#*)#)(&,*&"

P -4 c 2

P -4 c 2: string = " !#$%#% &!$& %+$!+! -%$-"

P -4 m 2

P -4 m 2: string = " !#$%#!$&% & %#$!#! &%$&"

P -4 n 2

P -4 n 2: string = " !#$%#% &!$&(,+*)+)(-,*-"

P -6

P -6: string = " !#%?#@$# !&%?&@$&"

P -6 2 c

P -6 2 c: string = " !#%?#@$# !-%?-@$-! &?%&$@&! +?%+$@+"

P -6 2 m

P -6 2 m: string = " !#%?#@$# !&%?&@$&! &?%&$@&! #?%#$@#"

P -6 c 2

P -6 c 2: string = " !#%?#@$# !-%?-@$-%$+@!+ ?+%$&@!& ?&"

P -6 m 2

P -6 m 2: string = " !#%?#@$# !&%?&@$&%$#@!# ?#%$&@!& ?&"

P 1

P 1: string = " !#"

P 1 1 2

P 1 1 2: string = " !#$%#"

P 1 1 2/b

P 1 1 2/b: string = " !#$,#$%& )&"

P 1 1 2/m

P 1 1 2/m: string = " !# !&$%#$%&"

P 1 1 21

P 1 1 21: string = " !#$%+"

P 1 1 21/b

P 1 1 21/b: string = " !#$%&$,+ )-"

P 1 1 21/m

P 1 1 21/m: string = " !#$%+$%& !-"

P 1 1 b

P 1 1 b: string = " !# )&"

P 1 1 m

P 1 1 m: string = " !# !&"

P 1 2 1

P 1 2 1: string = " !#$!&"

P 1 2/c 1

P 1 2/c 1: string = " !#$!-$%& %+"

P 1 2/m 1

P 1 2/m 1: string = " !# %#$!&$%&"

P 1 21 1

P 1 21 1: string = " !#$'&"

P 1 21/c 1

P 1 21/c 1: string = " !#$%&$)- ,+"

P 1 21/m 1

P 1 21/m 1: string = " !#$)&$%& ,#"

P 1 c 1

P 1 c 1: string = " !# %+"

P 1 m 1

P 1 m 1: string = " !# %#"

P 2 2 2

P 2 2 2: string = " !#$%#$!& %&"

P 2 2 21

P 2 2 21: string = " !#$%+$!- %&"

P 2 21 2

P 2 21 2: string = " !# ,&$)&$%#"

P 2 21 21

P 2 21 21: string = " !# %&$)-$,+"

P 2 3

P 2 3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& "

P 2/b 2/a 2/n

P 2/b 2/a 2/n: string = " !#$%#$!& %&*,&()&(,#*)#"

P 2/b 21/c 21/m

P 2/b 21/c 21/m: string = " !#$%+$)- ,&$%& !- ,+$)#"

P 2/c 2/c 2/m

P 2/c 2/c 2/m: string = " !#$%#$!- %-$%& !& %+$!+"

P 2/m -3

P 2/m -3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& $%& !& %#$!#&$%& !# %#$!%&$!& %# !#$"

P 2/m 2/m 2/m

P 2/m 2/m 2/m: string = " !#$%#$!& %&$%& !& %#$!#"

P 2/m 2/n 21/a

P 2/m 2/n 21/a: string = " !#*%+*!- %&$%&(!-(%+$!#"

P 2/n -3

P 2/n -3: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& *,-()-(,+*)+-*,-()+(,+*),-*)-(,+()+*"

P 2/n 2/n 2/n

P 2/n 2/n 2/n: string = " !#$%#$!& %&*,-()-(,+*)+"

P 2/n 21/n 2/a

P 2/n 21/n 2/a: string = " !#*%#*)- ,-$%&(!&(,+$)+"

P 21 2 2

P 21 2 2: string = " !#$!&(%&*%#"

P 21 2 21

P 21 2 21: string = " !#$!&(%-*%+"

P 21 21 2

P 21 21 2: string = " !#$%#*)&(,&"

P 21 21 2 (a)

P 21 21 2 (a): string = " !#*,#.%&$'&"

P 21 21 21

P 21 21 21: string = " !#*%+$)-(,&"

P 21 3

P 21 3: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&("

P 21/a -3

P 21/a -3: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&($%&(!- ,+*)#&$%-(!+ ,#*)%&$!-(,+ )#*"

P 21/b 2/c 21/n

P 21/b 2/c 21/n: string = " !#*,+$!-(,&$%&()- %+*)#"

P 21/b 21/a 2/m

P 21/b 21/a 2/m: string = " !#$%#*)&(,&$%& !&(,#*)#"

P 21/b 21/c 21/a

P 21/b 21/c 21/a: string = " !#*%+$)-(,&$%&(!- ,+*)#"

P 21/c 2/c 2/a

P 21/c 2/c 2/a: string = " !#*%#$!-(%-$%&(!& %+*!+"

P 21/c 21/c 2/n

P 21/c 21/c 2/n: string = " !#*,#$)-(%-$%&()& ,+*!+"

P 21/m 2/m 2/a

P 21/m 2/m 2/a: string = " !#*%#$!&(%&$%&(!& %#*!#"

P 21/m 21/m 2/n

P 21/m 21/m 2/n: string = " !#$%#*'&.,&*,&.'& %#$!#"

P 21/m 21/m 2/n a

P 21/m 21/m 2/n a: string = " !#*,#$)&(%&$%&.'& ,#*!#"

P 21/n 21/m 21/a

P 21/n 21/m 21/a: string = " !#0%/$'&.12$%&.!2 1#0'/"

P 21/n 21/n 2/m

P 21/n 21/n 2/m: string = " !#$%#*)-(,-$%& !&(,+*)+"

P 3

P 3: string = " !#%?#@$#"

P 3 1 2

P 3 1 2: string = " !#%?#@$#%$&@!& ?&"

P 3 1 c

P 3 1 c: string = " !#%?#@$#! +?%+$@+"

P 3 1 m

P 3 1 m: string = " !#%?#@$#! #?%#$@#"

P 3 2 1

P 3 2 1: string = " !#%?#@$#! &?%&$@&"

P 3 c 1

P 3 c 1: string = " !#%?#@$#%$+@!+ ?+"

P 3 m 1

P 3 m 1: string = " !#%?#@$#%$#@!# ?#"

P 31

P 31: string = " !#%?A@$B"

P 31 1 2

P 31 1 2: string = " !#%?Q@$^%$_@!X ?&"

P 31 2 1

P 31 2 1: string = " !#%?A@$B! &?%_$@X"

P 32

P 32: string = " !#%?B@$A"

P 32 1 2

P 32 1 2: string = " !#%?^@$Q%$X@!_ ?&"

P 32 2 1

P 32 2 1: string = " !#%?B@$A! &?%X$@_"

P 4

P 4: string = " !#$%#% #!$#"

P 4 2 2

P 4 2 2: string = " !#$%#% #!$#$!& %&! &%$&"

P 4 21 2

P 4 21 2: string = " !#$%#,(#)*#*)&(,&! &%$&"

P 4 3 2

P 4 3 2: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$"

P 4 b m

P 4 b m: string = " !#$%#% #!$#(,#*)#,*#)(#"

P 4 c c

P 4 c c: string = " !#$%#% #!$# %+$!+%$+! +"

P 4 m m

P 4 m m: string = " !#$%#% #!$# %#$!#%$#! #"

P 4 n c

P 4 n c: string = " !#$%#% #!$#(,+*)+,*+)(+"

P 4/m

P 4/m: string = " !#$%#% #!$#$%& !&!$&% &"

P 4/m -3 2/m

P 4/m -3 2/m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$$%& !& %#$!#&$%& !# %#$!%&$!& %# !#$%$#! #% &!$&$&! &% #!$#%&% &!$#%$#! "

P 4/m 2/c 2/c

P 4/m 2/c 2/c: string = " !#$%#% #!$#$!- %-! -%$-$%& !&!$&% & %+$!+%$+! +"

P 4/m 2/m 2/m

P 4/m 2/m 2/m: string = " !#$%#% #!$#$!& %&! &%$&$%& !&!$&% & %#$!#%$#! #"

P 4/m 21/b 2/m

P 4/m 21/b 2/m: string = " !#$%#% #!$#*)&(,&)(&,*&$%& !&!$&% &(,#*)#,*#)(#"

P 4/m 21/n 2/c

P 4/m 21/n 2/c: string = " !#$%#% #!$#*)-(,-)(-,*-$%& !&!$&% &(,+*)+,*+)(+"

P 4/n

P 4/n: string = " !#$%#,(#)*#*,&()&!$&% &"

P 4/n -3 2/n

P 4/n -3 2/n: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& ! &%$&!$#% # #%$#!$&% &!#!$#% &! &%$*,-()-(,+*)+-*,-()+(,+*),-*)-(,+()+*,*+)(+,(-)*-*-)(-,(+)*+,-,(-)*+,*+)("

P 4/n 2/b 2/m

P 4/n 2/b 2/m: string = " !#$%#% #!$#$!& %&! &%$&*,&()&)*&,(&(,#*)#,*#)(#"

P 4/n 2/c 2/c

P 4/n 2/c 2/c: string = " !#$%#,(#)*#*)-(,-! -%$-*,&()&!$&% & %+$!+,*+)(+"

P 4/n 2/n 2/c

P 4/n 2/n 2/c: string = " !#$%#% #!$#$!& %&! &%$&*,-()-)*-,(-(,+*)+,*+)(+"

P 4/n 21/m 2/m

P 4/n 21/m 2/m: string = " !#$%#,(#)*#*)&(,&! &%$&*,&()&!$&% & %#$!#,*#)(#"

P 41

P 41: string = " !#$%+% 5!$9"

P 41 2 2

P 41 2 2: string = " !#$%+% 5!$9$!& %-! >%$="

P 41 21 2

P 41 21 2: string = " !#$%+,(5)*9*)=(,>! &%$-"

P 41 3 2

P 41 3 2: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&(:3=8<>7694;5;54697<>83=:97654;=:3>8<"

P 42

P 42: string = " !#$%#% +!$+"

P 42 2 2

P 42 2 2: string = " !#$%#% +!$+$!& %&! -%$-"

P 42 21 2

P 42 21 2: string = " !#$%#,(+)*+*)-(,-! &%$&"

P 42 21 2a

P 42 21 2a: string = " !#*,#%.+'$+$'&.%&! -,*-"

P 42 3 2

P 42 3 2: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )(-,*-)*+,(+(+,*+)*-,(-)+)*+,(-)(-,*"

P 42 b c

P 42 b c: string = " !#$%#% +!$+(,#*)#,*+)(+"

P 42 c m

P 42 c m: string = " !#$%#% +!$+ %+$!+%$#! #"

P 42 m c

P 42 m c: string = " !#$%#% +!$+ %#$!#%$+! +"

P 42 n m

P 42 n m: string = " !#$%#,(+)*+(,+*)+%$#! #"

P 42/m

P 42/m: string = " !#$%#% +!$+$%& !&!$-% -"

P 42/m -3 2/n

P 42/m -3 2/n: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )(-,*-)*+,(+(+,*+)*-,(-)+)*+,(-)(-,*$%& !& %#$!#&$%& !# %#$!%&$!& %# !#$,*+)(+,(-)*-*-)(-,(+)*+,-,(-)*+,*+)("

P 42/m 2/c 2/m

P 42/m 2/c 2/m: string = " !#$%#% +!$+$!- %-! &%$&$%& !&!$-% - %+$!+%$#! #"

P 42/m 2/m 2/c

P 42/m 2/m 2/c: string = " !#$%#% +!$+$!& %&! -%$-$%& !&!$-% - %#$!#%$+! +"

P 42/m 21/b 2/c

P 42/m 21/b 2/c: string = " !#$%#% +!$+*)&(,&)(-,*-$%& !&!$-% -(,#*)#,*+)(+"

P 42/m 21/n 2/m

P 42/m 21/n 2/m: string = " !#$%#,./'*/*'-.,-! &%$&$%& !&'*-,.-.,/*'/%$#! #"

P 42/n

P 42/n: string = " !#$%#,(+)*+*,-()-!$&% &"

P 42/n -3 2/m

P 42/n -3 2/m: string = " !#$%#$!& %&# !#$%&$!& %!# %#$!&$%& )(-,*-)*+,(+(+,*+)*-,(-)+)*+,(-)(-,**,-()-(,+*)+-*,-()+(,+*),-*)-(,+()+*%$#! #% &!$&$&! &% #!$#%&% &!$#%$#! "

P 42/n 2/b 2/c

P 42/n 2/b 2/c: string = " !#$%#,(+)*+$!- %-)(&,*&*,-()-!$&% &(,#*)#%$+! +"

P 42/n 2/n 2/m

P 42/n 2/n 2/m: string = " !#$%#,(+)*+$!& %&)(-,*-*,-()-!$&% &(,+*)+%$#! #"

P 42/n 21/c 2/m

P 42/n 21/c 2/m: string = " !#$%#,(+)*+*)&(,&! -%$-*,-()-!$&% & %+$!+,*#)(#"

P 42/n 21/m 2/c

P 42/n 21/m 2/c: string = " !#$%#,(+)*+*)-(,-! &%$&*,-()-!$&% & %#$!#,*+)(+"

P 43

P 43: string = " !#$%+% 9!$5"

P 43 2 2

P 43 2 2: string = " !#$%+% 9!$5$!& %-! =%$>"

P 43 21 2

P 43 21 2: string = " !#$%+,(9)*5*)>(,=! &%$-"

P 43 3 2

P 43 3 2: string = " !#*%+$)-(,&# !+*%-$)&(,!# %+*)-$,&(7;>46=:<5839398<5:6=4;>75:<983>7;=46"

P 6

P 6: string = " !#%?#@$#$%#!@#? #"

P 6 2 2

P 6 2 2: string = " !#%?#@$#$%#!@#? #! &?%&$@&%$&@!& ?&"

P 6 c c

P 6 c c: string = " !#%?#@$#$%#!@#? #%$+@!+ ?+! +?%+$@+"

P 6 m m

P 6 m m: string = " !#%?#@$#$%#!@#? #%$#@!# ?#! #?%#$@#"

P 6/m

P 6/m: string = " !#%?#@$#$%#!@#? #$%&!@&? & !&%?&@$&"

P 6/m 2/c 2/c

P 6/m 2/c 2/c: string = " !#%?#@$#$%#!@#? #! -?%-$@-%$-@!- ?-$%&!@&? & !&@$&%?&%$+@!+ ?+! +?%+$@+"

P 6/m 2/m 2/m

P 6/m 2/m 2/m: string = " !#%?#@$#$%#!@#? #! &?%&$@&%$&@!& ?&$%&!@&? & !&@$&%?&%$#@!# ?#! #?%#$@#"

P 61

P 61: string = " !#%?A@$B$%/!@d? e"

P 61 2 2

P 61 2 2: string = " !#%?Q@$^$%+!@`? a! X?%&$@_%$b@!- ?c"

P 62

P 62: string = " !#%?^@$Q$%#!@^? Q"

P 62 2 2

P 62 2 2: string = " !#%?^@$Q$%#!@^? Q! _?%&$@X%$_@!& ?X"

P 63

P 63: string = " !#%?#@$#$%+!@+? +"

P 63 2 2

P 63 2 2: string = " !#%?#@$#$%+!@+? +! &?%&$@&%$-@!- ?-"

P 63 c m

P 63 c m: string = " !#%?#@$#$%+!@+? +%$+@!+ ?+! #?%#$@#"

P 63 m c

P 63 m c: string = " !#%?#@$#$%+!@+? +%$#@!# ?#! +?%+$@+"

P 63/m

P 63/m: string = " !#%?#@$#$%+!@+? +$%&!@&? & !-%?-@$-"

P 63/m 2/c 2/m

P 63/m 2/c 2/m: string = " !#%?#@$#$%+!@+? +! -?%-$@-%$&@!& ?&$%&!@&? & !-@$-%?-%$+@!+ ?+! #?%#$@#"

P 63/m 2/m 2/c

P 63/m 2/m 2/c: string = " !#%?#@$#$%+!@+? +! &?%&$@&%$-@!- ?-$%&!@&? & !-@$-%?-%$#@!# ?#! +?%+$@+"

P 64

P 64: string = " !#%?Q@$^$%#!@Q? ^"

P 64 2 2

P 64 2 2: string = " !#%?Q@$^$%#!@Q? ^! X?%&$@_%$X@!& ?_"

P 65

P 65: string = " !#%?B@$A$%/!@e? d"

P 65 2 2

P 65 2 2: string = " !#%?^@$Q$%+!@a? `! _?%&$@X%$c@!- ?b"

P b a 2

P b a 2: string = " !#$%#(,#*)#"

P c a 21

P c a 21: string = " !#$%+(%#*!+"

P c c 2

P c c 2: string = " !#$%# %+$!+"

P m a 2

P m a 2: string = " !#$%#(%#*!#"

P m c 21

P m c 21: string = " !#$%+ %+$!#"

P m m 2

P m m 2: string = " !#$%# %#$!#"

P m n 21

P m n 21: string = " !#*%+(%+$!#"

P n a 21

P n a 21: string = " !#$%+(,#*)+"

P n c 2

P n c 2: string = " !#$%# ,+$)+"

P n n 2

P n n 2: string = " !#$%#(,+*)+"

R -3

R -3: string = " !## !!# $%&&$%%&$"

R -3 2/c

R -3 2/c: string = " !## !!# 102021210$%&&$%%&$'././'/'."

R -3 2/m

R -3 2/m: string = " !## !!# %$&$&%&%$$%&&$%%&$! # #!#! "

R 3

R 3: string = " !## !!# "

R 3 2

R 3 2: string = " !## !!# %$&$&%&%$"

R 3 c

R 3 c: string = " !## !!# '././'/'."

R 3 m

R 3 m: string = " !## !!# ! # #!#! "

Const EntityTypeString

EntityTypeString: object

macrolide

macrolide: number = MacrolideEntity

non-polymer

non-polymer: number = NonPolymerEntity

polymer

polymer: number = PolymerEntity

water

water: number = WaterEntity

Const HelixTypes

HelixTypes: object

0

0: string = "h"

1

1: string = "h"

10

10: string = "h"

2

2: string = "h"

3

3: string = "i"

4

4: string = "h"

5

5: string = "g"

6

6: string = "h"

7

7: string = "h"

8

8: string = "h"

9

9: string = "h"

Const ImageDefaultParameters

ImageDefaultParameters: object

Image parameter object.

property

{Boolean} trim - trim the image

property

{Integer} factor - scaling factor to apply to the viewer canvas

property

{Boolean} antialias - antialias the image

property

{Boolean} transparent - transparent image background

antialias

antialias: boolean = false

factor

factor: number = 1

onProgress

onProgress: undefined | Function = undefined as Function|undefined

transparent

transparent: boolean = false

trim

trim: boolean = false

Const KeyActionPresets

KeyActionPresets: object

default

default: KeyActionPreset = [//[ 'i', KeyActions.toggleSpin ],//[ 'k', KeyActions.toggleRock ],//[ 'p', KeyActions.toggleAnimations ],//[ 'a', KeyActions.toggleAntialiasing ],[ 'r', KeyActions.autoView ]] as KeyActionPreset

Const KeywordDescriptions

KeywordDescriptions: object

[k.ACIDIC]

[k.ACIDIC]: string = "Asp or Glu"

[k.ALIPHATIC]

[k.ALIPHATIC]: string = "Ala or Gly or Ile or Leu or Val"

[k.ALTLOC]

[k.ALTLOC]: string = "Alternate location (e.g.: '%A' or '%B' etc. or '%' for non-alternate location atoms)"

[k.AMIDE]

[k.AMIDE]: string = "Asn or Gln"

[k.AND]

[k.AND]: string = "'And' logical operator (e.g.: '( not polymer or hetero ) and not ( water or ion )')"

[k.APOLARH]

[k.APOLARH]: string = ""

[k.AROMATIC]

[k.AROMATIC]: string = "Phe or Tyr or Trp or His"

[k.ATOMLIST]

[k.ATOMLIST]: string = "A list of atom indices (e.g.: @0,1,4,5,11,23,42)"

[k.ATOMNAME]

[k.ATOMNAME]: string = "Atom name (e.g.: '.CA' or '.C' or '.N' etc.)"

[k.ATOM_DEPRECATED]

[k.ATOM_DEPRECATED]: string = "#"

[k.BASIC]

[k.BASIC]: string = "His or Lys or Arg"

[k.CHAIN]

[k.CHAIN]: string = "Chain name (e.g.: ':A')"

[k.CHARGED]

[k.CHARGED]: string = "Asp or Glu or His or Lys or Arg"

[k.CYCLIC]

[k.CYCLIC]: string = "His or Phe or Pro or Trp or Tyr"

[k.ELEMENT]

[k.ELEMENT]: string = "Element name (e.g.: '_H' or '_C' or '_O')"

[k.HYDROGEN]

[k.HYDROGEN]: string = ""

[k.HYDROPHOBIC]

[k.HYDROPHOBIC]: string = "Ala or Val or Leu or Ile or Met or Pro or Phe or Trp"

[k.INSCODE]

[k.INSCODE]: string = "Insertion code (e.g.: '^A' or '^B' etc. or '^' for residues with no insertion code)"

[k.INSCODE_NEGATE2]

[k.INSCODE_NEGATE2]: string = ""

[k.INSCODE_NEGATE]

[k.INSCODE_NEGATE]: string = ""

[k.LIGAND]

[k.LIGAND]: string = "( not polymer or hetero ) and not ( water or ion )"

[k.MODEL]

[k.MODEL]: string = "Model number (e.g.: '/0' or '/1' etc.)"

[k.NONPOLAR]

[k.NONPOLAR]: string = "Ala or Ile or Leu or Met or Phe or Pro or Val or Trp"

[k.NOT]

[k.NOT]: string = "'Not' logical operator (e.g.: '( not polymer or hetero ) and not ( water or ion )')"

[k.NUCLEOPHILIC]

[k.NUCLEOPHILIC]: string = "Ser or Thr or Cys"

[k.OR]

[k.OR]: string = "'Or' logical operator (e.g.: '( not polymer or hetero ) and not ( water or ion )')"

[k.PAR_L]

[k.PAR_L]: string = "Used for grouping logical expressions (e.g.: '( not polymer or hetero ) and not ( water or ion )')"

[k.PAR_R]

[k.PAR_R]: string = "Used for grouping logical expressions (e.g.: '( not polymer or hetero ) and not ( water or ion )')"

[k.POLAR]

[k.POLAR]: string = "Asp or Cys or Gly or Glu or His or Lys or Arg or Asn or Gln or Ser or Thr or Tyr"

[k.RESLIST_END]

[k.RESLIST_END]: string = "Close a list of residues (e.g.: [ALA,GLU,MET] or numeric residue name (e.g.: '[032]' or '[1AB]')"

[k.RESLIST_START]

[k.RESLIST_START]: string = "Open a list of residues (e.g.: [ALA,GLU,MET] or numeric residue name (e.g.: '[032]' or '[1AB]')"

[k.SEPARATOR]

[k.SEPARATOR]: string = "Used to separate atom lists (e.g.: @0,1,4,5,11,23,42) and residue lists (e.g.: [ALA,GLU,MET])"

[k.SIDECHAINATTACHED]

[k.SIDECHAINATTACHED]: string = "not backbone or .CA or (PRO and .N)"

[k.SMALL]

[k.SMALL]: string = "Gly or Ala or Ser"

Const Keywords

Keywords: object

[k.ACIDIC]

[k.ACIDIC]: string = "ACIDIC"

[k.ALIPHATIC]

[k.ALIPHATIC]: string = "ALIPHATIC"

[k.ALTLOC]

[k.ALTLOC]: string = "%"

[k.AMIDE]

[k.AMIDE]: string = "AMID"

[k.AND]

[k.AND]: string = "AND"

[k.APOLARH]

[k.APOLARH]: string = "APOLARH"

[k.AROMATIC]

[k.AROMATIC]: string = "AROMATIC"

[k.ATOMLIST]

[k.ATOMLIST]: string = "@"

[k.ATOMNAME]

[k.ATOMNAME]: string = "."

[k.ATOM_DEPRECATED]

[k.ATOM_DEPRECATED]: string = "#"

[k.BASIC]

[k.BASIC]: string = "BASIC"

[k.CHAIN]

[k.CHAIN]: string = ":"

[k.CHARGED]

[k.CHARGED]: string = "CHARGED"

[k.CYCLIC]

[k.CYCLIC]: string = "CYCLIC"

[k.ELEMENT]

[k.ELEMENT]: string = "_"

[k.HYDROGEN]

[k.HYDROGEN]: string = "HYDROGEN"

[k.HYDROPHOBIC]

[k.HYDROPHOBIC]: string = "HYDROPHOBIC"

[k.INSCODE]

[k.INSCODE]: string = "^"

[k.INSCODE_NEGATE2]

[k.INSCODE_NEGATE2]: string = "--"

[k.INSCODE_NEGATE]

[k.INSCODE_NEGATE]: string = "-"

[k.LIGAND]

[k.LIGAND]: string = "LIGAND"

[k.MODEL]

[k.MODEL]: string = "/"

[k.NONPOLAR]

[k.NONPOLAR]: string = "NONPOLAR"

[k.NOT]

[k.NOT]: string = "NOT"

[k.NUCLEOPHILIC]

[k.NUCLEOPHILIC]: string = "NUCLEOPHILIC"

[k.OR]

[k.OR]: string = "OR"

[k.PAR_L]

[k.PAR_L]: string = "("

[k.PAR_R]

[k.PAR_R]: string = ")"

[k.POLAR]

[k.POLAR]: string = "POLAR"

[k.RESLIST_END]

[k.RESLIST_END]: string = "]"

[k.RESLIST_START]

[k.RESLIST_START]: string = "["

[k.SEPARATOR]

[k.SEPARATOR]: string = ","

[k.SIDECHAINATTACHED]

[k.SIDECHAINATTACHED]: string = "SIDECHAINATTACHED"

[k.SMALL]

[k.SMALL]: string = "SMALL"

Const LabelFactoryTypes

LabelFactoryTypes: object
: string = ""

atom

atom: string = "atom name + index"

atomindex

atomindex: string = "atom index"

atomname

atomname: string = "atom name"

bfactor

bfactor: string = "b-factor"

element

element: string = "element"

format

format: string = "format"

occupancy

occupancy: string = "occupancy"

qualified

qualified: string = "qualified name"

res

res: string = "one letter code + no"

residue

residue: string = "[residue name] + no + inscode"

resname

resname: string = "residue name"

resno

resno: string = "residue no"

serial

serial: string = "serial"

text

text: string = "text"

Const LineChartDefaultParameters

LineChartDefaultParameters: object

Default parameters for the D3 line chart

color

color: string = "currentColor"

stroke color of line

curve

curve: CurveFactory = d3.curveLinear

Method of interpolation between points

defined

defined: any = undefined as unknown as any

For gaps in data

height

height: number = 400

Outer height, in pixels

marginBottom

marginBottom: number = 30

Bottom margin, in pixels

marginLeft

marginLeft: number = 40

Left margin, in pixels

marginRight

marginRight: number = 30

Right margin, in pixels

marginTop

marginTop: number = 20

Top margin, in pixels

strokeLinecap

strokeLinecap: string = "round"

stroke line cap of line

strokeLinejoin

strokeLinejoin: string = "round"

stroke line join of line

strokeWidth

strokeWidth: number = 1.5

stroke width of line, in pixels

title

title: (d: any, idx?: any, data?: any) => string = undefined as unknown as (d: any, idx?: any, data?: any) => string

Given d in data, returns the title text

Type declaration

    • (d: any, idx?: any, data?: any): string

    • Parameters

      • d: any
      • Optional idx: any
      • Optional data: any

      Returns string

width

width: number = 640

Outer width, in pixels

xDomain

xDomain: [any, any] = undefined as unknown as [any, any]

[xmin, xmax]

xRange

xRange: [any, any] = undefined as unknown as [any, any]

[left, right]

xType

xType: scaleLinear = d3.scaleLinear

Type of x-scale

yDomain

yDomain: [any, any] = undefined as unknown as [any, any]

[ymin, ymax]

yFormat

yFormat: string = undefined as unknown as string

a format specifier string for the y-axis

yLabel

yLabel: string = undefined as unknown as string

a label for the y-axis

yRange

yRange: [any, any] = undefined as unknown as [any, any]

[bottom, top]

yType

yType: scaleLinear = d3.scaleLinear

Type of y-scale

x

  • x(__namedParameters: [any]): any

y

  • y(__namedParameters: [undefined, any]): any

Const Log

Log: object

eventListeners

eventListeners: ((type: "log" | "info" | "warn" | "error", ...argArray: any[]) => void)[] = [] as { (type: "log" | "info" | "warn" | "error", ...argArray: any[]): void }[]

time

time: any = Function.prototype.bind.call(console.time, console)

timeEnd

timeEnd: any = Function.prototype.bind.call(console.timeEnd, console)

error

  • error(...argArray: any[]): void

info

  • info(...argArray: any[]): void

log

  • log(...argArray: any[]): void

warn

  • warn(...argArray: any[]): void

Let MeasurementDefaultParams

MeasurementDefaultParams: object

arcVisible

arcVisible: boolean = true

color

color: string = "green"

labelAttachment

labelAttachment: "bottom-center" = "bottom-center"

labelBorder

labelBorder: true = true

labelBorderColor

labelBorderColor: number = 13882323

labelBorderWidth

labelBorderWidth: number = 0.25

labelColor

labelColor: number = 8421504

labelSize

labelSize: number = 0.7

labelUnit

labelUnit: string = "angstrom"

labelYOffset

labelYOffset: number = 0.1

labelZOffset

labelZOffset: number = 0.5

lineOpacity

lineOpacity: number = 0.8

linewidth

linewidth: number = 5

opacity

opacity: number = 0.6

planeVisible

planeVisible: boolean = false

Const MoreKeywordDescriptions

MoreKeywordDescriptions: object

[kwd.ALL]

[kwd.ALL]: string = ""

[kwd.AROMATICRING]

[kwd.AROMATICRING]: string = ""

[kwd.BACKBONE]

[kwd.BACKBONE]: string = ""

[kwd.BONDED]

[kwd.BONDED]: string = "All atoms with at least one bond"

[kwd.DNA]

[kwd.DNA]: string = ""

[kwd.HELIX]

[kwd.HELIX]: string = ""

[kwd.HETERO]

[kwd.HETERO]: string = ""

[kwd.ION]

[kwd.ION]: string = ""

[kwd.METAL]

[kwd.METAL]: string = ""

[kwd.NONE]

[kwd.NONE]: string = ""

[kwd.NUCLEIC]

[kwd.NUCLEIC]: string = ""

[kwd.POLARH]

[kwd.POLARH]: string = ""

[kwd.POLYMER]

[kwd.POLYMER]: string = ""

[kwd.PROTEIN]

[kwd.PROTEIN]: string = ""

[kwd.RING]

[kwd.RING]: string = "All atoms within rings"

[kwd.RNA]

[kwd.RNA]: string = ""

[kwd.SACCHARIDE]

[kwd.SACCHARIDE]: string = ""

[kwd.SCAFFOLD]

[kwd.SCAFFOLD]: string = ""

[kwd.SHEET]

[kwd.SHEET]: string = ""

[kwd.SIDECHAIN]

[kwd.SIDECHAIN]: string = ""

[kwd.STAPLE]

[kwd.STAPLE]: string = ""

[kwd.TURN]

[kwd.TURN]: string = "not helix and not sheet"

[kwd.WATER]

[kwd.WATER]: string = ""

Const MouseActionPresets

MouseActionPresets: object

astexviewer

astexviewer: MouseActionPreset = [[ 'drag-left', MouseActions.rotateDrag ],[ 'drag-ctrl-left', MouseActions.panDrag ],[ 'drag-shift-left', MouseActions.zoomDrag ],[ 'scroll', MouseActions.focusScroll ],[ 'clickPick-middle', MouseActions.movePick ],[ 'hoverPick', MouseActions.tooltipPick ]] as MouseActionPreset

coot

coot: MouseActionPreset = [[ 'scroll', MouseActions.isolevelScroll ],[ 'drag-left', MouseActions.rotateDrag ],[ 'drag-middle', MouseActions.panDrag ],[ 'drag-ctrl-left', MouseActions.panDrag ],[ 'drag-right', MouseActions.zoomFocusDrag ],[ 'drag-ctrl-right', MouseActions.focusScroll ],[ 'clickPick-middle', MouseActions.movePick ],[ 'hoverPick', MouseActions.tooltipPick ]] as MouseActionPreset

default

default: MouseActionPreset = [[ 'scroll', MouseActions.zoomScroll ],[ 'scroll-shift', MouseActions.focusScroll ],[ 'scroll-ctrl', MouseActions.isolevelScroll ],[ 'scroll-shift-ctrl', MouseActions.zoomFocusScroll ],//[ 'drag-left', MouseActions.rotateDrag ], // Now dragPick-left[ 'drag-right', MouseActions.panDrag ],//[ 'drag-ctrl-left', MouseActions.panDrag ], // Now dragPick-ctrl-left[ 'drag-ctrl-right', MouseActions.zRotateDrag ],//[ 'drag-shift-left', MouseActions.zoomDrag ], // Now dragPick-shift-left[ 'drag-middle', MouseActions.zoomFocusDrag ],[ 'drag-ctrl-shift-right', MouseActions.panComponentDrag ],//[ 'drag-ctrl-shift-left', MouseActions.rotateComponentDrag ], // Now dragPick-ctrl-shift-left[ 'clickPick-right', MouseActions.measurePick ],[ 'clickPick-ctrl-left', MouseActions.measurePick ],[ 'clickPick-middle', MouseActions.movePick ],// Catana modifications[ 'clickPick-left', MouseActions.clickPick_left ], //[ 'clickPick-left', MouseActions.movePick ],[ 'hoverPick', MouseActions.hoverPick ], //[ 'hoverPick', MouseActions.tooltipPick ],// Catana additions[ 'hoverPick-shift', MouseActions.hoverPick ],[ "downPick-left", MouseActions.downPick_left],[ "downPick-shift-left", MouseActions.downPick_left],[ "upPick-left", MouseActions.upPick_left],[ "upPick-shift-left", MouseActions.upPick_left],[ "dragPick-left", MouseActions.dragPick_left ],[ "dragPick-shift-left", MouseActions.dragPick_left ],//[ "dragPick-ctrl-left", MouseActions.dragPick_left ],//[ "dragPick-ctrl-shift-left", MouseActions.dragPick_left ]] as MouseActionPreset

pymol

pymol: MouseActionPreset = [[ 'drag-left', MouseActions.rotateDrag ],[ 'drag-middle', MouseActions.panDrag ],[ 'drag-right', MouseActions.zoomDrag ],[ 'drag-shift-right', MouseActions.focusScroll ],[ 'clickPick-ctrl+shift-middle', MouseActions.movePick ],[ 'hoverPick', MouseActions.tooltipPick ]] as MouseActionPreset

Const NA1

NA1: object

A

A: string = "A"

C

C: string = "C"

DA

DA: string = "A"

DC

DC: string = "C"

DG

DG: string = "G"

DI

DI: string = "I"

DT

DT: string = "T"

DU

DU: string = "U"

G

G: string = "G"

I

I: string = "I"

T

T: string = "T"

U

U: string = "U"

Const OuterShellElectronCounts

OuterShellElectronCounts: object

1

1: number = 1

10

10: number = 8

100

100: number = 12

101

101: number = 13

102

102: number = 14

103

103: number = 15

104

104: number = 2

105

105: number = 2

106

106: number = 2

107

107: number = 2

108

108: number = 2

109

109: number = 2

11

11: number = 1

110

110: number = 2

111

111: number = 2

112

112: number = 2

113

113: number = 3

114

114: number = 4

115

115: number = 5

116

116: number = 6

117

117: number = 7

118

118: number = 8

12

12: number = 2

13

13: number = 3

14

14: number = 4

15

15: number = 5

16

16: number = 6

17

17: number = 7

18

18: number = 8

19

19: number = 1

2

2: number = 2

20

20: number = 2

21

21: number = 3

22

22: number = 4

23

23: number = 5

24

24: number = 6

25

25: number = 7

26

26: number = 8

27

27: number = 9

28

28: number = 10

29

29: number = 11

3

3: number = 1

30

30: number = 2

31

31: number = 3

32

32: number = 4

33

33: number = 5

34

34: number = 6

35

35: number = 7

36

36: number = 8

37

37: number = 1

38

38: number = 2

39

39: number = 3

4

4: number = 2

40

40: number = 4

41

41: number = 5

42

42: number = 6

43

43: number = 7

44

44: number = 8

45

45: number = 9

46

46: number = 10

47

47: number = 11

48

48: number = 2

49

49: number = 3

5

5: number = 3

50

50: number = 4

51

51: number = 5

52

52: number = 6

53

53: number = 7

54

54: number = 8

55

55: number = 1

56

56: number = 2

57

57: number = 3

58

58: number = 4

59

59: number = 3

6

6: number = 4

60

60: number = 4

61

61: number = 5

62

62: number = 6

63

63: number = 7

64

64: number = 8

65

65: number = 9

66

66: number = 10

67

67: number = 11

68

68: number = 12

69

69: number = 13

7

7: number = 5

70

70: number = 14

71

71: number = 15

72

72: number = 4

73

73: number = 5

74

74: number = 6

75

75: number = 7

76

76: number = 8

77

77: number = 9

78

78: number = 10

79

79: number = 11

8

8: number = 6

80

80: number = 2

81

81: number = 3

82

82: number = 4

83

83: number = 5

84

84: number = 6

85

85: number = 7

86

86: number = 8

87

87: number = 1

88

88: number = 2

89

89: number = 3

9

9: number = 7

90

90: number = 4

91

91: number = 3

92

92: number = 4

93

93: number = 5

94

94: number = 6

95

95: number = 7

96

96: number = 8

97

97: number = 9

98

98: number = 10

99

99: number = 11

Const PluginUIElemDefinitions

PluginUIElemDefinitions: object

Defines supported plugin UI element types and their required object properties.

button

button: string[] = ["content", "callback"] as string[]

Button enabling to execute some action/script. The first argument of the callback script will be a dictionary of form [element name -> value] for every value-returning UI element.

color

color: string[] = [] as string[]

Color picker enabling to select desired color.

component-select

component-select: string[] = ["allowMultiple"] as string[]

Select that enables the user to select one or more loaded structural components.

input-number

input-number: string[] = [] as string[]

Input field enabling the user to provide numeric input.

input-text

input-text: string[] = [] as string[]

Input field enabling the user to provide textual input.

select

select: string[] = ["options", "allowMultiple"] as string[]

Select element enabling the user to select one or more of the predefined options.

text

text: string[] = ["content"] as string[]

Text element (non-editable). Content defines the textual content.

Const RadiusFactoryTypes

RadiusFactoryTypes: object
: string = ""

bfactor

bfactor: string = "by bfactor"

covalent

covalent: string = "by covalent radius"

data

data: string = "data"

explicit

explicit: string = "explicit"

size

size: string = "size"

sstruc

sstruc: string = "by secondary structure"

vdw

vdw: string = "by vdW radius"

Const ResidueColors

ResidueColors: object

A

A: number = 14423100

ALA

ALA: number = 9240460

ARG

ARG: number = 124

ASH

ASH: number = 16711935

ASN

ASN: number = 16743536

ASP

ASP: number = 10485826

ASX

ASX: number = 16711935

C

C: number = 16766720

CYS

CYS: number = 16777072

D

D: number = 35723

DA

DA: number = 14423100

DC

DC: number = 16766720

DD

DD: number = 35723

DG

DG: number = 3329330

DI

DI: number = 10145074

DT

DT: number = 4286945

DU

DU: number = 4251856

DX

DX: number = 8190976

G

G: number = 3329330

GLH

GLH: number = 16711935

GLN

GLN: number = 16731212

GLU

GLU: number = 6684672

GLX

GLX: number = 16711935

GLY

GLY: number = 16777215

HIS

HIS: number = 7368959

I

I: number = 10145074

ILE

ILE: number = 19456

LEU

LEU: number = 4546117

LYS

LYS: number = 4671416

MET

MET: number = 12099650

PHE

PHE: number = 5459026

PRO

PRO: number = 5395026

SER

SER: number = 16740418

T

T: number = 4286945

THR

THR: number = 12078080

TRP

TRP: number = 5195264

TYR

TYR: number = 9203788

U

U: number = 4251856

VAL

VAL: number = 16747775

X

X: number = 8190976

Const ResidueHydrophobicity

ResidueHydrophobicity: object

ALA

ALA: [number, number, number] = [0.17, 0.50, 0.33]

ARG

ARG: [number, number, number] = [0.81, 1.81, 1.00]

ASH

ASH: [number, number, number] = [-0.07, 0.43, 0.50]

ASN

ASN: [number, number, number] = [0.42, 0.85, 0.43]

ASP

ASP: [number, number, number] = [1.23, 3.64, 2.41]

CYS

CYS: [number, number, number] = [-0.24, -0.02, 0.22]

GLH

GLH: [number, number, number] = [-0.01, 0.11, 0.12]

GLN

GLN: [number, number, number] = [0.58, 0.77, 0.19]

GLU

GLU: [number, number, number] = [2.02, 3.63, 1.61]

GLY

GLY: [number, number, number] = [0.01, 1.15, 1.14]

HIS

HIS: [number, number, number] = [0.17, 0.11, -0.06]

ILE

ILE: [number, number, number] = [-0.31, -1.12, -0.81]

LEU

LEU: [number, number, number] = [-0.56, -1.25, -0.69]

LYS

LYS: [number, number, number] = [0.99, 2.80, 1.81]

MET

MET: [number, number, number] = [-0.23, -0.67, -0.44]

PHE

PHE: [number, number, number] = [-1.13, -1.71, -0.58]

PRO

PRO: [number, number, number] = [0.45, 0.14, -0.31]

SER

SER: [number, number, number] = [0.13, 0.46, 0.33]

THR

THR: [number, number, number] = [0.14, 0.25, 0.11]

TRP

TRP: [number, number, number] = [-1.85, -2.09, -0.24]

TYR

TYR: [number, number, number] = [-0.94, -0.71, 0.23]

VAL

VAL: [number, number, number] = [0.07, -0.46, -0.53]

Const ResidueRadii

ResidueRadii: object

004

004: number = 4.33

01W

01W: number = 8.55

02K

02K: number = 2.94

02V

02V: number = 4.83

02Y

02Y: number = 4.77

03E

03E: number = 3.38

03Y

03Y: number = 2.6

07O

07O: number = 8.05

0A0

0A0: number = 3.45

0A1

0A1: number = 7.1

0A8

0A8: number = 8.1

0A9

0A9: number = 5.17

0AF

0AF: number = 6.72

0AH

0AH: number = 5.78

0AK

0AK: number = 6.11

0AR

0AR: number = 8.46

0BN

0BN: number = 7

0CS

0CS: number = 4.07

0FL

0FL: number = 2.76

0LF

0LF: number = 9.96

0QL

0QL: number = 5.72

0TD

0TD: number = 3.62

0WZ

0WZ: number = 7.61

11Q

11Q: number = 4.85

11W

11W: number = 14.39

143

143: number = 8.22

175

175: number = 5.64

192

192: number = 2.44

193

193: number = 7.38

19W

19W: number = 3.94

1AC

1AC: number = 2.42

1C3

1C3: number = 7.43

1E3

1E3: number = 8.71

1MH

1MH: number = 5.04

1OP

1OP: number = 11.55

1PA

1PA: number = 8.07

1TQ

1TQ: number = 8.58

1TY

1TY: number = 8.84

1U8

1U8: number = 3.62

1VR

1VR: number = 3.89

1X6

1X6: number = 6.84

200

200: number = 6.89

22G

22G: number = 8.8

23F

23F: number = 5.27

23P

23P: number = 5.42

23S

23S: number = 6.09

26B

26B: number = 8.39

28X

28X: number = 7.84

2AG

2AG: number = 3.7

2AS

2AS: number = 3.57

2CO

2CO: number = 4.45

2FM

2FM: number = 5.54

2HF

2HF: number = 5.52

2JC

2JC: number = 2.97

2JF

2JF: number = 9.13

2JG

2JG: number = 5.67

2JH

2JH: number = 4.56

2ML

2ML: number = 3.86

2MR

2MR: number = 7.35

2MT

2MT: number = 3.67

2OR

2OR: number = 6.91

2P0

2P0: number = 8.52

2QY

2QY: number = 6.58

2QZ

2QZ: number = 2.52

2R1

2R1: number = 3.78

2R3

2R3: number = 6.94

2RX

2RX: number = 4.91

2TY

2TY: number = 8.65

2VA

2VA: number = 9.82

2XA

2XA: number = 8.25

2ZC

2ZC: number = 4.29

30V

30V: number = 8.53

31Q

31Q: number = 10.46

32L

32L: number = 6.75

32S

32S: number = 5.68

32T

32T: number = 5.72

3A5

3A5: number = 5.37

3AH

3AH: number = 9.11

3AR

3AR: number = 7.86

3CF

3CF: number = 6.47

3EG

3EG: number = 3.66

3FG

3FG: number = 4.96

3GL

3GL: number = 4.84

3PX

3PX: number = 4.7

3TY

3TY: number = 8.42

3YM

3YM: number = 6.52

4AW

4AW: number = 6.22

4BF

4BF: number = 6.92

4CF

4CF: number = 7.72

4CY

4CY: number = 4.6

4DB

4DB: number = 9.73

4DP

4DP: number = 9.28

4FB

4FB: number = 3.08

4FW

4FW: number = 6.1

4HL

4HL: number = 8.79

4HT

4HT: number = 6.03

4IK

4IK: number = 11.81

4IN

4IN: number = 6.31

4PH

4PH: number = 6.79

56A

56A: number = 13.01

5CS

5CS: number = 8.34

5CW

5CW: number = 7.21

5OH

5OH: number = 4.7

5PG

5PG: number = 5.69

6CL

6CL: number = 6.47

6CW

6CW: number = 7.56

6FL

6FL: number = 4.85

6HN

6HN: number = 7.34

7JA

7JA: number = 9.46

7MN

7MN: number = 7.34

8SP

8SP: number = 14.26

9AT

9AT: number = 2.47

9DN

9DN: number = 9.31

9DS

9DS: number = 9.29

9NE

9NE: number = 9.77

9NF

9NF: number = 8.93

9NR

9NR: number = 9.33

9NV

9NV: number = 8.99

A5N

A5N: number = 5.21

A8E

A8E: number = 3.76

AA4

AA4: number = 4.47

AAR

AAR: number = 6.39

ABA

ABA: number = 2.55

AC5

AC5: number = 2.44

AEI

AEI: number = 6.34

AGM

AGM: number = 6.57

AGQ

AGQ: number = 7.79

AGT

AGT: number = 9.04

AHB

AHB: number = 3.47

AHH

AHH: number = 5.06

AHP

AHP: number = 5.26

AIB

AIB: number = 2.4

ALA

ALA: number = 2.38

ALC

ALC: number = 5.26

ALN

ALN: number = 6.16

ALO

ALO: number = 2.57

ALT

ALT: number = 2.72

ALY

ALY: number = 7.38

APK

APK: number = 8.79

AR4

AR4: number = 8.42

ARG

ARG: number = 6.33

ARM

ARM: number = 6.86

ARO

ARO: number = 7.35

ARV

ARV: number = 7.59

AS9

AS9: number = 4.1

ASA

ASA: number = 3.64

ASB

ASB: number = 5.59

ASL

ASL: number = 5.36

ASN

ASN: number = 3.54

ASP

ASP: number = 3.55

ASX

ASX: number = 3.54

AYA

AYA: number = 3.65

AZH

AZH: number = 5.36

AZK

AZK: number = 6.03

AZS

AZS: number = 5.61

AZY

AZY: number = 7.37

B27

B27: number = 2.78

B3A

B3A: number = 2.48

B3E

B3E: number = 5.4

B3K

B3K: number = 5.89

B3L

B3L: number = 4.96

B3M

B3M: number = 5.07

B3Q

B3Q: number = 4.48

B3T

B3T: number = 3.34

B3U

B3U: number = 6.06

B3X

B3X: number = 4.38

B3Y

B3Y: number = 7.45

BB6

BB6: number = 2.62

BB7

BB7: number = 4.56

BB8

BB8: number = 5.14

BB9

BB9: number = 2.56

BBC

BBC: number = 6.42

BCS

BCS: number = 8.03

BCX

BCX: number = 2.99

BFD

BFD: number = 5.33

BG1

BG1: number = 8.02

BH2

BH2: number = 3.51

BHD

BHD: number = 3.48

BIF

BIF: number = 9.63

BIL

BIL: number = 4.7

BL2

BL2: number = 5.82

BMT

BMT: number = 6.37

BPE

BPE: number = 7.24

BTK

BTK: number = 8.59

BTR

BTR: number = 7.98

BUC

BUC: number = 5.8

C1X

C1X: number = 11.63

C3Y

C3Y: number = 5.24

C4R

C4R: number = 5.63

C5C

C5C: number = 5.35

C6C

C6C: number = 6.42

CAB

CAB: number = 4.19

CAF

CAF: number = 5.46

CAS

CAS: number = 5.35

CCS

CCS: number = 4.58

CDE

CDE: number = 2.51

CDV

CDV: number = 3.72

CGA

CGA: number = 7.91

CGU

CGU: number = 4.71

CHG

CHG: number = 4.2

CHP

CHP: number = 5.75

CLG

CLG: number = 13.62

CLH

CLH: number = 7.13

CME

CME: number = 5.86

CMH

CMH: number = 5.3

CML

CML: number = 6.16

CMT

CMT: number = 3.54

CPC

CPC: number = 2.65

CS1

CS1: number = 7.23

CS3

CS3: number = 8.24

CS4

CS4: number = 11.21

CSA

CSA: number = 5.7

CSB

CSB: number = 3.51

CSD

CSD: number = 3.95

CSJ

CSJ: number = 7.51

CSK

CSK: number = 3.91

CSO

CSO: number = 3.53

CSP

CSP: number = 5.26

CSR

CSR: number = 5.42

CSS

CSS: number = 3.61

CSU

CSU: number = 4.89

CSW

CSW: number = 3.68

CSX

CSX: number = 3.47

CSZ

CSZ: number = 3.6

CTE

CTE: number = 7.27

CTH

CTH: number = 3.45

CXM

CXM: number = 4.69

CY0

CY0: number = 11.98

CY1

CY1: number = 6.59

CY3

CY3: number = 2.79

CY4

CY4: number = 4.57

CYD

CYD: number = 8.55

CYF

CYF: number = 13.54

CYG

CYG: number = 8.03

CYJ

CYJ: number = 11.64

CYQ

CYQ: number = 5.67

CYR

CYR: number = 10.33

CYS

CYS: number = 2.78

CYW

CYW: number = 4.65

CZ2

CZ2: number = 5.16

CZZ

CZZ: number = 5.14

D4P

D4P: number = 5.66

DA2

DA2: number = 7.79

DAB

DAB: number = 3.48

DAH

DAH: number = 6.47

DAM

DAM: number = 2.49

DBU

DBU: number = 2.49

DBY

DBY: number = 6.46

DBZ

DBZ: number = 7.08

DDE

DDE: number = 6.86

DDZ

DDZ: number = 2.52

DFI

DFI: number = 3.93

DFO

DFO: number = 3.94

DHA

DHA: number = 2.32

DHL

DHL: number = 2.69

DIR

DIR: number = 5.8

DLS

DLS: number = 6.84

DM0

DM0: number = 6.99

DMH

DMH: number = 4.92

DMK

DMK: number = 3.52

DMT

DMT: number = 6.67

DNP

DNP: number = 2.45

DNS

DNS: number = 8.79

DNW

DNW: number = 7.97

DO2

DO2: number = 4.44

DOA

DOA: number = 12.33

DON

DON: number = 6.72

DPL

DPL: number = 3.58

DPP

DPP: number = 2.51

DPQ

DPQ: number = 6.54

DYS

DYS: number = 7.87

ECC

ECC: number = 4.79

ECX

ECX: number = 5.51

EFC

EFC: number = 5.28

ELY

ELY: number = 7.42

EME

EME: number = 4.69

ESB

ESB: number = 6.69

ESC

ESC: number = 5.65

ETA

ETA: number = 2.4

EXY

EXY: number = 7.37

F2F

F2F: number = 6.25

F2Y

F2Y: number = 6.2

FAK

FAK: number = 9.8

FC0

FC0: number = 5.18

FCL

FCL: number = 6.25

FDL

FDL: number = 9.49

FGL

FGL: number = 2.56

FGP

FGP: number = 4.34

FH7

FH7: number = 6.99

FHL

FHL: number = 9.75

FHO

FHO: number = 6.75

FLA

FLA: number = 2.4

FLE

FLE: number = 6.17

FLT

FLT: number = 9.65

FME

FME: number = 4.52

FOE

FOE: number = 8.17

FP9

FP9: number = 3.03

FPK

FPK: number = 3.08

FPR

FPR: number = 8.85

FRD

FRD: number = 5.05

FT6

FT6: number = 7.5

FTR

FTR: number = 6.08

FTY

FTY: number = 9.07

FVA

FVA: number = 2.9

FZN

FZN: number = 24.42

G8M

G8M: number = 3.57

GAU

GAU: number = 4.67

GEE

GEE: number = 4.76

GFT

GFT: number = 8.18

GHG

GHG: number = 4.83

GL3

GL3: number = 2.72

GLJ

GLJ: number = 3.7

GLN

GLN: number = 4.46

GLU

GLU: number = 4.49

GLX

GLX: number = 4.52

GLY

GLY: number = 2.37

GLZ

GLZ: number = 2.39

GMA

GMA: number = 4.4

GME

GME: number = 4.66

GNC

GNC: number = 4.6

GND

GND: number = 6.67

GPL

GPL: number = 10.77

GSU

GSU: number = 11.81

GVL

GVL: number = 9.6

H14

H14: number = 5.27

H5M

H5M: number = 3.61

HAR

HAR: number = 7.55

HBN

HBN: number = 8.8

HCL

HCL: number = 4.96

HCM

HCM: number = 5.53

HCS

HCS: number = 4.09

HFA

HFA: number = 5.14

HG7

HG7: number = 6.8

HGL

HGL: number = 8.07

HHI

HHI: number = 4.58

HHK

HHK: number = 5.11

HIA

HIA: number = 4.64

HIC

HIC: number = 5.76

HIP

HIP: number = 5.47

HIQ

HIQ: number = 7.98

HIS

HIS: number = 4.52

HL2

HL2: number = 3.75

HLU

HLU: number = 3.99

HLX

HLX: number = 4.98

HMR

HMR: number = 5.09

HNC

HNC: number = 10.41

HOX

HOX: number = 6.61

HPE

HPE: number = 6.63

HQA

HQA: number = 7.25

HR7

HR7: number = 6.98

HRG

HRG: number = 7.36

HRP

HRP: number = 5.46

HS8

HS8: number = 7.4

HS9

HS9: number = 4.71

HSL

HSL: number = 2.46

HSO

HSO: number = 4.56

HT7

HT7: number = 6.82

HTI

HTI: number = 7.8

HTR

HTR: number = 6.48

HVA

HVA: number = 2.58

HYP

HYP: number = 2.25

HZP

HZP: number = 3.12

I2M

I2M: number = 3.13

I58

I58: number = 6.73

IAM

IAM: number = 8.88

IAR

IAR: number = 6.77

ICY

ICY: number = 7.76

IEL

IEL: number = 7.07

IGL

IGL: number = 5.52

IIL

IIL: number = 3.81

ILE

ILE: number = 3.65

ILM

ILM: number = 3.84

ILX

ILX: number = 4.99

IML

IML: number = 3.74

IOR

IOR: number = 7.23

IPG

IPG: number = 2.91

IT1

IT1: number = 9.75

IYR

IYR: number = 6.46

IZO

IZO: number = 4.47

JJJ

JJJ: number = 7.5

JJK

JJK: number = 7.43

JJL

JJL: number = 8.3

KBE

KBE: number = 5.64

KCX

KCX: number = 7.28

KGC

KGC: number = 9.88

KOR

KOR: number = 10.1

KPI

KPI: number = 9.79

KPY

KPY: number = 10.17

KST

KST: number = 11.58

KWS

KWS: number = 5.09

KYN

KYN: number = 6.18

KYQ

KYQ: number = 9.75

L3O

L3O: number = 3.89

LA2

LA2: number = 14.07

LAA

LAA: number = 3.23

LAL

LAL: number = 2.41

LBY

LBY: number = 7.75

LCK

LCK: number = 9.81

LDH

LDH: number = 7.06

LE1

LE1: number = 2.72

LED

LED: number = 4.34

LEF

LEF: number = 4.37

LEN

LEN: number = 3.82

LET

LET: number = 11.29

LEU

LEU: number = 3.83

LGY

LGY: number = 11.71

LHC

LHC: number = 7.75

LLO

LLO: number = 10.13

LLP

LLP: number = 10.22

LLY

LLY: number = 8.71

LME

LME: number = 3.99

LMQ

LMQ: number = 4.69

LP6

LP6: number = 8.58

LPD

LPD: number = 2.48

LPG

LPG: number = 2.39

LPL

LPL: number = 7.51

LSO

LSO: number = 10.58

LTA

LTA: number = 6.57

LVG

LVG: number = 3.01

LVN

LVN: number = 2.89

LWY

LWY: number = 4.12

LYF

LYF: number = 12.19

LYH

LYH: number = 5.13

LYN

LYN: number = 4.8

LYO

LYO: number = 4.71

LYR

LYR: number = 18.28

LYS

LYS: number = 5.54

LYX

LYX: number = 13.36

LYZ

LYZ: number = 1.76

M0H

M0H: number = 4.83

M2L

M2L: number = 6.15

M2S

M2S: number = 5.28

M3L

M3L: number = 7.12

M3R

M3R: number = 7.18

MAA

MAA: number = 2.4

MBQ

MBQ: number = 9.55

MCG

MCG: number = 6.46

MCL

MCL: number = 9.73

MCS

MCS: number = 7.56

MD3

MD3: number = 8.41

MD5

MD5: number = 9.33

MD6

MD6: number = 6.44

MDF

MDF: number = 4.95

MDH

MDH: number = 2.58

MDO

MDO: number = 5.03

ME0

ME0: number = 4.52

MEA

MEA: number = 4.95

MEN

MEN: number = 4.33

MEQ

MEQ: number = 5.13

MET

MET: number = 4.49

MF3

MF3: number = 6.37

MGG

MGG: number = 7.34

MGN

MGN: number = 4.84

MH6

MH6: number = 1.72

MHL

MHL: number = 3.92

MHO

MHO: number = 4.89

MHS

MHS: number = 4.51

MHU

MHU: number = 7.51

MHV

MHV: number = 3.6

MHW

MHW: number = 2.74

MIR

MIR: number = 6.54

MIS

MIS: number = 6.32

MK8

MK8: number = 4.76

MKD

MKD: number = 6.42

ML3

ML3: number = 6.26

MLE

MLE: number = 3.87

MLL

MLL: number = 3.76

MLY

MLY: number = 6.88

MLZ

MLZ: number = 6.8

MME

MME: number = 4.99

MMO

MMO: number = 6.53

MNL

MNL: number = 4.9

MOD

MOD: number = 12.62

MP4

MP4: number = 5.86

MP8

MP8: number = 3.75

MPH

MPH: number = 5.29

MPJ

MPJ: number = 5.07

MPQ

MPQ: number = 4.2

MSA

MSA: number = 2.73

MSE

MSE: number = 4.62

MSL

MSL: number = 5.21

MSO

MSO: number = 4.96

MSP

MSP: number = 13.11

MT2

MT2: number = 5.51

MTY

MTY: number = 5.46

MVA

MVA: number = 2.56

MYK

MYK: number = 19.47

MYN

MYN: number = 4.71

N10

N10: number = 8.96

N2C

N2C: number = 3.55

NAL

NAL: number = 7.22

NB8

NB8: number = 11.98

NBQ

NBQ: number = 9.82

NC1

NC1: number = 11.4

NCB

NCB: number = 3.45

NCY

NCY: number = 2.91

NEP

NEP: number = 6.94

NFA

NFA: number = 5.04

NIY

NIY: number = 6.81

NLE

NLE: number = 4.67

NLO

NLO: number = 4.8

NLP

NLP: number = 4.81

NLQ

NLQ: number = 4.65

NLY

NLY: number = 6.37

NMC

NMC: number = 4.23

NMM

NMM: number = 8.25

NNH

NNH: number = 6.86

NOT

NOT: number = 7.15

NPH

NPH: number = 11.66

NPI

NPI: number = 6.9

NRG

NRG: number = 8.35

NVA

NVA: number = 3.76

NYB

NYB: number = 6.07

NYS

NYS: number = 8.1

NZH

NZH: number = 7.66

O12

O12: number = 14.08

OAS

OAS: number = 4.8

OBF

OBF: number = 3.64

OBS

OBS: number = 11.71

OCS

OCS: number = 3.94

OCY

OCY: number = 5

OHI

OHI: number = 5.35

OHS

OHS: number = 6.98

OIC

OIC: number = 4.62

OLD

OLD: number = 10.47

OLZ

OLZ: number = 5.32

OMH

OMH: number = 5.26

OMT

OMT: number = 5.07

OMX

OMX: number = 6.15

OMY

OMY: number = 6.11

ONH

ONH: number = 6.14

ONL

ONL: number = 4.83

ORN

ORN: number = 4.25

ORQ

ORQ: number = 6.04

OSE

OSE: number = 4.49

OTH

OTH: number = 3.6

OTY

OTY: number = 6.51

OXX

OXX: number = 7.05

OYL

OYL: number = 6.42

OZT

OZT: number = 3.4

P2Q

P2Q: number = 9.8

P2Y

P2Y: number = 2.51

P3Q

P3Q: number = 9.54

PAQ

PAQ: number = 8.77

PAT

PAT: number = 6.05

PBF

PBF: number = 9.75

PCA

PCA: number = 3.48

PCS

PCS: number = 5.05

PE1

PE1: number = 8.01

PEC

PEC: number = 6.54

PF5

PF5: number = 6.28

PFF

PFF: number = 6.31

PFX

PFX: number = 11.84

PG1

PG1: number = 10.67

PHA

PHA: number = 5.11

PHD

PHD: number = 5.35

PHE

PHE: number = 5.06

PHI

PHI: number = 7.12

PHL

PHL: number = 5.17

PLJ

PLJ: number = 3.71

PM3

PM3: number = 8.78

POM

POM: number = 3.6

PPN

PPN: number = 7.24

PR3

PR3: number = 5.12

PR4

PR4: number = 4.52

PR7

PR7: number = 4.66

PRJ

PRJ: number = 5.26

PRK

PRK: number = 9.15

PRO

PRO: number = 2.41

PRR

PRR: number = 5.58

PRS

PRS: number = 2.63

PRV

PRV: number = 4.28

PSH

PSH: number = 7.26

PSW

PSW: number = 4.65

PTH

PTH: number = 8.35

PTM

PTM: number = 8.74

PTR

PTR: number = 8.64

PVH

PVH: number = 4.58

PXU

PXU: number = 2.46

PYA

PYA: number = 7.75

PYL

PYL: number = 9.67

PYX

PYX: number = 11.3

QCS

QCS: number = 5.18

QIL

QIL: number = 3.84

QMM

QMM: number = 6.13

QPA

QPA: number = 6.95

QPH

QPH: number = 5.15

R1A

R1A: number = 8.2

R2T

R2T: number = 4.71

R4K

R4K: number = 4.67

RE0

RE0: number = 5.53

RE3

RE3: number = 5.29

RGL

RGL: number = 7.03

RVX

RVX: number = 7.01

S12

S12: number = 18.57

S1H

S1H: number = 19.21

S2C

S2C: number = 7.54

S2P

S2P: number = 4.81

SAC

SAC: number = 3.49

SAH

SAH: number = 11.7

SAR

SAR: number = 2.48

SBL

SBL: number = 8.96

SCH

SCH: number = 4.46

SCS

SCS: number = 5.48

SCY

SCY: number = 4.53

SD4

SD4: number = 4.57

SDP

SDP: number = 6.07

SE7

SE7: number = 4.19

SEB

SEB: number = 8.18

SEC

SEC: number = 2.96

SEE

SEE: number = 4.53

SEL

SEL: number = 2.46

SEN

SEN: number = 6.43

SEP

SEP: number = 4.8

SER

SER: number = 2.41

SET

SET: number = 2.46

SFE

SFE: number = 5.01

SGB

SGB: number = 6.88

SIB

SIB: number = 12.41

SIC

SIC: number = 4.81

SLL

SLL: number = 11.53

SLZ

SLZ: number = 5.69

SMC

SMC: number = 3.39

SME

SME: number = 4.8

SMF

SMF: number = 9

SNC

SNC: number = 3.93

SOC

SOC: number = 4.05

SOY

SOY: number = 10.94

SRZ

SRZ: number = 5.27

SUN

SUN: number = 6.73

SVA

SVA: number = 5.46

SVV

SVV: number = 5.09

SVX

SVX: number = 7.04

SVY

SVY: number = 7.1

SVZ

SVZ: number = 6.6

SXE

SXE: number = 6.65

SYS

SYS: number = 3.01

T0I

T0I: number = 7.34

T11

T11: number = 8.58

TA4

TA4: number = 5.55

TBG

TBG: number = 2.58

TCQ

TCQ: number = 8.56

TEF

TEF: number = 8.63

TH5

TH5: number = 4.65

TH6

TH6: number = 2.85

THC

THC: number = 3.8

THO

THO: number = 2.62

THR

THR: number = 2.5

TIH

TIH: number = 5.02

TIS

TIS: number = 4.81

TLY

TLY: number = 8.78

TMD

TMD: number = 6.76

TNR

TNR: number = 6.88

TOQ

TOQ: number = 7.5

TOX

TOX: number = 6.78

TPL

TPL: number = 5.41

TPO

TPO: number = 4.73

TPQ

TPQ: number = 6.48

TQI

TQI: number = 7.68

TQQ

TQQ: number = 7.76

TQZ

TQZ: number = 6.97

TRF

TRF: number = 6.69

TRN

TRN: number = 5.95

TRO

TRO: number = 5.82

TRP

TRP: number = 6.07

TRQ

TRQ: number = 7.36

TRW

TRW: number = 11.8

TRX

TRX: number = 7.27

TS9

TS9: number = 3.92

TSY

TSY: number = 4.26

TTQ

TTQ: number = 7.71

TTS

TTS: number = 9.41

TXY

TXY: number = 6.44

TY2

TY2: number = 6.49

TY5

TY5: number = 10.6

TY8

TY8: number = 7.22

TYB

TYB: number = 6.46

TYI

TYI: number = 6.49

TYJ

TYJ: number = 6.25

TYN

TYN: number = 9.87

TYO

TYO: number = 7.71

TYQ

TYQ: number = 6.43

TYR

TYR: number = 6.38

TYS

TYS: number = 8.59

TYX

TYX: number = 8.31

TYY

TYY: number = 6.54

U2X

U2X: number = 11.54

U3X

U3X: number = 11.7

UAL

UAL: number = 4.68

UF0

UF0: number = 19.72

UGY

UGY: number = 3.7

UN2

UN2: number = 3.22

UNK

UNK: number = 1.64

UU4

UU4: number = 2.49

UU5

UU5: number = 4.98

VAD

VAD: number = 2.56

VAH

VAH: number = 3.88

VAL

VAL: number = 2.51

VLL

VLL: number = 2.54

VLM

VLM: number = 2.51

VMS

VMS: number = 8.82

VOL

VOL: number = 2.55

VR0

VR0: number = 10.51

WFP

WFP: number = 6.07

WLU

WLU: number = 4.24

WPA

WPA: number = 5.11

WRP

WRP: number = 8.16

WVL

WVL: number = 4.69

X2W

X2W: number = 6.6

XCN

XCN: number = 4.57

XPR

XPR: number = 7.68

XSN

XSN: number = 3.47

XW1

XW1: number = 9.36

XX1

XX1: number = 9.92

XXA

XXA: number = 7.34

YCM

YCM: number = 5.32

YCP

YCP: number = 3.01

YNM

YNM: number = 6.39

YOF

YOF: number = 6.44

YPZ

YPZ: number = 9.38

YYA

YYA: number = 7.3

Z3E

Z3E: number = 7.2

Z70

Z70: number = 7.4

ZBZ

ZBZ: number = 7.79

ZCL

ZCL: number = 6.71

ZYJ

ZYJ: number = 11.4

ZYK

ZYK: number = 11.45

ZZD

ZZD: number = 8.16

ZZJ

ZZJ: number = 2.44

ZZU

ZZU: number = 6.94

Const RnaPdbsContent

RnaPdbsContent: object

A

A: string = aPdbString

C

C: string = cPdbString

G

G: string = gPdbString

U

U: string = uPdbString

Const ScaleDefaultParameters

ScaleDefaultParameters: object

domain

domain: number[] = [0, 1] as number[]

mode

mode: ColorMode = 'hcl' as ColorMode

reverse

reverse: boolean = false

scale

scale: string | string[] = 'uniform' as string | string[]

value

value: number = 16777215

Const ShapeDefaultParameters

ShapeDefaultParameters: object

aspectRatio

aspectRatio: number = 1.5

dashedCylinder

dashedCylinder: boolean = false

disableImpostor

disableImpostor: boolean = false

labelParams

labelParams: Partial<{ attachment: TextAttachments; backgroundColor: string | number; backgroundMargin: number; backgroundOpacity: number; borderColor: string | number; borderWidth: number; fixedSize: false; fontFamily: TextFonts; fontSize: number; fontStyle: TextStyles; fontWeight: TextWeights; forceTransparent: true; showBackground: false; showBorder: false; xOffset: number; yOffset: number; zOffset: number } & { background: boolean; clipCenter: Vector3; clipNear: number; clipRadius: number; depthWrite: boolean; diffuse: number; diffuseInterior: boolean; disablePicking: boolean; flatShaded: boolean; forceTransparent: boolean; interiorColor: number; interiorDarkening: number; matrix: Matrix4; metalness: number; opacity: number; opaqueBack: boolean; roughness: number; side: BufferSide; sortParticles: boolean; useInteriorColor: boolean; wireframe: boolean }> = {} as Partial<TextBufferParameters>

linewidth

linewidth: number = 2

openEnded

openEnded: boolean = false

pointSize

pointSize: number = 2

radialSegments

radialSegments: number = 50

sizeAttenuation

sizeAttenuation: boolean = false

sphereDetail

sphereDetail: number = 2

useTexture

useTexture: boolean = true

Const SstrucMap

SstrucMap: object

-1

-1: number = ''.charCodeAt(0)

0

0: number = 'i'.charCodeAt(0)

1

1: number = 's'.charCodeAt(0)

2

2: number = 'h'.charCodeAt(0)

3

3: number = 'e'.charCodeAt(0)

4

4: number = 'g'.charCodeAt(0)

5

5: number = 'b'.charCodeAt(0)

6

6: number = 't'.charCodeAt(0)

7

7: number = 'l'.charCodeAt(0)

Const StageDefaultParameters

StageDefaultParameters: object

ambientColor

ambientColor: string | number = 0xdddddd as string | number

ambientIntensity

ambientIntensity: number = 0.2

backgroundColor

backgroundColor: string | number = 'black' as string | number

cameraEyeSep

cameraEyeSep: number = 0.3

cameraFov

cameraFov: number = 40

cameraType

cameraType: CameraType = 'perspective' as 'perspective' | 'orthographic' | 'stereo'

clipDist

clipDist: number = 10

clipFar

clipFar: number = 1000

clipMode

clipMode: string = "scene"

clipNear

clipNear: number = 1

clipScale

clipScale: string = "relative"

fogFar

fogFar: number = 150

fogNear

fogNear: number = 50

hoverTimeout

hoverTimeout: number = 0

impostor

impostor: boolean = true

lightColor

lightColor: string | number = 0xdddddd as string | number

lightIntensity

lightIntensity: number = 1

mousePreset

mousePreset: "default" | "pymol" | "coot" | "astexviewer" = 'default' as MouseControlPreset

panSpeed

panSpeed: number = 1

quality

quality: RenderQualityType = 'medium' as RenderQualityType

rotateSpeed

rotateSpeed: number = 2

sampleLevel

sampleLevel: number = 0

tooltip

tooltip: boolean = true

workerDefault

workerDefault: boolean = true

zoomSpeed

zoomSpeed: number = 1.2

Const StructureColors

StructureColors: object

alphaHelix

alphaHelix: number = 16711808

betaStrand

betaStrand: number = 16762880

betaTurn

betaTurn: number = 6324479

carbohydrate

carbohydrate: number = 10921722

coil

coil: number = 16777215

dna

dna: number = 11403518

piHelix

piHelix: number = 6291584

rna

rna: number = 16580962

threeTenHelix

threeTenHelix: number = 10485888

Private Const SymOpCode

SymOpCode: object
file

Symmetry Constants

author

Alexander Rose alexander.rose@weirdbyte.de

: string = "X"

!

!: string = "Y"

#

#: string = "Z"

$

$: string = "-X"

%

%: string = "-Y"

&

&: string = "-Z"

'

': string = "Y+1/2"

(

(: string = "1/2+X"

)

): string = "1/2+Y"

*

*: string = "1/2-X"

+

+: string = "1/2+Z"

,

,: string = "1/2-Y"

-

-: string = "1/2-Z"

.

.: string = "X+1/2"

/

/: string = "Z+1/2"

0

0: string = "-X+1/2"

1

1: string = "-Y+1/2"

2

2: string = "-Z+1/2"

3

3: string = "1/4+X"

4

4: string = "1/4-Y"

5

5: string = "1/4+Z"

6

6: string = "1/4-X"

7

7: string = "1/4+Y"

8

8: string = "3/4-Y"

9

9: string = "3/4+Z"

:

:: string = "3/4+Y"

;

;: string = "3/4+X"

<

<: string = "3/4-X"

=

=: string = "1/4-Z"

>

>: string = "3/4-Z"

?

?: string = "X-Y"

@

@: string = "Y-X"

A

A: string = "Z+1/3"

B

B: string = "Z+2/3"

C

C: string = "X+2/3"

D

D: string = "Y+1/3"

E

E: string = "-Y+2/3"

F

F: string = "X-Y+1/3"

G

G: string = "Y-X+2/3"

H

H: string = "-X+1/3"

I

I: string = "X+1/3"

J

J: string = "Y+2/3"

K

K: string = "-Y+1/3"

L

L: string = "X-Y+2/3"

M

M: string = "Y-X+1/3"

N

N: string = "-X+2/3"

O

O: string = "2/3+X"

P

P: string = "1/3+Y"

Q

Q: string = "1/3+Z"

R

R: string = "2/3-Y"

S

S: string = "1/3+X-Y"

T

T: string = "2/3+Y-X"

U

U: string = "1/3-X"

V

V: string = "2/3-X"

W

W: string = "1/3-Y"

X

X: string = "1/3-Z"

Y

Y: string = "2/3+Y"

Z

Z: string = "1/3+Y-X"

[

[: string = "2/3+X-Y"

]

]: string = "1/3+X"

^

^: string = "2/3+Z"

_

_: string = "2/3-Z"

`

`: string = "5/6+Z"

a

a: string = "1/6+Z"

b

b: string = "5/6-Z"

c

c: string = "1/6-Z"

d

d: string = "Z+5/6"

e

e: string = "Z+1/6"

f

f: string = "Z+1/4"

g

g: string = "+Y"

Const TextAtlasDefaultParams

TextAtlasDefaultParams: object

font

font: TextFonts = 'sans-serif' as TextFonts

height

height: number = 1024

outline

outline: number = 3

size

size: number = 36

style

style: TextStyles = 'normal' as TextStyles

variant

variant: "normal" = 'normal' as TextVariants

weight

weight: TextWeights = 'normal' as TextWeights

width

width: number = 1024

Const TrajectoryPlayerDefaultParameters

TrajectoryPlayerDefaultParameters: object

direction

direction: TrajectoryPlayerDirection = 'forward' as TrajectoryPlayerDirection

end

end: number = 0

interpolateStep

interpolateStep: number = 5

interpolateType

interpolateType: TrajectoryPlayerInterpolateType = '' as TrajectoryPlayerInterpolateType

mode

mode: TrajectoryPlayerMode = 'loop' as TrajectoryPlayerMode

start

start: number = 0

step

step: number = 1

timeout

timeout: number = 50

Const Valences

Valences: object

1

1: number[] = [1]

10

10: number[] = [0]

11

11: number[] = [1]

12

12: number[] = [2]

13

13: number[] = [6]

14

14: number[] = [6]

15

15: number[] = [3, 5, 7]

16

16: number[] = [2, 4, 6]

17

17: number[] = [1]

18

18: number[] = [0]

19

19: number[] = [1]

2

2: number[] = [0]

20

20: number[] = [2]

3

3: number[] = [1]

31

31: number[] = [3]

32

32: number[] = [4]

33

33: number[] = [3, 5]

34

34: number[] = [2, 4, 6]

35

35: number[] = [1]

36

36: number[] = [0]

37

37: number[] = [1]

38

38: number[] = [2]

4

4: number[] = [2]

49

49: number[] = [3]

5

5: number[] = [3]

50

50: number[] = [4]

51

51: number[] = [3, 5]

52

52: number[] = [2]

53

53: number[] = [1, 2, 5]

54

54: number[] = [0, 2]

55

55: number[] = [1]

56

56: number[] = [2]

6

6: number[] = [4]

7

7: number[] = [3]

8

8: number[] = [2]

81

81: number[] = [3]

82

82: number[] = [4]

83

83: number[] = [3]

84

84: number[] = [2]

85

85: number[] = [1]

86

86: number[] = [0]

87

87: number[] = [1]

88

88: number[] = [2]

9

9: number[] = [1]

Const VdwRadii

VdwRadii: object

1

1: number = 1.1

10

10: number = 1.54

100

100: number = 2

101

101: number = 2

102

102: number = 2

103

103: number = 2

104

104: number = 2

105

105: number = 2

106

106: number = 2

107

107: number = 2

108

108: number = 2

109

109: number = 2

11

11: number = 2.27

110

110: number = 2

111

111: number = 2

112

112: number = 2

113

113: number = 2

114

114: number = 2

115

115: number = 2

116

116: number = 2

117

117: number = 2

118

118: number = 2

12

12: number = 1.73

13

13: number = 1.84

14

14: number = 2.1

15

15: number = 1.8

16

16: number = 1.8

17

17: number = 1.75

18

18: number = 1.88

19

19: number = 2.75

2

2: number = 1.4

20

20: number = 2.31

21

21: number = 2.3

22

22: number = 2.15

23

23: number = 2.05

24

24: number = 2.05

25

25: number = 2.05

26

26: number = 2.05

27

27: number = 2

28

28: number = 2

29

29: number = 2

3

3: number = 1.81

30

30: number = 2.1

31

31: number = 1.87

32

32: number = 2.11

33

33: number = 1.85

34

34: number = 1.9

35

35: number = 1.83

36

36: number = 2.02

37

37: number = 3.03

38

38: number = 2.49

39

39: number = 2.4

4

4: number = 1.53

40

40: number = 2.3

41

41: number = 2.15

42

42: number = 2.1

43

43: number = 2.05

44

44: number = 2.05

45

45: number = 2

46

46: number = 2.05

47

47: number = 2.1

48

48: number = 2.2

49

49: number = 2.2

5

5: number = 1.92

50

50: number = 1.93

51

51: number = 2.17

52

52: number = 2.06

53

53: number = 1.98

54

54: number = 2.16

55

55: number = 3.43

56

56: number = 2.68

57

57: number = 2.5

58

58: number = 2.48

59

59: number = 2.47

6

6: number = 1.7

60

60: number = 2.45

61

61: number = 2.43

62

62: number = 2.42

63

63: number = 2.4

64

64: number = 2.38

65

65: number = 2.37

66

66: number = 2.35

67

67: number = 2.33

68

68: number = 2.32

69

69: number = 2.3

7

7: number = 1.55

70

70: number = 2.28

71

71: number = 2.27

72

72: number = 2.25

73

73: number = 2.2

74

74: number = 2.1

75

75: number = 2.05

76

76: number = 2

77

77: number = 2

78

78: number = 2.05

79

79: number = 2.1

8

8: number = 1.52

80

80: number = 2.05

81

81: number = 1.96

82

82: number = 2.02

83

83: number = 2.07

84

84: number = 1.97

85

85: number = 2.02

86

86: number = 2.2

87

87: number = 3.48

88

88: number = 2.83

89

89: number = 2

9

9: number = 1.47

90

90: number = 2.4

91

91: number = 2

92

92: number = 2.3

93

93: number = 2

94

94: number = 2

95

95: number = 2

96

96: number = 2

97

97: number = 2

98

98: number = 2

99

99: number = 2

Const bondTypes

bondTypes: object

1

1: number = 1

2

2: number = 2

3

3: number = 3

am

am: number = 1

ar

ar: number = 1

du

du: number = 1

nc

nc: number = 0

un

un: number = 1

Const itemSize

itemSize: object

c

c: number = 3

f

f: number = 1

v2

v2: number = 2

v3

v3: number = 3

Const partialCharges

partialCharges: object

ARG

ARG: object

CD

CD: number = 0.1

CZ

CZ: number = 0.5

NE

NE: number = -0.1

ASN

ASN: object

CG

CG: number = 0.55

OD1

OD1: number = -0.55

ASP

ASP: object

CB

CB: number = -0.16

CG

CG: number = 0.36

OD1

OD1: number = -0.6

OD2

OD2: number = -0.6

CYS

CYS: object

CB

CB: number = 0.19

SG

SG: number = -0.19

GLN

GLN: object

CD

CD: number = 0.55

OE1

OE1: number = -0.55

GLU

GLU: object

CD

CD: number = 0.36

CG

CG: number = -0.16

OE1

OE1: number = -0.6

OE2

OE2: number = -0.6

HIS

HIS: object

CB

CB: number = 0.1

CD2

CD2: number = 0.2

CE1

CE1: number = 0.45

CG

CG: number = 0.15

ND1

ND1: number = 0.05

NE2

NE2: number = 0.05

LYS

LYS: object

CE

CE: number = 0.25

NZ

NZ: number = 0.75

MET

MET: object

CE

CE: number = 0.06

CG

CG: number = 0.06

SD

SD: number = -0.12

PTR

PTR: object

C

C: number = 0.55

CA

CA: number = 0.1

CZ

CZ: number = 0.25

N

N: number = -0.35

O

O: number = -0.55

O1P

O1P: number = -0.85

O2P

O2P: number = -0.85

O3P

O3P: number = -0.85

OG1

OG1: number = -1.1

P

P: number = 1.4

SEP

SEP: object

C

C: number = 0.55

CA

CA: number = 0.1

CB

CB: number = 0.25

N

N: number = -0.35

O

O: number = -0.55

O1P

O1P: number = -0.85

O2P

O2P: number = -0.85

O3P

O3P: number = -0.85

OG1

OG1: number = -1.1

P

P: number = 1.4

SER

SER: object

CB

CB: number = 0.25

OG

OG: number = -0.25

THR

THR: object

CB

CB: number = 0.25

OG1

OG1: number = -0.25

TPO

TPO: object

C

C: number = 0.55

CA

CA: number = 0.1

CB

CB: number = 0.25

N

N: number = -0.35

O

O: number = -0.55

O1P

O1P: number = -0.85

O2P

O2P: number = -0.85

O3P

O3P: number = -0.85

OG1

OG1: number = -1.1

P

P: number = 1.4

TRP

TRP: object

CD1

CD1: number = 0.06

CD2

CD2: number = 0.1

CE2

CE2: number = -0.04

CE3

CE3: number = -0.03

CG

CG: number = -0.03

NE1

NE1: number = -0.06

TYR

TYR: object

CZ

CZ: number = 0.25

OH

OH: number = -0.25

backbone

backbone: object

C

C: number = 0.55

CA

CA: number = 0.1

N

N: number = -0.35

O

O: number = -0.55

Const types

types: object

BYTE

BYTE: number = 1

CHAR

CHAR: number = 2

DOUBLE

DOUBLE: number = 6

FLOAT

FLOAT: number = 5

INT

INT: number = 4

SHORT

SHORT: number = 3

Generated using TypeDoc