-
Mathias Chouet authored4e8d9050
import { CalculatorType } from "../../src/compute-node";
import { Session } from "../../src/index";
import { Props } from "../../src/props";
import { CreateStructure } from "../../src/structure/factory_structure";
import { ParallelStructure } from "../../src/structure/parallel_structure";
import { ParallelStructureParams } from "../../src/structure/parallel_structure_params";
import { StructureKivi } from "../../src/structure/structure_kivi";
import { StructureKiviParams } from "../../src/structure/structure_kivi_params";
import { LoiDebit } from "../../src/structure/structure_props";
import { StructureRectangularOrificeFree } from "../../src/structure/structure_rectangular_orifice_free";
import { MessageCode } from "../../src/util/message";
import { Result } from "../../src/util/result";
import { precDigits } from "../test_config";
import { checkResult } from "../test_func";
import { CreateParalleleStructureTest, testParallelStructures } from "./functions";
import { CreateStructTest } from "./structure_test";
function createEnv() {
const ps = new ParallelStructure(
new ParallelStructureParams(30, 30, 15), // Q = 30, Z1 = 30, Z2 = 15
false // debug
);
/*
* Tests avec deux structures test identiques
*/
ps.addChild(CreateStructTest());
ps.addChild(CreateStructTest());
return ps;
}
let pstruct: ParallelStructure;
function getVarCalc(pstructLoc: ParallelStructure, structIndex: number, sVarCalc: string): any {
if (structIndex !== null) {
return {
uid: pstructLoc.structures[structIndex].uid,
symbol: sVarCalc
};
} else {
return sVarCalc;
}
}
/**
* Test sur ParallelStructure
* @param sVarCalc Variable à calculer
* @param rVcalc Valeur de référence à retrouver
* @param Q Débit de chacune des structures (pour structures identiques uniquement)
*/
function itParallelStructure(structIndex: number, sVarCalc: string, rVcalc: number, Q?: number) {
it(`${sVarCalc} should be ${rVcalc}`, () => {
const VC1: any = getVarCalc(pstruct, structIndex, sVarCalc);
checkResult(pstruct.Calc(VC1), rVcalc);
});
if (Q !== undefined) {
const pstructLocal = createEnv();
for (let i = 0; i < pstructLocal.structures.length; i++) {
it(`Calc(${JSON.stringify(sVarCalc)}) ouvrage[${i}].Q should be ${Q}`, () => {
const VC2: any = getVarCalc(pstruct, structIndex, sVarCalc);
pstruct.Calc(VC2);
const val = pstruct.structures[i].result.resultElement.values.Q;
expect(val).toBeCloseTo(Q, Math.max(0, precDigits - 1));
});
it(`Calc(${JSON.stringify(sVarCalc)}) ExtraResult[ouvrage[${i}].Q_Mode] should be 0`, () => {
const VC3 = getVarCalc(pstruct, structIndex, sVarCalc);
pstruct.Calc(VC3);
const val = pstruct.structures[i].result.resultElement.values.ENUM_StructureFlowMode;
expect(val).toEqual(0);
});
it(`Calc(${JSON.stringify(sVarCalc)}) ExtraResult[ouvrage[${i}].Q_Regime] should be 0`, () => {
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
const VC4 = getVarCalc(pstruct, structIndex, sVarCalc);
pstruct.Calc(VC4);
const val = pstruct.structures[i].result.resultElement.values.ENUM_StructureFlowRegime;
expect(val).toEqual(0);
});
}
}
}
describe("Class ParallelStructure: ", () => {
describe("Calc()", () => {
beforeEach(() => {
pstruct = createEnv();
});
it("should return 1 result", () => {
const p1 = createEnv();
const res: Result = p1.Calc("Q");
expect(p1.Calc("Q").resultElements.length).toEqual(1);
});
itParallelStructure(null, "Q", 30, 15);
itParallelStructure(null, "Z1", 30, 15);
itParallelStructure(null, "Z2", 15, 15);
itParallelStructure(0, "ZDV", 0, 15);
itParallelStructure(1, "ZDV", 0, 15);
it("shoud return an error Q too high", () => {
pstruct.prms.Q.v = 14;
const res: Result = pstruct.Calc({
uid: pstruct.structures[1].uid,
symbol: "ZDV"
});
expect(res.log.messages[0].code).toBe(MessageCode.ERROR_STRUCTURE_Q_TROP_ELEVE);
});
});
describe("testParallelStructures", () => {
/*
* Tests avec toutes les équations et toutes les variables (cf. jalhyd#38)
*/
const parallelStructure: ParallelStructure = new ParallelStructure(
new ParallelStructureParams(0, 102, 101.5), // Q = 0, Z1 = 102, Z2 = 101.5
false // debug
);
testParallelStructures(CreateParalleleStructureTest(parallelStructure));
});
describe("#94 Lois d'ouvrage: Erreur de calcul de ZDV", () => {
it(`Calc(ZDV) should return 101.57`, () => {
const ps3: ParallelStructure = new ParallelStructure(
new ParallelStructureParams(0.5, 102, 101.5), // Q = 0.5, Z1 = 102, Z2 = 101.5
false // debug
);
const structTestKivi3: StructureKivi = new StructureKivi(
new StructureKiviParams(
0, 0, 0, 0, // Q, ZDV, Z1, Z2
1, // L
0.4, // alpha
0.001, // béta
95.7 // ZRAM : cote Radier Amont
),
false
);
ps3.addChild(structTestKivi3);
ps3.calculatedParam = ps3.structures[0].prms.ZDV;
expect(ps3.CalcSerie().vCalc).toBeCloseTo(101.57, 2);
});
});
describe("#116 Pas de calcul de Z2 sur loi dénoyée", () => {
it("Calc(Z2) should return an error", () => {
// Create Parallel Structure with default parameters
const ps = Session.getInstance().createNub(
new Props({ calcType: CalculatorType.ParallelStructure })
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
) as ParallelStructure;
// Add Free flow weir
ps.addChild(CreateStructure(LoiDebit.WeirFree));
// Define Z2 to calculate
ps.calculatedParam = ps.prms.Z2;
expect(ps.CalcSerie().ok).toBeFalsy();
});
});
describe("#38 Calcul de Z2 avec Q > Qmax", () => {
it("Calc(Z2) should return error", () => {
const ps = Session.getInstance().createNub(
new Props({ calcType: CalculatorType.ParallelStructure })
) as ParallelStructure;
// Add Free flow weir
ps.addChild(CreateStructure(LoiDebit.GateCem88v));
ps.prms.Q.singleValue = 4;
ps.calculatedParam = ps.prms.Z2;
ps.CalcSerie();
const m = ps.result.resultElement.log.messages[0];
expect(m.code).toEqual(MessageCode.ERROR_DICHO_TARGET_TOO_HIGH);
expect(m.extraVar.variableSymbol).toEqual("Z2");
expect(m.extraVar.targetSymbol).toEqual("Q");
expect(m.extraVar.targetValue).toEqual(ps.prms.Q.currentValue);
});
});
describe("#136 StructureGateCem88v.Calc(ZDV)", () => {
it("Calc(ZDV) should return 100", () => {
const ps = Session.getInstance().createNub(
new Props({ calcType: CalculatorType.ParallelStructure })
) as ParallelStructure;
ps.prms.Q.singleValue = 2.309;
ps.addChild(CreateStructure(LoiDebit.GateCem88v));
ps.structures[0].prms.ZDV.setCalculated();
ps.structures[0].prms.ZDV.singleValue += 0.1;
expect(ps.CalcSerie().vCalc).toBeCloseTo(100, 3);
});
});
describe("Strucure logs should be propagated to parent Result - ", () => {
it("example with StructureRectangularOrificeFree, h2 > 0, calculating Q", () => {
const ps = Session.getInstance().createNub(
new Props({ calcType: CalculatorType.ParallelStructure })
) as ParallelStructure;
ps.prms.Q.singleValue = 2.309;
ps.addChild(CreateStructure(LoiDebit.RectangularOrificeFree));
ps.prms.Z1.singleValue = 105;
ps.prms.Z2.singleValue = 102;
ps.structures[0].prms.ZDV.singleValue = 101.5;
const res = ps.CalcSerie().resultElement;
expect(res.log.messages.length).toBe(1);
expect(
res.log.messages[0].code
).toBe(MessageCode.WARNING_DOWNSTREAM_ELEVATION_POSSIBLE_SUBMERSION);
});
it("example with StructureRectangularOrificeFree, h2 > 0, calculating something other than Q", () => {
const ps = Session.getInstance().createNub(
new Props({ calcType: CalculatorType.ParallelStructure })
) as ParallelStructure;
ps.prms.Q.singleValue = 2.309;
const c = CreateStructure(LoiDebit.RectangularOrificeFree) as StructureRectangularOrificeFree;
ps.addChild(c);
ps.prms.Z1.singleValue = 105;
ps.prms.Z2.singleValue = 102;
ps.structures[0].prms.ZDV.singleValue = 101.5;
ps.calculatedParam = c.prms.L;
const res = ps.CalcSerie().resultElement;
expect(res.log.messages.length).toBe(1);
expect(
res.log.messages[0].code
).toBe(MessageCode.WARNING_DOWNSTREAM_ELEVATION_POSSIBLE_SUBMERSION);
211212213214
});
});
});