#27 ouvrages parallèles : ajout de la partie calcul et affichage des...

 #27 ouvrages parallèles : ajout de la partie calcul et affichage des résultats (sans les résultats complémentaires)

src/app/calculators/parallel-structures/parallel-structures.config.json

@@ -50,35 +50,66 @@
                 "type": "select",
                 "select": [
                     {
-                        "id": "select_loidebit1_cemagref88"
+                        "id": "select_loidebit1_cem88d"
                     },
                     {
-                        "id": "select_loidebit1_vannedenoye"
+                        "id": "select_loidebit1_cem88v"
                     },
                     {
-                        "id": "select_loidebit1_vannenoye"
+                        "id": "select_loidebit1_seuildenoye"
+                    },
+                    {
+                        "id": "select_loidebit1_cunge80"
                     }
                 ],
                 "dep_exist": [
                     {
                         "refid": "select_ouvrage",
-                        "refvalue": "select_ouvrage_vanne_rect"
+                        "refvalue": "select_ouvrage_seuil_rect"
+                    }
+                ]
+            },
+            {
+                "id": "select_loidebit2",
+                "type": "select",
+                "select": [
+                    {
+                        "id": "select_loidebit2_cem88v"
                     },
+                    {
+                        "id": "select_loidebit2_cem88d"
+                    },
+                    {
+                        "id": "select_loidebit2_vannedenoye"
+                    },
+                    {
+                        "id": "select_loidebit2_vannenoye"
+                    },
+                    {
+                        "id": "select_loidebit2_cunge80"
+                    }
+                ],
+                "dep_exist": [
                     {
                         "refid": "select_ouvrage",
-                        "refvalue": "select_ouvrage_seuil_rect"
+                        "refvalue": "select_ouvrage_vanne_rect"
                     }
                 ]
             },
             {
                 "type": "input",
-                "id": "W",
+                "id": "ZDV",
                 "unit": "m",
-                "value": 0.5,
+                "value": 0.2,
+                "nodeType": "StructureRectangle",
                 "dep_exist": [
                     {
                         "refid": "select_ouvrage",
                         "refvalue": "select_ouvrage_vanne_rect"
+                    },
+                    {
+                        "refid": "select_ouvrage",
+                        "refvalue": "select_ouvrage_seuil_rect"
                     }
                 ]
             },
@@ -99,6 +130,18 @@
                     }
                 ]
             },
+            {
+                "type": "input",
+                "id": "W",
+                "unit": "m",
+                "value": 0.5,
+                "dep_exist": [
+                    {
+                        "refid": "select_ouvrage",
+                        "refvalue": "select_ouvrage_vanne_rect"
+                    }
+                ]
+            },
             {
                 "type": "input",
                 "id": "Cd",

src/app/calculators/parallel-structures/parallel-structures.fr.json

@@ -12,11 +12,16 @@
     "select_ouvrage_vanne_trap": "Vanne trapézoïdale",
     "W": "Ouverture de vanne",
     "select_loidebit1": "Loi de débit",
-    "select_loidebit1_cemagref88": "Déversoir/Orifice Cemagref 88",
-    "select_loidebit1_vannedenoye": "Vanne dénoyé",
-    "select_loidebit1_vannenoye": "Vanne noyé",
+    "select_loidebit1_seuildenoye": "Seuil dénoyé",
+    "select_loidebit1_cunge80": "Cunge 80",
+    "select_loidebit1_cem88d": "Déversoir/Orifice Cemagref 88",
+    "select_loidebit1_cem88v": "Déversoir/Vanne de fond Cemagref 88",
     "select_loidebit2": "Loi de débit",
-    "select_loidebit2_cemagref88": "Déversoir/Orifice Cemagref 88",
+    "select_loidebit2_vannedenoye": "Vanne dénoyé",
+    "select_loidebit2_vannenoye": "Vanne noyé",
+    "select_loidebit2_cunge80": "Cunge 80",
+    "select_loidebit2_cem88d": "Déversoir/Orifice Cemagref 88",
+    "select_loidebit2_cem88v": "Déversoir/Vanne de fond Cemagref 88",
     "ZDV": "Cote de la crête du déversoir ou du radier de la vanne",
     "L": "Largeur du déversoir",
     "Cd": "Coefficient de débit",

src/app/formulaire/definition/concrete/form-parallel-structures.ts

@@ -44,16 +44,18 @@ export class FormulaireParallelStructure extends FormulaireDefinition {
     }
 
     public resetResults() {
+        this._formResult.resetResults();
     }
 
     public doCompute() {
+        this._formCompute.doCompute();
     }
 
     public get hasResults(): boolean {
-        return false;
+        return this._formResult.hasResults;
     }
 
     public get results(): CalculatorResults[] {
-        return undefined;
+        return this._formResult.results;
     }
 }

src/app/formulaire/definition/form-compute-fixedvar.ts

@@ -23,6 +23,14 @@ export abstract class FormComputeFixedVar extends FormCompute {
         return this._formBase.getDisplayedParamFromState(ParamRadioConfig.CAL);
     }
 
+    /**
+     * retourne un identifiant du paramètre dans le formulaire
+     * surchargé dans le cas des ouvrages //
+     */
+    protected getParameterRefid(p: NgParameter) {
+        return p.symbol;
+    }
+
     /**
      * lance le calcul d'un paramètre en déterminant une valeur initiale
      */
@@ -43,10 +51,21 @@ export abstract class FormComputeFixedVar extends FormCompute {
                 init = 1e-8;
                 break;
         }
+
         if (prec == undefined)
-            return nub.Calc(p.symbol, init);
+            return nub.Calc(this.getParameterRefid(p), init);
 
-        return nub.Calc(p.symbol, init, prec);
+        return nub.Calc(this.getParameterRefid(p), init, prec);
+    }
+
+    /**
+     * fixe la valeur d'un paramètre de ComputeNode
+     * @param node ComputeNode contenant le paramètre
+     * @param p paramètre dont on fixe la valeur
+     * @param val valeur à fixer
+     */
+    protected setParameterValue(node: ComputeNode, p: NgParameter, val: number) {
+        node.getParameter(p.symbol).v = val;
     }
 
     protected compute() {
@@ -90,7 +109,7 @@ export abstract class FormComputeFixedVar extends FormCompute {
                     let step: number = +varParam.stepValue;
 
                     for (let val = min; val <= max; val += step) {
-                        prms[varParam.symbol].v = val;
+                        this.setParameterValue(nub, varParam, val);
 
                         let res: Result = this.runNubCalc(nub, computedParam, computePrec);
                         if (res.ok) {
@@ -106,7 +125,7 @@ export abstract class FormComputeFixedVar extends FormCompute {
                     this.formResult.graphType = GraphType.Histogram;
 
                     for (let val of varParam.valueList) {
-                        prms[varParam.symbol].v = val;
+                        this.setParameterValue(nub, varParam, val);
 
                         let res: Result = this.runNubCalc(nub, computedParam, computePrec);
                         if (res.ok) {

src/app/formulaire/definition/form-compute-parallel-structures.ts

-import { ComputeNode, ParamsEquation } from "jalhyd";
+import { ComputeNode, ParamsEquation, ParallelStructure, ParallelStructureParams, CalculatorType, StructureParams, Structure, CreateStructure, StructureType, ComputeNodeType } from "jalhyd";
 
 import { FormComputeFixedVar } from "./form-compute-fixedvar";
-import { FormulaireDefinition } from "./form-definition";
 import { FormResultFixedVar } from "./form-result-fixedvar";
+import { FormulaireDefinition } from "./form-definition";
+import { SelectField } from "../select-field";
+import { FormulaireElement } from "../formulaire-element";
+import { NgParameter } from "../ngparam";
+import { FormulaireNode } from "../formulaire-node";
+import { FieldSet } from "../fieldset";
+import { FieldsetContainer } from "../fieldset-container";
 
 export class FormComputeParallelStructures extends FormComputeFixedVar {
     constructor(formBase: FormulaireDefinition, formResult: FormResultFixedVar) {
         super(formBase, formResult);
     }
 
+    /**
+     * dictionnaire des StructureType indexés par les valeurs de liste déroulante (loi de débit)
+     */
+    private static tsMap = {
+        "cem88d": StructureType.Cem88d,
+        "cem88v": StructureType.Cem88d,
+        "cunge80": StructureType.Cunge80,
+        "seuildenoye": StructureType.WeirFree,
+        "vannenoye": StructureType.OrificeSubmerged,
+        "vannedenoye": StructureType.OrificeFree
+    }
+
+    /**
+     * @return dans le cas d'un paramètre d'ouvrage, le FieldSet parent d'un paramètre,
+     * le FieldsetContainer parent du FieldSet
+     * ainsi que l'indice du FieldSet parent dans le FieldsetContainer
+     */
+    private structureParents(p: NgParameter): [FieldsetContainer, FieldSet, number] {
+        const parent1: FormulaireNode = p.getDirectParent(this._formBase);
+        if (parent1 !== undefined)
+            if (parent1 instanceof FieldSet) {
+                const parent2 = parent1.getDirectParent(this._formBase);
+                if (parent2 instanceof FieldsetContainer) {
+                    const fsIndex = parent1.indexAsKid(this._formBase);
+                    return [parent2, parent1, fsIndex];
+                }
+            }
+
+        return [undefined, undefined, -1];
+    }
+
+    /**
+     * construit un identifiant de type "n.X" avec "n" l'index de l'ouvrage auquel appartient le paramètre et "X" son symbole
+     */
+    protected getParameterRefid(p: NgParameter) {
+        const [fsc, fs, i] = this.structureParents(p);
+        if (i == -1)
+            return super.getParameterRefid(p);
+
+        return `${i}.${p.symbol}`;
+    }
+
+    protected setParameterValue(node: ComputeNode, p: NgParameter, val: number) {
+        const [fsc, fs, i] = this.structureParents(p);
+        if (i == -1)
+            super.setParameterValue(node, p, val); // paramètre "normal" (pas un paramètre d'ouvrage)
+        else {
+            const n: ParallelStructure = node as ParallelStructure;
+            const prm = n.structures[i].getParameter(p.symbol);
+            prm.v = val;
+        }
+    }
+
     public getNubAndParameters(): [ComputeNode, ParamsEquation] {
-        return undefined;
+        // paramètres communs
+
+        const Q: number = this._formBase.getParameterValue("Q"); // Débit 
+        const Z1: number = this._formBase.getParameterValue("Z1"); // Cote de l'eau amont (m)
+        const Z2: number = this._formBase.getParameterValue("Z2"); // Cote de l'eau aval (m)
+        const prms = new ParallelStructureParams(Q, Z1, Z2);
+
+        const nub: ParallelStructure = new ParallelStructure(prms);
+
+        // ouvrages
+
+        for (const fs of this._formBase.allFieldsets)
+            if (fs.calculatorType == CalculatorType.Structure) {
+                let loiDebit: string = fs.getSelectedValue("select_loidebit1");
+                if (loiDebit == undefined)
+                    loiDebit = fs.getSelectedValue("select_loidebit2");
+                if (loiDebit == undefined)
+                    throw new Error(`FormComputeParallelStructures.getNubAndParameters() : aucune loi de débit trouvée`);
+
+                const ts: StructureType = FormComputeParallelStructures.tsMap[loiDebit];
+                if (ts == undefined)
+                    throw new Error(`FormComputeParallelStructures.getNubAndParameters() :loi de débit ${loiDebit} non prise en charge`);
+
+                // cote de radier
+                const ZDV = fs.getNodeParameterValue("ZDV");
+
+                // ouverture de vanne
+                try {
+                    var W = fs.getNodeParameterValue("W");
+                } catch (e) {
+                }
+
+                // création de l'ouvrage
+                const ouvr = CreateStructure(ts);
+
+                // affectation des valeurs (en prenant garde de ne pas écraser les valeurs par défaut dans le cas d'un paramètre à calculer)
+                if (Z1 != undefined)
+                    ouvr.prms.Z1.v = Z1;
+                if (Z2 != undefined)
+                    ouvr.prms.Z2.v = Z2;
+                if (ZDV != undefined)
+                    ouvr.prms.ZDV.v = ZDV;
+                if (W != undefined)
+                    ouvr.prms.W.v = W;
+
+                nub.addStructure(ouvr);
+            }
+
+        return [nub, prms];
     }
 }

src/app/formulaire/form-iterator/deep-node-iterator.ts

+import { AbstractFormulaireNodeIterator } from "./abstract-node-iterator";
+import { FormulaireNode } from "../formulaire-node";
+
+export class DeepFormulaireNodeIterator extends AbstractFormulaireNodeIterator<FormulaireNode> implements IterableIterator<FormulaireNode> {
+    // interface IterableIterator
+
+    [Symbol.iterator](): IterableIterator<FormulaireNode> {
+        return this;
+    }
+}
\ No newline at end of file

src/app/formulaire/formulaire-node.ts

 import { JalhydObject } from "jalhyd"
 
 import { FormulaireDefinition } from "./definition/form-definition";
+import { DeepFormulaireNodeIterator } from "./form-iterator/deep-node-iterator";
 
 /**
  * représentation sous forme d'arbre du formulaire et de ses éléments
@@ -112,6 +113,57 @@ export abstract class FormulaireNode {
         return undefined;
     }
 
+    private hasDirectKid(n: FormulaireNode): boolean {
+        for (const k of this._kids)
+            if (k._uid == n._uid)
+                return true;
+        return false;
+    }
+
+    /**
+     * retourne le parent direct de this
+     * @param root FormulaireNode racine dont on part pour rechercher le parent
+     */
+    public getDirectParent(root: FormulaireNode): FormulaireNode {
+        if (root.hasDirectKid(this))
+            return root;
+
+        const it = new DeepFormulaireNodeIterator(root);
+        for (const n of it)
+            if (n.hasDirectKid(this))
+                return n;
+        return undefined;
+    }
+
+    /**
+     * retourne l'indice d'un FormulaireNode enfant dans la liste des enfants
+     * @param kid FormulaireNode enfant dont on cherche l'indice
+     * @return -1 si non trouvé, indice commençant à 0 sinon
+     */
+    private kidIndex(kid: FormulaireNode): number {
+        let n = 0;
+        for (const k of this._kids) {
+            if (k._uid == kid._uid)
+                return n;
+            n++;
+        }
+
+        return -1;
+    }
+
+    /**
+     * retourne l'indice de this dans la liste des enfants de son parent
+     * (cad rang par rapport à ses frères)
+     * @param root FormulaireNode racine dont on part pour rechercher le parent
+     */
+    public indexAsKid(root: FormulaireNode): number {
+        // parent de this
+        const p = this.getDirectParent(root);
+
+        // indice
+        return p.kidIndex(this);
+    }
+
     /**
      * crée une nouvelle instance (appel simple du constructeur)
      */