Update app.py

app.py

@@ -723,6 +723,41 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
 
 
 
+from tabulate import tabulate
+
+# Константы
+TOTAL_NITROGEN = 125.000
+NO3_RATIO = 8.25
+NH4_RATIO = 1.00
+VOLUME_LITERS = 100
+
+# Коэффициенты электропроводности
+EC_COEFFICIENTS = {
+    'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015, 
+    'Ca': 0.0016, 'S': 0.0014, 
+    'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
+}
+
+# Целевые значения
+BASE_PROFILE = {
+    'P': 31.000, 'K': 210.000, 'Mg': 24.000,
+    'Ca': 84.000, 'S': 56.439,
+    'N (NO3-)': 0, 'N (NH4+)': 0
+}
+
+NUTRIENT_CONTENT_IN_FERTILIZERS = {
+    "Кальциевая селитра": {"N (NO3-)": 0.11863, "Ca": 0.16972},
+    "Калий азотнокислый": {"N (NO3-)": 0.136, "K": 0.382},
+    "Калий сернокислый": {"K": 0.44874, "S": 0.18401},
+    "Аммоний азотнокислый": {"N (NO3-)": 0.17499, "N (NH4+)": 0.17499},
+    "Сульфат магния": {"Mg": 0.09861, "S": 0.13010},
+    "Монофосфат калия": {"P": 0.218, "K": 0.275}
+}
+
+
+
+
+
 from tabulate import tabulate
 
 # Константы
@@ -755,15 +790,15 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
 }
 
 class NutrientCalculator:
-    def __init__(self, volume_liters: float = 1.0):
+    def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
-        self.results: Dict[str, Dict[str, Any]] = {}
+        self.results = {}
         self.target_profile = BASE_PROFILE.copy()
         self.actual_profile = {k: 0.0 for k in BASE_PROFILE}
         self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS 
         self.total_ec = 0.0
 
-        # Расчет азота
+        # Расчёт азота
         total_parts = NO3_RATIO + NH4_RATIO
         self.target_profile['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / total_parts)
         self.target_profile['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / total_parts)
@@ -772,101 +807,98 @@ class NutrientCalculator:
             "NH4+": self.target_profile['N (NH4+)']
         }
 
-        # Настройки компенсации по умолчанию
-        self.compensation_weights = {
-            'KNO3': 0.5,  # Вес калийной селитры (0-1)
-            'CaNO3': 0.3, # Вес кальциевой селитры (0-1)
-            'K2SO4': 0.2  # Вес сульфата калия (0-1)
-        }
-
-    def _label(self, element: str) -> str:
+    def _label(self, element):
         """Форматирование названий элементов для вывода"""
         labels = {
             'N (NO3-)': 'NO3',
             'N (NH4+)': 'NH4'
         }
         return labels.get(element, element)
-    def _apply(self, fert_name: str, main_element: str, required_ppm: float):
-        """Применяет удобрение и обновляет профиль"""
+
+    def calculate(self):
+        try:
+            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
+            self._apply("Кальциевая селитра", "Ca", self.target_profile['Ca'])
+            self._apply("Монофосфат калия", "P", self.target_profile['P'])
+            self._apply("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
+            
+            current_no3 = self.actual_profile['N (NO3-)']
+            no3_needed = self.target_profile['N (NO3-)'] - current_no3
+            
+            if no3_needed > 0.1:
+                self._apply("Калий азотнокислый", "N (NO3-)", no3_needed)
+            
+            self._apply_k_sulfate()
+            
+            k_deficit = self.target_profile['K'] - self.actual_profile['K']
+            if k_deficit > 0.1:
+                self._apply("Калий азотнокислый", "K", k_deficit)
+            
+            return self.results
+        except Exception as e:
+            print(f"Ошибка при расчёте: {str(e)}")
+            raise
+
+    def _apply(self, fert_name, main_element, required_ppm):
         if required_ppm <= 0:
             return
-        
+            
         try:
-            # Получаем содержание элемента в удобрении
             content = self.fertilizers[fert_name][main_element]
-        
-            # Рассчитываем граммы удобрения
             grams = (required_ppm * self.volume) / (content * 1000)
-        
-            # Инициализируем запись, если удобрение применяется впервые
+            
             if fert_name not in self.results:
-                self.results[fert_name] = {
+                result = {
                     'граммы': 0.0,
                     'миллиграммы': 0,
                     'вклад в EC': 0.0
                 }
-                # Добавляем поля для каждого элемента в удобрении
                 for element in self.fertilizers[fert_name]:
-                    self.results[fert_name][f'внесет {self._label(element)}'] = 0.0
-        
-            # Обновляем результаты
+                    result[f'внесет {self._label(element)}'] = 0.0
+                self.results[fert_name] = result
+                
             self.results[fert_name]['граммы'] += grams
-            self.results[fert_name]['миллиграммы'] = int(grams * 1000)
-        
-            # Рассчитываем вклад в EC и обновляем профиль
+            self.results[fert_name]['миллиграммы'] += int(grams * 1000)
+            
             fert_ec = 0.0
             for element, percent in self.fertilizers[fert_name].items():
                 added_ppm = (grams * percent * 1000) / self.volume
                 self.results[fert_name][f'внесет {self._label(element)}'] += added_ppm
                 self.actual_profile[element] += added_ppm
                 fert_ec += added_ppm * EC_COEFFICIENTS.get(element, 0.0015)
-        
+                
             self.results[fert_name]['вклад в EC'] += fert_ec
             self.total_ec += fert_ec
-        
         except KeyError as e:
             print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
             raise
-    def set_compensation_weights(self, kno3_weight: float, cano3_weight: float, k2so4_weight: float):
-        """Установка весов для компенсации элементов"""
-        total = kno3_weight + cano3_weight + k2so4_weight
-        self.compensation_weights = {
-            'KNO3': kno3_weight / total,
-            'CaNO3': cano3_weight / total,
-            'K2SO4': k2so4_weight / total
-            }
 
-    def calculate(self) -> Dict[str, Any]:
-        """Основной метод расчета с новой логикой"""
-        try:
-            # 1. Вносим Mg и S
-            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
-            
-            # 2. Балансируем азот с учетом компенсации
-            self._balance_nitrogen_with_compensation()
-            
-            # 3. Вносим Ca (остаток)
-            ca_needed = self.target_profile['Ca'] - self.actual_profile['Ca']
-            if ca_needed > 0.1:
-                self._apply("Кальциевая селитра", "Ca", ca_needed)
-            
-            # 4. Вносим P
-            p_needed = self.target_profile['P'] - self.actual_profile['P']
-            if p_needed > 0.1:
-                self._apply("Монофосфат калия", "P", p_needed)
-            
-            # 5. Корректируем K через сульфат калия (если остался дефицит)
-            k_needed = self.target_profile['K'] - self.actual_profile['K']
-            if k_needed > 0.1:
-                self._apply("Калий сернокислый", "K", k_needed)
-            
-            return self.results
+    def _apply_k_sulfate(self):
+        fert = "Калий сернокислый"
+        k_def = self.target_profile['K'] - self.actual_profile['K']
+        s_def = self.target_profile['S'] - self.actual_profile['S']
+        
+        if k_def <= 0 and s_def <= 0:
+            return
             
+        try:
+            if s_def > 0.1:
+                s_content = self.fertilizers[fert]["S"]
+                grams_s = (s_def * self.volume) / (s_content * 1000)
+                
+                k_content = self.fertilizers[fert]["K"]
+                k_from_s = (grams_s * k_content * 1000) / self.volume
+                
+                if k_from_s > k_def and k_def > 0.1:
+                    grams = (k_def * self.volume) / (k_content * 1000)
+                else:
+                    grams = grams_s
+                    
+                self._apply(fert, "S", s_def)
         except Exception as e:
-            print(f"Ошибка при расчёте: {str(e)}")
+            print(f"Ошибка при расчёте сульфата калия: {str(e)}")
             raise
 
-
     def calculate_ec(self):
         return round(self.total_ec, 2)
 
@@ -927,7 +959,17 @@ if __name__ == "__main__":
 
 
 
-def round_floats(obj: Union[float, Dict, List], ndigits: int = 3) -> Union[float, Dict, List]:
+
+
+
+
+
+
+
+
+from flask import request, jsonify
+
+def round_floats(obj, ndigits=3):
     """Рекурсивно округляет все float значения в структуре данных"""
     if isinstance(obj, float):
         return round(obj, ndigits)
@@ -937,7 +979,6 @@ def round_floats(obj: Union[float, Dict, List], ndigits: int = 3) -> Union[float
         return [round_floats(x, ndigits) for x in obj]
     return obj
 
-        
 @app.route('/calculation', methods=['POST'])
 def handle_calculation():
     try:
@@ -1031,7 +1072,7 @@ def handle_calculation():
         if 'fertilizers' in rounded_response:
             for fert in rounded_response['fertilizers'].values():
                 if 'миллиграммы' in fert:
-                    fert['миллиграммы'] = int(round(fert['граммы'] * 1000))
+                    fert['миллиграммы'] = int(round(fert['миллиграммы']))
         
         return jsonify(rounded_response)