#29 Ajout de l'équation du seuil triangulaire tronqué

spec/structure/structure_triangular_trunc_weir_free.spec.ts

+/**
+ * IMPORTANT !
+ * Décommenter temporairement la ligne suivante (import { } from "./mock_jasmine")
+ * Pour exécuter ce code dans le débugger.
+ * Faire de même avec le fichier rectangular_structure.ts
+ */
+// import { describe, expect, it, xdescribe } from "../mock_jasmine";
+
+import { StructureFlowMode, StructureFlowRegime } from "../../src/structure/structure";
+import { StructureTriangularTruncWeirFree } from "../../src/structure/structure_triangular_trunc_weir_free";
+import { TriangularTruncStructureParams } from "../../src/structure/triangular_trunc_structure_params";
+import { itCalcQ } from "./functions";
+
+const structPrm: TriangularTruncStructureParams =
+    new TriangularTruncStructureParams(0, 100.1, 100.1, 100, 0.9, 101, 1.36);
+const structTest: StructureTriangularTruncWeirFree = new StructureTriangularTruncWeirFree(structPrm, false);
+
+describe("Class StructureTriangularTruncWeirFree: ", () => {
+    describe("Calcul Q a surface libre avec h1 croissant: ", () => {
+        const h1: number[] =
+            [100.1, 100.2, 100.3, 100.4, 100.5, 100.6, 100.7, 100.8, 100.9, 101, 101.1, 101.5, 101.8, 102];
+        const Q: number[] =
+            [0., 0.004, 0.024, 0.067, 0.138, 0.240, 0.379, 0.558, 0.778, 1.045, 1.356, 2.914, 4.346, 5.407];
+        const mode: StructureFlowMode = StructureFlowMode.WEIR;
+        const regime: StructureFlowRegime = StructureFlowRegime.FREE;
+        itCalcQ(structTest, h1[0], Infinity, Q[0], StructureFlowMode.NULL, StructureFlowRegime.NULL);
+        for (let i = 1; i < Q.length; i++) {
+            itCalcQ(structTest, h1[i], Infinity, Q[i], mode, regime);
+        }
+    });
+});

spec/structure/structure_triangular_weir_free.spec.ts

@@ -14,7 +14,7 @@ import { itCalcQ } from "./functions";
 const structPrm: TriangularStructureParams = new TriangularStructureParams(0, 100.1, 100.1, 100, 45, 1.36);
 const structTest: StructureTriangularWeirFree = new StructureTriangularWeirFree(structPrm, false);
 
-describe("Class StructureWeirFree: ", () => {
+describe("Class StructureTriangularWeirFree: ", () => {
     describe("Calcul Q a surface libre avec h1 croissant: ", () => {
         const h1: number[] = [100.1, 100.2, 100.3, 100.4, 100.5, 100.6, 100.7, 100.8, 100.9, 101, 102];
         const Q: number[] = [0., 0.004, 0.024, 0.067, 0.138, 0.240, 0.379, 0.558, 0.778, 1.045, 6.767];

src/structure/structure_triangular_trunc_weir_free.ts

+import { Result } from "../util/result";
+import { Structure, StructureFlowMode, StructureFlowRegime } from "./structure";
+import { TriangularTruncStructureParams } from "./triangular_trunc_structure_params";
+
+export { TriangularTruncStructureParams };
+
+/**
+ * Equation classique seuil triangulaire dénoyé
+ */
+export class StructureTriangularTruncWeirFree extends Structure {
+
+    constructor(prms: TriangularTruncStructureParams, dbg: boolean = false) {
+        super(prms, dbg);
+    }
+
+    /**
+     * paramètres castés au bon type
+     */
+    get prms(): TriangularTruncStructureParams {
+        return this._prms as TriangularTruncStructureParams;
+    }
+
+    /**
+     * Calcul analytique Q = f(Cd, L, h1, h2, W) seuil dénoyé
+     * @param sVarCalc Variable à calculer (doit être "Q")
+     */
+    public Equation(sVarCalc: string): Result {
+        Structure.CheckEquation(sVarCalc);
+        const data = this.getResultData();
+
+        let v: number = this.prms.Cd.v * this.prms.B2.v / (this.prms.ZT.v - this.prms.ZDV.v);
+        if (this.prms.Z1.v <= this.prms.ZT.v) {
+            v = v * Math.pow(this.prms.h1.v, 2.5);
+        } else {
+            v = v * (Math.pow(this.prms.h1.v, 2.5) - Math.pow(this.prms.Z1.v - this.prms.ZT.v, 2.5));
+        }
+
+        return new Result(v, data);
+    }
+
+    protected getFlowRegime() {
+        return StructureFlowRegime.FREE;
+    }
+
+    protected getFlowMode() {
+        return StructureFlowMode.WEIR;
+    }
+
+}

src/structure/triangular_trunc_structure_params.ts

+import { ParamDefinition } from "../param/param-definition";
+import { ParamDomainValue } from "../param/param-domain";
+import { StructureParams } from "./structure_params";
+
+/**
+ * Parameters for rectangular structures (common for all rectangular structure equations)
+ */
+export class TriangularTruncStructureParams extends StructureParams {
+    /** Demi-ouverture du triangle (m) */
+    public B2: ParamDefinition;
+
+    /** Cote haute du triangle (m) */
+    public ZT: ParamDefinition;
+
+    /** Discharge coefficient */
+    // tslint:disable-next-line:variable-name
+    public Cd: ParamDefinition;
+
+    /**
+     * Constructeur d'une structure rectangulaire
+     * @param rQ    Débit (m3/s)
+     * @param rZDV  Cote de la crête du déversoir ou du radier de la vanne (m)
+     * @param rZ1   Cote de l'eau amont (m)
+     * @param rZ2   Cote de l'eau aval (m)
+     * @param rB2   Demi-ouverture du triangle (m)
+     * @param rZT   Cote haute du triangle (m)
+     * @param rCd   Coefficient de débit (-)
+     * @param rW    Ouverture de la vanne (m) (Valeur par défaut +infinity pour les déversoirs)
+     */
+    constructor(
+        rQ: number, rZDV: number, rZ1: number, rZ2: number,
+        rB2: number, rZT: number, rCd: number, rW: number = Infinity
+    ) {
+        super(rQ, rZDV, rZ1, rZ2, rW);
+        this.B2 = new ParamDefinition("B2", ParamDomainValue.POS, rB2);
+        this.addParamDefinition(this.B2);
+        this.ZT = new ParamDefinition("ZT", ParamDomainValue.POS, rZT);
+        this.addParamDefinition(this.ZT);
+        this.Cd = new ParamDefinition("Cd", ParamDomainValue.POS, rCd);
+        this.addParamDefinition(this.Cd);
+    }
+}