artemiy/help_lab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Добавлена функция передачи данных калькулятора в расчёт полнофакторного анализа

Browse Source
This commit is contained in:
Артемий Колобов
2026-05-07 15:02:28 +05:00
parent e3fbaceb24
commit e6e86e50a3
17 changed files with 1540 additions and 553 deletions
Download Patch File Download Diff File Expand all files Collapse all files
patch.sh
+265 -551
View File
@@ -6,366 +6,20 @@ GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
echo -e "${GREEN}=== Реорганизация программы Цифровой помощник биохимика ===${NC}"
echo -e "${GREEN}=== Обновление программы: добавление передачи данных в DoE ===${NC}"
# Создаём бэкап текущей версии
# Создаём бэкап
BACKUP_DIR="backup_$(date +%Y%m%d_%H%M%S)"
echo -e "${YELLOW}Создание бэкапа в $BACKUP_DIR...${NC}"
mkdir -p "$BACKUP_DIR"
cp *.py "$BACKUP_DIR/" 2>/dev/null
echo -e "${GREEN}✓ Бэкап создан${NC}"
cp -r src "$BACKUP_DIR/" 2>/dev/null
echo -e "${GREEN}✓ Бэкап создан в $BACKUP_DIR${NC}"
# Создаём структуру папок
echo -e "${YELLOW}Создание структуры проекта...${NC}"
mkdir -p src/models
mkdir -p src/views
mkdir -p src/controllers
mkdir -p src/utils
# Файл: src/models/reagent.py
cat > src/models/reagent.py << 'EOF'
class Reagent:
def __init__(self, name: str, percentage: float, unit: str, conversion_factor: float = 1.0):
self.name = name
self.percentage = percentage
self.unit = unit
self.conversion_factor = conversion_factor
self.dilution_factor = 1.0
def __repr__(self):
return f"Reagent(name={self.name}, percentage={self.percentage}, unit={self.unit})"
EOF
# Файл: src/models/__init__.py
cat > src/models/__init__.py << 'EOF'
from .reagent import Reagent
from .medium_model import MediumModel
from .experiment_model import ExperimentModel
__all__ = ['Reagent', 'MediumModel', 'ExperimentModel']
EOF
# Файл: src/models/medium_model.py
cat > src/models/medium_model.py << 'EOF'
import json
from typing import List, Tuple
from .reagent import Reagent
VOLUME_UNITS = {
'нл': 0.001, 'мкл': 1.0, 'мл': 1000.0, 'л': 1000000.0
}
MASS_UNITS = {
'нг': 0.000001, 'мкг': 0.001, 'мг': 1.0, 'г': 1000.0, 'кг': 1000000.0
}
class MediumModel:
def __init__(self):
self.total_amount = 100.0
self.amount_unit = 'мл'
self.solvent = 'Вода'
self.reagents = []
def convert_amount(self, amount_base: float, target_unit: str, is_volume: bool) -> float:
if is_volume:
conversion_factor = VOLUME_UNITS.get(target_unit, 1.0)
else:
conversion_factor = MASS_UNITS.get(target_unit, 1.0)
return amount_base / conversion_factor
def calculate_amounts(self) -> Tuple[List[float], float, float]:
results = []
if not self.reagents:
return results, self.total_amount, 100.0
total_percentage = sum(r.percentage for r in self.reagents)
if total_percentage > 100:
raise ValueError(f"Сумма процентов реагентов ({total_percentage:.2f}%) превышает 100%")
total_in_base = self.total_amount * VOLUME_UNITS[self.amount_unit]
undiluted_amounts = []
for reagent in self.reagents:
amount_in_base = (reagent.percentage / 100) * total_in_base
is_volume = reagent.unit in VOLUME_UNITS
adjusted_amount = amount_in_base * reagent.conversion_factor
final_amount = self.convert_amount(adjusted_amount, reagent.unit, is_volume)
undiluted_amounts.append(final_amount)
diluted_amounts = []
total_diluted_volume_base = 0
for i, reagent in enumerate(self.reagents):
dilution_factor = getattr(reagent, 'dilution_factor', 1.0)
if dilution_factor <= 0:
dilution_factor = 1.0
diluted_amount = undiluted_amounts[i] * dilution_factor
diluted_amounts.append(diluted_amount)
is_volume = reagent.unit in VOLUME_UNITS
if is_volume:
reagent_volume_base = diluted_amount * VOLUME_UNITS[reagent.unit]
else:
reagent_volume_base = 0
total_diluted_volume_base += reagent_volume_base
solvent_volume_base = total_in_base - total_diluted_volume_base
solvent_amount = solvent_volume_base / VOLUME_UNITS[self.amount_unit]
if solvent_amount < 0:
solvent_amount = 0
solvent_percentage = 100 - total_percentage
return diluted_amounts, solvent_amount, solvent_percentage
def save_to_file(self, filename: str):
data = {
'total_amount': self.total_amount,
'amount_unit': self.amount_unit,
'solvent': self.solvent,
'reagents': [{'name': r.name, 'percentage': r.percentage, 'unit': r.unit,
'conversion_factor': r.conversion_factor, 'dilution_factor': getattr(r, 'dilution_factor', 1.0)}
for r in self.reagents]
}
with open(filename, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=4)
def load_from_file(self, filename: str):
with open(filename, 'r', encoding='utf-8') as f:
data = json.load(f)
self.total_amount = data['total_amount']
self.amount_unit = data['amount_unit']
self.solvent = data['solvent']
self.reagents.clear()
for r_data in data['reagents']:
reagent = Reagent(r_data['name'], r_data['percentage'], r_data['unit'], r_data.get('conversion_factor', 1.0))
reagent.dilution_factor = r_data.get('dilution_factor', 1.0)
self.reagents.append(reagent)
def add_reagent(self, name: str, percentage: float, unit: str, conversion_factor: float = 1.0, dilution_factor: float = 1.0):
reagent = Reagent(name, percentage, unit, conversion_factor)
reagent.dilution_factor = dilution_factor
self.reagents.append(reagent)
def remove_reagent(self, index: int):
if 0 <= index < len(self.reagents):
del self.reagents[index]
def clear_reagents(self):
self.reagents.clear()
def get_reagent_count(self) -> int:
return len(self.reagents)
def set_total_amount(self, amount: float, unit: str):
self.total_amount = amount
self.amount_unit = unit
def set_solvent(self, solvent_name: str):
self.solvent = solvent_name
EOF
# Файл: src/models/experiment_model.py
cat > src/models/experiment_model.py << 'EOF'
import numpy as np
from typing import List, Dict, Any
class ExperimentModel:
def __init__(self):
self.factors = []
self.responses = []
self.center_points = 3
self.randomize = True
def set_factors(self, factors: List[Dict]):
self.factors = factors
def set_responses(self, responses: List[Dict]):
self.responses = responses
def set_center_points(self, n: int):
self.center_points = n
def set_randomize(self, value: bool):
self.randomize = value
def calculate_factorial_design(self) -> List[Dict]:
k = len(self.factors)
if k == 0:
return []
n_factorial = 2 ** k
design = []
for i in range(n_factorial):
experiment = {}
for j in range(k):
coded_level = -1 if (i >> (k - 1 - j)) & 1 == 0 else 1
natural_value = self.factors[j]['low'] if coded_level == -1 else self.factors[j]['high']
experiment[f"Фактор_{j+1}"] = {
'coded': coded_level,
'natural': natural_value,
'name': self.factors[j]['name'],
'unit': self.factors[j]['unit']
}
design.append(experiment)
for i in range(self.center_points):
center_experiment = {}
for j in range(k):
center_experiment[f"Фактор_{j+1}"] = {
'coded': 0,
'natural': self.factors[j]['center'],
'name': self.factors[j]['name'],
'unit': self.factors[j]['unit']
}
center_experiment['is_center'] = True
center_experiment['center_num'] = i + 1
design.append(center_experiment)
if self.randomize:
import random
random.shuffle(design)
return design
def analyze_results(self, results: List[List[float]], design: List[Dict]) -> Dict:
analysis = {}
for resp_idx, response in enumerate(self.responses):
resp_name = response.get('name', f'Отклик_{resp_idx+1}')
y_values = [results[i][resp_idx] for i in range(len(results))]
mean_y = np.mean(y_values)
variance = np.var(y_values, ddof=1) if len(y_values) > 1 else 0
std_dev = np.std(y_values, ddof=1) if len(y_values) > 1 else 0
cv = (std_dev / mean_y) * 100 if mean_y != 0 else 0
factorial_y = []
center_y = []
for i, exp in enumerate(design):
if exp.get('is_center', False):
center_y.append(y_values[i])
else:
factorial_y.append(y_values[i])
center_variance = np.var(center_y, ddof=1) if len(center_y) > 1 else 0
analysis[resp_name] = {
'mean': mean_y, 'variance': variance, 'std_dev': std_dev, 'cv': cv,
'factorial_values': factorial_y, 'center_values': center_y, 'center_variance': center_variance,
'n_factorial': len(factorial_y), 'n_center': len(center_y)
}
return analysis
EOF
# Файл: src/views/__init__.py
cat > src/views/__init__.py << 'EOF'
from .main_window import MainWindow
from .medium_view import MediumCalculatorWindow
from .experiment_view import ExperimentDesignWindow
__all__ = ['MainWindow', 'MediumCalculatorWindow', 'ExperimentDesignWindow']
EOF
# Файл: src/views/main_window.py
cat > src/views/main_window.py << 'EOF'
from PyQt5.QtWidgets import (QMainWindow, QVBoxLayout, QHBoxLayout, QPushButton, QLabel, QWidget, QFrame)
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QFont
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Цифровой помощник биохимика - Главное меню")
self.setGeometry(300, 200, 700, 500)
self.setStyleSheet("""
QMainWindow { background-color: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #e8f4f8, stop:1 #f0f0f0); }
QPushButton { background-color: #2196F3; color: white; border: none; padding: 15px; font-size: 16px; font-weight: bold; border-radius: 8px; }
QPushButton:hover { background-color: #1976D2; }
QLabel { color: #333; font-size: 14px; }
""")
self._init_ui()
self.medium_calculator = None
self.experiment_window = None
def _init_ui(self):
central_widget = QWidget()
self.setCentralWidget(central_widget)
layout = QVBoxLayout(central_widget)
layout.setSpacing(20)
layout.setContentsMargins(50, 50, 50, 50)
title_label = QLabel("Цифровой помощник биохимика")
title_font = QFont()
title_font.setPointSize(20)
title_font.setBold(True)
title_label.setFont(title_font)
title_label.setAlignment(Qt.AlignCenter)
title_label.setStyleSheet("color: #1565C0;")
layout.addWidget(title_label)
subtitle_label = QLabel("Биотехнологические инструменты для лаборатории")
subtitle_font = QFont()
subtitle_font.setPointSize(12)
subtitle_label.setFont(subtitle_font)
subtitle_label.setAlignment(Qt.AlignCenter)
subtitle_label.setStyleSheet("color: #666;")
layout.addWidget(subtitle_label)
layout.addSpacing(20)
btn_medium = QPushButton("🧪 Калькулятор питательных сред")
btn_medium.setMinimumHeight(80)
btn_medium.clicked.connect(self.open_medium_calculator)
layout.addWidget(btn_medium)
desc1_label = QLabel("Расчёт состава питательной среды с учётом процентного содержания,\nразбавления реагентов и автоматическим расчётом растворителя")
desc1_label.setAlignment(Qt.AlignCenter)
desc1_label.setWordWrap(True)
desc1_label.setStyleSheet("color: #555; font-size: 11px;")
layout.addWidget(desc1_label)
layout.addSpacing(15)
btn_experiment = QPushButton("📊 Планирование эксперимента (DoE)")
btn_experiment.setMinimumHeight(80)
btn_experiment.clicked.connect(self.open_experiment_designer)
layout.addWidget(btn_experiment)
desc2_label = QLabel("Дизайн эксперимента, оптимизация процессов,\nмногомерный анализ и визуализация")
desc2_label.setAlignment(Qt.AlignCenter)
desc2_label.setWordWrap(True)
desc2_label.setStyleSheet("color: #555; font-size: 11px;")
layout.addWidget(desc2_label)
layout.addSpacing(15)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout.addWidget(line)
bottom_layout = QHBoxLayout()
version_label = QLabel("Версия 1.0.0 | © 2026 Цифровой помощник биохимика")
version_label.setStyleSheet("color: #999; font-size: 10px;")
bottom_layout.addWidget(version_label)
bottom_layout.addStretch()
btn_exit = QPushButton("Выход")
btn_exit.setMaximumWidth(150)
btn_exit.setStyleSheet("QPushButton { background-color: #f44336; padding: 8px; font-size: 14px; } QPushButton:hover { background-color: #da190b; }")
btn_exit.clicked.connect(self.close)
bottom_layout.addWidget(btn_exit)
layout.addLayout(bottom_layout)
def open_medium_calculator(self):
from .medium_view import MediumCalculatorWindow
from ..controllers.medium_controller import MediumController
self.medium_calculator = MediumCalculatorWindow()
self.medium_controller = MediumController(self.medium_calculator)
self.medium_calculator.show()
def open_experiment_designer(self):
from .experiment_view import ExperimentDesignWindow
from ..controllers.experiment_controller import ExperimentController
self.experiment_window = ExperimentDesignWindow()
self.experiment_controller = ExperimentController(self.experiment_window)
self.experiment_window.show()
EOF
# Файл: src/views/medium_view.py
# Обновляем medium_view.py - добавляем кнопку
cat > src/views/medium_view.py << 'EOF'
from PyQt5.QtWidgets import (QMainWindow, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem,
QPushButton, QLabel, QDoubleSpinBox, QComboBox, QLineEdit, QWidget,
QMessageBox, QGroupBox, QFrame)
from PyQt5.QtCore import Qt
QMessageBox, QGroupBox, QFrame, QToolTip)
from PyQt5.QtCore import Qt, QPoint
from PyQt5.QtGui import QFont, QColor
class MediumCalculatorWindow(QMainWindow):
@@ -380,11 +34,16 @@ class MediumCalculatorWindow(QMainWindow):
QPushButton { background-color: #2196F3; color: white; border: none; padding: 8px 15px; border-radius: 4px; font-weight: bold; }
QPushButton:hover { background-color: #1976D2; }
QPushButton#danger { background-color: #f44336; }
QPushButton#danger:hover { background-color: #da190b; }
QPushButton#success { background-color: #4CAF50; }
QPushButton#success:hover { background-color: #45a049; }
QPushButton#doe { background-color: #9C27B0; }
QPushButton#doe:hover { background-color: #7B1FA2; }
QTableWidget { gridline-color: #ddd; background-color: white; }
QHeaderView::section { background-color: #1565C0; color: white; padding: 8px; font-weight: bold; }
""")
self._init_ui()
self.doe_window = None
def _init_ui(self):
central_widget = QWidget()
@@ -452,6 +111,14 @@ class MediumCalculatorWindow(QMainWindow):
self.calculate_btn.setObjectName("success")
self.save_btn = QPushButton("💾 Сохранить")
self.load_btn = QPushButton("📂 Загрузить")
# Новая кнопка для передачи в DoE
self.to_doe_btn = QPushButton("🎯 В DoE")
self.to_doe_btn.setObjectName("doe")
self.to_doe_btn.setToolTip("Передать состав реагентов в планировщик эксперимента\n"
"Реагенты станут факторами, их концентрации — нулевыми уровнями")
btn_layout.addWidget(self.to_doe_btn)
btn_layout.addWidget(self.calculate_btn)
btn_layout.addWidget(self.save_btn)
btn_layout.addWidget(self.load_btn)
@@ -516,6 +183,34 @@ class MediumCalculatorWindow(QMainWindow):
if row > 0:
self.table.removeRow(row)
def get_reagents_data(self):
"""Возвращает список реагентов для передачи в DoE"""
reagents = []
for row in range(1, self.table.rowCount()):
name_item = self.table.item(row, 0)
percent_item = self.table.item(row, 1)
unit_widget = self.table.cellWidget(row, 2)
coeff_item = self.table.item(row, 3)
if not all([name_item, percent_item]):
continue
try:
name = name_item.text()
percentage = float(percent_item.text())
unit = unit_widget.currentText() if unit_widget else "мг"
conversion_factor = float(coeff_item.text()) if coeff_item else 1.0
reagents.append({
'name': name,
'percentage': percentage,
'unit': unit,
'conversion_factor': conversion_factor
})
except ValueError:
continue
return reagents
def get_table_data(self):
data = []
for row in range(1, self.table.rowCount()):
@@ -569,9 +264,159 @@ class MediumCalculatorWindow(QMainWindow):
def show_error(self, message: str):
QMessageBox.critical(self, "Ошибка", message)
def show_info(self, message: str):
QMessageBox.information(self, "Информация", message)
EOF
# Файл: src/views/experiment_view.py (полная версия)
# Обновляем medium_controller.py - добавляем метод передачи в DoE
cat > src/controllers/medium_controller.py << 'EOF'
from PyQt5.QtWidgets import QFileDialog, QMessageBox, QTableWidgetItem, QComboBox
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QColor
import json
from ..models.medium_model import MediumModel
from ..models.reagent import Reagent
from ..views.experiment_view import ExperimentDesignWindow
class MediumController:
def __init__(self, view):
self.model = MediumModel()
self.view = view
self.doe_window = None
self._connect_signals()
self._setup_initial_data()
def _connect_signals(self):
self.view.add_row_btn.clicked.connect(self.add_reagent_row)
self.view.remove_row_btn.clicked.connect(self.remove_reagent_row)
self.view.calculate_btn.clicked.connect(self._perform_calculation)
self.view.save_btn.clicked.connect(self.save_composition)
self.view.load_btn.clicked.connect(self.load_composition)
self.view.to_doe_btn.clicked.connect(self.send_to_doe)
self.view.solvent_input.textChanged.connect(self.view.update_solvent_name)
def _setup_initial_data(self):
self.view.add_initial_rows()
def add_reagent_row(self):
self.view.add_new_row()
def remove_reagent_row(self):
self.view.remove_selected_row()
def _perform_calculation(self):
try:
self._update_model_from_view()
results, solvent_amount, solvent_percentage = self.model.calculate_amounts()
self.view.update_results(results)
self.view.update_solvent_result(solvent_amount, self.model.amount_unit)
self.view.update_solvent_percent(solvent_percentage)
except ValueError as e:
self.view.show_error(f"Ошибка в данных: {str(e)}")
except Exception as e:
self.view.show_error(f"Неожиданная ошибка: {str(e)}")
def _update_model_from_view(self):
self.model.reagents.clear()
self.model.total_amount = self.view.amount_input.value()
self.model.amount_unit = self.view.amount_unit_combo.currentText()
self.model.solvent = self.view.solvent_input.text()
for row in range(1, self.view.table.rowCount()):
name_item = self.view.table.item(row, 0)
percentage_item = self.view.table.item(row, 1)
unit_widget = self.view.table.cellWidget(row, 2)
conversion_item = self.view.table.item(row, 3)
dilution_item = self.view.table.item(row, 4)
if not all([name_item, percentage_item, conversion_item]):
continue
try:
name = name_item.text()
percentage = float(percentage_item.text())
unit = unit_widget.currentText() if unit_widget else "мг"
conversion_factor = float(conversion_item.text())
dilution_factor = float(dilution_item.text()) if dilution_item else 1.0
reagent = Reagent(name, percentage, unit, conversion_factor)
reagent.dilution_factor = dilution_factor
self.model.reagents.append(reagent)
except ValueError as e:
raise ValueError(f"Ошибка в строке {row + 1}: {str(e)}")
def send_to_doe(self):
"""Передаёт данные о реагентах в окно планирования эксперимента"""
reagents = self.view.get_reagents_data()
if len(reagents) == 0:
self.view.show_error("Нет реагентов для передачи в планировщик эксперимента!")
return
# Создаём или показываем существующее окно DoE
if self.doe_window is None:
self.doe_window = ExperimentDesignWindow()
# Передаём данные в окно DoE
self.doe_window.load_factors_from_reagents(reagents)
self.doe_window.show()
self.doe_window.raise_()
self.doe_window.activateWindow()
self.view.show_info(f"Передано {len(reagents)} реагентов в планировщик эксперимента\n"
f"Каждый реагент добавлен как фактор.\n"
f"Его концентрация (%) установлена как нулевой уровень.")
def save_composition(self):
filename, _ = QFileDialog.getSaveFileName(self.view, "Сохранить состав среды", "", "JSON Files (*.json);;All Files (*)")
if filename:
if not filename.lower().endswith('.json'):
filename += '.json'
try:
self._update_model_from_view()
self.model.save_to_file(filename)
QMessageBox.information(self.view, "Успех", "Состав среды успешно сохранён!")
except Exception as e:
self.view.show_error(f"Ошибка сохранения: {str(e)}")
def load_composition(self):
filename, _ = QFileDialog.getOpenFileName(self.view, "Загрузить состав среды", "", "JSON Files (*.json);;All Files (*)")
if filename:
try:
self.model.load_from_file(filename)
self._update_view_from_model()
QMessageBox.information(self.view, "Успех", "Состав среды успешно загружен")
except FileNotFoundError:
QMessageBox.critical(self.view, "Ошибка", f"Файл не найден: {filename}")
except json.JSONDecodeError as e:
QMessageBox.critical(self.view, "Ошибка", f"Неверный формат JSON-файла: {str(e)}")
except Exception as e:
QMessageBox.critical(self.view, "Ошибка", f"Ошибка при загрузке состава: {str(e)}")
def _update_view_from_model(self):
while self.view.table.rowCount() > 1:
self.view.table.removeRow(1)
if self.view.table.rowCount() == 0:
self.view.add_solvent_row()
self.view.amount_input.setValue(self.model.total_amount)
index = self.view.amount_unit_combo.findText(self.model.amount_unit)
if index >= 0:
self.view.amount_unit_combo.setCurrentIndex(index)
self.view.solvent_input.setText(self.model.solvent)
self.view.update_solvent_name()
for reagent in self.model.reagents:
row = self.view.table.rowCount()
self.view.table.insertRow(row)
self.view.table.setItem(row, 0, QTableWidgetItem(reagent.name))
self.view.table.setItem(row, 1, QTableWidgetItem(f"{reagent.percentage:.2f}"))
unit_combo = QComboBox()
unit_combo.addItems(["нг", "мкг", "мг", "г", "кг", "нл", "мкл", "мл", "л"])
unit_combo.setCurrentText(reagent.unit)
self.view.table.setCellWidget(row, 2, unit_combo)
self.view.table.setItem(row, 3, QTableWidgetItem(f"{reagent.conversion_factor:.2f}"))
self.view.table.setItem(row, 4, QTableWidgetItem(f"{getattr(reagent, 'dilution_factor', 1.0):.3f}"))
self.view.table.setItem(row, 5, QTableWidgetItem(""))
self.view.clear_results()
EOF
# Обновляем experiment_view.py - добавляем метод загрузки факторов из реагентов
cat > src/views/experiment_view.py << 'EOF'
from PyQt5.QtWidgets import (QMainWindow, QVBoxLayout, QHBoxLayout, QPushButton, QLabel,
QWidget, QMessageBox, QTableWidget, QTableWidgetItem, QGroupBox,
@@ -596,6 +441,8 @@ class ExperimentDesignWindow(QMainWindow):
QPushButton:hover { background-color: #45a049; }
QPushButton#danger { background-color: #f44336; }
QPushButton#danger:hover { background-color: #da190b; }
QPushButton#doe { background-color: #9C27B0; }
QPushButton#doe:hover { background-color: #7B1FA2; }
QTableWidget { gridline-color: #ddd; }
QHeaderView::section { background-color: #1565C0; color: white; padding: 8px; font-weight: bold; }
""")
@@ -768,6 +615,66 @@ class ExperimentDesignWindow(QMainWindow):
self.generated_design = None
self.factors_data = None
def load_factors_from_reagents(self, reagents):
"""Загружает факторы из списка реагентов калькулятора"""
if not reagents:
return
# Очищаем таблицу факторов
self.factors_table.setRowCount(0)
# Добавляем каждый реагент как фактор
for reagent in reagents:
row = self.factors_table.rowCount()
self.factors_table.insertRow(row)
# Название фактора = название реагента
self.factors_table.setItem(row, 0, QTableWidgetItem(reagent['name']))
# Нулевой уровень = процентное содержание
percentage = reagent['percentage']
self.factors_table.setItem(row, 1, QTableWidgetItem(f"{percentage:.2f}"))
# Шаг = 10% от нулевого уровня (или 1, если нулевой уровень 0)
step = max(percentage * 0.1, 1.0) if percentage > 0 else 1.0
self.factors_table.setItem(row, 2, QTableWidgetItem(f"{step:.2f}"))
# Единица измерения
unit = reagent['unit']
# Преобразуем единицы измерения в понятные для факторов
if unit in ['нг', 'мкг', 'мг', 'г', 'кг']:
display_unit = unit
elif unit in ['нл', 'мкл', 'мл', 'л']:
display_unit = unit
else:
display_unit = "%"
self.factors_table.setItem(row, 5, QTableWidgetItem(display_unit))
# Верхний и нижний уровни (вычисляются автоматически)
high = percentage + step
low = percentage - step
high_item = QTableWidgetItem(f"{high:.2f}")
high_item.setFlags(high_item.flags() & ~Qt.ItemIsEditable)
high_item.setBackground(QColor(240, 240, 240))
self.factors_table.setItem(row, 3, high_item)
low_item = QTableWidgetItem(f"{low:.2f}")
low_item.setFlags(low_item.flags() & ~Qt.ItemIsEditable)
low_item.setBackground(QColor(240, 240, 240))
self.factors_table.setItem(row, 4, low_item)
# Показываем сообщение об успешной загрузке
QMessageBox.information(
self,
"Загрузка из калькулятора",
f"Загружено {len(reagents)} факторов из калькулятора питательных сред.\n\n"
f"Каждый реагент стал фактором.\n"
f"Нулевой уровень = концентрация реагента (%)\n"
f"Шаг = 10% от нулевого уровня\n\n"
f"При необходимости отредактируйте шаг и единицы измерения."
)
def on_factor_changed(self, item):
row = item.row()
col = item.column()
@@ -1045,203 +952,10 @@ class ExperimentDesignWindow(QMainWindow):
QMessageBox.critical(self, "Ошибка", message)
EOF
# Файл: src/controllers/__init__.py
cat > src/controllers/__init__.py << 'EOF'
from .medium_controller import MediumController
from .experiment_controller import ExperimentController
__all__ = ['MediumController', 'ExperimentController']
EOF
# Файл: src/controllers/medium_controller.py
cat > src/controllers/medium_controller.py << 'EOF'
from PyQt5.QtWidgets import QFileDialog, QMessageBox, QTableWidgetItem, QComboBox
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QColor
import json
from ..models.medium_model import MediumModel
from ..models.reagent import Reagent
class MediumController:
def __init__(self, view):
self.model = MediumModel()
self.view = view
self._connect_signals()
self._setup_initial_data()
def _connect_signals(self):
self.view.add_row_btn.clicked.connect(self.add_reagent_row)
self.view.remove_row_btn.clicked.connect(self.remove_reagent_row)
self.view.calculate_btn.clicked.connect(self._perform_calculation)
self.view.save_btn.clicked.connect(self.save_composition)
self.view.load_btn.clicked.connect(self.load_composition)
self.view.solvent_input.textChanged.connect(self.view.update_solvent_name)
def _setup_initial_data(self):
self.view.add_initial_rows()
def add_reagent_row(self):
self.view.add_new_row()
def remove_reagent_row(self):
self.view.remove_selected_row()
def _perform_calculation(self):
try:
self._update_model_from_view()
results, solvent_amount, solvent_percentage = self.model.calculate_amounts()
self.view.update_results(results)
self.view.update_solvent_result(solvent_amount, self.model.amount_unit)
self.view.update_solvent_percent(solvent_percentage)
except ValueError as e:
self.view.show_error(f"Ошибка в данных: {str(e)}")
except Exception as e:
self.view.show_error(f"Неожиданная ошибка: {str(e)}")
def _update_model_from_view(self):
self.model.reagents.clear()
self.model.total_amount = self.view.amount_input.value()
self.model.amount_unit = self.view.amount_unit_combo.currentText()
self.model.solvent = self.view.solvent_input.text()
for row in range(1, self.view.table.rowCount()):
name_item = self.view.table.item(row, 0)
percentage_item = self.view.table.item(row, 1)
unit_widget = self.view.table.cellWidget(row, 2)
conversion_item = self.view.table.item(row, 3)
dilution_item = self.view.table.item(row, 4)
if not all([name_item, percentage_item, conversion_item]):
continue
try:
name = name_item.text()
percentage = float(percentage_item.text())
unit = unit_widget.currentText() if unit_widget else "мг"
conversion_factor = float(conversion_item.text())
dilution_factor = float(dilution_item.text()) if dilution_item else 1.0
reagent = Reagent(name, percentage, unit, conversion_factor)
reagent.dilution_factor = dilution_factor
self.model.reagents.append(reagent)
except ValueError as e:
raise ValueError(f"Ошибка в строке {row + 1}: {str(e)}")
def save_composition(self):
filename, _ = QFileDialog.getSaveFileName(self.view, "Сохранить состав среды", "", "JSON Files (*.json);;All Files (*)")
if filename:
if not filename.lower().endswith('.json'):
filename += '.json'
try:
self._update_model_from_view()
self.model.save_to_file(filename)
QMessageBox.information(self.view, "Успех", "Состав среды успешно сохранён!")
except Exception as e:
self.view.show_error(f"Ошибка сохранения: {str(e)}")
def load_composition(self):
filename, _ = QFileDialog.getOpenFileName(self.view, "Загрузить состав среды", "", "JSON Files (*.json);;All Files (*)")
if filename:
try:
self.model.load_from_file(filename)
self._update_view_from_model()
QMessageBox.information(self.view, "Успех", "Состав среды успешно загружен")
except FileNotFoundError:
QMessageBox.critical(self.view, "Ошибка", f"Файл не найден: {filename}")
except json.JSONDecodeError as e:
QMessageBox.critical(self.view, "Ошибка", f"Неверный формат JSON-файла: {str(e)}")
except Exception as e:
QMessageBox.critical(self.view, "Ошибка", f"Ошибка при загрузке состава: {str(e)}")
def _update_view_from_model(self):
while self.view.table.rowCount() > 1:
self.view.table.removeRow(1)
if self.view.table.rowCount() == 0:
self.view.add_solvent_row()
self.view.amount_input.setValue(self.model.total_amount)
index = self.view.amount_unit_combo.findText(self.model.amount_unit)
if index >= 0:
self.view.amount_unit_combo.setCurrentIndex(index)
self.view.solvent_input.setText(self.model.solvent)
self.view.update_solvent_name()
for reagent in self.model.reagents:
row = self.view.table.rowCount()
self.view.table.insertRow(row)
self.view.table.setItem(row, 0, QTableWidgetItem(reagent.name))
self.view.table.setItem(row, 1, QTableWidgetItem(f"{reagent.percentage:.2f}"))
unit_combo = QComboBox()
unit_combo.addItems(["нг", "мкг", "мг", "г", "кг", "нл", "мкл", "мл", "л"])
unit_combo.setCurrentText(reagent.unit)
self.view.table.setCellWidget(row, 2, unit_combo)
self.view.table.setItem(row, 3, QTableWidgetItem(f"{reagent.conversion_factor:.2f}"))
self.view.table.setItem(row, 4, QTableWidgetItem(f"{getattr(reagent, 'dilution_factor', 1.0):.3f}"))
self.view.table.setItem(row, 5, QTableWidgetItem(""))
self.view.clear_results()
EOF
# Файл: src/controllers/experiment_controller.py
cat > src/controllers/experiment_controller.py << 'EOF'
from ..models.experiment_model import ExperimentModel
class ExperimentController:
def __init__(self, view):
self.model = ExperimentModel()
self.view = view
def update_model_from_view(self):
factors = self.view.get_factors_data()
self.model.set_factors(factors)
responses = []
for row in range(self.view.responses_table.rowCount()):
name_item = self.view.responses_table.item(row, 0)
unit_item = self.view.responses_table.item(row, 1)
if name_item:
responses.append({
'name': name_item.text(),
'unit': unit_item.text() if unit_item else ""
})
self.model.set_responses(responses)
self.model.set_center_points(self.view.center_points_spin.value())
self.model.set_randomize(self.view.randomize_check.isChecked())
EOF
# Файл: main.py
cat > main.py << 'EOF'
import sys
import os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
from PyQt5.QtWidgets import QApplication
from src.views import MainWindow
def main():
app = QApplication(sys.argv)
app.setStyle('Fusion')
assistant = MainWindow()
assistant.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()
EOF
# Файл: run.sh
cat > run.sh << 'EOF'
#!/bin/bash
python3 main.py
EOF
chmod +x run.sh
# Файл: requirements.txt
cat > requirements.txt << 'EOF'
PyQt5>=5.15.0
numpy>=1.19.0
EOF
echo -e "${GREEN}========================================${NC}"
echo -e "${GREEN}Реорганизация завершена!${NC}"
echo -e "${GREEN}Обновление завершено!${NC}"
echo -e "${GREEN}========================================${NC}"
echo -e "${YELLOW}Для запуска обновлённой версии:${NC}"
echo -e "${GREEN}python3 main.py${NC}"
echo -e "${YELLOW}Добавлена кнопка «🎯 В DoE» в калькулятор питательных сред${NC}"
echo -e "${YELLOW}При нажатии реагенты передаются в планировщик как факторы${NC}"
echo ""
echo -e "${GREEN}или${NC}"
echo -e "${GREEN}./run.sh${NC}"
echo ""
echo -e "${YELLOW}Бэкап старых файлов:${NC} $BACKUP_DIR"
echo -e "${GREEN}Запуск: python3 main.py${NC}"