import { CalculatorType, ComputeNodeType } from "./compute-node";
import { Nub } from "./nub";
import { Props } from "./props";
// Calculettes
import { ConduiteDistrib, ConduiteDistribParams } from "./cond_distri";
import { LechaptCalmon, LechaptCalmonParams } from "./lechaptcalmon";
import { MacroRugo, MacrorugoParams } from "./macrorugo/macrorugo";
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 Session {
public static getInstance() {
if (Session._instance === undefined) {
Session._instance = new Session();
}
return Session._instance;
}
/** instance pour le pattern singleton */
private static _instance: Session;
private defaultPrecision: number = 0.001;
/** Nubs de la session */
private _nubs: Nub[];
constructor() {
this._nubs = [];
}
/**
* crée un Nub et l'ajoute à la session
*/
public createSessionNub(p: Props, dbg: boolean = false): Nub {
const res = this.newNubWithProps(p, dbg);
this._nubs.push(res);
return res;
}
/**
* remplace un Nub par un nouveau dans la session
* @param sn Nub à remplacer
* @param params propriété du nouveau Nub
*/
public replaceNub(sn: Nub, params: Props): Nub {
let i = 0;
for (const n of this._nubs) {
if (n.uid === sn.uid) {
const newNub = this.newNubWithProps(params);
this._nubs[i] = newNub;
// move structure inside parent
if (sn instanceof Structure) {
const struct = sn as Structure;
if (struct.parent) {
struct.parent.replaceStructureInplace(struct, newNub as Structure);
} else {
throw new Error("Structure nub had no parent");
}
}
return newNub;
}
i++;
}
// pas trouvé
return undefined;
}
/**
* Removes a Nub from the session
* @param sn the Nub to remove
*/
public deleteNub(sn: Nub) {
let i = 0;
for (const n of this._nubs) {
if (n.uid === sn.uid) {
this._nubs.splice(i, 1);
return;
}
i++;
}
throw new Error(`Session.deleteNub() : le Nub (uid ${sn.uid}) à supprimer n'a pas été trouvé`);
}
private newNubWithProps(p: Props, dbg: boolean = false): Nub {
const nub = this.createNub(p, dbg);
return nub;
}
/**
* Crée un Nub à partir d'une description (Props)
* @param params paramètres supplémentaires spécifiques
* - calcType: type de Nub
* - nodeType: sous type de Nub
* @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");
let nub: Nub;
let prms: any;
switch (calcType) {
case CalculatorType.ConduiteDistributrice:
{
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
);
nub = new ConduiteDistrib(prms, dbg);
break;
}
case CalculatorType.LechaptCalmon:
{
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
);
nub = new LechaptCalmon(prms, dbg);
break;
}
case CalculatorType.SectionParametree:
{
nub = new SectionParametree(this.createSection(nodeType, dbg), dbg);
break;
}
case CalculatorType.RegimeUniforme:
{
const sect: acSection = this.createSection(nodeType, dbg);
const ru = new RegimeUniforme(sect, dbg);
nub = ru;
break;
}
case CalculatorType.CourbeRemous:
{
const sectCR: acSection = this.createSection(nodeType, dbg);
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
);
nub = new CourbeRemous(prms, dbg);
break;
}
case CalculatorType.PabDimensions:
{
prms = new PabDimensionParams(
2, // Longueur L
1, // Largeur W
0.5, // Tirant d'eau Y
2 // Volume V
);
nub = new PabDimension(prms, dbg);
break;
}
case CalculatorType.PabPuissance:
{
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)
);
nub = new PabPuissance(prms, dbg);
break;
}
case CalculatorType.Structure:
{
const structType: StructureType = params.getPropValue("structureType");
const loiDebit: LoiDebit = params.getPropValue("loiDebit");
nub = CreateStructure(structType, loiDebit);
break;
}
case CalculatorType.ParallelStructure:
{
prms = new ParallelStructureParams(0.5, // Q
102, // Z1
101.5 // Z2
);
nub = new ParallelStructure(prms, dbg);
break;
}
case CalculatorType.Dever:
{
const deverPrms = new DeverParams(0.5, // Q
102, // Z1
10, // BR : largeur du cours d'eau
99 // ZR : cote du lit du cours d'eau
);
nub = new Dever(deverPrms, dbg);
break;
}
case CalculatorType.Cloisons:
{
nub = 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)
0.5 // Hauteur de chute (m)
), dbg
);
break;
}
case CalculatorType.MacroRugo:
{
nub = new MacroRugo(
new MacrorugoParams(
12.5, // ZF1
6, // L
1, // B
0.05, // If
1.57, // Q
0.6, // h
0.01, // Ks
0.05, // C
0.5, // D
0.8, // k
1.5 // Cd0
)
);
break;
}
default:
{
throw new Error(
// tslint:disable-next-line:max-line-length
`Session.createNub() : calculatrice '${CalculatorType[calcType]}' / noeud de calcul '${ComputeNodeType[nodeType]}' non pris en charge`
);
}
}
// propagate properties
nub.properties = params;
return nub;
}
/**
* Crée un Nub de type Section
* @param nt ComputeNodeType
* @param dbg activer débogage
*/
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);
}
default:
throw new Error(`type de section ${ComputeNodeType[nt]} non pris en charge`);
}
}
}