#45 implémentation de la référence à des résultats complémentaires d'ouvrages parallèles

spec/value_ref/value_ref_structure.spec.ts

+import { SectionParametree } from "../../src/section/section_nub";
+import { cSnTrapez, ParamsSectionTrapez, ParallelStructure, ParallelStructureParams } from "../../src";
+import { StructureCem88d, RectangularStructureParams } from "../../src/structure/structure_cem88d";
+import { StructureCunge80 } from "../../src/structure/structure_cunge80";
+
+/**
+ * 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";
+
+let nub1: ParallelStructure;
+let nub2: ParallelStructure;
+let nub3: StructureCem88d;
+let nub4: StructureCunge80;
+let prm3: RectangularStructureParams;
+let prm4: RectangularStructureParams;
+
+/**
+ * crée l'environnement de test.
+ * répété à chaque test car il manque un mock de beforeEach
+ */
+function createEnv() {
+    // Nub maître 1
+    nub1 = new ParallelStructure(new ParallelStructureParams(1, 2, 1));
+
+    // Nub maître 2
+    nub2 = new ParallelStructure(new ParallelStructureParams(1, 2, 1));
+
+    // Nub esclave 1
+    nub3 = new StructureCem88d(new RectangularStructureParams(0.5, 0, 1, 0.5, 1, 0.5));
+    prm3 = nub3.parameters as RectangularStructureParams;
+    nub1.addStructure(nub3);
+
+    // Nub esclave 2
+    nub4 = new StructureCunge80(new RectangularStructureParams(0.5, 0, 1, 0.5, 1, 0.5));
+    prm4 = nub4.parameters as RectangularStructureParams;
+    nub2.addStructure(nub4);
+}
+
+describe("référence d'un paramètre à un autre : ", () => {
+    describe("résultat complémentaire/ouvrages parallèles : ", () => {
+        it("test 1", () => {
+            // cas de figure :
+            // nub4.Q est lié au résultat complémentaire Q_Mode de nub1
+            // lecture de nub4.Q
+
+            createEnv();
+
+            prm4.Q.defineReference(nub1, "ouvrage[0].Q_Mode");
+
+            nub1.CalcSerie(0.001, 0.1, "Q");
+            nub2.CalcSerie(0.001, 0.1, "Q");
+            /*
+            nub1.result.resultElements[0].extraResults = {
+            "ouvrage[0].Q" : 6.264183905346331
+            "ouvrage[0].Q_Mode" : 0
+            "ouvrage[0].Q_Regime" : 0
+            }
+            nub2.result.resultElements[0].extraResults = {
+            "ouvrage[0].Q" : 2.4110855093366834
+            "ouvrage[0].Q_Mode" : 0
+            "ouvrage[0].Q_Regime" : 0
+            }
+            */
+
+            expect(prm4.Q.v).toEqual(0);
+        });
+
+        it("test 2", () => {
+            // cas de figure :
+            // nub4.Q est lié au résultat complémentaire Q de nub1
+            // lecture de nub4.Q
+
+            createEnv();
+
+            prm4.Q.defineReference(nub1, "ouvrage[0].Q");
+
+            nub1.CalcSerie(0.001, 0.1, "Q");
+            nub2.CalcSerie(0.001, 0.1, "Q");
+            /*
+            nub1.result.resultElements[0].extraResults = {
+            "ouvrage[0].Q" : 6.264183905346331
+            "ouvrage[0].Q_Mode" : 0
+            "ouvrage[0].Q_Regime" : 0
+            }
+            nub2.result.resultElements[0].extraResults = {
+            "ouvrage[0].Q" : 2.4110855093366834
+            "ouvrage[0].Q_Mode" : 0
+            "ouvrage[0].Q_Regime" : 0
+            }
+            */
+
+            expect(prm4.Q.v).toEqual(6.264183905346331);
+        });
+    });
+});

src/nub.ts

@@ -154,8 +154,8 @@ export abstract class Nub extends ComputeNode implements IReferencedObject {
         return this.getParameter(desc).paramValues;
     }
 
-    public getReferencedResult(desc: string): Result {
-        if (this._result !== undefined && this._result.name === desc)
+    public getReferencedResult(desc?: string): Result {
+        if (desc === undefined || (this._result !== undefined && this._result.name === desc))
             return this._result;
 
         return this.CalcSerie(0.001, 0.1, desc);

src/param/param-values.ts

@@ -83,7 +83,10 @@ export class ParamValues implements IObjectReference {
     public get valueMode() {
         switch (this._valueMode) {
             case ParamValueMode.LINK:
-                return this.referencedParamValues.valueMode;
+                const pv = this.referencedParamValues;
+                if (pv == undefined)
+                    return undefined;
+                return pv.valueMode;
 
             default:
                 return this._valueMode;

src/structure/parallel_structure.ts

@@ -5,6 +5,7 @@ import { Result } from "../util/result";
 import { ParallelStructureParams } from "./parallel_structure_params";
 import { Structure } from "./structure";
 import { IParamDefinitionIterator, ParamsEquation, ParamsEquationArrayIterator } from "../param/params-equation";
+import { ParamValues } from "../param/param-values";
 
 /**
  * Interface pour mémoriser le n° d'ouvrage et le paramètre à calculer
@@ -245,6 +246,19 @@ export class ParallelStructure extends Nub {
         return { index: i, prm: sPrm };
     }
 
+    /**
+     * 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] };
+    }
+
     /**
      * Calcul du paramètre d'un des ouvrages en parallèle
      * @param sVC Index de l'ouvrage et paramètre à calculer
@@ -258,4 +272,25 @@ export class ParallelStructure extends Nub {
         // Calcul du paramètre de la structure en calcul
         return this.structures[sVC.index].Calc(sVC.prm, rInit, rPrec);
     }
+
+    // interface IReferencedObject
+
+    public getReferencedParamValues(desc: string): ParamValues {
+        try {
+            // analyse ouvrage[n].X
+            const i: IStructureVarCalc = this.getStructureVarCalc2(desc);
+            return this.structures[i.index].getParameter(i.prm).paramValues;
+        }
+        catch (e) {
+            // pas de la forme ouvrage[n].X ou erreur sur n ou X
+            const param = this.getParameter(desc);
+            if (param === undefined)
+                return undefined;
+            return param.paramValues;
+        }
+    }
+
+    public getReferencedExtraResult(desc: string): any {
+        return this._result.getExtraResult(desc);
+    }
 }

src/value_ref/object_ref.ts

@@ -16,7 +16,7 @@ export interface IReferencedObject {
      * getter du résultat
      * @param desc : description sous forme symbolique
      */
-    getReferencedResult(desc: string): Result;
+    getReferencedResult(desc?: string): Result;
 
     /**
      * getter du résultat complémentaire
@@ -111,8 +111,6 @@ export class ObjectReference implements IObjectReference {
      * instance de résultat complémentaire référencée
      */
     public get referencedExtraResult(): any {
-        const tmp: string[] = this._refDefinition.split(".");
-        const r: Result = this._referencedObject.getReferencedResult(tmp[0]);
-        return r.getExtraResult(tmp[1]);
+        return this._referencedObject.getReferencedExtraResult(this._refDefinition);
     }
 }