parallel_structure.ts

import { CalculatorType } from "../compute-node";
import { Nub } from "../nub";
import { Pab } from "../pab/pab";
import { ParamCalculability } from "../param/param-definition";
import { ParamsEquation } from "../param/params-equation";
import { Session } from "../session";
import { Result } from "../util/result";
import { ParallelStructureParams } from "./parallel_structure_params";
import { Structure, StructureParams } from "./structure";
import { loiAdmissiblesOuvrages, LoiDebit } from "./structure_props";

export { ParallelStructureParams };

/**
 * 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._calcType = 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.parent = this;
        });
    }

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

    /**
     * Is the Nub used in a PAB?
     */
    get isInPAB(): boolean {
        return (this.parent !== undefined && this.parent instanceof Pab);
    }

    public adjustChildParameters(child: Nub) {
        const prms = child.prms as StructureParams;
        if (!this.isInPAB && prms.ZDV.visible) {
            // Dans le contexte hors PAB
            // Pour les seuils (i.e. Structures avec cote de radier de seuil)
            // on remplace ZDV par h1 la charge sur le seuil
            prms.h1.visible = true;
            prms.ZDV.visible = false;
        }
    }

    /** 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[] = [];