parallel_structure.ts 7.90 KiB
import { CalculatorType } from "../internal_modules";
import { Session } from "../internal_modules";
import { Nub } from "../internal_modules";
import { ParamCalculability } from "../internal_modules";
import { ParamsEquation } from "../internal_modules";
import { Result } from "../internal_modules";
import { ParallelStructureParams } from "../internal_modules";
import { Structure } from "../internal_modules";
import { loiAdmissiblesOuvrages, LoiDebit } from "../internal_modules";
import { MessageCode, Message } from "../internal_modules";
/**
 * 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
 * somme des débits de chaque structure.
export class ParallelStructure extends Nub {
    constructor(prms: ParamsEquation, dbg: boolean = false) {
        super(prms, dbg);
        this.setCalculatorType(CalculatorType.ParallelStructure);
    /** children casting */
    public get structures() {
        return this._children as Structure[];
    public set structures(structures: Structure[]) {
        this._children = structures;
        this._children.forEach((s) => {
            s.setParent(this);
        });
    /**
     * paramètres castés au bon type
    get prms(): ParallelStructureParams {
        return this._prms as ParallelStructureParams;
    /** Returns admissible LoiDebit grouped by StructureType */
    public getLoisAdmissibles(): { [key: string]: LoiDebit[]; } {
        return loiAdmissiblesOuvrages;
    /** Returns a flat array of all admissible LoiDebit */
    public getLoisAdmissiblesArray(): LoiDebit[] {
        let loisAdm: LoiDebit[] = [];
        const lois = this.getLoisAdmissibles();
        // tslint:disable-next-line:forin
        for (const k in lois) {
            loisAdm = loisAdm.concat(lois[k]);
        return loisAdm;
    /** Returns the 1st deep item from LoisAdmissibles */
    public getDefaultLoiDebit(): LoiDebit {
        const lois = this.getLoisAdmissibles();
        return lois[Object.keys(lois)[0]][0];
    /**
     * Effectue une série de calculs sur un paramètre; déclenche le calcul en chaîne
     * des modules en amont si nécessaire
     * Surcharge pour les tests préalables liés à la structure du nub
     * @param rInit solution approximative du paramètre
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
public CalcSerie(rInit?: number): Result { if (this.structures.length === 0) { this._result = new Result(undefined, this); this._result.globalLog.insert(new Message(MessageCode.ERROR_STRUCTURE_AU_MOINS_UNE)); return this._result; } return super.CalcSerie(rInit); } /** * Calcul du débit des structures en parallèle (sans détail pour chaque structure) * @param sVarCalc Variable à calculer (Q uniquement) */ public Equation(sVarCalc: string): Result { Structure.CheckEquation(sVarCalc); return this.CalcQ(); } /** * Calcul de la somme des débits de chaque structure * @param iExcept Index de la structure à ne pas additionner (optionnel) */ public CalcQ(iExcept?: number): Result { if (iExcept !== undefined) { if (iExcept < 0 || iExcept >= this._children.length) { throw new Error( "ParallelStructure.CalcQ iExcept not in [0;" + (this._children.length - 1) + "]", ); } } this.updateStructuresH1H2(); const calcRes: Result = new Result(0, this); let qTot: number = 0; for (let i = 0; i < this._children.length; i++) { if (i !== iExcept) { const res: Result = this._children[i].Calc("Q"); qTot += res.vCalc; // merge logs calcRes.resultElement.log.addLog(res.log); } } // Assigne le débit total dans le résultat calcRes.resultElement.vCalc = qTot; return calcRes; } /** * 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 { uid: "abcdef", symbol: "X" } avec "abcdef" l'index de l'ouvrage et "X" son paramètre * @param rInit Valeur initiale */ public Calc(sVarCalc: string | any, rInit?: number): Result { // if Calc() is called outside of CalcSerie(), _result might not be initialized if (!this.result) { this.initNewResultElement(); } switch (sVarCalc) { case "Z1": case "Z2": case "Q": this.currentResultElement = super.Calc(sVarCalc, rInit); if (this.result.ok) { this.getParameter(sVarCalc).v = this.result.resultElement.vCalc; } break; default: if (typeof sVarCalc === "string") { throw new Error("ParallelStructures.Calc() : unknow parameter to calculate " + sVarCalc);
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
} // Pour les caractéristiques des ouvrages const structureIndex = this.getIndexForChild(sVarCalc.uid); const r = this.CalcStructPrm(structureIndex, sVarCalc.symbol, rInit); // whether r is .ok() or not, just copy vCalc and logs to avoid // this._result being polluted by structure.flagsNull this.result.symbol = r.symbol; this.result.vCalc = r.vCalc; // merge logs this.result.log.addLog(r.log); this.result.globalLog.addLog(r.globalLog); } // check structures submergence for some discharge laws for (const st of this.structures) { st.checkSubmergence(); } return this.result; } /** * Once session is loaded, run a second pass on all linked parameters to * reset their target if needed */ public fixLinks(obj: any): { hasErrors: boolean } { // return value const ret = { hasErrors: false }; // iterate over parameters super.fixLinks(obj); // iterate over children if any if (obj.children && Array.isArray(obj.children)) { for (const s of obj.children) { // get the Nub const subNub = Session.getInstance().findNubByUid(s.uid); const res = subNub.fixLinks(s); // forward errors if (res.hasErrors) { ret.hasErrors = true; } } } return ret; } /** * paramétrage de la calculabilité des paramètres */ protected setParametersCalculability() { this.prms.Q.calculability = ParamCalculability.EQUATION; this.prms.Z1.calculability = ParamCalculability.DICHO; this.prms.Z2.calculability = ParamCalculability.DICHO; } /** * Mise à jour de Z1, Z2, h1 et h2 pour tous les ouvrages */ protected updateStructuresH1H2() { for (const structure of this.structures) { structure.prms.Z1.v = this.prms.Z1.v; structure.prms.Z2.v = this.prms.Z2.v; structure.prms.update_h1h2(); } } /** * Calcul du paramètre d'un des ouvrages en parallèle
211212213214215216217218219220221222223224225
* @param sVC Index de l'ouvrage et paramètre à calculer * @param rInit Valeur initiale */ protected CalcStructPrm(index: number, symbol: string, rInit?: number): Result { // Le débit restant sur la structure en calcul est : this.structures[index].prms.Q.v = this.prms.Q.v - this.CalcQ(index).vCalc; // Calcul du paramètre de la structure en calcul const r: Result = this.structures[index].Calc(symbol, rInit); this.structures[index].result.values.Q = this.structures[index].prms.Q.v; return r; } }