#33 PAB 1ère version qui compile

spec/pab/pab.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 test_func.ts
+ */
+// import { describe, expect, it, xdescribe, xit } from "../mock_jasmine";
+
+import { Pab, PabParams } from "../../src/pab/pab";
+import { PabCloisons } from "../../src/pab/pab_cloisons";
+import { Cloisons, CloisonsParams } from "../../src/structure/cloisons";
+
+/**
+ * Exemple formation Cassiopée 2018-09
+ */
+
+// Modèle de cloison
+const modelCloisons = new Cloisons(
+    new CloisonsParams(
+        0.773,      // Débit total (m3/s)
+        78.27,    // Cote de l'eau amont (m)
+        3.1,     // Longueur des bassins (m)
+        2.5,      // Largeur des bassins (m)
+        1.5,      // Profondeur moyenne (m)
+        0.23     // Hauteur de chute (m)
+    )
+);
+
+const pab: Pab = new Pab(
+    new PabParams(
+        0,
+        78.27,
+        74.86
+    )
+);
+
+const pabCloison = new PabCloisons(modelCloisons);
+
+for (let i = 0; i < 15; i++) {
+    pab.addChild(pabCloison);
+}
+
+describe("Class Pab: ", () => {
+    describe("Calc(Z1) Exemple Formation 2018-09 p.14", () => {
+        it("vCalc(Z1) should return 78.27", () => {
+            expect(pab.Calc("Z1").vCalc).toBeCloseTo(78.27, 2);
+        });
+    });
+});

src/pab/pab.ts

+import { Nub } from "../nub";
+import { ParamCalculability } from "../param/param-definition";
+import { Result } from "../util/result";
+import { PabCloisons } from "./pab_cloisons";
+import { PabParams } from "./pab_params";
+
+export { PabParams };
+
+export class Pab extends Nub {
+
+    /**
+     * paramètres castés au bon type
+     */
+    get prms(): PabParams {
+        return this._prms as PabParams;
+    }
+
+    /** Tableau des cloisons en série */
+    protected _pabCloisons: PabCloisons[] = [];
+
+    /**
+     * Calcul analytique
+     * @param sVarCalc Variable à calculer (Z1 uniquement)
+     */
+    public Equation(sVarCalc: string): Result {
+        const r: Result = new Result(0, this);
+        let Z: number = this.prms.Z2.v;
+        for (const cloison of this._pabCloisons) {
+            cloison.prms.Z2.v = Z;
+            cloison.Calc("Z1");
+            Z = cloison.prms.Z1.v;
+        }
+        this.prms.Z1.v = Z;
+        return r;
+    }
+
+    /**
+     * Ajout d'une cloison en série
+     * @param structure La structure à rajouter
+     * @param after position après laquelle insérer la cloison, à la fin sinon
+     */
+    public addChild(pabCloisons: PabCloisons, after?: number) {
+        if (after !== undefined) {
+            this._pabCloisons.splice(after + 1, 0, pabCloisons);
+        } else {
+            this._pabCloisons.push(pabCloisons);
+        }
+        // add reference to parent collection (this)
+        pabCloisons.parent = this;
+        // propagate precision
+        pabCloisons.prms.Pr.setValue(this.prms.Pr.v); // does not write to .v to bypass calculability control
+    }
+
+    /**
+     * paramétrage de la calculabilité des paramètres
+     */
+    protected setParametersCalculability() {
+        this.prms.Z1.calculability = ParamCalculability.EQUATION;
+        this.prms.Z2.calculability = ParamCalculability.DICHO;
+        this.prms.Q.calculability = ParamCalculability.DICHO;
+    }
+}
\ No newline at end of file

src/pab/pab_cloisons.ts

+import { ParamCalculability, ParamDefinition, ParamFamily} from "../param/param-definition";
+import { ParamDomainValue } from "../param/param-domain";
+import { ParamsEquation } from "../param/params-equation";
+import { Cloisons, CloisonsParams } from "../structure/cloisons";
+import { Pab } from "./pab";
+
+class PabCloisonsParams extends CloisonsParams {
+
+   /** Débit entrant à l'amont de la passe (m3/s) */
+   public QA: ParamDefinition;
+
+    /**
+     * Paramètres communs à toutes les équations de structure
+     * @param rQ Débit total (m3/s)
+     * @param rZ1 Cote de l'eau amont (m)
+     * @param rLB Longueur des bassins (m)
+     * @param rBB Largeur des bassins (m)
+     * @param rPB Profondeur moyenne (m)
+     * @param rDH Hauteur de chute (m)
+     */
+    constructor(modelCloisonsParams: CloisonsParams, rQA: number = 0) {
+        super(
+            modelCloisonsParams.Q.v,
+            modelCloisonsParams.Z1.v,
+            modelCloisonsParams.LB.v,
+            modelCloisonsParams.BB.v,
+            modelCloisonsParams.PB.v,
+            modelCloisonsParams.DH.v
+        );
+        this.Q = modelCloisonsParams.Q;
+        this.Z1 = modelCloisonsParams.Z1;
+        this.LB = modelCloisonsParams.LB;
+        this.BB = modelCloisonsParams.BB;
+        this.PB = modelCloisonsParams.PB;
+        this.DH = modelCloisonsParams.DH;
+        // Force la MAJ de la map avec les propriétés pointant vers celles de CloisonsParam
+        this.addParamDefinitions(modelCloisonsParams);
+        // On garde Pr en propre sur cet objet (Pointage impossible car en lecture seule)
+        this.addParamDefinition(this.Pr, true);
+
+        this.QA = new ParamDefinition(this, "QA", ParamDomainValue.ANY, rQA, ParamFamily.FLOWS);
+        this.addParamDefinition(this.QA);
+    }
+
+}
+
+// tslint:disable-next-line:max-classes-per-file
+export class PabCloisons extends Cloisons {
+
+    public parent: Pab;
+
+    constructor(modelCloisons: Cloisons, rQA: number = 0, dbg: boolean = false) {
+        super(new PabCloisonsParams(modelCloisons.prms, rQA), dbg);
+        this._structures = modelCloisons.structures;
+    }
+
+    /**
+     * paramètres castés au bon type
+     */
+    get prms(): PabCloisonsParams {
+        return this._prms as PabCloisonsParams;
+    }
+
+    /**
+     * paramétrage de la calculabilité des paramètres
+     */
+    protected setParametersCalculability() {
+        super.setParametersCalculability();
+        this.prms.QA.calculability = ParamCalculability.FREE;
+    }
+
+}

src/pab/pab_params.ts

+import { ParamDefinition, ParamFamily } from "../param/param-definition";
+import { ParamDomainValue } from "../param/param-domain";
+import { ParamsEquation } from "../param/params-equation";
+
+/**
+ * Parameters of a fish ladder
+ */
+export class PabParams extends ParamsEquation {
+
+    /** Débit entrant à l'amont de la passe (m3/s) */
+    public Q: ParamDefinition;
+
+    /** Cote de l'eau amont (m) */
+    public Z1: ParamDefinition;
+
+    /** Cote de l'eau aval (m) */
+    public Z2: ParamDefinition;
+
+    /**
+     * Paramètres communs à toutes les équations de structure
+     * @param rZ1 Cote de l'eau amont (m)
+     * @param rZ2 Cote de l'eau aval (m)
+     */
+    constructor(rQ: number, rZ1: number, rZ2: number) {
+        super();
+        this.Q = new ParamDefinition(this, "Q", ParamDomainValue.ANY, rZ1, ParamFamily.FLOWS);
+        this.addParamDefinition(this.Q);
+        this.Z1 = new ParamDefinition(this, "Z1", ParamDomainValue.ANY, rZ1, ParamFamily.ELEVATIONS);
+        this.addParamDefinition(this.Z1);
+        this.Z2 = new ParamDefinition(this, "Z2", ParamDomainValue.ANY, rZ2, ParamFamily.ELEVATIONS);
+        this.addParamDefinition(this.Z2);
+    }
+}

src/param/params-equation.ts

@@ -168,15 +168,16 @@ export abstract class ParamsEquation implements Iterable<ParamDefinition> {
         return new ParamDefinitionIterator(this);
     }
 
-    protected addParamDefinition(p: ParamDefinition) {
-        if (!this.hasParameter(p.symbol)) {
+    protected addParamDefinition(p: ParamDefinition, force: boolean = false) {
+        if (force || !this.hasParameter(p.symbol)) {
             this._paramMap[p.symbol] = p;
         }
     }
 
     protected addParamDefinitions(ps: ParamsEquation) {
         for (const p of ps) {
-            this.addParamDefinition(p);
+            // Force update of the map index
+            this.addParamDefinition(p, true);
         }
     }
 }

src/structure/cloisons.ts

@@ -85,6 +85,9 @@ export class Cloisons extends ParallelStructure {
         );
         r.extraResults.PV = puissanceNub.Calc("PV", 0).vCalc;
 
+        // Ajout de la cote de radier
+        r.extraResults.ZB = prms.Z1 - prms.DH - prms.PB;
+
         return r;
     }