Bladeren bron

adjust temperature target without upper and lower, use mid

chenhaiyang 4 jaren geleden
bovenliggende
commit
817e0021b7
1 gewijzigde bestanden met toevoegingen van 28 en 35 verwijderingen
  1. 28 35
      app/controllers/targets.py

+ 28 - 35
app/controllers/targets.py

@@ -57,7 +57,7 @@ class TargetController(Controller):
         pass
 
     @abstractmethod
-    async def get_targets(self):
+    async def get_targets(self) -> float:
         pass
 
     async def generate_temporary(self, lower, upper):
@@ -116,8 +116,8 @@ class TemperatureTargetController(TargetController):
 
     @staticmethod
     def _cut(value: float) -> float:
-        _LOWER_LIMIT = 21.0
-        _UPPER_LIMIT = 29.0
+        _LOWER_LIMIT = 22.0
+        _UPPER_LIMIT = 28.0
         value = min(value, _UPPER_LIMIT)
         value = max(value, _LOWER_LIMIT)
 
@@ -126,7 +126,8 @@ class TemperatureTargetController(TargetController):
     async def init_temporary(self) -> Tuple[float, float]:
         _VAR = 2
         _RANGE = 1
-        new_lower_bound, new_upper_bound = 23.0, 25.0
+        new_target = 24.0
+        new_lower_bound, new_upper_bound = new_target - 1.0, new_target + 1.0
         if self._realtime_data is not np.NAN:
             if self._season == Season.cooling:
                 if ('a little hot' in self._feedback
@@ -145,7 +146,7 @@ class TemperatureTargetController(TargetController):
 
         return self._cut(new_lower_bound), self._cut(new_upper_bound)
 
-    async def get_targets(self):
+    async def get_targets(self) -> float:
         current_lower_target = self._current_targets['temperatureMin'].loc[self._quarter_time]
         current_upper_target = self._current_targets['temperatureMax'].loc[self._quarter_time]
         if current_lower_target is np.NAN:
@@ -153,35 +154,31 @@ class TemperatureTargetController(TargetController):
         if current_upper_target is np.NAN:
             current_upper_target = 25.0
 
-        return current_lower_target, current_upper_target
+        return (current_lower_target + current_upper_target) / 2
 
-    async def readjust_current(self, lower: float, upper: float, diff: float) -> Tuple[float, float]:
+    async def readjust_current(self, current: float, diff: float) -> float:
         _RANGE = 2
-        new_lower_bound, new_upper_bound = lower, upper
+        new_target = current
         if self._realtime_data is np.NAN:
-            new_lower_bound += lower + diff
-            new_upper_bound += upper + diff
+            new_target += diff
         else:
             if self._season == Season.cooling:
-                if (diff > 0 and self._realtime_data + _RANGE > upper
-                        or diff < 0 and self._realtime_data - _RANGE < upper):
-                    new_upper_bound = self._realtime_data + diff
-                    new_lower_bound = new_upper_bound - (upper - lower)
+                standard = current + 1.0
+            elif self._season == Season.heating:
+                standard = current - 1.0
             else:
-                if (diff > 0 and self._realtime_data + _RANGE > lower
-                        or diff < 0 and self._realtime_data - _RANGE < lower):
-                    new_lower_bound = self._realtime_data + diff
-                    new_upper_bound = new_lower_bound + (upper - lower)
+                standard = current
 
-        return self._cut(new_lower_bound), self._cut(new_upper_bound)
+            if (diff > 0 and self._realtime_data + _RANGE > standard
+                    or diff < 0 and self._realtime_data - _RANGE < standard):
+                new_target += diff
 
-    async def generate_global(self, lower: float, upper: float):
-        extent = upper - lower
-        if self._season == Season.cooling:
-            new_targets = self._current_targets['new_targets'].apply(lambda x: [x - extent, x])
-        else:
-            new_targets = self._current_targets['new_targets'].apply(lambda x: [x, x + extent])
+        return new_target
 
+    async def generate_global(self):
+        _RANGE = 1
+        lower, upper = self._cut(x - _RANGE), self._cut(x + _RANGE)
+        new_targets = self._current_targets['new_targets'].apply(lambda x: [lower, upper])
         time_index = self._current_targets.reset_index()['time']
         result = {}
         for i in range(len(time_index)):
@@ -195,18 +192,14 @@ class TemperatureTargetController(TargetController):
                 lower_bound, upper_bound = await self.init_temporary()
                 await self.generate_temporary(lower_bound, upper_bound)
             else:
-                current_lower, current_upper = await self.get_targets()
-                lower_bound, upper_bound = await self.readjust_current(current_lower, current_upper, diff)
-                if self._season == Season.cooling:
-                    temp_target = upper_bound
-                else:
-                    temp_target = lower_bound
+                current_target = await self.get_targets()
+                new_target = await self.readjust_current(current_target, diff)
                 if not self._is_temporary:
-                    self._results.update({'latest_change': temp_target})
-                    await self.readjust_global(temp_target, self._previous_changes)
-                    await self.generate_global(current_lower, current_upper)
+                    self._results.update({'latest_change': new_target})
+                    await self.readjust_global(new_target, self._previous_changes)
+                    await self.generate_global()
                 else:
-                    await self.generate_temporary(lower_bound, upper_bound)
+                    await self.generate_temporary(self._cut(new_target) - 1.0, self._cut(new_target + 1.0))
         else:
             return