closes #41

spec/nubtest.ts

 import { Result } from "../src/util/result";
 import { Nub } from "../src/nub";
-import { ComputeNodeType, ParamCalculability, ParamDefinition, ParamDomainValue, ParamsEquation } from "../src/param";
+import { ParamCalculability, ParamDefinition, ParamDomainValue, ParamsEquation } from "../src/param";
 
 class NubTestParams extends ParamsEquation {
     private _A: ParamDefinition;
@@ -9,9 +9,9 @@ class NubTestParams extends ParamsEquation {
 
     constructor() {
         super();
-        this._A = new ParamDefinition(ComputeNodeType.Test, "A", ParamDomainValue.POS_NULL, 1);
-        this._B = new ParamDefinition(ComputeNodeType.Test, "B", ParamDomainValue.POS_NULL, 2);
-        this._C = new ParamDefinition(ComputeNodeType.Test, "C", ParamDomainValue.POS_NULL, 3);
+        this._A = new ParamDefinition(undefined, "A", ParamDomainValue.POS_NULL, 1);
+        this._B = new ParamDefinition(undefined, "B", ParamDomainValue.POS_NULL, 2);
+        this._C = new ParamDefinition(undefined, "C", ParamDomainValue.POS_NULL, 3);
 
         this.addParamDefinition(this._A);
         this.addParamDefinition(this._B);

src/cond_distri.ts

 import { Result } from "./util/result";
-import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability, ParamsEquation } from "./param";
+import { ParamDefinition, ParamDomainValue, ParamCalculability, ParamsEquation, CalculatorType } from "./param";
 import { Nub } from "./nub";
 
 /**
@@ -23,11 +23,11 @@ export class ConduiteDistribParams extends ParamsEquation {
 
     constructor(rQ: number, rD: number, rJ: number, rLg: number, rNu: number) {
         super();
-        this.Q = new ParamDefinition(ComputeNodeType.CondDistri, 'Q', ParamDomainValue.POS, rQ);
-        this.D = new ParamDefinition(ComputeNodeType.CondDistri, 'D', ParamDomainValue.POS, rD);
-        this.J = new ParamDefinition(ComputeNodeType.CondDistri, 'J', ParamDomainValue.POS, rJ);
-        this.Lg = new ParamDefinition(ComputeNodeType.CondDistri, 'Lg', ParamDomainValue.POS, rLg);
-        this.Nu = new ParamDefinition(ComputeNodeType.CondDistri, 'Nu', ParamDomainValue.POS, rNu);
+        this.Q = new ParamDefinition(CalculatorType.ConduiteDistributrice, 'Q', ParamDomainValue.POS, rQ);
+        this.D = new ParamDefinition(CalculatorType.ConduiteDistributrice, 'D', ParamDomainValue.POS, rD);
+        this.J = new ParamDefinition(CalculatorType.ConduiteDistributrice, 'J', ParamDomainValue.POS, rJ);
+        this.Lg = new ParamDefinition(CalculatorType.ConduiteDistributrice, 'Lg', ParamDomainValue.POS, rLg);
+        this.Nu = new ParamDefinition(CalculatorType.ConduiteDistributrice, 'Nu', ParamDomainValue.POS, rNu);
 
         this.addParamDefinition(this.Q);
         this.addParamDefinition(this.D);

src/lechaptcalmon.ts

 import { Result } from "./util/result";
-import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability, ParamsEquation } from "./param";
+import { ParamDefinition, ParamDomainValue, ParamCalculability, ParamsEquation, CalculatorType } from "./param";
 import { Nub } from "./nub";
 
 /**
@@ -29,13 +29,13 @@ export class LechaptCalmonParams extends ParamsEquation {
 
     constructor(rQ: number, rD: number, rJ: number, rLg: number, rL: number, rM: number, rN: number) {
         super();
-        this._Q = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'Q', ParamDomainValue.POS, rQ);
-        this._D = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'D', ParamDomainValue.POS, rD);
-        this._J = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'J', ParamDomainValue.POS, rJ);
-        this._Lg = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'Lg', ParamDomainValue.POS, rLg);
-        this._L = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'L', ParamDomainValue.POS, rL);
-        this._M = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'M', ParamDomainValue.POS, rM);
-        this._N = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'N', ParamDomainValue.POS, rN);
+        this._Q = new ParamDefinition(CalculatorType.LechaptCalmon, 'Q', ParamDomainValue.POS, rQ);
+        this._D = new ParamDefinition(CalculatorType.LechaptCalmon, 'D', ParamDomainValue.POS, rD);
+        this._J = new ParamDefinition(CalculatorType.LechaptCalmon, 'J', ParamDomainValue.POS, rJ);
+        this._Lg = new ParamDefinition(CalculatorType.LechaptCalmon, 'Lg', ParamDomainValue.POS, rLg);
+        this._L = new ParamDefinition(CalculatorType.LechaptCalmon, 'L', ParamDomainValue.POS, rL);
+        this._M = new ParamDefinition(CalculatorType.LechaptCalmon, 'M', ParamDomainValue.POS, rM);
+        this._N = new ParamDefinition(CalculatorType.LechaptCalmon, 'N', ParamDomainValue.POS, rN);
 
         this.addParamDefinition(this._Q);
         this.addParamDefinition(this._D);

src/pab/pab_dimension.ts

 import { Result } from "../util/result";
-import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability, ParamsEquation } from "../param";
-import { NumericalString } from "../util/numericalstring";
+import { ParamDefinition, ParamDomainValue, ParamCalculability, ParamsEquation, CalculatorType } from "../param";
 import { Nub } from "../nub";
 
 export class PabDimensionParams extends ParamsEquation {
@@ -20,10 +19,10 @@ export class PabDimensionParams extends ParamsEquation {
 
     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._L = new ParamDefinition(CalculatorType.PabDimensions, 'L', ParamDomainValue.POS, rL);
+        this._W = new ParamDefinition(CalculatorType.PabDimensions, 'W', ParamDomainValue.POS, rW);
+        this._Y = new ParamDefinition(CalculatorType.PabDimensions, 'Y', ParamDomainValue.POS, rY);
+        this._V = new ParamDefinition(CalculatorType.PabDimensions, 'V', ParamDomainValue.POS, rV);
 
         this.addParamDefinition(this._L);
         this.addParamDefinition(this._W);

src/pab/pab_puissance.ts

 import { Result } from "../util/result";
-import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability, ParamsEquation } from "../param";
-import { NumericalString } from "../util/numericalstring";
+import { ParamDefinition, ParamDomainValue, ParamCalculability, ParamsEquation, CalculatorType } from "../param";
 import { Nub } from "../nub";
 
 export class PabPuissanceParams extends ParamsEquation {
@@ -20,10 +19,10 @@ export class PabPuissanceParams extends ParamsEquation {
 
     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._DH = new ParamDefinition(CalculatorType.PabPuissance, 'DH', ParamDomainValue.POS, rDH);
+        this._Q = new ParamDefinition(CalculatorType.PabPuissance, 'Q', ParamDomainValue.POS, rQ);
+        this._V = new ParamDefinition(CalculatorType.PabPuissance, 'V', ParamDomainValue.POS, rV);
+        this._Pv = new ParamDefinition(CalculatorType.PabPuissance, 'Pv', ParamDomainValue.POS, rPV);
 
         this.addParamDefinition(this._DH);
         this.addParamDefinition(this._Q);

src/param.ts

-// import { Debug, UndefinedError } from './base';
 import { Debug } from "./base";
 import { DefinedNumber } from "./util/definedvalue";
 import { Interval } from "./util/interval";
@@ -291,6 +290,11 @@ export class ParamDefinition extends BaseParam {
      */
     private _calc: ParamCalculability;
 
+    /**
+     * calculette parente
+     */
+    private _calculatorType: CalculatorType;
+
     /**
      * noeud de calcul parent
      */
@@ -299,8 +303,9 @@ export class ParamDefinition extends BaseParam {
     // private static _idGen: number = 0; // A VIRER
     // private _id: number; // A VIRER
 
-    constructor(nt: ComputeNodeType, s: string, d: ParamDomain | ParamDomainValue, val: number = undefined) {
+    constructor(ct: CalculatorType, s: string, d: ParamDomain | ParamDomainValue, val?: number, nt: ComputeNodeType = ComputeNodeType.None) {
         super(s, d, val);
+        this._calculatorType = ct;
         this._computeNodeType = nt;
 
         this._calc = undefined;
@@ -358,9 +363,8 @@ export class ParamDefinition extends BaseParam {
     }
 
     public clone(): ParamDefinition {
-        const res = new ParamDefinition(this._computeNodeType, this.symbol, this.getDomain().clone());
+        const res = new ParamDefinition(this._calculatorType, this.symbol, this.getDomain().clone(), this.uncheckedValue, this._computeNodeType);
         res._calc = this._calc;
-        res.value = this.uncheckedValue;
         return res;
     }
 }
@@ -444,20 +448,26 @@ export abstract class ParamsEquation implements Iterable<ParamDefinition> {
     }
 }
 
+/** 
+ * type de calculette
+ */
+export enum CalculatorType {
+    ConduiteDistributrice, LechaptCalmon, SectionParametree, RegimeUniforme, CourbeRemous,
+    PabDimensions, // passe à bassin rectangulaire
+    PabPuissance, // passe à bassin : puissance dissipée
+    Structure,  // ouvrages hydrauliques simples
+    ParallelStructure  // ouvrages hydrauliques en parallèle
+}
+
 /**
- * type de noeud de calcul
+ * type de noeud de calcul (sous type de calculette)
  */
 export enum ComputeNodeType {
-    CondDistri, LechaptCalmon,
-    SectionParametree, // paramètres communs à toutes les sections paramétrées
+    None,
+    // types de sections
     SectionTrapeze, SectionRectangle, SectionCercle, SectionPuissance,
-    RegimeUniforme, // paramètres communs à toutes les sections paramétrées
-    RegimeUniformeTrapeze, RegimeUniformeRectangle, RegimeUniformeCercle, RegimeUniformePuissance,
-    CourbeRemous, // paramètres communs à toutes les courbes de remous
-    CourbeRemousTrapeze, CourbeRemousRectangle, CourbeRemousCercle, CourbeRemousPuissance,
-    PabDimensions, // passe à bassin rectangulaire
-    PabPuissance, // passe à bassin : énergie dissipée
-    Test
+    // types d'ouvrages hydrauliques
+    StructureRectangle,
 }
 
 /**

src/parameters.ts

-import { ComputeNodeType, ParamsEquation } from "./param";
+import { ComputeNodeType, ParamsEquation, CalculatorType, ParamDefinition } from "./param";
 import { ConduiteDistribParams, ConduiteDistrib } from "./cond_distri";
 import { LechaptCalmonParams, LechaptCalmon } from "./lechaptcalmon";
-import { ParamsSection, acSection } from "./section/section_type";
+import { acSection } from "./section/section_type";
 import { ParamsSectionTrapez, cSnTrapez } from "./section/section_trapez";
 import { ParamsSectionRectang, cSnRectang } from "./section/section_rectang";
 import { ParamsSectionCirc, cSnCirc } from "./section/section_circulaire";
@@ -10,11 +10,17 @@ import { RegimeUniforme } from "./regime_uniforme";
 import { CourbeRemous, CourbeRemousParams } from "./remous";
 import { PabDimensionParams, PabDimension } from "./pab/pab_dimension";
 import { PabPuissanceParams, PabPuissance } from "./pab/pab_puissance";
+import { HashTable } from "./util/hashtable";
+
 
 export class ComputeNodeParameters {
     private static _instance: ComputeNodeParameters;
 
-    private constructor() { }
+    private _nodes: HashTable;
+
+    private constructor() {
+        this._nodes = new HashTable();
+    }
 
     public static getInstance() {
         if (ComputeNodeParameters._instance == undefined)
@@ -22,152 +28,90 @@ export class ComputeNodeParameters {
         return ComputeNodeParameters._instance;
     }
 
-    public getComputeNodeParameters(type: ComputeNodeType): ParamsEquation {
-        switch (type) {
-            case ComputeNodeType.CondDistri:
-                {
-                    let cn = new ConduiteDistribParams(undefined, undefined, undefined, undefined, undefined);
-                    let n = new ConduiteDistrib(cn); // pour initialiser la calculabilité des paramètres
-                    return cn;
-                }
-
-            case ComputeNodeType.LechaptCalmon:
-                {
-                    let cn = new LechaptCalmonParams(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
-                    let n = new LechaptCalmon(cn); // pour initialiser la calculabilité des paramètres
-                    return cn;
-                }
-
+    private createSection(nt: ComputeNodeType): acSection {
+        switch (nt) {
+            case ComputeNodeType.None: // pour les paramètres communs, n'importe quelle section convient
             case ComputeNodeType.SectionTrapeze:
                 {
-                    let cn = new ParamsSectionTrapez(undefined, undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined, undefined, undefined);
+                    let cn = new ParamsSectionTrapez(1, 0.5, undefined, undefined,
+                        1, undefined, 0.1, 1);
                     let n = new cSnTrapez(cn); // pour initialiser la calculabilité des paramètres
-                    return cn;
+                    return n;
                 }
 
             case ComputeNodeType.SectionRectangle:
                 {
-                    let cn = new ParamsSectionRectang(undefined, undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined);
+                    let cn = new ParamsSectionRectang(undefined, 1, undefined, 1,
+                        undefined, 0.1, 1);
                     let n = new cSnRectang(cn); // pour initialiser la calculabilité des paramètres
-                    return cn;
+                    return n;
                 }
 
             case ComputeNodeType.SectionCercle:
                 {
-                    let cn = new ParamsSectionCirc(undefined, undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined, undefined);
+                    let cn = new ParamsSectionCirc(1, undefined, undefined, 1,
+                        undefined, 0.1, 1);
                     let n = new cSnCirc(cn); // pour initialiser la calculabilité des paramètres
-                    return cn;
+                    return n;
                 }
 
             case ComputeNodeType.SectionPuissance:
                 {
-                    let cn = new ParamsSectionPuiss(undefined, undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined, undefined, undefined);
+                    let cn = new ParamsSectionPuiss(0.5, undefined, 1, undefined,
+                        1, undefined, 0.1, 1);
                     let n = new cSnPuiss(cn); // pour initialiser la calculabilité des paramètres
-                    return cn;
+                    return n;
                 }
 
-            case ComputeNodeType.RegimeUniformeTrapeze:
-                {
-                    let cn = new ParamsSectionTrapez(undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined, undefined,
-                        ComputeNodeType.RegimeUniformeTrapeze,
-                        ComputeNodeType.RegimeUniforme);
-                    let n = new cSnTrapez(cn);
-                    let ru = new RegimeUniforme(n); // pour initialiser la calculabilité des paramètres
-                    return cn;
-                }
+            default:
+                throw new Error(`type de section ${ComputeNodeType[nt]} non pris en charge`);
+        }
+    }
 
-            case ComputeNodeType.RegimeUniformeRectangle:
+    private createComputeNodeParameters(calcType: CalculatorType, nodeType: ComputeNodeType): ParamsEquation {
+        switch (calcType) {
+            case CalculatorType.ConduiteDistributrice:
                 {
-                    let cn = new ParamsSectionRectang(undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined,
-                        ComputeNodeType.RegimeUniforme);
-                    let n = new cSnRectang(cn);
-                    let ru = new RegimeUniforme(n); // pour initialiser la calculabilité des paramètres
+                    const cn = new ConduiteDistribParams(undefined, undefined, undefined, undefined, undefined);
+                    const n = new ConduiteDistrib(cn); // pour initialiser la calculabilité des paramètres
                     return cn;
                 }
 
-            case ComputeNodeType.RegimeUniformeCercle:
+            case CalculatorType.LechaptCalmon:
                 {
-                    let cn = new ParamsSectionCirc(undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined,
-                        ComputeNodeType.RegimeUniformeCercle,
-                        ComputeNodeType.RegimeUniforme);
-                    let n = new cSnCirc(cn);
-                    let ru = new RegimeUniforme(n); // pour initialiser la calculabilité des paramètres
+                    const cn = new LechaptCalmonParams(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+                    const n = new LechaptCalmon(cn); // pour initialiser la calculabilité des paramètres
                     return cn;
                 }
 
-            case ComputeNodeType.RegimeUniformePuissance:
+            case CalculatorType.SectionParametree:
                 {
-                    let cn = new ParamsSectionPuiss(undefined, undefined, undefined,
-                        undefined, undefined, undefined, undefined, undefined,
-                        ComputeNodeType.RegimeUniformePuissance,
-                        ComputeNodeType.RegimeUniforme);
-                    let n = new cSnPuiss(cn);
-                    let ru = new RegimeUniforme(n); // pour initialiser la calculabilité des paramètres
-                    return cn;
+                    const sect: acSection = this.createSection(nodeType);
+                    return sect.prms;
                 }
 
-            case ComputeNodeType.CourbeRemousCercle:
-                {
-                    let cn = new ParamsSectionCirc(1, undefined, undefined, 1, undefined,
-                        0.001, 1,
-                        ComputeNodeType.CourbeRemousCercle,
-                        ComputeNodeType.CourbeRemous);
-                    let n = new cSnCirc(cn);
-                    let crp = new CourbeRemousParams(n, undefined, undefined, undefined, undefined, undefined);
-                    let ru = new CourbeRemous(crp); // pour initialiser la calculabilité des paramètres
-                    return crp
-                }
+            case CalculatorType.RegimeUniforme:
+                const sect: acSection = this.createSection(nodeType);
+                const ru = new RegimeUniforme(sect); // pour initialiser la calculabilité des paramètres
+                return sect.prms;
 
-            case ComputeNodeType.CourbeRemousPuissance:
-                {
-                    let cn = new ParamsSectionPuiss(1, undefined, 1, undefined, 1,
-                        undefined, 0.001, 1,
-                        ComputeNodeType.CourbeRemousPuissance,
-                        ComputeNodeType.CourbeRemous);
-                    let n = new cSnPuiss(cn);
-                    let crp = new CourbeRemousParams(n, undefined, undefined, undefined, undefined, undefined);
-                    let ru = new CourbeRemous(crp); // pour initialiser la calculabilité des paramètres
-                    return crp;
-                }
 
-            case ComputeNodeType.CourbeRemousRectangle:
+            case CalculatorType.CourbeRemous:
                 {
-                    let cn = new ParamsSectionRectang(undefined, 1, undefined, 1, undefined,
-                        0.001, 1,
-                        ComputeNodeType.CourbeRemous);
-                    let n = new cSnRectang(cn);
-                    let crp = new CourbeRemousParams(n, undefined, undefined, undefined, undefined, undefined);
-                    let ru = new CourbeRemous(crp); // pour initialiser la calculabilité des paramètres
+                    const sect: acSection = this.createSection(nodeType);
+                    const crp = new CourbeRemousParams(sect, undefined, undefined, undefined, undefined, undefined);
+                    const ru = new CourbeRemous(crp); // pour initialiser la calculabilité des paramètres
                     return crp;
                 }
 
-            case ComputeNodeType.CourbeRemousTrapeze:
-                {
-                    let cn = new ParamsSectionTrapez(1, 1, undefined, undefined, 1,
-                        undefined, 0.001, 1,
-                        ComputeNodeType.CourbeRemousTrapeze,
-                        ComputeNodeType.CourbeRemous);
-                    let n = new cSnTrapez(cn);
-                    let crp = new CourbeRemousParams(n, undefined, undefined, undefined, undefined, undefined);
-                    let ru = new CourbeRemous(crp); // pour initialiser la calculabilité des paramètres
-                    return crp;
-                }
-
-            case ComputeNodeType.PabDimensions:
+            case CalculatorType.PabDimensions:
                 {
                     let cn = new PabDimensionParams(undefined, undefined, undefined);
                     let n = new PabDimension(cn); // pour initialiser la calculabilité des paramètres
                     return cn;
                 }
 
-            case ComputeNodeType.PabPuissance:
+            case CalculatorType.PabPuissance:
                 {
                     let cn = new PabPuissanceParams(undefined, undefined, undefined);
                     let n = new PabPuissance(cn); // pour initialiser la calculabilité des paramètres
@@ -175,7 +119,18 @@ export class ComputeNodeParameters {
                 }
 
             default:
-                throw "ComputeNodeParameters.getComputeNodeParameters() : noeud de calcul '" + ComputeNodeType[type] + "' non pris en charge";
+                throw "ComputeNodeParameters.getComputeNodeParameters() : noeud de calcul '" + ComputeNodeType[nodeType] + "' non pris en charge";
         }
     }
+
+    public getComputeNodeParameter(calcType: CalculatorType, nodeType: ComputeNodeType, symbol: string): ParamDefinition {
+        const key = { calcType, nodeType };
+        let params = this._nodes.get(key);
+        if (params == undefined) {
+            params = this.createComputeNodeParameters(calcType, nodeType);
+            this._nodes.put(key, params);
+        }
+
+        return params.map[symbol];
+    }
 }

src/remous.ts

 import { round, XOR } from "./base";
 import { Dichotomie } from "./dichotomie";
 import { Nub } from "./nub";
-import { ComputeNodeType, ParamCalculability, ParamDefinition, ParamDomainValue, ParamsEquation } from "./param";
+import { ComputeNodeType, ParamCalculability, ParamDefinition, ParamDomainValue, ParamsEquation, CalculatorType } from "./param";
 import { acSection, ParamsSection } from "./section/section_type";
 import { cLog } from "./util/log";
 import { Message, MessageCode } from "./util/message";
@@ -55,10 +55,10 @@ export class CourbeRemousParams extends ParamsEquation {
     constructor(s: acSection, rYamont: number, rYAval: number, rLong: number, rDx: number, meth: MethodeResolution) {
         super();
         this._section = s;
-        this._Yamont = new ParamDefinition(ComputeNodeType.CourbeRemous, "Yamont", ParamDomainValue.POS, rYamont);
-        this._Yaval = new ParamDefinition(ComputeNodeType.CourbeRemous, "Yaval", ParamDomainValue.POS, rYAval);
-        this._Long = new ParamDefinition(ComputeNodeType.CourbeRemous, "Long", ParamDomainValue.POS, rLong);
-        this._Dx = new ParamDefinition(ComputeNodeType.CourbeRemous, "Dx", ParamDomainValue.POS, rDx);
+        this._Yamont = new ParamDefinition(CalculatorType.CourbeRemous, "Yamont", ParamDomainValue.POS, rYamont);
+        this._Yaval = new ParamDefinition(CalculatorType.CourbeRemous, "Yaval", ParamDomainValue.POS, rYAval);
+        this._Long = new ParamDefinition(CalculatorType.CourbeRemous, "Long", ParamDomainValue.POS, rLong);
+        this._Dx = new ParamDefinition(CalculatorType.CourbeRemous, "Dx", ParamDomainValue.POS, rDx);
         this._methodeResolution = meth;
 
         this.addParamDefinition(this._Yamont);

src/section/section_circulaire.ts

-import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamCalculability } from "../param";
+import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamCalculability, CalculatorType } from "../param";
 import { acSection, ParamsSection } from "./section_type";
 import { Message, MessageCode } from "../util/message";
 import { Result } from "../util/result";
@@ -7,11 +7,9 @@ import { randomBytes } from "crypto";
 export class ParamsSectionCirc extends ParamsSection {
         private _D: ParamDefinition;          // Diamètre du cercle
 
-        constructor(rD: number, rY: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number,
-                nodeType: ComputeNodeType = ComputeNodeType.SectionCercle,
-                defaultNodeType: ComputeNodeType = ComputeNodeType.SectionParametree) {
-                super(rY, undefined, rKs, rQ, rIf, rPrec, rYB, defaultNodeType);
-                this._D = new ParamDefinition(nodeType, 'D', ParamDomainValue.POS, rD);
+        constructor(rD: number, rY: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number) {
+                super(rY, undefined, rKs, rQ, rIf, rPrec, rYB, ComputeNodeType.None);
+                this._D = new ParamDefinition(CalculatorType.SectionParametree, 'D', ParamDomainValue.POS, rD, ComputeNodeType.SectionCercle);
 
                 this.addParamDefinition(this._D);
         }

src/section/section_puissance.ts

-import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability } from "../param";
+import { ComputeNodeType, ParamDefinition, ParamDomain, ParamDomainValue, ParamCalculability, CalculatorType } from "../param";
 import { acSection, ParamsSection } from "./section_type";
 import { Result } from "../util/result";
 
@@ -8,11 +8,9 @@ import { Result } from "../util/result";
 export class ParamsSectionPuiss extends ParamsSection {
         private _k: ParamDefinition; // Coefficient de forme compris entre 0 et 1
 
-        constructor(rk: number, rY: number, rLargeurBerge: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number,
-                nodeType: ComputeNodeType = ComputeNodeType.SectionPuissance,
-                defaultNodeType: ComputeNodeType = ComputeNodeType.SectionParametree) {
-                super(rY, rLargeurBerge, rKs, rQ, rIf, rPrec, rYB, defaultNodeType);
-                this._k = new ParamDefinition(nodeType, 'k', new ParamDomain(ParamDomainValue.INTERVAL, 0, 1), rk);
+        constructor(rk: number, rY: number, rLargeurBerge: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number) {
+                super(rY, rLargeurBerge, rKs, rQ, rIf, rPrec, rYB, ComputeNodeType.None);
+                this._k = new ParamDefinition(CalculatorType.SectionParametree, 'k', new ParamDomain(ParamDomainValue.INTERVAL, 0, 1), rk, ComputeNodeType.SectionPuissance);
 
                 this.addParamDefinition(this._k);
         }

src/section/section_rectang.ts

@@ -3,11 +3,10 @@ import { ComputeNodeType } from "../param";
 import { Result } from "../util/result";
 
 export class ParamsSectionRectang extends ParamsSection {
-        constructor(rY: number, rLargeurFond: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number,
-                defaultNodeType: ComputeNodeType = ComputeNodeType.SectionParametree) {
+        constructor(rY: number, rLargeurFond: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number) {
                 super(rY,
                         rLargeurFond, // LargeurBerge=LargeurFond
-                        rKs, rQ, rIf, rPrec, rYB, defaultNodeType);
+                        rKs, rQ, rIf, rPrec, rYB, ComputeNodeType.SectionRectangle);
         }
 }
 

src/section/section_trapez.ts

-import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamCalculability } from "../param";
+import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamCalculability, CalculatorType } from "../param";
 import { acSection, ParamsSection } from "./section_type";
 import { Result } from "../util/result";
 
@@ -6,12 +6,10 @@ export class ParamsSectionTrapez extends ParamsSection {
         private _LargeurFond: ParamDefinition; // Largeur au fond
         private _Fruit: ParamDefinition; // Fruit des berges
 
-        constructor(rLargeurFond: number, rFruit: number, rY: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number,
-                nodeType: ComputeNodeType = ComputeNodeType.SectionTrapeze,
-                defaultNodeType: ComputeNodeType = ComputeNodeType.SectionParametree) {
-                super(rY, undefined, rKs, rQ, rIf, rPrec, rYB, defaultNodeType);
-                this._LargeurFond = new ParamDefinition(nodeType, 'LargeurFond', ParamDomainValue.POS_NULL, rLargeurFond);
-                this._Fruit = new ParamDefinition(nodeType, 'Fruit', ParamDomainValue.POS_NULL, rFruit);
+        constructor(rLargeurFond: number, rFruit: number, rY: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number) {
+                super(rY, undefined, rKs, rQ, rIf, rPrec, rYB, ComputeNodeType.None);
+                this._LargeurFond = new ParamDefinition(CalculatorType.SectionParametree, 'LargeurFond', ParamDomainValue.POS_NULL, rLargeurFond, ComputeNodeType.SectionTrapeze);
+                this._Fruit = new ParamDefinition(CalculatorType.SectionParametree, 'Fruit', ParamDomainValue.POS_NULL, rFruit, ComputeNodeType.SectionTrapeze);
 
                 this.addParamDefinition(this._LargeurFond);
                 this.addParamDefinition(this._Fruit);

src/section/section_type.ts

 import { MessageCode, Message } from "../util/message";
-import { ComputeNodeType, ComputeNode, ParamDefinition, ParamDomainValue, ParamCalculability, ParamsEquation } from "../param";
+import { ComputeNodeType, ComputeNode, ParamDefinition, ParamDomainValue, ParamCalculability, ParamsEquation, CalculatorType } from "../param";
 import { cHautCritique, cHautNormale, cHautCorrespondante, cHautConjuguee } from "./hauteur";
 import { Result } from "../util/result";
 
@@ -16,14 +16,14 @@ export abstract class cParamsCanal extends ParamsEquation {
         private _iPrec: ParamDefinition;  // Précision en nombre de décimales
         private _YB: ParamDefinition;  // Hauteur de berge
 
-        constructor(nodeType: ComputeNodeType, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number) {
+        constructor(calcType: CalculatorType, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number) {
                 super();
-                this._Ks = new ParamDefinition(nodeType, 'Ks', ParamDomainValue.POS, rKs);
-                this._Q = new ParamDefinition(nodeType, 'Q', ParamDomainValue.POS_NULL, rQ);
-                this._If = new ParamDefinition(nodeType, 'If', ParamDomainValue.ANY, rIf);
-                this._Prec = new ParamDefinition(nodeType, 'Prec', ParamDomainValue.POS, rPrec);
-                this._iPrec = new ParamDefinition(nodeType, 'iPrec', ParamDomainValue.ANY, Math.round(-Math.log(rPrec) / Math.log(10)));
-                this._YB = new ParamDefinition(nodeType, 'YB', ParamDomainValue.POS, rYB);
+                this._Ks = new ParamDefinition(calcType, 'Ks', ParamDomainValue.POS, rKs);
+                this._Q = new ParamDefinition(calcType, 'Q', ParamDomainValue.POS_NULL, rQ);
+                this._If = new ParamDefinition(calcType, 'If', ParamDomainValue.ANY, rIf);
+                this._Prec = new ParamDefinition(calcType, 'Prec', ParamDomainValue.POS, rPrec);
+                this._iPrec = new ParamDefinition(calcType, 'iPrec', ParamDomainValue.ANY, Math.round(-Math.log(rPrec) / Math.log(10)));
+                this._YB = new ParamDefinition(calcType, 'YB', ParamDomainValue.POS, rYB);
 
                 this.addParamDefinition(this._Ks);
                 this.addParamDefinition(this._Q);
@@ -81,11 +81,17 @@ export abstract class ParamsSection extends cParamsCanal {
         private _Y: ParamDefinition;          // Tirant d'eau
         private _LargeurBerge: ParamDefinition; // largeur au débordement
 
-        constructor(rY: number, rLargeurBerge: number, rKs: number, rQ: number, rIf: number, rPrec: number, rYB: number,
-                nodeType: ComputeNodeType = ComputeNodeType.SectionParametree) {
-                super(nodeType, rKs, rQ, rIf, rPrec, rYB);
-                this._Y = new ParamDefinition(nodeType, 'Y', ParamDomainValue.POS_NULL, rY);
-                this._LargeurBerge = new ParamDefinition(nodeType, 'LargeurBerge', ParamDomainValue.POS_NULL, rLargeurBerge);
+        constructor(rY: number,
+                rLargeurBerge: number,
+                rKs: number,
+                rQ: number,
+                rIf: number,
+                rPrec: number,
+                rYB: number,
+                nodeType: ComputeNodeType) {
+                super(CalculatorType.SectionParametree, rKs, rQ, rIf, rPrec, rYB);
+                this._Y = new ParamDefinition(CalculatorType.SectionParametree, 'Y', ParamDomainValue.POS_NULL, rY, nodeType);
+                this._LargeurBerge = new ParamDefinition(CalculatorType.SectionParametree, 'LargeurBerge', ParamDomainValue.POS_NULL, rLargeurBerge, nodeType);
 
                 this.addParamDefinition(this._Y);
                 this.addParamDefinition(this._LargeurBerge);

src/structure/parallel_structure_params.ts

 import { Nub } from "../nub";
-import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamsEquation } from "../param";
+import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamsEquation, CalculatorType } from "../param";
 
 /**
  * Common parameters of hydraulic structure equations
@@ -22,11 +22,11 @@ export class ParallelStructureParams extends ParamsEquation {
      */
     constructor(rQ: number, rZ1: number, rZ2: number) {
         super();
-        this.Q = new ParamDefinition(ComputeNodeType.CondDistri, "Q", ParamDomainValue.ANY, rQ);
+        this.Q = new ParamDefinition(CalculatorType.ParallelStructure, "Q", ParamDomainValue.ANY, rQ);
         this.addParamDefinition(this.Q);
-        this.Z1 = new ParamDefinition(ComputeNodeType.CondDistri, "Z1", ParamDomainValue.ANY, rZ1);
+        this.Z1 = new ParamDefinition(CalculatorType.ParallelStructure, "Z1", ParamDomainValue.ANY, rZ1);
         this.addParamDefinition(this.Z1);
-        this.Z2 = new ParamDefinition(ComputeNodeType.CondDistri, "Z2", ParamDomainValue.ANY, rZ2);
+        this.Z2 = new ParamDefinition(CalculatorType.ParallelStructure, "Z2", ParamDomainValue.ANY, rZ2);
         this.addParamDefinition(this.Z2);
     }
 }

src/structure/rectangular_structure_params.ts

-import { ComputeNodeType, ParamCalculability, ParamDefinition, ParamDomainValue, ParamsEquation } from "../param";
+import { ComputeNodeType, ParamCalculability, ParamDefinition, ParamDomainValue, ParamsEquation, CalculatorType } from "../param";
 import { Structure } from "./structure";
 import { StructureParams } from "./structure_params";
 
@@ -25,9 +25,9 @@ export class RectangularStructureParams extends StructureParams {
      */
     constructor(rQ: number, rZDV: number, rZ1: number, rZ2: number, rL: number, rCd: number, rW: number = Infinity) {
         super(rQ, rZDV, rZ1, rZ2, rW);
-        this.L = new ParamDefinition(ComputeNodeType.CondDistri, "L", ParamDomainValue.POS, rL);
+        this.L = new ParamDefinition(CalculatorType.Structure, "L", ParamDomainValue.POS, rL, ComputeNodeType.StructureRectangle);
         this.addParamDefinition(this.L);
-        this.Cd = new ParamDefinition(ComputeNodeType.CondDistri, "Cd", ParamDomainValue.POS, rCd);
+        this.Cd = new ParamDefinition(CalculatorType.Structure, "Cd", ParamDomainValue.POS, rCd, ComputeNodeType.StructureRectangle);
         this.addParamDefinition(this.Cd);
     }
 }

src/structure/structure_params.ts

 import { Nub } from "../nub";
-import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamsEquation } from "../param";
+import { ComputeNodeType, ParamDefinition, ParamDomainValue, ParamsEquation, CalculatorType } from "../param";
 
 /**
  * Common parameters of hydraulic structure equations
@@ -36,23 +36,23 @@ export class StructureParams extends ParamsEquation {
      * @param rZ2 Cote de l'eau aval (m)
      * @param rW Ouverture de vanne (m) (infinity pour un seuil)
      */
-    constructor(rQ: number, rZDV: number, rZ1: number, rZ2: number, rW: number = Infinity ) {
+    constructor(rQ: number, rZDV: number, rZ1: number, rZ2: number, rW: number = Infinity) {
         super();
-        this.Q = new ParamDefinition(ComputeNodeType.CondDistri, "Q", ParamDomainValue.ANY, rQ);
+        this.Q = new ParamDefinition(CalculatorType.Structure, "Q", ParamDomainValue.ANY, rQ);
         this.addParamDefinition(this.Q);
-        this.ZDV = new ParamDefinition(ComputeNodeType.CondDistri, "ZDV", ParamDomainValue.ANY, rZDV);
+        this.ZDV = new ParamDefinition(CalculatorType.Structure, "ZDV", ParamDomainValue.ANY, rZDV);
         this.addParamDefinition(this.ZDV);
-        this.Z1 = new ParamDefinition(ComputeNodeType.CondDistri, "Z1", ParamDomainValue.ANY, rZ1);
+        this.Z1 = new ParamDefinition(CalculatorType.Structure, "Z1", ParamDomainValue.ANY, rZ1);
         this.addParamDefinition(this.Z1);
-        this.Z2 = new ParamDefinition(ComputeNodeType.CondDistri, "Z2", ParamDomainValue.ANY, rZ2);
+        this.Z2 = new ParamDefinition(CalculatorType.Structure, "Z2", ParamDomainValue.ANY, rZ2);
         this.addParamDefinition(this.Z2);
-        this.h1 = new ParamDefinition(ComputeNodeType.CondDistri, "h1", ParamDomainValue.POS_NULL,
+        this.h1 = new ParamDefinition(CalculatorType.Structure, "h1", ParamDomainValue.POS_NULL,
             Math.max(0, this.Z1.v - this.ZDV.v));
         this.addParamDefinition(this.h1);
-        this.h2 = new ParamDefinition(ComputeNodeType.CondDistri, "h2", ParamDomainValue.POS_NULL,
+        this.h2 = new ParamDefinition(CalculatorType.Structure, "h2", ParamDomainValue.POS_NULL,
             Math.max(0, this.Z2.v - this.ZDV.v));
         this.addParamDefinition(this.h2);
-        this.W = new ParamDefinition(ComputeNodeType.CondDistri, "W", ParamDomainValue.POS_NULL, rW);
+        this.W = new ParamDefinition(CalculatorType.Structure, "W", ParamDomainValue.POS_NULL, rW);
         this.addParamDefinition(this.W);
     }
 

src/util/hashtable.ts

+export class HashTable {
+    private _hashes: { [key: string]: any };
+
+    constructor() {
+        this._hashes = {};
+    }
+
+    public get(key: any): any {
+        return this._hashes[JSON.stringify(key)];
+    }
+
+    public put(key: any, value: any) {
+        this._hashes[JSON.stringify(key)] = value;
+    }
+}