cloisons.ts

import { CalculatorType } from "../compute-node";
import { PabPuissance, PabPuissanceParams } from "../pab/pab_puissance";
import { ParamCalculability } from "../param/param-definition";
import { Result } from "../util/result";
import { CloisonsParams } from "./cloisons_params";
import { ParallelStructure } from "./parallel_structure";
import { StructureKiviParams } from "./structure_kivi";
import { loiAdmissiblesCloisons, LoiDebit } from "./structure_props";

export { CloisonsParams };
export class Cloisons extends ParallelStructure {
    constructor(prms: CloisonsParams, dbg: boolean = false) {
        super(prms, dbg);
        this._calcType = CalculatorType.Cloisons;
    }

    /**
     * paramètres castés au bon type
     */
    get prms(): CloisonsParams {
        return this._prms as CloisonsParams;
    }

    public getLoisAdmissibles(): { [key: string]: LoiDebit[]; } {
        return loiAdmissiblesCloisons;
    }

    /**
     * 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", "DH" ou "n.X" avec "n" l'index de l'ouvrage et "X" son paramètre
     * @param rInit Valeur initiale
     */
    public Calc(sVarCalc: string, rInit?: number): Result {
        // Mise à jour de ZRAM pour Kivi à partir de Z1 - PB
        this.updateKiviZRAM();

        // Transformation DH => Z2
        this.prms.Z2.v = this.prms.Z1.v - this.prms.DH.v;
        let sVC: string = sVarCalc;
        if (sVarCalc === "DH") {
            sVC = "Z2";
        }

        // let r: Result = super.Calc(sVC, rInit);
        let r: Result;
        switch (sVC) {
            case "Z1":
            case "Z2":
            case "Q":
            case "LB":
            case "PB":
            case "BB":
                r = this.nubCalc(sVC, rInit);
                if (r.ok) {
                    this.getParameter(sVC).setValue(r.vCalc);
                }
                break;
            default:
                r = super.Calc(sVC, rInit);
        }

        if (r.ok) {
            // Recalcul du débit total pour récupérer les résultats des ouvrages dans les résultats complémentaires
            const resQtot: Result = this.CalcQ();
            for (const extraResKey in resQtot.extraResults) {
                if (resQtot.extraResults.hasOwnProperty(extraResKey)) {
                    r.resultElement.addExtraResult(extraResKey, resQtot.extraResults[extraResKey]);
                }
            }