nub_factory.ts 15.74 KiB
import { CalculatorType, ComputeNodeType } from "./compute-node";
import { Nub } from "./nub";
import { Props, SessionNub } from "./session_nub";
// Calculettes
import { ConduiteDistrib, ConduiteDistribParams } from "./cond_distri";
import { LechaptCalmon, LechaptCalmonParams } from "./lechaptcalmon";
import { PabDimension, PabDimensionParams } from "./pab/pab_dimension";
import { PabPuissance, PabPuissanceParams } from "./pab/pab_puissance";
import { RegimeUniforme } from "./regime_uniforme";
import { CourbeRemous, CourbeRemousParams, MethodeResolution } from "./remous";
import { SectionParametree } from "./section/section_nub";
import { Cloisons, CloisonsParams } from "./structure/cloisons";
import { Dever, DeverParams } from "./structure/dever";
import { ParallelStructure, ParallelStructureParams } from "./structure/parallel_structure";
// Classes relatives aux sections
import { cSnCirc, ParamsSectionCirc } from "./section/section_circulaire";
import { cSnPuiss, ParamsSectionPuiss } from "./section/section_puissance";
import { cSnRectang, ParamsSectionRectang } from "./section/section_rectang";
import { cSnTrapez, ParamsSectionTrapez } from "./section/section_trapez";
import { acSection } from "./section/section_type";
// Classes relatives aux structures
import { CreateStructure } from "./structure/factory_structure";
import { Structure } from "./structure/structure";
import { LoiDebit, StructureType } from "./structure/structure_props";
export class NubFactory {
    public static getInstance() {
        if (NubFactory._instance === undefined) {
            NubFactory._instance = new NubFactory();
        return NubFactory._instance;
    private static _instance: NubFactory; // instance pour le pattern singleton
    private _defaultPrecision: number = 0.001;
    private _session: SessionNub[];
    constructor() {
        this._session = [];
    public setDefaultPrecision(p: number) {
        this._defaultPrecision = p;
    /**
     * créé un Nub et l'ajoute à la session
    public createSessionNub(p: Props | {}, dbg: boolean = false): SessionNub {
        const res = this.newSessionNub(p, dbg);
        this._session.push(res);
        return res;
    public findSessionNub(params: Props | {}): SessionNub {
        for (const n of this._session) {
            if (n.hasProperties(params)) {
                return n;
        return undefined;
    /**
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
* remplace un SessionNub par un nouveau * @param sn SessionNub à remplacer * @param params propriété du nouveau SessionNub */ public replaceSessionNub(sn: SessionNub, params: Props): SessionNub { let i = 0; for (const n of this._session) { if (n.uid === sn.uid) { const newNub = this.newSessionNub(params); this._session[i] = newNub; this.replaceStructureNub(sn.nub, newNub.nub); return newNub; } i++; } // pas trouvé return undefined; } /** * déplace un SessionNub associé à un nub Structure d'une position vers le début de la liste de structures * @param sn SessionNub à remplacer * @param params propriété du nouveau SessionNub */ public moveStructureNubUp(sn: SessionNub) { const psn = this.findParallelStructureWithNub(sn.nub); // déplacement if (psn) { let i = 0; for (const n of this._session) { if (n.uid === sn.uid && i > 0) { const nS: SessionNub = this._session[i - 1]; this._session[i - 1] = this._session[i]; this._session[i] = nS; psn.moveStructureUp(sn.nub as Structure); return; } i++; } } throw new Error( `NubFactory.moveStructureNubUp() : la structure (uid ${sn.uid}) à déplacer n'a pas été trouvée` ); } /** * déplace un SessionNub associé à un nub Structure d'une position vers la fin de la liste de structures * @param sn SessionNub à remplacer */ public moveStructureNubDown(sn: SessionNub) { const psn = this.findParallelStructureWithNub(sn.nub); // déplacement if (psn) { let i = 0; for (const n of this._session) { if (n.uid === sn.uid && i < this._session.length - 1) { const nS: SessionNub = this._session[i]; this._session[i] = this._session[i + 1]; this._session[i + 1] = nS; psn.moveStructureDown(sn.nub as Structure); return; } i++; } }
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
throw new Error( `NubFactory.moveStructureNubDown() : la structure (uid ${sn.uid}) à déplacer n'a pas été trouvée` ); } public deleteSessionNub(sn: SessionNub) { let i = 0; for (const n of this._session) { if (n.uid === sn.uid) { this._session.splice(i, 1); this.deleteStructureNub(sn.nub); return; } i++; } throw new Error(`NubFactory.deleteSessionNub() : le SessionNub (uid ${sn.uid}) à supprimer n'a pas été trouvé`); } private newSessionNub(p: Props | {}, dbg: boolean = false): SessionNub { const params = p instanceof Props ? p : new Props(p); const nub = this.createNub(params, dbg); return new SessionNub(nub, params); } private replaceStructureNub(oldNub: Nub, newNub: Nub) { const b1 = oldNub instanceof Structure; const b2 = newNub instanceof Structure; if ((b1 && !b2) || (!b1 && b2)) { throw new Error( `NubFactory.replaceStructureNub() : arguments incorrects (${typeof (oldNub)}/${typeof (newNub)}` ); } if (b1 && b2) { for (const sn of this._session) { if (sn.nub instanceof ParallelStructure) { const psn = sn.nub as ParallelStructure; let i = 0; for (const st of psn.structures) { if (st.uid === oldNub.uid) { psn.replaceStructure(i, newNub as Structure); return; } i++; } } } throw new Error( `NubFactory.replaceStructureNub() : la structure (uid ${oldNub.uid}) à remplacer n'a pas été trouvée` ); } // copie (dans la mesure du possible) des modes de valeur des paramètres for (const p of newNub.parameters) { try { const p2 = oldNub.getParameter(p.symbol); p.valueMode = p2.valueMode; } catch (e) { // ??? } } } private deleteStructureNub(n: Nub) { if (n instanceof Structure) { for (const sn of this._session) { if (sn.nub instanceof ParallelStructure) { const psn = sn.nub as ParallelStructure; let i = 0; for (const st of psn.structures) { if (st.uid === n.uid) {
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
psn.deleteStructure(i); return; } i++; } } } throw new Error( `NubFactory.deleteStructureNub() : la structure (uid ${n.uid}) à supprimer n'a pas été trouvée` ); } } /** * recherche du nub ouvrages parallèles possédant l'ouvrage donné */ private findParallelStructureWithNub(n: Nub) { for (const s of this._session) { if (s.nub instanceof ParallelStructure) { const res = s.nub as ParallelStructure; if (res.hasStructure(n)) { return res; } } } return undefined; } /** * créé un Nub * @param calcType type de Nub * @param nodeType sous type de Nub * @param params paramètres supplémentaires spécifiques * @param dbg activer débogage */ private createNub(params: Props, dbg: boolean = false): Nub { const calcType: CalculatorType = params.getPropValue("calcType"); const nodeType: ComputeNodeType = params.getPropValue("nodeType"); switch (calcType) { case CalculatorType.ConduiteDistributrice: { const prms = new ConduiteDistribParams(3, // débit Q 1.2, // diamètre D 0.6, // perte de charge J 100, // Longueur de la conduite Lg 1e-6, // Viscosité dynamique Nu ); return new ConduiteDistrib(prms, dbg); } case CalculatorType.LechaptCalmon: { const prms = new LechaptCalmonParams(3, // débit 1.2, // diamètre 0.6, /// perte de charge 100, // longueur du toyo 1.863, // paramètre L du matériau 2, // paramètre M du matériau 5.33// paramètre N du matériau ); return new LechaptCalmon(prms, dbg); } case CalculatorType.SectionParametree: return new SectionParametree(this.createSection(nodeType, dbg), dbg); case CalculatorType.RegimeUniforme: const sect: acSection = this.createSection(nodeType, dbg);
281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350
const ru = new RegimeUniforme(sect, dbg); return ru; case CalculatorType.CourbeRemous: { const sectCR: acSection = this.createSection(nodeType, dbg); const prms = new CourbeRemousParams(sectCR, 0.15, // Yamont = tirant amont 0.4, // Yaval = tirant aval 100, // Long= Longueur du bief 5, // Dx=Pas d'espace MethodeResolution.EulerExplicite ); return new CourbeRemous(prms, dbg); } case CalculatorType.PabDimensions: { const prms = new PabDimensionParams( 2, // Longueur L 1, // Largeur W 0.5, // Tirant d'eau Y 2 // Volume V ); return new PabDimension(prms, dbg); } case CalculatorType.PabPuissance: { const prms = new PabPuissanceParams( 0.3, // Chute entre bassins DH (m) 0.1, // Débit Q (m3/s) 0.5, // Volume V (m3) 588.6 // Puissance dissipée PV (W/m3) ); return new PabPuissance(prms, dbg); } case CalculatorType.Structure: const structType: StructureType = params.getPropValue("structureType"); const loiDebit: LoiDebit = params.getPropValue("loiDebit"); return CreateStructure(structType, loiDebit); case CalculatorType.ParallelStructure: { const prms = new ParallelStructureParams(0.5, // Q 102, // Z1 101.5 // Z2 ); return new ParallelStructure(prms, dbg); } case CalculatorType.Dever: { const prms = new DeverParams(0.5, // Q 102, // Z1 10, // BR : largeur du cours d'eau 99 // ZR : cote du lit du cours d'eau ); return new Dever(prms, dbg); } case CalculatorType.Cloisons: { return new Cloisons( new CloisonsParams( 0, // Débit total (m3/s) 102, // Cote de l'eau amont (m) 10, // Longueur des bassins (m) 1, // Largeur des bassins (m) 1, // Profondeur moyenne (m)
351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
0.5 // Hauteur de chute (m) ), dbg ); } default: throw new Error( // tslint:disable-next-line:max-line-length `NubFactory.createNub() : calculatrice '${CalculatorType[calcType]}' / noeud de calcul '${ComputeNodeType[nodeType]}' non pris en charge` ); } } private createSection(nt: ComputeNodeType, dbg: boolean = false): acSection { switch (nt) { case ComputeNodeType.None: // pour les paramètres communs, n'importe quelle section convient case ComputeNodeType.SectionTrapeze: { const prms = new ParamsSectionTrapez(2.5, // largeur de fond 0.56, // fruit 0.8, // tirant d'eau 40, // Ks=Strickler 1.2, // Q=Débit 0.001, // If=pente du fond this._defaultPrecision, // précision 1, // YB= hauteur de berge ); return new cSnTrapez(prms, dbg); } case ComputeNodeType.SectionRectangle: { const prms = new ParamsSectionRectang(0.8, // tirant d'eau 2.5, // largeur de fond 40, // Ks=Strickler 1.2, // Q=Débit 0.001, // If=pente du fond this._defaultPrecision, // précision 1 // YB=hauteur de berge ); return new cSnRectang(prms, dbg); } case ComputeNodeType.SectionCercle: { const prms = new ParamsSectionCirc(2, // diamètre 0.8, // tirant d'eau 40, // Ks=Strickler 1.2, // Q=Débit 0.001, // If=pente du fond this._defaultPrecision, // précision 1, // YB= hauteur de berge ); return new cSnCirc(prms, dbg); } case ComputeNodeType.SectionPuissance: { const prms = new ParamsSectionPuiss(0.5, // coefficient 0.8, // tirant d'eau 4, // largeur de berge 40, // Ks=Strickler 1.2, // Q=Débit 0.001, // If=pente du fond this._defaultPrecision, // précision 1, // YB= hauteur de berge ); return new cSnPuiss(prms, dbg); }
421422423424425426427428429430431
default: throw new Error(`type de section ${ComputeNodeType[nt]} non pris en charge`); } } // public get sessionNubIterator(): IterableIterator<SessionNub> { // return this._session[Symbol.iterator](); // crée un itérateur à partir d'un tableau // } }