Better representation of parameter to calculate, when it is a child nub parameter (Structure)

spec/structure/functions.ts

@@ -118,7 +118,10 @@ export function testParallelStructures(oPS: ParallelStructure, iStTypes: number[
                         // Le calcul de l'ouverture sur les seuils doit renvoyer une exception (cas impossible)
                         it(`Calc(${prm.symbol}) should return exception`, () => {
                             expect(
-                                () => { oPS.Calc(i + "." + prm.symbol); }
+                                () => { oPS.Calc({
+                                    uid: oPS.structures[i].uid,
+                                    symbol: prm.symbol
+                                }); }
                             ).toThrow(new Error("Structure:Calc : Calcul de W impossible sur un seuil"));
                         });
                     } else if (
@@ -129,7 +132,10 @@ export function testParallelStructures(oPS: ParallelStructure, iStTypes: number[
                         // Les lois CEM88D et CUNGE80 ne font pas intervenir ZDV dans le calcul d'un orifice noyé
                         it(`Calc(${prm.symbol}) should return an error`, () => {
                             expect(
-                                oPS.Calc(i + "." + prm.symbol).code
+                                oPS.Calc({
+                                    uid: oPS.structures[i].uid,
+                                    symbol: prm.symbol
+                                }).code
                             ).toBe(MessageCode.ERROR_STRUCTURE_ZDV_PAS_CALCULABLE);
                         });
                     } else if (
@@ -138,12 +144,18 @@ export function testParallelStructures(oPS: ParallelStructure, iStTypes: number[
                     ) {
                         // Le calcul de l'angle de l'équation triangulaire n'est pas assez précis
                         it(`Calc(${prm.symbol}) should return ${ref}`, () => {
-                            checkResult(oPS.Calc(i + "." + prm.symbol), ref, 1);
+                            checkResult(oPS.Calc({
+                                uid: oPS.structures[i].uid,
+                                symbol: prm.symbol
+                            }), ref, 1);
                         });
                     } else {
                         // Cas normal : On teste la valeur calculée
                         it(`Calc(${prm.symbol}) should return ${ref}`, () => {
-                            checkResult(oPS.Calc(i + "." + prm.symbol), ref);
+                            checkResult(oPS.Calc({
+                                uid: oPS.structures[i].uid,
+                                symbol: prm.symbol
+                            }), ref);
                         });
                     }
                     prm.v = ref; // Go back to initial value for following tests

spec/structure/parallel_structure.spec.ts

@@ -39,11 +39,20 @@ describe("Class ParallelStructure: ", () => {
         itParallelStructure("Q", 30, 15);
         itParallelStructure("Z1", 30, 15);
         itParallelStructure("Z2", 15, 15);
-        itParallelStructure("0.ZDV", 0, 15);
-        itParallelStructure("1.ZDV", 0, 15);
+        itParallelStructure({
+            uid: pstruct.structures[0].uid,
+            symbol: "ZDV"
+        }, 0, 15);
+        itParallelStructure({
+            uid: pstruct.structures[1].uid,
+            symbol: "ZDV"
+        }, 0, 15);
         it("shoud return an error Q too high", () => {
             pstruct.prms.Q.v = 14;
-            const res: Result = pstruct.Calc("1.ZDV");
+            const res: Result = pstruct.Calc({
+                uid: pstruct.structures[1].uid,
+                symbol: "ZDV"
+            });
             expect(res.code).toBe(MessageCode.ERROR_STRUCTURE_Q_TROP_ELEVE);
         });
     });
@@ -55,7 +64,7 @@ describe("Class ParallelStructure: ", () => {
  * @param rVcalc Valeur de référence à retrouver
  * @param Q Débit de chacune des structures (pour structures identiques uniquement)
  */
-function itParallelStructure(sVarCalc: string, rVcalc: number, Q?: number) {
+function itParallelStructure(sVarCalc: any, rVcalc: number, Q?: number) {
     it(`${sVarCalc} should be ${rVcalc}`, () => {
         checkResult(pstruct.Calc(sVarCalc), rVcalc);
     });

src/nub.ts

-import { ParamDefinition, Session } from ".";
+import { ParamDefinition, Session, Structure } from ".";
 import { ComputeNode } from "./compute-node";
 import { Dichotomie } from "./dichotomie";
 import { INamedIterableValues, IterableValues } from "./param/param-value-iterator";
@@ -91,9 +91,9 @@ export abstract class Nub extends ComputeNode {
     /**
      * effectue une série de calculs sur un paramètre
      * @param rInit solution approximative du paramètre
-     * @param sDonnee éventuel symbole du paramètre à calculer
+     * @param sDonnee éventuel symbole / paire symbole-uid du paramètre à calculer
      */
-    public CalcSerie(rInit?: number, sDonnee?: string): Result {
+    public CalcSerie(rInit?: number, sDonnee?: any): Result {
         let computedParam: ParamDefinition;
         // instance de ParamValues utilisée pour le paramètre varié (qui peut être un paramètre référencé (importé))
         let variatedValues: IterableValues;
@@ -149,7 +149,7 @@ export abstract class Nub extends ComputeNode {
             }
         }
 
-        let computedSymbol: string;
+        let computedSymbol: any;
         if (sDonnee) {
             computedSymbol = sDonnee;
         } else {
@@ -182,7 +182,9 @@ export abstract class Nub extends ComputeNode {
             this._result = res;
         }
 
-        this._result.name = computedSymbol;
+        const realSymbol = (typeof computedSymbol === "string") ? computedSymbol : computedSymbol.symbol;
+        this._result.name = realSymbol;
+
         return this._result;
     }
 
@@ -234,7 +236,18 @@ export abstract class Nub extends ComputeNode {
                 ) {
                     // if it is safe to link p's value to src
                     if (p.isLinkableTo(src)) {
-                        res.push(new LinkedValue(this, p, p.symbol));
+                        // if p is a CALC param of a Structure, other than "Q", expose its parent
+                        // (structures always have Q as CALC param and cannot have another)
+                        if (
+                            (this instanceof Structure)
+                            && (p.valueMode === ParamValueMode.CALCUL)
+                            && p.symbol !== "Q"
+                        ) {
+                            // trick to expose p a a result of the parent Nub
+                            res.push(new LinkedValue(this.parent, p, p.symbol));
+                        } else {
+                            res.push(new LinkedValue(this, p, p.symbol));
+                        }
                     }
                 }
             }

src/structure/parallel_structure.ts

 import { Nub } from "../nub";
 import { ParamCalculability } from "../param/param-definition";
-import { Result } from "../util/result";
-import { ParallelStructureParams } from "./parallel_structure_params";
-import { Structure } from "./structure";
-
-import { ParamDefinition } from "../param/param-definition";
 import { IParamDefinitionIterator, ParamsEquation, ParamsEquationArrayIterator } from "../param/params-equation";
-
 import { Props } from "../props";
 import { Session } from "../session";
-import { LinkedValue } from "../value_ref/object_ref";
+import { Result } from "../util/result";
+import { ParallelStructureParams } from "./parallel_structure_params";
+import { Structure } from "./structure";
 import { loiAdmissiblesOuvrages, LoiDebit } from "./structure_props";
 
 export { ParallelStructureParams };
 
-/**
- * Interface pour mémoriser le n° d'ouvrage et le paramètre à calculer
- */
-interface IStructureVarCalc {
-    index: number;
-    prm: string;
-}
-
 /**
  * Calcul de une ou plusieurs structures hydrauliques en parallèles
  * reliées par les cotes amont et aval et dont le débit est égal à la
@@ -125,12 +113,13 @@ export class ParallelStructure extends Nub {
     /**
      * Returns the current index of the given structure if any,
      * or else returns -1
-     * @param structure Structure to look for
+     * @param structure Structure or Structure UID to look for
      */
-    public getIndexForStructure(structure: Structure): number {
+    public getIndexForStructure(structure: Structure | string): number {
         let index: number = -1;
+        const uid = (structure instanceof Structure) ? structure.uid : structure;
         for (let i = 0; i < this._structures.length; i++) {
-            if (this._structures[i].uid === structure.uid) {
+            if (this._structures[i].uid === uid) {
                 index = i;
             }
         }
@@ -239,10 +228,11 @@ export class ParallelStructure extends Nub {
     /**
      * Calcul du débit total, de la cote amont ou aval ou d'un paramètre d'une structure
      * @param sVarCalc Nom du paramètre à calculer :
-     *                 "Q", "Z1", "Z2" ou "n.X" avec "n" l'index de l'ouvrage et "X" son paramètre
+     *                 "Q", "Z1", "Z2"
+     *                 ou { uid: "abcdef", symbol: "X" } avec "abcdef" l'index de l'ouvrage et "X" son paramètre
      * @param rInit Valeur initiale
      */
-    public Calc(sVarCalc: string, rInit?: number): Result {
+    public Calc(sVarCalc: string | any, rInit?: number): Result {
         let res: Result;
         switch (sVarCalc) {
             case "Z1":
@@ -255,12 +245,13 @@ export class ParallelStructure extends Nub {
                 break;
             default:
                 // Pour les caractéristiques des ouvrages
-                const sVC = this.getStructureVarCalc(sVarCalc);
-                res = this.CalcStructPrm(sVC, rInit);
+                // const sVC = this.getStructureVarCalc(sVarCalc);
+                const structureIndex = this.getIndexForStructure(sVarCalc.uid);
+                res = this.CalcStructPrm(structureIndex, sVarCalc.symbol);
                 // Suppression des extraResults : ils sont complétés plus bas pour chaque ouvrage
                 res.resultElement.extraResults = {};
                 if (res.ok) {
-                    this._structures[sVC.index].getParameter(sVC.prm).setValue(res.vCalc);
+                    this._structures[structureIndex].getParameter(sVarCalc.symbol).setValue(res.vCalc);
                 }
         }
         if (res.ok) {
@@ -378,50 +369,17 @@ export class ParallelStructure extends Nub {
         }
     }
 
-    /**
-     * Renvoie le n° de structure et le paramètre à calculer
-     * @param sVarCalc Nom du paramètre à calculer : "n.X" avec "n" l'index de l'ouvrage et "X" son paramètre
-     */
-    protected getStructureVarCalc(sVarCalc: string): IStructureVarCalc {
-        let sIndex: string;
-        let sPrm: string;
-        if (sVarCalc.indexOf(".") === -1) {
-            throw new Error(`getStructureVarCalc() : erreur d'analyse de ${sVarCalc}, (pas de la forme n.X)`);
-        }
-        [sIndex, sPrm] = sVarCalc.split(".");
-        const i = parseInt(sIndex, 10);
-        if (isNaN(i)) {
-            throw new Error(`getStructureVarCalc() : erreur d'analyse de ${sVarCalc} (${sIndex} n'est pas un nombre)`);
-        }
-        return { index: i, prm: sPrm };
-    }
-
     /**
      * Calcul du paramètre d'un des ouvrages en parallèle
      * @param sVC Index de l'ouvrage et paramètre à calculer
      * @param rInit Valeur initiale
      */
-    protected CalcStructPrm(sVC: IStructureVarCalc, rInit?: number): Result {
+    protected CalcStructPrm(index: number, symbol: string, rInit?: number): Result {
         // Le débit restant sur la structure en calcul est :
-        this._structures[sVC.index].prms.Q.setValue(this.prms.Q.v - this.CalcQ(sVC.index).vCalc);
+        this._structures[index].prms.Q.setValue(this.prms.Q.v - this.CalcQ(index).vCalc);
 
         // Calcul du paramètre de la structure en calcul
-        return this._structures[sVC.index].Calc(sVC.prm, rInit);
-    }
-
-    /**
-     * Renvoie le n° de structure et le paramètre à calculer
-     * @param sVarCalc Nom du paramètre à calculer : "ouvrage[n].X" avec "n" l'index de l'ouvrage et "X" son paramètre
-     */
-    private getStructureVarCalc2(sVarCalc: string): IStructureVarCalc {
-        const re = /([A-Z,a-z]+)\[(\d+)\]\.(.+)/;
-        const match = re.exec(sVarCalc);
-        if (match === null || match[1] !== "ouvrage") {
-            throw new Error(
-                `getStructureVarCalc2() : erreur d'analyse de ${sVarCalc}, (pas de la forme ouvrage[n].X)`
-            );
-        }
-        return { index: +match[2], prm: match[3] };
+        return this._structures[index].Calc(symbol, rInit);
     }
 
 }

src/structure/structure.ts

 import { Nub } from "../nub";
 import { ParamCalculability, ParamDefinition, ParamFamily } from "../param/param-definition";
+import { ParamValueMode } from "../param/param-value-mode";
 import { Message, MessageCode } from "../util/message";
 import { Result } from "../util/result";
-import { LinkedValue } from "../value_ref/object_ref";
 
 import { ParallelStructure } from "./parallel_structure";
 import { StructureParams } from "./structure_params";
@@ -71,6 +71,10 @@ export abstract class Structure extends Nub {
     constructor(prms: StructureParams, dbg: boolean = false) {
         super(prms, dbg);
         this._isZDVcalculable = true;
+        // Q is always the only calculated variable; setting another parameter
+        // of a Structure to CALC mode makes it the calculated variable of the
+        // *parent* ParallelStructures
+        this.prms.Q.valueMode = ParamValueMode.CALCUL;
     }
 
     get isZDVcalculable(): boolean {