src/structure/validation.js

/**
 * @file Validation
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 * @private
 */

import { Vector3, Color } from '../../lib/three.es6.js'

import { Debug, Log } from '../globals.js'
import { defaults } from '../utils.js'
import { ClashPicker } from '../utils/picker.js'
import { uniformArray3 } from '../math/array-utils.js'
import { guessElement } from '../structure/structure-utils.js'

function getSele (a, atomname, useAltcode) {
  const icode = a.icode.value
  const chain = a.chain.value
  const altcode = a.altcode.value
  let sele = a.resnum.value
  if (icode.trim()) sele += '^' + icode
  if (chain.trim()) sele += ':' + chain
  if (atomname) sele += '.' + atomname
  if (useAltcode && altcode.trim()) sele += '%' + altcode
  sele += '/' + (parseInt(a.model.value) - 1)
  return sele
}

function setBitDict (dict, key, bit) {
  if (dict[ key ] === undefined) {
    dict[ key ] = bit
  } else {
    dict[ key ] |= bit
  }
}

function hasAttrValue (attr, value) {
  return attr !== undefined && attr.value === value
}

function getAtomSele (ap) {
  const icode = ap.inscode
  const chain = ap.chainname
  const atomname = ap.atomname
  const altcode = ap.altloc
  let sele = ap.resno
  if (icode) sele += '^' + icode
  if (chain) sele += ':' + chain
  if (atomname) sele += '.' + atomname
  if (altcode) sele += '%' + altcode
  sele += '/' + ap.modelIndex
  return sele
}

function getProblemCount (clashDict, g, ga) {
  let geoProblemCount = 0

  const clashes = g.getElementsByTagName('clash')
  for (let j = 0, jl = clashes.length; j < jl; ++j) {
    if (clashDict[ clashes[ j ].attributes.cid.value ]) {
      geoProblemCount += 1
      break
    }
  }

  const angleOutliers = g.getElementsByTagName('angle-outlier')
  if (angleOutliers.length > 0) {
    geoProblemCount += 1
  }

  const bondOutliers = g.getElementsByTagName('bond-outlier')
  if (bondOutliers.length > 0) {
    geoProblemCount += 1
  }

  const planeOutliers = g.getElementsByTagName('plane-outlier')
  if (planeOutliers.length > 0) {
    geoProblemCount += 1
  }

  if (hasAttrValue(ga.rota, 'OUTLIER')) {
    geoProblemCount += 1
  }

  if (hasAttrValue(ga.rama, 'OUTLIER')) {
    geoProblemCount += 1
  }

  if (hasAttrValue(ga.RNApucker, 'outlier')) {
    geoProblemCount += 1
  }

  return geoProblemCount
}

class Validation {
  constructor (name, path) {
    this.name = name
    this.path = path

    this.rsrzDict = {}
    this.rsccDict = {}
    this.clashDict = {}
    this.clashArray = []
    this.geoDict = {}
    this.geoAtomDict = {}
    this.atomDict = {}
    this.clashSele = 'NONE'
  }

  get type () { return 'validation' }

  fromXml (xml) {
    if (Debug) Log.time('Validation.fromXml')

    const rsrzDict = this.rsrzDict
    const rsccDict = this.rsccDict
    const clashDict = this.clashDict
    const clashArray = this.clashArray
    const geoDict = this.geoDict
    const geoAtomDict = this.geoAtomDict
    const atomDict = this.atomDict

    const groups = xml.getElementsByTagName('ModelledSubgroup')

    const _clashDict = {}
    const clashList = []

    if (Debug) Log.time('Validation.fromXml#clashDict')

    for (let i = 0, il = groups.length; i < il; ++i) {
      const g = groups[ i ]
      const ga = g.attributes

      const sele = getSele(ga)
      if (ga.rsrz !== undefined) {
        rsrzDict[ sele ] = parseFloat(ga.rsrz.value)
      }
      if (ga.rscc !== undefined) {
        rsccDict[ sele ] = parseFloat(ga.rscc.value)
      }
      ga.sele = sele

      const clashes = g.getElementsByTagName('clash')

      for (let j = 0, jl = clashes.length; j < jl; ++j) {
        const ca = clashes[ j ].attributes
        const atom = ca.atom.value

        if (guessElement(atom) !== 'H') {
          const cid = ca.cid.value
          const atomSele = getSele(ga, atom, true)
          atomDict[ atomSele ] = true

          if (_clashDict[ cid ] === undefined) {
            _clashDict[ cid ] = {
              sele1: atomSele,
              res1: sele
            }
          } else {
            const c = _clashDict[ cid ]
            if (c.res1 !== sele) {
              c.sele2 = atomSele
              c.res2 = sele
              clashList.push(c.res1, sele)
              clashDict[ cid ] = c
              clashArray.push(c)
            }
          }
        }
      }
    }

    if (Debug) Log.timeEnd('Validation.fromXml#clashDict')

    for (let i = 0, il = groups.length; i < il; ++i) {
      const g = groups[ i ]
      const ga = g.attributes

      const sele = ga.sele
      const isPolymer = ga.seq.value !== '.'

      if (isPolymer) {
        const geoProblemCount = getProblemCount(clashDict, g, ga)
        if (geoProblemCount > 0) {
          geoDict[ sele ] = geoProblemCount
        }
      } else {
        const clashes = g.getElementsByTagName('clash')
        const mogBondOutliers = g.getElementsByTagName('mog-bond-outlier')
        const mogAngleOutliers = g.getElementsByTagName('mog-angle-outlier')

        if (mogBondOutliers.length > 0 || mogAngleOutliers.length > 0 || clashes.length > 0) {
          const atomDict = {}
          geoAtomDict[ sele ] = atomDict

          for (let j = 0, jl = clashes.length; j < jl; ++j) {
            const ca = clashes[ j ].attributes
            if (clashDict[ ca.cid.value ]) {
              setBitDict(atomDict, ca.atom.value, 1)
            }
          }

          for (let j = 0, jl = mogBondOutliers.length; j < jl; ++j) {
            const mbo = mogBondOutliers[ j ].attributes
            mbo.atoms.value.split(',').forEach(function (atomname) {
              setBitDict(atomDict, atomname, 2)
            })
          }

          for (let j = 0, jl = mogAngleOutliers.length; j < jl; ++j) {
            const mao = mogAngleOutliers[ j ].attributes
            mao.atoms.value.split(',').forEach(function (atomname) {
              setBitDict(atomDict, atomname, 4)
            })
          }
        }
      }
    }

    this.clashSele = clashList.length ? clashList.join(' OR ') : 'NONE'

    if (Debug) Log.timeEnd('Validation.fromXml')
  }

  getClashData (params) {
    if (Debug) Log.time('Validation.getClashData')

    const p = params || {}

    const s = p.structure
    const atomSet = s.atomSet
    const c = new Color(defaults(p.color, '#f0027f'))

    const ap1 = s.getAtomProxy()
    const ap2 = s.getAtomProxy()
    const vDir = new Vector3()
    const vPos1 = new Vector3()
    const vPos2 = new Vector3()

    const clashArray = this.clashArray
    const n = clashArray.length

    const position1 = new Float32Array(n * 3)
    const position2 = new Float32Array(n * 3)
    const color = uniformArray3(n, c.r, c.g, c.b)
    const radius = new Float32Array(n)
    const picking = new Float32Array(n)

    if (Debug) Log.time('Validation.getClashData#atomDict')

    const atomDict = this.atomDict

    s.eachAtom(function (ap) {
      const sele = getAtomSele(ap)
      if (atomDict[ sele ] === true) {
        atomDict[ sele ] = ap.index
      }
    })

    if (Debug) Log.timeEnd('Validation.getClashData#atomDict')

    let i = 0

    clashArray.forEach(function (c, idx) {
      ap1.index = atomDict[ c.sele1 ]
      ap2.index = atomDict[ c.sele2 ]

      if (ap1.index === undefined || ap2.index === undefined ||
                !atomSet.isSet(ap1.index, ap2.index)) return

      vDir.subVectors(ap2, ap1).setLength(ap1.vdw)
      vPos1.copy(ap1).add(vDir)

      vDir.subVectors(ap1, ap2).setLength(ap2.vdw)
      vPos2.copy(ap2).add(vDir)

      const dHalf = ap1.distanceTo(ap2) / 2
      const r1 = Math.sqrt(ap1.vdw * ap1.vdw - dHalf * dHalf)
      const r2 = Math.sqrt(ap2.vdw * ap2.vdw - dHalf * dHalf)

      vPos1.toArray(position1, i * 3)
      vPos2.toArray(position2, i * 3)
      radius[ i ] = (r1 + r2) / 2
      picking[ i ] = idx

      ++i
    })

    if (Debug) Log.timeEnd('Validation.getClashData')

    return {
      position1: position1.subarray(0, i * 3),
      position2: position2.subarray(0, i * 3),
      color: color.subarray(0, i * 3),
      color2: color.subarray(0, i * 3),
      radius: radius.subarray(0, i),
      picking: new ClashPicker(picking.subarray(0, i), this, s)
    }
  }
}

export default Validation