w-geo 1.1.19 → 1.1.21

package/src/intrpPsdBySize.mjs

@@ -0,0 +1,125 @@
+import get from 'lodash-es/get.js'
+import size from 'lodash-es/size.js'
+import filter from 'lodash-es/filter.js'
+import map from 'lodash-es/map.js'
+import maxBy from 'lodash-es/maxBy.js'
+import minBy from 'lodash-es/minBy.js'
+import isnum from 'wsemi/src/isnum.mjs'
+import isearr from 'wsemi/src/isearr.mjs'
+import isestr from 'wsemi/src/isestr.mjs'
+import cdbl from 'wsemi/src/cdbl.mjs'
+import interp1 from 'wsemi/src/interp1.mjs'
+
+
+function intrpPsdBySize(pfss, psizes, opt = {}) {
+
+    //keySize
+    let keySize = get(opt, 'keySize', '')
+    if (!isestr(keySize)) {
+        keySize = 'size'
+    }
+
+    //keyFraction
+    let keyFraction = get(opt, 'keyFraction', '')
+    if (!isestr(keyFraction)) {
+        keyFraction = 'fraction'
+    }
+
+    //check
+    let pfs0 = get(pfss, 0)
+    let size0 = get(pfs0, keySize, '')
+    let fraction0 = get(pfs0, keyFraction, '')
+    if (!isnum(size0)) {
+        throw new Error(`pfssp[0][${keySize}] is not an effective number`)
+    }
+    if (!isnum(fraction0)) {
+        throw new Error(`fraction0[0][${keyFraction}] is not an effective number`)
+    }
+
+    //check
+    if (!isnum(psizes) && !isearr(psizes)) {
+        console.log('psizes', psizes)
+        throw new Error('psizes is not a number or an effective array')
+    }
+
+    //one
+    let one = false
+    if (isnum(psizes)) {
+        one = true
+        psizes = [cdbl(psizes)]
+    }
+
+    //取粒徑size與fraction為數字, 且size大於0(因要轉log內插), fraction要大於等於0, 且無施篩孔時值為-1亦須剔除
+    let rs = filter(pfss, (v) => {
+        let bs = cdbl(v[keySize]) > 0
+        let bf = cdbl(v[keyFraction]) >= 0
+        // console.log('bs', bs, v[keySize])
+        // console.log('bf', bf, v[keyFraction])
+        return bs && bf
+    })
+    // console.log('rs', rs)
+
+    //check
+    if (size(rs) === 0) {
+        console.log('pfss', pfss)
+        throw new Error(`invalid rs`)
+    }
+
+    //lrs
+    let lrs = map(rs, (v) => {
+        v[keySize] = Math.log(v[keySize])
+        return v
+    })
+
+    //sizeLogMax, sizeLogMin
+    let sizeLogMax = maxBy(lrs, keySize)
+    let sizeLogMin = minBy(lrs, keySize)
+
+    //ifs
+    let ifs = map(psizes, (psize) => {
+
+        //sizeLog
+        let sizeLog = Math.log(psize)
+        // console.log('psize', psize)
+        // console.log('sizeLog', sizeLog)
+
+        //check
+        if (sizeLog >= sizeLogMax[keySize]) {
+            return sizeLogMax[keyFraction]
+        }
+        if (sizeLog <= sizeLogMin[keySize]) {
+            return sizeLogMin[keyFraction]
+        }
+
+        //interp1
+        let optP = {
+            keyX: keySize,
+            keyY: keyFraction,
+        }
+        let pfraction = interp1(lrs, sizeLog, optP)
+        // console.log('pfraction', pfraction)
+
+        //check
+        if (get(pfraction, 'err')) {
+            console.log('lrs', lrs)
+            console.log('sizeLog', sizeLog)
+            console.log('optP', optP)
+            console.log('pfraction', pfraction)
+            return null
+        }
+
+        return pfraction
+    })
+    // console.log('ifs', ifs)
+
+    //r
+    let r = ifs
+    if (one) {
+        r = ifs[0]
+    }
+
+    return r
+}
+
+
+export default intrpPsdBySize

package/test/dtIntrpPsdBySize.test.mjs

@@ -0,0 +1,50 @@
+import assert from 'assert'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import dtIntrpPsdBySize from '../src/dtIntrpPsdBySize.mjs'
+
+
+describe(`dtIntrpPsdBySize`, function() {
+
+    let dt = {
+        GSD: `[101.6, 76.2, 50.8, 25.4, 19.0, 9.5, 4.75, 2.0, 0.85, 0.425, 0.25, 0.15, 0.106, 0.075, 0.027, 0.018, 0.011, 0.008, 0.006, 0.003, 0.001, 0.0, 0.0, 0.0]`,
+        GSP: `[100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, -1.0, 100.0, 99.0, 96.0, 86.0, 74.0, 61.0, 51.0, 32.0, 16.0, 0.0, 0.0, 0.0]`,
+    }
+
+    let psizes = [
+        630,
+        200,
+        63,
+        20,
+        6.3,
+        2,
+        0.63,
+        0.2,
+        0.063,
+        0.02,
+        0.0063,
+        0.002,
+    ]
+    // let fss = dtIntrpPsdBySize(dt, psizes)
+
+    let out1 = [
+        { size: 630, fraction: 100 },
+        { size: 200, fraction: 100 },
+        { size: 63, fraction: 99.99999999999999 },
+        { size: 20, fraction: 99.99999999999999 },
+        { size: 6.3, fraction: 100.00000000000001 },
+        { size: 2, fraction: 100 },
+        { size: 0.63, fraction: 100.00000000000001 },
+        { size: 0.2, fraction: 100 },
+        { size: 0.063, fraction: 98.4880247416152 },
+        { size: 0.02, fraction: 88.59851004564663 },
+        { size: 0.0063, fraction: 52.69597513510718 },
+        { size: 0.002, fraction: 26.094876057143324 }
+    ]
+    it(`should return ${out1} when dtIntrpPsdBySize(dt, ${psizes})`, function() {
+        let r = dtIntrpPsdBySize(dt, psizes)
+        let rr = out1
+        assert.strict.deepStrictEqual(r, rr)
+    })
+
+})

package/test/intrpPsdBySize.test.mjs

@@ -0,0 +1,29 @@
+import assert from 'assert'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import intrpPsdBySize from '../src/intrpPsdBySize.mjs'
+
+
+describe(`intrpPsdBySize`, function() {
+
+    let psd = [101.6, 76.2, 50.8, 25.4, 19.0, 9.5, 4.75, 2.0, 0.85, 0.425, 0.25, 0.15, 0.106, 0.075, 0.027, 0.018, 0.011, 0.008, 0.006, 0.003, 0.001, 0.0, 0.0, 0.0]
+    let psf = [100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, -1.0, 100.0, 99.0, 96.0, 86.0, 74.0, 61.0, 51.0, 32.0, 16.0, 0.0, 0.0, 0.0]
+    let pfss = _.map(psd, (_v, k) => {
+        let s = _.get(psd, k)
+        let f = _.get(psf, k)
+        return {
+            size: s,
+            fraction: f,
+        }
+    })
+    let psizes = 0.063
+    // let r = intrpPsdBySize(pfss, psizes)
+
+    let out1 = 98.4880247416152
+    it(`should return ${out1} when intrpPsdBySize(pfss, ${psizes})`, function() {
+        let r = intrpPsdBySize(pfss, psizes)
+        let rr = out1
+        assert.strict.deepStrictEqual(r, rr)
+    })
+
+})