{"version":3,"file":"assets/chunk.6d80981ff50f90b8cdde.js","mappings":"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AO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,IAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,KAExtB,KAAO,IAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,IAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,IAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,IAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,IAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAO,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,EAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAEnoB,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,EAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,EAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAA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","sources":["webpack://photodiode/webpack/runtime/chunk loaded","webpack://photodiode/webpack/runtime/create fake namespace object","webpack://photodiode/webpack/runtime/load script","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/-internals/metal","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/application","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/array/proxy","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/array","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/component/helper","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/component/template-only","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/component","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/controller","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/debug/container-debug-adapter","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/debug","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/destroyable","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/helper","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/modifier","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/object/compat","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/object/proxy","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/object","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/owner","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/routing/route","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/routing/router","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/runloop","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/service","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/template","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/template-factory","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/test","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/utils","webpack://photodiode/../../../../../@embroider/ext-cjs/@ember/version","webpack://photodiode/../../../../../@embroider/ext-cjs/@glimmer/tracking","webpack://photodiode/../../../../../@embroider/ext-cjs/@glimmer/validator","webpack://photodiode/../../../../../@embroider/ext-cjs/ember","webpack://photodiode/../../../../../@embroider/ext-cjs/jquery","webpack://photodiode/../../../../../@embroider/ext-cjs/require","webpack://photodiode/../../../../../@embroider/ext-cjs/rsvp","webpack://photodiode/../../../../node_modules/.pnpm/@ebiz+ember-aditools-analytics@7.0.0_@ember+string@4.0.0_ember-source@5.12.0_@glimmer+compone_a4qpztdwtx2w56ctsvl4s7wgyq/node_modules/@ebiz/ember-aditools-analytics/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-babel.b58762cc/node_modules/ember-cli-babel/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-typescript.7105dfa7/node_modules/ember-cli-typescript/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-compatibility-helpers.878b41c7/node_modules/ember-compatibility-helpers/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@glimmer/component.52988084/node_modules/@glimmer/component/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@glimmer/tracking.e3840884/node_modules/@glimmer/tracking/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-typescript.6ba55a35/node_modules/ember-cli-typescript/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-modifier.ad16094b/node_modules/ember-modifier/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/@ebiz+ember-aditools-device-table@6.3.2_@babel+core@7.25.8_@ebiz+aditools-styles@4.1.0_ember-_l3obvtgvihk2b4l52fx5rhbrvm/node_modules/@ebiz/ember-aditools-device-table/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ember/string.de568682/node_modules/@ember/string/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cache-primitive-polyfill.860da659/node_modules/ember-cache-primitive-polyfill/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cached-decorator-polyfill.3bd62979/node_modules/ember-cached-decorator-polyfill/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/@ebiz+ember-aditools-graph@6.1.0_@babel+core@7.25.8_ember-source@5.12.0_@glimmer+component@1._ip4c3hlxjhxyw3vxn3cih4gd4m/node_modules/@ebiz/ember-aditools-graph/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-htmlbars.d6b03df0/node_modules/ember-cli-htmlbars/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-tracked-storage-polyfill.6dd72949/node_modules/ember-tracked-storage-polyfill/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/tracked-built-ins@3.3.0/node_modules/tracked-built-ins/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-truth-helpers.33b6493b/node_modules/ember-truth-helpers/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/@ebiz+ember-aditools-page@14.2.3_@babel+core@7.25.8_@ebiz+aditools-styles@4.1.0_ember-intl@6._4vuj3s2r44drmfpylkp6yk3fmm/node_modules/@ebiz/ember-aditools-page/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/@ebiz+ember-aditools-site@4.0.2_@ember+string@4.0.0_ember-source@5.12.0_@glimmer+component@1._4ofmnf4qkkdmjzc633ijlaftqu/node_modules/@ebiz/ember-aditools-site/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ember/test-waiters.6ca1db3e/node_modules/@ember/test-waiters/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/@embroider+router@2.1.8_@embroider+core@3.4.18/node_modules/@embroider/router/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-babel.50729c7b/node_modules/ember-cli-babel/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-bundle-analyzer.1684c2db/node_modules/ember-cli-bundle-analyzer/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/ember-focus-trap@1.1.0_ember-source@5.12.0_@glimmer+component@1.1.2_@babel+core@7.25.8__rsvp@4.8.5_webpack@5.95.0_/node_modules/ember-focus-trap/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/ember-modifier@4.2.0_@babel+core@7.25.8_ember-source@5.12.0_@glimmer+component@1.1.2_@babel+c_v3xwwtnahardiulkmiwgknmqne/node_modules/ember-modifier/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/ember-page-title@8.2.3_ember-source@5.12.0_@glimmer+component@1.1.2_@babel+core@7.25.8__rsvp@4.8.5_webpack@5.95.0_/node_modules/ember-page-title/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@embroider/macros.15f0fc93/node_modules/@embroider/macros/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-test-loader.fbed2dfb/node_modules/ember-cli-test-loader/-embroider-implicit-modules.js","webpack://photodiode/../../../../node_modules/.pnpm/ember-qunit@8.1.1_@ember+test-helpers@3.3.1_@babel+core@7.25.8_ember-source@5.12.0_@glimmer+c_2rzihnhjkyyboi2klq55xw627u/node_modules/ember-qunit/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-inject-live-reload.b04a5ad8/node_modules/ember-cli-inject-live-reload/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-auto-import.234bdcf8/node_modules/ember-auto-import/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-htmlbars.1625ce98/node_modules/ember-cli-htmlbars/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ebiz/ember-aditools-deployment.4ed88428/node_modules/@ebiz/ember-aditools-deployment/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ember/jquery.f37eb833/node_modules/@ember/jquery/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ember/optional-features.fe9fb46e/node_modules/@ember/optional-features/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ember/test-helpers.71c2f94d/node_modules/@ember/test-helpers/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-code-coverage.0bd358c3/node_modules/ember-cli-code-coverage/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-async-await-helper.d75b706b/node_modules/ember-async-await-helper/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-changeset.41299fc8/node_modules/ember-changeset/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-app-version.cb3efc1e/node_modules/ember-cli-app-version/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-clean-css.f66d4c29/node_modules/ember-cli-clean-css/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-dependency-checker.10d1bc93/node_modules/ember-cli-dependency-checker/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-dependency-lint.15f5d0b1/node_modules/ember-cli-dependency-lint/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-deprecation-workflow.d3f1b758/node_modules/ember-cli-deprecation-workflow/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-sass.77a4addb/node_modules/ember-cli-sass/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/broccoli-asset-rev.53925774/node_modules/broccoli-asset-rev/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-terser.2f770ecf/node_modules/ember-cli-terser/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-sri.e5379a12/node_modules/ember-cli-sri/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-exam.c3f97d28/node_modules/ember-exam/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-intl.00f79baf/node_modules/ember-intl/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-cli-typescript.a6b95fef/node_modules/ember-cli-typescript/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-load-initializers.54ebefb1/node_modules/ember-load-initializers/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-maybe-import-regenerator.6f91c666/node_modules/ember-maybe-import-regenerator/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-resolver.152274b0/node_modules/ember-resolver/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-source.5b3c947f/node_modules/ember-source/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-modifier-manager-polyfill.b4e449a0/node_modules/ember-modifier-manager-polyfill/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/@ember/render-modifiers.7080e106/node_modules/@ember/render-modifiers/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/ember-tether.fdb990e6/node_modules/ember-tether/-embroider-implicit-modules.js","webpack://photodiode/../rewritten-packages/loader.js.42b4b44f/node_modules/loader.js/-embroider-implicit-modules.js","webpack://photodiode/./-embroider-implicit-modules.js","webpack://photodiode/../../../../photodiode-model/lib/src/circuit.js","webpack://photodiode/../../../../photodiode-model/lib/src/common.js","webpack://photodiode/../../../../photodiode-model/lib/src/complex.js","webpack://photodiode/../../../../photodiode-model/lib/src/conversion.js","webpack://photodiode/../../../../photodiode-model/lib/src/error-codes.js","webpack://photodiode/../../../../photodiode-model/lib/src/friendlyFrequencies.js","webpack://photodiode/../../../../photodiode-model/lib/src/graphs.js","webpack://photodiode/../../../../photodiode-model/lib/src/math.js","webpack://photodiode/../../../../photodiode-model/lib/src/messages.js","webpack://photodiode/../../../../photodiode-model/lib/src/model.js","webpack://photodiode/../../../../photodiode-model/lib/src/models/model-error.js","webpack://photodiode/../../../../photodiode-model/lib/src/next-steps.js","webpack://photodiode/../../../../photodiode-model/lib/src/photodiode-constants.js","webpack://photodiode/../../../../photodiode-model/lib/src/recommendations.js","webpack://photodiode/../../../../photodiode-model/lib/src/solver.js","webpack://photodiode/../../../../photodiode-model/lib/src/stages.js","webpack://photodiode/../../../../photodiode-model/lib/src/step-response.js","webpack://photodiode/../../../../photodiode-model/lib/src/utils.js","webpack://photodiode/webpack/bootstrap","webpack://photodiode/webpack/runtime/compat get default export","webpack://photodiode/webpack/runtime/define property getters","webpack://photodiode/webpack/runtime/ensure chunk","webpack://photodiode/webpack/runtime/get javascript chunk filename","webpack://photodiode/webpack/runtime/get mini-css chunk filename","webpack://photodiode/webpack/runtime/hasOwnProperty shorthand","webpack://photodiode/webpack/runtime/make namespace object","webpack://photodiode/webpack/runtime/publicPath","webpack://photodiode/webpack/runtime/jsonp chunk loading","webpack://photodiode/webpack/startup"],"sourcesContent":["var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar [chunkIds, fn, priority] = deferred[i];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","var inProgress = {};\nvar dataWebpackPrefix = \"photodiode:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","\nconst m = window.require(\"@ember/-internals/metal\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/application\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/array/proxy\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/array\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/component/helper\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/component/template-only\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/component\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/controller\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/debug/container-debug-adapter\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/debug\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/destroyable\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/helper\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/modifier\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/object/compat\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/object/proxy\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/object\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/owner\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/routing/route\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/routing/router\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/runloop\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/service\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/template\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/template-factory\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/test\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/utils\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@ember/version\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@glimmer/tracking\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"@glimmer/validator\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"ember\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"jquery\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.requirejs;\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nconst m = window.require(\"rsvp\");\nif (m.default && !m.__esModule) {\n  m.__esModule = true;\n}\nmodule.exports = m;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-cli-typescript/-embroider-implicit-modules.js\";\nimport \"ember-compatibility-helpers/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-compatibility-helpers/-embroider-implicit-modules.js\";\nimport \"ember-cli-typescript/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@glimmer/component/-embroider-implicit-modules.js\";\nimport \"@glimmer/tracking/-embroider-implicit-modules.js\";\nimport \"ember-modifier/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-compatibility-helpers/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"@glimmer/tracking/-embroider-implicit-modules.js\";\nimport \"ember-cache-primitive-polyfill/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@glimmer/component/-embroider-implicit-modules.js\";\nimport \"@glimmer/tracking/-embroider-implicit-modules.js\";\nimport \"ember-modifier/-embroider-implicit-modules.js\";\nimport \"@ember/string/-embroider-implicit-modules.js\";\nimport \"ember-cached-decorator-polyfill/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-cli-htmlbars/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-tracked-storage-polyfill/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"tracked-built-ins/-embroider-implicit-modules.js\";\nimport \"@glimmer/component/-embroider-implicit-modules.js\";\nimport \"@glimmer/tracking/-embroider-implicit-modules.js\";\nimport \"ember-modifier/-embroider-implicit-modules.js\";\nimport \"@ember/string/-embroider-implicit-modules.js\";\nimport \"ember-truth-helpers/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@ember/test-waiters/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\nimport \"ember-cli-test-loader/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\nimport \"ember-cli-htmlbars/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\nimport \"ember-cli-htmlbars/-embroider-implicit-modules.js\";\nimport \"@ember/test-waiters/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-cli-htmlbars/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\nimport \"@glimmer/tracking/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@ember/string/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\nimport \"ember-cli-typescript/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-cli-typescript/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-compatibility-helpers/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\nimport \"ember-modifier-manager-polyfill/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\nimport \"ember-cli-htmlbars/-embroider-implicit-modules.js\";\nimport \"@ember/render-modifiers/-embroider-implicit-modules.js\";\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\n","\nimport { importSync as i } from '@embroider/macros';\nlet d = window.define;\nimport \"@ebiz/ember-aditools-analytics/-embroider-implicit-modules.js\";\nimport \"@ebiz/ember-aditools-device-table/-embroider-implicit-modules.js\";\nimport \"@ebiz/ember-aditools-graph/-embroider-implicit-modules.js\";\nimport \"@ebiz/ember-aditools-page/-embroider-implicit-modules.js\";\nimport \"@ebiz/ember-aditools-site/-embroider-implicit-modules.js\";\nimport \"@embroider/router/-embroider-implicit-modules.js\";\nimport \"ember-cli-babel/-embroider-implicit-modules.js\";\nimport \"ember-cli-bundle-analyzer/-embroider-implicit-modules.js\";\nimport \"ember-focus-trap/-embroider-implicit-modules.js\";\nimport \"ember-modifier/-embroider-implicit-modules.js\";\nimport \"ember-page-title/-embroider-implicit-modules.js\";\nimport \"ember-qunit/-embroider-implicit-modules.js\";\nimport \"tracked-built-ins/-embroider-implicit-modules.js\";\nimport \"ember-cli-inject-live-reload/-embroider-implicit-modules.js\";\nimport \"@embroider/macros/-embroider-implicit-modules.js\";\nimport \"ember-auto-import/-embroider-implicit-modules.js\";\nimport \"ember-cli-htmlbars/-embroider-implicit-modules.js\";\nimport \"@ebiz/ember-aditools-deployment/-embroider-implicit-modules.js\";\nimport \"@glimmer/component/-embroider-implicit-modules.js\";\nimport \"@glimmer/tracking/-embroider-implicit-modules.js\";\nimport \"@ember/jquery/-embroider-implicit-modules.js\";\nimport \"@ember/optional-features/-embroider-implicit-modules.js\";\nimport \"@ember/test-waiters/-embroider-implicit-modules.js\";\nimport \"@ember/test-helpers/-embroider-implicit-modules.js\";\nimport \"ember-cli-code-coverage/-embroider-implicit-modules.js\";\nimport \"ember-async-await-helper/-embroider-implicit-modules.js\";\nimport \"ember-changeset/-embroider-implicit-modules.js\";\nimport \"ember-cli-app-version/-embroider-implicit-modules.js\";\nimport \"ember-cli-clean-css/-embroider-implicit-modules.js\";\nimport \"ember-cli-dependency-checker/-embroider-implicit-modules.js\";\nimport \"ember-cli-dependency-lint/-embroider-implicit-modules.js\";\nimport \"ember-cli-deprecation-workflow/-embroider-implicit-modules.js\";\nimport \"ember-cli-sass/-embroider-implicit-modules.js\";\nimport \"broccoli-asset-rev/-embroider-implicit-modules.js\";\nimport \"ember-cli-terser/-embroider-implicit-modules.js\";\nimport \"ember-cli-sri/-embroider-implicit-modules.js\";\nimport \"ember-exam/-embroider-implicit-modules.js\";\nimport \"ember-intl/-embroider-implicit-modules.js\";\nimport \"ember-load-initializers/-embroider-implicit-modules.js\";\nimport \"ember-maybe-import-regenerator/-embroider-implicit-modules.js\";\nimport \"ember-resolver/-embroider-implicit-modules.js\";\nimport \"ember-source/-embroider-implicit-modules.js\";\nimport \"ember-tether/-embroider-implicit-modules.js\";\nimport \"loader.js/-embroider-implicit-modules.js\";\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getStageOneInfo = getStageOneInfo;\nexports.opAmpStatus_TIA = opAmpStatus_TIA;\nexports.pickOpAmp_TIA = pickOpAmp_TIA;\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nvar _messages = _interopRequireDefault(require(\"./messages\"));\nvar _errorCodes = _interopRequireDefault(require(\"./error-codes\"));\nvar _stages = require(\"./stages\");\nvar _model = require(\"./model\");\nvar Solver = _interopRequireWildcard(require(\"./solver\"));\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\n//This function picks an op amp out of the recommended list for the TIA stage.   It can be used to figure out the first stage\n//in a one or two stage designs.\nfunction pickOpAmp_TIA(stage1Array, userInputs, opAmpDB, needSomeSpeed) {\n  var errorObject = {\n    errorCode: \"\",\n    errorParameter: {},\n    notRecommendedAvailable: false\n  };\n  let stageOne = getStageOneInfo(stage1Array, userInputs, opAmpDB);\n\n  //do we have some op amps that were recommended?\n  if (stageOne.minRecommendedScore < 1e60) return {\n    stage1: stageOne.recommended\n  };\n\n  //do we allow not recommended op amps?\n  else if (stageOne.minAllowedScore < 1e60 && !userInputs.requireRecommended) return {\n    stage1: stageOne.allowed\n  };\n\n  //everything is either not allowed or not recommended\n  else {\n    //If there is an allowed solution available, set the flag\n    if (stageOne.minAllowedScore < 1e60) {\n      errorObject.errorParameter.notRecommendedAvailable = true;\n      errorObject.errorParameter.marginalStatusMessage = stageOne.allowed.statusMessage;\n    }\n\n    //This error message will be overwritten if software is working correctly.\n    errorObject.errorMessage = 'Software error. Stages=' + userInputs.stages + '; needSomeSpeed=' + needSomeSpeed;\n    if (userInputs.stages === _photodiodeConstants.default.pdStages.oneStage && needSomeSpeed >= 0) {\n      errorObject.errorCode = _errorCodes.default.noOpAmpAvailableForSingleStageTooFast;\n    }\n    if (userInputs.stages === _photodiodeConstants.default.pdStages.oneStage && needSomeSpeed < 0) {\n      errorObject.errorCode = _errorCodes.default.noOpAmpAvailableForSingleStageTooSlow;\n    }\n    if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage && needSomeSpeed >= 0) {\n      errorObject.errorCode = _errorCodes.default.noOpAmpAvailableForFirstStageTooFast;\n    }\n    if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage && needSomeSpeed < 0) {\n      errorObject.errorCode = _errorCodes.default.noOpAmpAvailableForFirstStageTooSlow;\n    }\n    return (0, _model.setModelError)(errorObject);\n  }\n}\n\n//This function determines whether the TIA op amp is recommended, allowed, or not allowed\nfunction opAmpStatus_TIA(stage1, userInputs) {\n  var cf = stage1.cf;\n  var cfext = stage1.cfext;\n  var bw = stage1.bw;\n  var rf = stage1.rf;\n  var Q = stage1.q;\n  var opAmpObject = stage1.opAmp;\n  var notAllowedString = [];\n  var allowedString = [];\n  var status = _photodiodeConstants.default.opAmpStatus.recommended;\n  var statusMessage = [];\n  var maxOpAmpOutput;\n  var minSlewRate;\n  var needFaster = 0; //helps us know what kind of error message to give user if no recommended op amps are found - if positive number, user needs faster op amp than we have\n\n  var stage1peakVoltage = rf * userInputs.peakCurrent; //calculate peak voltage this way in case there are two stages \n\n  //Get max output swing\n  //Check input headroom to see if user can use in single supply operation\n  if (userInputs.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.positive && userInputs.stages === _photodiodeConstants.default.pdStages.oneStage) {\n    //output swings negative to user's peak voltage\n    if (opAmpObject.inHeadroomPlus > 0) maxOpAmpOutput = opAmpObject.maxSupplyVoltage / 2 - opAmpObject.outHeadroomMinus;else maxOpAmpOutput = opAmpObject.maxSupplyVoltage - opAmpObject.outHeadroomMinus;\n  } else {\n    //output swings positive to user's peak voltage\n    if (opAmpObject.inHeadroomMinus > 0) maxOpAmpOutput = opAmpObject.maxSupplyVoltage / 2 - opAmpObject.outHeadroomPlus;else maxOpAmpOutput = opAmpObject.maxSupplyVoltage - opAmpObject.outHeadroomPlus;\n  }\n\n  /************************* Allowed Checks ********************************/\n  //Do the allowed checks first, so that if the op amp is found to be not allowed below, the allowed status will be overwritten.\n\n  //check if op amp is too fast, but if user's application is really slow, than we relax requirement with the bwModifier variable\n  var bwModifier = Math.max(15000 / userInputs.speed, 1);\n  if (bw > 10 * userInputs.speed * bwModifier) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_too_fast\n    }); // \"too fast; \"\n    needFaster = -1;\n  }\n\n  //check if cf is so small that board parasitics will have big impact           \n  if (userInputs.speed > 1e6) {\n    if (cf < 50e-15) {\n      status = _photodiodeConstants.default.opAmpStatus.allowed;\n      allowedString.push({\n        key: _messages.default.amp_status_cf_less_50fF\n      }); //\" Cf < 50fF; \"\n    }\n  } else {\n    if (cf < 100e-15) {\n      status = _photodiodeConstants.default.opAmpStatus.allowed;\n      allowedString.push({\n        key: _messages.default.amp_status_cf_less_100fF\n      }); //\" Cf < 0.1pF; \"\n    }\n  }\n  var biasCurrent = opAmpObject.iBias;\n  // var userGain = userInputs.peakCurrent\n\n  //Bias Current Limit:\n  //1 kHz: 100pA, 10 kHz: 100pA, 100 kHz: 100pA, 1MHz: 50nA, 10MHz: 50uA, 100MHz, 50mA\n  var biasLimit = Math.max(100e-12, 50e-27 * userInputs.speed * userInputs.speed * userInputs.speed);\n  //But anything that creates less than 800 uV output offset is fine\n  biasLimit = Math.max(biasLimit, 800e-6 / rf);\n  //And make sure our biasLimit is no more than the user's input current\n  biasLimit = Math.min(biasLimit, userInputs.peakCurrent);\n  if (biasCurrent > biasLimit) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_bias_current_is,\n      data: biasCurrent\n    }); //\"High output offset (bias current is ___A);\"\n  }\n\n  //Precision folks don't normally like zero-drift parts since they have a lot of noise\n  if (opAmpObject.architecture && opAmpObject.architecture.indexOf(\"Zero Drift\") > -1) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_zero_drift\n    }); //\"zero drift;\"\n  }\n\n  //We allow bandwidth slightly less than requested\n  if (bw < 0.8 * userInputs.speed && userInputs.speed <= 1e6 || bw < 0.6 * userInputs.speed && userInputs.speed > 1e6) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_not_fast_enough\n    }); // \"not fast enough; \";\n    needFaster = 1;\n  }\n\n  //check for really big offset op amps\n  var stage1maxVoltage = rf * userInputs.peakCurrent;\n  if (opAmpObject.vos > 0.5 * stage1maxVoltage) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_high_vos,\n      data: opAmpObject.vos\n    }); //\"High output offset (input Vos is ___V);\";\n  }\n\n  //make sure to allow for peaking in slew rate.   \n  minSlewRate = Math.PI * 2 * userInputs.speed * stage1peakVoltage / 2 * Q;\n  if (opAmpObject.slewRate * 1e6 < minSlewRate && status === _photodiodeConstants.default.opAmpStatus.recommended) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_slew_rate_marginal\n    }); //\"slew rate marginal; \"\n  }\n\n  //Check if 2nd stage will require a really big gain\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    var totalGain = userInputs.peakVoltage / userInputs.peakCurrent;\n    var secondStageGain = totalGain / rf;\n    if (secondStageGain > 50) {\n      status = _photodiodeConstants.default.opAmpStatus.allowed;\n      allowedString.push({\n        key: _messages.default.amp_status_big_2nd_stage_gain,\n        data: secondStageGain\n      }); //\"Requires 2nd stage gain of __;\"\n    }\n  }\n\n  //AD8634 is a super expensive, high temp amp.   We want in the tool in case the high temp guys want it, but don't want\n  //to recommend.   (In reality, given its 200 nA bias current, highly unlikely to be used as photodiode amp, but just in case\n  if (opAmpObject.partNumber === \"AD8634\") {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_specialty_amp\n    }); //\"specialty amplifier; \"\n  }\n\n  //Harry Holt made a strong case for not allowing quad op amps for the following reasons:\n  //- layout is more difficult, so the parasitic capacitance is likely higher\n  //- self heating will increase bias current for JFET's and Mosfets (used example of AD8513: 3mA * 30V * 4\n  //- potential crosstalk\n  if (opAmpObject.numberChannels === 4) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_quad\n    });\n  }\n\n  // If status is Not Recommended for New Designs or Last Time Buy, you need to make this allowed\n  // instead of recommended\n  if (opAmpObject.deviceStatus === 4) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_not_recommended_for_new_designs\n    });\n  } else if (opAmpObject.deviceStatus === 5) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_last_time_buy\n    });\n  }\n\n  /*********************** Not Allowed Checks *************************/\n  //Prevent any cf's below zero\n  if (cf <= 0) {\n    //some op amps just too slow\n    if (opAmpObject.gbw !== null && userInputs.speed > opAmpObject.gbw) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_not_fast_enough\n      }); // \"not fast enough; \";\n    }\n    //but others borderline.  Fail in higher Q situations\n    else {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_not_enough_peaking\n      });\n    }\n  } else {\n    //for cases where cf is still above zero but becomes negative due to the internal feedback capacitance\n    if (cfext < 0) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_internal_cf_too_high\n      });\n    }\n    //check if anything else is wrong - likely indicates somebody left an input capacitance in \"F\" in PDB rather than \"pF\"\n    if (isNaN(bw) || isNaN(cf) || isNaN(rf)) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_dB_error\n      });\n    }\n    //Make sure bandwidth is high enough.  Put this in the cf<=0 else statement so that we don't generate two \"not fast enough\" errors\n    else if (bw < 0.5 * userInputs.speed && userInputs.speed <= 1e6 || bw < 0.2 * userInputs.speed && userInputs.speed > 1e6) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_not_fast_enough\n      }); // \"not fast enough; \";\n    }\n  }\n\n  //check if bandwidth will be way over what user wanted\n  if (bw > 100 * userInputs.speed * bwModifier) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_too_fast\n    }); // \"too fast; \"\n  }\n\n  //check voltage range\n  if (stage1peakVoltage > maxOpAmpOutput) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_voltage_not_enough\n    }); //\"voltage range not enough for peak output voltage; \";\n  }\n\n  //if under 5 MHz, disallow parts with biasCurrent triple user's input current\n  if (userInputs.speed < 5e6 && biasCurrent > 3 * userInputs.peakCurrent) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_bias_current_is,\n      data: biasCurrent\n    }); //\"High output offset (bias current is ___A);\"\n  }\n\n  //if 2nd stage needs huge gain, disallow\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    totalGain = userInputs.peakVoltage / userInputs.peakCurrent;\n    secondStageGain = totalGain / rf;\n    if (secondStageGain > 150) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_big_2nd_stage_gain,\n        data: secondStageGain\n      }); //\"Requires 2nd stage gain of __;\"\n    }\n  }\n\n  //disallow parts that require gains more than 1\n  if (opAmpObject.minStableGain !== \"1\" && !(opAmpObject.partNumber !== \"AD8067\" || opAmpObject.partNumber !== \"AD8099\")) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_min_stable_gain,\n      data: opAmpObject.minStableGain\n    }); //\"Min stable gain = __;\"\n  }\n\n  //Check if rf is too small\n  if (opAmpObject.feedbackMethod === \"Current\") {\n    if (rf < 0.8 * opAmpObject.cfb.minRf) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_cfb_rf_too_small\n      });\n    }\n  }\n  //if voltage feedback, output resistance can cause excessive peaking that throws our Q and fp calculations (see JIRA PD-653)\n  else {\n    if (rf * 1.5 < opAmpObject.rOut) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_cfb_rf_too_small\n      });\n    }\n  }\n\n  //only check for slew rate if we haven't failed already (if op amp not fast enough, telling user slew rate is also no good is redundant)\n  minSlewRate = minSlewRate * 0.8; //Allow slightly marginal slew rates\n  if (minSlewRate > opAmpObject.slewRate * 1e6 && status !== _photodiodeConstants.default.opAmpStatus.notAllowed) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_slew_rate_low\n    }); //\"slew rate too low; \";\n  }\n\n  // If status is Obsolete, the op amp becomes not allowed\n  if (opAmpObject.deviceStatus === 6) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_obsolete\n    });\n  }\n  if (status === _photodiodeConstants.default.opAmpStatus.notAllowed) statusMessage = notAllowedString; //remove last semicolon and space\n  else if (status === _photodiodeConstants.default.opAmpStatus.allowed) {\n    statusMessage = allowedString; //allowedString.substring(0, allowedString.length - 2);   //remove last semicolon and space\n  }\n  return {\n    status: status,\n    statusMessage: statusMessage,\n    minSlewRate: minSlewRate,\n    needFaster: needFaster\n  };\n}\nfunction getStageOneInfo(stage1Array, userInputs, opAmpDB) {\n  var debugArray = [],\n    minRecommendedScore = 1e60,\n    minAllowedScore = 1e60,\n    recommended = null,\n    allowed = null;\n  for (var i = 0; i < stage1Array.length; i++) {\n    if (stage1Array[i].status !== _photodiodeConstants.default.opAmpStatus.notAllowed) {\n      var noiseScore = noiseScore_TIA(stage1Array[i], userInputs, opAmpDB[i]);\n      var dcScore = dcScore_TIA(stage1Array[i], userInputs, opAmpDB[i]);\n      var bwScore = bwScore_TIA(stage1Array[i], userInputs, opAmpDB[i]);\n      var stage2Score = stage2Score_TIA(stage1Array[i], userInputs, opAmpDB[i]);\n      var numberScore = singleDualQuadScore(stage1Array[i], userInputs, opAmpDB[i]);\n      var totalScore = noiseScore + dcScore + bwScore + stage2Score + numberScore;\n      debugArray.push({\n        opAmpName: stage1Array[i].opAmpName,\n        noiseScore: noiseScore,\n        dcScore: dcScore,\n        bwScore: bwScore,\n        totalScore: totalScore\n      });\n      if (stage1Array[i].status === _photodiodeConstants.default.opAmpStatus.recommended && totalScore < minRecommendedScore) {\n        minRecommendedScore = totalScore;\n        recommended = stage1Array[i];\n      } else if (stage1Array[i].status === _photodiodeConstants.default.opAmpStatus.allowed && totalScore < minAllowedScore) {\n        minAllowedScore = totalScore;\n        allowed = stage1Array[i];\n      }\n    }\n  }\n  return {\n    recommended: recommended,\n    allowed: allowed,\n    minRecommendedScore: minRecommendedScore,\n    minAllowedScore: minAllowedScore\n  };\n}\nfunction noiseScore_TIA(stage1Info, userInputs, opAmpObject) {\n  \"use strict\";\n\n  var capGain = capGainCalculate(stage1Info, userInputs, opAmpObject);\n  var vNoise = opAmpObject.vNoise * capGain;\n  var iNoise = opAmpObject.iNoise * stage1Info.rf;\n  var sumVNoiseandINoise = Math.sqrt(vNoise * vNoise + iNoise * iNoise);\n\n  //2nd stage may have some more gain, so we account for that here\n  var ifOnlyOneStageResistor = userInputs.peakVoltage / userInputs.peakCurrent;\n  var resNoise = Math.sqrt(ifOnlyOneStageResistor / 1000) * 4e-9;\n  var secondStageGain = ifOnlyOneStageResistor / stage1Info.rf;\n  var score = sumVNoiseandINoise * secondStageGain / resNoise;\n\n  //scaling factor\n  score = score * 0.33;\n  return score;\n}\nfunction bwScore_TIA(stage1Info, userInputs) {\n  var score = userInputs.speed / stage1Info.bw;\n  if (score < 1) {\n    //Don't penalize higher than user's bandwith (noise and offset should do this for us)\n    score = 1;\n  }\n  return score;\n}\nfunction dcScore_TIA(stage1, userInputs, opAmpObject) {\n  let stage2;\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    //This is a kluge to try to get some idea of how much dc error the 2nd stage will contribute.  We reuse the same amplifier\n    //from stage 1, since we don't know yet what the stage 2 amplifier will be.   It isn't perfect, but does a reasonable job\n    //penalizing designs with a high gain in the second stage\n    stage2 = (0, _stages.stage2Info)(userInputs, opAmpObject, stage1.opAmp);\n  } else {\n    stage2 = null;\n  }\n  var stagesObject = {\n    stage1: stage1,\n    stage2: stage2\n  };\n  var dcError = Solver.calculateOutputOffset(stagesObject);\n\n  //dc error matters less at higher peak voltages and higher frequencies, so scale appropriately\n  var score = 150000 * dcError / Math.sqrt(userInputs.peakVoltage * userInputs.speed);\n  return score;\n}\nfunction capGainCalculate(stage1Info, userInputs, opAmpObject) {\n  var cDiff = opAmpObject.cDiff;\n  var cCm = opAmpObject.cCm;\n  var cIn = cDiff + cCm + userInputs.capacitance;\n  var capGain = 1 + cIn / stage1Info.cf;\n  return capGain;\n}\n\n//If it's a two stage design, and the op amp can't be reused in the 2nd stage, it gets a worse score\n//Lower scores are better\nfunction stage2Score_TIA(stage1Info, userInputs, opAmpObject) {\n  var score = 0;\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    var maxOpAmpOutput = opAmpObject.maxSupplyVoltage / 2 - opAmpObject.outHeadroomPlus;\n    var minSlewRate = Math.PI * 2 * userInputs.speed * userInputs.peakVoltage / 2;\n    if (userInputs.peakVoltage > maxOpAmpOutput) {\n      score = 3;\n    }\n    if (minSlewRate > opAmpObject.slewRate * 1e6) {\n      score = 3;\n    }\n  }\n  return score;\n}\n\n//This function gives a very slight edge to a single op amp in a single stage design and a dual op amp in a dual stage design\nfunction singleDualQuadScore(stage1info, userInputs, opAmpObject) {\n  var numChannels = parseInt(opAmpObject.numberChannels),\n    score;\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.pdStages) {\n    score = 0.01 * numChannels;\n  } else {\n    if (numChannels === 2) score = 0.01;else if (numChannels === 1) score = 0.02;else score = 0.04;\n  }\n  return score;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.calculateBandwidthSpeed = calculateBandwidthSpeed;\nexports.calculateMinPulseWidthSpeed = calculateMinPulseWidthSpeed;\nexports.calculateNelderMeadError = calculateNelderMeadError;\nexports.capacitorBasedOnTolerance = capacitorBasedOnTolerance;\nexports.checkErrorPercent = checkErrorPercent;\nexports.checkToleranceRange = checkToleranceRange;\nexports.determineStartingR3R4Value = determineStartingR3R4Value;\nexports.frequencyPoint = frequencyPoint;\nexports.friendlyFrequency = friendlyFrequency;\nexports.resistorBasedOnTolerance = resistorBasedOnTolerance;\nexports.sortErrorArray = sortErrorArray;\nexports.unjoinArray = unjoinArray;\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nvar FriendlyFrequency = _interopRequireWildcard(require(\"./friendlyFrequencies\"));\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction checkToleranceRange(desiredTolerance, desiredValue, toleranceTable) {\n  //let finalResistorTolerance = '';\n  let toleranceCoerced = false;\n  let rowIndex, row;\n\n  //first find the row of desiredTolerance row in table [index]\n  for (let i = 0; i < toleranceTable.length; i++) {\n    if (toleranceTable[i].tolerance == desiredTolerance) {\n      rowIndex = i;\n      break;\n    }\n  }\n  if (desiredValue >= toleranceTable[rowIndex].allowedMin && desiredValue <= toleranceTable[rowIndex].allowedMax) {\n    //finalResistorTolerance = desiredTolerance;\n    row = toleranceTable[rowIndex];\n  } else {\n    for (let i = rowIndex; i < toleranceTable.length; i++) {\n      if (desiredValue >= toleranceTable[i].allowedMin && desiredValue <= toleranceTable[i].allowedMax) {\n        row = toleranceTable[i];\n        toleranceCoerced = true;\n        //finalResistorTolerance = row.tolerance;\n        break;\n      }\n    }\n  }\n  return [toleranceCoerced, row];\n}\nfunction friendlyFrequency(start, end, decade) {\n  if (decade <= 0.5) {\n    return FriendlyFrequency.generateExtremelyFineGranularityFreqArray(start, end);\n  } else if (decade <= 2) {\n    return FriendlyFrequency.generateVeryFineGranularityFreqArray(start, end);\n  } else if (decade <= 3) {\n    return FriendlyFrequency.generateFineGranularityFreqArray(start, end);\n  } else {\n    return FriendlyFrequency.generateModerateGranularityFreqArray(start, end);\n  }\n}\nfunction frequencyPoint(startFreq, stopFreq, pointsPerDecade) {\n  var x = 10;\n  var y = 1 / pointsPerDecade;\n  var multiplier = Math.pow(x, y);\n  var i = 0;\n  var frequency_point = new Array();\n  frequency_point[0] = startFreq;\n  do {\n    frequency_point[i + 1] = frequency_point[i] * multiplier;\n    i++;\n  } while (frequency_point[i] < stopFreq);\n  return frequency_point;\n}\nfunction determineStartingR3R4Value(optimization, stageFp) {\n  var F_MAX = 10000000;\n  var r3plusr4, rMin, rMax, rFreq;\n  switch (optimization) {\n    case _photodiodeConstants.default.optimizationType.noise:\n      rMin = 100;\n      rMax = 10000;\n      break;\n    case _photodiodeConstants.default.optimizationType.voltageRange:\n      rMin = Math.sqrt(100000);\n      rMax = 100000;\n      break;\n    case _photodiodeConstants.default.optimizationType.power:\n      rMin = 1000;\n      rMax = 1000000;\n      break;\n    case _photodiodeConstants.default.optimizationType.allowedSpecific:\n      rMin = Math.sqrt(100000);\n      rMax = 1000000;\n      break;\n    case _photodiodeConstants.default.optimizationType.recommendedSpecific:\n      rMin = Math.sqrt(100000);\n      rMax = 1000000;\n      break;\n  }\n  var frequency = Math.min(F_MAX, stageFp);\n  rFreq = Math.sqrt(F_MAX / frequency) * rMin;\n  r3plusr4 = Math.min(rFreq, rMax);\n  return r3plusr4;\n}\nfunction unjoinArray(joinedArray) {\n  var length = joinedArray.length;\n  var array1 = [];\n  var array2 = [];\n  for (var n = 0; n < length; n++) {\n    array1.push(joinedArray[n][0]);\n    array2.push(joinedArray[n][1]);\n  }\n  return [array1, array2];\n}\nfunction calculateBandwidthSpeed(speedValue) {\n  return 2 / speedValue;\n}\nfunction calculateMinPulseWidthSpeed(speedValue) {\n  return 2 / speedValue;\n}\nfunction resistorBasedOnTolerance(desiredValue, desiredTolerance) {\n  var toleranceCoerced = false;\n  var finalTolerance;\n  var nominalValue;\n  var resistorArray = [];\n  //for error\n  var errorOccured = false;\n  var errorMessage = '';\n\n  //preferred Series E96,E24\n  var arrayE96 = [1, 1.02, 1.05, 1.07, 1.1, 1.13, 1.15, 1.18, 1.21, 1.24, 1.27, 1.3, 1.33, 1.37, 1.4, 1.43, 1.47, 1.5, 1.54, 1.58, 1.62, 1.65, 1.69, 1.74, 1.78, 1.82, 1.87, 1.91, 1.96, 2, 2.05, 2.1, 2.15, 2.21, 2.26, 2.32, 2.37, 2.43, 2.49, 2.55, 2.61, 2.67, 2.74, 2.8, 2.87, 2.94, 2.01, 3.09, 3.16, 3.24, 3.32, 3.4, 3.48, 3.57, 3.65, 3.74, 3.83, 3.92, 4.02, 4.12, 4.22, 4.32, 4.42, 4.53, 4.64, 4.75, 4.87, 4.99, 5.11, 5.23, 5.36, 5.49, 5.62, 5.76, 5.9, 6.04, 6.19, 6.34, 6.49, 6.65, 6.81, 6.98, 7.15, 7.32, 7.5, 7.68, 7.87, 8.06, 8.25, 8.45, 8.66, 8.87, 9.09, 9.31, 9.53, 9.76, 10];\n  var arrayE24 = [1, 1.1, 1.2, 1.3, 1.5, 1.6, 1.8, 2, 2.2, 2.4, 2.7, 3, 3.3, 3.6, 3.9, 4.3, 4.7, 5.1, 5.6, 6.2, 6.8, 7.5, 8.2, 9.1, 10];\n\n  //FOR NOW: we declare an object to represent a table (to be moved later) nominalFactor is the number in which we divide desiredValue in order to get it in range of the series check in setNominalValue()\n  var resistorTable = [];\n  resistorTable.push({\n    tolerance: _photodiodeConstants.default.resistorTolerance.ideal,\n    allowedMin: _photodiodeConstants.default.Limits.RSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT,\n    multiplicationFactors: [1],\n    preferredSeries: \"NA\"\n  });\n  resistorTable.push({\n    tolerance: _photodiodeConstants.default.resistorTolerance.oneTenth,\n    allowedMin: 10,\n    allowedMax: 1000000,\n    multiplicationFactors: [0.999, 1.0, 1.001],\n    preferredSeries: arrayE96\n  });\n  resistorTable.push({\n    tolerance: _photodiodeConstants.default.resistorTolerance.fiveTenths,\n    allowedMin: 10,\n    allowedMax: 1000000,\n    multiplicationFactors: [0.995, 1.0, 1.005],\n    preferredSeries: arrayE96\n  });\n  resistorTable.push({\n    tolerance: _photodiodeConstants.default.resistorTolerance.one,\n    allowedMin: _photodiodeConstants.default.Limits.RSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT,\n    multiplicationFactors: [0.99, 1.0, 1.01],\n    preferredSeries: arrayE96\n  });\n  resistorTable.push({\n    tolerance: _photodiodeConstants.default.resistorTolerance.five,\n    allowedMin: _photodiodeConstants.default.Limits.RSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT,\n    multiplicationFactors: [0.95, 1.0, 1.05],\n    preferredSeries: arrayE24\n  });\n  if (desiredValue < _photodiodeConstants.default.Limits.RSMALL_COMP_LIMIT || desiredValue > _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT) {\n    //throw up error: the previous functions should never generate a resistor outside of this range\n    errorOccured = true;\n    errorMessage = 'Resistor should never be outside ' + _photodiodeConstants.default.Limits.RSMALL_COMP_LIMIT + ' and ' + _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT + ' Limit';\n  } else {\n    var checkResistorRange_result = this.checkToleranceRange(desiredTolerance, desiredValue, resistorTable);\n    toleranceCoerced = checkResistorRange_result[0];\n    var row = checkResistorRange_result[1];\n    finalTolerance = row.tolerance;\n    //get nominal value\n    nominalValue = setNominalValue(desiredValue, row, false);\n\n    //create resistor array\n    for (var i = 0; i < row.multiplicationFactors.length; i++) {\n      resistorArray.push(nominalValue * row.multiplicationFactors[i]);\n    }\n  }\n  return [nominalValue, resistorArray, finalTolerance, toleranceCoerced, errorOccured, errorMessage];\n}\nfunction capacitorBasedOnTolerance(desiredValue, desiredTolerance) {\n  var toleranceCoerced = false;\n  var finalTolerance;\n  var nominalValue;\n  var capacitorArray = [];\n  //for error\n  var errorOccured = false;\n  var errorMessage = '';\n\n  //preferred Series E24,E12,E6\n  var arrayE24 = [1, 1.1, 1.2, 1.3, 1.5, 1.6, 1.8, 2, 2.2, 2.4, 2.7, 3, 3.3, 3.6, 3.9, 4.3, 4.7, 5.1, 5.6, 6.2, 6.8, 7.5, 8.2, 9.1, 10];\n  var arrayE12 = [1, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 10];\n  var arrayE6 = [1, 1.5, 2.2, 3.3, 5.7, 6.8, 10];\n\n  //FOR NOW: we declare an object to represent a table (to be moved later) nominalFactor is the number in which we multiply desiredValue in order to get it in range of the series check in setNominalValue()\n  var capacitorTable = [];\n  capacitorTable.push({\n    tolerance: _photodiodeConstants.default.capacitorTolerance.ideal,\n    allowedMin: _photodiodeConstants.default.Limits.CSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.CBIG_COMP_LIMIT,\n    multiplicationFactors: [1],\n    preferredSeries: \"NA\"\n  });\n  capacitorTable.push({\n    tolerance: _photodiodeConstants.default.capacitorTolerance.one,\n    allowedMin: _photodiodeConstants.default.Limits.CSMALL_COMP_LIMIT,\n    allowedMax: 0.0000000048,\n    multiplicationFactors: [0.99, 1.0, 1.01],\n    preferredSeries: arrayE24,\n    nominalFactor: 10000000\n  });\n  capacitorTable.push({\n    tolerance: _photodiodeConstants.default.capacitorTolerance.five,\n    allowedMin: _photodiodeConstants.default.Limits.CSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.CBIG_COMP_LIMIT,\n    multiplicationFactors: [0.95, 0.97, 1.0, 1.03, 1.05],\n    preferredSeries: arrayE24,\n    nominalFactor: 10000000\n  });\n  capacitorTable.push({\n    tolerance: _photodiodeConstants.default.capacitorTolerance.ten,\n    allowedMin: _photodiodeConstants.default.Limits.CSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.CBIG_COMP_LIMIT,\n    multiplicationFactors: [0.9, 0.95, 1.0, 1.05, 1.1],\n    preferredSeries: arrayE12,\n    nominalFactor: 10000000\n  });\n  capacitorTable.push({\n    tolerance: _photodiodeConstants.default.capacitorTolerance.twenty,\n    allowedMin: _photodiodeConstants.default.Limits.CSMALL_COMP_LIMIT,\n    allowedMax: _photodiodeConstants.default.Limits.CBIG_COMP_LIMIT,\n    multiplicationFactors: [0.8, 0.9, 1.0, 1.1, 1.2],\n    preferredSeries: arrayE6,\n    nominalFactor: 10000000\n  });\n  if (desiredValue < _photodiodeConstants.default.Limits.CSMALL_COMP_LIMIT || desiredValue > _photodiodeConstants.default.Limits.CBIG_COMP_LIMIT) {\n    //don't attempt to calculate a value\n    nominalValue = desiredValue;\n    finalTolerance = desiredTolerance;\n    return [nominalValue, capacitorArray, finalTolerance, toleranceCoerced, errorOccured, errorMessage];\n  } else {\n    var checkCapacitorRange_result = this.checkToleranceRange(desiredTolerance, desiredValue, capacitorTable);\n    toleranceCoerced = checkCapacitorRange_result[0];\n    var row = checkCapacitorRange_result[1];\n    finalTolerance = row.tolerance;\n\n    //get nominal value\n    nominalValue = setNominalValue(desiredValue, row, true);\n\n    //create capacitor array\n    for (var i = 0; i < row.multiplicationFactors.length; i++) {\n      capacitorArray.push(nominalValue * row.multiplicationFactors[i]);\n    }\n  }\n  return [nominalValue, capacitorArray, finalTolerance, toleranceCoerced, errorOccured, errorMessage];\n}\nfunction calculateNelderMeadError(freqArray, fp, Q, magnitudeValues) {\n  var stageMagnitude = [];\n  var error;\n  var idealMagnitude = [];\n  var difference;\n  var freqLength = freqArray.length;\n  if (fp < 0 || Q < 0) {\n    for (let j = 0; j < freqLength; j++) {\n      stageMagnitude[j] = 0;\n    }\n    if (Q < 0) {\n      Q = 0;\n    }\n    if (fp < 0) {\n      fp = 0;\n    }\n    idealMagnitude = stageMagnitude;\n  } else {\n    //calculate ideal values based on Q & fp\n    var num = magnitudeValues[0] * fp * fp;\n    for (let j = 0; j < freqLength; j++) {\n      var f = freqArray[j];\n      var denomReal = fp * fp - f * f;\n      var denomImag = f * fp / Q;\n      var denomMag = Math.sqrt(denomReal * denomReal + denomImag * denomImag);\n      idealMagnitude.push(num / denomMag);\n    }\n  }\n\n  //now calculate error\n  error = 0;\n  var stageMaglen = idealMagnitude.length;\n  for (var k = 0; k < stageMaglen; k++) {\n    difference = magnitudeValues[k] - idealMagnitude[k];\n    error = error + difference * difference;\n  }\n  return error;\n}\nfunction checkErrorPercent(fpQErrorObj) {\n  var boolErrorArr = false;\n  var errArrlen = fpQErrorObj.length;\n  var firstError = fpQErrorObj[0].error;\n  firstError = fpQErrorObj[0].error * 1.01;\n  if (firstError > fpQErrorObj[errArrlen - 1].error) {\n    boolErrorArr = true;\n  }\n  return boolErrorArr;\n}\nfunction sortErrorArray(fpQErrorObj) {\n  /*sorting the fpQErrorObj according to errorArray*/\n\n  fpQErrorObj.sort(function (obj1, obj2) {\n    return obj1.error < obj2.error ? -1 : obj1.error > obj2.error ? 1 : 0;\n  }); // sorting the fpQErrorObj array in ascending order according to the value of errorArray\n  return fpQErrorObj;\n} //end of function\n\n// PRIVATE FUNCTIONS\nfunction setNominalValue(desiredValue, row) {\n  var nominalValue, exponent, charAt, row1, row2;\n  var desiredVal;\n  var nominalVal;\n\n  //convert desiredValue to scientificNotation and a string\n  nominalVal = desiredValue.toExponential().toString();\n\n  //remove exponent\n  exponent = nominalVal.length;\n  charAt = nominalVal.indexOf('e');\n  exponent = nominalVal.slice(charAt, exponent);\n  nominalVal = parseFloat(nominalVal.slice(0, charAt));\n  desiredVal = nominalVal;\n\n  // NOTE : dealing with the case where preferredSeries is NA\n  if (row.preferredSeries == \"NA\") {\n    nominalValue = desiredVal;\n  } //\n  else {\n    for (var i = 0; i < row.preferredSeries.length; i++) {\n      if (row.preferredSeries[i] <= desiredVal && desiredVal < row.preferredSeries[i + 1]) {\n        row1 = desiredVal / row.preferredSeries[i];\n        row2 = row.preferredSeries[i + 1] / desiredVal;\n\n        //get closest\n        if (row1 < row2) {\n          nominalValue = row.preferredSeries[i];\n        } else if (row2 < row1) {\n          nominalValue = row.preferredSeries[i + 1];\n        }\n        break;\n      }\n    }\n  }\n\n  //read exponent\n  nominalValue = nominalValue.toString() + exponent;\n  nominalValue = parseFloat(nominalValue);\n  return nominalValue;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nclass Complex {\n  constructor(real, imaginary) {\n    this.real = real;\n    this.imaginary = imaginary;\n  }\n  static createComplex(real, imaginary) {\n    return new Complex(real, imaginary);\n  }\n  complexfreq(fp) {\n    var complexfreq = new Array();\n    for (var r = 0; r < fp.length; r++) {\n      complexfreq[r] = new Complex(fp[r], 0);\n    }\n    return complexfreq;\n  }\n  complexNumberRaisedToPower(c, n) {\n    var modC, theta, retComplex, realPart, imaginaryPart;\n\n    // |x+iy| = Math.sqrt(x^2 + y^2) = |z|\n    modC = Math.sqrt(c.real * c.real + c.imaginary * c.imaginary);\n\n    // |x+iy|^n  = |z|^n\n    var modCpowern = Math.pow(modC, n);\n\n    //theta=tan^(-1)(y/x)>\n    theta = Math.atan2(c.imaginary, c.real);\n\n    //|z|^n * cos(n* theta)\n    realPart = modCpowern * Math.cos(n * theta);\n\n    //|z|^n * sin(n* theta)\n    imaginaryPart = modCpowern * Math.sin(n * theta);\n\n    //zn = rn(cos(ntheta)+i sin(ntheta))\n    retComplex = new Complex(realPart, imaginaryPart);\n    return retComplex;\n  }\n  toString() {\n    return this.real + \" + \" + this.imaginary + \"i\";\n  }\n  plus(c) {\n    return new Complex(this.real + c.real, this.imaginary + c.imaginary);\n  }\n  plusDestroy(c) {\n    var realPart = c.real;\n    var imagPart = c.imaginary;\n    c.real = this.real + realPart;\n    c.imaginary = this.imaginary + imagPart;\n    return c;\n  }\n  subs(c) {\n    return new Complex(this.real - c.real, this.imaginary - c.imaginary);\n  }\n  subsDestroy(c) {\n    var realPart = c.real;\n    var imagPart = c.imaginary;\n    c.real = this.real - realPart;\n    c.imaginary = this.imaginary - imagPart;\n    return c;\n  }\n  mult(c) {\n    var realPart = c.real;\n    var imagPart = c.imaginary;\n    return new Complex(realPart * this.real - imagPart * this.imaginary, this.imaginary * realPart + imagPart * this.real);\n  }\n  multDestroy(c) {\n    var realPart = c.real;\n    var imagPart = c.imaginary;\n    c.real = realPart * this.real - imagPart * this.imaginary;\n    c.imaginary = this.imaginary * realPart + imagPart * this.real;\n    return c;\n  }\n  divide(c) {\n    var realPart = c.real;\n    var imagPart = c.imaginary;\n    var divident = realPart * realPart + imagPart * imagPart;\n    return new Complex((this.real * realPart + this.imaginary * imagPart) / divident, (this.imaginary * realPart - this.real * imagPart) / divident);\n  }\n  divideDestroy(c) {\n    var realPart = c.real;\n    var imagPart = c.imaginary;\n    var divident = realPart * realPart + imagPart * imagPart;\n    c.real = (this.real * realPart + this.imaginary * imagPart) / divident;\n    c.imaginary = (this.imaginary * realPart - this.real * imagPart) / divident;\n    return c;\n  }\n  magnitude() {\n    return Math.sqrt(this.real * this.real + this.imaginary * this.imaginary);\n  }\n  arctan(c) {\n    var i = Complex.I;\n    return i.mult(Complex.log(i.plus(c).divide(i.subs(c)))).divide(new Complex(2, 0, 2, 0));\n  }\n  floor(c) {\n    return new Complex(Math.floor(c.real), Math.floor(c.imaginary));\n  }\n  log(c) {\n    return new Complex(Math.log(c.real), c.t + 2 * Math.PI * Math.floor(-c.t / (2 * Math.PI) + 1 / 2));\n  }\n}\nexports.default = Complex;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.VAtoDB = VAtoDB;\nexports.VVtoDB = VVtoDB;\nexports.dBtoVV = dBtoVV;\nexports.degreeToradian = degreeToradian;\nexports.getGainDB = getGainDB;\nexports.getGainVV = getGainVV;\nexports.groupDelay = groupDelay;\nexports.hzToRadPerSecond = hzToRadPerSecond;\nexports.negatePhase = negatePhase;\nexports.phaseDelay = phaseDelay;\nexports.radianTodegree = radianTodegree;\nvar AdiMath = _interopRequireWildcard(require(\"./math\"));\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction VAtoDB(VA) {\n  var log10VA = AdiMath.logBaseTen(VA);\n  var db = 20 * log10VA;\n  return db;\n}\n\n// PRIVATE FUNCTIONS\nfunction radianTodegree(radArray) {\n  var newArray = [];\n  for (var i = 0; i < radArray.length; i++) {\n    newArray.push(radArray[i] * (180 / Math.PI));\n  }\n  return newArray;\n}\nfunction VVtoDB(vv) {\n  var log10vv = AdiMath.logBaseTen(vv);\n  var db = 20 * log10vv;\n  return db;\n}\nfunction dBtoVV(db) {\n  var x = db / 20;\n  var vv = Math.pow(10, x);\n  return vv;\n}\nfunction degreeToradian(cmag) {\n  var newArray = [];\n  for (var i = 0; i < cmag.length; i++) {\n    var newArrayInner = [];\n    newArrayInner.push(cmag[i] * (Math.PI / 180));\n    newArray.push(newArrayInner);\n  }\n  return newArray;\n}\nfunction negatePhase(phaseArray) {\n  var negatedPhaseArray = [];\n  for (var i = 0; i < phaseArray.length; i++) {\n    negatedPhaseArray.push(phaseArray[i] * -1);\n  }\n  return negatedPhaseArray;\n}\nfunction hzToRadPerSecond(frequencyArray) {\n  var result = [];\n  for (var i = 0; i < frequencyArray.length; i++) {\n    result.push(frequencyArray[i] * (2 * Math.PI));\n  }\n  return result;\n}\nfunction phaseDelay(phaseArray, frequencyArray) {\n  var radPerS = [],\n    result = [];\n\n  //convert frequencyArray convert from Hz to rad/s\n  radPerS = this.hzToRadPerSecond(frequencyArray);\n  //negate Phase Array\n  var negatedPhaseArray = this.negatePhase(phaseArray);\n  //divide negatedPhase array by frequency array\n  for (var m = 0; m < radPerS.length; m++) {\n    result.push(negatedPhaseArray[m] / radPerS[m]);\n  }\n  return result;\n}\nfunction groupDelay(phaseArray, frequencyArray) {\n  var frequencyDifference, phaseDifference;\n  var groupDelayArray = [];\n  var newFrequencyAxis = [];\n  var negatedPhaseArray = this.negatePhase(phaseArray);\n\n  //convert array from Hz to rad/s\n  var frequencyRadPerSecondArray = this.hzToRadPerSecond(frequencyArray);\n\n  //loop through negatedPhaseArray\n  for (var i = 1; i < negatedPhaseArray.length; i++) {\n    //calculate frequencyDifference \n    frequencyDifference = frequencyRadPerSecondArray[i] - frequencyRadPerSecondArray[i - 1];\n\n    //calculate phaseDifference\n    phaseDifference = negatedPhaseArray[i] - negatedPhaseArray[i - 1];\n\n    //calculate groupDelay\n    groupDelayArray.push(phaseDifference / frequencyDifference);\n\n    //use original frequencyArray to calculate newFrequencyAxis\n    newFrequencyAxis.push(Math.sqrt(frequencyArray[i] * frequencyArray[i - 1]));\n  }\n\n  //prepare array (Group Delay plotted against NewFrequencyAxis x,y respectfully)\n  return [groupDelayArray, newFrequencyAxis];\n}\nfunction getGainDB(gain, gainUnit) {\n  if (gain != 0) {\n    gain = gainUnit == 'dB' ? gain : this.VVtoDB(gain);\n  }\n  return parseInt(gain);\n}\nfunction getGainVV(gain, gainUnit) {\n  if (gainUnit == 'dB') {\n    gain = this.dBtoVV(gain);\n  }\n  return parseInt(gain);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nclass ErrorCodes {\n  static PhotodiodeUtils = {\n    calculatePeakLightIntensity: {\n      peakPhotodiodeNotInRange: 'peak_light_error'\n    },\n    calculatePeakPhotodiode: {\n      computedPeakPhotodiodeNotInRange: 'peak_photodiode_error'\n    }\n  };\n  static OneStage = {\n    oneStageRf: {\n      rfTooHigh: 'rf_too_high'\n    }\n  };\n  static TwoStage = {\n    pickOpAmp_2ndStage: {\n      noOpAmpAvailable: 'no_op_amps_available_for_second_stage'\n    }\n  };\n  static fixedOpAmpNoGood = 'fixed_op_amp_no_good';\n  static noOpAmpAvailableForSingleStageTooSlow = 'no_op_amps_available_for_single_stage_too_slow';\n  static noOpAmpAvailableForSingleStageTooFast = \"no_op_amps_available_for_single_stage_too_fast\";\n  static noOpAmpAvailableForFirstStageTooSlow = \"no_op_amps_available_for_first_stage_too_slow\";\n  static noOpAmpAvailableForFirstStageTooFast = \"no_op_amps_available_for_first_stage_too_fast\";\n  static internalCfTooHigh = 'internal_cf_too_high';\n}\nexports.default = ErrorCodes;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.generateExtremelyFineGranularityFreqArray = generateExtremelyFineGranularityFreqArray;\nexports.generateFineGranularityFreqArray = generateFineGranularityFreqArray;\nexports.generateModerateGranularityFreqArray = generateModerateGranularityFreqArray;\nexports.generateVeryFineGranularityFreqArray = generateVeryFineGranularityFreqArray;\n// const POINTS_PER_DECADE_58 /* vs 50 */ = [\n//   // by 0.05 (mostly)\n//   1.00, 1.05, 1.10, 1.15, 1.20, 1.25, 1.30, 1.35, 1.40, 1.45, 1.50, \n//   // by 0.10\n//   1.60, 1.70, 1.80, 1.90, 2.00, 2.10, 2.20, 2.30, 2.40, 2.50, 2.60, 2.70, 2.80, 2.90, 3.00, 3.10, 3.20, \n//   // by 0.15\n//   3.35, 3.50, 3.70, 3.85, 4.00, 4.15, 4.30, \n//   // by 0.20 (mostly)\n//   4.50, 4.70, 4.85, 5.00, 5.20, 5.40, 5.60, 5.80, 6.00, \n//   // by 0.25\n//   6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 8.00, 8.25, 8.50, 8.75, 9.00, 9.25, 9.75, 10.00,\n// ];\n\nconst POINTS_PER_DECADE_63 /* vs 50 */ = [\n// by 0.05 (mostly)\n1.00, 1.05, 1.10, 1.15, 1.20, 1.25, 1.30, 1.35, 1.40, 1.45, 1.50, 1.55, 1.60, 1.65, 1.70, 1.75, 1.80, 1.85, 1.90, 1.95, 2.00,\n// by 0.10\n2.10, 2.20, 2.30, 2.40, 2.50, 2.60, 2.70, 2.80, 2.90, 3.00, 3.10, 3.20,\n// by 0.15\n3.35, 3.50, 3.70, 3.85, 4.00, 4.15, 4.30,\n// by 0.20 (mostly)\n4.50, 4.70, 4.85, 5.00, 5.20, 5.40, 5.60, 5.80, 6.00,\n// by 0.25\n6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 8.00, 8.25, 8.50, 8.75, 9.00, 9.25, 9.75, 10.00];\nconst POINTS_PER_DECADE_99 /* vs 101 */ = [\n// by 0.02\n1.00, 1.02, 1.04, 1.06, 1.08, 1.10,\n// by 0.025 (0.02/0.03/0.03/0.02)\n1.12, 1.15, 1.18, 1.20, 1.22, 1.25, 1.28, 1.30, 1.32, 1.35, 1.38, 1.40, 1.42, 1.45, 1.48, 1.50,\n// by 0.05\n1.55, 1.60, 1.65, 1.70, 1.75, 1.80, 1.85, 1.90, 1.95, 2.00, 2.05, 2.10, 2.15, 2.20, 2.25, 2.30, 2.35, 2.40, 2.45, 2.50, 2.55, 2.60, 2.70, 2.75, 2.80, 2.85, 2.90, 2.95, 3.00, 3.05, 3.10, 3.15, 3.20,\n// by 0.10\n3.30, 3.40, 3.50, 3.60, 3.70, 3.90, 4.00, 4.10, 4.20,\n// by 0.125 (0.12/0.13/0.13/0.12)\n4.32, 4.45, 4.58, 4.75, 4.88, 5.00,\n// by 0.15\n5.15, 5.30, 5.50, 5.65, 5.80, 6.00, 6.15, 6.30, 6.45, 6.60, 6.75, 6.88, 7.00, 7.15, 7.32, 7.50, 7.65, 7.80,\n//by 0.20\n8.00, 8.20, 8.40, 8.60, 8.80, 9.00, 9.20, 9.40, 9.60, 9.80, 10];\nconst POINTS_PER_DECADE_607 /* vs 603 */ = [\n// by 0.005\n1.005, 1.010, 1.015, 1.020, 1.025, 1.030, 1.035, 1.040, 1.045, 1.050, 1.055, 1.060, 1.065, 1.070, 1.075, 1.080, 1.085, 1.090, 1.095, 1.100, 1.105, 1.110, 1.115, 1.120, 1.125, 1.130, 1.135, 1.140, 1.145, 1.150, 1.155, 1.160, 1.165, 1.170, 1.175, 1.180, 1.185, 1.190, 1.195, 1.200, 1.205, 1.210, 1.215, 1.220, 1.225, 1.230, 1.235, 1.240, 1.245, 1.250, 1.255, 1.260, 1.265, 1.270, 1.275, 1.280, 1.285, 1.290, 1.295, 1.300, 1.305, 1.310, 1.315, 1.320, 1.325, 1.330, 1.335, 1.340, 1.345, 1.350, 1.355, 1.360, 1.365, 1.370, 1.375, 1.380, 1.385, 1.390, 1.395, 1.400, 1.405, 1.410, 1.415, 1.420, 1.425, 1.430, 1.435, 1.440, 1.445, 1.450, 1.455, 1.460, 1.465, 1.470, 1.475, 1.480, 1.485, 1.490, 1.495, 1.500, 1.505, 1.510, 1.515, 1.520, 1.525, 1.530, 1.535, 1.540, 1.545, 1.550, 1.555, 1.560, 1.565, 1.570, 1.575, 1.580, 1.585, 1.590, 1.595, 1.600,\n// by 0.0075  (.008/.007/0.007/0.008)\n1.608, 1.615, 1.622, 1.630, 1.638, 1.645, 1.652, 1.660, 1.668, 1.675, 1.682, 1.690, 1.698, 1.705, 1.712, 1.720, 1.728, 1.735, 1.742, 1.750, 1.758, 1.765, 1.772, 1.780, 1.788, 1.795, 1.802, 1.810, 1.818, 1.825, 1.832, 1.840, 1.848, 1.855, 1.862, 1.870, 1.878, 1.885, 1.892, 1.900, 1.908, 1.915, 1.922, 1.930, 1.938, 1.945, 1.952, 1.960, 1.968, 1.975, 1.981, 1.987, 1.993, 2.000, 2.006, 2.013, 2.020, 2.028, 2.035, 2.042, 2.050, 2.057, 2.065, 2.072, 2.080, 2.088, 2.095, 2.102, 2.110, 2.118, 2.125, 2.133, 2.140, 2.148, 2.155, 2.162, 2.170, 2.178, 2.185, 2.192, 2.200, 2.208, 2.216, 2.225, 2.231, 2.238, 2.244, 2.250, 2.259, 2.267, 2.275, 2.282, 2.290, 2.298, 2.305, 2.312, 2.320, 2.328, 2.335, 2.342, 2.350, 2.358, 2.365, 2.372, 2.380,\n// by 0.01\n2.390, 2.400, 2.410, 2.420, 2.430, 2.440, 2.450, 2.460, 2.470, 2.480, 2.490, 2.500, 2.510, 2.520, 2.530, 2.540, 2.550, 2.560, 2.570, 2.580, 2.590, 2.600, 2.610, 2.620, 2.630, 2.640, 2.650, 2.660, 2.670, 2.680, 2.690, 2.700, 2.710, 2.720, 2.730, 2.740, 2.750, 2.760, 2.770, 2.780, 2.790, 2.800, 2.810, 2.820, 2.830, 2.840, 2.850, 2.860, 2.87, 2.88, 2.89, 2.9, 2.91, 2.92, 2.93, 2.94, 2.95, 2.96, 2.97, 2.98, 2.99, 3.0, 3.01, 3.02, 3.03, 3.04, 3.05, 3.06, 3.07, 3.08, 3.09, 3.1, 3.11, 3.12, 3.13, 3.14, 3.15, 3.16, 3.17, 3.18, 3.19, 3.2, 3.21, 3.22, 3.23, 3.24, 3.25, 3.26, 3.27, 3.28, 3.29, 3.3, 3.31, 3.32, 3.33, 3.34, 3.35, 3.36, 3.37, 3.38, 3.39,\n// by 0.02\n3.4, 3.42, 3.44, 3.46, 3.48, 3.5, 3.52, 3.54, 3.56, 3.58, 3.6, 3.62, 3.64, 3.66, 3.68, 3.7, 3.72, 3.74, 3.76, 3.78, 3.8, 3.82, 3.84, 3.86, 3.88, 3.9, 3.92, 3.93, 3.96, 3.98, 4.0, 4.02, 4.04, 4.06, 4.08, 4.1, 4.12, 4.14, 4.16, 4.18, 4.2, 4.22, 4.24, 4.26, 4.28, 4.3, 4.32, 4.34, 4.36, 4.38, 4.4, 4.42, 4.44, 4.46, 4.48, 4.5, 4.52, 4.54, 4.56, 4.58, 4.6, 4.62, 4.64, 4.66, 4.68, 4.7, 4.72, 4.74, 4.76, 4.78, 4.8, 4.82, 4.84, 4.86, 4.88, 4.9, 4.92, 4.94, 4.96, 4.98, 5.0, 5.02, 5.04, 5.06, 5.08, 5.1, 5.12, 5.14, 5.16, 5.18, 5.2, 5.22, 5.24, 5.26, 5.28, 5.3, 5.32, 5.34, 5.36, 5.38, 5.4, 5.42, 5.44, 5.46, 5.48, 5.5, 5.52, 5.54, 5.56, 5.58, 5.6, 5.62, 5.64, 5.66, 5.68, 5.7, 5.72, 5.74, 5.76, 5.78, 5.8, 5.82, 5.84, 5.86, 5.88, 5.9, 5.92, 5.94, 5.96, 5.98, 6.0, 6.02, 6.04, 6.06, 6.08, 6.1, 6.12, 6.14, 6.16, 6.18, 6.2, 6.22, 6.24, 6.26, 6.28, 6.3, 6.32, 6.34, 6.36, 6.38, 6.4, 6.42, 6.44, 6.46, 6.48, 6.5, 6.52, 6.54, 6.56, 6.58, 6.6, 6.62, 6.64, 6.66, 6.68, 6.7, 6.72, 6.74, 6.76, 6.78, 6.80, 6.82, 6.84, 6.86, 6.88, 6.90, 6.92, 6.94, 6.96, 6.98, 7.00,\n// 0.025 => (0.02/0.03/0.03/0.02)\n7.02, 7.05, 7.08, 7.10, 7.12, 7.15, 7.18, 7.20, 7.22, 7.25, 7.28, 7.30, 7.32, 7.35, 7.38, 7.40, 7.42, 7.45, 7.48, 7.50, 7.52, 7.55, 7.58, 7.60, 7.62, 7.65, 7.68, 7.70, 7.72, 7.75, 7.78, 7.80, 7.82, 7.85, 7.88, 7.90, 7.92, 7.95, 7.98, 8.00, 8.02, 8.05, 8.08, 8.10, 8.12, 8.15, 8.18, 8.20, 8.22, 8.25, 8.28, 8.30, 8.32, 8.35, 8.38, 8.40, 8.42, 8.45, 8.48, 8.50, 8.52, 8.55, 8.58, 8.60, 8.62, 8.65, 8.68, 8.70, 8.72, 8.75, 8.78, 8.80, 8.82, 8.85, 8.88, 8.90, 8.92, 8.95, 8.98, 9.00,\n// 0.05\n9.05, 9.10, 9.15, 9.20, 9.25, 9.30, 9.35, 9.4, 9.45, 9.50, 9.55, 9.60, 9.65, 9.70, 9.75, 9.80, 9.85, 9.90, 9.95, 10.0];\n\n/**\r\n * Total of 50 points per decade\r\n * @param {*} start first frequency in array\r\n * @param {*} stop last frequency in array.  Must be bigger than start.\r\n * @param {*} expectedPoints (optional): Array of points that are expected in each decade.  Overrides POINTS_PER_DECADE constant.  For example passing in [1,2] will result in 1, 2, 10, 20, 100, 200, etc.\r\n */\nfunction generateModerateGranularityFreqArray(start, stop, expectedPoints) {\n  // eslint-disable-next-line no-unused-vars\n  const POINTS_PER_DECADE = [\n  // by 0.05\n  1.07, 1.12, 1.17,\n  // by 0.06\n  1.23, 1.29, 1.35, 1.41,\n  // by 0.07\n  1.48, 1.55, 1.62,\n  // by 0.08\n  1.70, 1.78, 1.86,\n  // by 0.09\n  1.95, 2.04,\n  // by 0.10\n  2.14, 2.24,\n  // by 0.11\n  2.35, 2.46, 2.57,\n  // by 0.13\n  2.7, 2.82,\n  // by 0.14\n  2.96, 3.1, 3.24,\n  // by 0.16\n  3.4, 3.56, 3.72,\n  // by 0.18\n  3.9, 4.08,\n  // by 0.20\n  4.28, 4.48,\n  // by 0.21\n  4.69,\n  // by 0.22\n  4.91,\n  // by 0.23\n  5.14,\n  // by 0.24\n  5.38,\n  // by 0.26\n  5.64, 5.9,\n  // by 0.28\n  6.18,\n  // by 0.30\n  6.48, 6.78,\n  // by 0.32\n  7.1,\n  // by 0.34\n  7.44,\n  // by 0.35\n  7.79,\n  // by 0.37\n  8.16,\n  // by 0.38\n  8.54,\n  // by 0.40\n  8.94,\n  // by 0.42\n  9.36,\n  // by 0.44\n  9.8,\n  // by 0.46\n  10.26];\n  return generateFreqArray(start, stop, expectedPoints, POINTS_PER_DECADE_63);\n}\n\n/**\r\n * Total of 101 points per decade\r\n * @param {*} start first frequency in array\r\n * @param {*} stop last frequency in array.  Must be bigger than start.\r\n * @param {*} expectedPoints (optional): Array of points that are expected in each decade.  Overrides POINTS_PER_DECADE constant.  For example passing in [1,2] will result in 1, 2, 10, 20, 100, 200, etc.\r\n */\nfunction generateFineGranularityFreqArray(start, stop, expectedPoints) {\n  // eslint-disable-next-line no-unused-vars\n  const POINTS_PER_DECADE = [1,\n  //by 0.02\n  1.02, 1.05, 1.07, 1.09,\n  //by 0.03\n  1.12, 1.15, 1.17, 1.2, 1.23, 1.26, 1.29, 1.32, 1.35, 1.38, 1.41, 1.44, 1.47,\n  //by 0.04\n  1.51, 1.55, 1.59, 1.62, 1.66, 1.7, 1.74, 1.78, 1.82, 1.86, 1.9, 1.94,\n  //by 0.05\n  1.99, 2.04, 2.09, 2.14, 2.19, 2.24, 2.29, 2.34, 2.39,\n  //by 0.06\n  2.45, 2.51, 2.57, 2.63, 2.69, 2.75, 2.81,\n  //by 0.07\n  2.88, 2.95, 3.02, 3.09, 3.16, 3.23,\n  //by 0.08\n  3.31, 3.39, 3.47, 3.55, 3.63, 3.71,\n  //by 0.09\n  3.8, 3.89, 3.98, 4.07,\n  //by 0.1\n  4.17, 4.27, 4.37, 4.47, 4.57,\n  //by 0.11\n  4.68, 4.79, 4.9, 5.01,\n  //by 0.12\n  5.13, 5.25, 5.37, 5.49,\n  //by 0.13\n  5.62, 5.75,\n  //by 0.14\n  5.89, 6.03, 6.17, 6.31,\n  //by 0.15\n  6.46, 6.61, 6.76,\n  // 0.16\n  6.92, 7.08, 7.24,\n  //by 0.17\n  7.41, 7.58,\n  //by 0.18\n  7.76, 7.94,\n  //by 0.19\n  8.13, 8.32, 8.51,\n  //by 0.2\n  8.71, 8.91,\n  //by 0.21\n  9.12, 9.33,\n  //by 0.22\n  9.55, 9.77,\n  //by 0.23\n  10];\n  return generateFreqArray(start, stop, expectedPoints, POINTS_PER_DECADE_99);\n}\n\n/**\r\n * Total of 110 points per decade\r\n * @param {*} start first frequency in array\r\n * @param {*} stop last frequency in array.  Must be bigger than start.\r\n * @param {*} expectedPoints (optional): Array of points that are expected in each decade.  Overrides POINTS_PER_DECADE constant.  For example passing in [1,2] will result in 1, 2, 10, 20, 100, 200, etc.\r\n */\nfunction generateVeryFineGranularityFreqArray(start, stop, expectedPoints) {\n  // eslint-disable-next-line no-unused-vars\n  const POINTS_PER_DECADE = [\n  //by 0.02\n  1.02, 1.04, 1.06, 1.08, 1.1,\n  //by 0.03\n  1.13, 1.16, 1.18, 1.21, 1.23, 1.26, 1.28, 1.31, 1.34, 1.37, 1.4, 1.43, 1.46, 1.49, 1.52, 1.55, 1.58, 1.61,\n  //by 0.04\n  1.65, 1.69, 1.72, 1.76, 1.8, 1.83, 1.87, 1.91, 1.95, 1.99,\n  //by 0.05\n  2.03, 2.08, 2.12, 2.17, 2.21, 2.26, 2.31, 2.36, 2.41, 2.46, 2.51,\n  //by 0.06\n  2.56, 2.62, 2.67, 2.73, 2.79, 2.85, 2.91, 2.97, 3.03, 3.09,\n  //by 0.07\n  3.16, 3.23, 3.3, 3.37, 3.44, 3.51, 3.58,\n  //by 0.08\n  3.66, 3.74, 3.82, 3.9, 3.98, 4.06,\n  //by 0.09\n  4.15, 4.24, 4.33, 4.42, 4.51, 4.6,\n  //by 0.1\n  4.7, 4.8, 4.91, 5.01, 5.11,\n  //by 0.11\n  5.22, 5.33, 5.44,\n  //by 0.12\n  5.56, 5.68, 5.8, 5.92,\n  //by 0.13\n  6.05, 6.18, 6.31, 6.44,\n  //by 0.14\n  6.58, 6.72, 6.86, 7.0,\n  //by 0.15\n  7.15, 7.3,\n  //by 0.16\n  7.46, 7.62, 7.78, 7.94,\n  //by 0.17\n  8.11, 8.28,\n  //by 0.18\n  8.46, 8.64, 8.82,\n  //by 0.19\n  9.01, 9.2, 9.39,\n  //by 0.2\n  9.59, 9.79,\n  //by 0.21\n  10];\n  return generateFreqArray(start, stop, expectedPoints, POINTS_PER_DECADE_99);\n}\n\n/**\r\n * Total of 603 points per decade\r\n * @param {*} start first frequency in array\r\n * @param {*} stop last frequency in array.  Must be bigger than start.\r\n * @param {*} expectedPoints (optional): Array of points that are expected in each decade.  Overrides POINTS_PER_DECADE constant.  For example passing in [1,2] will result in 1, 2, 10, 20, 100, 200, etc.\r\n */\nfunction generateExtremelyFineGranularityFreqArray(start, stop, expectedPoints) {\n  // eslint-disable-next-line no-unused-vars\n  const POINTS_PER_DECADE = [\n  // by 0.004\n  1.004, 1.008, 1.012, 1.016, 1.02, 1.024, 1.028, 1.032, 1.036, 1.04, 1.044, 1.048, 1.052, 1.056, 1.06, 1.064, 1.068, 1.072, 1.076, 1.08,\n  // by 0.005\n  1.084, 1.089, 1.094, 1.099, 1.104, 1.109, 1.114, 1.119, 1.124, 1.129, 1.134, 1.139, 1.144, 1.149, 1.154, 1.159, 1.164, 1.169, 1.174, 1.179, 1.184, 1.189, 1.194, 1.199, 1.204, 1.209, 1.214, 1.219, 1.224, 1.229, 1.234, 1.239, 1.244, 1.249, 1.254, 1.259, 1.264, 1.269, 1.274, 1.279, 1.284, 1.289, 1.294, 1.299, 1.304, 1.309, 1.314, 1.319, 1.324, 1.329, 1.334, 1.339, 1.344, 1.349, 1.354, 1.359, 1.364, 1.369, 1.374, 1.379, 1.384, 1.389, 1.394, 1.399, 1.404, 1.409, 1.414, 1.419, 1.424, 1.429, 1.434, 1.439, 1.444, 1.449, 1.454, 1.459, 1.464, 1.469, 1.474, 1.479, 1.484, 1.489, 1.494, 1.499, 1.504,\n  // by 0.006\n  1.509, 1.515, 1.521, 1.527, 1.533, 1.539, 1.545, 1.551, 1.557, 1.563, 1.569, 1.575, 1.581, 1.587, 1.593,\n  // by 0.007\n  1.599, 1.606, 1.613, 1.62, 1.627, 1.634, 1.641, 1.648, 1.655, 1.662, 1.669, 1.676, 1.683, 1.69, 1.697, 1.704, 1.711, 1.718, 1.725, 1.732, 1.739, 1.746, 1.753, 1.76, 1.767, 1.774, 1.781, 1.788, 1.795, 1.802, 1.809, 1.816, 1.823, 1.83, 1.837, 1.844, 1.851, 1.858, 1.865, 1.872, 1.879, 1.886, 1.893, 1.9, 1.907, 1.914, 1.921, 1.928, 1.935, 1.942, 1.949, 1.956, 1.963, 1.97, 1.977, 1.984, 1.991, 1.998, 2.005, 2.012, 2.019, 2.026, 2.033, 2.04, 2.047, 2.054, 2.061, 2.068, 2.075, 2.082, 2.089, 2.096, 2.103, 2.11, 2.117, 2.124, 2.131, 2.138, 2.145,\n  // by 0.008\n  2.152, 2.16, 2.168, 2.176, 2.184, 2.192, 2.2, 2.208, 2.216, 2.224, 2.232, 2.24, 2.248,\n  // by 0.009\n  2.257, 2.266, 2.275, 2.284, 2.293, 2.302, 2.311, 2.32, 2.329, 2.338, 2.347, 2.356, 2.365, 2.374, 2.383, 2.392, 2.401, 2.41, 2.419, 2.428, 2.437, 2.446, 2.455, 2.464, 2.473, 2.482, 2.491, 2.5, 2.509, 2.518, 2.527, 2.536, 2.545, 2.554, 2.563, 2.572, 2.581, 2.59, 2.599, 2.608, 2.617, 2.626, 2.635, 2.644, 2.653, 2.662, 2.671, 2.68, 2.689, 2.698, 2.707, 2.716, 2.725, 2.734, 2.743, 2.752, 2.761, 2.77, 2.779, 2.788, 2.797, 2.806, 2.815, 2.824, 2.833, 2.842, 2.851, 2.86,\n  //by 0.01\n  2.87, 2.88, 2.89, 2.9, 2.91, 2.92, 2.93, 2.94, 2.95, 2.96, 2.97, 2.98, 2.99, 3.0, 3.01, 3.02, 3.03, 3.04, 3.05, 3.06, 3.07, 3.08, 3.09, 3.1, 3.11, 3.12, 3.13, 3.14, 3.15, 3.16, 3.17, 3.18, 3.19, 3.2, 3.21, 3.22, 3.23, 3.24, 3.25, 3.26, 3.27, 3.28, 3.29, 3.3, 3.31, 3.32, 3.33, 3.34, 3.35, 3.36, 3.37, 3.38, 3.39,\n  //by 0.02\n  3.4, 3.42, 3.44, 3.46, 3.48, 3.5, 3.52, 3.54, 3.56, 3.58, 3.6, 3.62, 3.64, 3.66, 3.68, 3.7, 3.72, 3.74, 3.76, 3.78, 3.8, 3.82, 3.84, 3.86, 3.88, 3.9, 3.92, 3.93, 3.96, 3.98, 4.0, 4.02, 4.04, 4.06, 4.08, 4.1, 4.12, 4.14, 4.16, 4.18, 4.2, 4.22, 4.24, 4.26, 4.28, 4.3, 4.32, 4.34, 4.36, 4.38, 4.4, 4.42, 4.44, 4.46, 4.48, 4.5, 4.52, 4.54, 4.56, 4.58, 4.6, 4.62, 4.64, 4.66, 4.68, 4.7, 4.72, 4.74, 4.76, 4.78, 4.8, 4.82, 4.84, 4.86, 4.88, 4.9, 4.92, 4.94, 4.96, 4.98, 5.0, 5.02, 5.04, 5.06, 5.08, 5.1, 5.12, 5.14, 5.16, 5.18, 5.2, 5.22, 5.24, 5.26, 5.28, 5.3, 5.32, 5.34, 5.36, 5.38, 5.4, 5.42, 5.44, 5.46, 5.48, 5.5, 5.52, 5.54, 5.56, 5.58, 5.6, 5.62, 5.64, 5.66, 5.68, 5.7, 5.72, 5.74, 5.76, 5.78, 5.8, 5.82, 5.84, 5.86, 5.88, 5.9, 5.92, 5.94, 5.96, 5.98, 6.0, 6.02, 6.04, 6.06, 6.08, 6.1, 6.12, 6.14, 6.16, 6.18, 6.2, 6.22, 6.24, 6.26, 6.28, 6.3, 6.32, 6.34, 6.36, 6.38, 6.4, 6.42, 6.44, 6.46, 6.48, 6.5, 6.52, 6.54, 6.56, 6.58, 6.6, 6.62, 6.64, 6.66, 6.68, 6.7, 6.72, 6.74, 6.76, 6.77,\n  // 0.03\n  6.79, 6.82, 6.85, 6.88, 6.91, 6.94, 6.97, 7.0, 7.03, 7.06, 7.09, 7.12, 7.15, 7.18, 7.21, 7.24, 7.27, 7.3, 7.33, 7.36, 7.39, 7.42, 7.45, 7.48, 7.51, 7.54, 7.57, 7.6, 7.63, 7.66, 7.69, 7.72, 7.75, 7.78, 7.81, 7.84, 7.87, 7.9, 7.93, 7.96, 7.99, 8.02, 8.05, 8.08, 8.11, 8.14, 8.17, 8.2, 8.23, 8.26, 8.29, 8.32, 8.35, 8.38, 8.41, 8.44, 8.47, 8.5, 8.53, 8.56, 8.59, 8.62, 8.65, 8.68, 8.71, 8.74, 8.77, 8.8, 8.83, 8.86, 8.89, 8.92, 8.95, 8.98, 9.01,\n  // 0.04\n  9.04, 9.08, 9.12, 9.16, 9.2, 9.24, 9.28, 9.32, 9.36, 9.4, 9.44, 9.48, 9.52, 9.56, 9.6, 9.64, 9.68, 9.72, 9.76, 9.8, 9.84, 9.88, 9.92, 9.96, 10.001];\n  return generateFreqArray(start, stop, expectedPoints, POINTS_PER_DECADE_607);\n}\nfunction generateFreqArray(start, stop, expectedPoints, pointsPerDecade) {\n  // error checking\n  if (typeof start !== 'number') throw new Error('Cannot generate frequency array, start freq is not a number');\n  if (typeof stop !== 'number') throw new Error('Cannot generate frequency array, stop freq is not a number');\n  if (start <= 0) throw new Error('Cannot generate frequency array when start freq is <= 0');\n  if (start >= stop) throw new Error('Cannot generate frequency array when start frequency is >= stop frequency');\n  let results = [],\n    currentPosition = start;\n  const expectedPointsArr = expectedPoints || pointsPerDecade;\n  let decadeStart = Math.floor(Math.log10(start));\n\n  // Iterate through each decade and add the corresponding point values\n  for (let decade = decadeStart; currentPosition < stop; decade++) {\n    let newPoints = expectedPointsArr.map(value => Number(value + 'e' + decade)).filter(value => !results.includes(value)); // ensure we aren't adding duplicates\n\n    results.push(...newPoints);\n    currentPosition = results[results.length - 1] + 1;\n  }\n\n  // find index of the nearest start value\n  const index = results.findIndex(value => value >= start);\n  // if index is not 0, get the value before the index result above, this index will be the starting point of the array\n  const startIndex = index === 0 ? index : index - 1;\n  const endIndex = results.findIndex(value => value >= stop);\n  const filteredResult = results.filter((_value, index) => {\n    return index >= startIndex && index <= endIndex;\n  });\n  return filteredResult;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.addSpectralToRMSSum = addSpectralToRMSSum;\nexports.calculateAlphaForCFBVoltageNoise = calculateAlphaForCFBVoltageNoise;\nexports.calculateArraysForNoiseGainPlot = calculateArraysForNoiseGainPlot;\nexports.calculateClosedLoopGain = calculateClosedLoopGain;\nexports.calculateComplexA = calculateComplexA;\nexports.calculateComplexA_PolesAndZeroes = calculateComplexA_PolesAndZeroes;\nexports.calculateComplexAlpha_Stage2 = calculateComplexAlpha_Stage2;\nexports.calculateComplexAlpha_TIA = calculateComplexAlpha_TIA;\nexports.calculateComplexBeta_Stage2 = calculateComplexBeta_Stage2;\nexports.calculateComplexBeta_TIA = calculateComplexBeta_TIA;\nexports.calculateComplexClosedLoopGain = calculateComplexClosedLoopGain;\nexports.calculateENOB = calculateENOB;\nexports.calculateMaxSupplyVoltage = calculateMaxSupplyVoltage;\nexports.calculateMinSupplyVoltage = calculateMinSupplyVoltage;\nexports.calculateNaturalFrequencyAndQ = calculateNaturalFrequencyAndQ;\nexports.calculateNoise = calculateNoise;\nexports.calculateOpAmpCurrentNoiseGain_Stage2 = calculateOpAmpCurrentNoiseGain_Stage2;\nexports.calculateOpAmpCurrentNoiseGain_TIA = calculateOpAmpCurrentNoiseGain_TIA;\nexports.calculateOpAmpVoltageNoiseGain = calculateOpAmpVoltageNoiseGain;\nexports.calculateRfNoiseGain_Stage2 = calculateRfNoiseGain_Stage2;\nexports.calculateRfNoiseGain_TIA = calculateRfNoiseGain_TIA;\nexports.calculateRfilterNoiseGain = calculateRfilterNoiseGain;\nexports.calculateRgNoiseGain_Stage2 = calculateRgNoiseGain_Stage2;\nexports.calculateRinNoiseGain = calculateRinNoiseGain;\nexports.calculateSNR = calculateSNR;\nexports.calculateSpectralDensityForOneFrequency = calculateSpectralDensityForOneFrequency;\nexports.createMagnitudeArray = createMagnitudeArray;\nexports.getActualFpFq = getActualFpFq;\nexports.getRoughBW = getRoughBW;\nexports.getSpectralNoiseData = getSpectralNoiseData;\nexports.solveQ_fnAndMagnitude = solveQ_fnAndMagnitude;\nvar _complex = _interopRequireDefault(require(\"./complex\"));\nvar AdiMath = _interopRequireWildcard(require(\"./math\"));\nvar Common = _interopRequireWildcard(require(\"./common\"));\nvar Solver = _interopRequireWildcard(require(\"./solver\"));\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\n//Get a rough BW that doesn't change with peaking.   We'll use this so that our cutoff frequency stays\n//in the middle of our plots\nfunction getRoughBW(stagesObject) {\n  var opAmp = stagesObject.stage1.opAmp;\n  let gbw;\n  if (opAmp.feedbackMethod === 'Current') {\n    gbw = opAmp.cfb.zbw / opAmp.cfb.rIn;\n  } else {\n    gbw = opAmp.gbw;\n  }\n  var polefrequency = 1 / (2 * Math.PI * stagesObject.stage1.cin * stagesObject.stage1.rf);\n  return Math.sqrt(polefrequency * gbw);\n}\n\n// export function createComplexClosedLoopGainArray(frequencyArray, stages, inputValues) {\n//     var i, complexA, complexAlpha, complexBeta, complexClosedLoopGain, complexClosedLoopGain_2ndStage;\n//     var complexClosedLoopGainArray = [];\n//     var stage1 = stages.stage1, stage2 = stages.stage2;\n//     var freqLength = frequencyArray.length;\n\n//     for (i = 0; i < freqLength; i++) {\n//         complexA = this.calculateComplexA(frequencyArray[i], stage1);\n//         complexAlpha = this.calculateComplexAlpha_TIA(frequencyArray[i], stage1);\n//         complexBeta = this.calculateComplexBeta_TIA(frequencyArray[i], stage1);\n//         complexClosedLoopGain = this.calculateComplexClosedLoopGain(complexA, complexBeta, complexAlpha);\n\n//         if (inputValues.stages === PhotodiodeConstants.pdStages.twoStage) {\n//             complexA = this.calculateComplexA(frequencyArray[i], stage2);\n//             complexAlpha = this.calculateComplexAlpha_Stage2(frequencyArray[i], stage2);\n//             complexBeta = this.calculateComplexBeta_Stage2(frequencyArray[i], stage2);\n//             complexClosedLoopGain_2ndStage = this.calculateComplexClosedLoopGain(complexA, complexBeta, complexAlpha);\n//             complexClosedLoopGain = complexClosedLoopGain.mult(complexClosedLoopGain_2ndStage);\n//         }\n\n//         complexClosedLoopGainArray.push(magnitude);\n//     }\n\n//     return complexClosedLoopGainArray;\n// }\n\n//more accurate than original magnitude calculation function\nfunction createMagnitudeArray(frequencyArray, stages, inputValues) {\n  var i, complexA, complexAlpha, complexBeta, magnitude, magnitude_2ndStage;\n  var magnitudeArray = [];\n  var stage1 = stages.stage1,\n    stage2 = stages.stage2;\n  var freqLength = frequencyArray.length;\n  var complexAPhases = [];\n  for (i = 0; i < freqLength; i++) {\n    complexA = this.calculateComplexA(frequencyArray[i], stage1);\n    complexAPhases.push(Math.atan2(complexA.imaginary, complexA.real) * 180 / Math.PI);\n    complexAlpha = this.calculateComplexAlpha_TIA(frequencyArray[i], stage1);\n    complexBeta = this.calculateComplexBeta_TIA(frequencyArray[i], stage1);\n    magnitude = this.calculateClosedLoopGain(complexA, complexBeta, complexAlpha);\n    if (inputValues.stages === _photodiodeConstants.default.pdStages.twoStage) {\n      complexA = this.calculateComplexA(frequencyArray[i], stage2);\n      complexAlpha = this.calculateComplexAlpha_Stage2(frequencyArray[i], stage2);\n      complexBeta = this.calculateComplexBeta_Stage2(frequencyArray[i], stage2);\n      magnitude_2ndStage = this.calculateClosedLoopGain(complexA, complexBeta, complexAlpha);\n      magnitude *= magnitude_2ndStage;\n    }\n    magnitudeArray.push(magnitude);\n  }\n  return magnitudeArray;\n}\n\n//This function calculations the natural frequency and Q for display on the Frequency Response graph\nfunction calculateNaturalFrequencyAndQ(stages, numStages) {\n  var stage1 = stages.stage1;\n  var rin = stage1.rin;\n  var rf = stage1.rf;\n  let gbw;\n  if (stage1.opAmp.feedbackMethod === 'Current' && stage1.opAmp.cfb) {\n    gbw = stage1.opAmp.cfb.zbw / stage1.opAmp.cfb.rIn;\n  } else {\n    gbw = stage1.opAmp.gbw;\n  }\n  var cin = stage1.cin;\n  var cf = stage1.cf;\n  var fn = Solver.solveBW(cin, rin, cf, rf, gbw);\n  var fnAndQ = this.solveQ_fnAndMagnitude(fn, stages, numStages);\n  return fnAndQ;\n}\n\n//This function solves for Q using the magnitude value at the natural frequency.\n//In other words, if we just had the graph, what would Q be?\n//We use this method to show the \"real Q\".  Unlike our Q calculation from circuit values, which just assumes\n//a 2nd order circuit, this method incorporates the additional poles.\nfunction solveQ_fnAndMagnitude(fn, stages, numStages) {\n  //we'll just reuse createMagnitudeArray function, so set up data in the way it likes\n  var frequencyArray = [1e-9, fn];\n  var inputValues = {\n    stages: numStages\n  };\n  var magnitudeArray = this.createMagnitudeArray(frequencyArray, stages, inputValues);\n  var Q = magnitudeArray[1] / magnitudeArray[0];\n  var results = this.getActualFpFq(fn, Q, stages, inputValues);\n  return {\n    fn: results[0],\n    q: results[1]\n  };\n}\n\n//This function calculates the 3dB frequency only use the plot information\n//It assumes that the first point in the plot is equivalent to the DC gain, and calculates 0.707 drop off from it.\n// export function calculate3dBFromPlot(magnitudeArray, frequencyArray) {\n//     var dcValue = magnitudeArray[0];\n//     var threedBFound = false;\n//     var threedB = Math.sqrt(2) / 2 * dcValue;\n\n//     for (var i = 1; i < magnitudeArray.length; i++) {\n//         if (magnitudeArray[i] < threedB) {\n//             threedBFound = true;\n//             var frequencyInterval = frequencyArray[i] / frequencyArray[i - 1];\n//             var voltageInterval = magnitudeArray[i] / magnitudeArray[i - 1];\n//             var voltageIntervalTo3dB = threedB / magnitudeArray[i - 1];\n//             var fraction = (1 - voltageIntervalTo3dB) / (1 - voltageInterval);\n//             var frequencyIntervalTo3dB = fraction * (frequencyInterval - 1) + 1;\n//             var interpolated3dBFrequency = frequencyIntervalTo3dB * frequencyArray[i - 1];\n//             break;\n//         }\n//     }\n\n//     if (threedBFound)\n//         return interpolated3dBFrequency;\n//     else\n//         return NaN;\n// }\n\n//This function calculates the arrays for the noise gain plot\n//Inputs:\n//frequencyArray:  array of frequency points\n//stage:  stagesObject.stage1\nfunction calculateArraysForNoiseGainPlot(frequencyArray, stage) {\n  var i,\n    capGainArray = [],\n    noiseGainArray = [],\n    opAmpArray = [],\n    rcParArray = [];\n  var capGain = (stage.cin + stage.cf) / stage.cf;\n  let rPar;\n  if (stage.opAmp.feedbackMethod === 'Current') {\n    rPar = stage.rf;\n  } else {\n    rPar = stage.rf * stage.rin / (stage.rf + stage.rin);\n  }\n  var rcParallelPole = 1 / (2 * Math.PI * rPar * (stage.cin + stage.cf));\n  for (i = 0; i < frequencyArray.length; i++) {\n    var complexA = this.calculateComplexA(frequencyArray[i], stage);\n    // if (i == 103) {\n    //     var placetoStop = 1;\n    // }\n\n    var complexBeta = this.calculateComplexBeta_TIA(frequencyArray[i], stage);\n    let noiseGain, opAmpGain;\n    if (stage.opAmp.feedbackMethod === 'Current') {\n      var complexAlpha = this.calculateAlphaForCFBVoltageNoise(stage, frequencyArray[i]);\n      noiseGain = this.calculateOpAmpVoltageNoiseGain(complexA, complexBeta, complexAlpha);\n      opAmpGain = complexA.magnitude() / stage.rin;\n    } else {\n      noiseGain = this.calculateOpAmpVoltageNoiseGain(complexA, complexBeta);\n      opAmpGain = complexA.magnitude();\n    }\n    var rcParRatio = frequencyArray[i] / rcParallelPole;\n    var rcParGain = Math.sqrt(rcParRatio * rcParRatio + 1);\n    capGainArray.push(capGain);\n    noiseGainArray.push(noiseGain);\n    opAmpArray.push(opAmpGain);\n    rcParArray.push(rcParGain);\n  }\n  return [noiseGainArray,\n  //Dark black line, in legend call this \"Noise Gain\"\n  capGainArray,\n  //Red dotted line, in legend call this \"(Cin + Cf)/Cf \"\n  opAmpArray,\n  //Green dotted line, in legend call this \"Op Amp Gain\"\n  rcParArray //Blue dotted line, in legend call this \"(Cin||Cf)(Rin||Rf) Zero\"\n  ];\n}\n\n//This function calculates the arrays for the stability plot\n//Inputs:\n//frequencyArray:  array of frequency points\n//stage:  stagesObject.stage1\n// export function calculateArraysForStabilityPlot(frequencyArray, stage) {\n//     let gbw;\n//     if (stage.opAmp.feedbackMethod === \"Current\") {\n//         gbw = parseFloat(stage.opAmp.zbw) / parseFloat(stage.opAmp.rIn);\n//     }\n//     else {\n//         gbw = stage.opAmp.gbw;\n//     }\n//     var rPar = stage.rf * stage.rin / (stage.rf + stage.rin);\n//     var rcParallelPole = 1 / (2 * Math.PI * rPar * (stage.cin + stage.cf));\n//     var rfcfZero = 1 / (2 * Math.PI * stage.rf * stage.cf);\n//     var resDividerGain = stage.rin / (stage.rf + stage.rin);\n//     var capDividerGain = stage.cf / (stage.cin + stage.cf);\n//     var A, beta, loopGain, frequency, i;\n//     var AArray = [], betaArray = [], loopGainArray = [];\n\n//     for (i = 0; i < frequencyArray.length; i++) {\n//         frequency = frequencyArray[i];\n\n//         //A\n//         if (frequency < (gbw * 2))\n//             A = gbw / frequency;\n//         else\n//             A = (gbw / frequency) * ((gbw * 2) / frequency);\n\n//         //Beta\n//         if (resDividerGain > capDividerGain) { //typical voltage feedback case, since resGain is not much smaller than 1.\n//             if (frequency < rcParallelPole)\n//                 beta = resDividerGain;\n//             else if (frequency < rfcfZero)\n//                 beta = resDividerGain * rcParallelPole / frequency;\n//             else\n//                 beta = capDividerGain;\n//         }\n//         else {  //can happen with current feedback case, since low rin of current feedback can create large resGain\n//             if (frequency < rfcfZero)\n//                 beta = resDividerGain;\n//             else if (frequency < rcParallelPole)\n//                 beta = resDividerGain * frequency / rfcfZero;\n//             else\n//                 beta = capDividerGain;\n//         }\n\n//         //Loop Gain\n//         loopGain = A * beta;\n\n//         //Now push to arrays\n//         AArray.push(A);\n//         betaArray.push(beta);\n//         loopGainArray.push(loopGain);\n//     }\n\n//     return [loopGainArray,      //Dark black line, in legend call this \"Loop Gain (A * beta)\"\n//         betaArray,               //Red dotted line, in legend call this \"Feedback (beta)\"\n//         AArray                   //Green dotted line, in legend call this \"Op Amp Gain (A)\"\n//     ];                           //We will only have three lines - there is no blue dotted line.\n// }\n\n//This function is used for displaying the minimum supply voltage on the next steps page\nfunction calculateMinSupplyVoltage(userInputs, stage1, stage2) {\n  var outHeadroom1, outHeadroom2, inHeadroom2, minSupplyOut2, minSupplyIn2, minSupplyOut1, minSupply, secondStageGain;\n  var peakVoltage = userInputs.peakVoltage;\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    secondStageGain = 1 + stage2.rf / stage2.rg;\n    outHeadroom2 = stage2.opAmp.outHeadroomPlus;\n    minSupplyOut2 = outHeadroom2 + peakVoltage;\n    if (userInputs.biasPreference === 'negative') {\n      //output of first stage is positive so check its positive headroom\n      outHeadroom1 = stage1.opAmp.outHeadroomPlus;\n      minSupplyOut1 = outHeadroom1 + peakVoltage / secondStageGain;\n\n      //since using noninverting stage, need input headroom of 2nd stage\n      inHeadroom2 = stage2.opAmp.inHeadroomPlus;\n      minSupplyIn2 = inHeadroom2 + peakVoltage / secondStageGain;\n    } else {\n      //output of first stage is negative so check its negative headroom\n      outHeadroom1 = stage1.opAmp.outHeadroomMinus;\n      minSupplyOut1 = outHeadroom1 + peakVoltage / secondStageGain;\n\n      //common mode of inverting stages always stays at 0, so don't have to worry about input range\n      minSupplyIn2 = 0;\n    }\n    minSupply = Math.max(minSupplyOut1, minSupplyIn2, minSupplyOut2, stage1.opAmp.minSupplyVoltage / 2, stage2.opAmp.minSupplyVoltage / 2);\n  }\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.oneStage) {\n    if (userInputs.biasPreference === 'negative') {\n      outHeadroom1 = stage1.opAmp.outHeadroomPlus;\n    } else {\n      outHeadroom1 = stage1.opAmp.outHeadroomMinus;\n    }\n    minSupplyOut1 = outHeadroom1 + peakVoltage;\n    minSupply = Math.max(minSupplyOut1, stage1.opAmp.minSupplyVoltage / 2);\n  }\n  return minSupply;\n}\nfunction calculateMaxSupplyVoltage(userInputs, stage1, stage2) {\n  var maxSupply;\n  if (userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    maxSupply = Math.min(stage1.opAmp.maxSupplyVoltage / 2, stage2.opAmp.maxSupplyVoltage / 2);\n  } else {\n    maxSupply = stage1.opAmp.maxSupplyVoltage / 2;\n  }\n  return maxSupply;\n}\nfunction getSpectralNoiseData(frequencies, stages) {\n  var noiseInfo = this.calculateNoise(frequencies, stages);\n  return noiseInfo.graphLines;\n}\n\n// PRIVATE FUNCTIONS\n//When calculating the voltage noise of a current feedback amp, we have to convert the voltage into a current.\n//Therefore the alpha is not 1, like in the voltage feedback case.  The alphadepends on both the\n//input resistance of the op amp as well as the feedback components.  This function calculates it.\nfunction calculateAlphaForCFBVoltageNoise(stage, frequency) {\n  var rf_c_s = stage.rf * (stage.cin + stage.cf) * 2 * Math.PI * frequency;\n  var complexNum = _complex.default.createComplex(1, rf_c_s);\n  var complexDenom = _complex.default.createComplex(stage.rin + stage.rf, stage.rin * rf_c_s);\n  var complexAlpha = complexNum.divideDestroy(complexDenom);\n  return complexAlpha;\n}\n\n// Calculate feedforward factor for TIA\nfunction calculateComplexAlpha_TIA(frequency, stage) {\n  var rParallel = stage.rf * stage.rin / (stage.rf + stage.rin);\n  var cParallel = stage.cin + stage.cf;\n  var pole = 1 / (2 * Math.PI * cParallel * rParallel);\n\n  //Calculate numerator.   Note that we assume current source pulls out of circuit, which would normally need a negative sign.\n  //However since we are connected to the inverting input, the negatives cancel out, so no negative sign needed.\n  let complexDCgain;\n  if (stage.opAmp.feedbackMethod === 'Current') {\n    complexDCgain = _complex.default.createComplex(rParallel / stage.rin, 0);\n  } else {\n    complexDCgain = _complex.default.createComplex(rParallel, 0);\n  }\n  var complexDenom = _complex.default.createComplex(1, frequency / pole);\n  return complexDCgain.divideDestroy(complexDenom);\n}\n\n// Calculate feedforward factor for TIA\nfunction calculateComplexAlpha_Stage2(frequency, stage) {\n  var complexNum, complexDenom;\n\n  //Current feedback\n  if (stage.opAmp.feedbackMethod === 'Current' && stage.opAmp.cfb) {\n    if (stage.rfilter === undefined) {\n      //current feedback not allowed in inverting configuration - should have been caught before this point.\n      console.log('Error:  current feedback part in stage 2 inverting configuration');\n      return _complex.default.createComplex(1e60, 0);\n    } else {\n      //non-inverting case\n      var OpAmpRin = stage.opAmp.cfb.rIn;\n      var rPar = stage.rf * stage.rg / (stage.rf + stage.rg);\n      var currentThroughRin = 1 / (OpAmpRin + rPar);\n      return _complex.default.createComplex(currentThroughRin, 0);\n    }\n  }\n\n  //Voltage feedback\n  else {\n    //If no rfilter, then using inverting configuration\n    if (stage.rfilter === undefined || stage.rfilter === null) {\n      /*parallel(rg,C) / (parallel(rg,C) + rf) = rg/(rg +rf*rg*C*s + rf)*/\n      complexNum = _complex.default.createComplex(-1 * stage.rf, 0); //Multiply by -1 here to signify a negative alpha, since we're feeding into inverting input\n      complexDenom = _complex.default.createComplex(stage.rg + stage.rf, stage.rg * stage.rf * stage.cfilter * 2 * Math.PI * frequency);\n    }\n    //noninverting configuration.   This is a calculation for the low pass filter before the noninverting amp (since noninverting amp by itself has alpha = 1)\n    else {\n      complexNum = _complex.default.createComplex(1, 0);\n      complexDenom = _complex.default.createComplex(1, stage.rfilter * stage.cfilter * 2 * Math.PI * frequency);\n    }\n    return complexNum.divideDestroy(complexDenom);\n  }\n}\n\n//Calculates feedback factor for TIA\nfunction calculateComplexBeta_TIA(frequency, stage) {\n  var rParallel = stage.rf * stage.rin / (stage.rf + stage.rin);\n  var cParallel = stage.cin + stage.cf;\n  var pole = 1 / (2 * Math.PI * cParallel * rParallel);\n  var zero = 1 / (2 * Math.PI * stage.rf * stage.cf);\n  let ACgain;\n  if (stage.opAmp.feedbackMethod === 'Current') {\n    ACgain = stage.cf / (cParallel * stage.rin);\n  } else {\n    ACgain = stage.cf / cParallel;\n  }\n  var complexNum = _complex.default.createComplex(ACgain * zero, ACgain * frequency);\n  var complexDenom = _complex.default.createComplex(pole, frequency);\n  return complexNum.divideDestroy(complexDenom);\n}\n\n// Calculate feedback factor for the second stage\nfunction calculateComplexBeta_Stage2(frequency, stage) {\n  var complexNum, complexDenom;\n  //Current feedback\n  if (stage.opAmp.feedbackMethod === 'Current' && stage.opAmp.cfb) {\n    if (stage.rfilter === undefined) {\n      //current feedback not allowed in inverting configuration - should have been caught before this point.\n      console.log('Error:  current feedback part in stage 2 inverting configuration');\n      return _complex.default.createComplex(1e60, 0);\n    } else {\n      //non-inverting case\n      var OpAmpRin = stage.opAmp.cfb.rIn;\n      var rPar = stage.rg * OpAmpRin / (stage.rg + OpAmpRin);\n      var voltageAtInvertingTerminal = rPar / (rPar + stage.rf);\n      var currentThroughRin = voltageAtInvertingTerminal / OpAmpRin;\n      return _complex.default.createComplex(currentThroughRin, 0);\n    }\n  }\n\n  //Voltage feedback\n  else {\n    //If no rfilter, then using inverting configuration which has capacitor in feedback\n    if (stage.rfilter === undefined) {\n      /*   rf / (parallel(rg,C) + rf) = (rf +rf*rg*C*s) / (rg +rf*rg*C*s + rf)  */\n      complexNum = _complex.default.createComplex(stage.rg, stage.rf * stage.rg * stage.cfilter * 2 * Math.PI * frequency);\n      complexDenom = _complex.default.createComplex(stage.rg + stage.rf, stage.rg * stage.rf * stage.cfilter * 2 * Math.PI * frequency);\n      return complexNum.divideDestroy(complexDenom);\n    }\n    //noninverting configuration\n    else {\n      return _complex.default.createComplex(stage.rg / (stage.rg + stage.rf), 0);\n    }\n  }\n}\n\n//Calculates the open loop gain of the op amp\n//We assume a modified integrator model for op amp: infinite Aol, but assume a secondary pole 2x past gbw\n//This corresponds to the following formula:  (2*PI*gbw/s) * 1/( s/(4*PI*gbw) + 1)\n//We do the math slightly differently below so we can do less complex math (which is expensive)\nfunction calculateComplexA(frequency, stage) {\n  var pi = Math.PI;\n  var sImaginary = frequency * 2 * pi;\n  var sSquared = -4 * pi * pi * frequency * frequency;\n  var complexA;\n  let gbw;\n  let complexTopTerm;\n  let complexBottomTerm;\n  if (stage.opAmp.feedbackMethod === 'Current' && stage.opAmp.cfb) {\n    //model CFB amp as having a Z curve that is ideal integrator + 2 identical poles at higher frequency\n    //the two poles are set so there is 135 degrees of phase at the minRf.   This occurs when the poles are 2.414214 * minRf frequency\n    //equations is zbw / (s * (s/freqDualPole + 1)^2)\n    gbw = stage.opAmp.cfb.zbw / stage.opAmp.cfb.rIn;\n    var freq135 = stage.opAmp.cfb.zbw / stage.opAmp.cfb.minRf;\n    // var rad135 = freq135 * 2 * pi;\n    var freqDualPole = freq135 * 2.414214;\n    var radDualPole = freqDualPole * 2 * pi;\n    var ZBWrad = stage.opAmp.cfb.zbw * 2 * pi;\n    var sCubed = -8 * pi * pi * pi * frequency * frequency * frequency;\n    complexTopTerm = _complex.default.createComplex(radDualPole * radDualPole * ZBWrad, 0);\n    complexBottomTerm = _complex.default.createComplex(2 * sSquared * radDualPole, sCubed + radDualPole * radDualPole * sImaginary);\n    complexA = complexTopTerm.divideDestroy(complexBottomTerm);\n  }\n  //Voltage feedback case\n  else {\n    gbw = stage.opAmp.gbw;\n    var GBWrad = gbw * 2 * pi;\n    let rOutDivider;\n    //Math to simulate effect of op amp Rout.  Important when cf and cin capacitors are large.\n    if (stage.opAmp.rOut !== undefined && stage.opAmp.rOut !== null && !isNaN(stage.opAmp.rOut) && stage.cin !== undefined) {\n      var rOut = stage.opAmp.rOut;\n      var topTermRout = _complex.default.createComplex(1, (stage.rf * stage.cin + stage.rf * stage.cf) * sImaginary);\n      var bottomTermRout = _complex.default.createComplex(1 + sSquared * rOut * stage.cin * stage.rf * stage.cf, (stage.rf * stage.cin + stage.rf * stage.cf + rOut * stage.cin) * sImaginary);\n      rOutDivider = topTermRout.divideDestroy(bottomTermRout);\n    } else {\n      rOutDivider = _complex.default.createComplex(1, 0);\n    }\n\n    //Some voltage feedback parts not stable at G=1.  Here is where we handle this\n    if (stage.opAmp.polesZeroes) {\n      complexA = this.calculateComplexA_PolesAndZeroes(stage.opAmp.polesZeroes, sImaginary);\n    } else {\n      //sets 2nd pole at gbw * 2\n      complexTopTerm = _complex.default.createComplex(2 * GBWrad * GBWrad, 0).multDestroy(rOutDivider);\n      complexBottomTerm = _complex.default.createComplex(sSquared, 2 * GBWrad * sImaginary);\n      complexA = complexTopTerm.divideDestroy(complexBottomTerm);\n    }\n  }\n  return complexA;\n}\n\n//This function is for used for calculating op amps with poles and zeros.\n//This function allows us to set poles, left hand plan zeros, and one right half plane zero independently of gbw\n//This function does not use a dominant pole.  Instead the gbw sets the position of the open loop gain line at lower frequencies\n//(i.e. compute gbw as if the 20 dB/decade line keeps going through the 0 dB line)\n//The equation we start with is:\n// GBW/s * p0/(s+p0) * p1/(s+p1) * p2/(s+p2) * p3/(s+p3) * p4/(s+p4) * (s+z0)/z0 * (s+z1)/z1 * (s-rhpz)/rhpz\n// Because everything is a ratio we can dispense with converting everything with 2*PI\nfunction calculateComplexA_PolesAndZeroes(polesZeroes, sImaginary) {\n  var i;\n  var freq = sImaginary / (2 * Math.PI);\n\n  //Try to keep our complex number declarations to just these three, since each new complex number is quite expensive\n  var complexProduct = _complex.default.createComplex(0, 0);\n  var complexDenom = _complex.default.createComplex(0, 0);\n  var complexNum = _complex.default.createComplex(0, 0);\n\n  //GBW/s\n  complexProduct.real = 0;\n  complexProduct.imaginary = -1 * polesZeroes.gbw / freq;\n\n  //poles:  p[i]/(s+p[i])\n  for (i = 0; i < polesZeroes.p.length; i++) {\n    complexNum.real = polesZeroes.p[i];\n    complexNum.imaginary = 0;\n    complexDenom.real = polesZeroes.p[i];\n    complexDenom.imaginary = freq;\n    complexProduct = complexNum.divideDestroy(complexDenom).multDestroy(complexProduct);\n  }\n\n  //zeros:  (s+z[i])/z[i]\n  for (i = 0; i < polesZeroes.z.length; i++) {\n    complexNum.real = polesZeroes.z[i];\n    complexNum.imaginary = freq;\n    complexDenom.real = polesZeroes.z[i];\n    complexDenom.imaginary = 0;\n    complexProduct = complexNum.divideDestroy(complexDenom).multDestroy(complexProduct);\n  }\n\n  //right half plane zero:  (s-rhpz)/rhpz\n  if (polesZeroes.rhpz) {\n    complexNum.real = -1 * polesZeroes.rhpz;\n    complexNum.imaginary = freq;\n    complexDenom.real = -1 * polesZeroes.rhpz;\n    complexDenom.imaginary = 0;\n    complexProduct = complexNum.divideDestroy(complexDenom).multDestroy(complexProduct);\n  }\n  return complexProduct;\n}\nfunction calculateNoise(frequencyArray, stageInfo) {\n  var i, j;\n  var totalArray = [];\n  var stage1 = stageInfo.stage1;\n  var stage2 = stageInfo.stage2;\n  var results;\n  var stage1Keys = ['total', 'rf', 'rin', 'opAmpI', 'opAmpV'];\n  var stage2Keys = ['total', 'rf', 'rg', 'rfilter', 'opAmpI', 'opAmpV'];\n  var stage1Sums = {\n    total: 0,\n    rf: 0,\n    rin: 0,\n    opAmpI: 0,\n    opAmpV: 0\n  };\n  var stage2Sums = {\n    total: 0,\n    rf: 0,\n    rg: 0,\n    rfilter: 0,\n    opAmpI: 0,\n    opAmpV: 0\n  };\n  var key = '';\n  var individualStage1Spectrals = {\n    total: [],\n    rf: [],\n    rin: [],\n    opAmpI: [],\n    opAmpV: []\n  };\n  var individualStage2Spectrals = {\n    total: [],\n    rf: [],\n    rg: [],\n    rfilter: [],\n    opAmpI: [],\n    opAmpV: []\n  };\n\n  //console.log(stage2);\n  for (i = 0; i < frequencyArray.length; i++) {\n    results = this.calculateSpectralDensityForOneFrequency(frequencyArray[i], stage1, stage2);\n\n    //arrays for graphing.  Plot all the data as agreed for ARNA-5363\n    for (j = 0; j < stage1Keys.length; j++) {\n      key = stage1Keys[j];\n      individualStage1Spectrals[key].push([frequencyArray[i], results.stage1[key]]);\n    }\n    if (results.stage2.total > 0) {\n      for (j = 0; j < stage2Keys.length; j++) {\n        key = stage2Keys[j];\n        individualStage2Spectrals[key].push([frequencyArray[i], results.stage2[key]]);\n      }\n    }\n    totalArray.push([frequencyArray[i], results.total]);\n  }\n\n  //RMS noise calculations\n  let halfOfTheFrequencies = getColumnFrom2DArray(totalArray, 0);\n  let totalRMSNoise = computeRMSNoiseFromSpectralArray(halfOfTheFrequencies, getColumnFrom2DArray(totalArray, 1));\n  for (j = 0; j < stage1Keys.length; j++) {\n    key = stage1Keys[j];\n    stage1Sums[key] = computeRMSNoiseFromSpectralArray(halfOfTheFrequencies, getColumnFrom2DArray(individualStage1Spectrals[key], 1));\n  }\n  if (results.stage2.total > 0) {\n    for (j = 0; j < stage2Keys.length; j++) {\n      key = stage2Keys[j];\n      stage2Sums[key] = computeRMSNoiseFromSpectralArray(halfOfTheFrequencies, getColumnFrom2DArray(individualStage2Spectrals[key], 1));\n    }\n  }\n  var graphLines = [totalArray, individualStage1Spectrals.opAmpV, individualStage1Spectrals.opAmpI, individualStage1Spectrals.rf, individualStage1Spectrals.rin, individualStage2Spectrals.opAmpV, individualStage2Spectrals.opAmpI, individualStage2Spectrals.rf, individualStage2Spectrals.rg, individualStage2Spectrals.rfilter];\n  return {\n    total: totalRMSNoise,\n    stage1: stage1Sums,\n    stage2: stage2Sums,\n    graphLines: graphLines\n  };\n}\nfunction getColumnFrom2DArray(array2D, columnIndex) {\n  return array2D.map(row => row[columnIndex]);\n}\nfunction calculateSNR(rmsNoise, peakToPeakV) {\n  'use strict';\n\n  var peakRMS = peakToPeakV / (2 * Math.sqrt(2));\n  var SNR_VperV = peakRMS / rmsNoise;\n  var SNR_dB = 20 * AdiMath.logBaseTen(SNR_VperV);\n  return SNR_dB;\n}\n\n//This function does the well known:\n//ENOB = (SINAD - 1.76) / 6.02\n//But assume 0 distoration and use SNR instead of SINAD\n//Since we have a computer we also compute the long form of 1.76 and 6.02.  Since it's a cheap calculation, might as well be accurate.\nfunction calculateENOB(SNR) {\n  'use strict';\n\n  var onePtSevenSix = 10 * AdiMath.logBaseTen(3 / 2); //1.76\n  var sixPtZeroTwo = 20 * AdiMath.logBaseTen(2); //6.02\n  var ENOB = (SNR - onePtSevenSix) / sixPtZeroTwo;\n  return ENOB;\n}\n\n//Computes a single RMS number from an array of spectral noise points\n//Spectral noise points do not need to be evenly spaced\n//Algorithm: For maximum accuracy we determine the midpoints between frequencies in the array.  For each point in the array we then compute the rms noise from the\n//midpoint below to the midpoint above.  This is probably overkill.  If we find this is too many calculations, it's probably find to just do\n//away with the midpoint calculations and just compute in the span from one point from the next.  We'd be a little less accurate (because all the multiplication is on one side\n//of a point rather than having it in the middle.)  But probably not a big enough error to matter.\n//frequencyArray:  array of frequencies in Hz, each point in frequency array is the frequency of the corresponding point in spectralNoiseArray\n//spectralNoiseArray: array of spectral noises in V/rt(Hz)\n//Returns rmsNoise, a single number in Vrms\n\n//Potential unit test:\n// testFrequencies = [1, 2, 5, 10, 20, 50, 100];\n// testSpectrals =   [1, 1, 1,  1,  1,  1,   1];\n// Expected result: 9.9498743710662\n\nfunction computeRMSNoiseFromSpectralArray(frequencyArray, spectralNoiseArray) {\n  //Will start measuring exactly at frequencyArray[0], so only look at energy from frequency[0] to midPointAbove\n  let midPointBelow = frequencyArray[0];\n  let rmsNoise = 0;\n  let midPointAbove, rmsNoiseSinglePoint;\n  for (let i = 0; i < frequencyArray.length - 1; i++) {\n    midPointAbove = Math.sqrt(frequencyArray[i] * frequencyArray[i + 1]);\n    rmsNoiseSinglePoint = spectralNoiseArray[i] * Math.sqrt(midPointAbove - midPointBelow);\n    rmsNoise = Math.sqrt(rmsNoise * rmsNoise + rmsNoiseSinglePoint * rmsNoiseSinglePoint);\n    midPointBelow = midPointAbove;\n  }\n\n  //Last point\n  //We want to stop rms calculation exactly at last frequency point, so only look at energy from midPointBelow to last frequency point \n  midPointAbove = frequencyArray[frequencyArray.length - 1];\n  rmsNoiseSinglePoint = spectralNoiseArray[spectralNoiseArray.length - 1] * Math.sqrt(midPointAbove - midPointBelow);\n  rmsNoise = Math.sqrt(rmsNoise * rmsNoise + rmsNoiseSinglePoint * rmsNoiseSinglePoint);\n  return rmsNoise;\n}\n\n//This utility function take a spectral density and the square root of a frequency span, calculates the rms noise for that span,\n//and then adds it to an existing rms sum\nfunction addSpectralToRMSSum(frequencySpanRoot, oldTotalNoise, spectralDensity) {\n  var noiseInterval = spectralDensity * frequencySpanRoot;\n  var newTotalNoise = Math.sqrt(noiseInterval * noiseInterval + oldTotalNoise * oldTotalNoise);\n  return newTotalNoise;\n}\nfunction calculateSpectralDensityForOneFrequency(frequency, stage1, stage2) {\n  var noiseGain;\n  var spectralNoise;\n  var stage1noise, stage2noise;\n  var complexAlpha = this.calculateComplexAlpha_TIA(frequency, stage1);\n  var complexBeta = this.calculateComplexBeta_TIA(frequency, stage1);\n  var complexA = this.calculateComplexA(frequency, stage1);\n\n  /************ Stage 1 calculations  ****/\n  //calculate op amp voltage noise\n\n  if (stage1.opAmp.feedbackMethod === 'Current') {\n    complexAlpha = this.calculateAlphaForCFBVoltageNoise(stage1, frequency);\n    noiseGain = this.calculateOpAmpVoltageNoiseGain(complexA, complexBeta, complexAlpha);\n  } else {\n    noiseGain = this.calculateOpAmpVoltageNoiseGain(complexA, complexBeta);\n  }\n  spectralNoise = stage1.opAmp.vNoise;\n  var opAmpVnoise = noiseGain * spectralNoise;\n  var opAmpVGain = noiseGain;\n\n  //calculate op amp current noise\n  noiseGain = this.calculateOpAmpCurrentNoiseGain_TIA(complexA, complexBeta, complexAlpha);\n  spectralNoise = stage1.opAmp.iNoise;\n  var opAmpInoise = noiseGain * spectralNoise;\n  var opAmpIGain = noiseGain;\n\n  //calculate rf noise\n  noiseGain = this.calculateRfNoiseGain_TIA(complexA, complexBeta, complexAlpha, stage1);\n  spectralNoise = Math.sqrt(stage1.rf / 1000) * 4.058e-9;\n  var rfNoise = noiseGain * spectralNoise;\n  var rfGain = noiseGain;\n\n  //calculate rin noise\n  noiseGain = this.calculateRinNoiseGain(complexA, complexBeta, complexAlpha, stage1);\n  spectralNoise = Math.sqrt(stage1.rin / 1000) * 4.058e-9;\n  var rinNoise = noiseGain * spectralNoise;\n  var rinGain = noiseGain;\n\n  //sum everything together\n  var totalSpectralDensity = Math.sqrt(opAmpVnoise * opAmpVnoise + opAmpInoise * opAmpInoise + rfNoise * rfNoise + rinNoise * rinNoise);\n  stage1noise = {\n    total: totalSpectralDensity,\n    rf: rfNoise,\n    rin: rinNoise,\n    opAmpI: opAmpInoise,\n    opAmpV: opAmpVnoise,\n    complexAlpha: complexAlpha,\n    complexBeta: complexBeta,\n    complexA: complexA,\n    opAmpVGain: opAmpVGain,\n    opAmpIGain: opAmpIGain,\n    rfGain: rfGain,\n    rinGain: rinGain\n  };\n\n  /************* Stage 2 calculations *********/\n  if (stage2 !== null && stage2 !== undefined) {\n    complexAlpha = this.calculateComplexAlpha_Stage2(frequency, stage2);\n    complexBeta = this.calculateComplexBeta_Stage2(frequency, stage2);\n    complexA = this.calculateComplexA(frequency, stage2);\n\n    //calculate op amp voltage noise\n    noiseGain = this.calculateOpAmpVoltageNoiseGain(complexA, complexBeta);\n    spectralNoise = stage2.opAmp.vNoise;\n    opAmpVnoise = noiseGain * spectralNoise;\n\n    //calculate op amp current noise\n    noiseGain = this.calculateOpAmpCurrentNoiseGain_Stage2(complexA, complexBeta, complexAlpha, stage2);\n    spectralNoise = stage2.opAmp.iNoise;\n    opAmpInoise = noiseGain * spectralNoise;\n\n    //calculate rf noise\n    noiseGain = this.calculateRfNoiseGain_Stage2(complexA, complexBeta, complexAlpha, stage2);\n    spectralNoise = Math.sqrt(stage2.rf / 1000) * 4.058e-9;\n    rfNoise = noiseGain * spectralNoise;\n\n    //calculate rg noise\n    noiseGain = this.calculateRgNoiseGain_Stage2(complexA, complexBeta, complexAlpha, stage2);\n    spectralNoise = Math.sqrt(stage2.rg / 1000) * 4.058e-9;\n    var rgNoise = noiseGain * spectralNoise;\n\n    //calculate rfilter noise\n    if (stage2.rfilter !== null && stage2.rfilter !== undefined) {\n      noiseGain = this.calculateRfilterNoiseGain(complexA, complexBeta, complexAlpha, stage2);\n      spectralNoise = Math.sqrt(stage2.rfilter / 1000) * 4.058e-9;\n    } else {\n      spectralNoise = 0;\n      noiseGain = 0;\n    }\n    var rfilterNoise = noiseGain * spectralNoise;\n\n    //sum everything together\n    totalSpectralDensity = Math.sqrt(opAmpVnoise * opAmpVnoise + opAmpInoise * opAmpInoise + rfNoise * rfNoise + rgNoise * rgNoise + rfilterNoise * rfilterNoise);\n    var stage2gain = this.calculateClosedLoopGain(complexA, complexBeta, complexAlpha);\n    stage2noise = {\n      total: totalSpectralDensity,\n      rf: rfNoise,\n      rg: rgNoise,\n      rfilter: rfilterNoise,\n      opAmpI: opAmpInoise,\n      opAmpV: opAmpVnoise,\n      complexAlpha: complexAlpha,\n      complexBeta: complexBeta,\n      complexA: complexA,\n      gain: stage2gain\n    };\n\n    //now refer all stage 1 values to output\n    stage1noise.total *= stage2gain;\n    stage1noise.rf *= stage2gain;\n    stage1noise.rin *= stage2gain;\n    stage1noise.opAmpI *= stage2gain;\n    stage1noise.opAmpV *= stage2gain;\n  } else {\n    stage2noise = {\n      total: 0,\n      rf: 0,\n      rg: 0,\n      rfilter: 0,\n      opAmpI: 0,\n      opAmpV: 0\n    };\n  }\n  var totalNoise = Math.sqrt(stage1noise.total * stage1noise.total + stage2noise.total * stage2noise.total);\n  return {\n    total: totalNoise,\n    stage1: stage1noise,\n    stage2: stage2noise\n  };\n}\n\n//Calculates the gain for the photodiode current (i.e the transfer function)\n//This is A*alpha/(1+A*beta)\n//Returns complex value\nfunction calculateComplexClosedLoopGain(complexA, complexBeta, complexAlpha) {\n  'use strict';\n\n  //get A/(1+A*beta)\n  var complexTemporary = complexA.mult(complexBeta);\n  complexTemporary.real++;\n  complexTemporary = complexA.divideDestroy(complexTemporary);\n\n  // now make it alpha*A/(1+A*beta)\n  var complexClosedLoopGain = complexAlpha.multDestroy(complexTemporary);\n  return complexClosedLoopGain;\n}\n\n//Calculates the gain for the photodiode current (i.e the transfer function)\n//This is A*alpha/(1+A*beta)\n//Returns magnitude\nfunction calculateClosedLoopGain(complexA, complexBeta, complexAlpha) {\n  let complexMagnitude = this.calculateComplexClosedLoopGain(complexA, complexBeta, complexAlpha);\n  return complexMagnitude.magnitude();\n}\n\n//This function performs:  A/(1+A*beta) or alpha * A / (1+A*beta) in the CFB case where complexAlpha is defined\nfunction calculateOpAmpVoltageNoiseGain(complexA, complexBeta, complexAlpha) {\n  'use strict';\n\n  var complexTemporary = complexA.mult(complexBeta);\n  complexTemporary.real++;\n  complexTemporary = complexA.divideDestroy(complexTemporary);\n  if (complexAlpha !== undefined) {\n    complexTemporary = complexAlpha.multDestroy(complexTemporary);\n  }\n  var noiseGain = complexTemporary.magnitude();\n  return noiseGain;\n}\n\n//Current noise gain is exactly the same as the closed loop gain, so just call that and return magnitude\nfunction calculateOpAmpCurrentNoiseGain_TIA(complexA, complexBeta, complexAlpha) {\n  return this.calculateClosedLoopGain(complexA, complexBeta, complexAlpha);\n}\n\n//Current noise gain easy if it's inverting configuration, more complicated with noninverting\nfunction calculateOpAmpCurrentNoiseGain_Stage2(complexA, complexBeta, complexAlpha, stage) {\n  'use strict';\n\n  var iGain;\n\n  //Alpha for noninverting section needs to include both rf || rg impedance as well as cfilter || rfilter impedance\n  if (stage.rfilter !== undefined) {\n    //first calculate current noise for inverting input:\n    var complexRfRg = _complex.default.createComplex(stage.rf * stage.rg / (stage.rf + stage.rg), 0);\n    var invertingIgain = this.calculateClosedLoopGain(complexA, complexBeta, complexRfRg);\n    //now noninverting input:\n    var complexRfilter = _complex.default.createComplex(stage.rfilter, 0);\n    var complexFilterImpedance = complexAlpha.multDestroy(complexRfilter);\n    var noninvertingIgain = this.calculateClosedLoopGain(complexA, complexBeta, complexFilterImpedance);\n    //add together\n    iGain = Math.sqrt(invertingIgain * invertingIgain + noninvertingIgain * noninvertingIgain);\n  } else {\n    //inverting configuration.   Multiple original alpha by rf to convert voltage divider to parallel\n    var complexRf = _complex.default.createComplex(stage.rf, 0);\n    var iGainAlpha = complexAlpha.multDestroy(complexRf);\n    iGain = this.calculateClosedLoopGain(complexA, complexBeta, iGainAlpha);\n  }\n  return iGain;\n}\n\n//This function performs:  rfAlpha*A/(1+A*beta)\n//rfAlpha has the same pole as the circuit's alpha, but has a gain of Rin/(Rin+Rf) rather than Rf||Rin\n//Therefore we divide the circuit alpha by Rf to get the rfAlpha\nfunction calculateRfNoiseGain_TIA(complexA, complexBeta, complexAlpha, stage) {\n  var complexRf = _complex.default.createComplex(stage.rf, 0);\n  var complexRfAlpha = complexAlpha.divideDestroy(complexRf);\n\n  //now that we have a new complexAlpha, we can use the same math as the calculateClosedLoopGain function\n  return this.calculateClosedLoopGain(complexA, complexBeta, complexRfAlpha);\n}\nfunction calculateRfNoiseGain_Stage2(complexA, complexBeta, complexAlpha, stage) {\n  'use strict';\n\n  var complexRfAlpha;\n\n  //noninverting\n  if (stage.rfilter !== undefined) {\n    complexRfAlpha = complexBeta;\n  }\n  //inverting\n  else {\n    var rfOverRg = stage.rf / stage.rg;\n    complexRfAlpha = _complex.default.createComplex(rfOverRg * complexAlpha.real, rfOverRg * complexAlpha.imaginary);\n  }\n\n  //now that we have a new complexAlpha, we can use the same math as the calculateClosedLoopGain function\n  return this.calculateClosedLoopGain(complexA, complexBeta, complexRfAlpha);\n}\nfunction calculateRgNoiseGain_Stage2(complexA, complexBeta, complexAlpha, stage) {\n  'use strict';\n\n  var complexRgAlpha;\n\n  //noninverting\n  if (stage.rfilter !== undefined) {\n    var rfOverRg = stage.rf / stage.rg;\n    complexRgAlpha = _complex.default.createComplex(rfOverRg * complexBeta.real, rfOverRg * complexBeta.imaginary);\n  }\n  //inverting\n  else {\n    complexRgAlpha = complexAlpha;\n  }\n\n  //now that we have a new complexAlpha, we can use the same math as the calculateClosedLoopGain function\n  return this.calculateClosedLoopGain(complexA, complexBeta, complexRgAlpha);\n}\n\n//rfilter noise gain is same as the transfer function of 2nd stage\nfunction calculateRfilterNoiseGain(complexA, complexBeta, complexAlpha, stage) {\n  //noninverting\n  if (stage.rfilter !== undefined) return this.calculateClosedLoopGain(complexA, complexBeta, complexAlpha);\n  //inverting, this resistor doesn't exist\n  else return 0;\n}\n\n//This function performs:  rinAlpha*A/(1+A*beta)\n//rinAlpha has the same pole as the circuit's alpha, but has a gain of Rf/(Rin+Rf) rather than Rf||Rin\n//Therefore we divide the circuit alpha by Rin to get the rfAlpha\nfunction calculateRinNoiseGain(complexA, complexBeta, complexAlpha, stage) {\n  'use strict';\n\n  var complexRin = _complex.default.createComplex(stage.rin, 0);\n  var complexRinAlpha = complexAlpha.divideDestroy(complexRin);\n  var complexDenom = complexAlpha.mult(complexBeta);\n  complexDenom.real++;\n  var complexRinNoiseGain = complexA.multDestroy(complexRinAlpha).divideDestroy(complexDenom);\n  return complexRinNoiseGain.magnitude();\n}\nfunction getActualFpFq(loopFp, loopQ, stagesObject, inputValues) {\n  var actualFp, actualQ;\n\n  //Compute frequency range - we don't need near the amount of points we use for graphing to get a pretty good approximation, so no sense using the typical frequency range, since it will make things slower.\n  // We'll just use 50 points.\n  var startFreq = loopFp / 5;\n  var stopFreq = loopFp * 2;\n  var pointsPerDecade = 50;\n  var newFreqPoints = Common.frequencyPoint(startFreq, stopFreq, pointsPerDecade); //call to frequency point function\n\n  //create simplex array\n  var fpArray = [loopFp, loopFp * 0.99, loopFp * 0.99, loopFp, loopFp * 0.96];\n  var qArray = [loopQ, loopQ * 1.005, loopQ, loopQ * 1.01, loopQ * 1.1];\n  var pointsInfpArray = fpArray.length;\n  var errorArray = [];\n\n  //create error simplex by comparing ideal frequency response generated with fp and Q vs. actual magnitude response\n  let magnitudeArray = this.createMagnitudeArray(newFreqPoints, stagesObject, inputValues, false);\n  for (var j = 0; j < pointsInfpArray; j++) {\n    errorArray[j] = Common.calculateNelderMeadError(newFreqPoints, fpArray[j], qArray[j], magnitudeArray);\n  }\n\n  //Implementation of NELDER MEAD STATE MACHINE\n  var centerOfGravityFp = 0,\n    centerOfGravityQ = 0,\n    state = 'centerOfGravity',\n    reflectedFp,\n    reflectedQ,\n    reflectedError,\n    expandedFp,\n    expandedQ,\n    expandedError,\n    contractedFp,\n    contractedQ,\n    contractedError,\n    fpQErrorObj = [],\n    fpQErr = [],\n    errorPercentCheck = false,\n    fpArraylen = fpArray.length,\n    qArraylen = qArray.length,\n    errLen = errorArray.length,\n    count = 0;\n  for (var k = 0; k < errLen; k++) {\n    fpQErrorObj.push({\n      fp: fpArray[k],\n      q: Number(qArray[k]),\n      error: Number(errorArray[k])\n    });\n  }\n  fpQErr = Common.sortErrorArray(fpQErrorObj);\n  do {\n    if (state == 'centerOfGravity') {\n      //finding the average of fpArray, except for last point\n      var sumFp = 0;\n      var avgFp;\n      for (let i = 0; i < fpArraylen - 1; i++) {\n        sumFp += fpQErr[i].fp;\n      }\n      avgFp = sumFp / (fpArraylen - 1);\n      centerOfGravityFp = avgFp;\n      var sumQ = 0;\n      var avgQ;\n      for (let i = 0; i < qArraylen - 1; i++) {\n        sumQ += Number(fpQErr[i].q);\n      }\n      avgQ = sumQ / (qArraylen - 1);\n      centerOfGravityQ = avgQ;\n      reflectedFp = 2 * centerOfGravityFp - fpQErr[fpArraylen - 1].fp;\n      reflectedQ = 2 * centerOfGravityQ - Number(fpQErr[qArraylen - 1].q);\n      reflectedError = Common.calculateNelderMeadError(newFreqPoints, reflectedFp, reflectedQ, magnitudeArray);\n\n      //checking if reflectedError is smaller than any points in ErrorArray\n      errLen = fpQErr.length;\n      if (reflectedError < fpQErr[0].error) {\n        state = 'expansion';\n      } else if (reflectedError >= fpQErr[errLen - 2].error) {\n        state = 'contraction';\n      } else {\n        fpQErr[fpArraylen - 1].fp = reflectedFp;\n        fpQErr[qArraylen - 1].q = reflectedQ;\n        fpQErr[errLen - 1].error = reflectedError;\n        state = 'centerOfGravity';\n      }\n    }\n    if (state == 'expansion') {\n      expandedFp = 3 * centerOfGravityFp - 2 * fpQErr[fpArraylen - 1].fp;\n      expandedQ = 3 * centerOfGravityQ - 2 * Number(fpQErr[qArraylen - 1].q);\n      expandedError = Common.calculateNelderMeadError(newFreqPoints, expandedFp, expandedQ, magnitudeArray);\n      if (expandedError < reflectedError) {\n        fpQErr[fpArraylen - 1].fp = expandedFp;\n        fpQErr[qArraylen - 1].q = expandedQ;\n        fpQErr[errLen - 1].error = expandedError;\n      } else {\n        fpQErr[fpArraylen - 1].fp = reflectedFp;\n        fpQErr[qArraylen - 1].q = reflectedQ;\n        fpQErr[errLen - 1].error = reflectedError;\n      }\n    }\n    if (state == 'contraction') {\n      contractedFp = 0.5 * centerOfGravityFp + 0.5 * fpQErr[fpArraylen - 1].fp;\n      contractedQ = 0.5 * centerOfGravityQ + 0.5 * Number(fpQErr[qArraylen - 1].q);\n      contractedError = Common.calculateNelderMeadError(newFreqPoints, contractedFp, contractedQ, magnitudeArray);\n      if (contractedError < fpQErr[errLen - 1].error) {\n        fpQErr[fpArraylen - 1].fp = contractedFp;\n        fpQErr[qArraylen - 1].q = contractedQ;\n        fpQErr[errLen - 1].error = contractedError;\n      } else {\n        for (let j = 1; j < fpArraylen; j++) {\n          fpQErr[j].fp = fpQErr[0].fp + 0.5 * (fpQErr[j].fp - fpQErr[0].fp);\n          fpQErr[j].q = Number(fpQErr[0].q) + 0.5 * (Number(fpQErr[j].q) - Number(fpQErr[0].q));\n          fpQErr[j].error = Common.calculateNelderMeadError(newFreqPoints, fpQErr[j].fp, fpQErr[j].q, magnitudeArray);\n        }\n      }\n    }\n\n    // sort the error array\n    var fpQErr1 = Common.sortErrorArray(fpQErr);\n    fpQErr = fpQErr1;\n\n    // check the error percent\n    errorPercentCheck = Common.checkErrorPercent(fpQErr);\n    count++;\n    if (count == 1000 || fpQErr[0].error < 1e-6) {\n      //if ((count == 1000)) {\n      break;\n    } else {\n      state = 'centerOfGravity';\n    }\n  } while (errorPercentCheck == false); // check if all errors in error array lies between 1% of each other and number of iterations >1000\n  actualFp = fpQErr[0].fp; // first point in fp array\n  actualQ = fpQErr[0].q; // first point in q array\n\n  return [actualFp, actualQ];\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.MaxArray = MaxArray;\nexports.MinArray = MinArray;\nexports.convolve = convolve;\nexports.cosh = cosh;\nexports.getBaseLog = getBaseLog;\nexports.getLogMidPoint = getLogMidPoint;\nexports.inverseFourier = inverseFourier;\nexports.logBaseTen = logBaseTen;\nexports.sinh = sinh;\nfunction sinh(number) {\n  var x = number;\n  var expNumber = Math.exp(x);\n  var expNegNumber = Math.exp(-x);\n  var sinhNumber = (expNumber - expNegNumber) / 2;\n  return sinhNumber;\n}\nfunction cosh(number) {\n  var x = number;\n  var expNumber = Math.exp(x);\n  var expNegNumber = Math.exp(-x);\n  var coshNumber = (expNumber + expNegNumber) / 2;\n  return coshNumber;\n}\nfunction logBaseTen(your_log) {\n  var result = Math.log(your_log) / Math.log(10);\n  return result;\n}\nfunction getBaseLog(x, y) {\n  return Math.log(y) / Math.log(x);\n}\nfunction convolve(xArr, yArr) {\n  var resultArray = [];\n  var nLength = xArr.length;\n  var mLength = yArr.length;\n  for (var i = 0, j = 0; i < mLength; i++) {\n    var result = 0;\n    for (var k = 0; k < nLength; k++) {\n      j = i - k;\n      if (j >= 0 && j < mLength) result += xArr[k] * yArr[j];else break;\n    }\n    resultArray[i] = result;\n  }\n  return resultArray;\n}\nfunction getLogMidPoint(maxVal, minVal) {\n  var val = 0;\n  var avg = (this.logBaseTen(maxVal) + this.logBaseTen(minVal)) / 2;\n  val = Math.pow(10, avg);\n  return val;\n}\nfunction MaxArray(array) {\n  return Math.max.apply(Math, array);\n}\nfunction MinArray(array) {\n  return Math.min.apply(Math, array);\n}\nfunction inverseFourier(complexFreqDomainArray, freqStep, numTimePoints, expectedEndPoint) {\n  var freqDomainLength = complexFreqDomainArray.length;\n  var pi = Math.PI;\n  var xArray = [];\n  var yArrayImpulse = [];\n  var yArrayStep = [];\n  var timestep = 1 / (freqStep * complexFreqDomainArray.length);\n  var integrationSum = 0;\n  for (var i = 0; i < numTimePoints; i++) {\n    var runningSum = 0;\n    for (var j = 0; j < freqDomainLength; j++) {\n      //set up multiplier, which has magnitude 1 and varying phase. (i.e imagine corkscrew)\n      //number of multipler cycles would equal j, if we used symetrical frequency domain array\n      //however to save calculations we don't mirror frequency array.\n      //So # of multipler cycles is j/2. This means we set up phase with pi, rather than pi/2\n      var multiplier_phase = pi * i * j / freqDomainLength;\n      var multiplier_real = Math.cos(multiplier_phase);\n      var multiplier_imag = Math.sin(multiplier_phase);\n      var result_real = multiplier_real * complexFreqDomainArray[j].real - multiplier_imag * complexFreqDomainArray[j].imaginary;\n      runningSum += result_real;\n    }\n    xArray.push(i * timestep / 2);\n    yArrayImpulse.push(runningSum / freqDomainLength);\n    if (i !== 0) {\n      integrationSum += (yArrayImpulse[i] + yArrayImpulse[i - 1]) / 2;\n      yArrayStep.push(integrationSum);\n    } else {\n      yArrayStep.push(0);\n    }\n  }\n  var endPointError = yArrayStep[yArrayStep.length - 1] - expectedEndPoint;\n  var errorCorrection = endPointError / numTimePoints;\n  yArrayStep = [];\n  integrationSum = 0;\n  for (i = 0; i < numTimePoints; i++) {\n    yArrayImpulse[i] -= errorCorrection;\n    if (i !== 0) {\n      integrationSum += (yArrayImpulse[i] + yArrayImpulse[i - 1]) / 2;\n      yArrayStep.push(integrationSum);\n    } else {\n      yArrayStep.push(0);\n    }\n  }\n  return [xArray, yArrayStep, yArrayImpulse];\n}\n\n// NOT used\n// PRIVATE FUNCTIONS\n// function asinh(arg) {\n//     return Math.log(arg + Math.sqrt(arg * arg + 1));\n// }\n\n// function aCosh(arg) {\n//     return Math.log(arg + Math.sqrt(arg * arg - 1));\n// }","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _default = exports.default = {\n  amp_status_bias_current_is: \"amp_status_bias_current_is\",\n  amp_status_big_2nd_stage_gain: \"amp_status_big_2nd_stage_gain\",\n  amp_status_cf_less_50fF: \"amp_status_cf_less_50fF\",\n  amp_status_cf_less_100fF: \"amp_status_cf_less_100fF\",\n  amp_status_cfb_no_cf: \"amp_status_cfb_no_cf\",\n  amp_status_cfb_rf_too_small: \"amp_status_cfb_rf_too_small\",\n  amp_status_dB_error: \"amp_status_dB_error\",\n  amp_status_gbw_less_than_bandwith_requested: \"amp_status_gbw_less_than_bandwith_requested\",\n  amp_status_high_vos: \"amp_status_high_vos\",\n  amp_status_min_stable_gain: \"amp_status_min_stable_gain\",\n  amp_status_negative_cf: \"amp_status_negative_cf\",\n  amp_status_not_allowed: \"amp_status_not_allowed\",\n  amp_status_not_enough_peaking: \"amp_status_not_enough_peaking\",\n  amp_status_not_fast_enough: \"amp_status_not_fast_enough\",\n  amp_status_not_recommended: \"amp_status_not_recommended\",\n  amp_status_quad: \"amp_status_quad\",\n  amp_status_internal_cf_too_high: \"amp_status_internal_cf_too_high\",\n  amp_status_recommended: \"amp_status_recommended\",\n  amp_status_slew_rate_low: \"amp_status_slew_rate_low\",\n  amp_status_slew_rate_marginal: \"amp_status_slew_rate_marginal\",\n  amp_status_specialty_amp: \"amp_status_specialty_amp\",\n  amp_status_too_fast: \"amp_status_too_fast\",\n  amp_status_voltage_not_enough: \"amp_status_voltage_not_enough\",\n  amp_status_zero_drift: \"amp_status_zero_drift\",\n  fixed_op_amp_no_good: \"fixed_op_amp_no_good\",\n  no_op_amps_available_for_single_stage_too_fast: \"no_op_amps_available_for_single_stage_too_fast\",\n  no_op_amps_available_for_single_stage_too_slow: \"no_op_amps_available_for_single_stage_too_slow\",\n  no_op_amps_available_for_first_stage_too_fast: \"no_op_amps_available_for_first_stage_too_fast\",\n  no_op_amps_available_for_first_stage_too_slow: \"no_op_amps_available_for_first_stage_too_slow\",\n  no_op_amps_available_for_second_stage: \"no_op_amps_available_for_second_stage\",\n  rf_too_high: \"rf_too_high\",\n  currentCalculation_peak_light_error: \"currentCalculation_peak_light_error\",\n  currentCalculation_peak_photodiode_error: \"currentCalculation_peak_photodiode_error\",\n  amp_status_not_recommended_for_new_designs: \"amp_status_not_recommended_for_new_designs\",\n  amp_status_last_time_buy: \"amp_status_last_time_buy\",\n  amp_status_obsolete: \"amp_status_obsolete\"\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.billOfMaterials = billOfMaterials;\nexports.getAvailableOpAmps = getAvailableOpAmps;\nexports.getCircuitDesignModel = getCircuitDesignModel;\nexports.getCircuitGraphData = getCircuitGraphData;\nexports.getResult = getResult;\nexports.getSchematicFromInput = getSchematicFromInput;\nexports.setModelError = setModelError;\nvar _modelError = _interopRequireDefault(require(\"./models/model-error\"));\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nvar _stages = require(\"./stages\");\nvar Graphs = _interopRequireWildcard(require(\"./graphs\"));\nvar Common = _interopRequireWildcard(require(\"./common\"));\nvar StepResponse = _interopRequireWildcard(require(\"./step-response\"));\nvar Recommendations = _interopRequireWildcard(require(\"./recommendations\"));\nvar NextSteps = _interopRequireWildcard(require(\"./next-steps\"));\nvar Solver = _interopRequireWildcard(require(\"./solver\"));\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\n// import ErrorCodes from \"./error-codes\";\n\nfunction getAvailableOpAmps(opAmpDb, Vr, Bias, Cd, Rsh, Ip, sensor, peakVoltage, speed, peaking, numberOfStages, stage1OpAmpName, stageIndex) {\n  return Recommendations.getAvailableOpAmps(opAmpDb, Vr, Bias, Cd, Rsh, Ip, sensor, peakVoltage, speed, peaking, numberOfStages, stage1OpAmpName, stageIndex);\n}\nfunction billOfMaterials(stagesObject, stagesPreference, sensor) {\n  return NextSteps.billOfMaterials(stagesObject, stagesPreference, sensor);\n}\nfunction getCircuitDesignModel(inputValues, opAmpDB) {\n  var results;\n  if (inputValues.stages === _photodiodeConstants.default.pdStages.oneStage) {\n    if (inputValues.opAmps && inputValues.opAmps.length > 0 && inputValues.opAmps[0] !== null && inputValues.opAmps[0] !== undefined) {\n      results = (0, _stages.calculateOneStage_FixedOpAmp)(inputValues, opAmpDB);\n    } else {\n      results = (0, _stages.calculateOneStage_FindOpAmp)(inputValues, opAmpDB);\n    }\n  } else {\n    if (inputValues.opAmps && inputValues.opAmps.length > 0 && inputValues.opAmps[0] !== null && inputValues.opAmps[0] !== undefined) results = (0, _stages.calculateTwoStages_FixedOpAmp)(inputValues, opAmpDB);else {\n      results = (0, _stages.calculateTwoStages_FindOpAmp)(inputValues, opAmpDB);\n    }\n  }\n  if (results instanceof _modelError.default) return results;\n  return {\n    stage1: results.stage1,\n    stage2: results.stage2\n  };\n}\nfunction getCircuitGraphData(inputValues, opAmpDB, stagesObject) {\n  var roughBW = Graphs.getRoughBW(stagesObject);\n  var magnitudeArray = [],\n    frequencyArray = [],\n    //startFrequency = inputValues.speed / 100,\n    //stopFrequency = inputValues.speed * 1000,\n    startFrequency = roughBW / 100,\n    stopFrequency = roughBW * 100,\n    dynamicRangeObj = {};\n\n  // calculate frequency\n  const decade = Math.log10(stopFrequency) - Math.log10(startFrequency);\n  frequencyArray = Common.friendlyFrequency(startFrequency, stopFrequency, decade);\n\n  //calculate magnitude\n  magnitudeArray = Graphs.createMagnitudeArray(frequencyArray, stagesObject, inputValues);\n\n  //               var stepResponseResults = AdiCm.PD.lib.StepResponse.stepResponse(inputValues, opAmpDB, stagesObject);\n  var stepResponseResults = StepResponse.pulseResponse(inputValues, opAmpDB, stagesObject);\n  var timeAxis = stepResponseResults[0];\n  var stepResponseArray = stepResponseResults[1];\n  var riseTime = stepResponseResults[2];\n  var overshoot = stepResponseResults[3];\n  var vPeak = inputValues.peakVoltage;\n  var noiseResults = Graphs.calculateNoise(frequencyArray, stagesObject); //Use the outputs for the \"Noise Contributors\" in the SNR tab \n  //noiseResults.total also used for Minimum Signal - Noise Floor\n  var minPhotoCurrent = noiseResults.total / vPeak * inputValues.peakCurrent; //Use for Minimum Signal - Photodiode Current \n  //calculate quick results\n  var snr = Graphs.calculateSNR(noiseResults.total, vPeak);\n  var enob = Graphs.calculateENOB(snr);\n  var outputOffset = Solver.calculateOutputOffset(stagesObject);\n  dynamicRangeObj = {\n    snr: snr,\n    enob: enob,\n    outputOffset: outputOffset,\n    noise: noiseResults,\n    minPhotoCurrent: minPhotoCurrent\n  };\n  return {\n    stagesObject: stagesObject,\n    frequency: frequencyArray,\n    magnitude: magnitudeArray,\n    timeAxis: timeAxis,\n    stepResponse: stepResponseArray,\n    riseTime: riseTime,\n    overshoot: overshoot,\n    dynamicRange: dynamicRangeObj\n  };\n}\nfunction getResult(opampDb, Vr, Bias, Cd, Rsh, Ip, sensor, peakVoltage, speed, peaking, numberOfStages, opamp1, opamp2, requireRecommended /*, isFirstTime*/) {\n  let opAmps = [opamp1, opamp2];\n  let inputValues = {\n    sensor: sensor,\n    reverseVoltage: Vr,\n    biasPreference: Bias,\n    capacitance: Cd,\n    shuntResistance: Rsh,\n    peakCurrent: Ip,\n    peakVoltage: peakVoltage,\n    speed: speed,\n    peaking: peaking,\n    stages: numberOfStages,\n    opAmps: opAmps,\n    requireRecommended: requireRecommended\n  };\n  let circuitData = this.getCircuitDesignModel(inputValues, opampDb);\n  if (circuitData instanceof _modelError.default) return circuitData;\n  let graphData = this.getCircuitGraphData(inputValues, opampDb, circuitData);\n  return graphData;\n}\nfunction getSchematicFromInput(Vr, Bias, Cd, Rsh, Ip, Photodiode) {\n  let vBias = Bias == '-' ? -Vr : Vr;\n  let circuitName = Bias == '-' ? _photodiodeConstants.default.pdCircuits.oneStageNegative : _photodiodeConstants.default.pdCircuits.oneStagePositive;\n  return {\n    vr: Vr,\n    vBias: vBias,\n    cd: Cd,\n    rsh: Rsh,\n    ip: Ip,\n    photodiodeName: Photodiode,\n    circuitName: circuitName\n  };\n}\nfunction setModelError(errorObject) {\n  return errorObject.errorParameter ? new _modelError.default(errorObject.errorCode, errorObject.errorParameter) : new _modelError.default(errorObject.errorCode);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nclass ModelError {\n  ErrorCode; //string;\n  ErrorMessage; // string;\n  ErrorParameter;\n  constructor(errorCode, errorParameter, errorMessage) {\n    this.ErrorCode = errorCode;\n    this.ErrorMessage = errorMessage;\n    this.ErrorParameter = errorParameter;\n  }\n}\nexports.default = ModelError;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.billOfMaterials = billOfMaterials;\nexports.opAmpSparesByPassCapacitors = opAmpSparesByPassCapacitors;\nexports.referenceDesignator = referenceDesignator;\nvar _prettyNum = _interopRequireDefault(require(\"@ebiz/pretty-num\"));\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction referenceDesignator(opAmp, name, value) {\n  let refDesignator = \"\";\n  switch (name) {\n    case _photodiodeConstants.default.circuitComponents.Cf:\n      {\n        refDesignator = [\"Cf\", value + \"F\"];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.Rf:\n      {\n        refDesignator = [\"Rf\", value + \"\\u2126\"];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.Rg2:\n      {\n        refDesignator = [\"Rg2\", value + \"\\u2126\"];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.Rf2:\n      {\n        refDesignator = [\"Rf2\", value + \"\\u2126\"];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.Cfilter:\n      {\n        refDesignator = [\"Cfilter\", value + \"F\"];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.Rfilter:\n      {\n        refDesignator = [\"Rfilter\", value + \"\\u2126\"];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.D1:\n      {\n        refDesignator = [\"D1\", value];\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.OpAmp1:\n      {\n        if (opAmp.numberChannels && parseInt(opAmp.numberChannels) > 1) {\n          refDesignator = [\"1/\" + opAmp.numberChannels + \" \" + value, \"U1\"];\n        } else {\n          refDesignator = [value, \"U1\"];\n        }\n        break;\n      }\n    case _photodiodeConstants.default.circuitComponents.OpAmp2:\n      {\n        if (opAmp.numberChannels && parseInt(opAmp.numberChannels) > 1) {\n          refDesignator = [\"1/\" + opAmp.numberChannels + \" \" + value, \"U2\"];\n        } else {\n          refDesignator = [value, \"U2\"];\n        }\n        break;\n      }\n  }\n  return refDesignator;\n}\nfunction opAmpSparesByPassCapacitors(stagesObject, stagesPreference) {\n  let byPassCapacitors = new Array(),\n    opAmpSpares = new Array(),\n    tantCapacitors = new Array(),\n    retObject = [];\n  byPassCapacitors.push({\n    name: \"Cbp+\",\n    value: 100e-9,\n    type: \"positive\"\n  });\n  byPassCapacitors.push({\n    name: \"Cbp-\",\n    value: 100e-9,\n    type: \"negative\"\n  });\n  var opAmp1 = stagesObject.stage1.opAmp;\n\n  // first stage op amp spares\n  if (opAmp1.numberChannels > 1) {\n    let len = opAmp1.numberChannels - 1;\n    for (let i = 0; i < len; i++) {\n      // add spare opAmp\n      opAmpSpares.push({\n        name: \"U1\",\n        value: \"1/\" + opAmp1.numberChannels + \" \" + opAmp1.partNumber\n      });\n    }\n  }\n\n  // 2 stages\n  if (stagesPreference == _photodiodeConstants.default.pdStages.twoStage) {\n    let opAmp2 = stagesObject.stage2.opAmp;\n    byPassCapacitors.push({\n      name: \"Cbp2+\",\n      value: 100e-9,\n      type: \"positive\"\n    });\n    byPassCapacitors.push({\n      name: \"Cbp2-\",\n      value: 100e-9,\n      type: \"negative\"\n    });\n\n    //If we are using the same part for each stage, then assume using the same package for each stage and remove the extra spares\n    if (opAmp2.partNumber === opAmp1.partNumber) {\n      opAmpSpares.pop();\n    } else if (opAmp2.numberChannels > 1) {\n      let len = opAmp2.numberChannels - 1;\n      for (let i = 0; i < len; i++) {\n        // add spare opAmp\n        opAmpSpares.push({\n          name: \"U1\",\n          value: \"1/\" + opAmp2.numberChannels + \" \" + opAmp2.partNumber\n        });\n      }\n    }\n  }\n  tantCapacitors.push({\n    name: \"Ctant+\",\n    value: 10e-6,\n    type: \"positive\"\n  });\n  tantCapacitors.push({\n    name: \"Ctant-\",\n    value: 10e-6,\n    type: \"negative\"\n  });\n  retObject = {\n    opAmpSpares: opAmpSpares,\n    byPassCapacitors: byPassCapacitors,\n    tantCapacitors: tantCapacitors\n  };\n  return retObject;\n}\nfunction billOfMaterials(stagesObject, stagesPreference, sensor) {\n  var billOfMaterialsResistorArray = new Array(),\n    billOfMaterialsCapacitorArray = new Array(),\n    billOfMaterialsOpAmpArray = new Array(),\n    validCapacitors = new Array(),\n    validResistors = new Array(),\n    billOfMaterialArray = new Array(),\n    resistorTable,\n    capacitorTable,\n    opAmpTable,\n    byPassCapsSpareOpAmps,\n    byPassCapacitors,\n    tantCapacitors,\n    resistorTolerance = '0.5%',\n    capacitorTolerance = '5%',\n    bypassCapacitorTolerance = '20%';\n\n  // get capacitors and resitors for first stage\n  validCapacitors.push({\n    name: _photodiodeConstants.default.circuitComponents.Cf,\n    value: stagesObject.stage1.cfext\n  });\n  validResistors.push({\n    name: _photodiodeConstants.default.circuitComponents.Rf,\n    value: stagesObject.stage1.rf\n  });\n\n  // get capacitors and resitors for second stage if there are 2 stages\n  if (stagesPreference == _photodiodeConstants.default.pdStages.twoStage) {\n    //if we are using a voltage follower for the 2nd stage, we don't want to print out rf2 or rg2\n    if (stagesObject.stage2.rf !== 0) {\n      validResistors.push({\n        name: _photodiodeConstants.default.circuitComponents.Rg2,\n        value: stagesObject.stage2.rg\n      });\n      validResistors.push({\n        name: _photodiodeConstants.default.circuitComponents.Rf2,\n        value: stagesObject.stage2.rf\n      });\n    }\n    validCapacitors.push({\n      name: _photodiodeConstants.default.circuitComponents.Cfilter,\n      value: stagesObject.stage2.cfilter\n    });\n    if (stagesObject.stage2.rfilter != undefined) {\n      validResistors.push({\n        name: _photodiodeConstants.default.circuitComponents.Rfilter,\n        value: stagesObject.stage2.rfilter\n      });\n    }\n  }\n\n  // get bill of materials object of all the resistors\n  for (let j = 0; j < validResistors.length; j++) {\n    let materialAndPackageResistor = materialAndPackageForResistors(resistorTolerance);\n    billOfMaterialsResistorArray.push({\n      refDesignator: validResistors[j].name,\n      value: validResistors[j].value,\n      prodURL: null,\n      package: materialAndPackageResistor.package,\n      material: materialAndPackageResistor.material,\n      tolerance: resistorTolerance\n    });\n  }\n\n  // get bill of materials object for all the capacitors \n  for (let k = 0; k < validCapacitors.length; k++) {\n    // eslint-disable-next-line no-unused-vars\n    let refDesignatorCapacitor = this.referenceDesignator(stagesObject.stage1.opAmp, validCapacitors[k].name, validCapacitors[k].value);\n    let materialAndPackageCapacitor = materialAndPackageForCapacitors(validCapacitors[k].value, capacitorTolerance, false);\n    billOfMaterialsCapacitorArray.push({\n      refDesignator: validCapacitors[k].name,\n      value: validCapacitors[k].value,\n      prodURL: null,\n      package: materialAndPackageCapacitor.package,\n      material: materialAndPackageCapacitor.material,\n      tolerance: capacitorTolerance\n    });\n  }\n\n  // get the bill of materials object for first stage op amp\n  let PackageAndMaterialsOpAmp1 = materialAndPackageForOpAmps(stagesObject.stage1.opAmp);\n  billOfMaterialsOpAmpArray.push({\n    refDesignator: 'U1',\n    value: stagesObject.stage1.opAmp.partNumber,\n    prodURL: stagesObject.stage1.opAmp.generic.toUpperCase() + \".html\",\n    package: PackageAndMaterialsOpAmp1.package,\n    material: PackageAndMaterialsOpAmp1.material,\n    tolerance: \"\"\n  });\n  if (stagesPreference == _photodiodeConstants.default.pdStages.twoStage) {\n    // get the bill of materials object for second stage op amp\n    let PackageAndMaterialsOpAmp2 = materialAndPackageForOpAmps(stagesObject.stage2.opAmp);\n    billOfMaterialsOpAmpArray.push({\n      refDesignator: 'U2',\n      value: stagesObject.stage2.opAmp.partNumber,\n      prodURL: stagesObject.stage2.opAmp.generic.toUpperCase() + \".html\",\n      package: PackageAndMaterialsOpAmp2.package,\n      material: PackageAndMaterialsOpAmp2.material,\n      tolerance: \"\"\n    });\n  }\n\n  // get bypass capacitors\n  byPassCapsSpareOpAmps = this.opAmpSparesByPassCapacitors(stagesObject, stagesPreference);\n  byPassCapacitors = byPassCapsSpareOpAmps.byPassCapacitors;\n  tantCapacitors = byPassCapsSpareOpAmps.tantCapacitors;\n\n  //loop through byPass capacitors to get the bill of materials object\n  for (let i = 0; i < byPassCapacitors.length; i++) {\n    let byPassCapMaterialsAndPackage = materialAndPackageForCapacitors(byPassCapacitors[i].value, bypassCapacitorTolerance, false);\n    //fix for if value is a engineering string, rather than number\n    if (typeof byPassCapacitors[i].value === \"string\") {\n      var bypassCapString = byPassCapacitors[i].value;\n      bypassCapString = bypassCapString.slice(0, -1);\n      byPassCapacitors[i].value = _prettyNum.default.userEntryToNumber(bypassCapString, \"Engineering\", 3)[0];\n    }\n    billOfMaterialsCapacitorArray.push({\n      refDesignator: byPassCapacitors[i].name,\n      value: byPassCapacitors[i].value,\n      prodURL: null,\n      package: byPassCapMaterialsAndPackage.package,\n      material: byPassCapMaterialsAndPackage.material,\n      tolerance: bypassCapacitorTolerance\n    });\n  }\n\n  //loop through tantalum capacitors to get the bill of materials object\n  for (let m = 0; m < tantCapacitors.length; m++) {\n    //fix for if value is a engineering string, rather than number\n    if (typeof tantCapacitors[m].value === \"string\") {\n      let tantCapString = tantCapacitors[m].value;\n      tantCapString = tantCapString.slice(0, -1);\n      tantCapacitors[m].value = _prettyNum.default.userEntryToNumber(tantCapString, \"Engineering\", 3)[0];\n    }\n    billOfMaterialsCapacitorArray.push({\n      refDesignator: tantCapacitors[m].name,\n      value: tantCapacitors[m].value,\n      prodURL: null,\n      package: \"6032\",\n      material: \"tantalum\",\n      tolerance: \"20%\"\n    });\n  }\n\n  // get the bill of materials object for photodiode/sensor\n  let sensorValue = sensor == '' || sensor.length == 0 ? \"Custom\" : sensor;\n  let billOfMaterialsSensor = {\n    count: 1,\n    designators: ['D1'],\n    value: sensorValue,\n    prodURL: null,\n    package: \"\",\n    tolerance: \"\",\n    material: \"\"\n  };\n\n  // getting the bill Of Material grouping for resistor array table and adding the unit for resistors\n  resistorTable = billOfMaterialsTable(billOfMaterialsResistorArray, true, \"Ω\");\n\n  // getting the bill of Material grouping for capacitor array table and adding the unit for capacitors\n  capacitorTable = billOfMaterialsTable(billOfMaterialsCapacitorArray, true, \"F\");\n\n  // getting the bill of material grouping for opAmp table\n  opAmpTable = billOfMaterialsTable(billOfMaterialsOpAmpArray, false, null);\n\n  // add sensor to op amps table\n  opAmpTable.push(billOfMaterialsSensor);\n\n  // merge all objects into one final bill of materials object array\n  billOfMaterialArray = resistorTable.concat(capacitorTable.concat(opAmpTable));\n  return billOfMaterialArray;\n}\n\n//Private functions\nfunction materialAndPackageForResistors(toleranceValue) {\n  let pkg,\n    material,\n    retObject = [];\n  if (toleranceValue <= _photodiodeConstants.default.resistorTolerance.fiveTenths) {\n    pkg = \"0603\";\n    material = \"Thin Film\";\n  } else {\n    pkg = \"0603\";\n    material = \"\";\n  }\n  retObject = {\n    package: pkg,\n    material: material\n  };\n  return retObject;\n}\nfunction materialAndPackageForOpAmps(opAmp) {\n  let pkg,\n    material,\n    retObject = [];\n  material = \"\";\n  pkg = \"\";\n  if (opAmp.packageCode !== null && opAmp.packageCode.indexOf(\"R-8\") != -1) {\n    pkg = \"SOIC\";\n  } else if (opAmp.packageCode !== null && opAmp.packageCode.indexOf(\"RM-8\") != -1) {\n    pkg = \"MSOP\";\n  }\n  retObject = {\n    package: pkg,\n    material: material\n  };\n  return retObject;\n}\nfunction materialAndPackageForCapacitors(value, toleranceValue, boolReferenceBoard) {\n  var pkg = \"\",\n    material = \"\",\n    tolerance,\n    retObject = [];\n\n  //check if the tolerance is ideal and get the integer value of the tolerance to compare\n  if (toleranceValue != _photodiodeConstants.default.capacitorTolerance.ideal) {\n    tolerance = parseFloat(toleranceValue);\n  }\n  if (value <= 10 * 1e-9) {\n    material = \"C0G\";\n    pkg = \"0603\";\n  } else if (value > 10 * 1e-9 && value <= 100 * 1e-9 && tolerance <= 10) {\n    material = \"C0G\";\n    pkg = \"1206\";\n  } else if (value > 10 * 1e-9 && value <= 100 * 1e-9 && tolerance == 20) {\n    material = \"X7R\";\n    pkg = \"0603\";\n  } else if (value > 100 * 1e-9 && value < 10 * 1e-6) {\n    material = \"X7R\";\n    pkg = \"1206\";\n  } else if (value == 0.00001 && boolReferenceBoard == true) {\n    material = \"tantalum\";\n    pkg = \"6032\";\n  }\n  retObject = {\n    package: pkg,\n    material: material\n  };\n  return retObject;\n}\n\n// function groupBy(array, predicate) {\n//     var grouped = {};\n//     for (var i = 0; i < array.length; i++) {\n//         var groupKey = predicate(array[i]);\n//         if (typeof (grouped[groupKey]) === \"undefined\")\n//             grouped[groupKey] = [];\n//         grouped[groupKey].push(array[i]);\n//     }\n\n//     return grouped;\n// }\n\nfunction billOfMaterialsTable(array, formatValue, unit) {\n  var billOfMaterialDisplay = new Array(),\n    arrayNew = new Array(),\n    arrayCount = new Array(),\n    dlist = \"\",\n    boolFound = false;\n  for (let i = 0; i < array.length; i++) {\n    let element = array[i];\n    element.refDesignator = [element.refDesignator];\n  }\n  let arrayClone = {\n    ...array[0]\n  };\n\n  // clone and push the first element of the array\n  arrayNew.push(arrayClone);\n  arrayCount.push(1);\n  for (var b = 1; b < array.length; b++) {\n    dlist = array[b].refDesignator;\n    boolFound = false;\n\n    // compare each element of array with the elements of arrayNew created\n    for (var i = 0; i < arrayNew.length; i++) {\n      if (array[b].value == arrayNew[i].value && array[b].tolerance == arrayNew[i].tolerance && array[b].package == arrayNew[i].package && array[b].material == arrayNew[i].material) {\n        arrayNew[i].refDesignator = arrayNew[i].refDesignator.concat(dlist);\n        if (array[b].count > 1) {\n          arrayCount[i]++;\n        }\n        arrayCount[i]++;\n        boolFound = true;\n        break;\n      }\n    }\n\n    // if boolFound is true, continue with the loop\n    if (boolFound) continue;\n\n    // if any element in from the array doesnt match with elements of arrayNew, clone and push it to arrayNew\n    var tempObj = {\n      ...array[b]\n    };\n    arrayNew.push(tempObj);\n    arrayCount.push(1);\n  }\n  for (var j = 0; j < arrayNew.length; j++) {\n    if (formatValue) {\n      arrayNew[j].value = _prettyNum.default.numberToUserDisplay(arrayNew[j].value, \"Engineering\", 5, {\n        supplySpace: true\n      }) + unit;\n    }\n\n    // push the elements of arrayNew to billOfMaterialsDisplay\n    billOfMaterialDisplay.push({\n      count: arrayCount[j],\n      designators: arrayNew[j].refDesignator,\n      value: arrayNew[j].value,\n      prodURL: arrayNew[j].prodURL,\n      package: arrayNew[j].package,\n      tolerance: arrayNew[j].tolerance,\n      material: arrayNew[j].material\n    });\n  }\n  return billOfMaterialDisplay;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nconst optimizationType = {\n  noise: \"Noise\",\n  voltageRange: \"VoltageRange\",\n  power: \"Power\",\n  recommendedSpecific: \"RecommendedSpecificComponents\",\n  allowedSpecific: \"AllowedSpecificComponents\"\n};\nconst Limits = {\n  RSMALL_LOAD_LIMIT: 50,\n  RSMALL_COMP_LIMIT: 1,\n  RBIG_COMP_LIMIT: 100000000,\n  CSMALL_COMP_LIMIT: 0,\n  CSMALL_COMP_1PF: 1e-12,\n  CBIG_COMP_LIMIT: 1e-5,\n  INFINITY: 1e66,\n  NEGINFINITY: -1e60\n};\nconst resistorTolerance = {\n  ideal: \"ideal\",\n  oneTenth: \"0.1%\",\n  fiveTenths: \"0.5%\",\n  one: \"1%\",\n  five: \"5%\"\n};\nconst capacitorTolerance = {\n  ideal: \"ideal\",\n  one: \"1%\",\n  five: \"5%\",\n  ten: \"10%\",\n  twenty: \"20%\"\n};\nconst opAmpStatus = {\n  allowed: \"allowed\",\n  notAllowed: \"not allowed\",\n  recommended: \"recommended\",\n  notRecommended: \"not recommended\"\n};\nconst biasPreferenceOptions = {\n  positive: \"positive\",\n  negative: \"negative\"\n};\nconst specialOpAmps = [{\n  partNumber: 'AD8099',\n  minGain: 20,\n  pole1: 6e8,\n  pole2: 2e9,\n  zero: 2e9,\n  compPin: true\n}, {\n  partNumber: 'AD8021',\n  minGain: 10,\n  pole1: 1e10,\n  pole2: 4.4e8,\n  zero: 4.5e8,\n  compPin: true\n}, {\n  partNumber: 'AD829',\n  minGain: 20,\n  pole1: 1e8,\n  pole2: 2e8,\n  zero: 2e8,\n  compPin: true\n}, {\n  partNumber: 'ADA4895-1',\n  minGain: 10,\n  pole1: 1e9,\n  pole2: 1e9,\n  zero: 1e9,\n  compPin: false\n}, {\n  partNumber: 'ADA4895-2',\n  minGain: 10,\n  pole1: 3e8,\n  pole2: 2e9,\n  zero: 1e9,\n  compPin: false\n}, {\n  partNumber: 'ADA4637-1',\n  minGain: 5,\n  pole1: 1e9,\n  pole2: 1e9,\n  zero: 1e9,\n  compPin: false\n}, {\n  partNumber: 'AD8067',\n  minGain: 8,\n  pole1: 1.5e8,\n  pole2: 2e8,\n  zero: 1.5e8,\n  compPin: false\n}, {\n  partNumber: 'AD8397',\n  minGain: 2,\n  pole1: 1.5e8,\n  pole2: 2.3e8,\n  zero: 2.3e8,\n  compPin: false\n}];\nconst filterType = {\n  lowPass: \"lowPass\",\n  highPass: \"highPass\",\n  bandPass: \"bandPass\",\n  bandStop: \"bandStop\",\n  gain: \"gain\",\n  notch: \"notch\"\n};\nconst pdStages = {\n  oneStage: 1,\n  twoStage: 2\n};\nconst pdCircuits = {\n  oneStagePositive: 'oneStagePositive',\n  oneStageNegative: 'oneStageNegative'\n};\nconst toggleUnits = {\n  vv: \"V/V\",\n  va: \"V/A\",\n  db: \"dB\"\n};\nconst circuitComponents = {\n  Cf: \"Cf\",\n  Rf: \"Rf\",\n  Rf2: \"Rf2\",\n  Rg2: \"Rg2\",\n  Cfilter: \"Cfilter\",\n  Rfilter: \"Rfilter\",\n  D1: \"D1\",\n  OpAmp1: \"OpAmp1\",\n  OpAmp2: \"OpAmp2\"\n};\nvar _default = exports.default = {\n  optimizationType,\n  Limits,\n  resistorTolerance,\n  capacitorTolerance,\n  opAmpStatus,\n  biasPreferenceOptions,\n  specialOpAmps,\n  filterType,\n  pdStages,\n  pdCircuits,\n  toggleUnits,\n  circuitComponents\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getAvailableOpAmps = getAvailableOpAmps;\nexports.getIdealOpAmp1 = getIdealOpAmp1;\nexports.getIdealOpAmp2 = getIdealOpAmp2;\nvar Stages = _interopRequireWildcard(require(\"./stages\"));\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nvar _messages = _interopRequireDefault(require(\"./messages\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction getAvailableOpAmps(opAmpDb, Vr, Bias, Cd, Rsh, Ip, sensor, peakVoltage, speed, peaking, numberOfStages, stage1OpAmpName, stageIndex) {\n  let inputValues = {\n    sensor: sensor,\n    reverseVoltage: Vr,\n    biasPreference: Bias,\n    capacitance: Cd,\n    shuntResistance: Rsh,\n    peakCurrent: Ip,\n    peakVoltage: peakVoltage,\n    speed: speed,\n    peaking: peaking,\n    stages: numberOfStages\n  };\n  let result = opAmpRecommendationStatus(opAmpDb, stageIndex, inputValues, stage1OpAmpName);\n  return result;\n}\nfunction getIdealOpAmp1(opAmpDb, Vr, Bias, Cd, Rsh, Ip, sensor, peakVoltage, speed, peaking, numberOfStages) {\n  let inputValues = {\n    sensor: sensor,\n    reverseVoltage: Vr,\n    biasPreference: Bias,\n    capacitance: Cd,\n    shuntResistance: Rsh,\n    peakCurrent: Ip,\n    peakVoltage: peakVoltage,\n    speed: speed,\n    peaking: peaking,\n    stages: numberOfStages\n  };\n  let result;\n  if (numberOfStages === _photodiodeConstants.default.pdStages.oneStage) {\n    result = Stages.findOpAmp(inputValues, opAmpDb);\n  } else {\n    result = Stages.findOpAmp1(inputValues, opAmpDb);\n  }\n  return result;\n}\nfunction getIdealOpAmp2(opAmpDb, Vr, Bias, Cd, Rsh, Ip, sensor, peakVoltage, speed, peaking, numberOfStages, stage1OpAmpPartNumber) {\n  let inputValues = {\n    sensor: sensor,\n    reverseVoltage: Vr,\n    biasPreference: Bias,\n    capacitance: Cd,\n    shuntResistance: Rsh,\n    peakCurrent: Ip,\n    peakVoltage: peakVoltage,\n    speed: speed,\n    peaking: peaking,\n    stages: numberOfStages\n  };\n  let result;\n  if (numberOfStages === _photodiodeConstants.default.pdStages.oneStage) {\n    result = null;\n  } else {\n    result = Stages.findOpAmp2(inputValues, opAmpDb, stage1OpAmpPartNumber);\n  }\n  return result;\n}\n\n//PRIVATE\nfunction opAmpRecommendationStatus(opAmpDB, stageIndex, userInputs, stage1OpAmpName) {\n  let result = [];\n  let stage1OpAmp;\n  for (let i = 0; i < opAmpDB.length; i++) {\n    let opAmp = opAmpDB[i];\n    let stageInfo;\n    if (stageIndex === 1 && userInputs.stages === _photodiodeConstants.default.pdStages.oneStage) {\n      stageInfo = Stages.stage1Info_SingleStage(Stages.oneStageRf(userInputs).rf, userInputs, opAmp);\n    } else if (stageIndex === 1 && userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n      stageInfo = Stages.stage1Info_DualStage(userInputs, opAmp);\n    } else if (stageIndex === 2 && userInputs.stages === _photodiodeConstants.default.pdStages.twoStage) {\n      if (!stage1OpAmp) {\n        for (let j = 0; j < opAmpDB.length; j++) {\n          if (opAmpDB[j].partNumber === stage1OpAmpName) {\n            stage1OpAmp = opAmpDB[j];\n            break;\n          }\n        }\n      }\n      stageInfo = Stages.stage2Info(userInputs, opAmp, stage1OpAmp);\n    } else {\n      return result;\n    }\n    let status = _messages.default.amp_status_recommended;\n    let comment = [];\n    let selectable = true;\n    let disallowed = false;\n    switch (stageInfo.status) {\n      case _photodiodeConstants.default.opAmpStatus.allowed:\n        status = _messages.default.amp_status_not_recommended;\n        selectable = true;\n        disallowed = false;\n        comment = stageInfo.statusMessage;\n        break;\n      case _photodiodeConstants.default.opAmpStatus.notAllowed:\n        status = _messages.default.amp_status_not_allowed;\n        selectable = false;\n        disallowed = true;\n        comment = stageInfo.statusMessage;\n        break;\n      case _photodiodeConstants.default.opAmpStatus.recommended:\n        status = _messages.default.amp_status_recommended;\n        selectable = true;\n        disallowed = false;\n        break;\n    }\n    var opAmpListItem = {\n      selectable: selectable,\n      disallowed: disallowed,\n      status: status,\n      comment: comment,\n      partNumber: opAmp.partNumber,\n      scdFlag: false\n    };\n    result.push(opAmpListItem);\n  }\n  return result;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.calculateOutputOffset = calculateOutputOffset;\nexports.solveBW = solveBW;\nexports.solveBW_CfFlexible = solveBW_CfFlexible;\nexports.solveCf_BWFlexible = solveCf_BWFlexible;\nexports.solveCf_RfFlexible = solveCf_RfFlexible;\nexports.solveQ = solveQ;\nexports.solveRf_CfFlexible = solveRf_CfFlexible;\n// Solves for TIA Cf when BW is flexible\nfunction solveCf_BWFlexible(Rf, Rin, Q, Cin, gbw) {\n  var GBWrad = gbw * 2 * Math.PI;\n  var undersqrt1 = 1 - 4 * Q * Q - 4 * Q * Q * Rf / Rin;\n  var undersqrt2 = 4 * Q * Q * GBWrad * Rf * Cin;\n  if (undersqrt1 + undersqrt2 < 0) {\n    Cf = -99;\n  } else {\n    var sqrtterm = Math.sqrt(undersqrt1 + undersqrt2);\n    var Cfdenom = 2 * Q * Q * Rf * GBWrad;\n    var Cf = (1 - 2 * Q * Q - 2 * Q * Q * Rf / Rin + sqrtterm) / Cfdenom;\n  }\n  return Cf;\n}\n\n// Solves for BW when Cf is flexible\nfunction solveBW_CfFlexible(Rf, Rin, Q, Cin, gbw) {\n  var GBWrad = gbw * 2 * Math.PI;\n  var undersqrt1 = 1 - 4 * Q * Q - 4 * Q * Q * Rf / Rin;\n  var undersqrt2 = 4 * Q * Q * GBWrad * Rf * Cin;\n  var sqrtterm = Math.sqrt(undersqrt1 + undersqrt2);\n  var wodenom = 2 * Q * (GBWrad * Rf * Cin - Rf / Rin - 1);\n  var wo = (sqrtterm - 1) * GBWrad / wodenom;\n  var bw = wo / (2 * Math.PI);\n  return bw;\n}\nfunction solveRf_CfFlexible(gbw, bw, cIn, rIn, Q) {\n  var gbwRad = gbw * 2 * Math.PI;\n  var wo = bw * 2 * Math.PI;\n  var num = rIn * (-wo * gbwRad + Q * gbwRad * gbwRad + Q * wo * wo);\n  var denom = Q * wo * wo * (-1 + gbwRad * rIn * cIn);\n  var rf = num / denom;\n  return rf;\n}\nfunction solveCf_RfFlexible(gbw, bw, cIn, rIn, Q) {\n  \"use strict\";\n\n  var gbwRad = gbw * 2 * Math.PI;\n  var wo = bw * 2 * Math.PI;\n  var num = rIn * cIn * wo * gbwRad - rIn * cIn * Q * wo * wo - Q * gbwRad;\n  var denom = (-wo * gbwRad + Q * gbwRad * gbwRad + Q * wo * wo) * rIn;\n  var cf = num / denom;\n  return cf;\n}\nfunction solveBW(cIn, rIn, cf, rf, gbw) {\n  var cTotal = cIn + cf;\n  var gbwRad = gbw * 2 * Math.PI;\n\n  //with extra pole from op amp\n  var wo = Math.sqrt(gbwRad / (1 / (2 * gbwRad) + rf * cTotal));\n  var BW = wo / (2 * Math.PI);\n  return BW;\n}\nfunction solveQ(cIn, rIn, cf, rf, gbw, BW) {\n  var wo = BW * 2 * Math.PI;\n  var cTotal = cIn + cf;\n  var gbwRad = gbw * 2 * Math.PI;\n  var num = wo * rIn * rf * cTotal;\n  var denom = rIn + rf + rIn * rf * gbwRad * cf;\n  var Q = num / denom;\n  return Q;\n}\n\n//calculates the offset at the output of the circuit, based on the\nfunction calculateOutputOffset(stagesObject) {\n  var vosRTO;\n  var stage1 = stagesObject.stage1;\n  var stage2 = stagesObject.stage2;\n\n  //Calculate offset from stage 1\n  var rPar = stage1.rin * stage1.rf / (stage1.rin + stage1.rf);\n  var biasError = rPar * stage1.opAmp.iBias;\n  var stage1vosRTI = biasError + stage1.opAmp.vos;\n  var gain = (stage1.rf + stage1.rin) / stage1.rin;\n  var stage1vosRTO = stage1vosRTI * gain;\n\n  //two stage configuration\n  var rpar = null;\n  var stage2vosRTI = null;\n  if (stage2 !== null && stage2 !== undefined) {\n    //noninverting configuration\n    if (stage2.rfilter !== undefined) {\n      rpar = stage2.rf * stage2.rg / (stage2.rg + stage2.rg);\n      gain = (stage2.rf + stage2.rg) / stage2.rg;\n      biasError = stage2.opAmp.iBias * (rpar + stage2.rfilter);\n      stage2vosRTI = biasError + stage2.opAmp.vos;\n      vosRTO = (stage2vosRTI + stage1vosRTO) * gain;\n    }\n    //inverting configuration\n    else {\n      rpar = stage2.rf * stage2.rg / (stage2.rg + stage2.rg);\n      var noisegain = (stage2.rf + stage2.rg) / stage2.rg;\n      gain = stage2.rf / stage2.rg;\n      biasError = stage2.opAmp.iBias * rpar;\n      stage2vosRTI = biasError + stage2.opAmp.vos;\n      vosRTO = stage2vosRTI * noisegain + stage1vosRTO * gain;\n    }\n  }\n  //one stage configuration\n  else {\n    vosRTO = stage1vosRTO;\n  }\n  return vosRTO;\n}\n\n// NOT Used\n// function solveBWTheHardWay(cIn, rIn, cf, rf, gbw, rout, rsh, cd) {\n//     var poleNumerator = (-rf * rout * cf) - (rf * rsh * cd) - (rf * rsh * cf) - (rout * rsh * cd);\n//     var poleNumeratorSquared = ((Math.pow(rf, 2)) * (Math.pow(rout, 2)) * (Math.pow(cf, 2)))\n//         - (2 * Math.pow(rf, 2) * rout * rsh * cd * cf)\n//         + (2 * Math.pow(rf, 2) * rout * rsh * Math.pow(cf, 2))\n//         + (Math.pow(rf, 2) * Math.pow(rsh, 2) * Math.pow(cd, 2))\n//         + (2 * Math.pow(rf, 2) * Math.pow(rsh, 2) * cd * cf)\n//         + (Math.pow(rf, 2) * Math.pow(rsh, 2) * Math.pow(cf, 2))\n//         - (2 * rf * Math.pow(rout, 2) * rsh * cd * cf)\n//         + (2 * rf * rout * Math.pow(rsh, 2) * Math.pow(cd, 2))\n//         - (2 * rf * rout * Math.pow(rsh, 2) * cd * cf)\n//         + (Math.pow(rout, 2) * Math.pow(rsh, 2) * Math.pow(cd, 2));\n//     var poleDenominator = rf * rout * rsh * cd * cf;\n//     var pole1 = -(poleNumerator + Math.sqrt(poleNumeratorSquared)) / (2 * poleDenominator);\n//     var pole2 = (-poleNumerator + Math.sqrt(poleNumeratorSquared)) / (2 * poleDenominator);\n\n//     var pole = Math.min(pole1, pole2);\n\n//     var gbwRad = gbw * 2 * Math.PI;\n//     var wo = Math.sqrt(gbwRad / (1 / (2 * gbwRad) + (1 / pole)));\n//     var BW = wo / (2 * Math.PI);\n\n//     // compare to easy way\n//     //var BWeasy = this.solveBW(cIn, rIn, cf, rf, gbw);\n\n//     return BW;\n// }","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.calculateOneStage_FindOpAmp = calculateOneStage_FindOpAmp;\nexports.calculateOneStage_FixedOpAmp = calculateOneStage_FixedOpAmp;\nexports.calculateTwoStages_FindOpAmp = calculateTwoStages_FindOpAmp;\nexports.calculateTwoStages_FixedOpAmp = calculateTwoStages_FixedOpAmp;\nexports.findOpAmp = findOpAmp;\nexports.findOpAmp1 = findOpAmp1;\nexports.findOpAmp2 = findOpAmp2;\nexports.oneStageRf = oneStageRf;\nexports.stage1Info_DualStage = stage1Info_DualStage;\nexports.stage1Info_SingleStage = stage1Info_SingleStage;\nexports.stage2Info = stage2Info;\nvar Common = _interopRequireWildcard(require(\"./common\"));\nvar Solver = _interopRequireWildcard(require(\"./solver\"));\nvar _circuit = require(\"./circuit\");\nvar _model = require(\"./model\");\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nvar _modelError = _interopRequireDefault(require(\"./models/model-error\"));\nvar _errorCodes = _interopRequireDefault(require(\"./error-codes\"));\nvar _messages = _interopRequireDefault(require(\"./messages\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction calculateOneStage_FindOpAmp(userInputs, opAmpDB) {\n  var i,\n    stage1 = null,\n    stage1Array = [],\n    needFaster = 0;\n\n  //Get our Rf\n  var results = oneStageRf(userInputs);\n\n  // check for errors\n  if (results instanceof _modelError.default) {\n    return results;\n  }\n\n  //no errors, proceed\n  var rf = results.rf;\n\n  //Get stage info for all op amps\n  for (i = 0; i < opAmpDB.length; i++) {\n    stage1 = stage1Info_SingleStage(rf, userInputs, opAmpDB[i]);\n    stage1Array.push(stage1);\n    needFaster += stage1.needFaster;\n  }\n\n  //Pick the highest scoring op amp out of the recommended list\n  results = (0, _circuit.pickOpAmp_TIA)(stage1Array, userInputs, opAmpDB, needFaster);\n\n  // check for errors\n  if (results instanceof _modelError.default) return results;\n  return {\n    stage1: results.stage1,\n    stage2: null\n  };\n}\nfunction findOpAmp(userInputs, opAmpDB) {\n  let result = calculateOneStage_FindOpAmp(userInputs, opAmpDB);\n  if (result instanceof _modelError.default) return result;\n  return result.stage1.opAmp;\n}\n\n// This function calculates the values for a single stage circuit when the op amp is already known\nfunction calculateOneStage_FixedOpAmp(userInputs, opAmpDB) {\n  var results,\n    rf,\n    i,\n    opAmpObject,\n    stage1 = null;\n  var errorObject = {\n    errorCode: \"\",\n    errorParameter: {},\n    notRecommendedAvailable: false\n  };\n\n  //Get our Rf\n  results = oneStageRf(userInputs);\n\n  // check for errors\n  if (results instanceof _modelError.default) return results;\n\n  //no errors, proceed\n  rf = results.rf;\n\n  //Find op amp object\n  var opAmpName = userInputs.opAmps[0];\n  for (i = 0; i < opAmpDB.length; i++) {\n    if (opAmpDB[i].partNumber === opAmpName) {\n      opAmpObject = opAmpDB[i];\n      break;\n    }\n  }\n\n  //Get stage info for our op amp\n  stage1 = stage1Info_SingleStage(rf, userInputs, opAmpObject);\n  if (stage1.cf > 0 && stage1.cfext < 0) {\n    errorObject.errorCode = _errorCodes.default.internalCfTooHigh;\n    errorObject.errorParameter.partName = stage1.opAmp.partNumber;\n    errorObject.errorParameter.cf = stage1.cf;\n    errorObject.errorParameter.cfint = stage1.cfint;\n    errorObject.errorParameter.cfext = stage1.cfext;\n    errorObject.errorParameter.statusMessage = stage1.statusMessage;\n    return (0, _model.setModelError)(errorObject);\n  } else {\n    if (stage1.status != _photodiodeConstants.default.opAmpStatus.allowed && stage1.status != _photodiodeConstants.default.opAmpStatus.recommended) {\n      errorObject.errorCode = _errorCodes.default.fixedOpAmpNoGood;\n      errorObject.errorParameter.partName = opAmpName;\n      errorObject.errorParameter.statusMessage = stage1.statusMessage;\n      return (0, _model.setModelError)(errorObject);\n    }\n  }\n  return {\n    stage1: stage1,\n    stage2: null\n  };\n}\n\n//This function generates the stage information for the user's inputs, given an rf and an opAmpObject\nfunction stage1Info_SingleStage(rf, userInputs, opAmpObject) {\n  var results, rIn, gbw;\n\n  //set up circuit calculations based on whether current or voltage feedback\n  if (opAmpObject.feedbackMethod === \"Current\" && opAmpObject.cfb) {\n    //if current feedback, we can use all the same voltage feedback equations if we just make these two changes:\n    rIn = opAmpObject.cfb.rIn;\n    gbw = opAmpObject.cfb.zbw / rIn;\n  } else {\n    rIn = userInputs.shuntResistance;\n    gbw = opAmpObject.gbw;\n  }\n\n  //calculate bandwidth and cf\n  var Q = userInputs.peaking;\n  var cDiff = opAmpObject.cDiff;\n  var cCm = opAmpObject.cCm;\n  var cIn = cDiff + cCm + userInputs.capacitance;\n  var bw = Solver.solveBW_CfFlexible(rf, rIn, Q, cIn, gbw);\n  var cf = Solver.solveCf_BWFlexible(rf, rIn, Q, cIn, gbw);\n  var cfint = opAmpObject.cfint;\n  var cfext = cf - cfint;\n\n  //convert cfext to standard value if it is larger than 1 pf.  If smaller, don't convert, with the assumption that parasitic\n  //capacitance screws things up anyway.\n  if (cfext > _photodiodeConstants.default.Limits.CSMALL_COMP_1PF) {\n    results = Common.capacitorBasedOnTolerance(cfext, _photodiodeConstants.default.capacitorTolerance.five);\n    cfext = results[0];\n    cf = cfext + cfint; //update cf using new cfext\n  }\n\n  //recompute bw and Q with new capacitor value\n  bw = Solver.solveBW(cIn, rIn, cf, rf, gbw);\n\n  //Solve for Q\n  Q = Solver.solveQ(cIn, rIn, cf, rf, opAmpObject.gbw, bw); //this is not terribly accurate, since it doesn't include op amp secondary pole effect on Q, but it's quick\n  var stage1Info = {\n    opAmp: opAmpObject,\n    bw: bw,\n    q: Q,\n    rf: rf,\n    cf: cf,\n    cfint: cfint,\n    cfext: cfext,\n    cin: cIn,\n    rin: rIn,\n    rinDisplay: userInputs.shuntResistance,\n    status: false,\n    statusMessage: \"\",\n    needFaster: false\n  };\n\n  //determine op amp status based on bw and cf\n  results = (0, _circuit.opAmpStatus_TIA)(stage1Info, userInputs);\n  stage1Info.status = results.status;\n  stage1Info.statusMessage = results.statusMessage;\n  stage1Info.needFaster = results.needFaster;\n\n  //return information to caller\n  return stage1Info;\n}\nfunction calculateTwoStages_FindOpAmp(userInputs, opAmpDB) {\n  var stage1 = null,\n    stage2 = null,\n    stage1Array = [],\n    results,\n    needSomeSpeed = 0;\n\n  /*Get stage1 info for all op amps*/\n  for (let i = 0; i < opAmpDB.length; i++) {\n    stage1 = stage1Info_DualStage(userInputs, opAmpDB[i]);\n    stage1Array.push(stage1);\n    needSomeSpeed += stage1.needFaster;\n  }\n\n  /*Pick the highest scoring op amp out of the recommended list for stage 1*/\n  results = (0, _circuit.pickOpAmp_TIA)(stage1Array, userInputs, opAmpDB, needSomeSpeed);\n  if (results instanceof _modelError.default) {\n    return results;\n  }\n  stage1 = results.stage1;\n\n  //if no errors, get 2nd stage\n  results = calculate2ndStage(userInputs, opAmpDB, stage1.opAmp);\n  if (results instanceof _modelError.default) return results;\n  stage2 = results.stage2;\n  return {\n    stage1: stage1,\n    stage2: stage2\n  };\n}\nfunction findOpAmp1(userInputs, opAmpDB) {\n  var stage1 = null,\n    stage1Array = [],\n    results,\n    needSomeSpeed = 0;\n\n  /*Get stage1 info for all op amps*/\n  for (let i = 0; i < opAmpDB.length; i++) {\n    stage1 = stage1Info_DualStage(userInputs, opAmpDB[i]);\n    stage1Array.push(stage1);\n    needSomeSpeed += stage1.needFaster;\n  }\n\n  /*Pick the highest scoring op amp out of the recommended list for stage 1*/\n  results = (0, _circuit.pickOpAmp_TIA)(stage1Array, userInputs, opAmpDB, needSomeSpeed);\n  if (results instanceof _modelError.default) return results;\n  stage1 = results.stage1;\n  return stage1.opAmp;\n}\nfunction findOpAmp2(userInputs, opAmpDb, stage1OpAmpPartNumber) {\n  var stage2;\n  var stage2Array = [];\n  let stage1OpAmpObject = opAmpDb.find(p => p.partNumber == stage1OpAmpPartNumber);\n  for (let i = 0; i < opAmpDb.length; i++) {\n    stage2 = stage2Info(userInputs, opAmpDb[i], stage1OpAmpObject);\n    stage2Array.push(stage2);\n  }\n  var results = pickOpAmp_2ndStage(stage2Array, opAmpDb, stage1OpAmpObject);\n  if (results instanceof _modelError.default) return results;\n  stage2 = results.stage2;\n  return stage2.opAmp;\n}\n\n//This function calculates the two stages if the first op amp is fixed\nfunction calculateTwoStages_FixedOpAmp(userInputs, opAmpDB) {\n  var results, i, opAmpObject;\n  var stage1 = null,\n    stage2 = null;\n  var errorObject = {\n    errorCode: \"\",\n    errorParameter: {},\n    notRecommendedAvailable: false\n  };\n\n  /*Find op amp object*/\n  var opAmpName = userInputs.opAmps[0];\n  for (i = 0; i < opAmpDB.length; i++) {\n    if (opAmpDB[i].partNumber === opAmpName) {\n      opAmpObject = opAmpDB[i];\n      break;\n    }\n  }\n\n  /*Get stage1 info for our op amp*/\n  stage1 = stage1Info_DualStage(userInputs, opAmpObject);\n\n  //show error message if no good op amp\n  if (stage1.status != _photodiodeConstants.default.opAmpStatus.allowed && stage1.status != _photodiodeConstants.default.opAmpStatus.recommended) {\n    errorObject.errorCode = _errorCodes.default.fixedOpAmpNoGood;\n    errorObject.errorParameter.partName = opAmpName;\n    errorObject.errorParameter.statusMessage = stage1.statusMessage;\n    return (0, _model.setModelError)(errorObject);\n  }\n\n  //get 2nd stage\n  results = calculate2ndStage(userInputs, opAmpDB, stage1.opAmp);\n  if (results instanceof _modelError.default) return results;\n  stage2 = results.stage2;\n  return {\n    stage1: stage1,\n    stage2: stage2\n  };\n}\nfunction stage1Info_DualStage(userInputs, opAmpObject) {\n  let bw = userInputs.speed;\n  let cDiff = opAmpObject.cDiff;\n  let cCm = opAmpObject.cCm;\n  let cIn = cDiff + cCm + userInputs.capacitance;\n  let Q = userInputs.peaking;\n  let gbw = computeGbw(opAmpObject);\n  let rIn = computeRin(userInputs, opAmpObject);\n  if (gbw <= bw) {\n    let status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    let statusMessage = [];\n    statusMessage.push({\n      key: _messages.default.amp_status_gbw_less_than_bandwith_requested\n    });\n    let needFaster = 2;\n    let stage1Info = {\n      status: status,\n      statusMessage: statusMessage,\n      opAmp: opAmpObject,\n      bw: bw,\n      q: Q,\n      rf: NaN,\n      cf: NaN,\n      cin: cIn,\n      rin: rIn,\n      needFaster: needFaster\n    };\n    return stage1Info;\n  }\n  let totalGain = computeTotalGain(userInputs);\n  let rfValues = computeRf(gbw, bw, cIn, rIn, Q, totalGain);\n  let rf = rfValues.standardRf;\n  let cf = computeCf(gbw, bw, cIn, rIn, Q, rfValues, totalGain);\n  var cfint = opAmpObject.cfint;\n  var cfext = cf - cfint;\n\n  //recompute bw and Q with new rf and cf values\n  let newBw = Solver.solveBW(cIn, rIn, cf, rf, gbw);\n  let newQ = Solver.solveQ(cIn, rIn, cf, rf, opAmpObject.gbw, newBw); //not terribly accurate, since doesn't include effect of secondary op amp pole, but fast\n\n  let stage1Info = {\n    opAmp: opAmpObject,\n    bw: newBw,\n    q: newQ,\n    rf: rf,\n    cf: cf,\n    cfint: cfint,\n    cfext: cfext,\n    cin: cIn,\n    rin: rIn,\n    rinDisplay: userInputs.shuntResistance,\n    status: false,\n    statusMessage: \"\",\n    needFaster: false\n  };\n  let results = (0, _circuit.opAmpStatus_TIA)(stage1Info, userInputs);\n  stage1Info.status = results.status;\n  stage1Info.statusMessage = results.statusMessage;\n  stage1Info.needFaster = results.needFaster;\n  return stage1Info;\n}\nfunction stage2Info(userInputs, opAmpObject, stage1OpAmpObject) {\n  let totalGain = computeTotalGain(userInputs);\n  let stage1Values = getStage1Values(userInputs, stage1OpAmpObject, totalGain);\n  let stage2Gain = totalGain / stage1Values.rf;\n  let rgPlusRf = Common.determineStartingR3R4Value(_photodiodeConstants.default.optimizationType.voltageRange, stage1Values.bw);\n\n  //if photodiode is biased negative, output of first stage is positive, so we need a non-inverting configuration\n  //else we have an inverting configuration.   Calculate noiseGain so we can use the same code for both.\n  let noiseGain;\n  if (userInputs.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.negative) {\n    noiseGain = stage2Gain;\n  } else {\n    noiseGain = stage2Gain + 1;\n  }\n  let rg;\n  let rf;\n  let results;\n  if (noiseGain > 2) {\n    //rf is bigger, so do it first\n    rf = rgPlusRf - rgPlusRf / noiseGain;\n    results = Common.resistorBasedOnTolerance(rf, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n    rf = results[0];\n    rg = rf / (noiseGain - 1);\n    results = Common.resistorBasedOnTolerance(rg, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n    rg = results[0];\n  } else if (noiseGain > 1.005) {\n    //rg is bigger so do it first\n    rg = rgPlusRf / noiseGain;\n    results = Common.resistorBasedOnTolerance(rg, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n    rg = results[0];\n    rf = rg * (noiseGain - 1);\n    results = Common.resistorBasedOnTolerance(rf, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n    rf = results[0];\n  } else {\n    rg = _photodiodeConstants.default.Limits.INFINITY;\n    rf = 0;\n  }\n  let stage1GBW = null;\n  let cfilter;\n  let rfilter;\n  if (userInputs.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.negative) {\n    if (stage1OpAmpObject.feedbackMethod === \"Current\" && stage1OpAmpObject.cfb) {\n      stage1GBW = stage1OpAmpObject.cfb.zbw / stage1OpAmpObject.cfb.rIn;\n    } else {\n      stage1GBW = stage1OpAmpObject.gbw;\n    }\n    var calculateRFIlterResults = calculateRFilter(stage1GBW, userInputs.speed);\n    //  results = calculateRFilter(stage1GBW, stage1.bw);\n    cfilter = calculateRFIlterResults.cfilter;\n    rfilter = calculateRFIlterResults.rfilter;\n  } else {\n    cfilter = 1 / (2 * Math.PI * rf * userInputs.speed);\n    //cfilter = 1 / (2 * Math.PI * rf * stage1.bw);\n    var capacitorBasedOnToleranceResults = Common.capacitorBasedOnTolerance(cfilter, _photodiodeConstants.default.capacitorTolerance.five);\n    cfilter = capacitorBasedOnToleranceResults[0];\n    rfilter = undefined;\n  }\n  var opAmpStatus2ndStageResults = opAmpStatus_2ndStage(rf, rg, userInputs, opAmpObject);\n  return {\n    status: opAmpStatus2ndStageResults.status,\n    statusMessage: opAmpStatus2ndStageResults.statusMessage,\n    opAmp: opAmpObject,\n    bw: stage1Values.bw,\n    rg: rg,\n    rf: rf,\n    cfilter: cfilter,\n    rfilter: rfilter\n  };\n}\n\n//Computes the feedback resistors, rf, for the transimpedance stage.\nfunction oneStageRf(userInputs) {\n  var rf, results;\n  var errorObject = {\n    errorCode: \"\",\n    errorParameter: {},\n    notRecommendedAvailable: false\n  };\n\n  //To avoid division by zero, this equation assumes peak current is nonzero.  Since we check for this when user inputs, should be safe assumption.\n  rf = userInputs.peakVoltage / userInputs.peakCurrent;\n  if (rf > _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT) {\n    errorObject.errorCode = _errorCodes.default.OneStage.oneStageRf.rfTooHigh;\n    return (0, _model.setModelError)(errorObject);\n  }\n  results = Common.resistorBasedOnTolerance(rf, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n  return {\n    rf: results[0]\n  };\n}\nfunction pickOpAmp_2ndStage(stage2Array, opAmpDB, stage1OpAmpObject) {\n  var stage2;\n  var errorObject = {\n    errorCode: \"\",\n    errorParameter: {},\n    notRecommendedAvailable: false\n  };\n  var lowestSupplyCurrent = 1e60;\n  for (var i = 0; i < stage2Array.length; i++) {\n    if (stage2Array[i].status === _photodiodeConstants.default.opAmpStatus.recommended) {\n      //if the op amp used in the first stage is recommended for the second stage, just use that one \n      if (stage2Array[i].opAmp.partNumber === stage1OpAmpObject.partNumber) {\n        stage2 = stage2Array[i];\n        lowestSupplyCurrent = opAmpDB[i].supplyCurrent;\n        break;\n      }\n      //otherwise pick the op amp with the lowest supply current that is still recommended\n      if (opAmpDB[i].supplyCurrent < lowestSupplyCurrent) {\n        lowestSupplyCurrent = opAmpDB[i].supplyCurrent;\n        stage2 = stage2Array[i];\n      }\n    }\n  }\n\n  //No op amps were recommended\n  if (lowestSupplyCurrent === 1e60) {\n    errorObject.errorCode = _errorCodes.default.TwoStage.pickOpAmp_2ndStage.noOpAmpAvailable;\n    return (0, _model.setModelError)(errorObject);\n  }\n  return {\n    stage2: stage2\n  };\n}\n\n//This function determines whether the TIA op amp is recommended, allowed, or not allowed\nfunction opAmpStatus_2ndStage(rf, rg, userInputs, opAmpObject) {\n  var notAllowedString = [];\n  var allowedString = [];\n  var status = _photodiodeConstants.default.opAmpStatus.recommended;\n  var statusMessage = [];\n  var slewrate = opAmpObject.slewRate;\n  var gbw = null;\n  if (opAmpObject.feedbackMethod === \"Current\" && opAmpObject.cfb) {\n    //if current feedback, we can use all the same voltage feedback equations if we just make these two changes:\n    rg = opAmpObject.cfb.rIn * rg / (opAmpObject.cfb.rIn + rg);\n    gbw = opAmpObject.cfb.zbw / rg;\n  } else {\n    gbw = opAmpObject.gbw;\n  }\n\n  //Check if we are below min slew rate.   If so, first set to \"allowed\".  If really bad, we'll set to \"not allowed\" later\n  var minSlewRate = Math.PI * 2 * userInputs.speed * userInputs.peakVoltage / 2 * userInputs.peaking;\n  if (opAmpObject.slewRate * 1e6 < minSlewRate && status === _photodiodeConstants.default.opAmpStatus.recommended) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_slew_rate_marginal\n    }); //\"slew rate marginal; \";\n  }\n\n  //AD8634 is a super expensive, high temp amp.   We want in the tool in case the high temp guys want it, but don't want\n  //to recommend.   (In reality, given its 200 nA bias current, highly unlikely to be used as photodiode amp, but just in case\n  if (opAmpObject.partNumber === \"AD8634\") {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_specialty_amp\n    }); //\"specialty amplifier; \"\n  }\n\n  // If status is Not Recommended for New Designs or Last Time Buy, you need to make this allowed\n  // instead of recommended\n  if (opAmpObject.deviceStatus === 4) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_not_recommended_for_new_designs\n    });\n  } else if (opAmpObject.deviceStatus === 5) {\n    status = _photodiodeConstants.default.opAmpStatus.allowed;\n    allowedString.push({\n      key: _messages.default.amp_status_last_time_buy\n    });\n  }\n\n  //Check output swing\n  var maxOpAmpOutput = opAmpObject.maxSupplyVoltage / 2 - opAmpObject.outHeadroomPlus;\n  if (userInputs.peakVoltage > maxOpAmpOutput) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_voltage_not_enough\n    }); //\"voltage range not enough for peak output voltage; \";\n  }\n\n  //Check if gain bandwidth is high enough\n  var noiseGain = 1 + rf / rg;\n  var gbwNeeded = noiseGain * userInputs.speed;\n  if (gbw < gbwNeeded) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_not_fast_enough\n    }); // \"not fast enough; \";\n  }\n\n  //only check for slew rate if we haven't failed already (if op amp not fast enough, telling user slew rate is also no good is redundant)\n  minSlewRate = minSlewRate * 0.8; //  Allow for slightly slower slew rates.  This makes marginal slew rate op amps \"not recommended\".\n  if (slewrate * 1e6 < minSlewRate && status !== _photodiodeConstants.default.opAmpStatus.notAllowed) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_slew_rate_low\n    }); //\"slew rate too low; \";\n  }\n  if (opAmpObject.feedbackMethod === \"Current\") {\n    if (userInputs.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.positive) {\n      //inverting configuration uses a capacitor in the feedback path: a no-no for current feedback parts\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_cfb_no_cf\n      });\n    }\n    if (rf < opAmpObject.cfb.minRf) {\n      status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n      notAllowedString.push({\n        key: _messages.default.amp_status_cfb_rf_too_small\n      });\n    }\n  }\n\n  //In inverting configuration, only allow gain=1 stable op amps, since we have cap in feedback path.\n  //In non-inverting configuration, we only allow op amps with min stable gain less than noise gain.\n  var minStableGain = opAmpObject.minStableGain;\n  if (userInputs.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.positive && minStableGain > 1 || minStableGain > noiseGain) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_min_stable_gain,\n      data: opAmpObject.minStableGain\n    }); //\"Min stable gain = __;\"\n  }\n\n  // If status is Obsolete, the op amp becomes not allowed\n  if (opAmpObject.deviceStatus === 6) {\n    status = _photodiodeConstants.default.opAmpStatus.notAllowed;\n    notAllowedString.push({\n      key: _messages.default.amp_status_obsolete\n    });\n  }\n  if (status === _photodiodeConstants.default.opAmpStatus.notAllowed) statusMessage = notAllowedString; //remove last semicolon and space\n  else if (status === _photodiodeConstants.default.opAmpStatus.allowed) statusMessage = allowedString; //remove last semicolon and space\n\n  return {\n    status: status,\n    statusMessage: statusMessage\n  };\n}\nfunction calculate2ndStage(userInputs, opAmpDB, stage1OpAmpObject) {\n  var opAmpObject, i, stage2;\n  var stage2Array = [];\n  var errorObject = {\n    errorCode: \"\",\n    errorParameter: {},\n    notRecommendedAvailable: false\n  };\n\n  //If 2nd stage is locked\n  if (userInputs.opAmps[1]) {\n    /*Find op amp object*/\n    var opAmpName = userInputs.opAmps[1];\n    for (i = 0; i < opAmpDB.length; i++) {\n      if (opAmpDB[i].partNumber === opAmpName) {\n        opAmpObject = opAmpDB[i];\n        break;\n      }\n    }\n    stage2 = stage2Info(userInputs, opAmpObject, stage1OpAmpObject);\n    if (stage2.status != _photodiodeConstants.default.opAmpStatus.allowed && stage2.status != _photodiodeConstants.default.opAmpStatus.recommended) {\n      errorObject.errorCode = _errorCodes.default.fixedOpAmpNoGood;\n      errorObject.errorParameter.partName = opAmpName;\n      errorObject.errorParameter.statusMessage = stage2.statusMessage;\n      return (0, _model.setModelError)(errorObject);\n    }\n  }\n\n  //if 2nd stage is unlocked, find a good op amp\n  else {\n    //Get stage2 info for all op amps*/\n    for (i = 0; i < opAmpDB.length; i++) {\n      stage2 = stage2Info(userInputs, opAmpDB[i], stage1OpAmpObject);\n      stage2Array.push(stage2);\n    }\n\n    //Pick the highest scoring op amp out of recommended list for stage 2\n    var results = pickOpAmp_2ndStage(stage2Array, opAmpDB, stage1OpAmpObject);\n    if (results instanceof _modelError.default) return results;\n    stage2 = results.stage2;\n  }\n  return {\n    stage2: stage2\n  };\n}\nfunction getStage1Values(userInputs, stage1OpAmpObject, totalGain) {\n  let bw = userInputs.speed;\n  let cDiff = stage1OpAmpObject.cDiff;\n  let cCm = stage1OpAmpObject.cCm;\n  let cIn = cDiff + cCm + userInputs.capacitance;\n  let Q = userInputs.peaking;\n  let gbw = computeGbw(stage1OpAmpObject);\n  let rIn = computeRin(userInputs, stage1OpAmpObject);\n  let rf;\n  if (gbw <= bw) {\n    rf = NaN;\n  }\n  let rfValues = computeRf(gbw, bw, cIn, rIn, Q, totalGain);\n  rf = rfValues.standardRf;\n  let theoreticalRf = rfValues.theoreticalRf;\n  let cf = computeCf(gbw, bw, cIn, rIn, Q, theoreticalRf, totalGain);\n  let newBw = Solver.solveBW(cIn, rIn, cf, rf, gbw);\n  let newQ = Solver.solveQ(cIn, rIn, cf, rf, stage1OpAmpObject.gbw, newBw);\n  return {\n    rf: rf,\n    cf: cf,\n    bw: newBw,\n    Q: newQ\n  };\n}\nfunction calculateRFilter(opampGBW, bw) {\n  var rfilter, cfilter;\n  //get rfilter first; pick resistor based on opampGBW so we pick bigger resistors for slow parts and smaller resistors for faster ones\n  rfilter = Common.determineStartingR3R4Value(_photodiodeConstants.default.optimizationType.noise, opampGBW / 50);\n  //then calculate capacitor value \n  cfilter = 1 / (2 * Math.PI * rfilter * bw);\n  var results = Common.capacitorBasedOnTolerance(cfilter, _photodiodeConstants.default.capacitorTolerance.twenty);\n  cfilter = results[0];\n  // then go back and refine resistor choice based on that\n  rfilter = 1 / (2 * Math.PI * cfilter * bw);\n  results = Common.resistorBasedOnTolerance(rfilter, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n  rfilter = results[0];\n  return {\n    rfilter: rfilter,\n    cfilter: cfilter\n  };\n}\nfunction computeRin(userInputs, opAmpObject) {\n  var rIn = userInputs.shuntResistance;\n  if (opAmpObject.feedbackMethod === \"Current\" && opAmpObject.cfb) {\n    //if current feedback, we can use all the same voltage feedback equations if we just make this change to rIn:\n    rIn = opAmpObject.cfb.rIn;\n  }\n  return rIn;\n}\nfunction computeGbw(opAmpObject) {\n  let gbw = opAmpObject.gbw;\n  if (opAmpObject.feedbackMethod === \"Current\" && opAmpObject.cfb) {\n    //if current feedback, we can use all the same voltage feedback equations if we just make this change to gbw:\n    var rIn = opAmpObject.cfb.rIn;\n    gbw = opAmpObject.cfb.zbw / rIn;\n  }\n  return gbw;\n}\nfunction computeRf(gbw, bw, cIn, rIn, Q, totalGain) {\n  let theoreticalRf = Solver.solveRf_CfFlexible(gbw, bw, cIn, rIn, Q);\n  let adjustedRf = theoreticalRf;\n  if (theoreticalRf > totalGain || theoreticalRf > _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT) {\n    adjustedRf = Math.min(totalGain, _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT);\n  }\n  let results = Common.resistorBasedOnTolerance(adjustedRf, _photodiodeConstants.default.resistorTolerance.fiveTenths);\n  return {\n    standardRf: results[0],\n    theoreticalRf: theoreticalRf,\n    adjustedRf: adjustedRf\n  };\n}\nfunction computeCf(gbw, bw, cIn, rIn, Q, rf, totalGain) {\n  var cf = Solver.solveCf_RfFlexible(gbw, bw, cIn, rIn, Q);\n  let theoreticalRf = rf.theoreticalRf;\n  if (theoreticalRf > totalGain || theoreticalRf > _photodiodeConstants.default.Limits.RBIG_COMP_LIMIT) {\n    cf = Solver.solveCf_BWFlexible(rf.adjustedRf, rIn, Q, cIn, gbw);\n  }\n\n  //convert cf to standard value if larger than 1 pf.   If smaller, we assume board parasitic capacitance will have \n  //a larger effect than the tolerance. \n  if (cf > _photodiodeConstants.default.Limits.CSMALL_COMP_1PF) {\n    let results = Common.capacitorBasedOnTolerance(cf, _photodiodeConstants.default.capacitorTolerance.five);\n    cf = results[0];\n  }\n  return cf;\n}\nfunction computeTotalGain(userInputs) {\n  var totalGain = userInputs.peakVoltage / userInputs.peakCurrent;\n  return totalGain;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.pulseResponse = pulseResponse;\nexports.stepResponse = stepResponse;\nexports.stepResponseOvershoot = stepResponseOvershoot;\nexports.stepResponseRiseTime = stepResponseRiseTime;\nvar Common = _interopRequireWildcard(require(\"./common\"));\nvar GraphCalculations = _interopRequireWildcard(require(\"./graphs\"));\nvar AdiMath = _interopRequireWildcard(require(\"./math\"));\nvar _photodiodeConstants = _interopRequireDefault(require(\"./photodiode-constants\"));\nfunction _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nfunction pulseResponse(inputValues, opAmpDB, stagesObject) {\n  //Our pulse width will be 3/4 of the total time axis, so we can see the falling edge\n  var pulsePercent = 1 / 2;\n  var bwForCalculatingTime = inputValues.speed * pulsePercent;\n  var timeAxis = createTimeAxis(bwForCalculatingTime);\n  //var userPulseWidth = Common.calculateMinPulseWidthSpeed(inputValues.speed);\n  var timeLength = timeAxis.length;\n  var pulseWidthIndex = timeLength * pulsePercent;\n  var stepResponseReturn = this.stepResponse(inputValues, opAmpDB, stagesObject, timeAxis);\n  var stepResponseArray = stepResponseReturn[1];\n  var riseTime = this.stepResponseRiseTime(stepResponseArray, timeAxis, inputValues);\n  var overshoot = this.stepResponseOvershoot(stepResponseArray, timeAxis, inputValues);\n\n  //Add the original step response by a negated version shifted in time by the pulse width\n  var pulseResponseArray = [];\n  for (var i = 0; i < stepResponseArray.length; i++) {\n    if (i < pulseWidthIndex) {\n      pulseResponseArray[i] = stepResponseArray[i];\n    } else {\n      pulseResponseArray[i] = stepResponseArray[i] - stepResponseArray[i - pulseWidthIndex];\n    }\n  }\n\n  // Assume step response is settled by end is so is a good gain indicator.  This is more accurate way to calculate gain than using peak voltage / peackCurrent because it will incorporate the nonideal resistors.\n  // However this method won't be accurate if step hasn't settled by the end of the step time.\n  // The more accurate way would be to calculate gain using the stage 1 and stage 2 gains, but that's a lot of formula and ifs to account for the various stage options.  I was hoping we had a function for our \n  // total DC gain, but I couldn't find it.\n  // Calling this good enough.\n  let tiaGain = stepResponseArray[stepResponseArray.length - 1] / inputValues.peakCurrent;\n  let offsetFromShuntResistance = inputValues.reverseVoltage / inputValues.shuntResistance * tiaGain;\n  //Offset always is same sign as the photodiode current, so invert the offset if the pulse response goes down instead of up\n  //if (tiaGain > 0) {\n  pulseResponseArray = pulseResponseArray.map(pulseResponseValue => pulseResponseValue + offsetFromShuntResistance);\n  // }\n  //else {\n  //    pulseResponseArray = pulseResponseArray.map(pulseResponseValue => pulseResponseValue - offsetFromShuntResistance);\n  //}\n\n  return [timeAxis, pulseResponseArray, riseTime, overshoot];\n}\nfunction stepResponse(inputValues, opAmpDB, stagesObject, timeAxis) {\n  \"use strict\";\n\n  var stepResponseArray = [],\n    tempArray = [],\n    fakeStages,\n    impulseRes;\n  fakeStages = createStagesforStepResponse(inputValues, opAmpDB, stagesObject);\n  if (timeAxis === undefined) {\n    var roughBW = GraphCalculations.getRoughBW(stagesObject);\n    timeAxis = createTimeAxis(roughBW / 2);\n  }\n\n  //Increase our sample rate by 5x so that we have more internal accuracy, especially with slew rate limiting\n  //slewRateEffect_TIA has to do some time shifting.  It also has to indentify when we switch from slew rate limited to not slew rate limited.\n  //Both are much more accurate if we have more points to look at.\n  //Method below robust even if we do not have equal timeAxis spacing\n  let timeAxis5x = [];\n  for (let i = 0; i < timeAxis.length - 1; i++) {\n    let timeAxisDifference = timeAxis[i + 1] - timeAxis[i];\n    timeAxis5x.push(timeAxis[i]);\n    timeAxis5x.push(timeAxis[i] + timeAxisDifference * 0.2);\n    timeAxis5x.push(timeAxis[i] + timeAxisDifference * 0.4);\n    timeAxis5x.push(timeAxis[i] + timeAxisDifference * 0.6);\n    timeAxis5x.push(timeAxis[i] + timeAxisDifference * 0.8);\n  }\n\n  // Step Response of 1 stage setup\n  var stepResSetup1 = stepResponseSetup(fakeStages[0]);\n  // Step Response of 1 point \n  for (var t = 0; t < timeAxis5x.length; t++) {\n    stepResponseArray[t] = stepResponseIdeal(timeAxis5x[t], stepResSetup1, fakeStages[0]);\n  }\n\n  //add in slew rate effect of first op amp\n  stepResponseArray = slewRateEffect_TIA(timeAxis5x, stepResponseArray, fakeStages[0].slewRate);\n\n  // rest of the stages\n  for (let i = 1, len = fakeStages.length; i < len; i++) {\n    impulseRes = impulseResponse(timeAxis5x, fakeStages[i]);\n    tempArray = AdiMath.convolve(stepResponseArray, impulseRes);\n    stepResponseArray = tempArray;\n  }\n\n  //add in slew rate effect of 2nd op amp\n  if (inputValues.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    stepResponseArray = slewRateEffect_2ndStage(timeAxis5x, stepResponseArray, 1e6 * stagesObject.stage2.opAmp.slewRate);\n  }\n\n  // if (user has selected a one stage design) && (photodiode polarity is positive)\n  // polarity should be negative\n  if (inputValues.stages == _photodiodeConstants.default.pdStages.oneStage && inputValues.biasPreference == _photodiodeConstants.default.biasPreferenceOptions.positive) {\n    for (let k = 0, len = stepResponseArray.length; k < len; k++) {\n      stepResponseArray[k] = stepResponseArray[k] * -1;\n    }\n  }\n\n  //Now decimate back down to our original axis\n  let decimatedStepResponseArray = [];\n  for (let i = 0; i < stepResponseArray.length; i = i + 5) {\n    decimatedStepResponseArray.push(stepResponseArray[i]);\n  }\n  //If we're missing a value, tack on the last value in the array\n  if (decimatedStepResponseArray.length < timeAxis.length) {\n    decimatedStepResponseArray.push(stepResponseArray[stepResponseArray.length - 1]);\n  }\n  return [timeAxis, decimatedStepResponseArray];\n}\n\n//Calculates 10% to 90% rise time\n//This function always assumes the step response starts at 0, and is trying to go to the peak voltage.\n//It is able to handle the case where the step response is inverted.\nfunction stepResponseRiseTime(stepResponseArray, timeArray, inputValues) {\n  //create local copy of array so we don't mess up original\n  var stepResponseArrayLocal = stepResponseArray.slice(0);\n\n  //first check if step response is the special case where it goes from 0 to a negative number.  If so, invert so we can do\n  //the calculations like all the othe cases.\n  if (inputValues.stages === _photodiodeConstants.default.pdStages.oneStage && inputValues.biasPreference == _photodiodeConstants.default.biasPreferenceOptions.positive) {\n    for (var k = 0, len = stepResponseArrayLocal.length; k < len; k++) {\n      stepResponseArrayLocal[k] = stepResponseArray[k] * -1;\n    }\n  }\n  var timeInterval, voltageInterval, riseTime;\n  var minValue = 0;\n  var maxValue = stepResponseArrayLocal[stepResponseArrayLocal.length - 1];\n  var amplitude = maxValue - minValue;\n  var tenPercent = 0.1 * amplitude + minValue;\n  var ninetyPercent = 0.9 * amplitude + minValue;\n  var tenPercentFound = false;\n  var ninetyPercentFound = false;\n  for (var i = 1; i < stepResponseArrayLocal.length; i++) {\n    if (!tenPercentFound && stepResponseArrayLocal[i] > tenPercent) {\n      tenPercentFound = true;\n      timeInterval = timeArray[i] - timeArray[i - 1];\n      voltageInterval = stepResponseArrayLocal[i] - stepResponseArrayLocal[i - 1];\n      var interpolatedTenPercentTime = timeArray[i - 1] + timeInterval * (tenPercent - stepResponseArrayLocal[i - 1]) / voltageInterval;\n    }\n    if (!ninetyPercentFound && stepResponseArrayLocal[i] > ninetyPercent) {\n      ninetyPercentFound = true;\n      timeInterval = timeArray[i] - timeArray[i - 1];\n      voltageInterval = stepResponseArrayLocal[i] - stepResponseArrayLocal[i - 1];\n      var interpolatedNinetyPercentTime = timeArray[i - 1] + timeInterval * (ninetyPercent - stepResponseArrayLocal[i - 1]) / voltageInterval;\n      break;\n    }\n  }\n  if (tenPercentFound && ninetyPercentFound) {\n    riseTime = interpolatedNinetyPercentTime - interpolatedTenPercentTime;\n  } else {\n    riseTime = NaN;\n  }\n  return riseTime;\n}\n\n//Calculates the peak overshoot\n//This function always assumes the step response starts at 0, and is trying to go to the peak voltage.\n//It is able to handle the case where the step response is inverted.\nfunction stepResponseOvershoot(stepResponseArray, timeArray, inputValues) {\n  //create local copy of array so we don't mess up original\n  var stepResponseArrayLocal = stepResponseArray.slice(0);\n\n  //first check if step response is the special case where it goes from 0 to a negative number.  If so, invert so we can do\n  //the calculations like all the othe cases.\n  if (inputValues.stages === _photodiodeConstants.default.pdStages.oneStage && inputValues.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.positive) {\n    for (var k = 0, len = stepResponseArrayLocal.length; k < len; k++) {\n      stepResponseArrayLocal[k] = stepResponseArray[k] * -1;\n    }\n  }\n  var largestValue = Math.max.apply(Math, stepResponseArrayLocal);\n  var lastValue = stepResponseArrayLocal[stepResponseArrayLocal.length - 1];\n  var percentOvershoot = (largestValue / lastValue - 1) * 100;\n  return percentOvershoot;\n}\n\n//PRIVATE FUNCTIONS\n//this function adds in the effect of slew rate for the second stage.   It simply clips the waveform to keep it at the appropriate slew.\nfunction slewRateEffect_2ndStage(timeAxis, stepValues, slewRate) {\n  \"use strict\";\n\n  var slope, absSlope, newVal, sign;\n  var timeLen = timeAxis.length;\n  var timeStep = timeAxis[1] - timeAxis[0];\n  var i;\n  var newStepValues = [];\n  newStepValues.push(stepValues[0]);\n  for (i = 1; i < timeLen; i++) {\n    slope = (stepValues[i] - newStepValues[i - 1]) / timeStep;\n    absSlope = Math.abs(slope);\n    if (absSlope > slewRate) {\n      if (slope < 0) {\n        sign = -1;\n      } else {\n        sign = 1;\n      }\n      newVal = newStepValues[i - 1] + slewRate * timeStep * sign;\n      newStepValues.push(newVal);\n    } else {\n      newStepValues.push(stepValues[i]);\n    }\n  }\n  return newStepValues;\n}\n\n//this function adds in the effect of slew rate for the TIA stage.   It deletes all points exceeding slew rate and replaces them with slew rate limited values. \n//It then time shifts the remaining points\nfunction slewRateEffect_TIA(timeAxis, stepValues, slewRate) {\n  var slope;\n  var timeLen = timeAxis.length;\n  var timeStep = timeAxis[1] - timeAxis[0];\n  var newStepValues = [];\n  var slewRateExceededArray = [];\n  var i, j;\n\n  //stop when we go over steady state value or if our slope falls under the slew rate rate (after first exceeding it)\n  var slewRateExceeded = false;\n  for (i = 0; i < timeLen; i++) {\n    slope = Math.abs((stepValues[i + 1] - stepValues[i]) / timeStep);\n    if (slope > slewRate) {\n      slewRateExceededArray.push(true);\n      slewRateExceeded = true;\n    } else slewRateExceededArray.push(false);\n  }\n\n  //if no slew rate limiting, just return original waveform \n  if (!slewRateExceeded) {\n    return stepValues;\n  }\n\n  //first segment: not slew limited.   Use original values;\n  for (j = 0, i = 0; !slewRateExceededArray[i] && i < timeLen; j++, i++) {\n    newStepValues[j] = stepValues[i];\n  }\n\n  //second segment: slew limited.   Make new slew limited values\n  let startValue = stepValues[i];\n  i = getIndexWhereSlewRateNoLongerLimited(slewRateExceededArray, timeLen, i);\n  let stopValue = stepValues[i];\n  j = addSlewRateLimitedValuesToNewStepValues(startValue, stopValue, newStepValues, timeStep, timeLen, j, slewRate);\n\n  //third segment: not slew limited.  Reuse old values, but have to time shift and linearly interpolate\n  for (; !slewRateExceededArray[i] && i < timeLen && j < timeLen; i++, j++) {\n    newStepValues[j] = stepValues[i];\n  }\n\n  //fourth segment: slew limited.  Make new slew limited values\n  startValue = stepValues[i];\n  i = getIndexWhereSlewRateNoLongerLimited(slewRateExceededArray, timeLen, i);\n  stopValue = stepValues[i];\n  j = addSlewRateLimitedValuesToNewStepValues(startValue, stopValue, newStepValues, timeStep, timeLen, j, slewRate);\n\n  //fifth segment.  The rest.   Assuming waveform now attenuated enough that no more slew rate limiting\n  for (; !slewRateExceededArray[i] && i < timeLen && j < timeLen; i++, j++) {\n    newStepValues[j] = stepValues[i];\n  }\n  return newStepValues;\n}\n\n//step through the old values above slew rate, so we can determine where slew rate limiting stops in old step array\nfunction getIndexWhereSlewRateNoLongerLimited(slewRateExceededArray, timeLen, i) {\n  while (slewRateExceededArray[i] && i < timeLen) {\n    i++;\n  }\n  return i;\n}\n\n//This function adds slew rate limited values to our new stepValues in the slew rate limited segment\n//It returns the spot where slew rate limiting ends in the newStepValues array\nfunction addSlewRateLimitedValuesToNewStepValues(startValue, stopValue, newStepValues, timeStep, timeLen, j, slewRate) {\n  //now create new step values by traveling on the slew rate slope starting from start value\n  for (let k = 0; j < timeLen; j++, k++) {\n    newStepValues[j] = startValue + slewRate * k * timeStep;\n    if (newStepValues[j] > stopValue) {\n      break;\n    }\n  }\n  return j;\n}\n\n// function linearInterpolate(x3, x1, x2, y1, y2) {\n//     var y3 = y1 + (((x3 - x1) * (y2 - y1)) / (x2 - x1));\n\n//     return y3;\n// }\n\nfunction createTimeAxis(fCutOff) {\n  var maxXaxis,\n    stepSize,\n    pointsInStepResponse,\n    timeAxis = new Array();\n  maxXaxis = Common.calculateMinPulseWidthSpeed(fCutOff);\n\n  /*pointsInStepResponse sets the number of points in the graph  It is a compromise between speed and accuracy.   \r\n  jqplot in takes about 300 ms to plot 512 points in firefox in Jan 2013.  However smaller numbers of points start \r\n  to show choppiness in plots with lots of ripple like bandpass*/\n\n  pointsInStepResponse = 256;\n  stepSize = maxXaxis / pointsInStepResponse;\n  for (var k = 0; k < pointsInStepResponse; k++) {\n    timeAxis[k] = k * stepSize;\n  }\n  return timeAxis;\n}\n\n//Create a set of stages that approximate the performance of the circuit.   Since we only know know to calculate step response for 1st and 2nd order stages, this information\n//must be put in that form.\nfunction createStagesforStepResponse(inputValues, opAmpDB, stagesObject) {\n  var plottingStages = [];\n  var realStage1 = stagesObject.stage1;\n  var realStage2 = stagesObject.stage2;\n\n  //first stage:  transimpedance circuit assuming ideal integrator op amp\n  //get Q for first stage.   By using this Q, rather than the original user's request, it will incorporate peaking effects from the gbw*2 pole of the op amp.\n  var results = GraphCalculations.calculateNaturalFrequencyAndQ(stagesObject, _photodiodeConstants.default.pdStages.oneStage);\n  plottingStages.push({\n    Stage: \"2\",\n    StageQ: results.q,\n    StageFp: results.fn,\n    StageFz: 1,\n    Gain: realStage1.rf * inputValues.peakCurrent,\n    StageId: 1,\n    stageType: _photodiodeConstants.default.filterType.lowPass,\n    slewRate: 1e6 * realStage1.opAmp.slewRate\n  });\n\n  //this stage incorporates secondary pole(s) from op amp\n  if (realStage1.opAmp.feedbackMethod === \"Current\" && realStage1.opAmp.cfb) {\n    //current feedback second stage: incorporate two secondary poles at 2.414214 * minRf frequency\n    var freq135 = realStage1.opAmp.cfb.zbw / realStage1.opAmp.cfb.minRf;\n    var freqDualPole = freq135 * 2.414214;\n    plottingStages.push({\n      Stage: \"2\",\n      StageQ: 0.707,\n      StageFp: freqDualPole,\n      StageFz: 1,\n      Gain: 1,\n      StageId: 1,\n      stageType: _photodiodeConstants.default.filterType.lowPass,\n      slewRate: 1e60 //make slew rate so big it doesn't matter\n    });\n  } else {\n    //voltage feedback second stage: incorporate second op amp pole at gbw*2\n    plottingStages.push({\n      Stage: \"1\",\n      StageQ: 0.707,\n      StageFp: realStage1.opAmp.gbw * 2,\n      StageFz: 1,\n      Gain: 1,\n      StageId: 1,\n      stageType: _photodiodeConstants.default.filterType.lowPass,\n      slewRate: 1e60 //make slew rate so big it doesn't matter\n    });\n  }\n  if (inputValues.stages === _photodiodeConstants.default.pdStages.twoStage) {\n    // third stage:  effect of cfilter\n    var stage3fp;\n    if (inputValues.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.negative) {\n      stage3fp = 1 / (2 * Math.PI * realStage2.cfilter * realStage2.rfilter);\n    } else {\n      stage3fp = 1 / (2 * Math.PI * realStage2.cfilter * realStage2.rf);\n    }\n    plottingStages.push({\n      Stage: \"1\",\n      StageQ: 0.707,\n      StageFp: stage3fp,\n      StageFz: 1,\n      Gain: 1,\n      StageId: 1,\n      stageType: _photodiodeConstants.default.filterType.lowPass,\n      slewRate: 1e60 //make so big it doesn't matter\n    });\n    let stage4fp;\n    // fourth stage: 2nd stage frequency response assuming ideal integrator op amp\n    if (realStage2.opAmp.feedbackMethod === \"Current\" && realStage2.opAmp.cfb) {\n      var rpar = realStage2.rg * realStage2.opAmp.cfb.rIn / (realStage2.rg + realStage2.opAmp.cfb.rIn);\n      var beta_current = rpar / (realStage2.rf + rpar) / realStage2.opAmp.cfb.rIn;\n      stage4fp = realStage2.opAmp.cfb.zbw * beta_current;\n    } else {\n      stage4fp = realStage2.opAmp.gbw / (1 + realStage2.rf / realStage2.rg);\n    }\n    let stage4Gain;\n    if (inputValues.biasPreference === _photodiodeConstants.default.biasPreferenceOptions.negative) {\n      stage4Gain = 1 + realStage2.rf / realStage2.rg;\n    } else {\n      stage4Gain = realStage2.rf / realStage2.rg;\n    }\n    plottingStages.push({\n      Stage: \"1\",\n      StageQ: 0.707,\n      StageFp: stage4fp,\n      StageFz: 1,\n      Gain: stage4Gain,\n      StageId: 1,\n      stageType: _photodiodeConstants.default.filterType.lowPass,\n      slewRate: 1e6 * realStage2.opAmp.slewRate\n    });\n  }\n  return plottingStages;\n}\n\n//See step response documentation in Filter Wizard confluence for where all this comes from.  \nfunction stepResponseSetup(stage) {\n  var a,\n    b,\n    c,\n    w0,\n    Q,\n    pi = Math.PI;\n  if (stage.Stage == \"0\") {\n    w0 = 0;\n    Q = 0;\n    if (stage.stageType == \"gain\") {\n      a = stage.Gain;\n      b = 0;\n      c = 0;\n    } else {\n      console.log(\"should never happen\");\n    }\n  }\n  if (stage.Stage == \"1\") {\n    w0 = stage.StageFp * 2 * pi; // stageFp for butterworth and chebyshev\n\n    Q = 0;\n    c = 0;\n    if (stage.stageType == _photodiodeConstants.default.filterType.lowPass) {\n      a = stage.Gain;\n      b = stage.Gain;\n    } else if (stage.stageType == _photodiodeConstants.default.filterType.highPass) {\n      a = 0;\n      b = -1 * stage.Gain;\n    }\n  }\n  if (stage.Stage == \"2\") {\n    w0 = stage.StageFp * 2 * pi; // stageFp for butterworth and chebyshev\n\n    Q = stage.StageQ;\n    if (stage.stageType == _photodiodeConstants.default.filterType.lowPass) {\n      a = 0;\n      b = 0;\n      c = stage.Gain * Math.pow(w0, 2);\n    }\n    if (stage.stageType == _photodiodeConstants.default.filterType.highPass) {\n      a = stage.Gain;\n      b = 0;\n      c = 0;\n    }\n    if (stage.stageType == _photodiodeConstants.default.filterType.bandPass) {\n      a = 0;\n      b = stage.Gain * w0 / Q;\n      c = 0;\n    }\n    if (stage.stageType == \"notch\") {\n      a = stage.Gain;\n      b = 0;\n      c = stage.Gain * Math.pow(w0, 2);\n    }\n    if (stage.stageType == \"gain\") {\n      console.log(\"should never happen\");\n    }\n  }\n  return [a, b, c, w0, Q]; //return a,b,c,w0,Q\n}\n\n//See step response documentation in Filter Wizard confluence for where all this comes from.  Particularly the \"step response calculations from Art.pdf\".\nfunction stepResponseIdeal(timePoint, stepResSetup, stage) {\n  var answer;\n  var a = stepResSetup[0];\n  var b = stepResSetup[1];\n  var c = stepResSetup[2];\n  var w0 = stepResSetup[3];\n  var Q = stepResSetup[4];\n  var X;\n  var Y;\n  var W;\n  var Z;\n  if (stage.Stage == \"0\" || stage.Stage == \"1\") {\n    var tw0 = -1 * timePoint * w0;\n    answer = a - b * Math.exp(tw0);\n  }\n  if (stage.Stage == \"2\") {\n    X = -c - a * Math.pow(w0, 2) + 2 * b * w0 * Q; //X=-c-a*wo**2+2*b*wo*Q;\n    Y = -Math.pow(w0, 2) * (-1 + 4 * Math.pow(Q, 2)); //Y=-wo**2*(-1 + 4*Q**2);\n    W = a * Math.pow(w0, 2) - c; //W=a*wo**2-c;\n    Z = Math.exp(-timePoint * w0 / 2 / Q); //Z=exp(-t*wo/2/Q);\n\n    if (Y > 0) {\n      var sqrtY = Math.sqrt(Y); //sqrt(Y)\n      var tYQ = timePoint * sqrtY / 2 / Q; //t*sqrt(Y)/2/Q\n\n      var sinhY = Math.sinh(tYQ); //sinh(t*sqrt(Y)/2/Q)\n      var coshY = Math.cosh(tYQ); //cosh(t*sqrt(Y)/2/Q)\n      //There are some cases where Z goes to 0 and sinhY and coshY go to infinity.\n      //As long as we're not recommending absolutely horrible circuits that are completely unstable (if we are, we have more serious problems),\n      //Z should go to 0 faster than sinhY and coshy go to infinity, so result should be 0. Trouble is, computer doesn't know this.\n      //It generates NaN when 0 * infinity, which kills our plot.  So we add this check. \n      //An even safer method would be to decompose the sinhY and coshY functions into exponentials, multiply by Z using the exponent terms \n      //(i.e. add the exponent terms), and then take the exponential.  This would work for unstable circuits too.  But the math is hard enough\n      // to follow already!  So we use this check instead.\n      if ((X * sinhY === Infinity || W * coshY === Infinity || X * sinhY === -Infinity || W * coshY === -Infinity) && Z === 0) {\n        sinhY = 1;\n        coshY = 1;\n      }\n      answer = X * sinhY * Z / sqrtY / w0 + (c + W * coshY * Z) / Math.pow(w0, 2);\n    }\n    if (Y < 0) {\n      var sqrtNegY = Math.sqrt(-Y); //sqrt(-Y)\n\n      answer = X * Math.sin(timePoint * sqrtNegY / 2 / Q) * Z / sqrtNegY / w0 + (c + W * Math.cos(timePoint * sqrtNegY / 2 / Q) * Z) / Math.pow(w0, 2);\n    }\n    if (Y == 0) {\n      var w02 = Math.pow(w0, 2); //w0**2\n      var w03 = Math.pow(w0, 3); //w0**3\n      var exptw0 = Math.exp(timePoint * w0); // exp(t*wo)\n\n      answer = -(c - c * exptw0 - a * w02 + a * timePoint * w03 - b * timePoint * w02 + c * timePoint * w0) / (w02 * exptw0);\n    }\n  }\n  return answer;\n}\nfunction impulseResponse(timeAxis, stage) {\n  var t;\n  var impulseArray = [];\n  var firstPoint;\n  var secondPoint;\n  var timeLen = timeAxis.length;\n  var StepResSet = stepResponseSetup(stage);\n  if (stage.stageType == _photodiodeConstants.default.filterType.highPass || stage.stageType == _photodiodeConstants.default.filterType.gain) {\n    impulseArray[0] = stage.Gain;\n  } else {\n    impulseArray[0] = 0;\n  }\n  firstPoint = stepResponseIdeal(timeAxis[0], StepResSet, stage); // for t=0\n\n  //starting the loop with second point\n  for (t = 1; t < timeLen; t++) {\n    secondPoint = stepResponseIdeal(timeAxis[t], StepResSet, stage);\n    impulseArray[t] = secondPoint - firstPoint;\n    firstPoint = secondPoint;\n  }\n  return impulseArray;\n}\n\n// function adjustStepResponse(stages, stepResponseArray, inputValues) {\n//     var totalGain = 1;\n\n//     // Multiple gain from all stages calculated in step 2.\n//     for (let i = 0, len = stages.length; i < len; i++) {\n//         totalGain = totalGain * stages[i].Gain;\n//     }\n\n//     // Divide step response by this total gain.\n//     // Then multiply step response by the output voltage requested by the user.\n//     for (let j = 0, len = stepResponseArray.length; j < len; j++) {\n//         stepResponseArray[j] = (stepResponseArray[j] / totalGain) * inputValues.peakVoltage;\n//     }\n\n//     // if (user has selected a one stage design) && (photodiode polarity is positive)\n//     // multiply step response points by -1\n//     if (inputValues.stages == 1 && inputValues.biasPreference == PhotodiodeConstants.biasPreferenceOptions.positive) {\n//         for (var k = 0, len = stepResponseArray.length; k < len; k++) {\n//             stepResponseArray[k] = stepResponseArray[k] * -1;\n//         }\n//     }\n\n//     return stepResponseArray;\n// }\n\n//This function inverts the step response \n// function invertStepResponse(stepResponseArray, inputValues) {\n//     if (inputValues.stages == 1 && inputValues.biasPreference == PhotodiodeConstants.biasPreferenceOptions.positive) {\n//         for (var k = 0, len = stepResponseArray.length; k < len; k++) {\n//             stepResponseArray[k] = stepResponseArray[k] * -1;\n//         }\n//     }\n\n//     return stepResponseArray;\n// }\n\n//This function not ready for prime time. When calculating the downward slope, it assumes that everything has\n//settled to steady state, which is not the case. Somehow modifications need to be made to account for the charged\n//state of the existing components.\n// function convertToPulseResponse(stepResponseArray, inputValues, timeAxis) {\n//     //get step response as if we were directly converting frequency response graph (complete with massive gain)\n//     var posArray = stepResponseArray;\n//     var negArray = [];\n//     var pulseArray = [];\n//     var extraTime = [];\n//     var lastValue = stepResponseArray[stepResponseArray.length - 1];\n//     var onePoint;\n\n//     if ((inputValues.stages === '1') || (inputValues.biasPreference === 'negative')) {\n//         //show positive pulse first and have everything be above zero\n//         for (let i = 0; i < posArray.length; i++) {\n//             //scale in case last value hasn't settled yet\n//             onePoint = lastValue / inputValues.peakVoltage * posArray[i];\n//             negArray.push(lastValue - onePoint);\n//         }\n//         pulseArray = posArray.concat(negArray);\n//     }\n//     else {\n//         //show negative pulse first and have everything below zero\n//         for (let i = 0; i < posArray.length; i++) {\n//             negArray.push(-posArray[i]);\n//             //scale in case last value hasn't settled yet\n//             onePoint = lastValue / inputValues.peakVoltage * posArray[i];\n//             posArray[i] = posArray[i] - lastValue;\n//         }\n//         pulseArray = negArray.concat(posArray);\n//     }\n\n//     //now double the timeAxis\n//     let timeInterval = timeAxis[1] - timeAxis[0];\n//     let origLength = timeAxis.length;\n//     for (let i = 0; i < origLength; i++) {\n//         extraTime.push((origLength + i) * timeInterval);\n//     }\n//     var newTimeAxis = timeAxis.concat(extraTime);\n\n//     return [newTimeAxis, pulseArray];\n// }\n\n//This function currently not used, but kept in here in case we want to use it in the future.\n//It seems like we need a 10,000 point computation to get a reasonably good step response result.\n//However it takes about the following amount of time to do this:\n//createComplexClosedLoopGainArray: 200 ms\n//inverseFourier: 800 ms\n//This might be able to optimized by doing the following:\n//- interpolate the higher complexClosedLoopGain values rather than calculating them outright\n//- use FFT techniques (i.e. Cooley Tukey algorithm) in inverseFourier function\n// static stepFromFourier(stagesObject, inputValues) {\n//     var freqStep = inputValues.speed / 100;\n//     var freqStop = inputValues.speed * 100;\n//     var frequency;\n\n//     var frequencyArray = [1e-6];  //Start with frequency very close to DC, but not zero\n//     for (frequency = freqStep; frequency < freqStop; frequency += freqStep) {\n//         frequencyArray.push(frequency);\n//     }\n\n//     console.time('complexClosedLoopGainArray');\n//     var complexClosedLoopGainArray = this.createComplexClosedLoopGainArray(frequencyArray, stagesObject, inputValues, true);\n//     console.timeEnd('complexClosedLoopGainArray');\n//     console.time('inverseFourier');\n//     var stepResponseResults = this.inverseFourier(complexClosedLoopGainArray, freqStep, 400, complexClosedLoopGainArray[0].magnitude());\n//     console.timeEnd('inverseFourier');\n\n//     return stepResponseResults;\n// }","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.joinArrays = exports.getRangeLimits = exports.getMultilineLimits = exports.VVarrtoDBarr = exports.VAarrtoDBarr = void 0;\nvar Conversion = _interopRequireWildcard(require(\"./conversion\"));\nfunction _getRequireWildcardCache(e) { if (\"function\" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }\nfunction _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || \"object\" != typeof e && \"function\" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if (\"default\" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }\nconst joinArrays = function (array1, array2) {\n  var length = Math.min(array1.length, array2.length);\n  var result = [];\n  for (var n = 0; n < length; n++) {\n    result.push([array1[n], array2[n]]);\n  }\n  return result;\n};\nexports.joinArrays = joinArrays;\nconst VVarrtoDBarr = function (vvArr) {\n  var vvArray = [];\n  var dbArray = new Array();\n  if (vvArr) {\n    vvArray = vvArr; // putting the values of input vvArr to a new array vvArray.\n    var len = vvArray.length;\n    for (var i = 0; i < len; i++) {\n      dbArray[i] = Conversion.VVtoDB(vvArray[i]);\n    }\n  }\n  return dbArray;\n};\nexports.VVarrtoDBarr = VVarrtoDBarr;\nconst VAarrtoDBarr = function (vaArray) {\n  var dbArray = new Array(); // declaring the dbArray\n\n  if (vaArray) {\n    var len = vaArray.length;\n    for (var i = 0; i < len; i++) {\n      dbArray[i] = Conversion.VAtoDB(vaArray[i]);\n    }\n  }\n  return dbArray;\n};\nexports.VAarrtoDBarr = VAarrtoDBarr;\nconst getRangeLimits = function (graphData) {\n  var model = graphData;\n  var minx = Math.min(...model.map(x => x[0]));\n  var maxx = Math.max(...model.map(x => x[0]));\n  var miny = null;\n  var maxy = null;\n  if (graphData[0].length === 2) {\n    miny = Math.min(...model.map(x => x[1]));\n    maxy = Math.max(...model.map(x => x[1]));\n  } else {\n    var yValues = [];\n    model.forEach(x => {\n      yValues.push(x[1]);\n      yValues.push(x[2]);\n      yValues.push(x[3]);\n    });\n    miny = Math.min(...yValues);\n    maxy = Math.max(...yValues);\n  }\n  var result = {\n    xmin: minx,\n    xmax: maxx,\n    ymin: miny,\n    ymax: maxy\n  };\n  return result;\n};\nexports.getRangeLimits = getRangeLimits;\nconst getMultilineLimits = function (graphDataList) {\n  let limitsList = [];\n  graphDataList.forEach(element => {\n    if (element.length > 2) {\n      let elemLimit = getRangeLimits(element);\n      limitsList.push(elemLimit);\n    }\n  });\n  let limits = [];\n  limitsList.forEach(element => {\n    limits.push([element.xmin, element.ymin]);\n    limits.push([element.xmax, element.ymax]);\n  });\n  let limitsResult = getRangeLimits(limits);\n  if (limitsResult.ymin == 0) {\n    let yValues = limits.map(x => x[1]).filter(x => x != 0);\n    limitsResult.ymin = Math.min(...yValues);\n  }\n  return limitsResult;\n};\nexports.getMultilineLimits = getMultilineLimits;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"assets/chunk.\" + {\"0\":\"554e362e509277fed5ff\",\"12\":\"a41c129cb844938b56cd\",\"565\":\"6fee7263425738d5adc8\",\"657\":\"5576bb3276c763e6cfd3\",\"847\":\"2557d9c0adc43c0bb656\",\"943\":\"9118334df775ae8e4590\"}[chunkId] + \".js\";\n};","// This function allow to reference async chunks\n__webpack_require__.miniCssF = (chunkId) => {\n\t// return url for filenames based on template\n\treturn undefined;\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"/en/photodiode/\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t149: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkphotodiode\"] = self[\"webpackChunkphotodiode\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\nvar __webpack_exports__ = __webpack_require__.O(undefined, [965], () => (__webpack_require__(2965)))\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["deferred","leafPrototypes","getProto","inProgress","dataWebpackPrefix","m","window","require","default","__esModule","module","exports","requirejs","define","Object","defineProperty","value","getStageOneInfo","opAmpStatus_TIA","stage1","userInputs","maxOpAmpOutput","minSlewRate","cf","cfext","bw","rf","Q","q","opAmpObject","opAmp","notAllowedString","allowedString","status","_photodiodeConstants","opAmpStatus","recommended","statusMessage","needFaster","stage1peakVoltage","peakCurrent","biasPreference","biasPreferenceOptions","positive","stages","pdStages","oneStage","inHeadroomPlus","maxSupplyVoltage","outHeadroomMinus","inHeadroomMinus","outHeadroomPlus","bwModifier","Math","max","speed","allowed","push","key","_messages","amp_status_too_fast","amp_status_cf_less_50fF","amp_status_cf_less_100fF","biasCurrent","iBias","biasLimit","min","amp_status_bias_current_is","data","architecture","indexOf","amp_status_zero_drift","amp_status_not_fast_enough","stage1maxVoltage","vos","amp_status_high_vos","PI","slewRate","amp_status_slew_rate_marginal","twoStage","totalGain","peakVoltage","secondStageGain","amp_status_big_2nd_stage_gain","partNumber","amp_status_specialty_amp","numberChannels","amp_status_quad","deviceStatus","amp_status_not_recommended_for_new_designs","amp_status_last_time_buy","gbw","notAllowed","amp_status_not_enough_peaking","amp_status_internal_cf_too_high","isNaN","amp_status_dB_error","amp_status_voltage_not_enough","minStableGain","amp_status_min_stable_gain","feedbackMethod","cfb","minRf","amp_status_cfb_rf_too_small","rOut","amp_status_slew_rate_low","amp_status_obsolete","pickOpAmp_TIA","stage1Array","opAmpDB","needSomeSpeed","errorObject","errorCode","errorParameter","notRecommendedAvailable","stageOne","minRecommendedScore","minAllowedScore","requireRecommended","marginalStatusMessage","errorMessage","_errorCodes","noOpAmpAvailableForSingleStageTooFast","noOpAmpAvailableForSingleStageTooSlow","noOpAmpAvailableForFirstStageTooFast","noOpAmpAvailableForFirstStageTooSlow","_model","setModelError","_interopRequireDefault","_stages","Solver","e","r","t","_getRequireWildcardCache","has","get","n","__proto__","a","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","_interopRequireWildcard","WeakMap","debugArray","length","noiseScore","noiseScore_TIA","dcScore","dcScore_TIA","bwScore","bwScore_TIA","totalScore","stage2Score_TIA","singleDualQuadScore","opAmpName","stage1Info","capGain","cDiff","cCm","capacitance","capGainCalculate","vNoise","iNoise","sumVNoiseandINoise","sqrt","ifOnlyOneStageResistor","resNoise","score","stage2","stage2Info","stagesObject","calculateOutputOffset","stage1info","numChannels","parseInt","calculateBandwidthSpeed","speedValue","calculateMinPulseWidthSpeed","calculateNelderMeadError","freqArray","fp","magnitudeValues","error","difference","stageMagnitude","idealMagnitude","freqLength","j","num","f","denomReal","denomImag","denomMag","stageMaglen","k","capacitorBasedOnTolerance","desiredValue","desiredTolerance","finalTolerance","nominalValue","toleranceCoerced","capacitorArray","errorOccured","arrayE24","capacitorTable","tolerance","capacitorTolerance","ideal","allowedMin","Limits","CSMALL_COMP_LIMIT","allowedMax","CBIG_COMP_LIMIT","multiplicationFactors","preferredSeries","one","nominalFactor","five","ten","twenty","checkCapacitorRange_result","this","checkToleranceRange","row","setNominalValue","checkErrorPercent","fpQErrorObj","boolErrorArr","errArrlen","toleranceTable","rowIndex","determineStartingR3R4Value","optimization","stageFp","rMin","rMax","rFreq","F_MAX","optimizationType","noise","voltageRange","power","allowedSpecific","recommendedSpecific","frequency","frequencyPoint","startFreq","stopFreq","pointsPerDecade","y","multiplier","pow","frequency_point","Array","friendlyFrequency","start","end","decade","FriendlyFrequency","generateExtremelyFineGranularityFreqArray","generateVeryFineGranularityFreqArray","generateFineGranularityFreqArray","generateModerateGranularityFreqArray","resistorBasedOnTolerance","resistorArray","arrayE96","resistorTable","resistorTolerance","RSMALL_COMP_LIMIT","RBIG_COMP_LIMIT","oneTenth","fiveTenths","checkResistorRange_result","sortErrorArray","sort","obj1","obj2","unjoinArray","joinedArray","array1","array2","exponent","charAt","row1","row2","desiredVal","nominalVal","toExponential","toString","slice","parseFloat","Complex","constructor","real","imaginary","createComplex","complexfreq","complexNumberRaisedToPower","c","modC","theta","realPart","imaginaryPart","modCpowern","atan2","cos","sin","plus","plusDestroy","imagPart","subs","subsDestroy","mult","multDestroy","divide","divident","divideDestroy","magnitude","arctan","I","log","floor","VAtoDB","VA","AdiMath","logBaseTen","VVtoDB","vv","dBtoVV","db","x","degreeToradian","cmag","newArray","newArrayInner","getGainDB","gain","gainUnit","getGainVV","groupDelay","phaseArray","frequencyArray","frequencyDifference","phaseDifference","groupDelayArray","newFrequencyAxis","negatedPhaseArray","negatePhase","frequencyRadPerSecondArray","hzToRadPerSecond","result","phaseDelay","radPerS","radianTodegree","radArray","static","calculatePeakLightIntensity","peakPhotodiodeNotInRange","calculatePeakPhotodiode","computedPeakPhotodiodeNotInRange","oneStageRf","rfTooHigh","pickOpAmp_2ndStage","noOpAmpAvailable","stop","expectedPoints","generateFreqArray","POINTS_PER_DECADE_607","POINTS_PER_DECADE_99","POINTS_PER_DECADE_63","Error","results","currentPosition","expectedPointsArr","log10","newPoints","map","Number","filter","includes","index","findIndex","startIndex","endIndex","filteredResult","_value","addSpectralToRMSSum","frequencySpanRoot","oldTotalNoise","spectralDensity","noiseInterval","calculateAlphaForCFBVoltageNoise","stage","rf_c_s","cin","complexNum","_complex","complexDenom","rin","calculateArraysForNoiseGainPlot","capGainArray","noiseGainArray","opAmpArray","rcParArray","rPar","rcParallelPole","complexA","calculateComplexA","complexBeta","calculateComplexBeta_TIA","noiseGain","opAmpGain","complexAlpha","calculateOpAmpVoltageNoiseGain","rcParRatio","rcParGain","calculateClosedLoopGain","calculateComplexClosedLoopGain","pi","sImaginary","sSquared","complexTopTerm","complexBottomTerm","zbw","rIn","radDualPole","ZBWrad","sCubed","GBWrad","rOutDivider","undefined","topTermRout","bottomTermRout","polesZeroes","calculateComplexA_PolesAndZeroes","freq","complexProduct","p","z","rhpz","calculateComplexAlpha_Stage2","rfilter","console","currentThroughRin","rg","cfilter","calculateComplexAlpha_TIA","rParallel","cParallel","pole","complexDCgain","calculateComplexBeta_Stage2","OpAmpRin","zero","ACgain","complexTemporary","calculateENOB","SNR","calculateMaxSupplyVoltage","calculateMinSupplyVoltage","minSupplyOut2","minSupplyIn2","minSupplyOut1","minSupply","minSupplyVoltage","calculateNaturalFrequencyAndQ","numStages","fn","solveBW","solveQ_fnAndMagnitude","calculateNoise","stageInfo","totalArray","stage1Keys","stage2Keys","stage1Sums","total","opAmpI","opAmpV","stage2Sums","individualStage1Spectrals","individualStage2Spectrals","calculateSpectralDensityForOneFrequency","halfOfTheFrequencies","getColumnFrom2DArray","totalRMSNoise","computeRMSNoiseFromSpectralArray","graphLines","calculateOpAmpCurrentNoiseGain_Stage2","iGain","complexRfRg","invertingIgain","complexRfilter","complexFilterImpedance","noninvertingIgain","complexRf","iGainAlpha","calculateOpAmpCurrentNoiseGain_TIA","calculateRfNoiseGain_Stage2","complexRfAlpha","rfOverRg","calculateRfNoiseGain_TIA","calculateRfilterNoiseGain","calculateRgNoiseGain_Stage2","complexRgAlpha","calculateRinNoiseGain","complexRin","complexRinAlpha","calculateSNR","rmsNoise","peakToPeakV","SNR_VperV","spectralNoise","stage1noise","stage2noise","opAmpVnoise","opAmpVGain","opAmpInoise","opAmpIGain","rfNoise","rfGain","rinNoise","rinGain","totalSpectralDensity","rgNoise","rfilterNoise","stage2gain","createMagnitudeArray","inputValues","magnitudeArray","complexAPhases","getActualFpFq","loopFp","loopQ","newFreqPoints","Common","fpArray","qArray","pointsInfpArray","errorArray","reflectedFp","reflectedQ","reflectedError","expandedFp","expandedQ","expandedError","contractedFp","contractedQ","contractedError","centerOfGravityFp","centerOfGravityQ","state","fpQErr","errorPercentCheck","fpArraylen","qArraylen","errLen","count","sumFp","sumQ","getRoughBW","polefrequency","getSpectralNoiseData","frequencies","array2D","columnIndex","spectralNoiseArray","midPointAbove","rmsNoiseSinglePoint","midPointBelow","MaxArray","array","apply","MinArray","convolve","xArr","yArr","resultArray","nLength","mLength","cosh","number","exp","getBaseLog","getLogMidPoint","maxVal","minVal","avg","inverseFourier","complexFreqDomainArray","freqStep","numTimePoints","expectedEndPoint","freqDomainLength","xArray","yArrayImpulse","yArrayStep","timestep","integrationSum","runningSum","multiplier_phase","multiplier_real","multiplier_imag","errorCorrection","your_log","sinh","amp_status_cfb_no_cf","amp_status_gbw_less_than_bandwith_requested","amp_status_negative_cf","amp_status_not_allowed","amp_status_not_recommended","amp_status_recommended","fixed_op_amp_no_good","no_op_amps_available_for_single_stage_too_fast","no_op_amps_available_for_single_stage_too_slow","no_op_amps_available_for_first_stage_too_fast","no_op_amps_available_for_first_stage_too_slow","no_op_amps_available_for_second_stage","rf_too_high","currentCalculation_peak_light_error","currentCalculation_peak_photodiode_error","billOfMaterials","stagesPreference","sensor","NextSteps","getAvailableOpAmps","opAmpDb","Vr","Bias","Cd","Rsh","Ip","peaking","numberOfStages","stage1OpAmpName","stageIndex","Recommendations","getCircuitDesignModel","opAmps","calculateOneStage_FixedOpAmp","calculateOneStage_FindOpAmp","calculateTwoStages_FixedOpAmp","calculateTwoStages_FindOpAmp","_modelError","getCircuitGraphData","roughBW","Graphs","startFrequency","stopFrequency","stepResponseResults","StepResponse","pulseResponse","timeAxis","stepResponseArray","riseTime","overshoot","vPeak","noiseResults","minPhotoCurrent","snr","stepResponse","dynamicRange","enob","outputOffset","getResult","opampDb","opamp1","opamp2","reverseVoltage","shuntResistance","circuitData","getSchematicFromInput","Photodiode","vr","vBias","cd","rsh","ip","photodiodeName","circuitName","pdCircuits","oneStageNegative","oneStagePositive","ErrorCode","ErrorMessage","ErrorParameter","opAmpTable","byPassCapsSpareOpAmps","byPassCapacitors","tantCapacitors","billOfMaterialsResistorArray","billOfMaterialsCapacitorArray","billOfMaterialsOpAmpArray","validCapacitors","validResistors","name","circuitComponents","Cf","Rf","Rg2","Rf2","Cfilter","Rfilter","materialAndPackageResistor","materialAndPackageForResistors","refDesignator","prodURL","package","material","referenceDesignator","materialAndPackageCapacitor","materialAndPackageForCapacitors","PackageAndMaterialsOpAmp1","materialAndPackageForOpAmps","generic","toUpperCase","PackageAndMaterialsOpAmp2","opAmpSparesByPassCapacitors","byPassCapMaterialsAndPackage","bypassCapString","_prettyNum","userEntryToNumber","tantCapString","billOfMaterialsSensor","designators","billOfMaterialsTable","concat","opAmpSpares","retObject","type","opAmp1","len","opAmp2","pop","D1","OpAmp1","OpAmp2","toleranceValue","pkg","packageCode","boolReferenceBoard","formatValue","unit","billOfMaterialDisplay","arrayNew","arrayCount","dlist","boolFound","element","arrayClone","b","tempObj","numberToUserDisplay","supplySpace","RSMALL_LOAD_LIMIT","CSMALL_COMP_1PF","INFINITY","NEGINFINITY","notRecommended","negative","specialOpAmps","minGain","pole1","pole2","compPin","filterType","lowPass","highPass","bandPass","bandStop","notch","toggleUnits","va","stage1OpAmp","Stages","stage1Info_SingleStage","stage1Info_DualStage","comment","selectable","disallowed","opAmpListItem","scdFlag","opAmpRecommendationStatus","getIdealOpAmp1","findOpAmp","findOpAmp1","getIdealOpAmp2","stage1OpAmpPartNumber","findOpAmp2","vosRTO","biasError","stage1vosRTI","stage1vosRTO","rpar","noisegain","cIn","cTotal","gbwRad","solveBW_CfFlexible","Rin","Cin","undersqrt1","undersqrt2","solveCf_BWFlexible","solveCf_RfFlexible","wo","solveQ","BW","solveRf_CfFlexible","internalCfTooHigh","partName","cfint","fixedOpAmpNoGood","_circuit","calculate2ndStage","stage2Array","stage1OpAmpObject","find","rinDisplay","computeGbw","computeRin","NaN","computeTotalGain","rfValues","computeRf","standardRf","computeCf","newBw","stage1Values","theoreticalRf","getStage1Values","stage2Gain","rgPlusRf","stage1GBW","calculateRFIlterResults","opampGBW","calculateRFilter","opAmpStatus2ndStageResults","slewrate","opAmpStatus_2ndStage","OneStage","lowestSupplyCurrent","supplyCurrent","TwoStage","adjustedRf","createTimeAxis","pulseWidthIndex","stepResponseRiseTime","stepResponseOvershoot","pulseResponseArray","tiaGain","offsetFromShuntResistance","pulseResponseValue","fakeStages","impulseRes","plottingStages","realStage1","realStage2","GraphCalculations","Stage","StageQ","StageFp","StageFz","Gain","StageId","stageType","freqDualPole","stage3fp","stage4fp","stage4Gain","beta_current","createStagesforStepResponse","timeAxis5x","timeAxisDifference","stepResSetup1","stepResponseSetup","stepResponseIdeal","stepValues","timeLen","timeStep","newStepValues","slewRateExceededArray","slewRateExceeded","abs","startValue","stopValue","getIndexWhereSlewRateNoLongerLimited","addSlewRateLimitedValuesToNewStepValues","slewRateEffect_TIA","impulseResponse","slope","newVal","sign","slewRateEffect_2ndStage","decimatedStepResponseArray","timeArray","stepResponseArrayLocal","timeInterval","voltageInterval","amplitude","tenPercent","ninetyPercent","tenPercentFound","ninetyPercentFound","interpolatedTenPercentTime","interpolatedNinetyPercentTime","fCutOff","stepSize","w0","timePoint","stepResSetup","answer","X","Y","W","Z","tw0","sqrtY","tYQ","sinhY","coshY","Infinity","sqrtNegY","w02","w03","exptw0","firstPoint","secondPoint","impulseArray","StepResSet","Conversion","vvArr","vvArray","dbArray","vaArray","getRangeLimits","graphData","model","minx","maxx","miny","maxy","yValues","forEach","xmin","xmax","ymin","ymax","graphDataList","limitsList","elemLimit","limits","limitsResult","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","O","chunkIds","priority","notFulfilled","fulfilled","keys","every","splice","getter","d","getPrototypeOf","obj","mode","then","ns","create","def","current","getOwnPropertyNames","definition","o","enumerable","chunkId","Promise","all","reduce","promises","miniCssF","prop","prototype","l","url","done","script","needAttach","scripts","document","getElementsByTagName","s","getAttribute","createElement","charset","timeout","nc","setAttribute","src","onScriptComplete","prev","event","onerror","onload","clearTimeout","doneFns","parentNode","removeChild","setTimeout","bind","target","head","appendChild","Symbol","toStringTag","installedChunks","installedChunkData","promise","resolve","reject","errorType","realSrc","message","request","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","runtime","some","id","chunkLoadingGlobal","self","__webpack_exports__"],"sourceRoot":""}