add adists with rubar3 + rubar3 in release

src/Solver/RubarBE.py

@@ -610,6 +610,28 @@ class Rubar3(CommandLineSolver):
                 )
 
             ts = set()
+            timestamp = next(filter(
+                lambda p: p.name == 'rubarbe_tinit',
+                study.river.get_params(self._type).parameters
+            )).value
+            if timestamp.count(':') == 3:
+                timestamp = old_pamhyr_date_to_timestamp(timestamp)
+            ts.add(timestamp)
+
+            # add initial condition
+            for r, edge in enumerate(study.river.enable_edges()):
+                reach = edge.reach
+                ics = study.river.initial_conditions.get(edge)
+                q = ics.get_discharge()
+                z = ics.get_elevation()
+                k = 0
+                for i, j in zip(z, q):
+                    v = reach.profiles[k].speed(i, j)
+                    set_and_compute_limites(reachs[r][0], k, i, j, v)
+                    k += 1
+
+            # start read
+
             end = False
             while True:
                 line = f.readline()
@@ -649,6 +671,97 @@ class Rubar3(CommandLineSolver):
                     h, s, q, z = read_data_line(f)
                     set_and_compute_limites(reach, ind, z+h, q, s)
 
+    @timer
+    def write_bin(self, study, fname, results, qlog=None, name="0"):
+        logger.info(f"write_bin: Start writing '{fname}' ...")
+
+        with open(fname, "wb") as f:
+            def newline(j): return np.asarray([j], dtype=np.int32).tofile(f)
+            def endline(j): return np.asarray([j], dtype=np.int32).tofile(f)
+
+            def write_int(i):
+                newline(len(i)*4)
+                np.array(i, dtype=np.int32).tofile(f)
+                endline(len(i)*4)
+
+            def write_float(i):
+                newline(len(i)*4)
+                np.array(i, dtype=np.float32).tofile(f)
+                endline(len(i)*4)
+
+            def write_float64(i):
+                newline(len(i)*8)
+                np.array(i, dtype=np.float64).tofile(f)
+                endline(len(i)*8)
+
+            def write_float64(i):
+                newline(len(i)*8)
+                np.array(i, dtype=np.float64).tofile(f)
+                endline(len(i)*8)
+
+            def write_data(npts, t, a, val):
+                newline(npts*4 + 13)
+                np.array(npts, dtype=np.int32).tofile(f)
+                np.array(t, dtype=np.float64).tofile(f)
+                np.array(bytearray(a.encode()), dtype=np.byte).tofile(f)
+                np.array(val, dtype=np.float32).tofile(f)
+                endline(npts*4 + 13)
+
+            ts_list = sorted(results.get("timestamps"))
+            profiles = []
+            for r in results.river.reachs:
+                profiles += r.profiles
+
+            # Meta data (1st line)
+            nb_reach = len(results.river)
+            nb_profile = len(profiles)
+            write_int([nb_reach, nb_profile, "82"])
+
+            # Reach information (2nd line)
+            is1 = []
+            is2 = []
+            ltmp = []
+            i = 1
+            for r in results.river.reachs:
+                j = i+len(r)-1
+                ltmp += [i, j]
+                is1.append(i)
+                is2.append(j)
+                i += i+len(r)
+            write_int(ltmp)
+
+            # X (3rd line)
+            rk = []
+            for r in results.river.reachs:
+                rk += r.geometry.get_rk()
+            write_float(rk)
+
+            # Z and Y (4th line)
+            # ltmp = []
+            # for r in results.river.reachs:
+            #     for p in r.prifiles:
+            #         ltpm.append(p.rk)
+            write_float(3*nb_profile*[0.0])
+
+            # Data
+
+            for timestamp in ts_list:
+                q = list(
+                    map(
+                        lambda p: p.get_ts_key(timestamp, "Q"),
+                        profiles
+                    )
+                )
+                write_data(nb_profile, timestamp, "Q", q)
+                z = list(
+                    map(
+                        lambda p: p.get_ts_key(timestamp, "Z"),
+                        profiles
+                    )
+                )
+                write_data(nb_profile, timestamp, "Z", z)
+            logger.info(f"write_bin: ... end with {len(ts_list)} timestamps")
+
     @timer
     def results(self, study, repertory, qlog=None, name="0"):
         results = Results(
@@ -670,6 +783,9 @@ class Rubar3(CommandLineSolver):
             logger_exception(e)
             return None
 
+        fname = os.path.join(repertory, f"{name}.BIN")
+        self.write_bin(study, fname, results, qlog, name)
+
         return results