Ajout des calculs pour le noeud "passe à bassins : puissance dissipée"

spec/pab/pab_puissance.spec.ts

@@ -2,7 +2,7 @@
 /// <reference path="../../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../../src/util/result";
-import { PabPuissance, PabPuissanceParams } from "pab_puissance";
+import { PabPuissance, PabPuissanceParams } from "../../src/pab/pab_puissance";
 import { check } from "../nubtest";
 
 function PabPuissanceTest(varTest: string) {
@@ -16,11 +16,11 @@ function PabPuissanceTest(varTest: string) {
             );
 
             let res: number = prms[varTest].v;
-            prms[varTest].v = undefined;
 
             const nub = new PabPuissance(prms);
+            prms[varTest].v = undefined;
 
-            check(nub.Calc(), res);
+            check(nub.Calc(varTest, 1e-9), res);
         });
     });
 }
@@ -34,5 +34,4 @@ describe("Class PabPuissance: ", () => {
     PabPuissanceTest("Q");
     PabPuissanceTest("V");
     PabPuissanceTest("Pv");
-
 });

src/index.ts

@@ -19,3 +19,4 @@ export * from './util/log';
 export * from './util/result';
 export * from './util/interval';
 export * from './pab/pab_dimension';
+export * from './pab/pab_puissance';

src/pab/pab_puissance.ts

+import { Result } from "../util/result";
+import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability, ParamsEquation } from "../param";
+import { NumericalString } from "../index";
+import { Nub } from "../nub";
+
+export class PabPuissanceParams extends ParamsEquation {
+    [key: string]: any; // pour pouvoir faire this['methode]();
+
+    /** Chute entre bassins DH */
+    private _DH: ParamDefinition;
+
+    /** Débit Q */
+    private _Q: ParamDefinition;
+
+    /** Volume V */
+    private _V: ParamDefinition;
+
+    /** Puissance dissipée PV */
+    private _Pv: ParamDefinition;
+
+    constructor(rDH: number, rQ: number, rV: number, rPV: number = undefined) {
+        super();
+        this._DH = new ParamDefinition(ComputeNodeType.PabPuissance, 'DH', ParamDomainValue.POS, rDH);
+        this._Q = new ParamDefinition(ComputeNodeType.PabPuissance, 'Q', ParamDomainValue.POS, rQ);
+        this._V = new ParamDefinition(ComputeNodeType.PabPuissance, 'V', ParamDomainValue.POS, rV);
+        this._Pv = new ParamDefinition(ComputeNodeType.PabPuissance, 'Pv', ParamDomainValue.POS, rPV);
+
+        this.addParamDefinition(this._DH);
+        this.addParamDefinition(this._Q);
+        this.addParamDefinition(this._V);
+        this.addParamDefinition(this._Pv);
+    }
+
+    get DH() {
+        return this._DH;
+    }
+
+    get Q() {
+        return this._Q;
+    }
+
+    get V() {
+        return this._V;
+    }
+
+    get Pv() {
+        return this._Pv;
+    }
+}
+export class PabPuissance extends Nub {
+    constructor(prms: PabPuissanceParams, dbg: boolean = false) {
+        super(prms, dbg);
+    }
+
+    /**
+     * paramètres castés au bon type
+     */
+    get prms(): PabPuissanceParams {
+        return <PabPuissanceParams>this._prms;
+    }
+
+    /**
+     * paramétrage de la calculabilité des paramètres
+     */
+    protected setParametersCalculability() {
+        this.prms.DH.calculability = ParamCalculability.DICHO;
+        this.prms.Q.calculability = ParamCalculability.DICHO;
+        this.prms.V.calculability = ParamCalculability.DICHO;
+        this.prms.Pv.calculability = ParamCalculability.EQUATION;
+    }
+
+    Equation(sVarCalc: string): Result {
+        let v: number;
+
+        switch (sVarCalc) {
+            case "Pv":
+                const ro: number = 1000;     // masse volumique de l'eau en kg/m3
+                const g: number = 9.81;     // accélération de la gravité terrestre en m/s2.
+                v = ro * g * this.prms.Q.v * this.prms.DH.v / this.prms.V.v;
+                break;
+
+            default:
+                throw "PabPuissance.Equation() : invalid variable name " + sVarCalc;
+        }
+
+        return new Result(v);
+    }
+}

src/param.ts

@@ -422,6 +422,7 @@ export enum ComputeNodeType {
     CourbeRemous, // paramètres communs à toutes les courbes de remous
     CourbeRemousTrapeze, CourbeRemousRectangle, CourbeRemousCercle, CourbeRemousPuissance,
     PabDimensions, // passe à bassin rectangulaire
+    PabPuissance, // passe à bassin : énergie dissipée
     Test
 }
 

src/parameters.ts

@@ -9,6 +9,7 @@ import { ParamsSectionPuiss, cSnPuiss } from "./section/section_puissance";
 import { RegimeUniforme } from "./regime_uniforme";
 import { CourbeRemous, CourbeRemousParams } from "./remous";
 import { PabDimensionParams, PabDimension } from "./pab/pab_dimension";
+import { PabPuissanceParams, PabPuissance } from "./pab/pab_puissance";
 
 export class ComputeNodeParameters {
     private static _instance: ComputeNodeParameters;
@@ -166,6 +167,13 @@ export class ComputeNodeParameters {
                     return cn;
                 }
 
+            case ComputeNodeType.PabPuissance:
+                {
+                    let cn = new PabPuissanceParams(undefined, undefined, undefined);
+                    let n = new PabPuissance(cn); // pour initialiser la calculabilité des paramètres
+                    return cn;
+                }
+
             default:
                 throw "ComputeNodeParameters.getComputeNodeParameters() : noeud de calcul '" + ComputeNodeType[type] + "' non pris en charge";
         }