Ajout des calculs pour les dimensions de la passe à bassins, correction des tests unitaires

spec/nubtest.ts

@@ -84,7 +84,7 @@ export function equalEpsilon(val1: number, val2: number, epsilon: number = precD
  * @param val1 Première valeur à comparer
  * @param val2 Deuxième valeur à comparer
  */
-function check(val1: Result, val2: number) {
+export function check(val1: Result, val2: number) {
     expect(equalEpsilon(val1.vCalc, val2)).toBe(true);
 }
 

spec/pab/pab_dimension.spec.ts

@@ -2,7 +2,7 @@
 /// <reference path="../../node_modules/@types/jasmine/index.d.ts" />
 
 import { Result } from "../../src/util/result";
-import { PabDimension, PabDimensionParams } from "../src/pab/pab_dimension";
+import { PabDimension, PabDimensionParams } from "../../src/pab/pab_dimension";
 import { check } from "../nubtest";
 
 function pabDimensionTest(varTest: string) {
@@ -16,11 +16,11 @@ function pabDimensionTest(varTest: string) {
             );
 
             let res: number = prms[varTest].v;
-            prms[varTest].v = undefined;
 
             const nub = new PabDimension(prms);
+            prms[varTest].v = undefined;
 
-            check(nub.Calc(), res);
+            check(nub.Calc(varTest), res);
         });
     });
 }

src/index.ts

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

src/pab/pab_dimension.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 PabDimensionParams extends ParamsEquation {
+    [key: string]: any; // pour pouvoir faire this['methode]();
+
+    /** Longueur L */
+    private _L: ParamDefinition;
+
+    /** Largeur W */
+    private _W: ParamDefinition;
+
+    /** Tirant d'eau Y */
+    private _Y: ParamDefinition;
+
+    /** Volume V */
+    private _V: ParamDefinition;
+
+    constructor(rL: number, rW: number, rY: number, rV: number = undefined) {
+        super();
+        this._L = new ParamDefinition(ComputeNodeType.PabDimensions, 'L', ParamDomainValue.POS, rL);
+        this._W = new ParamDefinition(ComputeNodeType.PabDimensions, 'W', ParamDomainValue.POS, rW);
+        this._Y = new ParamDefinition(ComputeNodeType.PabDimensions, 'Y', ParamDomainValue.POS, rY);
+        this._V = new ParamDefinition(ComputeNodeType.PabDimensions, 'V', ParamDomainValue.POS, rV);
+
+        this.addParamDefinition(this._L);
+        this.addParamDefinition(this._W);
+        this.addParamDefinition(this._Y);
+        this.addParamDefinition(this._V);
+    }
+
+    get L() {
+        return this._L;
+    }
+
+    get W() {
+        return this._W;
+    }
+
+    get Y() {
+        return this._Y;
+    }
+
+    get V() {
+        return this._V;
+    }
+}
+export class PabDimension extends Nub {
+    constructor(prms: PabDimensionParams, dbg: boolean = false) {
+        super(prms, dbg);
+    }
+
+    /**
+     * paramètres castés au bon type
+     */
+    get prms(): PabDimensionParams {
+        return <PabDimensionParams>this._prms;
+    }
+
+    /**
+     * paramétrage de la calculabilité des paramètres
+     */
+    protected setParametersCalculability() {
+        this.prms.L.calculability = ParamCalculability.EQUATION;
+        this.prms.W.calculability = ParamCalculability.EQUATION;
+        this.prms.Y.calculability = ParamCalculability.EQUATION;
+        this.prms.V.calculability = ParamCalculability.EQUATION;
+    }
+
+    Equation(sVarCalc: string): Result {
+        let v: number;
+
+        switch (sVarCalc) {
+            case "V":
+                v = this.prms.L.v * this.prms.W.v * this.prms.Y.v;
+                break;
+
+            case "L":
+                v = this.prms.V.v / this.prms.W.v / this.prms.Y.v;
+                break
+
+            case "W":
+                v = this.prms.V.v / this.prms.L.v / this.prms.Y.v;
+                break;
+
+            case "Y":
+                v = this.prms.V.v / this.prms.L.v / this.prms.W.v;
+                break;
+
+            default:
+                throw "PabDimension.Equation() : invalid variable name " + sVarCalc;
+        }
+
+        return new Result(v);
+    }
+}

src/param.ts

@@ -421,6 +421,7 @@ export enum ComputeNodeType {
     RegimeUniformeTrapeze, RegimeUniformeRectangle, RegimeUniformeCercle, RegimeUniformePuissance,
     CourbeRemous, // paramètres communs à toutes les courbes de remous
     CourbeRemousTrapeze, CourbeRemousRectangle, CourbeRemousCercle, CourbeRemousPuissance,
+    PabDimensions, // passe à bassin rectangulaire
     Test
 }
 

src/parameters.ts

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