Update app.py

app.py

@@ -756,156 +756,39 @@ 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}
-}
-
-
-# Коэффициенты электропроводности
-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
-
-# Константы
-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}
-}
-
 class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
         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.actual_profile = {}
+        self.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)
-        self.initial_n_profile = {
-            "NO3-": self.target_profile['N (NO3-)'],
-            "NH4+": self.target_profile['N (NH4+)']
+        # Инициализация весов компенсации
+        self.compensation_weights = {
+            "POTASSIUM_NITRATE": {"weight": 0.5, "fert": "Калий азотнокислый", "main_element": "K"},
+            "CALCIUM_NITRATE": {"weight": 0.3, "fert": "Кальциевая селитра", "main_element": "Ca"},
+            "POTASSIUM_SULFATE": {"weight": 0.2, "fert": "Калий сернокислый", "main_element": "K"}
         }
 
     def _label(self, element):
-        """Форматирование названий элементов для вывода"""
         labels = {
             'N (NO3-)': 'NO3',
             'N (NH4+)': 'NH4'
         }
         return labels.get(element, element)
 
-    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]
+            content = self.fertilizers[fert_name].get(main_element, 0)
+            if content == 0:
+                raise KeyError(f"Элемент {main_element} отсутствует в удобрении {fert_name}")
+
             grams = (required_ppm * self.volume) / (content * 1000)
-            
+
             if fert_name not in self.results:
                 result = {
                     'граммы': 0.0,
@@ -915,226 +798,150 @@ class NutrientCalculator:
                 for element in self.fertilizers[fert_name]:
                     result[f'внесет {self._label(element)}'] = 0.0
                 self.results[fert_name] = result
-                
+
             self.results[fert_name]['граммы'] += grams
-            self.results[fert_name]['миллиграммы'] += int(grams * 1000)
-            
+            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.actual_profile[element] = self.actual_profile.get(element, 0) + added_ppm
+                fert_ec += added_ppm * 0.0015  # Примерный коэффициент EC
+
             self.results[fert_name]['вклад в EC'] += fert_ec
             self.total_ec += fert_ec
         except KeyError as e:
-            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
+            print(f"Ошибка: {str(e)}")
             raise
 
-    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:
+    def _compensate_element(self, element, target_profile):
+        needed = target_profile[element] - self.actual_profile.get(element, 0)
+        if needed <= 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)}")
-            raise
-
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
 
-    def print_report(self):
+        candidates = []
+        for weight_key, weight_data in self.compensation_weights.items():
+            fert_name = weight_data["fert"]
+            if element in self.fertilizers.get(fert_name, {}):
+                candidates.append({
+                    'name': fert_name,
+                    'weight': weight_data["weight"],
+                    'content': self.fertilizers[fert_name][element]
+                })
+
+        if not candidates:
+            raise ValueError(f"Нет удобрений для элемента {element}")
+
+        total_weight = sum(c['weight'] for c in candidates)
+        for candidate in candidates:
+            share = candidate['weight'] / total_weight
+            ppm_to_apply = needed * share
+            self._apply(candidate['name'], element, ppm_to_apply)
+
+    def calculate(self, target_profile):
         try:
-            print("\n" + "="*60)
-            print("ПРОФИЛЬ ПИТАТЕЛЬНОГО РАСТВОРА (ИТОГО):")
-            print("="*60)
-            table = [[el, round(self.actual_profile[el], 1)] for el in self.actual_profile]
-            print(tabulate(table, headers=["Элемент", "ppm"]))
-
-            print("\nИсходный расчёт азота:")
-            for form, val in self.initial_n_profile.items():
-                print(f"  {form}: {round(val, 1)} ppm")
-
-            print("\n" + "="*60)
-            print(f"РАСЧЕТ ДЛЯ {self.volume} ЛИТРОВ РАСТВОРА")
-            print("="*60)
-            print(f"Общая концентрация: {round(sum(self.actual_profile.values()), 1)} ppm")
-            print(f"EC: {self.calculate_ec()} mS/cm")
-
-            print("\nРЕКОМЕНДУЕМЫЕ УДОБРЕНИЯ:")
-            fert_table = []
-            for fert, data in self.results.items():
-                adds = [f"+{k}: {v:.1f} ppm" for k, v in data.items() if k.startswith('внесет')]
-                fert_table.append([
-                    fert,
-                    round(data['граммы'], 3),
-                    data['миллиграммы'],
-                    round(data['вклад в EC'], 3),
-                    "\n".join(adds)
-                ])
-            print(tabulate(fert_table, 
-                         headers=["Удобрение", "Граммы", "Миллиграммы", "EC (мСм/см)", "Добавит"]))
-
-            print("\nОСТАТОЧНЫЙ ДЕФИЦИТ:")
-            deficit = {
-                k: round(self.target_profile[k] - self.actual_profile[k], 1)
-                for k in self.target_profile
-                if abs(self.target_profile[k] - self.actual_profile[k]) > 0.1
-            }
-            if deficit:
-                for el, val in deficit.items():
-                    print(f"  {el}: {val} ppm")
-            else:
-                print("  Все элементы покрыты полностью")
-        except Exception as e:
-            print(f"Ошибка при выводе отчёта: {str(e)}")
-            raise
-
-if __name__ == "__main__":
-    try:
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.calculate()
-        calculator.print_report()  # Правильный вызов метода класса
-    except Exception as e:
-        print(f"Критическая ошибка: {str(e)}")
-
+            # Вносим магний
+            self._apply("Сульфат магния", "Mg", target_profile['Mg'])
 
+            # Вносим кальций через компенсацию
+            self._compensate_element("Ca", target_profile)
 
+            # Вносим фосфор
+            self._apply("Монофосфат калия", "P", target_profile['P'])
 
+            # Вносим аммонийный азот
+            self._apply("Аммоний азотнокислый", "N (NH4+)", target_profile['N (NH4+)'])
 
+            # Компенсируем нитратный азот
+            self._compensate_element("N (NO3-)", target_profile)
 
+            # Компенсируем серу
+            self._compensate_element("S", target_profile)
 
+            # Компенсируем калий
+            self._compensate_element("K", target_profile)
 
+            return self.results
+        except Exception as e:
+            print(f"Ошибка при расчёте: {str(e)}")
+            raise
 
 
-
-from flask import request, jsonify
-
-def round_floats(obj, ndigits=3):
-    """Рекурсивно округляет все float значения в структуре данных"""
-    if isinstance(obj, float):
-        return round(obj, ndigits)
-    elif isinstance(obj, dict):
-        return {k: round_floats(v, ndigits) for k, v in obj.items()}
-    elif isinstance(obj, (list, tuple)):
-        return [round_floats(x, ndigits) for x in obj]
-    return obj
-
+# Роут для обработки расчетов
 @app.route('/calculation', methods=['POST'])
 def handle_calculation():
     try:
         data = request.get_json()
-        
-        # Получаем параметр точности округления (по умолчанию 3)
-        rounding_precision = int(data['profileSettings'].get('rounding_precision', 3))
-        
+
         # Проверка обязательных полей
         if not data or 'fertilizerConstants' not in data or 'profileSettings' not in data:
             return jsonify({'error': 'Неверный формат данных'}), 400
-        
-        # Извлекаем данные из запроса
-        fertilizer_data = data['fertilizerConstants']
-        profile_data = data['profileSettings']
-        
-        # Устанавливаем константы из запроса
-        TOTAL_NITROGEN = float(profile_data.get('TOTAL_NITROG', 125.0))
-        NO3_RATIO = float(profile_data.get('NO3_RAT', 8.25))
-        VOLUME_LITERS = float(profile_data.get('liters', 100))
-        NH4_RATIO = 1.00  # Фиксированное значение
-        
-        # Формируем целевой профиль
-        target_profile = {
-            'P': float(profile_data.get('P', 31.0)),
-            'K': float(profile_data.get('K', 210.0)),
-            'Mg': float(profile_data.get('Mg', 24.0)),
-            'Ca': float(profile_data.get('Ca', 84.0)),
-            'S': float(profile_data.get('S', 56.439)),
-            'N (NO3-)': 0,  # Будет рассчитано в калькуляторе
-            'N (NH4+)': 0   # Будет рассчитано в калькуляторе
-        }
-        
-        # Обновляем константы удобрений
-        NUTRIENT_CONTENT_IN_FERTILIZERS = {
+
+        # Инициализация калькулятора
+        calculator = NutrientCalculator(volume_liters=float(data['profileSettings'].get('liters', 100)))
+
+        # Настройка удобрений из запроса
+        calculator.fertilizers = {
             "Кальциевая селитра": {
-                "N (NO3-)": float(fertilizer_data["Кальциевая селитра"].get("N (NO3-)", 0.11863)),
-                "Ca": float(fertilizer_data["Кальциевая селитра"].get("Ca", 0.16972))
+                "N (NO3-)": float(data['fertilizerConstants']["Кальциевая селитра"].get("N (NO3-)", 0.11863)),
+                "Ca": float(data['fertilizerConstants']["Кальциевая селитра"].get("Ca", 0.16972))
             },
             "Калий азотнокислый": {
-                "N (NO3-)": float(fertilizer_data["Калий азотнокислый"].get("N (NO3-)", 0.13854)),
-                "K": float(fertilizer_data["Калий азотнокислый"].get("K", 0.36672))
+                "N (NO3-)": float(data['fertilizerConstants']["Калий азотнокислый"].get("N (NO3-)", 0.136)),
+                "K": float(data['fertilizerConstants']["Калий азотнокислый"].get("K", 0.382))
             },
             "Аммоний азотнокислый": {
-                "N (NO3-)": float(fertilizer_data["Аммоний азотнокислый"].get("N (NO3-)", 0.17499)),
-                "N (NH4+)": float(fertilizer_data["Аммоний азотнокислый"].get("N (NH4+)", 0.17499))
+                "N (NO3-)": float(data['fertilizerConstants']["Аммоний азотнокислый"].get("N (NO3-)", 0.17499)),
+                "N (NH4+)": float(data['fertilizerConstants']["Аммоний азотнокислый"].get("N (NH4+)", 0.17499))
             },
             "Сульфат магния": {
-                "Mg": float(fertilizer_data["Сульфат магния"].get("Mg", 0.1022)),
-                "S": float(fertilizer_data["Сульфат магния"].get("S", 0.13483))
+                "Mg": float(data['fertilizerConstants']["Сульфат магния"].get("Mg", 0.09861)),
+                "S": float(data['fertilizerConstants']["Сульфат магния"].get("S", 0.13010))
             },
             "Монофосфат калия": {
-                "P": float(fertilizer_data["Монофосфат калия"].get("P", 0.22761)),
-                "K": float(fertilizer_data["Монофосфат калия"].get("K", 0.28731))
+                "P": float(data['fertilizerConstants']["Монофосфат калия"].get("P", 0.218)),
+                "K": float(data['fertilizerConstants']["Монофосфат калия"].get("K", 0.275))
             },
             "Калий сернокислый": {
-                "K": float(fertilizer_data["Калий сернокислый"].get("K", 0.44874)),
-                "S": float(fertilizer_data["Калий сернокислый"].get("S", 0.18401))
+                "K": float(data['fertilizerConstants']["Калий сернокислый"].get("K", 0.44874)),
+                "S": float(data['fertilizerConstants']["Калий сернокислый"].get("S", 0.18401))
             }
         }
-        
-        # Создаем и настраиваем калькулятор
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.target_profile = target_profile
-        calculator.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
-        
-        # Устанавливаем параметры азота
-        calculator.target_profile['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / (NO3_RATIO + NH4_RATIO))
-        calculator.target_profile['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / (NO3_RATIO + NH4_RATIO))
-        
-        # Выполняем расчет
-        results = calculator.calculate()
-        
-        # Формируем ответ
+
+        # Настройка целевого профиля
+        total_n = float(data['profileSettings'].get('TOTAL_NITROGEN', 125.0))
+        no3_ratio = float(data['profileSettings'].get('NO3_RATIO', 8.25))
+        nh4_ratio = 1.0
+
+        target_profile = {
+            'P': float(data['profileSettings'].get('P', 31.0)),
+            'K': float(data['profileSettings'].get('K', 210.0)),
+            'Mg': float(data['profileSettings'].get('Mg', 24.0)),
+            'Ca': float(data['profileSettings'].get('Ca', 84.0)),
+            'S': float(data['profileSettings'].get('S', 56.439)),
+            'N (NO3-)': total_n * (no3_ratio / (no3_ratio + nh4_ratio)),
+            'N (NH4+)': total_n * (nh4_ratio / (no3_ratio + nh4_ratio))
+        }
+
+        # Выполнение расчета
+        results = calculator.calculate(target_profile)
+
+        # Подготовка ответа
         response = {
-            'actual_profile': calculator.actual_profile,
-            'fertilizers': results,
-            'total_ec': calculator.calculate_ec(),
-            'total_ppm': sum(calculator.actual_profile.values()),
-            'nitrogen_ratios': {
-                'NO3_RATIO': NO3_RATIO,
-                'NH4_RATIO': NH4_RATIO,
-                'TOTAL_NITROGEN': TOTAL_NITROGEN
-            }
+            "actual_profile": calculator.actual_profile,
+            "fertilizers": results,
+            "nitrogen_ratios": {
+                "NH4_RATIO": nh4_ratio,
+                "NO3_RATIO": no3_ratio,
+                "TOTAL_NITROGEN": total_n
+            },
+            "total_ec": round(calculator.total_ec, 2),
+            "total_ppm": round(sum(calculator.actual_profile.values()), 3)
         }
-        
-        # Округляем все числовые значения
-        rounded_response = round_floats(response, rounding_precision)
-        
-        # Для миллиграммов применяем целочисленное округление
-        if 'fertilizers' in rounded_response:
-            for fert in rounded_response['fertilizers'].values():
-                if 'миллиграммы' in fert:
-                    fert['миллиграммы'] = int(round(fert['миллиграммы']))
-        
-        return jsonify(rounded_response)
-        
+
+        return jsonify(response)
+
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
@@ -1151,6 +958,8 @@ def handle_calculation():
 
 
 
+
+
         
 
 if __name__ == '__main__':