Update app.py

app.py

@@ -680,340 +680,165 @@ def view_image():
 def nutri_call():
     return render_template('nutri_call.html')
 
-# Константы
-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.target_profile = {}
+        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+)']
-        }
+    def set_target_profile(self, profile):
+        """Устанавливаем целевой профиль извне"""
+        self.target_profile = profile.copy()
+        self.actual_profile = {k: 0.0 for k in profile}
 
-    def _label(self, element):
-        """Форматирование названий элементов для вывода"""
-        labels = {
-            'N (NO3-)': 'NO3',
-            'N (NH4+)': 'NH4'
-        }
-        return labels.get(element, element)
+    def set_fertilizers(self, fertilizers):
+        """Устанавливаем состав удобрений извне"""
+        self.fertilizers = fertilizers
 
     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
+            # Расчёт по порядку внесения удобрений
+            self._apply_fertilizer("Сульфат магния", "Mg")
+            self._apply_fertilizer("Кальциевая селитра", "Ca")
+            self._apply_fertilizer("Монофосфат калия", "P")
+            self._apply_fertilizer("Аммоний азотнокислый", "N (NH4+)")
             
+            # Довносим NO3 если нужно
+            no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile['N (NO3-)']
             if no3_needed > 0.1:
-                self._apply("Калий азотнокислый", "N (NO3-)", no3_needed)
+                self._apply_fertilizer("Калий азотнокислый", "N (NO3-)", no3_needed)
             
-            self._apply_k_sulfate()
+            # Довносим калий если нужно
+            k_needed = self.target_profile['K'] - self.actual_profile['K']
+            if k_needed > 0.1:
+                self._apply_fertilizer("Калий азотнокислый", "K", k_needed)
             
-            k_deficit = self.target_profile['K'] - self.actual_profile['K']
-            if k_deficit > 0.1:
-                self._apply("Калий азотнокислый", "K", k_deficit)
+            # Довносим серу если нужно
+            s_needed = self.target_profile['S'] - self.actual_profile['S']
+            if s_needed > 0.1:
+                self._apply_fertilizer("Калий сернокислый", "S", s_needed)
             
-            return self.results
+            return True
         except Exception as e:
-            print(f"Ошибка при расчёте: {str(e)}")
-            raise
+            print(f"Calculation error: {str(e)}")
+            return False
 
-    def _apply(self, fert_name, main_element, required_ppm):
-        if required_ppm <= 0:
+    def _apply_fertilizer(self, name, element, required_ppm=None):
+        """Универсальный метод внесения удобрений"""
+        if name not in self.fertilizers:
             return
-            
-        try:
-            content = self.fertilizers[fert_name][main_element]
-            grams = (required_ppm * self.volume) / (content * 1000)
-            
-            if fert_name not in self.results:
-                result = {
-                    'граммы': 0.0,
-                    'миллиграммы': 0,
-                    'вклад в EC': 0.0
-                }
-                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)
-            
-            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 _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 required_ppm is None:
+            required_ppm = self.target_profile[element] - self.actual_profile[element]
         
-        if k_def <= 0 and s_def <= 0:
+        if required_ppm <= 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):
-        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
+        content = self.fertilizers[name].get(element, 0)
+        if content == 0:
+            return
 
-    # Данные на страницу
+        grams = (required_ppm * self.volume) / (content * 1000)
+        
+        # Записываем результаты
+        if name not in self.results:
+            self.results[name] = {'grams': 0.0, 'adds': {}}
+        
+        self.results[name]['grams'] += grams
+        
+        # Обновляем фактические концентрации
+        for nutrient, percent in self.fertilizers[name].items():
+            added_ppm = (grams * percent * 1000) / self.volume
+            self.actual_profile[nutrient] = self.actual_profile.get(nutrient, 0) + added_ppm
+            self.results[name]['adds'][nutrient] = self.results[name]['adds'].get(nutrient, 0) + added_ppm
+        
+        # Расчёт EC
+        self.total_ec += sum(
+            added_ppm * 0.0015  # Упрощённый коэффициент
+            for nutrient, added_ppm in self.results[name]['adds'].items()
+        )
 
-    def get_web_results(self):
-        """Возвращает данные в формате для web-интерфейса"""
+    def get_results(self):
+        """Возвращаем результаты в стандартном формате"""
         return {
-            'fertilizers': self._format_fertilizers(),
-            'profile': self._format_profile(),
-            'ec': self.calculate_ec(),
-            'deficits': self.calculate_deficits()
-        }
-
-    def _format_fertilizers(self):
-        formatted = []
-        for name, data in self.results.items():
-            fert = {
-                'name': name,
-                'grams': round(data['граммы'], 3),
-                'adds': {}
+            'fertilizers': [
+                {
+                    'name': name,
+                    'grams': round(data['grams'], 3),
+                    'adds': {k: round(v, 3) for k, v in data['adds'].items()}
+                } 
+                for name, data in self.results.items()
+            ],
+            'profile': [
+                {
+                    'element': k.replace(' (NO3-)', '-NO3').replace(' (NH4+)', '-NH4'),
+                    'ppm': round(v, 3)
+                }
+                for k, v in self.actual_profile.items()
+            ],
+            'ec': round(self.total_ec, 2),
+            'deficits': {
+                k: max(self.target_profile[k] - self.actual_profile.get(k, 0), 0)
+                for k in self.target_profile
             }
-            for k, v in data.items():
-                if k.startswith('внесет'):
-                    fert['adds'][k.replace('внесет ', '')] = round(v, 1)
-            formatted.append(fert)
-        return formatted
-
-    def _format_profile(self):
-        return [{'element': k, 'ppm': round(v, 1)} 
-                for k, v in self.actual_profile.items()]
-    def calculate_deficits(self):
-        """Вычисляет остаточные дефициты элементов"""
-        return {
-            k: max(self.target_profile[k] - self.actual_profile[k], 0)
-            for k in self.target_profile
-        }
-
-    def get_web_results(self):
-        """Возвращает данные в формате для web-интерфейса"""
-        return {
-            'fertilizers': self._format_fertilizers(),
-            'profile': self._format_profile(),
-            'ec': self.calculate_ec(),
-            'deficits': self.calculate_deficits(),
-            'volume': self.volume
         }
 
-    def _format_fertilizers(self):
-        formatted = []
-        for name, data in self.results.items():
-            fert = {
-                'name': name,
-                'grams': round(data['граммы'], 3),
-                'adds': {}
-            }
-            for k, v in data.items():
-                if k.startswith('внесет'):
-                    fert['adds'][k.replace('внесет ', '')] = round(v, 1)
-            formatted.append(fert)
-        return formatted
-
-    def _format_profile(self):
-        return [{'element': k.replace(' (NO3-)', '-NO3').replace(' (NH4+)', '-NH4'), 
-                'ppm': round(v, 1)} 
-               for k, v in self.actual_profile.items()]
-
-# Функции для преобразования данных от клиента
-FERTILIZER_NAME_MAP = {
-    "CaN2O6": "Кальциевая селитра",
-    "KNO3": "Калий азотнокислый",
-    "K2SO4": "Калий сернокислый",
-    "NH4NO3": "Аммоний азотнокислый",
-    "MgSO4": "Сульфат магния",
-    "KH2PO4": "Монофосфат калия"
-}
-
-NUTRIENT_MAP = {
-    "NO3": "N (NO3-)",
-    "NH4": "N (NH4+)"
-}
-
-def convert_client_data(client_data):
-    """Преобразует данные от клиента в серверный формат"""
-    server_format = {}
-    for chem_form, nutrients in client_data.items():
-        fert_name = FERTILIZER_NAME_MAP.get(chem_form, chem_form)
-        server_format[fert_name] = {}
-        
-        for element, value in nutrients.items():
-            server_element = NUTRIENT_MAP.get(element, element)
-            server_format[fert_name][server_element] = value
-            
-    return server_format
-
-if __name__ == "__main__":
-    try:
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.calculate()
-        calculator.print_report()  # Правильный вызов метода класса
-    except Exception as e:
-        print(f"Критическая ошибка: {str(e)}")
-
-
-
-
-
-
-
-
 @app.route('/calculation', methods=['POST'])
 def handle_calculation():
     try:
-        raw_data = request.json
-        print("\n=== ПРИНЯТЫЕ ДАННЫЕ ===")
-        print(raw_data)
-
-        # 1. Извлекаем значения азота из запроса
-        no3 = float(raw_data['profileSettings'].get('N (NO3-)', 0))
-        nh4 = float(raw_data['profileSettings'].get('N (NH4+)', 0))
-        liters = int(raw_data['profileSettings'].get('liters', VOLUME_LITERS))
-
-        # 2. Создаём калькулятор с РУЧНОЙ установкой азота
-        calculator = NutrientCalculator(volume_liters=liters)
+        data = request.json
+        
+        # Создаём калькулятор
+        calculator = NutrientCalculator(volume_liters=data['profileSettings']['liters'])
         
-        # 3. ПЕРЕЗАПИСЫВАЕМ расчёт азота (главное исправление!)
-        calculator.target_profile.update({
-            'N (NO3-)': no3,
-            'N (NH4+)': nh4
+        # Настраиваем профиль
+        calculator.set_target_profile({
+            'P': float(data['profileSettings']['P']),
+            'K': float(data['profileSettings']['K']),
+            'Mg': float(data['profileSettings']['Mg']),
+            'Ca': float(data['profileSettings']['Ca']),
+            'S': float(data['profileSettings']['S']),
+            'N (NO3-)': float(data['profileSettings']['N (NO3-)']),
+            'N (NH4+)': float(data['profileSettings']['N (NH4+)'])
         })
-
-        # 4. Устанавливаем кастомные удобрения
-        calculator.fertilizers = convert_client_data(raw_data['fertilizerConstants'])
         
-        # 5. Запускаем расчёт
-        calculator.calculate()
+        # Настраиваем удобрения
+        calculator.set_fertilizers({
+            "Кальциевая селитра": {
+                "N (NO3-)": float(data['fertilizerConstants']['CaN2O6']['NO3']) / 100,
+                "Ca": float(data['fertilizerConstants']['CaN2O6']['Ca']) / 100
+            },
+            # ... остальные удобрения аналогично
+        })
         
-        return jsonify(calculator.get_web_results())
-
+        # Выполняем расчёт
+        if calculator.calculate():
+            return jsonify({
+                'status': 'success',
+                'data': calculator.get_results()
+            })
+        else:
+            return jsonify({
+                'status': 'error',
+                'message': 'Calculation failed'
+            }), 500
+            
     except Exception as e:
-        print(f"Ошибка: {str(e)}")
-        return jsonify({"error": str(e)}), 500
-
-
-
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 400