jalhyd
Version:
JaLHyd, a Javascript Library for Hydraulics
209 lines • 8.19 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ParallelStructure = void 0;
const internal_modules_1 = require("../internal_modules");
const internal_modules_2 = require("../internal_modules");
const internal_modules_3 = require("../internal_modules");
const internal_modules_4 = require("../internal_modules");
const internal_modules_5 = require("../internal_modules");
const internal_modules_6 = require("../internal_modules");
const internal_modules_7 = require("../internal_modules");
const internal_modules_8 = require("../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.
*/
class ParallelStructure extends internal_modules_3.Nub {
constructor(prms, dbg = false) {
super(prms, dbg);
/**
* true to inhibit emission of ERROR_STRUCTURE_SUBMERGENCE_LOWER_THAN error in Structure calculations and
* WARNING_SLOT_SUBMERGENCE_NOT_BETWEEN_07_AND_09 warning in StructureWeirSubmergedLarinier.
* Used during predams calculations.
*/
this.inhibitSubmergenceError = false;
this.setCalculatorType(internal_modules_1.CalculatorType.ParallelStructure);
}
/** children casting */
get structures() {
return this._children;
}
set structures(structures) {
this._children = structures;
this._children.forEach((s) => {
s.setParent(this);
});
}
/**
* paramètres castés au bon type
*/
get prms() {
return this._prms;
}
/** Returns admissible LoiDebit grouped by StructureType */
getLoisAdmissibles() {
return internal_modules_7.loiAdmissiblesOuvrages;
}
/** Returns a flat array of all admissible LoiDebit */
getLoisAdmissiblesArray() {
let loisAdm = [];
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 */
getDefaultLoiDebit() {
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
*/
CalcSerie(rInit) {
if (this.structures.length === 0) {
this._result = new internal_modules_5.Result(undefined, this);
this._result.globalLog.insert(new internal_modules_8.Message(internal_modules_8.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)
*/
Equation(sVarCalc) {
internal_modules_6.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)
*/
CalcQ(iExcept) {
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 = new internal_modules_5.Result(0, this);
let qTot = 0;
for (let i = 0; i < this._children.length; i++) {
if (i !== iExcept) {
const res = this._children[i].Calc("Q");
if (!res.ok) {
return res;
}
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
*/
Calc(sVarCalc, rInit) {
// 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);
}
// 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);
}
return this.result;
}
/**
* Once session is loaded, run a second pass on all linked parameters to
* reset their target if needed
*/
fixLinks(obj) {
// 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 = internal_modules_2.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
*/
setParametersCalculability() {
this.prms.Q.calculability = internal_modules_4.ParamCalculability.EQUATION;
this.prms.Z1.calculability = internal_modules_4.ParamCalculability.DICHO;
this.prms.Z2.calculability = internal_modules_4.ParamCalculability.DICHO;
}
/**
* Mise à jour de Z1, Z2, h1 et h2 pour tous les ouvrages
*/
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
* @param sVC Index de l'ouvrage et paramètre à calculer
* @param rInit Valeur initiale
*/
CalcStructPrm(index, symbol, rInit) {
// 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 = this.structures[index].Calc(symbol, rInit);
this.structures[index].result.values.Q = this.structures[index].prms.Q.v;
return r;
}
}
exports.ParallelStructure = ParallelStructure;
//# sourceMappingURL=parallel_structure.js.map