diff --git a/spec/verificateur/verificateur.spec.ts b/spec/verificateur/verificateur.spec.ts
index 184e079043313bf1f2463860409b22673b59f857..212e30fa2794b2ae26b36a01c9857da891d9ed35 100644
--- a/spec/verificateur/verificateur.spec.ts
+++ b/spec/verificateur/verificateur.spec.ts
@@ -144,9 +144,14 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
-            expect(res.log.messages.length).toBe(6); // 5 cloisons + 1 downwall
-            expect(res.log.messages[2].code).toBe(MessageCode.ERROR_VERIF_PAB_JETS);
-            expect(res.log.messages[5].code).toBe(MessageCode.ERROR_VERIF_PAB_JETS_DW);
+            /* expect(res.globalLog.messages.length).toBe(1);
+            expect(res.globalLog.messages[0].code).toBe(MessageCode.ERROR_VERIF_KO); */
+            expect(res.log.messages.length).toBe(1);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(6); // 5 cloisons + 1 downwall
+            expect(r0.log.messages[2].code).toBe(MessageCode.ERROR_VERIF_PAB_JETS);
+            expect(r0.log.messages[5].code).toBe(MessageCode.ERROR_VERIF_PAB_JETS_DW);
         });
 
         // falls on Cloison / downwall
@@ -162,9 +167,12 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
-            expect(res.log.messages.length).toBe(6); // 5 cloisons + 1 downwall
-            expect(res.log.messages[2].code).toBe(MessageCode.ERROR_VERIF_PAB_DHMAX);
-            expect(res.log.messages[5].code).toBe(MessageCode.ERROR_VERIF_PAB_DHMAX_DW);
+            expect(res.log.messages.length).toBe(1);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(6); // 5 cloisons + 1 downwall
+            expect(r0.log.messages[2].code).toBe(MessageCode.ERROR_VERIF_PAB_DHMAX);
+            expect(r0.log.messages[5].code).toBe(MessageCode.ERROR_VERIF_PAB_DHMAX_DW);
         });
 
         // weirs and slots witdh
@@ -186,9 +194,12 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
-            expect(res.log.messages.length).toBe(2);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_BMIN);
-            expect(res.log.messages[1].code).toBe(MessageCode.ERROR_VERIF_PAB_BMIN);
+            expect(res.log.messages.length).toBe(1);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(2);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_BMIN);
+            expect(r0.log.messages[1].code).toBe(MessageCode.ERROR_VERIF_PAB_BMIN);
         });
 
         // basins depth
@@ -207,9 +218,12 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
-            expect(res.log.messages.length).toBe(2);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_YMOY);
-            expect(res.log.messages[1].code).toBe(MessageCode.ERROR_VERIF_PAB_YMOY_2_DH);
+            expect(res.log.messages.length).toBe(1);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(2);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_YMOY);
+            expect(r0.log.messages[1].code).toBe(MessageCode.ERROR_VERIF_PAB_YMOY_2_DH);
             expect(res.globalLog.messages.length).toBe(0);
         });
 
@@ -229,9 +243,12 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
-            expect(res.log.messages.length).toBe(2);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_HMIN);
-            expect(res.log.messages[1].code).toBe(MessageCode.ERROR_VERIF_PAB_HMIN_DW);
+            expect(res.log.messages.length).toBe(1);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(2);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_HMIN);
+            expect(r0.log.messages[1].code).toBe(MessageCode.ERROR_VERIF_PAB_HMIN_DW);
             expect(res.globalLog.messages.length).toBe(0);
         });
 
@@ -250,7 +267,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_LMIN);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAB_LMIN);
         });
 
     });
@@ -290,7 +310,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_DH);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_DH);
         });
 
         // species groups 3a, 3b, 7b are discouraged
@@ -310,10 +333,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(true);
             expect(res.vCalc).toBe(1);
 
-            expect(res.log.messages.length).toBe(3);
-            expect(res.log.messages[0].code).toBe(MessageCode.WARNING_VERIF_PAR_SPECIES_GROUP);
-            expect(res.log.messages[1].code).toBe(MessageCode.WARNING_VERIF_PAR_SPECIES_GROUP);
-            expect(res.log.messages[2].code).toBe(MessageCode.WARNING_VERIF_PAR_SPECIES_GROUP);
+            for (const i of [ 0, 2, 3 ]) {
+                const r = v.species[i].result;
+                expect(r.log.messages[0].code).toBe(MessageCode.WARNING_VERIF_PAR_SPECIES_GROUP);
+            }
         });
 
         // water level, plane & fatou
@@ -333,7 +356,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
         });
 
         it("Tirant d'eau insuffisant (fatou)", () => {
@@ -354,7 +380,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
         });
 
         // water level, superactive & chevron
@@ -377,7 +406,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
         });
 
         it("Tirant d'eau insuffisant (chevron)", () => {
@@ -399,7 +431,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_PAR_YMIN);
         });
 
         // slopes
@@ -463,7 +498,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_MR_VMAX);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_MR_VMAX);
         });
 
         // water level
@@ -484,7 +522,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_MR_YMIN);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_MR_YMIN);
         });
     });
 
@@ -523,9 +564,9 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(true);
             expect(res.vCalc).toBe(1);
 
-            expect(res.log.messages.length).toBe(3); // warning sur 3 des 4 radiers
+            const r0 = v.species[0].result;
             for (let i=0; i < 3; i++) {
-                expect(res.log.messages[i].code).toBe(MessageCode.WARNING_VERIF_MRC_VMAX_APRON_N);
+                expect(r0.log.messages[i].code).toBe(MessageCode.WARNING_VERIF_MRC_VMAX_APRON_N);
             }
             expect(res.globalLog.messages.length).toBe(1);
             expect(res.globalLog.messages[0].code).toBe(MessageCode.INFO_VERIF_OK);
@@ -544,11 +585,14 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
-            expect(res.log.messages.length).toBe(5); // warning sur les 4 radiers, plus erreur "aucun radier OK"
+            expect(res.log.messages.length).toBe(1);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(5); // warning sur les 4 radiers, plus erreur "aucun radier OK"
             for (let i=0; i < 4; i++) {
-                expect(res.log.messages[i].code).toBe(MessageCode.WARNING_VERIF_MRC_VMAX_APRON_N);
+                expect(r0.log.messages[i].code).toBe(MessageCode.WARNING_VERIF_MRC_VMAX_APRON_N);
             }
-            expect(res.log.messages[4].code).toBe(MessageCode.ERROR_VERIF_MRC_AT_LEAST_ONE_APRON);
+            expect(r0.log.messages[4].code).toBe(MessageCode.ERROR_VERIF_MRC_AT_LEAST_ONE_APRON);
             expect(res.globalLog.messages.length).toBe(0);
         });
     });
@@ -584,7 +628,10 @@ describe("vérificateur de franchissement −", () => {
             expect(res.ok).toBe(false);
 
             expect(res.log.messages.length).toBe(1);
-            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_NO_PRESET);
+            expect(res.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_SPECIES_KO);
+            const r0 = v.species[0].result;
+            expect(r0.log.messages.length).toBe(1);
+            expect(r0.log.messages[0].code).toBe(MessageCode.ERROR_VERIF_NO_PRESET);
         });
 
         // pass with errors
@@ -601,6 +648,7 @@ describe("vérificateur de franchissement −", () => {
             const res = v.CalcSerie();
             expect(res.ok).toBe(false);
 
+            expect(res.resultElements.length).toBe(0);
             expect(res.globalLog.messages.length).toBe(1);
             expect(res.globalLog.messages[0].code).toBe(MessageCode.ERROR_VERIF_ERRORS_IN_PASS);
         });
diff --git a/src/util/message.ts b/src/util/message.ts
index b75f65ab0a1420543ef77efaf003b0f1e495e042..744105667cbc2dd2004c09d8ebacd8365626300c 100644
--- a/src/util/message.ts
+++ b/src/util/message.ts
@@ -195,6 +195,12 @@ export enum MessageCode {
     /** Vérificateur : la passe à vérifier contient des erreurs */
     ERROR_VERIF_ERRORS_IN_PASS,
 
+    /** Vérificateur : les nubs Espece ont produit au moins un message de niveau erreur sur l'ensemble des résultats */
+    ERROR_VERIF_KO,
+
+    /** Vérificateur : les nubs Espece du résultat en cours ont produit au moins un message de niveau erreur */
+    ERROR_VERIF_SPECIES_KO,
+
     /** Vérificateur, passe à macrorugosités : vitesse max. %V% trop élevée (maximum: %maxV%) */
     ERROR_VERIF_MR_VMAX,
 
diff --git a/src/verification/espece.ts b/src/verification/espece.ts
index 6c5a7fc2ecbc8edf616182b842ab1be71e1e8208..c57e19b752050132e83655d20d5239a8e3df7f9b 100644
--- a/src/verification/espece.ts
+++ b/src/verification/espece.ts
@@ -347,7 +347,7 @@ export class Espece extends Nub implements Observer {
                     cloisonNumber = 1;
                     for (const c of passB.children) {
                         const iRes = c.result.resultElements[this.indexToCheck];
-                        if (iRes.values.DH > this.prms.DHMax.singleValue) {
+                        if (this.prms.DHMax.singleValue !== undefined && iRes.values.DH > this.prms.DHMax.singleValue) {
                             res.vCalc = 0;
                             const m = new Message(MessageCode.ERROR_VERIF_PAB_DHMAX);
                             m.extraVar.N = String(cloisonNumber);
@@ -360,7 +360,7 @@ export class Espece extends Nub implements Observer {
                     // downwall
                     const ca = passB.downWall;
                     const iRes = ca.result.resultElements[this.indexToCheck];
-                    if (iRes.values.DH > this.prms.DHMax.singleValue) {
+                    if (this.prms.DHMax.singleValue !== undefined && iRes.values.DH > this.prms.DHMax.singleValue) {
                         res.vCalc = 0;
                         const m = new Message(MessageCode.ERROR_VERIF_PAB_DHMAX_DW);
                         m.extraVar.DH = iRes.values.DH;
@@ -383,7 +383,7 @@ export class Espece extends Nub implements Observer {
                     cloisonNumber = 1;
                     for (const c of passB.children) {
                         const iRes = c.result.resultElements[this.indexToCheck];
-                        if (iRes.values.YMOY < this.prms.PMin.singleValue) {
+                        if (this.prms.PMin.singleValue !== undefined && iRes.values.YMOY < this.prms.PMin.singleValue) {
                             res.vCalc = 0;
                             const m = new Message(MessageCode.ERROR_VERIF_PAB_YMOY);
                             m.extraVar.N = String(cloisonNumber);
@@ -419,7 +419,7 @@ export class Espece extends Nub implements Observer {
                     // 6. basins length
                     cloisonNumber = 1;
                     for (const c of passB.children) {
-                        if (c.prms.LB.singleValue < this.prms.LMin.singleValue) {
+                        if (this.prms.LMin.singleValue !== undefined && c.prms.LB.singleValue < this.prms.LMin.singleValue) {
                             res.vCalc = 0;
                             const m = new Message(MessageCode.ERROR_VERIF_PAB_LMIN);
                             m.extraVar.N = String(cloisonNumber);
@@ -446,7 +446,7 @@ export class Espece extends Nub implements Observer {
                     }
 
                     // 3. water level
-                    let minY: number;
+                    let minY = 0; // if this.prms.YMin(P|S)B is undefined, "skip test"
                     if ([ ParType.PLANE, ParType.FATOU ].includes(passR.parType)) {
                         minY = this.prms.YMinPB.singleValue;
                     } else if ([ ParType.SUPERACTIVE, ParType.CHEVRON ].includes(passR.parType)) {
@@ -516,7 +516,7 @@ export class Espece extends Nub implements Observer {
             // for "Villemonte 1947" ("échancrure") or "Fente noyée (Larinier 1992)" ("fente") only
             if ([ LoiDebit.WeirVillemonte, LoiDebit.WeirSubmergedLarinier ].includes(s.loiDebit)) {
                 const structParams = s.prms as RectangularStructureParams;
-                if (structParams.L.v < this.prms.BMin.singleValue) {
+                if (this.prms.BMin.singleValue !== undefined && structParams.L.v < this.prms.BMin.singleValue) {
                     res.vCalc = 0;
                     let m: Message;
                     if (cloisonNumber === undefined) {
@@ -545,7 +545,7 @@ export class Espece extends Nub implements Observer {
         let structureNumber = 1;
         for (const s of c.structures) {
             // for "Villemonte 1947" ("échancrure") only
-            if (s.loiDebit === LoiDebit.WeirVillemonte && s.prms.h1.v < this.prms.HMin.singleValue) {
+            if (s.loiDebit === LoiDebit.WeirVillemonte && this.prms.HMin.singleValue !== undefined && s.prms.h1.v < this.prms.HMin.singleValue) {
                 res.vCalc = 0;
                 let m: Message;
                 if (cloisonNumber === undefined) {
@@ -613,7 +613,7 @@ export class Espece extends Nub implements Observer {
         let val = 1;
 
         // 1. water level
-        if (pass.prms.Y.V < this.prms.YMin.singleValue) {
+        if (this.prms.YMin.singleValue !== undefined && pass.prms.Y.V < this.prms.YMin.singleValue) {
             val = 0;
             let m: Message;
             if (apronNumber !== undefined) {
@@ -628,7 +628,7 @@ export class Espece extends Nub implements Observer {
         }
 
         // 2. speed
-        if (passResult.values.Vmax > this.prms.VMax.singleValue) {
+        if (this.prms.VMax.singleValue !== undefined && passResult.values.Vmax > this.prms.VMax.singleValue) {
             val = 0;
             let m: Message;
             if (apronNumber !== undefined) {
diff --git a/src/verification/verificateur.ts b/src/verification/verificateur.ts
index ce42ff995e4d548e6464069742143dde954e6f92..5a50328370a9c1281c27fe17d1cd5b57265698a2 100644
--- a/src/verification/verificateur.ts
+++ b/src/verification/verificateur.ts
@@ -13,6 +13,9 @@ import { StructureJetTypeStrict } from "../structure/structure";
 
 export class Verificateur extends Nub implements Observer {
 
+    /** Instances of Espece re-created before each calculation */
+    protected _species: Espece[];
+
     constructor(dbg: boolean = false)  {
         super(new VerificateurParams(), dbg);
         this._calcType = CalculatorType.Verificateur;
@@ -23,9 +26,14 @@ export class Verificateur extends Nub implements Observer {
         this.pabJetType = StructureJetTypeStrict.SURFACE;
         // List of fish species to check the pass against
         this.speciesList = [];
+        this._species = [];
         // no calculated param
     }
 
+    public get species(): Espece[] {
+        return this._species;
+    }
+
     public get prms(): VerificateurParams {
         return this._prms as VerificateurParams;
     }
@@ -73,14 +81,21 @@ export class Verificateur extends Nub implements Observer {
         if (! this.nubToVerify.result || ! this.nubToVerify.result.ok) {
             this._result = new Result(undefined, this);
             this._result.addMessage(new Message(MessageCode.ERROR_VERIF_ERRORS_IN_PASS));
+            // @TODO when pass varies and some iterations have errors
             return this._result;
         }
+
+        // create Espece instances
+        this.initSpecies();
+
         // @TODO manage variating passes - fake parameter linked to pass result ? See in GUI ?
         super.CalcSerie();
 
-        // if no log (everything went ok), add a success message
-        if (! this._result.hasErrorMessages()) {
+        if (this._result.hasErrorMessages()) {
+            // this._result.addMessage(new Message(MessageCode.ERROR_VERIF_KO));
+        } else { // if no error log (everything went ok), add a success message
             this._result.addMessage(new Message(MessageCode.INFO_VERIF_OK));
+            // @TODO when pass varies and only some iterations went OK
         }
         return this._result;
     }
@@ -98,8 +113,8 @@ export class Verificateur extends Nub implements Observer {
         const r = new Result(v, this);
 
         // console.log("Equation ! Nub UID =", this.nubToVerify.uid);
-        for (const s of this.speciesList) {
-            const nub = this.getEspeceFromString(s);
+        let spIndex = 0;
+        for (const nub of this._species) {
             // give the pass pointer
             nub.passToCheck = this.nubToVerify;
             if (this.nubToVerify.calcType === CalculatorType.Pab) {
@@ -110,13 +125,21 @@ export class Verificateur extends Nub implements Observer {
             nub.indexToCheck = 0;
 
             const subRes = nub.Calc();
-            // copy log @TODO aggregate in a smarter way ?
-            r.resultElement.log.addLog(subRes.resultElement.log);
+            // subRes.resultElement.log
+
+            // if at least one error log in Espece nub, add one at Verificateur level, so that .ok is false
+            if (subRes.hasErrorMessages()) {
+                const m = new Message(MessageCode.ERROR_VERIF_SPECIES_KO);
+                m.extraVar.speciesGroup = this.speciesList[spIndex];
+                r.resultElement.addMessage(m);
+            }
 
             // @TODO remove vCalc as no parameter is calculated ?
             if (subRes.vCalc === 0) {
                 v = 0;
             }
+
+            spIndex ++;
         }
         r.vCalc = v;
 
@@ -132,6 +155,18 @@ export class Verificateur extends Nub implements Observer {
         }
     }
 
+    /**
+     * Creates an instance of Espece for each element of this.speciesList, and places
+     * it in this.species so that their results are kept and their logs are accessible
+     * after calculation has ended
+     */
+    protected initSpecies() {
+        this._species = [];
+        for (const s of this.speciesList) {
+            this._species.push(this.getEspeceFromString(s));
+        }
+    }
+
     /**
      * Retrieves an Espece from a given string, which should be either
      * the UID of an Espece Session Nub, or the label of an element
@@ -164,4 +199,5 @@ export class Verificateur extends Nub implements Observer {
     protected findCalculatedParameter(): any {
         return undefined;
     }
+
 }