ngHyd : Angular Component Library For Hydraulics using JaLHyd library

All the things to know for developping the library

The library needs nodeJS installed and the following node packages installed globally: typescript, karma, tslint.

This can be done from the command line:

npm install -g typescript karma tslint

The documentation of Cassiopee needs to install MkDocs and some extensions:

sudo apt install python3-pip
python3 -m pip install mkdocs
python3 -m pip install python-markdown-math
python3 -m pip install mkdocs-material

Install the necessary packages of the library:

Clone or update the JalHyd project and in the JalHyd folder, run :

npm package

Then, back to the ngHyd project folder, run :

npm run jalhyd

and then :

npm install

To compile the typescript code

npm run build

To run compilation in watch mode as well as application execution in a navigator window

npm start

To flag suspicious language usage

npm run lint

Caveats

Deployment

Custom Material SVG Icons will only show up when the application is deployed on the domain root (no subfolders), see this feature request

Procédure d'ajout d'un module de calcul

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(this, ComputeNodeType.LechaptCalmon, 'L', ParamDomainValue.POS, rL);
      		this._W = new ParamDefinition(this, ComputeNodeType.LechaptCalmon, 'W', ParamDomainValue.POS, rW);
      		this._A = new ParamDefinition(this, 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ètre à calculer par défaut
      		this._defaultCalculatedParam = prms.A;
      		this.resetDefaultCalculatedParam();
      	}
    
      	/**
      	* 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, this);
      	}
      }

• Créer les tests unitaires correspondants

• Ajouter une valeur à l'enum CalculatorType pour identifier le type de module de calcul (par ex MaCalculette).

• Compléter la méthode Session.createNub().

ngHyd

1. Créer les fichiers de configuration du module de calcul

   • 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 (1er paramètre du constructeur)

     Ne pas oublier de spécifier :

     • éventuellement le type de noeud par défaut du module de calcul dans les options avec le champ "defaultNodeType". Si ce champ est absent, sa valeur est "ComputeNodeType.None". Ce champ sert par ex pour les sections paramétrées à déterminer le type de section à afficher lors de la création du module de calcul.

     • éventuellement le type de noeud de paramètres particuliers (objets comportant "type":"input") avec le champ "nodeType": "MaCalculetteBleue" (par défaut, "ComputeNodeType.None")

   • dans src/app/calculators/ma-calculette :

     Créer les fichiers d'internationalisation (ma-calculette.<langue>.json). Il doivent reprendre tous les ids utilisés dans le fichier de configuration et fournir leur traduction.

2. Si nécessaire créer la classe du formulaire dans src/app/formulaire/definition/concrete . Une classe de base gérant la majorité des cas est déjà disponible, en général cette étape n'est pas nécessaire

   • Par ex : FormulaireMaCalculette dans src/app/formulaire/definition/concrete/form-ma-calculette.ts

     Ces classes concrètes sont construites par composition des classes dans src/app/formulaire/definition :

     • form-def-* : définition/description du formulaire.
       • FormDefSection : avec paramètre à varier
       • FormDefParamToCalculate : avec paramètre à calculer
       • etc...
     • form-compute-* : aspects calculatoires
     • form-result-* : affichage des résultats

     On peut soit composer la classe concrète directement avec ces classes, soient dériver ces dernières et composer avec.

3. src/locale/messages.<langue>.json : Ajouter un champ pour le titre du module de calcul. Par exemple : "INFO_MACALC_TITRE": "Ma calculette"

4. Dans le constructeur de FormulaireService, ajouter une entrée dans this.calculatorPaths pour fournir le préfixe des fichiers de configuration/internationalisation.

5. Si une nouvelle classe a été créée à l'étape 2, dans la méthode FormulaireService.newFormulaire(), compléter le switch pour fournir la classe à instancier.