diff --git a/src/prebarrage/pre_barrage.ts b/src/prebarrage/pre_barrage.ts
index 82c9e16431f67fd3e442df3abb262796822c393b..0edb292950d255a656fccc7f5c80d18f244881cd 100644
--- a/src/prebarrage/pre_barrage.ts
+++ b/src/prebarrage/pre_barrage.ts
@@ -352,13 +352,11 @@ export class PreBarrage extends Nub {
         // calculate Q on all walls so that their result shows Q and not Z1
         for (const c of this._children) {
             if (c instanceof PbCloison) {
-                c.inhibitSubmergenceError = true;
                 // sauvegarde des messages générés pendant les itérations de dichotomie
-                const logBackup: cLog = c.result.resultElement.log.clone();
+                const logBackup: cLog = c.result.resultElement.log.cloneErrors();
                 c.finalCalc();
                 // restitution des messages sauvés
                 c.result.resultElement.log.addLog(logBackup);
-                c.inhibitSubmergenceError = false;
             }
         }
 
@@ -369,17 +367,6 @@ export class PreBarrage extends Nub {
             }
         }
 
-        // recalculate Q on all walls without error inhibition
-        for (const c of this._children) {
-            if (c instanceof PbCloison) {
-                // sauvegarde des messages générés pendant les itérations de dichotomie
-                const logBackup: cLog = c.result.resultElement.log.clone();
-                c.finalCalc();
-                // restitution des messages sauvés
-                c.result.resultElement.log.addLog(logBackup);
-            }
-        }
-
         // if an error occurred in any nub, remove all results
         // except if it's a dichotomy convergence error (and only this error)
 
diff --git a/src/util/log.ts b/src/util/log.ts
index d78c7d924738979c84b433498859f1370e382f35..8c682c26173005bb43be5c1a9b0091792b1d7c75 100644
--- a/src/util/log.ts
+++ b/src/util/log.ts
@@ -66,6 +66,19 @@ export class cLog {
         return this._messages;
     }
 
+    /**
+     * @return a clone of "this" (clone error messages only)
+     */
+    public cloneErrors(): cLog {
+        const res: cLog = new cLog();
+        for (const m of this._messages) {
+            if (m.getSeverity() === MessageSeverity.ERROR) {
+                res.add(m);
+            }
+        }
+        return res;
+    }
+
     /**
      * @return a clone of "this" (do not clone messages, keep references to original messages)
      */
@@ -115,6 +128,18 @@ export class cLog {
         return true;
     }
 
+    /**
+     * @returns true if given message exactly matches one of the messages
+     */
+    private hasMessage(m: Message): boolean {
+        for (const msg of this._messages) {
+            if (m.equals(msg, true)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public get uniqueMessageCodes(): MessageCode[] {
         const res: MessageCode[] = [];
         for (const m of this.messages) {
diff --git a/src/util/message.ts b/src/util/message.ts
index 77253f6882a12db3a022a8d7c5328b55b6956aca..5925cb864306e5f8da4cab2233d9c598e8606c26 100644
--- a/src/util/message.ts
+++ b/src/util/message.ts
@@ -753,4 +753,45 @@ export class Message {
         const sourceNub = this.sourceNub;
         return MessageCode[this._code] + " " + JSON.stringify(this.extraVar) + (sourceNub === undefined ? "" : " parentnub " + sourceNub.constructor.name);
     }
+
+    public equals(m: Message, includeSourceNub: boolean): boolean {
+        if (this._code !== m._code)
+            return false;
+
+        const keys1 = Object.keys(this.extraVar);
+        const keys2 = Object.keys(m.extraVar);
+        if (keys1.length !== keys2.length)
+            return false;
+
+        if (keys1.length === 0) {
+            return true;
+        }
+
+        for (const k of keys1) {
+            if (!keys2.includes(k)) {
+                return false;
+            }
+            if (this.extraVar[k] !== m.extraVar[k]) {
+                return false;
+            }
+        }
+
+        // to be sure all keys are shared, do the same thing the other way around
+        for (const k of keys2) {
+            if (!keys1.includes(k)) {
+                return false;
+            }
+            if (this.extraVar[k] !== m.extraVar[k]) {
+                return false;
+            }
+        }
+
+        if (includeSourceNub) {
+            if (this.sourceNub !== undefined && (this.sourceNub.uid !== m.sourceNub?.uid)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }