RnD/reactor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: RnD:boundary-conditions
Branches Tags
RnD:main RnD:dev-Rene RnD:boundary-conditions
..
compare: RnD:06251988aff9d9b3af19386294bd1a3d27f323fb
Branches Tags
RnD:main RnD:dev-Rene RnD:boundary-conditions

6 Commits
boundary-c ... 06251988af

Author SHA1 Message Date
Rene De Ren
06251988af fix: replace console usage with logger, throw on unknown reactor type 
Unknown reactor type is a configuration error that should fail loudly.
Converted console.log to logger.warn for unknown topics.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-03-12 09:33:34 +01:00
Rene De Ren
7ff7c6ec1d test: add unit tests for specificClass 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-03-11 16:31:53 +01:00
Rene De Ren
a18c36b2e5 refactor: adopt POSITIONS constants and fix ESLint warnings 
Replace hardcoded position strings with POSITIONS.* constants.
Prefix unused variables with _ to resolve no-unused-vars warnings.
Fix no-prototype-builtins where applicable.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-03-11 15:35:28 +01:00
Rene De Ren
aacbc1e99d Migrate _loadConfig to use ConfigManager.buildConfig() 
Replaces manual base config construction with shared buildConfig() method.
Node now only specifies domain-specific config sections.

Part of #1: Extract base config schema

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-03-11 14:59:35 +01:00
Rene De Ren
68576a8a36 Fix ESLint errors and bugs 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-03-11 13:39:57 +01:00
p.vanderwilt
442ddc60ed Fix syntax error 2025-10-01 11:50:35 +02:00
7 changed files with 445 additions and 108 deletions
Expand all files Collapse all files

4
additional_nodes/recirculation-pump.js
View File

@@ -3,13 +3,12 @@ module.exports = function(RED) {
RED.nodes.createNode(this, config);
var node = this;
let name = config.name;
let F2 = parseFloat(config.F2);
const inlet_F2 = parseInt(config.inlet);
node.on('input', function(msg, send, done) {
switch (msg.topic) {
case "Fluent":
case "Fluent": {
// conserve volume flow debit
let F_in = msg.payload.F;
let F1 = Math.max(F_in - F2, 0);
@@ -24,6 +23,7 @@ module.exports = function(RED) {
send([msg_F1, msg_F2]);
break;
}
case "clock":
break;
default:

4
additional_nodes/settling-basin.js
View File

@@ -3,13 +3,12 @@ module.exports = function(RED) {
RED.nodes.createNode(this, config);
var node = this;
let name = config.name;
let TS_set = parseFloat(config.TS_set);
const inlet_sludge = parseInt(config.inlet);
node.on('input', function(msg, send, done) {
switch (msg.topic) {
case "Fluent":
case "Fluent": {
// conserve volume flow debit
let F_in = msg.payload.F;
let C_in = msg.payload.C;
@@ -41,6 +40,7 @@ module.exports = function(RED) {
send([msg_F1, msg_F2]);
break;
}
case "clock":
break;
default:

30
src/nodeClass.js
View File

@@ -1,4 +1,5 @@
const { Reactor_CSTR, Reactor_PFR } = require('./specificClass.js');
const { configManager } = require('generalFunctions');
class nodeClass {
@@ -48,14 +49,15 @@ class nodeClass {
case "Dispersion":
this.source.setDispersion = msg;
break;
case 'registerChild':
case 'registerChild': {
// Register this node as a parent of the child node
const childId = msg.payload;
const childObj = this.RED.nodes.getNode(childId);
const childObj = this.RED.nodes.getNode(childId);
this.source.childRegistrationUtils.registerChild(childObj.source, msg.positionVsParent);
break;
}
default:
console.log("Unknown topic: " + msg.topic);
this.source.logger.warn(`Unknown topic: ${msg.topic}`);
}
if (done) {
@@ -69,20 +71,10 @@ class nodeClass {
* @param {object} uiConfig Config set in UI in node-red
*/
_loadConfig(uiConfig) {
this.config = {
general: {
name: uiConfig.name || this.name,
id: this.node.id,
unit: null,
logging: {
enabled: uiConfig.enableLog,
logLevel: uiConfig.logLevel
}
},
functionality: {
positionVsParent: uiConfig.positionVsParent || 'atEquipment', // Default to 'atEquipment' if not specified
softwareType: "reactor" // should be set in config manager
},
const cfgMgr = new configManager();
// Build config: base sections + reactor-specific domain config
this.config = cfgMgr.buildConfig('reactor', uiConfig, this.node.id, {
reactor_type: uiConfig.reactor_type,
volume: parseFloat(uiConfig.volume),
length: parseFloat(uiConfig.length),
@@ -106,7 +98,7 @@ class nodeClass {
parseFloat(uiConfig.X_TS_init)
],
timeStep: parseFloat(uiConfig.timeStep)
}
});
}
/**
@@ -137,7 +129,7 @@ class nodeClass {
new_reactor = new Reactor_PFR(this.config);
break;
default:
console.warn("Unknown reactor type: " + uiConfig.reactor_type);
throw new Error(`Unknown reactor type: ${this.config.reactor_type}`);
}
this.source = new_reactor; // protect from reassignment

4
src/reaction_modules/asm3_class Koch.js
View File

@@ -19,7 +19,7 @@ class ASM3 {
nu_NO: 0.5, // anoxic reduction factor [-]
K_O: 0.2, // saturation constant S_0 [g O2 m-3]
K_NO: 0.5, // saturation constant S_NO [g NO3-N m-3]
K_S: 10., // saturation constant S_s [g COD m-3]
K_S: 10.0, // saturation constant S_s [g COD m-3]
K_STO: 0.1, // saturation constant X_STO [g X_STO g-1 X_H]
mu_H_max: 3., // maximum specific growth rate [d-1]
K_NH: 0.01, // saturation constant S_NH3 [g NH3-N m-3]
@@ -171,7 +171,7 @@ class ASM3 {
compute_rates(state, T = 20) {
// state: S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS
const rates = Array(12);
const [S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS] = state;
const [S_O, , S_S, S_NH, , S_NO, S_HCO, , X_S, X_H, X_STO, X_A] = state;
const { k_H, K_X, k_STO, nu_NO, K_O, K_NO, K_S, K_STO, mu_H_max, K_NH, K_HCO, b_H_O, b_H_NO, b_STO_O, b_STO_NO, mu_A_max, K_A_NH, K_A_O, K_A_HCO, b_A_O, b_A_NO } = this.kin_params;
const { theta_H, theta_STO, theta_mu_H, theta_b_H_O, theta_b_H_NO, theta_b_STO_O, theta_b_STO_NO, theta_mu_A, theta_b_A_O, theta_b_A_NO } = this.temp_params;

2
src/reaction_modules/asm3_class.js
View File

@@ -171,7 +171,7 @@ class ASM3 {
compute_rates(state, T = 20) {
// state: S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS
const rates = Array(12);
const [S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS] = state;
const [S_O, , S_S, S_NH, , S_NO, S_HCO, , X_S, X_H, X_STO, X_A] = state;
const { k_H, K_X, k_STO, nu_NO, K_O, K_NO, K_S, K_STO, mu_H_max, K_NH, K_HCO, b_H_O, b_H_NO, b_STO_O, b_STO_NO, mu_A_max, K_A_NH, K_A_O, K_A_HCO, b_A_O, b_A_NO } = this.kin_params;
const { theta_H, theta_STO, theta_mu_H, theta_b_H_O, theta_b_H_NO, theta_b_STO_O, theta_b_STO_NO, theta_mu_A, theta_b_A_O, theta_b_A_NO } = this.temp_params;

163
src/specificClass.js
View File

@@ -1,7 +1,7 @@
const ASM3 = require('./reaction_modules/asm3_class.js');
const { create, all, isArray } = require('mathjs');
const { assertNoNaN } = require('./utils.js');
const { childRegistrationUtils, logger, MeasurementContainer } = require('generalFunctions');
const { childRegistrationUtils, logger, MeasurementContainer, POSITIONS } = require('generalFunctions');
const EventEmitter = require('events');
const mathConfig = {
@@ -12,7 +12,6 @@ const math = create(all, mathConfig);
const S_O_INDEX = 0;
const NUM_SPECIES = 13;
const BC_PADDING = 2;
const DEBUG = false;
class Reactor {
@@ -28,10 +27,6 @@ class Reactor {
this.measurements = new MeasurementContainer();
this.upstreamReactor = null;
this.childRegistrationUtils = new childRegistrationUtils(this); // Child registration utility
this.parent = []; // Gets assigned via child registration
this.upstreamReactor = null;
this.downstreamReactor = null;
this.asm = new ASM3();
@@ -46,7 +41,7 @@ class Reactor {
this.currentTime = Date.now(); // milliseconds since epoch [ms]
this.timeStep = 1 / (24*60*60) * this.config.timeStep; // time step in seconds, converted to days.
this.speedUpFactor = 100; // speed up factor for simulation, 60 means 1 minute per simulated second
this.speedUpFactor = 60; // speed up factor for simulation, 60 means 1 minute per simulated second
}
/**
@@ -118,18 +113,23 @@ class Reactor {
}
}
_connectMeasurement(measurementChild) {
if (!measurementChild) {
_connectMeasurement(measurement) {
if (!measurement) {
this.logger.warn("Invalid measurement provided.");
return;
}
const position = measurementChild.config.functionality.positionVsParent;
const measurementType = measurementChild.config.asset.type;
let position;
if (measurement.config.functionality.distance !== 'undefined') {
position = measurement.config.functionality.distance;
} else {
position = measurement.config.functionality.positionVsParent;
}
const measurementType = measurement.config.asset.type;
const eventName = `${measurementType}.measured.${position}`;
// Register event listener for measurement updates
measurementChild.measurements.emitter.on(eventName, (eventData) => {
measurement.measurements.emitter.on(eventName, (eventData) => {
this.logger.debug(`${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
// Store directly in parent's measurement container
@@ -144,27 +144,26 @@ class Reactor {
}
_connectReactor(reactorChild) {
if (!reactorChild) {
_connectReactor(reactor) {
if (!reactor) {
this.logger.warn("Invalid reactor provided.");
return;
}
this.upstreamReactor = reactorChild;
reactorChild.downstreamReactor = this;
this.upstreamReactor = reactor;
reactorChild.emitter.on("stateChange", (data) => {
reactor.emitter.on("stateChange", (data) => {
this.logger.debug(`State change of upstream reactor detected.`);
this.updateState(data);
});
}
_updateMeasurement(measurementType, value, position, context) {
_updateMeasurement(measurementType, value, position, _context) {
this.logger.debug(`---------------------- updating ${measurementType} ------------------ `);
switch (measurementType) {
case "temperature":
if (position == "atEquipment") {
if (position == POSITIONS.AT_EQUIPMENT) {
this.temperature = value;
}
break;
@@ -246,15 +245,11 @@ class Reactor_PFR extends Reactor {
this.alpha = config.alpha;
this.state = Array.from(Array(this.n_x), () => config.initialState.slice());
this.extendedState = Array.from(Array(this.n_x + 2*BC_PADDING), () => new Array(NUM_SPECIES).fill(0));
// initialise extended state
this.state.forEach((row, i) => this.extendedState[i+BC_PADDING] = row);
this.state = Array.from(Array(this.n_x), () => config.initialState.slice())
this.D = 0.0; // axial dispersion [m2 d-1]
this.D_op = this._makeDoperator();
this.D_op = this._makeDoperator(true, true);
assertNoNaN(this.D_op, "Derivative operator");
this.D2_op = this._makeD2operator();
@@ -292,26 +287,25 @@ class Reactor_PFR extends Reactor {
* @returns {Array} - New reactor state.
*/
tick(time_step) {
this._applyBoundaryConditions();
const dispersion = math.multiply(this.D / (this.d_x*this.d_x), this.D2_op, this.extendedState);
const advection = math.multiply(-1 * math.sum(this.Fs) / (this.A*this.d_x), this.D_op, this.extendedState);
const reaction = this.extendedState.map((state_slice) => this.asm.compute_dC(state_slice, this.temperature));
const transfer = Array.from(Array(this.n_x+2*BC_PADDING), () => new Array(NUM_SPECIES).fill(0));
const dispersion = math.multiply(this.D / (this.d_x*this.d_x), this.D2_op, this.state);
const advection = math.multiply(-1 * math.sum(this.Fs) / (this.A*this.d_x), this.D_op, this.state);
const reaction = this.state.map((state_slice) => this.asm.compute_dC(state_slice, this.temperature));
const transfer = Array.from(Array(this.n_x), () => new Array(NUM_SPECIES).fill(0));
if (isNaN(this.kla)) { // calculate OTR if kla is not NaN, otherwise use externally calculated OTR
for (let i = BC_PADDING+1; i < BC_PADDING+this.n_x - 1; i++) {
for (let i = 1; i < this.n_x - 1; i++) {
transfer[i][S_O_INDEX] = this.OTR * this.n_x/(this.n_x-2);
}
} else {
for (let i = BC_PADDING+1; i < BC_PADDING+this.n_x - 1; i++) {
transfer[i][S_O_INDEX] = this._calcOTR(this.extendedState[i][S_O_INDEX], this.temperature) * this.n_x/(this.n_x-2);
for (let i = 1; i < this.n_x - 1; i++) {
transfer[i][S_O_INDEX] = this._calcOTR(this.state[i][S_O_INDEX], this.temperature) * this.n_x/(this.n_x-2);
}
}
const dC_total = math.multiply(math.add(dispersion, advection, reaction, transfer).slice(BC_PADDING, this.n_x+BC_PADDING), time_step);
const dC_total = math.multiply(math.add(dispersion, advection, reaction, transfer), time_step);
const stateNew = math.add(this.state, dC_total);
this._applyBoundaryConditions(stateNew);
if (DEBUG) {
assertNoNaN(dispersion, "dispersion");
@@ -322,18 +316,18 @@ class Reactor_PFR extends Reactor {
}
this.state = this._arrayClip2Zero(stateNew);
this.state.forEach((row, i) => this.extendedState[i+BC_PADDING] = row);
return stateNew;
}
_updateMeasurement(measurementType, value, position, context) {
_updateMeasurement(measurementType, value, position, _context) {
switch(measurementType) {
case "quantity (oxygen)":
let grid_pos = Math.round(context.distance / this.config.length * this.n_x);
case "quantity (oxygen)": {
let grid_pos = Math.round(position / this.config.length * this.n_x);
this.state[grid_pos][S_O_INDEX] = value; // naive approach for reconciling measurements and simulation
break;
}
default:
super._updateMeasurement(measurementType, value, position, context);
super._updateMeasurement(measurementType, value, position, _context);
}
}
@@ -341,51 +335,57 @@ class Reactor_PFR extends Reactor {
* Apply boundary conditions to the reactor state.
* for inlet, apply generalised Danckwerts BC, if there is not flow, apply Neumann BC with no flux
* for outlet, apply regular Danckwerts BC (Neumann BC with no flux)
* @param {Array} state - Current reactor state without enforced BCs.
*/
_applyBoundaryConditions() {
if (this.upstreamReactor) {
for (let i = 0; i < BC_PADDING; i++) {
this.extendedState[i] = this.upstreamReactor.state.at(i-BC_PADDING);
}
_applyBoundaryConditions(state) {
if (math.sum(this.Fs) > 0) { // Danckwerts BC
const BC_C_in = math.multiply(1 / math.sum(this.Fs), [this.Fs], this.Cs_in)[0];
const BC_dispersion_term = (1-this.alpha)*this.D*this.A/(math.sum(this.Fs)*this.d_x);
state[0] = math.multiply(1/(1+BC_dispersion_term), math.add(BC_C_in, math.multiply(BC_dispersion_term, state[1])));
} else {
if (math.sum(this.Fs) > 0) { // Danckwerts BC
const BC_C_in = math.multiply(1 / math.sum(this.Fs), [this.Fs], this.Cs_in)[0];
const BC_dispersion_term = (1-this.alpha)*this.D*this.A/(math.sum(this.Fs)*this.d_x);
this.extendedState[BC_PADDING] = math.multiply(1/(1+BC_dispersion_term), math.add(BC_C_in, math.multiply(BC_dispersion_term, this.extendedState[BC_PADDING+1])));
this.extendedState[BC_PADDING-1] = math.add(math.multiply(2, this.extendedState[BC_PADDING]), math.multiply(-2, this.extendedState[BC_PADDING+2]), this.extendedState[BC_PADDING+3]);
} else {
for (let i = 0; i < BC_PADDING; i++) {
this.extendedState[i] = this.extendedState[BC_PADDING];
}
}
}
if (this.downstreamReactor) {
for (let i = 0; i < BC_PADDING; i++) {
this.extendedState[this.n_x+BC_PADDING+i] = this.downstreamReactor.state[i];
}
} else {
// Neumann BC (no flux)
for (let i = 0; i < BC_PADDING; i++) {
this.extendedState[BC_PADDING+this.n_x+i] = this.extendedState.at(-1-BC_PADDING);
}
state[0] = state[1];
}
// Neumann BC (no flux)
state[this.n_x-1] = state[this.n_x-2];
}
/**
* Create finite difference first derivative operator.
* @param {boolean} central - Use central difference scheme if true, otherwise use upwind scheme.
* @param {boolean} higher_order - Use higher order scheme if true, otherwise use first order scheme.
* @returns {Array} - First derivative operator matrix.
*/
_makeDoperator() { // create gradient operator
const D_size = this.n_x+2*BC_PADDING;
const I = math.resize(math.diag(Array(D_size).fill(1/12), -2), [D_size, D_size]);
const A = math.resize(math.diag(Array(D_size).fill(-2/3), -1), [D_size, D_size]);
const B = math.resize(math.diag(Array(D_size).fill(2/3), 1), [D_size, D_size]);
const C = math.resize(math.diag(Array(D_size).fill(-1/12), 2), [D_size, D_size]);
const D = math.add(I, A, B, C);
// set by BCs elsewhere
D.forEach((row, i) => i < BC_PADDING || i >= this.n_x+BC_PADDING ? row.fill(0) : row);
return D;
_makeDoperator(central = false, higher_order = false) { // create gradient operator
if (higher_order) {
if (central) {
const I = math.resize(math.diag(Array(this.n_x).fill(1/12), -2), [this.n_x, this.n_x]);
const A = math.resize(math.diag(Array(this.n_x).fill(-2/3), -1), [this.n_x, this.n_x]);
const B = math.resize(math.diag(Array(this.n_x).fill(2/3), 1), [this.n_x, this.n_x]);
const C = math.resize(math.diag(Array(this.n_x).fill(-1/12), 2), [this.n_x, this.n_x]);
const D = math.add(I, A, B, C);
const NearBoundary = Array(this.n_x).fill(0.0);
NearBoundary[0] = -1/4;
NearBoundary[1] = -5/6;
NearBoundary[2] = 3/2;
NearBoundary[3] = -1/2;
NearBoundary[4] = 1/12;
D[1] = NearBoundary;
NearBoundary.reverse();
D[this.n_x-2] = math.multiply(-1, NearBoundary);
D[0] = Array(this.n_x).fill(0); // set by BCs elsewhere
D[this.n_x-1] = Array(this.n_x).fill(0);
return D;
} else {
throw new Error("Upwind higher order method not implemented! Use central scheme instead.");
}
} else {
const I = math.resize(math.diag(Array(this.n_x).fill(1 / (1+central)), central), [this.n_x, this.n_x]);
const A = math.resize(math.diag(Array(this.n_x).fill(-1 / (1+central)), -1), [this.n_x, this.n_x]);
const D = math.add(I, A);
D[0] = Array(this.n_x).fill(0); // set by BCs elsewhere
D[this.n_x-1] = Array(this.n_x).fill(0);
return D;
}
}
/**
@@ -393,13 +393,12 @@ class Reactor_PFR extends Reactor {
* @returns {Array} - Second derivative operator matrix.
*/
_makeD2operator() { // create the central second derivative operator
const D_size = this.n_x+2*BC_PADDING;
const I = math.diag(Array(D_size).fill(-2), 0);
const A = math.resize(math.diag(Array(D_size).fill(1), 1), [D_size, D_size]);
const B = math.resize(math.diag(Array(D_size).fill(1), -1), [D_size, D_size]);
const I = math.diag(Array(this.n_x).fill(-2), 0);
const A = math.resize(math.diag(Array(this.n_x).fill(1), 1), [this.n_x, this.n_x]);
const B = math.resize(math.diag(Array(this.n_x).fill(1), -1), [this.n_x, this.n_x]);
const D2 = math.add(I, A, B);
// set by BCs elsewhere
D2.forEach((row, i) => i < BC_PADDING || i >= this.n_x+BC_PADDING ? row.fill(0) : row);
D2[0] = Array(this.n_x).fill(0); // set by BCs elsewhere
D2[this.n_x - 1] = Array(this.n_x).fill(0);
return D2;
}
}

346
test/specificClass.test.js Normal file
View File

@@ -0,0 +1,346 @@
/**
* Tests for reactor specificClass (domain logic).
*
* Two reactor classes are exported: Reactor_CSTR and Reactor_PFR.
* Both extend a base Reactor class.
*
* Key methods tested:
* - _calcOTR: oxygen transfer rate calculation
* - _arrayClip2Zero: clip negative values to zero
* - setInfluent / getEffluent: influent/effluent data flow
* - setOTR: external OTR override
* - tick (CSTR): forward Euler state update
* - tick (PFR): finite difference state update
* - registerChild: dispatches to measurement / reactor handlers
*/
const { Reactor_CSTR, Reactor_PFR } = require('../src/specificClass');
// --------------- helpers ---------------
const NUM_SPECIES = 13;
function makeCSTRConfig(overrides = {}) {
return {
general: {
name: 'TestCSTR',
id: 'cstr-test-1',
logging: { enabled: false, logLevel: 'error' },
},
functionality: {
softwareType: 'reactor',
positionVsParent: 'atEquipment',
},
volume: 1000,
n_inlets: 1,
kla: 240,
timeStep: 1, // 1 second
initialState: new Array(NUM_SPECIES).fill(1.0),
...overrides,
};
}
function makePFRConfig(overrides = {}) {
return {
general: {
name: 'TestPFR',
id: 'pfr-test-1',
logging: { enabled: false, logLevel: 'error' },
},
functionality: {
softwareType: 'reactor',
positionVsParent: 'atEquipment',
},
volume: 200,
length: 10,
resolution_L: 10,
n_inlets: 1,
kla: 240,
alpha: 0.5,
timeStep: 1,
initialState: new Array(NUM_SPECIES).fill(0.1),
...overrides,
};
}
// --------------- CSTR tests ---------------
describe('Reactor_CSTR', () => {
describe('constructor / initialization', () => {
it('should create an instance and set state from initialState', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
expect(r).toBeDefined();
expect(r.state).toEqual(new Array(NUM_SPECIES).fill(1.0));
});
it('should initialize Fs and Cs_in arrays based on n_inlets', () => {
const r = new Reactor_CSTR(makeCSTRConfig({ n_inlets: 3 }));
expect(r.Fs).toHaveLength(3);
expect(r.Cs_in).toHaveLength(3);
expect(r.Fs.every(v => v === 0)).toBe(true);
});
it('should store volume from config', () => {
const r = new Reactor_CSTR(makeCSTRConfig({ volume: 500 }));
expect(r.volume).toBe(500);
});
it('should initialize temperature to 20', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
expect(r.temperature).toBe(20);
});
});
describe('_calcOTR()', () => {
let r;
beforeAll(() => { r = new Reactor_CSTR(makeCSTRConfig({ kla: 240 })); });
it('should return a positive value when S_O < saturation', () => {
const otr = r._calcOTR(0, 20);
expect(otr).toBeGreaterThan(0);
});
it('should return approximately zero when S_O equals saturation', () => {
// S_O_sat at T=20: 14.652 - 4.1022e-1*20 + 7.9910e-3*400 + 7.7774e-5*8000
const T = 20;
const S_O_sat = 14.652 - 4.1022e-1 * T + 7.9910e-3 * T * T + 7.7774e-5 * T * T * T;
const otr = r._calcOTR(S_O_sat, T);
expect(otr).toBeCloseTo(0, 5);
});
it('should return a negative value when S_O > saturation (supersaturated)', () => {
const otr = r._calcOTR(100, 20);
expect(otr).toBeLessThan(0);
});
it('should use T=20 as default temperature', () => {
const otr1 = r._calcOTR(0);
const otr2 = r._calcOTR(0, 20);
expect(otr1).toBe(otr2);
});
});
describe('_arrayClip2Zero()', () => {
let r;
beforeAll(() => { r = new Reactor_CSTR(makeCSTRConfig()); });
it('should clip negative values to zero', () => {
expect(r._arrayClip2Zero([-5, 3, -1, 0, 7])).toEqual([0, 3, 0, 0, 7]);
});
it('should leave all-positive arrays unchanged', () => {
expect(r._arrayClip2Zero([1, 2, 3])).toEqual([1, 2, 3]);
});
it('should handle nested arrays (2D)', () => {
const result = r._arrayClip2Zero([[-1, 2], [3, -4]]);
expect(result).toEqual([[0, 2], [3, 0]]);
});
it('should handle a single scalar', () => {
expect(r._arrayClip2Zero(-5)).toBe(0);
expect(r._arrayClip2Zero(5)).toBe(5);
});
});
describe('setInfluent / getEffluent', () => {
it('should store influent data via setter', () => {
const r = new Reactor_CSTR(makeCSTRConfig({ n_inlets: 2 }));
const input = {
payload: {
inlet: 0,
F: 100,
C: new Array(NUM_SPECIES).fill(5),
},
};
r.setInfluent = input;
expect(r.Fs[0]).toBe(100);
expect(r.Cs_in[0]).toEqual(new Array(NUM_SPECIES).fill(5));
});
it('should return effluent with the sum of Fs and the current state', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
r.Fs[0] = 50;
const eff = r.getEffluent;
expect(eff.topic).toBe('Fluent');
expect(eff.payload.F).toBe(50);
expect(eff.payload.C).toEqual(r.state);
});
});
describe('setOTR', () => {
it('should set the OTR value', () => {
const r = new Reactor_CSTR(makeCSTRConfig({ kla: NaN }));
r.setOTR = { payload: 42 };
expect(r.OTR).toBe(42);
});
});
describe('tick()', () => {
it('should return a new state array of correct length', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
const result = r.tick(0.001);
expect(result).toHaveLength(NUM_SPECIES);
});
it('should not produce NaN values', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
r.Fs[0] = 10;
r.Cs_in[0] = new Array(NUM_SPECIES).fill(5);
const result = r.tick(0.001);
result.forEach(v => expect(Number.isNaN(v)).toBe(false));
});
it('should not produce negative concentrations', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
// Run multiple ticks
for (let i = 0; i < 100; i++) {
r.tick(0.001);
}
r.state.forEach(v => expect(v).toBeGreaterThanOrEqual(0));
});
it('should reach steady state with zero flow (concentrations change only via reaction)', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
// No inflow
const initial = [...r.state];
r.tick(0.0001);
// State should have changed due to reaction/OTR
const changed = r.state.some((v, i) => v !== initial[i]);
expect(changed).toBe(true);
});
});
describe('registerChild()', () => {
it('should not throw for "measurement" software type', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
// Passing null child will trigger warn but not crash
expect(() => r.registerChild(null, 'measurement')).not.toThrow();
});
it('should not throw for "reactor" software type', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
expect(() => r.registerChild(null, 'reactor')).not.toThrow();
});
it('should not throw for unknown software type', () => {
const r = new Reactor_CSTR(makeCSTRConfig());
expect(() => r.registerChild(null, 'unknown')).not.toThrow();
});
});
});
// --------------- PFR tests ---------------
describe('Reactor_PFR', () => {
describe('constructor / initialization', () => {
it('should create an instance with 2D state grid', () => {
const r = new Reactor_PFR(makePFRConfig());
expect(r).toBeDefined();
expect(r.state).toHaveLength(10); // resolution_L = 10
expect(r.state[0]).toHaveLength(NUM_SPECIES);
});
it('should compute d_x = length / n_x', () => {
const r = new Reactor_PFR(makePFRConfig({ length: 10, resolution_L: 5 }));
expect(r.d_x).toBe(2);
});
it('should compute cross-sectional area A = volume / length', () => {
const r = new Reactor_PFR(makePFRConfig({ volume: 200, length: 10 }));
expect(r.A).toBe(20);
});
it('should initialize D (dispersion) to 0', () => {
const r = new Reactor_PFR(makePFRConfig());
expect(r.D).toBe(0);
});
it('should create derivative operators of correct size', () => {
const r = new Reactor_PFR(makePFRConfig({ resolution_L: 8 }));
expect(r.D_op).toHaveLength(8);
expect(r.D_op[0]).toHaveLength(8);
expect(r.D2_op).toHaveLength(8);
expect(r.D2_op[0]).toHaveLength(8);
});
});
describe('setDispersion', () => {
it('should set the axial dispersion value', () => {
const r = new Reactor_PFR(makePFRConfig());
r.setDispersion = { payload: 0.5 };
expect(r.D).toBe(0.5);
});
});
describe('tick()', () => {
it('should return a 2D state grid of correct dimensions', () => {
const r = new Reactor_PFR(makePFRConfig());
r.D = 0.01;
const result = r.tick(0.0001);
expect(result).toHaveLength(10);
expect(result[0]).toHaveLength(NUM_SPECIES);
});
it('should not produce NaN values with small time step and dispersion', () => {
const r = new Reactor_PFR(makePFRConfig());
r.D = 0.01;
r.Fs[0] = 10;
r.Cs_in[0] = new Array(NUM_SPECIES).fill(5);
const result = r.tick(0.0001);
result.forEach(row => {
row.forEach(v => expect(Number.isNaN(v)).toBe(false));
});
});
it('should not produce negative concentrations', () => {
const r = new Reactor_PFR(makePFRConfig());
r.D = 0.01;
for (let i = 0; i < 10; i++) {
r.tick(0.0001);
}
r.state.forEach(row => {
row.forEach(v => expect(v).toBeGreaterThanOrEqual(0));
});
});
});
describe('_applyBoundaryConditions()', () => {
it('should apply Neumann BC at outlet (last = second to last)', () => {
const r = new Reactor_PFR(makePFRConfig({ resolution_L: 5 }));
const state = Array.from({ length: 5 }, () => new Array(NUM_SPECIES).fill(1));
state[3] = new Array(NUM_SPECIES).fill(7);
r._applyBoundaryConditions(state);
// outlet BC: state[4] = state[3]
expect(state[4]).toEqual(new Array(NUM_SPECIES).fill(7));
});
it('should apply Neumann BC at inlet when no flow', () => {
const r = new Reactor_PFR(makePFRConfig({ resolution_L: 5 }));
r.Fs[0] = 0;
const state = Array.from({ length: 5 }, () => new Array(NUM_SPECIES).fill(1));
state[1] = new Array(NUM_SPECIES).fill(3);
r._applyBoundaryConditions(state);
// No flow: state[0] = state[1]
expect(state[0]).toEqual(new Array(NUM_SPECIES).fill(3));
});
});
describe('_arrayClip2Zero() (inherited)', () => {
it('should clip 2D arrays correctly', () => {
const r = new Reactor_PFR(makePFRConfig());
const result = r._arrayClip2Zero([[-1, 2], [3, -4]]);
expect(result).toEqual([[0, 2], [3, 0]]);
});
});
describe('_calcOTR() (inherited)', () => {
it('should work the same as in CSTR', () => {
const r = new Reactor_PFR(makePFRConfig({ kla: 240 }));
const otr = r._calcOTR(0, 20);
expect(otr).toBeGreaterThan(0);
});
});
});