Ajout de la calculette "Dimensions d'une passe à bassins"

README.md

@@ -36,3 +36,144 @@ and then :
 ### To flag suspicious language usage
 
 `npm run lint`
+
+
+# Procédure d'ajout d'une calculette #
+
+##JaLHyd
+
+
+* Créer la classe de paramétrage
+
+	* exemple :
+
+			export class TotoParams extends ParamsEquation {
+				[key: string]: any; // pour pouvoir faire this['methode]();
+
+				/** Longueur L */
+				private _L: ParamDefinition;
+
+				/** Largeur W */
+				private _W: ParamDefinition;
+
+				/** Tugudu A */
+				private _A: ParamDefinition;
+
+				constructor(rL: number, rW: number, rA:number=undefined) {
+					super();
+					this._L = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'L', ParamDomainValue.POS, rL);
+					this._W = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'W', ParamDomainValue.POS, rW);
+					this._A = new ParamDefinition(ComputeNodeType.LechaptCalmon, 'A', ParamDomainValue.POS, rA);
+
+					this.addParamDefinition(this._L);
+					this.addParamDefinition(this._W);
+					this.addParamDefinition(this._A);
+				}
+
+				get L() {
+					return this._L;
+				}
+
+				get W() {
+					return this._W;
+				}
+
+				get A() {
+					return this._A;
+				}
+			}
+
+
+* Créer la classe de calcul
+
+	* exemple :
+
+			export class Toto extends Nub {
+				constructor(prms: TotoParams, dbg: boolean = false) {
+					super(prms, dbg);
+				}
+
+				/**
+				* paramètres castés au bon type
+				*/
+				get prms(): TotoParams {
+					return <TotoParams>this._prms;
+				}
+
+				/**
+				* paramétrage de la calculabilité des paramètres
+				*/
+				protected setParametersCalculability() {
+					this.prms.L.calculability = ParamCalculability.DICHO;
+					this.prms.W.calculability = ParamCalculability.DICHO;
+					this.prms.A.calculability = ParamCalculability.EQUATION;
+				}
+
+				Equation(sVarCalc: string): Result {
+					let v: number;
+
+					switch (sVarCalc) {
+						case "A":
+							v = this.prms.L.v / this.prms.W.v;
+							break;
+
+						default:
+							throw "Toto.Equation() : invalid variable name " + sVarCalc;
+					}
+
+					return new Result(v);
+				}
+			}
+
+
+* Créer les tests unitaires correspondants
+
+
+* Ajouter une valeur à l'enum _ComputeNodeType_ pour identifier le type de noeud de calcul (par ex _MaCalculette_).
+
+
+* Compléter la méthode _ComputeNodeParameters.getComputeNodeParameters()_.
+
+	Si plusieurs valeurs de _ComputeNodeType_ font référence à la même calculette, n'ajouter les _case_ que pour les valeurs "concrètes". Par exemple, pour les sections paramétrées, il n'y a pas de _case_ pour la valeur _SectionParametree_ qui est générique.
+
+
+##ngHyd
+
+
+* Créer les fichier de configuration de la calculette
+	- dans _src/app/calculators_ : créer un répertoire (par ex _ma-calculette_)
+
+	- dans _src/app/calculators/ma-calculette_ :
+	
+		Créer _ma-calculette.config.json_ sur le modèle des autres.
+		Les ids utilisés doivent correspondre au symbole fourni à classe _ParamDefinition_ (2ème paramètre du constructeur)
+
+		Ne pas oublier de spécifier :
+			- le type de noeud de la calculette (dans l'objet comportant _"id":"options"_) avec le champ _"nodeType": "MaCalculette"_
+			- éventuellement le type de noeud de fieldset particuliers (objets comportant _"id":"fs_XXX"_) avec le champ _"nodeType": "MaCalculetteBleue"_
+
+	- dans _src/app/calculators/ma-calculette_ :
+	
+		Créer les fichiers d'internationalisation (_ma-calculette.&lt;langue&gt;.json_). Il doivent reprendre tous les ids utilisés dans le fichier de configuration et fournir leur traduction.
+
+* Ajouter une valeur à l'enum _CalculatorType_ pour identifier la calculette.
+
+	On ne reprend pas directement l'enum _ComputeNodeType_ car celui ci sert à distinguer les variantes au sein d'une même calculette (par exemple les différentes sections paramétrées).
+
+* Composant CalculatorListComponent : ajouter une ligne au constructeur pour créer une nouvelle entrée dans la liste des calculettes disponibles.
+
+* Classe _FormulaireService_, méthode _getConfigPathPrefix()_ : compléter le _switch_ pour fournir le préfixe des fichiers de configuration/internationalisation.
+
+* Classe ParamService : compléter le constructeur.
+
+* S'il existe plusieurs valeurs de _ComputeNodeType_ pour la même calculette, compléter les méthodes
+	- _FormulaireDefinition.getComputeNodeTypeFromSection()_.
+	- _ParamService.hasParameter()_
+
+* _src/locale/error_messages.&lt;langue&gt;.json_ :
+	Ajouter un champ pour le titre de la calculette. Par exemple :
+		 _"INFO_MACALC_TITRE": "Ma calculette"_
+	Compléter la méthode _GenericCalculatorComponent .uitextTitre()_ avec cette valeur et la valeur de l'enum _CalculatorType_ correspondante.
+
+* Classe FormulaireDefinition : compléter la méthode _doCompute()_.
+	En particulier, adapter les méthodes _getNubAndParameters()_ ou _getSectionNubAndParameters()_ (récupération des valeurs saisies dans l'interface).
\ No newline at end of file

src/app/calculators/generic/calculator.component.ts

@@ -68,6 +68,9 @@ export class GenericCalculatorComponent implements OnInit, DoCheck, OnDestroy, O
             case CalculatorType.CourbeRemous:
                 return this.intlService.localizeText("INFO_REMOUS_TITRE")
 
+            case CalculatorType.PabDimensions:
+                return this.intlService.localizeText("INFO_PABDIM_TITRE")
+
             default:
                 return "Invalid calculator type " + this._formulaire.calculatorType;
         }

src/app/calculators/pab-dimensions/pab-dimensions.config.json

+[
+    {
+        "id": "fs_dimensions",
+        "option": "cal",
+        "fields": [
+            {
+                "type": "input",
+                "id": "L",
+                "unit": "m",
+                "value": 2
+            },
+            {
+                "type": "input",
+                "id": "W",
+                "unit": "m",
+                "value": 1
+            },
+            {
+                "type": "input",
+                "id": "Y",
+                "unit": "m",
+                "value": 0.5
+            },
+            {
+                "type": "input",
+                "id": "V",
+                "unit": "m³",
+                "value": 1
+            }
+        ]
+    },
+    {
+        "id": "fs_param_calc",
+        "option": "fix",
+        "fields": [
+            {
+                "type": "input",
+                "id": "Pr",
+                "unit": "m",
+                "value": 0.0001
+            }
+        ]
+    },
+    {
+        "id": "options",
+        "idCal": "V",
+        "nodeType": "PabDimensions"
+    }
+]
\ No newline at end of file

src/app/calculators/pab-dimensions/pab-dimensions.en.json

+{
+    "fs_dimensions": "Basin dimensions",
+    "L": "Length",
+    "W": "Width",
+    "Y": "Draft'eau",
+    "V": "Volume",
+    "Pr": "Calculation accuracy",
+    "fs_param_calc": "Calculation parameters"
+}
\ No newline at end of file

src/app/calculators/pab-dimensions/pab-dimensions.fr.json

+{
+    "fs_dimensions": "Dimensions du bassin",
+    "L": "Longueur",
+    "W": "Largeur",
+    "Y": "Tirant d'eau",
+    "V": "Volume",
+    "Pr": "Précision de calcul",
+    "fs_param_calc": "Paramètres de calcul"
+}
\ No newline at end of file

src/app/components/calculator-list/calculator-list.component.ts

@@ -25,6 +25,7 @@ export class CalculatorListComponent {
         this._items.push(new ListElement("Regime uniforme", CalculatorType.RegimeUniforme));
         this._items.push(new ListElement("Sections paramétrées", CalculatorType.SectionParametree));
         this._items.push(new ListElement("Courbes remous", CalculatorType.CourbeRemous));
+        this._items.push(new ListElement("Dimensions d'une passe à bassin", CalculatorType.PabDimensions));
     }
 
     private create(t: CalculatorType) {

src/app/formulaire/formulaire-definition.ts

 import { ComputeNodeType, ParamsEquation, Nub, acSection, RegimeUniforme, MethodeResolution, CourbeRemousParams, CourbeRemous } from "jalhyd";
 import { ParamsSectionRectang, cSnRectang, ParamsSectionCirc, cSnCirc, ParamsSectionPuiss, cSnPuiss, Result } from "jalhyd";
 import { ConduiteDistrib, ConduiteDistribParams, LechaptCalmon, LechaptCalmonParams, ParamsSectionTrapez, cSnTrapez } from "jalhyd";
+import { PabDimension, PabDimensionParams } from "jalhyd";
 
 import { ParamService } from "../services/param/param.service";
 import { InternationalisationService } from "../services/internationalisation/internationalisation.service";
@@ -24,7 +25,8 @@ import { StringMap } from "../stringmap";
 
 
 export enum CalculatorType {
-    ConduiteDistributrice, LechaptCalmon, SectionParametree, RegimeUniforme, CourbeRemous
+    ConduiteDistributrice, LechaptCalmon, SectionParametree, RegimeUniforme, CourbeRemous,
+    PabDimensions, // passe à bassin rectangulaire
 }
 
 
@@ -917,6 +919,17 @@ export class FormulaireDefinition {
                     return [nub, prms];
                 }
 
+            case CalculatorType.PabDimensions:
+                {
+                    let L: number = this.getParameterValue("L"); // longueur L
+                    let W: number = this.getParameterValue("W"); // largeur W
+                    let Y: number = this.getParameterValue("Y"); // tirant d'eau Y
+                    let V: number = this.getParameterValue("V"); // volume V
+                    let prms = new PabDimensionParams(L, W, Y, V);
+                    let nub = new PabDimension(prms); // pour initialiser la calculabilité des paramètres
+                    return [nub, prms];
+                }
+
             default:
                 throw "FormulaireService.getNubAndParameters() : valeur de CalculatorType " + this.calculatorType + " non implémentée"
         }

src/app/services/formulaire/formulaire.service.ts

@@ -172,6 +172,9 @@ export class FormulaireService extends Observable {
             case CalculatorType.CourbeRemous:
                 return "app/calculators/remous/remous.";
 
+            case CalculatorType.PabDimensions:
+                return "app/calculators/pab-dimensions/pab-dimensions.";
+
             default:
                 throw "FormulaireService.getConfigPathPrefix() : valeur de CalculatorType " + ct + " non implémentée"
         }

src/app/services/param/param.service.ts

@@ -23,6 +23,7 @@ export class ParamService {
         this.addParameters(ComputeNodeType.CourbeRemousPuissance);
         this.addParameters(ComputeNodeType.CourbeRemousRectangle);
         this.addParameters(ComputeNodeType.CourbeRemousTrapeze);
+        this.addParameters(ComputeNodeType.PabDimensions);
 
         // précision de calcul
 
@@ -47,6 +48,10 @@ export class ParamService {
         p.calculability = ParamCalculability.FREE;
         this.addParameter(p);
 
+        p = new ParamDefinition(ComputeNodeType.PabDimensions, 'Pr', d);
+        p.calculability = ParamCalculability.FREE;
+        this.addParameter(p);
+
         // logObject(this._params);
     }
 

src/locale/error_messages.en.json

@@ -68,5 +68,6 @@
     "INFO_REMOUSRESULTS_FOND": "Bottom",
     "INFO_REMOUSRESULTS_BERGE": "Embankment",
     "INFO_REMOUSRESULTS_TIRANTNORMAL": "Normal water level",
-    "INFO_REMOUSRESULTS_TIRANTCRITIQUE": "Critical water level"
+    "INFO_REMOUSRESULTS_TIRANTCRITIQUE": "Critical water level",
+    "INFO_PABDIM_TITRE": "Passe à bassin : dimensions"
 }
\ No newline at end of file

src/locale/error_messages.fr.json

@@ -74,5 +74,6 @@
     "INFO_REMOUSRESULTS_FOND": "Fond",
     "INFO_REMOUSRESULTS_BERGE": "Berge",
     "INFO_REMOUSRESULTS_TIRANTNORMAL": "Tirant d'eau normal",
-    "INFO_REMOUSRESULTS_TIRANTCRITIQUE": "Tirant d'eau critique"
+    "INFO_REMOUSRESULTS_TIRANTCRITIQUE": "Tirant d'eau critique",
+    "INFO_PABDIM_TITRE": "Passe à bassin : dimensions"
 }
\ No newline at end of file