'0304'

Author: smasky

model/APEX/ds_param.yaml

@@ -1,4 +1,10 @@
 design_parameters:
+  - name: SOL_K
+    type: float
+    mode: v
+    bounds: [0.0001, 10]
+    cache: True
+    
   - name: GWSO
     type: float
     mode: v
@@ -183,4 +189,4 @@ design_parameters:
     type: float
     mode: v
     bounds: [0.01, 0.05]
-    cache: True
+    cache: True

model/APEX/paraLibrary.yaml

@@ -308,3 +308,14 @@ parameter_library:
       start: 25
       width: 8
       precision: 2
+  
+  - name: SOL_K
+    type: float
+    bounds: [0.0001, 100]
+    file:
+      name: "*.SOL"
+      line: 22
+      start: 1
+      width: 8
+      precision: 2
+      maxNum: 10

model/APEX/param_manager.py

@@ -24,6 +24,7 @@ class ParamFileSpec:
     start: int
     width: int
     precision: int
+    maxNum: int
 
 @dataclass
 class ParamSpec:
@@ -39,7 +40,10 @@ def from_dict(d: Dict[str, Any]) -> "ParamSpec":
             name=d["name"],
             type=TYPE_MAP.get(d["type"], 0),
             bounds=d["bounds"],
-            file=ParamFileSpec(**d["file"])
+            file=ParamFileSpec(name=d["file"]["name"], line=d["file"]["line"], 
+                               start=d["file"]["start"], width=d["file"]["width"], 
+                               precision=d["file"]["precision"],
+                               maxNum=int(d["file"].get("maxNum", 1))),
         )
 
     @property
@@ -101,7 +105,7 @@ def from_dict(d: Dict[str, Any], index: int):
         )
 
 # -------------------------------------------------------------
-# Parameter Manager (重构版)
+# Parameter Manager
 # -------------------------------------------------------------
 
 class ParamManager:

model/APEX/runoff.yaml

@@ -5,7 +5,7 @@ basic:
   workPath: "E:/Apex_workPath"
   command: "APEX1501_rel32.exe"
   timeout: 120
-  parallel: 15
+  parallel: 1
 
 parameters:
   library: "paraLibrary.yaml"

model/APEX/write_in_handler.py

@@ -11,7 +11,7 @@ class SubEntry:
 class Parameter:
     name: str
     index: int
-    entry: SubEntry               
+    entries: List[SubEntry]               
     mode: int                     # 0: orig*(1+x), 1: =x, 2: orig+x
     typ: int                      # 1: int, else: float
     precision: int
@@ -85,7 +85,7 @@ def register_param(
         precision = lib_info.file.precision
         lb = lib_info.lb if hardBound else None
         ub = lib_info.ub if hardBound else None
-        
+        maxNum = lib_info.file.maxNum
         line_idx = linePos - 1
 
         if typ == 1:
@@ -95,18 +95,23 @@ def register_param(
                 ub = int(ub)
 
         line_start = self.line_offsets[line_idx]
-
-        off = line_start + (staPos - 1)
-
-        field = bytes(self.base_content[off:off + width])
-        val = self._parse_float_field(field)
-
-        entry = SubEntry(offset=off, original_val=val)
+        # TODO
+        if line_idx + 1 < len(self.line_offsets):
+            line_end = self.line_offsets[line_idx + 1]
+        else:
+            line_end = len(self.base_content)
+        base_offset = line_start + (staPos - 1)
+        entries = self._scan_entries(
+            start_offset=base_offset, 
+            width=width, 
+            max_num=maxNum, 
+            line_end_offset=line_end
+        )
 
         self.params[index] = Parameter(
             name = name,
             index = index,
-            entry = entry,
+            entries = entries,
             mode = mode,
             typ = typ,
             precision = precision,
@@ -118,66 +123,85 @@ def register_param(
         return True
 
     def set_values_and_save(
-        self,
-        output_filepath: str,
-        indices: List[int],
-        vals: List[float],
-        warn_stacklevel: int = 2,
-        warn_detail_limit: int = 20,
-    ):
+            self,
+            output_filepath: str,
+            indices: List[int],
+            vals: List[float],
+            warn_stacklevel: int = 2,
+            warn_detail_limit: int = 20,
+        ):
+            
+            self.file_content = bytearray(self.base_content)
+            mods: List[Modification] = []
+            clamp_events = []
+
+            for idx, input_val in zip(indices, vals):
+                p = self.params.get(idx)
+                if not p:
+                    continue
+
+                for e in p.entries:
+                    
+                    if p.mode == 0:   # relative %
+                        raw = e.original_val * (1.0 + float(input_val))
+                    elif p.mode == 1: # replace
+                        raw = float(input_val)
+                    elif p.mode == 2: # absolute add
+                        raw = e.original_val + float(input_val)
+                    else:
+                        raw = float(input_val)
+
+                    raw2 = int(raw) if p.typ == 1 else raw
+
+                    clamped = raw2
+                    if p.lb is not None and clamped < p.lb:
+                        clamped = p.lb
+                    if p.ub is not None and clamped > p.ub:
+                        clamped = p.ub
+
+                    if clamped != raw2:
+                        clamp_events.append((idx, p.name, raw2, clamped, p.lb, p.ub))
+
+                    b = self._format_value(clamped, p.width, p.precision, p.typ)
+                    mods.append(Modification(offset=e.offset, width=p.width, data=b))
+
+            for m in mods:
+                self.file_content[m.offset : m.offset + m.width] = m.data
+
+            if clamp_events:
+                head = clamp_events[:warn_detail_limit]
+                msg_lines = [
+                    f"Param clamp: {output_filepath}, idx={i}, raw={raw:.2f}->{clamped:.2f}"
+                    for (i, name, raw, clamped, lb, ub) in head
+                ]
+                more = "" if len(clamp_events) <= warn_detail_limit else f"\n... {len(clamp_events)-warn_detail_limit} more"
+                warnings.warn("\n".join(msg_lines) + more, stacklevel=warn_stacklevel)
+
+            with open(output_filepath, "wb") as out:
+                out.write(self.file_content)
+            
+    def _scan_entries(
+        self, start_offset: int, width: int, max_num: int, line_end_offset: int
+    ) -> List[SubEntry]:
+
+        entries = []
 
-        self.file_content = bytearray(self.base_content)
+        for i in range(max_num):
+            curr_off = start_offset + (i * width)
+            curr_end = curr_off + width
+
+            if curr_end > line_end_offset:
+                break
+            
+            if curr_end > len(self.base_content):
+                break
+
+            field = bytes(self.base_content[curr_off : curr_end])
+            val = self._parse_float_field(field)
 
-        mods: List[Modification] = []
-        clamp_events = []
+            if val is None:
+                break 
 
-        for idx, input_val in zip(indices, vals):
+            entries.append(SubEntry(offset=curr_off, original_val=val))
 
-            p = self.params.get(idx)
-            if not p:
-                continue
-
-            e = p.entry
-
-            # 1) calculate raw
-            if p.mode == 0:
-                raw = e.original_val * (1.0 + float(input_val))
-            elif p.mode == 1:
-                raw = float(input_val)
-            elif p.mode == 2:
-                raw = e.original_val + float(input_val)
-            else:
-                raw = float(input_val)
-
-            # 2) transform type
-            raw2 = int(raw) if p.typ == 1 else raw
-
-            # 3) clamp (warning)
-            clamped = raw2
-            if p.lb is not None and clamped < p.lb:
-                clamped = p.lb
-            if p.ub is not None and clamped > p.ub:
-                clamped = p.ub
-
-            if clamped != raw2:
-                clamp_events.append((idx, p.name, raw2, clamped, p.lb, p.ub))
-
-            b = self._format_value(clamped, p.width, p.precision, p.typ)
-            mods.append(Modification(offset=e.offset, width=p.width, data=b))
-
-        for m in mods:
-            self.file_content[m.offset:m.offset + m.width] = m.data
-
-        if clamp_events:
-            head = clamp_events[:warn_detail_limit]
-            msg_lines = [
-                f"Param clamp: in file {output_filepath}, idx={i}, name={name}, {raw} -> {clamped}, hardBounds=[{lb},{ub}]"
-                for (i, name, raw, clamped, lb, ub) in head
-            ]
-            more = "" if len(clamp_events) <= warn_detail_limit else (
-                f"\n... and {len(clamp_events) - warn_detail_limit} more clamps"
-            )
-            warnings.warn("\n".join(msg_lines) + more, stacklevel=warn_stacklevel)
-
-        with open(output_filepath, "wb") as out:
-            out.write(self.file_content)
+        return entries