@gmod/hic 1.3.2 → 2.0.0

package/esm/normalizationVector.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalizationVector.js","sourceRoot":"","sources":["../src/normalizationVector.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"normalizationVector.js","sourceRoot":"","sources":["../src/normalizationVector.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmod/hic",
-  "version": "1.3.2",
+  "version": "2.0.0",
   "packageManager": "pnpm@11.15.1",
   "description": "Read .hic contact matrix files in node or the browser",
   "license": "MIT",

package/src/bufferedFile.ts

@@ -41,30 +41,16 @@ export default class BufferedFile {
       // Request within buffer bounds
       const sliceStart = start - bufferStart
       result = buf.slice(sliceStart, sliceStart + length)
-    } else if (buf && start < bufferStart && end > bufferStart) {
-      // Overlap left (unexpected in straw); we don't adjust the buffer
-      const l1 = bufferStart - start
-      const a1 = await this.file.read(position, l1, opts)
-      const l2 = length - l1
-      if (l2 > 0) {
-        result = concatBuffers(a1, buf.slice(0, l2))
-      } else {
-        result = a1
-      }
-    } else if (buf && start < bufferEnd && end > bufferEnd) {
-      // Overlap right
+    } else if (buf && start >= bufferStart && start < bufferEnd) {
+      // Overlap right. The expected-values walk only moves forward, so a
+      // request starting before the buffer takes the fresh read below.
       const l1 = bufferEnd - start
       const a1 = buf.slice(this.bufferLength - l1, this.bufferLength)
-      const l2 = length - l1
-      if (l2 > 0) {
-        const next = await this.file.read(bufferEnd, this.size, opts)
-        this.buffer = next
-        this.bufferStart = bufferEnd
-        this.bufferLength = next.byteLength
-        result = concatBuffers(a1, next.slice(0, l2))
-      } else {
-        result = a1
-      }
+      const next = await this.file.read(bufferEnd, this.size, opts)
+      this.buffer = next
+      this.bufferStart = bufferEnd
+      this.bufferLength = next.byteLength
+      result = concatBuffers(a1, next.slice(0, length - l1))
     } else {
       // No overlap with buffer
       const next = await this.file.read(position, this.size, opts)

package/src/hicFile.ts

@@ -5,7 +5,6 @@ import { LocalFile } from 'generic-filehandle2'
 import { binWindow } from './binWindow.ts'
 import BinaryParser from './binary.ts'
 import BufferedFile from './bufferedFile.ts'
-import LRU from './lru.ts'
 import Matrix from './matrix.ts'
 import NormalizationVector from './normalizationVector.ts'
 import { readerFromFilehandle } from './reader.ts'
@@ -66,8 +65,7 @@ export interface HicConfig {
   /**
    * Ceiling on the decompressed contacts the block cache holds, in bytes.
    * Defaults to 128 MB. Lower it where the budget is tight and re-reading is
-   * cheaper than the memory; raising it buys nothing once a fetch's working set
-   * fits, since the entry cap bounds the cache too.
+   * cheaper than the memory.
    */
   blockCacheMaxBytes?: number
 }
@@ -75,7 +73,7 @@ export interface HicConfig {
 // Cached blocks are the decompressed records and nothing else. hic-straw also
 // hung the MatrixZoomData and the block-index entry off each Block; neither was
 // ever read back, and the zoom data pinned a whole `blockIndex` record per
-// cached block for the lifetime of the LRU.
+// cached block for the lifetime of the cache.
 interface Block {
   blockNumber: number
   records: ContactRecords
@@ -122,15 +120,13 @@ function truncateRecords(records: ContactRecords, n: number): ContactRecords {
 // The cliffs are exactly these three capacities. Note the first column: 41% of a
 // cold whole-genome fetch's reads were re-reads of normalization vectors the
 // same fetch had already fetched.
-const BLOCK_CACHE_MAX_ENTRIES = 1024
-// The bound the entry cap was standing in for. Blocks became struct-of-arrays
-// (see contactRecords.ts), so a cached contact is 12 bytes of untraced
-// ArrayBuffer rather than ~55 on the GC-traced heap — but a block still holds
-// every contact in its bin square, which is the one thing here that can hold
-// real memory, and block sizes vary by more than an order of magnitude with
-// binsize. Measured on the file above: 0.05 MB at 2.5 Mb, 0.23 MB at 100 kb. So
-// the entry cap now tracks the working set and this tracks the memory, instead
-// of one number answering both badly. See LRU's WeightOpts.
+//
+// Blocks became struct-of-arrays (see contactRecords.ts), so a cached contact is
+// 12 bytes of untraced ArrayBuffer rather than ~55 on the GC-traced heap — but a
+// block still holds every contact in its bin square, which is the one thing here
+// that can hold real memory, and block sizes vary by more than an order of
+// magnitude with binsize. Measured on the file above: 0.05 MB at 2.5 Mb, 0.23 MB
+// at 100 kb. So the block cache's only bound is its byte budget.
 //
 // This is the one capacity here a caller can override (`blockCacheMaxBytes`),
 // because it is the only one that bounds MEMORY. The two entry caps below are
@@ -152,7 +148,10 @@ const NORM_VECTOR_CACHE_SIZE = 64
 // so no separate resolution generation is needed to keep entries apart —
 // hic-straw's extra `resolution` field only made the cache single-resolution
 // (every zoom step threw the previous level away).
-function blockCacheWeight(block: Block) {
+function blockCacheWeight(block: Block | undefined) {
+  if (!block) {
+    return 0
+  }
   const { bin1, bin2, counts } = block.records
   return bin1.byteLength + bin2.byteLength + counts.byteLength
 }
@@ -167,7 +166,7 @@ function getNormalizationVectorKey(
 }
 
 export class HicFile {
-  private config: HicConfig
+  private nvi: string | undefined
   private file: Reader
 
   // These caches share the in-flight read, not just its result. A
@@ -190,7 +189,7 @@ export class HicFile {
   })
   // Assigned in the constructor rather than here, since its byte budget is
   // configurable and a field initializer cannot see `config`.
-  private blockCache: LRU<string, Block>
+  private blockCache: SharedReadCache<string, Block | undefined>
   private normVectorIndexPosition = -1
   private normVectorIndexSize = -1
 
@@ -203,18 +202,17 @@ export class HicFile {
   normExpectedValueVectorsPosition: number | undefined
 
   private chromosomes: Chromosome[] = []
-  private chromosomeIndexMap: Record<string, number> = {}
-  private chrAliasTable: Record<string, string> = {}
+  private chromosomeIndexMap = new Map<string, number>()
   private bpResolutions: number[] = []
   private masterIndex: Record<string, MasterIndexEntry> = {}
   private meta: HicMetadata | undefined
 
   constructor(config: HicConfig) {
-    const { filehandle, path, reader, blockCacheMaxBytes } = config
-    this.config = config
-    this.blockCache = new LRU<string, Block>(BLOCK_CACHE_MAX_ENTRIES, {
-      maxBytes: blockCacheMaxBytes ?? BLOCK_CACHE_MAX_BYTES,
-      weigh: blockCacheWeight,
+    const { filehandle, path, reader, nvi, blockCacheMaxBytes } = config
+    this.nvi = nvi
+    this.blockCache = new SharedReadCache({
+      maxSize: blockCacheMaxBytes ?? BLOCK_CACHE_MAX_BYTES,
+      sizeOf: blockCacheWeight,
     })
     if (reader) {
       this.file = reader
@@ -282,7 +280,7 @@ export class HicFile {
     }
 
     const chromosomes: Chromosome[] = []
-    const chromosomeIndexMap: Record<string, number> = {}
+    const chromosomeIndexMap = new Map<string, number>()
     let nChrs = binaryParser.getInt()
     let i = 0
     while (nChrs-- > 0) {
@@ -292,7 +290,7 @@ export class HicFile {
         size: version < 9 ? binaryParser.getInt() : binaryParser.getLong(),
       }
       chromosomes.push(chr)
-      chromosomeIndexMap[chr.name] = chr.index
+      chromosomeIndexMap.set(chr.name, chr.index)
       i++
     }
 
@@ -302,17 +300,6 @@ export class HicFile {
       bpResolutions.push(binaryParser.getInt())
     }
 
-    const chrAliasTable: Record<string, string> = {}
-    for (const chrName of Object.keys(chromosomeIndexMap)) {
-      if (chrName.startsWith('chr')) {
-        chrAliasTable[chrName.slice(3)] = chrName
-      } else if (chrName === 'MT') {
-        chrAliasTable.chrM = chrName
-      } else {
-        chrAliasTable[`chr${chrName}`] = chrName
-      }
-    }
-
     throwIfAborted(signal)
     this.version = version
     this.footerPosition = footerPosition
@@ -324,7 +311,6 @@ export class HicFile {
     this.chromosomes = chromosomes
     this.chromosomeIndexMap = chromosomeIndexMap
     this.bpResolutions = bpResolutions
-    this.chrAliasTable = chrAliasTable
     this.meta = {
       version,
       genome: genomeId,
@@ -397,14 +383,13 @@ export class HicFile {
     normalization: string,
     region1: HicRegion,
     region2: HicRegion,
-    units: string,
     binsize: number,
     opts?: ProgressOpts,
   ) {
     await this.init(opts)
 
-    const idx1 = this.chromosomeIndexMap[this.getFileChrName(region1.chr)]
-    const idx2 = this.chromosomeIndexMap[this.getFileChrName(region2.chr)]
+    const idx1 = this.chromosomeIndexMap.get(region1.chr)
+    const idx2 = this.chromosomeIndexMap.get(region2.chr)
 
     // A `.hic` stores only `bin1 <= bin2`, so a query whose x window sits to the
     // right of its y window has to be swapped or it asks for the half of the
@@ -444,7 +429,7 @@ export class HicFile {
     // resolved once per pair rather than per block, each paired with the bin
     // offset its values start at.
     const [norm, blocks] = await Promise.all([
-      this.getNormVectors(normalization, r1, r2, units, binsize, opts),
+      this.getNormVectors(normalization, r1, r2, binsize, opts),
       // The measurable half of the pair: blocks are counted and the two norm
       // vectors are not, because the vector chain is two hops whatever the
       // query and the block chain is the one that grows with the region.
@@ -522,9 +507,8 @@ export class HicFile {
     //
     // `transposed` says the query was swapped, so `bin1` runs along `region2`.
     // Reported rather than left for the caller to re-derive: it is decided here
-    // from this file's own alias table and chromosome indices, and a caller
-    // re-deriving it off a divergent chr-name scheme would silently un-swap the
-    // wrong axis.
+    // from this file's chromosome indices, which a caller would otherwise have
+    // to look up again to know which axis to un-swap.
     return {
       records: contactRecords,
       appliedNormalization: norm ? normalization : 'NONE',
@@ -536,59 +520,29 @@ export class HicFile {
     normalization: string,
     r1: HicRegion,
     r2: HicRegion,
-    units: string,
     binsize: number,
     opts?: BaseOpts,
   ) {
+    if (!normalization || normalization === 'NONE') {
+      return undefined
+    }
     const signalOpts = { signal: opts?.signal }
-    let result:
-      | {
-          v1: Float64Array
-          v2: Float64Array
-          offset1: number
-          offset2: number
-        }
-      | undefined
-    if (normalization && normalization !== 'NONE') {
-      const chr1 = this.getFileChrName(r1.chr)
-      const chr2 = this.getFileChrName(r2.chr)
-      const offset1 = Math.floor(r1.start / binsize)
-      const offset2 = Math.floor(r2.start / binsize)
-      const nv1 = await this.getNormalizationVector(
-        normalization,
-        chr1,
-        units,
-        binsize,
-        signalOpts,
-      )
-      const nv2 =
-        chr1 === chr2
-          ? nv1
-          : await this.getNormalizationVector(
-              normalization,
-              chr2,
-              units,
-              binsize,
-              signalOpts,
-            )
-      if (nv1 && nv2) {
-        result = {
-          v1: await nv1.getValues(
-            offset1,
-            Math.ceil(r1.end / binsize),
-            signalOpts,
-          ),
-          v2: await nv2.getValues(
-            offset2,
-            Math.ceil(r2.end / binsize),
-            signalOpts,
-          ),
-          offset1,
-          offset2,
-        }
-      }
+    const [offset1, end1] = binWindow(r1, binsize)
+    const [offset2, end2] = binWindow(r2, binsize)
+    // Awaited in sequence, an inter-chromosomal pair would pay four
+    // round-trip waves for what is two hops per vector.
+    const [nv1, nv2] = await Promise.all([
+      this.getNormalizationVector(normalization, r1.chr, binsize, signalOpts),
+      this.getNormalizationVector(normalization, r2.chr, binsize, signalOpts),
+    ])
+    if (!nv1 || !nv2) {
+      return undefined
     }
-    return result
+    const [v1, v2] = await Promise.all([
+      nv1.getValues(offset1, end1, signalOpts),
+      nv2.getValues(offset2, end2, signalOpts),
+    ])
+    return { v1, v2, offset1, offset2 }
   }
 
   async getBlocks(
@@ -601,10 +555,8 @@ export class HicFile {
       `${zd.getKey()}_${blockNumber}`
 
     await this.init(opts)
-    const chr1 = this.getFileChrName(region1.chr)
-    const chr2 = this.getFileChrName(region2.chr)
-    const idx1 = this.chromosomeIndexMap[chr1]
-    const idx2 = this.chromosomeIndexMap[chr2]
+    const idx1 = this.chromosomeIndexMap.get(region1.chr)
+    const idx2 = this.chromosomeIndexMap.get(region2.chr)
 
     let blocks: (Block | undefined)[] = []
     if (idx1 === undefined) {
@@ -627,45 +579,42 @@ export class HicFile {
         }
 
         const blockNumbers = zd.getBlockNumbers(region1, region2, this.version)
-        const blockNumbersToQuery: number[] = []
-        for (const num of blockNumbers) {
-          const cached = this.blockCache.get(blockKey(num, zd))
-          if (cached) {
-            blocks.push(cached)
-          } else {
-            blockNumbersToQuery.push(num)
-          }
-        }
+        const keys = blockNumbers.map(num => blockKey(num, zd))
+        const cached = keys.map(key => this.blockCache.has(key))
 
         // Cached blocks are already done, not absent: a pan that reuses most
         // of its blocks reads most of the way along rather than restarting at
         // zero, which is what the bar should say — the work left is the reads.
+        // A block another fetch has in flight counts as cached too.
         //
         // A query covering no blocks at all reports nothing rather than `0, 0`:
         // there is no fraction in it, and a caller dividing would get NaN.
         const { onProgress } = opts ?? {}
-        let done = blocks.length
-        if (blockNumbers.length > 0) {
-          onProgress?.(done, blockNumbers.length)
+        const total = blockNumbers.length
+        let done = cached.filter(Boolean).length
+        if (total > 0) {
+          onProgress?.(done, total)
         }
-        // Still one `Promise.all`, so every block is still issued in one wave:
-        // what a remote file pays is round-trip DEPTH, and counting the
-        // completions must not turn one wave into a queue. `readChainDepth`
-        // pins that.
-        const newBlocks = await Promise.all(
-          blockNumbersToQuery.map(async blockNumber => {
-            const block = await this.readBlock(blockNumber, zd, signalOpts)
-            done++
-            onProgress?.(done, blockNumbers.length)
+        // One `Promise.all`, so every block is issued in one wave: what a
+        // remote file pays is round-trip DEPTH, and counting the completions
+        // must not turn one wave into a queue. `readChainDepth` pins that.
+        //
+        // A block number missing from the index has no data, so it skips the
+        // cache, which would otherwise keep a weightless entry for it forever.
+        blocks = await Promise.all(
+          blockNumbers.map(async (num, i) => {
+            const block = zd.blockIndex[num]
+              ? await this.blockCache.get(keys[i]!, opts?.signal, signal =>
+                  this.readBlock(num, zd, { signal }),
+                )
+              : undefined
+            if (!cached[i]) {
+              done++
+              onProgress?.(done, total)
+            }
             return block
           }),
         )
-        for (const block of newBlocks) {
-          if (block) {
-            this.blockCache.set(blockKey(block.blockNumber, zd), block)
-          }
-        }
-        blocks = blocks.concat(newBlocks)
       }
     }
     return blocks
@@ -793,17 +742,16 @@ export class HicFile {
   async getNormalizationVector(
     type: string,
     chr: string,
-    unit: string,
     binSize: number,
     opts?: BaseOpts,
   ) {
     await this.init(opts)
 
-    const chrIdx = this.chromosomeIndexMap[this.getFileChrName(chr)]
+    const chrIdx = this.chromosomeIndexMap.get(chr)
     if (chrIdx === undefined) {
       return undefined
     }
-    const key = getNormalizationVectorKey(type, chrIdx, unit, binSize)
+    const key = getNormalizationVectorKey(type, chrIdx, 'BP', binSize)
 
     // Sharing the in-flight read is what keeps concurrent region pairs sharing
     // one vector: a chromosome appears in every pair it takes part in, so with a
@@ -872,8 +820,8 @@ export class HicFile {
         },
         opts.signal,
       )
-    } else if (this.config.nvi) {
-      const nviArray = decodeURIComponent(this.config.nvi).split(',')
+    } else if (this.nvi) {
+      const nviArray = decodeURIComponent(this.nvi).split(',')
       return this.readNormVectorIndex(
         {
           start: parseInt(nviArray[0]!),
@@ -927,41 +875,28 @@ export class HicFile {
         this.normExpectedValueVectorsPosition,
         opts,
       )
-      let byteCount = INT
-
-      let data = await this.file.read(nviStart, INT, { signal })
+      const data = await this.file.read(nviStart, INT, { signal })
       // Possible if there are no norm vectors. A legal v8 file, though uncommon.
       if (data.byteLength !== 0) {
-        const binaryParser = new BinaryParser(new DataView(data))
-        const nEntries = binaryParser.getInt()
-        const sizeEstimate = nEntries * 30
-        data = await this.file.read(nviStart + byteCount, sizeEstimate, {
-          signal,
-        })
+        const nEntries = new BinaryParser(new DataView(data)).getInt()
         const found: NormVectorIndex = { entries: {}, types: ['NONE'] }
 
-        const processEntries = async (remaining: number, buf: ArrayBuffer) => {
-          const parser = new BinaryParser(new DataView(buf))
-          let n = remaining
-          while (n-- > 0) {
-            if (parser.available() < 100) {
-              n++ // Reset counter as entry is not processed
-              byteCount += parser.position
-              const est = Math.max(1000, n * 30)
-              const more = await this.file.read(nviStart + byteCount, est, {
-                signal,
-              })
-              await processEntries(n, more)
-              return
-            }
-            this.parseNormVectorEntry(parser, found)
+        let position = nviStart + INT
+        let requested = nEntries * 30
+        let buf = await this.file.read(position, requested, { signal })
+        let parser = new BinaryParser(new DataView(buf))
+        for (let n = nEntries; n > 0; n--) {
+          // A short read means the buffer already runs to EOF, and refilling
+          // it would only return the same bytes again.
+          if (parser.available() < 100 && buf.byteLength === requested) {
+            position += parser.position
+            requested = Math.max(1000, n * 30)
+            buf = await this.file.read(position, requested, { signal })
+            parser = new BinaryParser(new DataView(buf))
           }
-          byteCount += parser.position
+          this.parseNormVectorEntry(parser, found)
         }
-
-        await processEntries(nEntries, data)
         throwIfAborted(signal)
-        this.config.nvi = `${nviStart},${byteCount}`
         index = found
       }
     }
@@ -1044,15 +979,11 @@ export class HicFile {
     const filePosition = binaryParser.getLong() // 8
     const sizeInBytes =
       this.version < 9 ? binaryParser.getInt() : binaryParser.getLong() // 4:8
-    const key = `${type}_${chrIdx}_${unit}_${binSize}`
+    const key = getNormalizationVectorKey(type, chrIdx, unit, binSize)
 
     if (!index.types.includes(type)) {
       index.types.push(type)
     }
     index.entries[key] = { filePosition, size: sizeInBytes }
   }
-
-  getFileChrName(chrAlias: string) {
-    return this.chrAliasTable[chrAlias] ?? chrAlias
-  }
 }