Merge pull request #220 from PierreRust/214-rounding_based_on_min_max

#214 add rounding based on min and max

boaviztapi/data/config.yml

@@ -30,6 +30,8 @@ default_criteria: ["gwp", "adp", "pe"]
 
 default_duration:
 
-min_significant_figures: 5
+uncertainty: 10
+max_sig_fig: 4
+min_sig_fig: 1
 
-cpu_name_fuzzymatch_threshold: 80
+cpu_name_fuzzymatch_threshold: 80

boaviztapi/model/__init__.py

@@ -1,4 +1,4 @@
 from typing import Tuple, List
 
-# value, significant_figures, min, max, [warnings]
-ComputedImpacts = Tuple[float, int, float, float, List[str]]
+# value, min, max, [warnings]
+ComputedImpacts = Tuple[float, float, float, List[str]]

boaviztapi/model/component/assembly.py

@@ -18,8 +18,7 @@ def impact_embedded(self, impact_type: str) -> ComputedImpacts:
             max=get_impact_factor(item='assembly', impact_type=impact_type)['impact']
         )
 
-        significant_figures = rd.min_significant_figures(impact_factor.value)
-        return impact_factor.value, significant_figures, impact_factor.min, impact_factor.max, ["End of life is not included in the calculation"]
+        return impact_factor.value, impact_factor.min, impact_factor.max, ["End of life is not included in the calculation"]
 
     def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
         raise NotImplementedError

boaviztapi/model/component/case.py

@@ -1,6 +1,5 @@
 from typing import Tuple
 
-import boaviztapi.utils.roundit as rd
 from boaviztapi import config
 from boaviztapi.model import ComputedImpacts
 from boaviztapi.model.boattribute import Boattribute
@@ -21,6 +20,7 @@ def __init__(self, archetype=get_component_archetype(config["default_case"], "ca
             min=get_arch_value(archetype, 'case_type', 'min'),
             max=get_arch_value(archetype, 'case_type', 'max')
         )
+
     def impact_embedded(self, impact_type: str) -> ComputedImpacts:
         if self.case_type.value == 'rack':
             return self.__impact_manufacture_rack(impact_type)
@@ -34,31 +34,27 @@ def __impact_manufacture_rack(self, impact_type: str) -> ComputedImpacts:
             max=get_impact_factor(item='case', impact_type=impact_type)['rack']['impact']
         )
 
-        significant_figures = rd.min_significant_figures(impact_factor.value)
-
         if self.case_type.is_archetype() and self.case_type.value == 'rack':
             blade_impact = self.__impact_manufacture_blade(impact_type)
             if blade_impact[0] > impact_factor.value:
-                return impact_factor.value, significant_figures, impact_factor.min, blade_impact[3], ["End of life is not included in the calculation"]
+                return impact_factor.value, impact_factor.min, blade_impact[2], ["End of life is not included in the calculation"]
             else:
-                return impact_factor.value, significant_figures, blade_impact[2], impact_factor.max, ["End of life is not included in the calculation"]
-        return impact_factor.value, significant_figures, impact_factor.min, impact_factor.max, ["End of life is not included in the calculation"]
+                return impact_factor.value, blade_impact[1], impact_factor.max, ["End of life is not included in the calculation"]
+        return impact_factor.value, impact_factor.min, impact_factor.max, ["End of life is not included in the calculation"]
 
     def __impact_manufacture_blade(self, impact_type: str) -> ComputedImpacts:
         impact_blade_server, impact_blade_16_slots = self.__get_impact_constants_blade(impact_type)
 
         impact = self.__compute_impact_manufacture_blade(impact_blade_server, impact_blade_16_slots)
 
-        significant_figures = self.__compute_significant_numbers(impact_blade_server.value, impact_blade_16_slots.value)
-
         if self.case_type.is_archetype() and self.case_type.value == 'blade':
             rack_impact = self.__impact_manufacture_rack(impact_type)
             if rack_impact[0] > impact.value:
-                return impact.value, significant_figures, impact.min, rack_impact[3], ["End of life is not included in the calculation"]
+                return impact.value, impact.min, rack_impact[2], ["End of life is not included in the calculation"]
             else:
-                return impact.value, significant_figures, rack_impact[2], impact.max, ["End of life is not included in the calculation"]
+                return impact.value, rack_impact[1], impact.max, ["End of life is not included in the calculation"]
 
-        return impact.value, significant_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]
 
     def __get_impact_constants_blade(self, impact_type: str) -> Tuple[ImpactFactor, ImpactFactor]:
         impact_blade_server = ImpactFactor(
@@ -82,9 +78,5 @@ def __compute_impact_manufacture_blade(impact_blade_server: ImpactFactor, impact
             max=(impact_blade_16_slots.max / 16) + impact_blade_server.max
         )
 
-    @staticmethod
-    def __compute_significant_numbers(impact_blade_server: float, impact_blade_16_slots: float) -> int:
-        return rd.min_significant_figures(impact_blade_server, impact_blade_16_slots)
-
     def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
         raise NotImplementedError

boaviztapi/model/component/component.py

@@ -1,6 +1,5 @@
 from abc import abstractmethod
 
-import boaviztapi.utils.roundit as rd
 from boaviztapi.model import ComputedImpacts
 from boaviztapi.model.boattribute import Boattribute
 from boaviztapi.model.usage import ModelUsage
@@ -27,30 +26,25 @@ def __iter__(self):
     @property
     def usage(self) -> ModelUsage:
         if self._usage is None:
-            self._usage = ModelUsage(archetype=get_arch_component(self.archetype,"USAGE"))
+            self._usage = ModelUsage(archetype=get_arch_component(self.archetype, "USAGE"))
         return self._usage
 
     @usage.setter
     def usage(self, value: int) -> None:
         self._usage = value
 
-    def impact_use(self, impact_type: str, duration:float) -> ComputedImpacts:
+    def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
         if not self.usage.avg_power.is_set():
             raise NotImplementedError
         impact_factor = self.usage.elec_factors[impact_type]
 
         impacts = impact_factor.value * (self.usage.avg_power.value / 1000) * self.usage.use_time_ratio.value * duration
-        sig_fig = self.__compute_significant_numbers_usage(impact_factor.value)
 
         max_impact = impact_factor.max * (self.usage.avg_power.max / 1000) * self.usage.use_time_ratio.min * duration
         min_impact = impact_factor.min * (self.usage.avg_power.min / 1000) * self.usage.use_time_ratio.max * duration
 
-
-        return impacts, sig_fig, min_impact, max_impact, []
-
-    def __compute_significant_numbers_usage(self, impact_factor: float) -> int:
-        return rd.min_significant_figures(self.usage.avg_power.value, self.usage.use_time.value, impact_factor)
+        return impacts, min_impact, max_impact, []
 
     @abstractmethod
     def impact_embedded(self, impact_type: str) -> ComputedImpacts:
-        raise NotImplementedError
+        raise NotImplementedError

boaviztapi/model/component/cpu.py

@@ -79,10 +79,9 @@ def __init__(self, archetype=get_component_archetype(config["default_cpu"], "cpu
     # IMPACT COMPUTATION
     def impact_embedded(self, impact_type: str) -> ComputedImpacts:
         core_impact, cpu_die_impact, cpu_impact = self.__get_impact_constants(impact_type)
-        sign_figures = self.__compute_significant_numbers(core_impact.value, cpu_die_impact.value, cpu_impact.value)
         impact = self.__compute_impact_manufacture(core_impact, cpu_die_impact, cpu_impact)
 
-        return impact.value, sign_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]
 
     def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
         impact_factor = self.usage.elec_factors[impact_type]
@@ -104,11 +103,7 @@ def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
                     self.usage.avg_power.max / 1000) * self.usage.use_time_ratio.max * duration
         )
 
-        sig_fig = self.__compute_significant_numbers_usage(impact_factor.value)
-        return impact.value, sig_fig, impact.min, impact.max, []
-
-    def __compute_significant_numbers_usage(self, impact_factor: float) -> int:
-        return rd.min_significant_figures(self.usage.avg_power.value, self.usage.use_time_ratio.value, impact_factor)
+        return impact.value, impact.min, impact.max, []
 
     # TODO: compute min & max
     def model_power_consumption(self) -> ImpactFactor:
@@ -149,9 +144,6 @@ def __get_impact_constants(self, impact_type: str) -> Tuple[ImpactFactor, Impact
 
         return core_impact, cpu_die_impact, cpu_impact
 
-    def __compute_significant_numbers(self, core_impact: float, cpu_die_impact: float, cpu_impact: float) -> int:
-        return rd.min_significant_figures(self.die_size.value, core_impact, cpu_die_impact, cpu_impact)
-
     def __compute_impact_manufacture(self, core_impact: ImpactFactor, cpu_die_impact: ImpactFactor,
                                      cpu_impact: ImpactFactor) -> ImpactFactor:
         return ImpactFactor(

boaviztapi/model/component/hdd.py

@@ -29,5 +29,4 @@ def impact_embedded(self, impact_type: str) -> ComputedImpacts:
             max=get_impact_factor(item='hdd', impact_type=impact_type)['impact']
         )
 
-        significant_figures = rd.min_significant_figures(impact.value)
-        return impact.value, significant_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]

boaviztapi/model/component/motherboard.py

@@ -1,4 +1,3 @@
-import boaviztapi.utils.roundit as rd
 from boaviztapi.model.component.component import Component, ComputedImpacts
 from boaviztapi.model.impact import ImpactFactor
 from boaviztapi.service.factor_provider import get_impact_factor
@@ -17,5 +16,4 @@ def impact_embedded(self, impact_type: str) -> ComputedImpacts:
             max=get_impact_factor(item='motherboard', impact_type=impact_type)['impact']
         )
 
-        significant_figures = rd.min_significant_figures(impact.value)
-        return impact.value, significant_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]

boaviztapi/model/component/power_supply.py

@@ -1,4 +1,3 @@
-import boaviztapi.utils.roundit as rd
 from boaviztapi import config
 from boaviztapi.model.boattribute import Boattribute
 from boaviztapi.model.component.component import Component, ComputedImpacts
@@ -28,9 +27,8 @@ def impact_embedded(self, impact_type: str) -> ComputedImpacts:
         )
 
         impact = self.__compute_impact_manufacture(impact_factor)
-        sign_figures = rd.min_significant_figures(impact_factor.value)
 
-        return impact.value, sign_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]
 
     def __compute_impact_manufacture(self, power_supply_impact: ImpactFactor) -> ImpactFactor:
         return ImpactFactor(

boaviztapi/model/component/ram.py

@@ -47,15 +47,13 @@ def __init__(self, archetype=get_component_archetype(config["default_ram"], "ram
         )
         self.usage.avg_power.add_warning("value for one ram strip")
 
-
     # IMPACT COMPUTATION
     def impact_embedded(self, impact_type: str) -> ComputedImpacts:
         ram_die_impact, ram_impact = self.__get_impact_constants(impact_type)
 
         impact = self.__compute_impact_manufacture(ram_die_impact, ram_impact)
 
-        sign_figures = self.__compute_significant_numbers(ram_die_impact.value, ram_impact.value)
-        return impact.value, sign_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]
 
     def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
         impact_factor = self.usage.elec_factors[impact_type]
@@ -77,13 +75,9 @@ def impact_use(self, impact_type: str, duration: float) -> ComputedImpacts:
                     self.usage.avg_power.max / 1000) * self.usage.use_time_ratio.max * duration
         )
 
-        sig_fig = self.__compute_significant_numbers_usage(impact_factor.value)
-        return impact.value, sig_fig, impact.min, impact.max, []
-
-    def __compute_significant_numbers_usage(self, impact_factor: float) -> int:
-        return rd.min_significant_figures(self.usage.avg_power.value, self.usage.use_time_ratio.value, impact_factor)
+        return impact.value, impact.min, impact.max, []
 
-    def model_power_consumption(self,) -> ImpactFactor:
+    def model_power_consumption(self, ) -> ImpactFactor:
         self.usage.consumption_profile = RAMConsumptionProfileModel()
         self.usage.consumption_profile.compute_consumption_profile_model(ram_capacity=self.capacity.value)
 
@@ -95,9 +89,9 @@ def model_power_consumption(self,) -> ImpactFactor:
                 self.usage.consumption_profile.apply_multiple_workloads(self.usage.time_workload.value))
 
         return ImpactFactor(
-                value=rd.round_to_sigfig(self.usage.avg_power.value, 5),
-                min=rd.round_to_sigfig(self.usage.avg_power.value, 5),
-                max=rd.round_to_sigfig(self.usage.avg_power.value, 5)
+            value=rd.round_to_sigfig(self.usage.avg_power.value, 5),
+            min=rd.round_to_sigfig(self.usage.avg_power.value, 5),
+            max=rd.round_to_sigfig(self.usage.avg_power.value, 5)
         )
 
     def __get_impact_constants(self, impact_type: str) -> Tuple[ImpactFactor, ImpactFactor]:
@@ -113,9 +107,6 @@ def __get_impact_constants(self, impact_type: str) -> Tuple[ImpactFactor, Impact
         )
         return ram_die_impact, ram_impact
 
-    def __compute_significant_numbers(self, ram_die_impact: float, ram_impact: float) -> int:
-        return rd.min_significant_figures(self.density.value, ram_die_impact, ram_impact)
-
     def __compute_impact_manufacture(self, ram_die_impact: ImpactFactor, ram_impact: ImpactFactor) -> ImpactFactor:
         return ImpactFactor(
             value=(self.capacity.value / self.density.value) * ram_die_impact.value + ram_impact.value,
@@ -153,4 +144,4 @@ def _complete_density(self):
                 source="Average of " + str(len(sub)) + " rows",
                 min=float(sub['density'].min()),
                 max=float(sub['density'].max())
-            )
+            )

boaviztapi/model/component/ssd.py

@@ -3,7 +3,6 @@
 
 import pandas as pd
 
-import boaviztapi.utils.roundit as rd
 from boaviztapi import config, data_dir
 from boaviztapi.model.boattribute import Boattribute
 from boaviztapi.model.component.component import Component, ComputedImpacts
@@ -52,9 +51,8 @@ def __init__(self, archetype=get_component_archetype(config["default_ssd"], "ssd
     # IMPACT CALCUATION
     def impact_embedded(self, impact_type: str) -> ComputedImpacts:
         ssd_die_impact, ssd_impact = self.__get_impact_constants(impact_type)
-        sign_figures = self.__compute_significant_numbers(ssd_die_impact.value, ssd_impact.value)
         impact = self.__compute_impact_manufacture(ssd_die_impact, ssd_impact)
-        return impact.value, sign_figures, impact.min, impact.max, ["End of life is not included in the calculation"]
+        return impact.value, impact.min, impact.max, ["End of life is not included in the calculation"]
 
 
     def __get_impact_constants(self, impact_type: str) -> Tuple[ImpactFactor, ImpactFactor]:
@@ -70,9 +68,6 @@ def __get_impact_constants(self, impact_type: str) -> Tuple[ImpactFactor, Impact
         )
         return ssd_die_impact, ssd_impact
 
-    def __compute_significant_numbers(self, ssd_die_impact: float, ssd_impact: float) -> int:
-        return rd.min_significant_figures(self.density.value, ssd_die_impact, ssd_impact)
-
     def __compute_impact_manufacture(self, ssd_die_impact: ImpactFactor, ssd_impact: ImpactFactor) -> ImpactFactor:
         return ImpactFactor(
             value=(self.capacity.value / self.density.value) * ssd_die_impact.value + ssd_impact.value,