Commit 89f6e2fe authored by Le Faucheux Pierre's avatar Le Faucheux Pierre
Browse files

#22 Tests validés sur régime émergent

parent 8eb14f35
......@@ -34,9 +34,6 @@ function [res]=find_Q_nat(Q,ks,D,h,Cd0,S,L,pf,C,sigma,bDbg)
if(bDbg) then print_r("fFr"); end;
alpha=1-(1.*C).^0.5-1/2*sigma.*C;
Cd=Cd0.*(1+1./(pf./D).^2).*fFr;
//Cd=Cd0.*(0.8-2*C).*(1+0.4./(pf./D).^2).*fFr;
R=(1-sigma*C);//%.*(1-C.^0.5).^2;
......@@ -96,21 +93,27 @@ function [res]=find_Q_nat(Q,ks,D,h,Cd0,S,L,pf,C,sigma,bDbg)
else
alpha=1-(1.*C).^0.5-1/2*sigma.*C;
if bDbg then print_r('alpha'); end;
Cd=Cd0.*(1+1./(pf./D).^2).*fFr;
if bDbg then print_r('Cd'); end;
hstar=pf/D;
Re=U0.*pf/1e-6;
if bDbg then print_r('Re'); end;
if ks==0
Cf=0.3164/4.*Re.^(-0.25);
else
Cf=2/(5.1*log10(pf/ks-1)+6)^2;
end
if bDbg then print_r('Cf'); end;
N= (alpha.*Cf)./(pf./D.*Cd.*C);
if bDbg then print_r('N'); end;
res=abs(U0-(2*g.*S.*D.*(R)./(Cd.*C.*(1+N))).^0.5);
end
endfunction
function [res]=find_U0_R0(U01,h,C,D,sigma,Cd0,cfmean,r,S)
g=9.81;
Frexp=U01./(1-(1.*C).^0.5)./(9.81*h)^0.5;
//Frexp=U01./(9.81*h)^0.5;
fFr=(min(r./(1-(Frexp.^2)/4),Frexp.^(-2/3))).^2;
if Frexp>1.3
fFr=(Frexp.^(-2/3)).^2;
end
alpha=1-(1.*C);
Cd=Cd0.*(1+0.4./(h./D).^2).*fFr;
//Cd=Cd0.*1.*(1+1./(h./D).^2).*fFr;
N= (alpha.*cfmean)./(h./D.*Cd.*C);
hstar=h/D;
//res=(U01-(2*g.*S.*D.*(1-(sigma*C))./(Cd.*C.*(1+N))).^0.5);
res=abs(U01-(2*g.*S.*D*(1-sigma.*C)./(Cd.*C.*(1+N))).^0.5);
endfunction
......@@ -17,7 +17,7 @@ function macrorugo_resultComp(z_amont, S, long, Q, L, pf, C, Cd, h, D)
if pf/h<1
flowcond = 'emergent'
elseif pf/h<1.1 && pf/h>=1
elseif pf/h<1.1 & pf/h>=1
flowcond = 'quasi emergent'
else
flowcond = 'immerge'
......@@ -31,12 +31,11 @@ function macrorugo_resultComp(z_amont, S, long, Q, L, pf, C, Cd, h, D)
if Cd==2
q_technique= 0.648*(pf/D)^1.084*S^0.56*C^(-0.456)*(9.81*D)^0.5.*D*L;
V_technique=3.35*(pf/D)^0.27*S^0.53*(9.81*D)^0.5;
Vmax=Vg.*(min(coeff_contraction/(1-(Fr.^2)/4),Fr.^(-2/3)));
else
q_technique=0.815*(pf/D)^1.45*S^0.557*C^(-0.456)*(9.81*D)^0.5.*D*L;
V_technique=4.54*(pf/D)^0.32*S^0.56*(9.81*D)^0.5;
Vmax=Vg.*(min(coeff_contraction/(1-(Fr.^2)/4),Fr.^(-2/3)));
end
Vmax=Vg.*(min(coeff_contraction/(1-(Fr.^2)/4),Fr.^(-2/3)));
print_r("Vmax");
print_r("V_technique");
end
......
......@@ -20,6 +20,8 @@ function macrorugo_searchQ(ks, D, k, Cd0, S, B, h, C, z_amont, long, bDbg)
g=9.81
N=0;
q0=(2*g.*S.*D.*(1-(sigma*C))/(Cd0.*C.*(1+N))).^0.5*h*B;
fVal = find_Q_nat(q0,ks,D,k,Cd0,S,B,h,C,sigma,%t);
printf("find_Q_nat(%f)=%f\n",q0,fVal);
[Q fVal, exitflag, outputs] = fminsearch(list(find_Q_nat, ks,D,k,Cd0,S,B,h,C,sigma,bDbg), q0, opt);
printf("Q=%f fVal=%f\n",Q, fVal);
macrorugo_resultComp(z_amont, S, long, Q, B, h, C, Cd0, k, D)
......
......@@ -10,110 +10,185 @@ import { ParamCalculability, ParamValueMode } from "../../src";
import { MacroRugo, MacroRugoFlowType, MacrorugoParams } from "../../src/macrorugo/macrorugo";
import { checkPercent, checkResult } from "../test_func";
function macroRugoInstanceEmergent(): MacroRugo {
/*
*** Emergent conditions Cd=1.5***
ks=0.010000
D=0.500000
k=0.700000
Cd0=1.500000
S=0.050000
B=1.000000
h=0.600000
C=0.130000
Q=0.493722 fVal=0.000000
cote_bas = 12.200000
Vdeb = 0.822870
Fr = 0.530417
P = 242.170537
flowcond = emergent
Vmax = 1.799472
V_technique = 1.991299
q_technique = 0.561860
*/
function macroRugoInstanceEmergentCd15(): MacroRugo {
return new MacroRugo(
new MacrorugoParams(
12.5, // ZF1
6, // L
1, // B
0.05, // If
1.57, // Q
0.493722, // Q
0.6, // h
0.01, // Ks
0.05, // C
0.13, // C
0.5, // D
0.8, // k
0.7, // k
1.5 // Cd0
)
);
}
const macroRugoExtraResultEmergentCd15: { [key: string]: number|MacroRugoFlowType } = {
ENUM_MacroRugoFlowType: MacroRugoFlowType.EMERGENT,
Fr: 0.530417,
PV: 242.170537,
Q_GuideTech: 0.561860,
V_GuideTech: 1.991299,
Vdeb: 0.822870,
Vmax: 1.799472,
ZF2: 12.2
};
/*
*** Emergent conditions Cd=2***
ks=0.010000
D=0.500000
k=0.700000
Cd0=2.000000
S=0.050000
B=1.000000
h=0.600000
C=0.130000
Q=0.376808 fVal=0.000000
cote_bas = 12.200000
Vdeb = 0.628013
Fr = 0.404814
P = 184.824088
flowcond = emergent
Vmax = 1.536115
V_technique = 1.592932
q_technique = 0.414154
*/
function macroRugoInstanceEmergentCd2(): MacroRugo {
const nub: MacroRugo = macroRugoInstanceEmergentCd15();
nub.prms.Cd0.v = 2;
nub.prms.Q.v = 0.376808;
return nub;
}
const macroRugoExtraResultEmergentCd2: { [key: string]: number|MacroRugoFlowType } = {
ENUM_MacroRugoFlowType: MacroRugoFlowType.EMERGENT,
Fr: 0.404814,
PV: 184.824088,
Q_GuideTech: 0.414154,
V_GuideTech: 1.592932,
Vdeb: 0.628013,
Vmax: 1.536115,
ZF2: 12.2
};
/*
*** Submerged conditions ***
ks=0.010000
D=0.500000
k=0.700000
Cd0=1.500000
S=0.050000
B=1.000000
h=0.800000
C=0.130000
Q=0.908068 fVal=0.000000
cote_bas = 12.200000
Vdeb = 1.135085
Fr = 0.633645
P = 445.407266
flowcond = immerge
q_technique = 0.940450
*/
function macroRugoInstanceSubmerged(): MacroRugo {
const nub: MacroRugo = macroRugoInstanceEmergent();
const nub: MacroRugo = macroRugoInstanceEmergentCd15();
nub.prms.Y.v = 0.8;
nub.prms.PBH.v = 0.6;
nub.prms.Q.v = 4.737;
nub.prms.Q.v = 0.908068;
return nub;
}
function testMacroRugo(nubFactory: () => MacroRugo, varTest: string, valRef: number) {
describe("Calc(): ", () => {
it(`${varTest} should be ${valRef}`, () => {
const nub = nubFactory();
const macroRugoExtraResultSubmerged: { [key: string]: number|MacroRugoFlowType } = {
ENUM_MacroRugoFlowType: MacroRugoFlowType.SUBMERGED,
Fr: 0.633645,
PV: 445.407266,
Q_GuideTech: 0.940450,
Vdeb: 1.135085,
ZF2: 12.2
};
function MacroRugoFactory(sInstance: string): MacroRugo {
switch (sInstance) {
case "EmergentCd15": {
return macroRugoInstanceEmergentCd15();
}
case "EmergentCd2": {
return macroRugoInstanceEmergentCd2();
}
case "Submerged": {
return macroRugoInstanceSubmerged();
}
default: {
throw new Error("Instance name error");
}
}
}
function testMacroRugo(sInstance: string, varTest: string, valRef: number) {
it(`Calc(${varTest}) should be ${valRef}`, () => {
const nub = MacroRugoFactory(sInstance);
nub.prms.Q.v = nub.Calc("Q").vCalc;
const p = nub.getParameter(varTest);
p.v = undefined;
p.valueMode = ParamValueMode.CALCUL;
checkResult(nub.Calc(varTest, 0.1), valRef);
});
});
}
describe("Class MacroRugo: ", () => {
describe("Emerged conditions", () => {
it(`resolveU0(2.58) should be around 0`, () => {
const nubit = macroRugoInstanceEmergent();
function testMacroRugoConfig(sInstance: string, Q0: number, fVal0: number, mrExtraRes: { [key: string]: number }) {
describe(`Conditions: ${sInstance}` , () => {
it(`resolveQ(${Q0}) should be ${fVal0}`, () => {
const nubit = MacroRugoFactory(sInstance);
// tslint:disable-next-line:no-string-literal
expect(nubit["resolveU0"](2.58)).toBeCloseTo(0, 1);
});
it(`resolveQ(1.547827) should be around 0`, () => {
const nubit = macroRugoInstanceEmergent();
// tslint:disable-next-line:no-string-literal
expect(nubit["resolveQ"](1.547827)).toBeCloseTo(0, 1);
});
it(`Calc("Q") should be around 1.548`, () => {
checkResult(macroRugoInstanceEmergent().Calc("Q", 0.1), 1.548, 1);
});
it(`Calc("Q", 0.1).extraResults.ZF2 should be around 12.2`, () => {
expect(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.ZF2).toBeCloseTo(12.2, 3);
});
it(`Calc("Q", 0.1).extraResults.Vdeb should be around 2.579818`, () => {
checkPercent(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.Vdeb, 2.579818, 0.03);
});
it(`Calc("Q", 0.1).extraResults.V should be around 2.694279`, () => {
checkPercent(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.V, 2.694279, 0.03);
});
it(`Calc("Q", 0.1).extraResults.Fr should be around 1.369611`, () => {
checkPercent(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.Fr, 1.369611, 0.03);
});
it(`Calc("Q", 0.1).extraResults.P should be around 759.240352`, () => {
checkPercent(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.PV, 759.240352, 0.03);
});
it(`Calc("Q", 0.1).extraResults.FlowType should be MacroRugoFlowType.EMERGENT`, () => {
expect(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.ENUM_MacroRugoFlowType)
.toBe(MacroRugoFlowType.EMERGENT);
});
it(`Calc("Q", 0.1).extraResults.Q2 should be around 0.868672`, () => {
checkPercent(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.Q_GuideTech, 0.868672, 0.03);
});
it(`Calc("Q", 0.1).extraResults.V2 should be around 1.991299`, () => {
checkPercent(macroRugoInstanceEmergent().Calc("Q", 0.1).extraResults.V_GuideTech, 1.991299, 0.03);
expect(nubit["resolveQ"](Q0)).toBeCloseTo(fVal0, 5);
});
const nub = macroRugoInstanceEmergent();
const nub = MacroRugoFactory(sInstance);
for (const prm of nub.prms) {
if ([ParamCalculability.DICHO, ParamCalculability.EQUATION].includes(prm.calculability)) {
testMacroRugo(macroRugoInstanceEmergent, prm.symbol, prm.v);
testMacroRugo(sInstance, prm.symbol, prm.v);
}
}
for (const sExtraRes in mrExtraRes) {
if (mrExtraRes.hasOwnProperty(sExtraRes)) {
it(`${sExtraRes} should be ${mrExtraRes[sExtraRes]}`, () => {
expect(MacroRugoFactory(sInstance).Calc("Q").extraResults[sExtraRes])
.toBeCloseTo(mrExtraRes[sExtraRes], 5);
});
}
}
});
describe("Submerged conditions", () => {
it(`resolveQ(4.737) should be around 0`, () => {
const nubit = macroRugoInstanceSubmerged();
// tslint:disable-next-line:no-string-literal
expect(nubit["resolveQ"](4.737)).toBeCloseTo(0, 1);
});
}
});
describe("Class MacroRugo: ", () => {
testMacroRugoConfig("EmergentCd15", 0.901710, 0.379574, macroRugoExtraResultEmergentCd15);
testMacroRugoConfig("EmergentCd2", 0.768677, 0.418044, macroRugoExtraResultEmergentCd2);
testMacroRugoConfig("Submerged", 1.202280, 0.145051, macroRugoExtraResultSubmerged);
});
......@@ -9,7 +9,7 @@ export { MacrorugoParams };
export enum MacroRugoFlowType {
EMERGENT,
QUASI_EMERGENT,
IMMERGE
SUBMERGED
}
export class MacroRugo extends Nub {
......@@ -52,8 +52,7 @@ export class MacroRugo extends Nub {
/**
* 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 "n.X" avec "n" l'index de l'ouvrage et "X" son paramètre
* @param sVarCalc Nom du paramètre à calculer
* @param rInit Valeur initiale
* @param rPrec Précision attendue
*/
......@@ -67,10 +66,14 @@ export class MacroRugo extends Nub {
// Vitesse débitante
r.extraResults.Vdeb = this.V(this.prms.Q) / this.prms.B.v / this.prms.Y.v;
// Froude
r.extraResults.Fr = r.extraResults.Vdeb / (1 - Math.sqrt(MacroRugo.fracAxAy * this.prms.C.v))
/ Math.sqrt(MacroRugo.g * this.prms.Y.v);
const vg: number = r.extraResults.Vdeb / (1 - Math.sqrt(MacroRugo.fracAxAy * this.prms.C.v));
r.extraResults.Fr = vg / Math.sqrt(MacroRugo.g * this.prms.Y.v);
// Vitesse maximale
r.extraResults.V = r.extraResults.Vdeb * this.calc_fFr(r.extraResults.Vdeb);
const cc = 0.4 * this.prms.Cd0.v + 0.7;
r.extraResults.Vmax = vg * Math.min(
cc / (1 - Math.pow(r.extraResults.Fr, 2) / 4),
Math.pow(r.extraResults.Fr, -2 / 3)
);
// Puissance dissipée
r.extraResults.PV = 1000 * MacroRugo.g * this.V(this.prms.Q) / this.prms.B.v * this.prms.If.v;
// Type d'écoulement
......@@ -79,13 +82,13 @@ export class MacroRugo extends Nub {
} else if (this.prms.Y.v / this.prms.PBH.v < MacroRugo.limitSubmerg) {
r.extraResults.ENUM_MacroRugoFlowType = MacroRugoFlowType.QUASI_EMERGENT;
} else {
r.extraResults.ENUM_MacroRugoFlowType = MacroRugoFlowType.IMMERGE;
r.extraResults.ENUM_MacroRugoFlowType = MacroRugoFlowType.SUBMERGED;
}
// Vitesse et débit du guide technique
let cQ: [number, number, number, number];
let cV: [number, number, number];
let hdk: number;
if (this.prms.Y.v / this.prms.PBH.v > MacroRugo.limitSubmerg) {
if (r.extraResults.ENUM_MacroRugoFlowType === MacroRugoFlowType.SUBMERGED) {
cQ = [0.955, 2.282, 0.466, -0.23];
hdk = this.prms.PBH.v;
} else {
......@@ -101,9 +104,9 @@ export class MacroRugo extends Nub {
r.extraResults.Q_GuideTech = cQ[0] * Math.pow(this.prms.Y.v / hdk, cQ[1]) *
Math.pow(this.prms.If.v, cQ[2]) * Math.pow(this.prms.C.v, cQ[3]) *
Math.sqrt(MacroRugo.g * hdk) * hdk * this.prms.B.v;
if (this.prms.Y.v / this.prms.PBH.v <= MacroRugo.limitSubmerg) {
if (r.extraResults.ENUM_MacroRugoFlowType !== MacroRugoFlowType.SUBMERGED) {
r.extraResults.V_GuideTech = cV[0] * Math.pow(this.prms.Y.v / this.prms.PBD.v, cV[1]) *
Math.pow(this.prms.If.v, cQ[2]) * Math.sqrt(MacroRugo.g * this.prms.PBD.v);
Math.pow(this.prms.If.v, cV[2]) * Math.sqrt(MacroRugo.g * this.prms.PBD.v);
}
return r;
}
......@@ -201,11 +204,11 @@ export class MacroRugo extends Nub {
// Calcul de u moyen
uMoy = (Qinf + Qsup) / k;
} else {
} else {
// Emergent conditions
// Resolve equation (4) Cassan et al., 2016
uMoy = uniroot(this.resolveU0, this, 0, 1E7);
return this.resolveEmergent();
}
return this.U0 - uMoy;
}
......@@ -241,11 +244,11 @@ export class MacroRugo extends Nub {
/**
* Bed friction coefficient Equation (3) (Cassan et al., 2016)
*/
private calcCf(U0: number): number {
private calcCf(): number {
if (this.prms.Ks.v < 1E-6) {
if (this.prms.Ks.v < 1E-9) {
// Between Eq (8) and (9) (Cassan et al., 2016)
const reynolds = U0 * this.prms.Y.v / MacroRugo.nu;
const reynolds = this.U0 * this.prms.Y.v / MacroRugo.nu;
return 0.3164 / 4. * Math.pow(reynolds, -0.25);
} else {
// Equation (3) (Cassan et al., 2016)
......@@ -292,7 +295,7 @@ export class MacroRugo extends Nub {
private resolveAlpha_t(alpha: number): number {
/** s: minimum distance between blocks */
const s = this.prms.PBD.v * ( 1 / Math.sqrt(this.prms.C.v) - 1);
const s = this.prms.PBD.v * (1 / Math.sqrt(this.prms.C.v) - 1);
/** Equation(11) Cassan et al., 2016 */
const l0 = Math.min(s, 0.15 * this.prms.PBH.v);
......@@ -300,17 +303,17 @@ export class MacroRugo extends Nub {
return alpha * this.calcUz(alpha) - l0 * this.ustar;
}
private resolveU0(U0: number): number {
private resolveEmergent(): number {
const g = MacroRugo.g;
const alpha = 1 - (1 / MacroRugo.fracAxAy * this.prms.C.v);
const alpha = 1 - Math.pow(1 * this.prms.C.v, 0.5) - 0.5 * this.sigma * this.prms.C.v;
// tslint:disable-next-line:variable-name
const Cd = this.calcCd(this.calc_fFr(U0));
const Cd = this.prms.Cd0.v * (1 + 1 / Math.pow(this.prms.Y.v / this.prms.PBD.v, 2)) * this.calc_fFr(this.U0);
/** N from Cassan 2016 eq(2) et Cassan 2014 eq(12) */
const N = (alpha * this.calcCf(U0)) / (this.prms.Y.v / this.prms.PBD.v * Cd * this.prms.C.v);
const N = (alpha * this.calcCf()) / (this.prms.Y.v / this.prms.PBD.v * Cd * this.prms.C.v);
return U0 - Math.sqrt(
return this.U0 - Math.sqrt(
2 * MacroRugo.g * this.prms.If.v * this.prms.PBD.v *
(1 - this.sigma * this.prms.C.v) / (Cd * this.prms.C.v * (1 + N))
);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment