diff --git a/.vscode/settings.json b/.vscode/settings.json index 0b2301e3f456aec1b5824af8e18c649154242ab9..bfe798cdd5cacba7673fc10e9e3939e19a15f00e 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -6,5 +6,14 @@ "latex", "plaintext", "markdown" + ], + "cSpell.words": [ + "Cassan", + "DICHO", + "MACRORUGO", + "fdescribe", + "jalhyd", + "nghyd", + "prms" ] } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 62d238d7383bf327f9802d4ace0d6a8aca1a8dcf..6977faf6b44138df65d6928c8d73b04f7c481637 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,11 +1,58 @@ # Historique des versions +### 4.14.2 - 2021-03-25 + +#### Nouvelles fonctionnalités + +* Passe à macro-rugosité: Retour aux formules utilisées dans la v4.13.1 ([jalhyd#297](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/297), [nghyd#493](https://gitlab.irstea.fr/cassiopee/nghyd/issues/493)) + +#### Correction de bogues + +* Passe à macro-rugosité: error de calcul de la vitesse max ([jalhyd#294](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/294)) +* Graphiques: lorsqu'on relance un calcul les axes ne se mettent pas à jour ([nghyd#489](https://gitlab.irstea.fr/cassiopee/nghyd/issues/489)) + +#### Documentation + +* Macrorugo : Documentation de Cd0 avec schéma ([nghyd#492](https://gitlab.irstea.fr/cassiopee/nghyd/issues/492)) + +### 4.14.1 - 2021-02-17 + +#### Nouvelles fonctionnalités + +* Passe à macro-rugosité: Changer Cd0 pour Cx et ajuster Cd0 aux données expérimentales ([jalhyd#291](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/291)) + +#### Correction de bogues + +* Vérificateur de passe: message erroné pour les passes à macro-rugosités submergées ([jalhyd#292](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/292)) + +### 4.14.0 - 2021-02-16 (Scomber scombrus) + +#### Nouvelles fonctionnalités +* Passe à macro-rugosité: Mise à jour des formules de calcul ([jalhyd#283](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/283)) +* Passe à macro-rugosité: Ajout de la vitesse moyenne entre les blocs ([jalhyd#285](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/285)) +* Passe à macro-rugosité: Ajout du Strickler équivalent dans les résultats liables à des Strickler ([jalhyd#287](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/287)) +* Passe à macro-rugosité: ajout d'un avertissement pour les concentrations en dehors de l'intervalle validé par les expérimentations ([jalhyd#284](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/284)) +* Vérificateur: Les passes à macro-rugosité submergées sont non franchissables ([jalhyd#290](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/290)) + +#### Correction de bogues + +* Passe à macro-rugosité: Calcul de la puissance dissipée erroné ([jalhyd#282](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/282)) +* Crash au chargement d'un module contenant une parenthèse dans son nom ([nghyd#487](https://gitlab.irstea.fr/cassiopee/nghyd/issues/487)) +* Electron: l'icône de l'application n'est plus reconnue ([nghyd#485](https://gitlab.irstea.fr/cassiopee/nghyd/issues/485)) + +#### Documentation + +* Documentation du solveur multi-module et des modules de calcul mathématiques ([nghyd#433](https://gitlab.irstea.fr/cassiopee/nghyd/issues/433)) +* Macrorugo : documenter le coefficient de forme Cd0 ([nghyd#477](https://gitlab.irstea.fr/cassiopee/nghyd/issues/477)) +* MacroRugo: erreur de formule de correction de Cd dans la documentation ([nghyd#488](https://gitlab.irstea.fr/cassiopee/nghyd/issues/488)) +* Documentation du module de calcul de la cote amont / aval d'un bief ([nghyd#490](https://gitlab.irstea.fr/cassiopee/nghyd/issues/490)) + ### 4.13.1 - 2020-10-02 #### Correction de bogues * PreBarrage: Distribution des débits erronée sur exemple simple ([jalhyd#279](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/279)) -* PreBarrage: rreur de calcul sur Z2 > Z1 initiale ([jalhyd#280](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/280)) +* PreBarrage: erreur de calcul sur Z2 > Z1 initiale ([jalhyd#280](https://gitlab.irstea.fr/cassiopee/jalhyd/issues/280)) * Prebarrage : avec Chrome (et electron) le schéma est mal rendu ([nghyd#482](https://gitlab.irstea.fr/cassiopee/nghyd/issues/482)) ### 4.13.0 - 2020-09-24 (Michel Larinier) diff --git a/docs/en/calculators/hsl/cote_amont_aval.md b/docs/en/calculators/hsl/cote_amont_aval.md new file mode 100644 index 0000000000000000000000000000000000000000..98d6429018f849e4c3d1632a4e312e1cbbd98d74 --- /dev/null +++ b/docs/en/calculators/hsl/cote_amont_aval.md @@ -0,0 +1,11 @@ +# Upstream / downstream elevations of a reach + +This module is based on the equations of the [backwater curves module](courbe_remous.md) and is used to calculate the following: + +- The water elevation upstream of a reach of a fluvial backwater curve; +- The water elevation downstream of a reach of a torrential backwater curve; +- The flow that connects the upstream and downstream water elevations of a fluvial or torrential backwater curve. + +The regime chosen on the type of water line determines whether the calculation is made from downstream to upstream (fluvial regime) and from upstream to downstream (torrential regime). + +This calculation module is particularly useful for calculating the water line of a series of hydraulic structures or reaches (see the typical example "Flow of a channel with structures"). diff --git a/docs/en/calculators/maths/operators.md b/docs/en/calculators/maths/operators.md new file mode 100644 index 0000000000000000000000000000000000000000..18c77c3b935c07c54b86c8942225bd5eae7409fb --- /dev/null +++ b/docs/en/calculators/maths/operators.md @@ -0,0 +1,40 @@ +# Operators and trigonometric functions + +The basic mathematical operators and functions provided by Cassiopeia make it possible above all to facilitate the link between the results of one calculation module and the input into another in the case of a sequence of calculations between several modules. The provided example "Weir jet length" shows the use of the "Linear function" module. + +<div style="position: relative"><a id="fonction-affine" style="position: absolute; top: -60px;"></a></div> +## Linear function + +The linear function module solves the equation of a line: + +$$ y = a x + b $$ + +Three parameters must be entered and the module calculates the missing parameter. + +<div style="position: relative"><a id="somme-et-produit-de-puissances" style="position: absolute; top: -60px;"></a></div> +## Sum and product of powers + +This module allows to write an equation summing powers in the form \(a x ^ n\) with \(a\), \(x\), and \(n\) of real numbers. + +In the case of a sum the equation solved by the module is written: + +$$ y = \sum_{i=1}^{k} a_i x_i ^ {n_i} $$ + +In the case of a product the equation solved by the module is written: + +$$ y = \prod_{i=1}^{k} a_i x_i ^ {n_i} $$ + +All parameters must be entered except the last one which is the value calculated in the equation. + +<div style="position: relative"><a id="fonction-trigonometrique" style="position: absolute; top: -60px;"></a></div> +## Trigonometric function + +This module allows to calculate the value of a trigonometric function or its inverse. + +The equation solved by this module is written: + +$$ y = f(x) $$ + +With \(f\), a trigonometric function and \(x\) an angle in degrees or radian. + +The "Operation" parameter allows to choose the operator among the available functions: cos, sin, tan, cosh, sinh and tanh. The "Unit" parameter is used to choose between degree and radian. diff --git a/docs/en/calculators/maths/solver.md b/docs/en/calculators/maths/solver.md new file mode 100644 index 0000000000000000000000000000000000000000..511fe93fe42b42d7eeeb270a3cf61707503d0a8f --- /dev/null +++ b/docs/en/calculators/maths/solver.md @@ -0,0 +1,34 @@ +# Multi-module solver + +The multi-module solver allows to calculate the value of an input parameter of a module depending on a calculation chain made up of several modules for which a target value for an output calculated parameter is sought. + +The diagram below shows the example of a calculation chain comprising two modules. The module `x` takes the parameter `Input x` and calculates the parameter `Output x`. The `y` module takes the `Input y` parameter and calculates the `Output y` parameter. The `Input y` parameter is linked to the `Output x` parameter. The problem to be solved by the solver is to get the value of the `Input x` to obtain a target value in `Output y`. + +<div class="mermaid"> + graph LR + Ix([Input x]) + x[Module x] + Ox([Output x / Input y]) + y[Module y] + Oy([Output y]) + Ix --> x + x --> Ox + Ox --> y + y --> Oy + Oy -..->|Input x for a target value Output y ?| Ix +</div> + +To solve this problem, the characteristics of the target parameter must be defined which include: + +- The module and its calculated parameter (here the module `y` calculating `Output y`); +- The target result which can be the parameter calculated by the module or one of its complementary results (Here `Output y`); +- The desired target value. + +It is also necessary to define the characteristics of the searched parameter: + +- The searched parameter is to be chosen from the list of input parameters of the modules of the session (Here the `Input x` parameter of the `x` module); +- An initial value of this parameter to start the calculation. + +The initial value chosen must be close enough to the solution because there is no guarantee that the function resulting from the sequence of calculations is continuous and monotonous. + +Examples of the use of the multi-module solver are given in the example sessions "Channel flow with structures" and "Critical slope of a channel". The notes of these sessions describe the sequence of the modules and the use of the solver. diff --git a/docs/en/calculators/pam/bloc_base_carree.png b/docs/en/calculators/pam/bloc_base_carree.png new file mode 100644 index 0000000000000000000000000000000000000000..8c5dee84cf9fe9e341b7da0440d31e46ccbf967e Binary files /dev/null and b/docs/en/calculators/pam/bloc_base_carree.png differ diff --git a/docs/en/calculators/pam/bloc_cylindre.png b/docs/en/calculators/pam/bloc_cylindre.png new file mode 100644 index 0000000000000000000000000000000000000000..5040485e061c7dd8e952f53ff772c35d1e32ac88 Binary files /dev/null and b/docs/en/calculators/pam/bloc_cylindre.png differ diff --git a/docs/en/calculators/pam/bloc_face_arrondie.png b/docs/en/calculators/pam/bloc_face_arrondie.png new file mode 100644 index 0000000000000000000000000000000000000000..5507f417f17a7fbe14a9b85cd7042e3b22106788 Binary files /dev/null and b/docs/en/calculators/pam/bloc_face_arrondie.png differ diff --git a/docs/en/calculators/pam/bloc_face_plate.png b/docs/en/calculators/pam/bloc_face_plate.png new file mode 100644 index 0000000000000000000000000000000000000000..a745e5f4337385b26d4c61c1bf0d486652e90a6c Binary files /dev/null and b/docs/en/calculators/pam/bloc_face_plate.png differ diff --git a/docs/en/calculators/pam/cassan2016_flow_chart_design_method.png b/docs/en/calculators/pam/cassan2016_flow_chart_design_method.png new file mode 100755 index 0000000000000000000000000000000000000000..7f3871efef4858e51a64b8eaafb5f78f86e4e76a Binary files /dev/null and b/docs/en/calculators/pam/cassan2016_flow_chart_design_method.png differ diff --git a/docs/en/calculators/pam/concentration.md b/docs/en/calculators/pam/concentration.md index 372c6b12d923c48e9535c4c775c6b6b063cd5e0f..347267607e0120e7f6c318a52c8625c8b00a26bb 100644 --- a/docs/en/calculators/pam/concentration.md +++ b/docs/en/calculators/pam/concentration.md @@ -1,6 +1,6 @@ # Blocks concentration -This module makes it possible to calculate the concentration of uniformly distributed blocks in a rock-ramp fish pass. +This module makes it possible to calculate the concentration of uniformly distributed blocks in a [rock-ramp fish pass](./macrorugo.md). It allows to calculate one of the following values: @@ -11,7 +11,25 @@ It allows to calculate one of the following values: ## Formula -The formula is detailed in the [rock-ramp fish pass](./macrorugo.md) documentation. + + +*Excerpt from Larinier et al., 2006[^1]* + +[^1]: Larinier, Michel, Courret, D., Gomes, P., 2006. Technical guide for the design of "natural" fish passes, GHAPPE RA Report. Compagnie Nationale du Rhône / Adour Garonne Water Agency. http://dx.doi.org/10.13140/RG.2.1.1834.8562 + +The spacing between the blocks is then calculated with the following formula: + +$$ax = ay = \frac{D}{\sqrt{C}}$$ + +With : + +- \(ax\) and \(ay\) respectively the longitudinal and lateral distances between the centres of the blocks (m); +- the width of the blocks facing the flow (m); +- the concentration of the blocks (-). + +The number of blocks \(N\) for a pass of width \(B\) is then obtained with the equation: + +$$ N = B / ax $$ ## Harmonization diff --git a/docs/en/calculators/pam/macrorugo.md b/docs/en/calculators/pam/macrorugo.md index bcd90f51ea3c4ba419f4cd6fe6b2b5766eec04ee..09b471f1bd41e84f13579299750cae2efebeb671 100644 --- a/docs/en/calculators/pam/macrorugo.md +++ b/docs/en/calculators/pam/macrorugo.md @@ -24,8 +24,4 @@ It requires the following values to be entered: - The background roughness (m); - The width of the blocks \(D\) facing the flow (m); - The useful height of the blocks \(k\) (m); -- The shape parameter of the blocks (1 for round, 2 for square) - -The spacing between the blocks is then calculated with the following formula: - -$$ax = ay = \frac{D}{\sqrt{C}}$$ +- The drag coefficient of a single block (1 for round, 2 for square). diff --git a/docs/en/calculators/pam/macrorugo_theorie.md b/docs/en/calculators/pam/macrorugo_theorie.md index 7ec96462ba5e55df91f77cf5ec3960f71b15339e..07d0eb1fcb39d1c431cc51fc0d6dbbcdcc69b738 100644 --- a/docs/en/calculators/pam/macrorugo_theorie.md +++ b/docs/en/calculators/pam/macrorugo_theorie.md @@ -1,10 +1,13 @@ # Calculation of the flow rate of a rock-ramp pass -The calculation of the flow rate of a rock-ramp pass corresponds to the implementation of the algorithm and the equations present in -*Cassan L, Laurens P. 2016. Design of emergent and submerged rock-ramp fish passes. Knowl. Manag. Aquat. Ecosyst. 417, 45, <https://doi.org/10.1051/kmae/2016032>*. +The calculation of the flow rate of a rock-ramp pass corresponds to the implementation of the algorithm and the equations present in Cassan et al. (2016)[^1]. ## General calculation principle + + +*After Cassan et al., 2016[^1]* + There are three possibilities: - the submerged case when \(h \ge 1.1 \times k\) @@ -55,7 +58,9 @@ with $$\beta = \sqrt{(k / \alpha_t)(C_d C k / D)/(1 - \sigma C)}$$ -with \(\sigma = 1\) for \(C_{d0} = 2\) (square blocks), \(\sigma = \pi/4\) otherwise (circular blocks) +with + +$$C_d = C_{x} f_{h_*}(h_*)$$ and \(\alpha_t\) obtained by solving the following equation: @@ -93,13 +98,11 @@ $$Q_{sup} = \frac{u_*}{\kappa} \left( (h - d) \left( \ln \left( \frac{h-d}{z_0} The calculation of the flow rate is done by successive iterations which consist in finding the flow rate value allowing to obtain the equality between the flow velocity \(V\) and the average velocity of the bed given by the equilibrium of the friction forces (bottom + drag) with gravity: -$$u_0 = \sqrt{\frac{2 g S D (1 - \sigma C)}{C_d C (1 + N)}}$$ +$$u_0 = \sqrt{\frac{2 g S D (1 - \sigma C)}{C_d f_F(F) C (1 + N)}}$$ with -$$C_d = C_{d0} (1 + 0.4 / h_*^2) f_F(F)$$ - -$$N = \frac{\alpha C_f}{C_d C h_*}$$ +$$N = \frac{\alpha C_f}{C_d f_F(F) C h_*}$$ with @@ -107,29 +110,77 @@ $$\alpha = 1 - (a_y / a_x \times C)$$ ## Formulas used -### Throughput speed *V* +### Bulk velocity *V* $$V = \frac{Q}{B \times h}$$ ### Average speed between blocks *V<sub>g</sub>* +From Eq. 1 Cassan et al (2016)[^1] and Eq. 1 Cassan et al (2014)[^2]: + $$V_g = \frac{V}{1 - \sqrt{(a_x/a_y)C}}$$ +<div style="position: relative"><a id="coefficient-de-trainee-dun-bloc-cd0" style="position: absolute; top: -60px;"></a></div> +### Drag coefficient of a single block *C<sub>d0</sub>* + +\(C_{d0}\) is the drag coefficient of a block considering a single block +infinitely high with \(F << 1\) (Cassan et al, 2014[^2]). + + +| Block shape | Cylinder | "Rounded face" shape | Square-based parallelepiped | "Flat face" shape | +|:------------|:--------:|:--------------------:|:-----------------------:|:--------------------:| +| |  |  |  |  | +| Value of \(C_{d0}\) | 1.0 | 1.2-1.3 | 2.0 | 2.2 | + +When establishing the statistical formulae for the 2006 technical guide (Larinier et al. 2006[^4]), the definition of the block shapes to be tested was based on the use of quarry blocks with neither completely round nor completely square faces. +The so-called "rounded face" shape was thus not completely cylindrical, but had a trapezoidal bottom face (seen in plan). +Similarly, the "flat face" shape was not square in cross-section, but also had a trapezoidal bottom face. +These differences in shape between the "rounded face" and a true cylinder on the one hand, and the "flat face" and a true parallelepiped with a square base on the other hand, result in slight differences between them in the shape coefficients \(C_{d0}\). + + +### Block shape coefficient *σ* + +Cassan et al. (2014)[^2], et Cassan et al. (2016)[^1] define \(\sigma\) as the ratio between the +block area in the \(x,y\) plane and \(D^2\). +For the cylindrical form of the blocks, \(\sigma\) is equal to \(\pi / 4\) and for a square block, \(\sigma = 1\). + +### Ratio between the average speed downstream of a block and the maximum speed *r* + +The values of (\r\) depends on the block shapes (Cassan et al., 2014[^2] et Tran et al. 2016 [^3]): + +- round : \(r_Q=1.1\) +- "rounded face" shape : \(r=1.2\) +- square-based parallelepiped : \(r=1.5\) +- "flat face" shape : \(r=1.6\) + +Cassiopée implements a formula depending on \(C{d0}\): + +$$ r = 0.4 C_{d0} + 0.7 $$ + ### Froude *F* $$F = \frac{V_g}{\sqrt{gh}}$$ ### Froude-related drag coefficient correction function *f<sub>F</sub>(F)* -If \(F < 1.3\) (Eq. 5, Cassan et al., 2016) +If \(F < 1\) (Eq. 19, Cassan et al., 2014[^2]): -$$f_F(F) = \mathrm{min} \left( \frac{0.4 C_{d0} + 0.7}{1- (F^2 / 4)}, \frac{1}{F^{\frac{2}{3}}} \right)^2$$ +$$f_F(F) = \min \left( \frac{r}{1- \frac{F_{g}^{2}}{4}}, \frac{1}{F^{\frac{2}{3}}} \right)^2$$ -else +otherwise \(f_F(F) = 1\) because a torrential flow upstream of the blocks is theoretically impossible because of the hydraulic jump caused by the downstream block. -$$f_F(F) = F^{\frac{-4}{3}}$$ +### Maximum speed *u<sub>max</sub>* -(The distinction is only numerical because \(1- (F^2 / 4)\) is not defined for \(F > 2\)) +According to equation 19 of Cassan et al, 2014[^2] : + +$$ u_{max} = V_g \sqrt{f_F(F)} $$ + +### Drag coefficient correction function linked to relative depth *f<sub>h\*</sub>(h<sub>\*</sub>)* + +The equation used in Cassiopeia differs slightly from equation 20 of Cassan et al. 2014[^2] and equation 6 of Cassan et al. 2016[^1]. +This formula is a fit to the experimental measurements on circular blocks used in Cassan et al. 2016[^1]: + +$$ f_{h_*}(h_*) = (1 + 1 / h_*^{2}) $$ ### Coefficient of friction of the bed *C<inf>f</inf>* @@ -180,3 +231,7 @@ $$C_f = \frac{2}{(5.1 \mathrm{log} (h/k_s)+6)^2}$$ - \(z\): vertical position (m) - \(z_0\): hydraulic roughness (m) - \(\tilde{z}\): dimensionless stand \(\tilde{z} = z / k\) + +[^1]: Cassan L, Laurens P. 2016. Design of emergent and submerged rock-ramp fish passes. Knowl. Manag. Aquat. Ecosyst., 417, 45 + +[^2]: Cassan, L., Tien, T.D., Courret, D., Laurens, P., Dartus, D., 2014. Hydraulic Resistance of Emergent Macroroughness at Large Froude Numbers: Design of Nature-Like Fishpasses. Journal of Hydraulic Engineering 140, 04014043. https://doi.org/10.1061/(ASCE)HY.1943-7900.0000910 diff --git a/docs/fr/calculators/hsl/cote_amont_aval.md b/docs/fr/calculators/hsl/cote_amont_aval.md new file mode 100644 index 0000000000000000000000000000000000000000..a3f27e286d49e694b45139f54f88e460e5de3b0b --- /dev/null +++ b/docs/fr/calculators/hsl/cote_amont_aval.md @@ -0,0 +1,12 @@ +# Cotes amont / aval d'un bief + +Ce module basé sur les équations du [module de calcul des courbes de remous](courbe_remous.md) permet de calculer : + +- La cote de l'eau à l'amont d'un bief d'une courbe de remous fluviale +- La cote de l'eau à l'aval d'un bief d'une courbe de remous torrentielle +- Le débit permettant de relié les cotes de l'eau amont et aval d'une courbe de remous fluviale ou torrentielle. + +Le régime choisi sur le type de ligne d'eau détermine si le calcul s'effectue de l'aval vers l'amont (régime fluvial) et de l'amont vers l'aval (régime torrentiel). + +Ce module de calcul est particulièrement utile pour calculer la ligne d'eau d'un enchaînement de ouvrages hydrauliques ou de biefs (Voir l'exemple type "Débit d'un chenal avec ouvrages"). + diff --git a/docs/fr/calculators/maths/operators.md b/docs/fr/calculators/maths/operators.md new file mode 100644 index 0000000000000000000000000000000000000000..2f1feeaa10125aebe144824d6b05e921b8fb2b18 --- /dev/null +++ b/docs/fr/calculators/maths/operators.md @@ -0,0 +1,37 @@ +# Opérateurs et fonctions trigonométriques + +Les opérateurs et fonctions mathématiques basiques pourvus par Cassiopée permettent avant tout de faciliter le lien entre les résultats d'un module de calcul et l'entrée dans autre dans le cas d'un enchaînement de calcul entre plusieurs modules. L'exemple fourni "Longueur de jet d'un déversoir" montre des utilisations du module "Fonction affine". + +## Fonction affine + +Le module fonction affine résout l'équation de droite : + +$$ y = a x + b $$ + +Trois paramètres doivent être saisis et le module calcule le paramètre manquant. + +## Somme et produit de puissances + +Ce module permet d'écrire une équation sommant des puissances sous la forme \(a x ^ n\) avec \(a\), \(x\), et \(n\) des réels. + +Dans le cas d'une somme l'équation résolue par le module s'écrit : + +$$ y = \sum_{i=1}^{k} a_i x_i ^ {n_i}$$ + +Dans le cas d'un produit l'équation résolue par le module s'écrit : + +$$ y = \prod_{i=1}^{k} a_i x_i ^ {n_i}$$ + +Tous les paramètres doivent être saisis à l'exception du dernier qui est la valeur calculée dans l'équation. + +## Fonction trigonométrique + +Ce module permet de calculer la valeur d'une fonction trigonométrique ou son inverse. + +L'équation résolue par ce module s'écrit : + +$$ y = f(x) $$ + +Avec \(f\), une fonction trigonométrique et \(x\) un angle en degré ou radian. + +Le paramètre "Opération" permet de choisir l'opérateur parmi les fonctions disponibles sont : cos, sin, tan, cosh, sinh et tanh. Le paramètre "Unité" permet de choisir entre degré et radian. diff --git a/docs/fr/calculators/maths/solver.md b/docs/fr/calculators/maths/solver.md new file mode 100644 index 0000000000000000000000000000000000000000..bdce114325ccce3d2ac50b7b13269300379564e0 --- /dev/null +++ b/docs/fr/calculators/maths/solver.md @@ -0,0 +1,34 @@ +# Solveur multimodule + +Le solveur multimodule permet de calculer la valeur d'un paramètre d'entrée d'un module dépendant d'une chaine de calcul constituée de plusieurs modules pour laquelle on cherche à atteindre une valeur cible pour un paramètre calculé en sortie. + +Le schéma ci-dessous reprend l'exemple d'une chaîne de calcul comprenant deux modules. Le module `x` prend entrée le paramètre `Input x` et calcule le paramètre `Output x`. Le module `y` prend entrée le paramètre `Input y` et calcule le paramètre `Output y`. Le paramètre `Input y` est lié au paramètre `Output x`. Le problème à résoudre par le solveur est d'obtenir la valeur de l'`Input x` permettant d'obtenir une valeur cible en `Output y`. + +<div class="mermaid"> + graph LR + Ix([Input x]) + x[Module x] + Ox([Output x / Input y]) + y[Module y] + Oy([Output y]) + Ix --> x + x --> Ox + Ox --> y + y --> Oy + Oy -..->|Input x pour une valeur cible Output y ?| Ix +</div> + +Pour résoudre ce problème, il faut définir les caractéristiques du paramètre cible qui comprennent : + +- Le module et son paramètre calculé (Ici le module `y` calculant `Output y`) ; +- Le résultat ciblé qui peut être le paramètre calculé par le module où un de ces résultats complémentaire (Ici `Output y`) ; +- La valeur cible désirée. + +Il faut aussi définir les caractéristiques du paramètre recherché : + +- Le paramètre recherché est à choisir parmi la liste des paramètres en entrée des modules de la session (Ici le paramètre `Input x` du module `x`) ; +- Une valeur initiale de ce paramètre pour démarrer le calcul. + +La valeur initiale choisie doit être assez proche de la solution car il n'y a aucune garantie que la fonction issue de l'enchaînement des calculs soit continue et monotone. + +Des exemples d'utilisation du solveur multimodule sont présents dans les sessions exemples "Débit d'un chenal avec ouvrages" et "Pente critique d'un canal". Les notes de ces sessions décrivent l'enchaînement des modules et l'utilisation du solveur. diff --git a/docs/fr/calculators/pam/bloc_base_carree.png b/docs/fr/calculators/pam/bloc_base_carree.png new file mode 100644 index 0000000000000000000000000000000000000000..8c5dee84cf9fe9e341b7da0440d31e46ccbf967e Binary files /dev/null and b/docs/fr/calculators/pam/bloc_base_carree.png differ diff --git a/docs/fr/calculators/pam/bloc_cylindre.png b/docs/fr/calculators/pam/bloc_cylindre.png new file mode 100644 index 0000000000000000000000000000000000000000..5040485e061c7dd8e952f53ff772c35d1e32ac88 Binary files /dev/null and b/docs/fr/calculators/pam/bloc_cylindre.png differ diff --git a/docs/fr/calculators/pam/bloc_face_arrondie.png b/docs/fr/calculators/pam/bloc_face_arrondie.png new file mode 100644 index 0000000000000000000000000000000000000000..5507f417f17a7fbe14a9b85cd7042e3b22106788 Binary files /dev/null and b/docs/fr/calculators/pam/bloc_face_arrondie.png differ diff --git a/docs/fr/calculators/pam/bloc_face_plate.png b/docs/fr/calculators/pam/bloc_face_plate.png new file mode 100644 index 0000000000000000000000000000000000000000..a745e5f4337385b26d4c61c1bf0d486652e90a6c Binary files /dev/null and b/docs/fr/calculators/pam/bloc_face_plate.png differ diff --git a/docs/fr/calculators/pam/cassan2016_flow_chart_design_method.png b/docs/fr/calculators/pam/cassan2016_flow_chart_design_method.png new file mode 100755 index 0000000000000000000000000000000000000000..7f3871efef4858e51a64b8eaafb5f78f86e4e76a Binary files /dev/null and b/docs/fr/calculators/pam/cassan2016_flow_chart_design_method.png differ diff --git a/docs/fr/calculators/pam/concentration.md b/docs/fr/calculators/pam/concentration.md index 2263ad332efe94848885b8cb8b2eae3a3f3306e8..5a8390bd2bd7e47385972a6495d8b8183da4d256 100644 --- a/docs/fr/calculators/pam/concentration.md +++ b/docs/fr/calculators/pam/concentration.md @@ -1,6 +1,6 @@ # Concentration de blocs -Ce module permet de calculer la concentration de blocs uniformément répartis dans une passe à macro-rugosités. +Ce module permet de calculer la concentration de blocs uniformément répartis dans une [passe à macro-rugosités](./macrorugo.md). L'outil permet de calculer l'une des valeurs suivantes : @@ -11,7 +11,26 @@ L'outil permet de calculer l'une des valeurs suivantes : ## Formule -La formule appliquée est détaillée dans la documentation de la [passe à macro-rugosités](./macrorugo.md). + + +*Extrait de Larinier et al., 2006[^1]* + +[^1]: Larinier, Michel, Courret, D., Gomes, P., 2006. Guide technique pour la conception des passes à poissons “naturelles,†Rapport GHAPPE RA. Compagnie Nationale du Rhône / Agence de l’Eau Adour Garonne. http://dx.doi.org/10.13140/RG.2.1.1834.8562 + + +L'espacement entre les blocs se calcule ensuite avec la formule suivante : + +$$ax = ay = \frac{D}{\sqrt{C}}$$ + +Avec : + +- \(ax\) et \(ay\) respectivement les distances longitudinales et latérales entre les centres des blocs (m) ; +- \(D\) la largeur des blocs face à l’écoulement (m) ; +- \(C\) la concentration des blocs (-). + +Le nombre de blocs \(N\) pour une passe de largeur \(B\) s'obtient alors avec l'équation : + +$$ N = B / ax $$ ## Harmonisation diff --git a/docs/fr/calculators/pam/macrorugo.md b/docs/fr/calculators/pam/macrorugo.md index 2a5992014e61fc9d8c69fdbe9f2c70d2f4bf3c5d..646df7cff0f188f39ed5c5937258f71f7987acb7 100644 --- a/docs/fr/calculators/pam/macrorugo.md +++ b/docs/fr/calculators/pam/macrorugo.md @@ -24,8 +24,5 @@ Il nécessite d'entrer les valeurs suivantes : - La rugosité de fond (m) ; - La largeur des blocs \(D\) face à l’écoulement (m) ; - La hauteur utile des blocs \(k\) (m) ; -- Le paramètre de forme des blocs (1 pour rond, 2 pour carré) +- Le coefficient de trainée d'un bloc (1 pour rond, 2 pour carré). -L'espacement entre les blocs se calcule ensuite avec la formule suivante : - -$$ax = ay = \frac{D}{\sqrt{C}}$$ diff --git a/docs/fr/calculators/pam/macrorugo_theorie.md b/docs/fr/calculators/pam/macrorugo_theorie.md index 5f7b641a2b3f3aea85ab96cdc9fbd6adfc262b47..07a067454861084e71747bb04700e22290b214cf 100644 --- a/docs/fr/calculators/pam/macrorugo_theorie.md +++ b/docs/fr/calculators/pam/macrorugo_theorie.md @@ -1,10 +1,13 @@ # Calcul du débit d'une passe à macro-rugosité -Le calcul du débit d'une passe à macro-rugosité correspond à l'implémentation de l'algorithme et des équations présentent dans -*Cassan L, Laurens P. 2016. Design of emergent and submerged rock-ramp fish passes. Knowl. Manag. Aquat. Ecosyst., 417, 45*. +Le calcul du débit d'une passe à macro-rugosité correspond à l'implémentation de l'algorithme et des équations présentent dans Cassan et al. (2016)[^1]. ## Principe général du calcul + + +*Extrait de Cassan et al., 2016[^1]* + Il existe trois cas : - le cas submergé quand \(h \ge 1.1 \times k\) @@ -51,11 +54,13 @@ avec $$u(\tilde{z}) = u_0 \sqrt{\beta \left( \frac{h}{k} -1 \right) \frac{\sinh(\beta \tilde{z})}{\cosh(\beta)} + 1}$$ -avec +avec \(\beta^2\) le ratio entre les forces trainée et de turbulence (Cassan et al., 2016, Eq. 8) : $$\beta = \sqrt{(k / \alpha_t)(C_d C k / D)/(1 - \sigma C)}$$ -avec \(\sigma = 1\) pour \(C_{d0} = 2\) (blocs carrés), \(\sigma = \pi/4\) sinon (blocs circulaires) +avec : + +$$C_d = C_{x} f_{h_*}(h_*)$$ et \(\alpha_t\) obtenu à partir de la résolution de l'équation suivante : @@ -93,13 +98,11 @@ $$Q_{sup} = \frac{u_*}{\kappa} \left( (h - d) \left( \ln \left( \frac{h-d}{z_0} Le calcul du débit se fait par itérations successives qui consistent à trouver la valeur de débit permettant d'obtenir l'égalité entre la vitesse débitante \(V\) et la vitesse moyenne du lit donnée par l'équilibre des forces de frottements (fond + traînée) avec la gravité : -$$u_0 = \sqrt{\frac{2 g S D (1 - \sigma C)}{C_d C (1 + N)}}$$ +$$u_0 = \sqrt{\frac{2 g S D (1 - \sigma C)}{C_d f_F(F) C (1 + N)}}$$ avec -$$C_d = C_{d0} (1 + 0.4 / h_*^2) f_F(F)$$ - -$$N = \frac{\alpha C_f}{C_d C h_*}$$ +$$N = \frac{\alpha C_f}{C_d f_F(F) C h_*}$$ avec @@ -113,23 +116,68 @@ $$V = \frac{Q}{B \times h}$$ ### Vitesse moyenne entre les blocs *V<sub>g</sub>* +Eq. 1 Cassan et al (2016)[^1] et Eq. 1 Cassan et al (2014)[^2]: + $$V_g = \frac{V}{1 - \sqrt{(a_x/a_y)C}}$$ +### Coefficient de trainée d'un bloc *C<sub>d0</sub>* + +\(C_{d0}\) est le coefficient de trainée théorique d'un bloc de hauteur infinie pour un Froude \(F << 1\) (Cassan et al, 2014[^2]). + +| Forme du bloc | Cylindre | Forme "face arrondie" | Parallélépipède à base carré | Forme "face plate" | +|:--------------|:--------:|:---------------------:|:----------------------------:|:------------------:| +| |  |  |  |  | +| Valeur de \(C_{d0}\) | 1.0 | 1.2-1.3 | 2.0 | 2.2 | + +Lors de l'établissement des formules statistiques du guide technique de 2006 (Larinier et al. 2006[^4]), la définition des formes de blocs à tester a été établie dans la perspective de l'utilisation de blocs de carrière à faces ni complètement rondes, ni complètement carrées. +La forme dite à « face arrondie » n'était ainsi pas complètement cylindrique, mais présentait une face aval trapézoïdale (vue en plan). +De même, la forme dite à « face plane » ne présentait pas une section carrée, mais également une face aval trapézoïdale. +Ces différences de forme entre la « face arrondie » et un véritable cylindre d’une part, et la « face plate » et un véritable parallélépipède à base carrée d’autre part, se traduisent par de légères différences entre celles-ci sur les coefficients de forme \(C_{d0}\). + +### Coefficient de forme de bloc *σ* + +Cassan et al. (2014)[^2], et Cassan et al. (2016)[^1] définit \(\sigma\) comme le ratio entre l'aire du bloc vu du dessus et \(D^2\). +On a donc \(\sigma = \pi / 4\) pour un bloc circulaire et \(\sigma = 1\) pour un bloc carré. + +### Rapport entre la vitesse moyenne à l'aval d'un bloc et la vitesse max *r* + +Les valeurs de \(r\) dépendent de la forme des blocs (Cassan et al., 2014[^2] et Tran et al. 2016 [^3]) : + +- rond : \(r=1.1\) +- face arrondie : \(r=1.2\) +- carré : \(r=1.5\) +- face plate : \(r=1.6\) + +Cassiopée propose une formule de calcul en fonction de \(C{d0}\) : + +$$ r = 0.4 C_{d0} + 0.7 $$ + ### Froude *F* $$F = \frac{V_g}{\sqrt{gh}}$$ -### Fonction de correction du coefficient de trainée liée au Froude *f<sub>F</sub>(F)* +### Fonction de correction du coefficient de trainée liée au Froude *f<sub>F</sub>(F,r)* + +Si \(F < 1\) (Eq. 19, Cassan et al., 2014[^2]) : + +$$f_F(F) = \min \left( \frac{r}{1- \frac{F_{g}^{2}}{4}}, \frac{1}{F^{\frac{2}{3}}} \right)^2$$ + +sinon \(f_F(F) = 1\) car un écoulement torrentiel à l'amont des blocs est théoriquement impossible à cause du ressaut hydraulic provoqué par le bloc aval. + +### Vitesse maximale *u<sub>max</sub>* -Si \(F < 1.3\) (Eq. 5, Cassan et al., 2016) +D'après l'équation 19 de Cassan et al., 2014[^2] : -$$f_F(F) = \mathrm{min} \left( \frac{0.4 C_{d0} + 0.7}{1- (F^2 / 4)}, \frac{1}{F^{\frac{2}{3}}} \right)^2$$ -sinon +$$ u_{max} = V_g \sqrt{f_F(F)} $$ -$$f_F(F) = F^{\frac{-4}{3}}$$ -(La distinction est uniquement numérique car \(1- (F^2 / 4)\) est non défini pour \(F > 2\)) +### Fonction de correction du coefficient de trainée lié à la profondeur relative *f<sub>h\*</sub>(h<sub>\*</sub>)* + +L'équation utilisée dans Cassiopée diffère légèrement de l'équation 20 de Cassan et al. 2014[^2] et l'équation 6 de Cassan et al. 2016[^1]. +Cette formule est un ajustement sur les mesures expérimentales sur les blocs circulaires utilisées dans de Cassan et al. 2016[^1] : + +$$ f_{h_*}(h_*) = (1 + 1 / h_*^{2}) $$ ### Coefficient de friction du lit *C<inf>f</inf>* @@ -180,3 +228,12 @@ $$C_f = \frac{2}{(5.1 \mathrm{log} (h/k_s)+6)^2}$$ - \(z\) : position verticale (m) - \(z_0\) : rugosité hydraulique (m) - \(\tilde{z}\) : position verticale adimensionnelle \(\tilde{z} = z / k\) + +[^1]: Cassan L, Laurens P. 2016. Design of emergent and submerged rock-ramp fish passes. Knowl. Manag. Aquat. Ecosyst., 417, 45. https://doi.org/10.1051/kmae/2016032 + +[^2]: Cassan, L., Tien, T.D., Courret, D., Laurens, P., Dartus, D., 2014. Hydraulic Resistance of Emergent Macroroughness at Large Froude Numbers: Design of Nature-Like Fishpasses. Journal of Hydraulic Engineering 140, 04014043. https://doi.org/10.1061/(ASCE)HY.1943-7900.0000910 + +[^3]: Tran, T.D., Chorda, J., Laurens, P., Cassan, L., 2016. Modelling nature-like fishway flow around unsubmerged obstacles using a 2D shallow water model. Environmental Fluid Mechanics 16, 413–428. https://doi.org/10.1007/s10652-015-9430-3 + +[^4]: Larinier, Michel, Courret, D., Gomes, P., 2006. Guide technique pour la conception des passes à poissons “naturelles,†Rapport GHAPPE RA. Compagnie Nationale du Rhône / Agence de l’Eau Adour Garonne. http://dx.doi.org/10.13140/RG.2.1.1834.8562 + diff --git a/electron/icon.png b/electron/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..67c7918826dd586f53aab4da6d7dbfe3ea96937a Binary files /dev/null and b/electron/icon.png differ diff --git a/mkdocs-en.yml b/mkdocs-en.yml index bc7a02c587bb949ecaffbaf8e009d28d4bb6f104..fc9fc321d57aafa3eb1600956bd9429846e3f524 100644 --- a/mkdocs-en.yml +++ b/mkdocs-en.yml @@ -13,6 +13,7 @@ extra_javascript: - ../javascripts/mathjax.config.js - ../javascripts/mathjax/tex-mml-chtml.js - ../javascripts/matomo-tracking.js + - ../javascripts/mermaid.min.js markdown_extensions: - mdx_math - footnotes @@ -31,6 +32,7 @@ nav: - Open-channel flow: - Uniform flow: calculators/hsl/regime_uniforme.md - calculators/hsl/courbe_remous.md + - calculators/hsl/cote_amont_aval.md - calculators/hsl/section_parametree.md - calculators/hsl/pente.md - calculators/hsl/types_sections.md @@ -85,6 +87,9 @@ nav: - Downstream migration: - Loss of charge, water grid: calculators/devalaison/grille.md - Jet impact: calculators/devalaison/jet.md + - Mathematical tools: + - calculators/maths/operators.md + - calculators/maths/solver.md - Numerical methods: - Runge-Kutta 4: methodes_numeriques/rk4.md - Euler explicit: methodes_numeriques/euler_explicite.md diff --git a/mkdocs-fr.yml b/mkdocs-fr.yml index dfe03ac28cb1179a2c6c52886d0ba574717447b3..e32b6f3f81073700ee9eb541958f1c32d6b9d2cf 100644 --- a/mkdocs-fr.yml +++ b/mkdocs-fr.yml @@ -13,6 +13,7 @@ extra_javascript: - ../javascripts/mathjax.config.js - ../javascripts/mathjax/tex-mml-chtml.js - ../javascripts/matomo-tracking.js + - ../javascripts/mermaid.min.js markdown_extensions: - mdx_math - footnotes @@ -31,6 +32,7 @@ nav: - Hydraulique à surface libre: - Régime uniforme: calculators/hsl/regime_uniforme.md - calculators/hsl/courbe_remous.md + - calculators/hsl/cote_amont_aval.md - calculators/hsl/section_parametree.md - calculators/hsl/pente.md - calculators/hsl/types_sections.md @@ -85,7 +87,10 @@ nav: - Dévalaison: - Perte de charge sur grille de prise d'eau: calculators/devalaison/grille.md - Impact de jet: calculators/devalaison/jet.md - - Méthodes numériques de résolution : + - Outils mathématiques: + - calculators/maths/operators.md + - calculators/maths/solver.md + - Méthodes numériques de résolution: - Runge-Kutta 4: methodes_numeriques/rk4.md - Euler explicite: methodes_numeriques/euler_explicite.md - Intégration de trapèzes: methodes_numeriques/integration_trapezes.md diff --git a/package-lock.json b/package-lock.json index 9014400063c21a5997717acfc2e45ab4975f3763..c8b39b42057aa73838ddb2e87837e9a02722b410 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "fr.irstea.cassiopee", - "version": "4.13.1", + "version": "4.14.2", "lockfileVersion": 1, "requires": true, "dependencies": { @@ -9726,12 +9726,14 @@ "minimist": { "version": "0.0.8", "bundled": true, - "dev": true + "dev": true, + "optional": true }, "minipass": { "version": "2.3.5", "bundled": true, "dev": true, + "optional": true, "requires": { "safe-buffer": "^5.1.2", "yallist": "^3.0.0" @@ -9750,6 +9752,7 @@ "version": "0.5.1", "bundled": true, "dev": true, + "optional": true, "requires": { "minimist": "0.0.8" } diff --git a/package.json b/package.json index 9e279be5fe0d0f3dd0c4c6a8c57de5e02cc80381..aaeba42b1ebb61bd252a0212ac0e62300f640e68 100644 --- a/package.json +++ b/package.json @@ -3,7 +3,7 @@ "displayName": "Cassiopée", "description": "Hydraulic calculators", "author": "Inrae", - "version": "4.13.1", + "version": "4.14.2", "main": "main.js", "homepage": "https://cassiopee.g-eau.fr", "license": "MIT", diff --git a/scripts/check-translations.js b/scripts/check-translations.js index 4143d689e4546a86d78ec4fdd665c8e9e915eb91..d15fc3de61a8f75638f4da577324616224ca659e 100644 --- a/scripts/check-translations.js +++ b/scripts/check-translations.js @@ -4,7 +4,7 @@ * 1) Reads Message enum in jalhyd, and for every message code in it, checks * that there is a translation in each nghyd's locale/*.json file (ie. for * every language) - * + * * 2) For every nghyd calculator, checks that the translated keys are the same * in all language files */ @@ -35,7 +35,7 @@ jm = jm.replace(/[ \t]+/g, ""); // remove line breaks jm = jm.replace(/\n/g, ""); -// split on ";" +// split on "," const messages = jm.split(","); // remove import on 1st line (wtf) @clodo diff --git a/scripts/mkdocs-postprocess.js b/scripts/mkdocs-postprocess.js index 0efd29ea8f57489fb8c0bc3f0cb1c3ccc940a2c9..0e929e5459efa55b5605bc89a7b0e42a92bf90fa 100644 --- a/scripts/mkdocs-postprocess.js +++ b/scripts/mkdocs-postprocess.js @@ -23,5 +23,7 @@ fs.copySync("docs/mathjax.config.js", destPath + "/mathjax.config.js"); fs.copySync("docs/matomo-tracking.js", destPath + "/matomo-tracking.js"); +fs.copySync("node_modules/mermaid/dist/mermaid.min.js", destPath + "/mermaid.min.js"); + // copy illustrated guide (not related to MkDocs, but still a part of the doc) fs.copySync("docs/cassiopee_notice_illustree_fr.pdf", "src/assets/docs/pdf/cassiopee_notice_illustree_fr.pdf"); diff --git a/src/app/calculators/bief/config.json b/src/app/calculators/bief/config.json index 399d8a25fea8439439f61dbdcc2e914864e37556..95f2ca549d1b5dc05e6a6b4a750015c93ceca321 100644 --- a/src/app/calculators/bief/config.json +++ b/src/app/calculators/bief/config.json @@ -70,6 +70,6 @@ "type": "options", "defaultNodeType": "SectionRectangle", "selectIds": [ "select_section", "select_regime" ], - "help": "hsl/bief.html" + "help": "hsl/cote_amont_aval.html" } ] \ No newline at end of file diff --git a/src/app/calculators/macrorugo/config.json b/src/app/calculators/macrorugo/config.json index 7f48b9643ff0c5c2fd1facde4ceb9df215f6e279..6cbce4d4541d9cb123908d3026a6026c0a061954 100644 --- a/src/app/calculators/macrorugo/config.json +++ b/src/app/calculators/macrorugo/config.json @@ -19,7 +19,10 @@ }, "Q", "Y", - "C" + { + "id": "C", + "help": "pam/concentration.html" + } ] }, { @@ -28,7 +31,10 @@ "fields": [ "PBD", "PBH", - "Cd0" + { + "id": "Cd0", + "help": "pam/macrorugo_theorie.html#coefficient-de-trainee-dun-bloc-cd0" + } ] }, { diff --git a/src/app/calculators/macrorugocompound/config.json b/src/app/calculators/macrorugocompound/config.json index 38afc88af9cf7002a82ac1c0780d4fb0764c4fe9..496a352629be9d42c5f98a37d5052df441743b16 100644 --- a/src/app/calculators/macrorugocompound/config.json +++ b/src/app/calculators/macrorugocompound/config.json @@ -16,7 +16,10 @@ "help": "hsl/pente.html" }, "Ks", - "C" + { + "id": "C", + "help": "pam/concentration.html" + } ] }, { @@ -25,7 +28,10 @@ "fields": [ "PBD", "PBH", - "Cd0" + { + "id": "Cd0", + "help": "pam/macrorugo_theorie.html#coefficient-de-trainee-dun-bloc-cd0" + } ] }, { diff --git a/src/app/calculators/solveur/config.json b/src/app/calculators/solveur/config.json index f04658c8dfe828fcbf5646c179c02facff532ea1..71a23177b300afc843f27e7c3eed29817fca5aeb 100644 --- a/src/app/calculators/solveur/config.json +++ b/src/app/calculators/solveur/config.json @@ -35,6 +35,6 @@ "selectIds": [ "select_target_result" ], "customSelectIds": [ "select_target_nub", "select_searched_param" ], "targettedResultSelectId": "select_target_result", - "_help": "solveur.html" + "help": "maths/solver.html" } ] \ No newline at end of file diff --git a/src/app/calculators/spp/config.json b/src/app/calculators/spp/config.json index 24318a4e529389851752cff9b7b81395d395ff3b..8506d7c73f7385b057410a5ee0a4b0b68abef2a8 100644 --- a/src/app/calculators/spp/config.json +++ b/src/app/calculators/spp/config.json @@ -32,6 +32,6 @@ { "type": "options", "selectIds": [ "select_sppoperation" ], - "_help": "util/spp.html" + "help": "maths/operators.html#somme-et-produit-de-puissances" } ] \ No newline at end of file diff --git a/src/app/calculators/trigo/config.json b/src/app/calculators/trigo/config.json index 34baffff0ef57f7f368d79949974fb50abd3a732..3b9f5d97a4b7eb5c65974554a57534edbe4f685d 100644 --- a/src/app/calculators/trigo/config.json +++ b/src/app/calculators/trigo/config.json @@ -25,6 +25,6 @@ { "type": "options", "selectIds": [ "select_operation", "select_unit" ], - "_help": "util/trigo.html" + "help": "maths/operators.html#fonction-trigonometrique" } ] \ No newline at end of file diff --git a/src/app/calculators/yaxb/config.json b/src/app/calculators/yaxb/config.json index b834b062710249d67b242882986cd82499a6905f..391232436897f377be3c2a08e0fcc5591ecf6961 100644 --- a/src/app/calculators/yaxb/config.json +++ b/src/app/calculators/yaxb/config.json @@ -6,6 +6,6 @@ }, { "type": "options", - "_help": "util/yaxb.html" + "help": "maths/operators.html#fonction-affine" } ] \ No newline at end of file diff --git a/src/app/components/generic-calculator/calculator.component.ts b/src/app/components/generic-calculator/calculator.component.ts index dc3d0900ac45821f76d76f09941e48008d3d8135..718ff08f5a873b395b553155be771e2e4b3d3a69 100644 --- a/src/app/components/generic-calculator/calculator.component.ts +++ b/src/app/components/generic-calculator/calculator.component.ts @@ -541,6 +541,7 @@ export class GenericCalculatorComponent implements OnInit, DoCheck, AfterViewChe * réception d'un événement de changement de valeur d'un input */ public onInputChange(event: any) { + // console.debug(`CalculatorComponent.onInputChange(${event?.symbol})`); this._formulaire.resetResults([], (event ? event.symbol : undefined)); } @@ -584,6 +585,7 @@ export class GenericCalculatorComponent implements OnInit, DoCheck, AfterViewChe /** réception d'un événement de clic sur un nœud du schéma de PréBarrage */ public onPBNodeSelected(event: any) { + // console.debug(`GenericCalculatorComponent.onPBNodeSelected(${event?.node?.uid})`); // show proper form (actually subform elements) or proper results, // depending on what was clicked (this._formulaire as FormulairePrebarrage).nodeSelected(event.node); diff --git a/src/app/components/macrorugo-compound-results/macrorugo-compound-results-table.component.ts b/src/app/components/macrorugo-compound-results/macrorugo-compound-results-table.component.ts index bf70492bf1b76785f94acbc9409326e0fada2b0e..d466e6869ae5a58c7a9563a9ebb297b1fb2c9834 100644 --- a/src/app/components/macrorugo-compound-results/macrorugo-compound-results-table.component.ts +++ b/src/app/components/macrorugo-compound-results/macrorugo-compound-results-table.component.ts @@ -102,8 +102,9 @@ export class MacrorugoCompoundResultsTableComponent extends ResultsComponentDire (Y !== undefined ? Y.toFixed(nDigits) : "-"), (res.Q !== undefined ? res.Q.toFixed(nDigits) : "-"), res.Vdeb.toFixed(nDigits), - res.Fr.toFixed(nDigits), - res.Vmax.toFixed(nDigits), + res.Fr?.toFixed(nDigits), + res.Vg?.toFixed(nDigits), + res.Vmax?.toFixed(nDigits), res.PV.toFixed(nDigits), this.intlService.localizeText("INFO_ENUM_MACRORUGOFLOWTYPE_" + res.ENUM_MacroRugoFlowType), res.xCenter.toFixed(nDigits) diff --git a/src/app/components/pb-schema/pb-schema.component.ts b/src/app/components/pb-schema/pb-schema.component.ts index 026f5e3ee862233e712ca42200a69f90e73b69dd..cdbe3fad0932b9ebd36b8fc3ad8c692c166d987a 100644 --- a/src/app/components/pb-schema/pb-schema.component.ts +++ b/src/app/components/pb-schema/pb-schema.component.ts @@ -298,6 +298,7 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni } private selectNode(item: any) { + // console.debug(`PbSchemaComponent.selectNode(${item?.id})`); // highlight clicked element this.clearHighlightedItems(); item.classList.add("node-highlighted"); @@ -449,9 +450,9 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni this.model.addChild(new PbCloison(undefined, this._selectedItem.bassinAval)); } } - this.unselect(); - this.refresh(); this.clearResults(); + this.unselect(); + this.refreshWithSelection(); this.calculatorComponent.showPBInputData = true; } @@ -476,10 +477,8 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni const wallCopy = new PbCloison(wall.bassinAmont, wall.bassinAval); wallCopy.loadObjectRepresentation(wall.objectRepresentation()); this.model.addChild(wallCopy); - this.unselect(); - this.refresh(); - this.selectNodeOnSchema(wallCopy); this.clearResults(); + this.refreshWithSelection(wallCopy.uid); this.calculatorComponent.showPBInputData = true; } @@ -491,10 +490,8 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni public onAddBasinClick() { const newBasin = new PbBassin(new PbBassinParams(20, 99)); this.model.addChild(newBasin); - this.unselect(); - this.refresh(); - this.selectNodeOnSchema(newBasin); this.clearResults(); + this.refreshWithSelection(newBasin.uid); this.calculatorComponent.showPBInputData = true; } @@ -526,10 +523,8 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni result.down === 0 ? undefined : this.model.bassins[result.down - 1] ); this.model.addChild(wall); - this.unselect(); - this.refresh(); - this.selectNodeOnSchema(wall); this.clearResults(); + this.refreshWithSelection(wall.uid); this.calculatorComponent.showPBInputData = true; } }); @@ -552,10 +547,8 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni this.model.moveBasin(this._selectedItem.uid, this.model.findBasinPosition(this._selectedItem.uid) - 1); } const basin = this._selectedItem; - this.unselect(); - this.refresh(); - this.selectNodeOnSchema(basin); this.clearResults(); + this.refreshWithSelection(this._selectedItem.uid); this.calculatorComponent.showPBInputData = true; } @@ -576,10 +569,8 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni this.model.moveBasin(this._selectedItem.uid, this.model.findBasinPosition(this._selectedItem.uid) + 1); } const basin = this._selectedItem; - this.unselect(); - this.refresh(); - this.selectNodeOnSchema(basin); this.clearResults(); + this.refreshWithSelection(this._selectedItem.uid); this.calculatorComponent.showPBInputData = true; } @@ -659,6 +650,7 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni } private unselect() { + // console.debug(`PbSchemaComponent.unselect()`); this._selectedItem = undefined; this.clearHighlightedItems(); this.nodeSelected.emit({}); // nothing selected @@ -667,7 +659,6 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni /** clear all PB form results whenever the basins / walls layout is changed */ private clearResults() { this.pbSchema.form.reset(); - this.refreshWithSelection(); } /** @@ -675,9 +666,9 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni * nub uid, else keeps previous selection */ private refreshWithSelection(uid ?: string) { + // console.debug(`PbSchemaComponent.refreshWithSelection(${uid})`); // remember previously selected node const selectedNodeUID = this._selectedItem?.uid; - this.unselect(); this.refresh(); // select a specific node on the schema if (uid !== undefined) { @@ -691,6 +682,7 @@ export class PbSchemaComponent implements AfterViewInit, AfterContentInit, OnIni // interface Observer public update(sender: IObservable, data: any) { + // console.debug(`PbSchemaComponent.update:`, data); if (sender instanceof PbSchema) { if (data.action === "refresh") { this.refreshWithSelection(data.value); diff --git a/src/app/components/results-chart/results-chart.component.ts b/src/app/components/results-chart/results-chart.component.ts index ff0cc3a2b92f145a45e64781e5b1778fb95ac904..a547f1097474621a175fdb755fb4b9dd7c2417c1 100644 --- a/src/app/components/results-chart/results-chart.component.ts +++ b/src/app/components/results-chart/results-chart.component.ts @@ -134,8 +134,6 @@ export class ResultsChartComponent extends ResultsComponentDirective implements public set chartX(X) { if (X !== this.chartX) { this._results.chartX = X; - this.forceRebuild(); - // refresh chart this.drawChart(); } } @@ -149,8 +147,6 @@ export class ResultsChartComponent extends ResultsComponentDirective implements public set chartY(Y) { if (Y !== this.chartY) { this._results.chartY = Y; - this.forceRebuild(); - // refresh chart this.drawChart(); } } @@ -186,6 +182,7 @@ export class ResultsChartComponent extends ResultsComponentDirective implements public drawChart() { if (this._results && this._results.hasPlottableResults()) { + this.forceRebuild(); switch (this._graphTypeComponent.selectedValue) { case ChartType.Histogram: this.graph_type = "bar"; diff --git a/src/app/formulaire/definition/form-definition.ts b/src/app/formulaire/definition/form-definition.ts index 54231bc1a3580b892b1b65c76fcbd18d1c5066a3..442a96ef680fe5e41f5bb28cc62b0ac3e64dc6a4 100644 --- a/src/app/formulaire/definition/form-definition.ts +++ b/src/app/formulaire/definition/form-definition.ts @@ -419,6 +419,7 @@ export abstract class FormulaireDefinition extends FormulaireNode implements Obs * links will be considered as dependencies @see jalhyd#98 */ public resetResults(visited: string[] = [], symbol?: string, forceResetAllDependencies: boolean = false) { + // console.debug(`FormulaireDefinition.resetResults(${visited})`); visited.push(this.currentNub.uid); // reset GUI results this.resetFormResults(); diff --git a/src/app/formulaire/definition/form-prebarrage.ts b/src/app/formulaire/definition/form-prebarrage.ts index 73b4df1c57061fdc65c6089d630d711ae8753a60..4400467c8535c95d25367bc66dca6ebf98e6db17 100644 --- a/src/app/formulaire/definition/form-prebarrage.ts +++ b/src/app/formulaire/definition/form-prebarrage.ts @@ -125,6 +125,7 @@ export class FormulairePrebarrage extends FormulaireFixedVar { * envoie un événement "nodeSelected" (on a cliqué sur un nœud) */ public nodeSelected(node: PbBassin | PbCloison) { + // console.debug(`FormulairePrebarrage.NodeSelected(${node?.uid})`); // did something change, or we just clicked again on the node that was already selected ? if (this._selectedItem !== node) { // store for results formatting @@ -199,6 +200,7 @@ export class FormulairePrebarrage extends FormulaireFixedVar { // interface Observer public update(sender: IObservable, data: any) { + // console.debug("FormulairePrebarrage.update:", data); super.update(sender, data); if (sender instanceof FormulairePbCloison) { if (data.action === "updateBasin") { @@ -300,6 +302,7 @@ export class FormulairePrebarrage extends FormulaireFixedVar { } public resetResults() { + // console.debug("FormulairePrebarrage.resetResults()"); const hasToRedraw = (this._currentNub.result !== undefined); super.resetResults(); // reset all children nubs diff --git a/src/app/formulaire/elements/pb-schema.ts b/src/app/formulaire/elements/pb-schema.ts index f9c5afae59c9c0c4d1be46bde74f8d073a04933d..7b0df1a73c89994b92b523a48db166286fc2f9e5 100644 --- a/src/app/formulaire/elements/pb-schema.ts +++ b/src/app/formulaire/elements/pb-schema.ts @@ -38,6 +38,7 @@ export class PbSchema extends FormulaireElement { /** Asks PbSchemaComponent to redraw the schema */ public refresh(nodeUidToSelect?: string) { + // console.debug(`PbSchema.refresh(${nodeUidToSelect})`); this.notifyObservers({ action: "refresh", value: nodeUidToSelect diff --git a/src/app/results/macrorugo-compound-results.ts b/src/app/results/macrorugo-compound-results.ts index 74e776f72846483d97857ed9f123cb6714dbb5eb..a8274fad9846330d93dab23830b33ed3b55bd15f 100644 --- a/src/app/results/macrorugo-compound-results.ts +++ b/src/app/results/macrorugo-compound-results.ts @@ -29,6 +29,7 @@ export class MacrorugoCompoundResults extends MultiDimensionResults implements P "Q", "Vdeb", "Fr", + "Vg", "Vmax", "PV", "ENUM_MacroRugoFlowType", diff --git a/src/app/services/formulaire.service.ts b/src/app/services/formulaire.service.ts index 9a1abbe1ab16e5bbec7b2d62599a1bd05d7dad45..5d3910bbfc888c573f59c31074b96fc5279095a9 100644 --- a/src/app/services/formulaire.service.ts +++ b/src/app/services/formulaire.service.ts @@ -232,6 +232,13 @@ export class FormulaireService extends Observable { return s; } + /** + * From https://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex + */ + private escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string + } + /** * Checks if the given calculator name (tab title) is already used by any existing * form; if so, adds a number after it @@ -249,7 +256,7 @@ export class FormulaireService extends Observable { } // browse session calculators - const re2 = new RegExp("^" + baseName + "( (\\d+))?$"); + const re2 = new RegExp("^" + this.escapeRegExp(baseName) + "( (\\d+))?$"); for (const f of this.formulaires) { const matches2 = re2.exec(f.calculatorName); if (matches2) { @@ -815,6 +822,7 @@ export class FormulaireService extends Observable { if (form) { const hadResults = form.hasResults; // form might not have a result, but still have another form depending on it ! + // console.debug(`FormulaireService.resetAllDependingFormsResults(form->${dn.uid})`); form.resetResults(visited); if (hadResults) { if (notify) { diff --git a/src/locale/messages.en.json b/src/locale/messages.en.json index 009ebec322f54dcaf14a4642347e1287a40cab99..94d4434ca1cfaee8579877855884f47302b02989 100755 --- a/src/locale/messages.en.json +++ b/src/locale/messages.en.json @@ -114,7 +114,7 @@ "INFO_COURBEREMOUS_DESCRIPTION": "open channel regime flow subcritical supercritical hydraulic jump", "INFO_COURBEREMOUS_TITRE_COURT": "Backwater", "INFO_COURBEREMOUS_TITRE": "Backwater curves", - "INFO_DEVER_DESCRIPTION": "slot threshold approach speed head hydraulic", + "INFO_DEVER_DESCRIPTION": "slot threshold approach velocity head hydraulic", "INFO_DEVER_TITRE_COURT": "Free weir", "INFO_DEVER_TITRE": "Free flow weir stage-discharge laws", "INFO_DIAGRAM_SOLVEUR_FINDS": "finds", @@ -264,7 +264,7 @@ "INFO_LIB_ELEVATIONS": "Every elevation", "INFO_LIB_VOLUMES": "Every volume", "INFO_LIB_FLOWS": "Every flow", - "INFO_LIB_SPEEDS": "Every speed", + "INFO_LIB_SPEEDS": "Every velocity", "INFO_LIB_DIAMETERS": "Every diameter", "INFO_LIB_ABSCISSE_CLOISON": "Wall abscissa", "INFO_LIB_ALPHA": "Alpha coefficient", @@ -360,10 +360,11 @@ "INFO_LIB_TAU0": "Tractive force", "INFO_LIB_TOR": "Supercritical water line", "INFO_LIB_TOTAL": "Total", - "INFO_LIB_V_GUIDETECH": "Technical guide speed", - "INFO_LIB_V": "Average speed", - "INFO_LIB_VDEB": "Conveyance speed", - "INFO_LIB_VMAX": "Maximal speed", + "INFO_LIB_V_GUIDETECH": "Technical guide velocity", + "INFO_LIB_V": "Average velocity", + "INFO_LIB_VDEB": "Conveyance velocity", + "INFO_LIB_VMAX": "Maximal velocity", + "INFO_LIB_VG": "Averaged velocity between blocks", "INFO_LIB_W": "Gate opening", "INFO_LIB_X": "Value for searched parameter", "INFO_LIB_YC": "Critical depth", @@ -670,14 +671,15 @@ "WARNING_VANLEV_ZDV_SUP_MAX": "Regulated weir: maximum sill elevation reached", "WARNING_GRILLE_ALPHA_GREATER_THAN_45": "Recommendation for fish guiding: α ≤ 45°", "WARNING_GRILLE_BETA_GREATER_THAN_26": "Recommendation for fish guiding: β ≤ 26°", - "WARNING_GRILLE_VN_GREATER_THAN_05": "Recommendation to prevent fish getting stuck on grid plan (physical barrier) or prematurely passing through the grid (behavioural barrier): VN ≤ 0.5 m/s.<br>Above average value calculated here, refer to the recommendations taken from experimental caracterisation of effective speed values.", + "WARNING_GRILLE_VN_GREATER_THAN_05": "Recommendation to prevent fish getting stuck on grid plan (physical barrier) or prematurely passing through the grid (behavioural barrier): VN ≤ 0.5 m/s.<br>Above average value calculated here, refer to the recommendations taken from experimental caracterisation of effective velocity values.", "WARNING_GRILLE_O_LOWER_THAN_OB": "Total obstruction (entered) is lower than obstruction due to bars only (calculated)", - "WARNING_LECHAPT_CALMON_SPEED_OUTSIDE_04_2": "This formula is discouraged for a speed that is not between 0.4 and 2 m/s", + "WARNING_LECHAPT_CALMON_SPEED_OUTSIDE_04_2": "This formula is discouraged for a velocity that is not between 0.4 and 2 m/s", "WARNING_UPSTREAM_BOTTOM_HIGHER_THAN_WATER": "Upstream water elevation is lower or equal to bottom elevation", "WARNING_DOWNSTREAM_BOTTOM_HIGHER_THAN_WATER": "Downstream water elevation is lower or equal to bottom elevation", "WARNING_NEGATIVE_SILL": "Sill should be positive", "WARNING_RAMP_WIDTH_LOWER_THAN_PATTERN_WIDTH": "Ramp width should contain at least one block (%pattern%m)", "WARNING_RAMP_WIDTH_NOT_MULTIPLE_OF_HALF_PATTERN_WIDTH": "Ramp width should be a multiple of half the block width (%halfPattern%m). Nearest values are %lower% and %higher%", + "WARNING_MACRORUGO_CONCENTRATION_OUT_OF_BOUNDS": "The calculation formula has not been experimentally validated for block concentrations not between 8% and 20%", "WARNING_YN_SECTION_PENTE_NEG_NULLE_HNORMALE_INF": "Normal depth: slope is negative or zero, normal depth is infinite", "WARNING_YN_SECTION_NON_CONVERGENCE_NEWTON_HNORMALE": "Normal depth: non convergence of the calculation (Newton's method)", "WARNING_SECTION_OVERFLOW": "Overflow: water elevation exceeds embankment elevation", @@ -705,12 +707,14 @@ "ERROR_VERIF_ERRORS_IN_PASS": "Pass to verify contains errors", "ERROR_VERIF_VARYING_ERRORS_IN_PASS": "Pass to verify contains error at iteration %i%", "ERROR_VERIF_MISSING_CRITERION": "Criterion %var_criterion% must be defined", - "ERROR_VERIF_MR_VMAX": "Maximum speed %V% too high (maximum: %maxV%)", + "ERROR_VERIF_MR_VMAX": "Maximum velocity %V% too high (maximum: %maxV%)", + "ERROR_VERIF_MR_SUBMERGED": "Submerged blocks", "ERROR_VERIF_MR_PVMAX": "Dissipated power %PV% too high (maximum: %maxPV%)", "ERROR_VERIF_MR_YMIN": "Water level %Y% too low (minimum: %minY%)", "ERROR_VERIF_MRC_AT_LEAST_ONE_APRON": "None of the aprons is crossable", "ERROR_VERIF_MRC_CROSSABLE_WIDTH": "Crossable width %width% m is lower than the width of a block pattern %patternWidth% m", - "WARNING_VERIF_MRC_VMAX_APRON_N": "Maximum speed %V% too high (maximum: %maxV%)", + "WARNING_VERIF_MRC_VMAX_APRON_N": "Maximum velocity %V% too high (maximum: %maxV%)", + "WARNING_VERIF_MRC_SUBMERGED_APRON_N": "Submerged blocks", "WARNING_VERIF_MRC_YMIN_APRON_N": "Water level %Y% too low (minimum: %minY%)", "INFO_VERIF_MRC_CROSSABLE_WIDTH": "Maximum crossable width is %width% m", "ERROR_VERIF_NO_PRESET": "This species group is not compatible with this pass type", diff --git a/src/locale/messages.fr.json b/src/locale/messages.fr.json index b018c642dc4817658b78003cdeaa065e5116aba7..6e487527a3f6a9a6e897c53855ef36410d77c039 100755 --- a/src/locale/messages.fr.json +++ b/src/locale/messages.fr.json @@ -365,6 +365,7 @@ "INFO_LIB_V": "Vitesse moyenne", "INFO_LIB_VDEB": "Vitesse débitante", "INFO_LIB_VMAX": "Vitesse maximale", + "INFO_LIB_VG": "Vitesse moyenne entre les blocs", "INFO_LIB_W": "Ouverture de vanne", "INFO_LIB_X": "Valeur du paramètre recherché", "INFO_LIB_YC": "Tirant d'eau critique", @@ -679,6 +680,7 @@ "WARNING_NEGATIVE_SILL": "La pelle du seuil devrait être positive", "WARNING_RAMP_WIDTH_LOWER_THAN_PATTERN_WIDTH": "La largeur de la rampe devrait comprendre au moins un motif de plot (%pattern%m)", "WARNING_RAMP_WIDTH_NOT_MULTIPLE_OF_HALF_PATTERN_WIDTH": "La largeur de la rampe devrait être un multiple d'un demi motif (%halfPattern%m). Les valeurs voisines sont %lower% et %higher%", + "WARNING_MACRORUGO_CONCENTRATION_OUT_OF_BOUNDS": "La formule de calcul n'est pas validée expérimentalement pour des concentrations de blocs non compris entre 8% et 20%", "WARNING_YN_SECTION_PENTE_NEG_NULLE_HNORMALE_INF": "Hauteur normale : pente négative ou nulle, hauteur normale infinie", "WARNING_YN_SECTION_NON_CONVERGENCE_NEWTON_HNORMALE": "Hauteur normale : non convergence du calcul (méthode de Newton)", "WARNING_SECTION_OVERFLOW": "Débordement : la cote de l'eau dépasse la cote de berge", @@ -707,11 +709,13 @@ "ERROR_VERIF_VARYING_ERRORS_IN_PASS": "La passe à vérifier contient des erreurs à l'itération %i%", "ERROR_VERIF_MISSING_CRITERION": "Le critère %var_criterion% doit être défini", "ERROR_VERIF_MR_VMAX": "Vitesse maximale %V% trop élevée (maximum : %maxV%)", + "ERROR_VERIF_MR_SUBMERGED": "Blocs submergés", "ERROR_VERIF_MR_PVMAX": "Puissance dissipée %PV% trop élevée (maximum : %maxPV%)", "ERROR_VERIF_MR_YMIN": "Tirant d'eau %Y% insuffisant (minimum : %minY%)", "ERROR_VERIF_MRC_AT_LEAST_ONE_APRON": "Aucun des radiers n'est franchissable", "ERROR_VERIF_MRC_CROSSABLE_WIDTH": "La largeur franchissable %width% m est inférieure à la largeur d'un motif de blocs %patternWidth% m", "WARNING_VERIF_MRC_VMAX_APRON_N": "Vitesse maximale %V% trop élevée (maximum : %maxV%)", + "WARNING_VERIF_MRC_SUBMERGED_APRON_N": "Blocs submergés", "WARNING_VERIF_MRC_YMIN_APRON_N": "Tirant d'eau %Y% insuffisant (minimum : %minY%)", "INFO_VERIF_MRC_CROSSABLE_WIDTH": "La largeur franchissable maximale est %width% m", "ERROR_VERIF_NO_PRESET": "Ce groupe d'espèces n'est pas compatible avec ce type de passe",