pypharm 1.2.6__tar.gz → 1.2.8__tar.gz

{pypharm-1.2.6 → pypharm-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypharm
-Version: 1.2.6
+Version: 1.2.8
 Summary: Module for solving pharmacokinetic problems
 Home-page: https://github.com/Krash13/PyPharm
 Author: Krash13
@@ -136,3 +136,71 @@ model.optimize(
 )
 ```
 
+При оптимизации, вектор неизвестных это
+x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные)]
+
+**4) Модель MagicCompartmentModel** 
+
+Данная модель необходима нам для тех случаев, 
+когда мы не знаем как именно стоит переводить входные
+единицы измерения в выходные.
+
+В модель добавляется 2 дополнительных параметра:
+
+* magic_coefficient - множитель преобразования входных единиц в выходные;
+* exclude_compartments - список номеров камер, которые не 
+подвергнутся преобразованию.
+
+```python  
+from PyPharm import MagicCompartmentModel  
+  
+model = MagicCompartmentModel([[0, 0.4586], [0.1919, 0]], [0.0309, 0], volumes=[228, 629], magic_coefficient=None, exclude_compartments=[2])  
+  
+res = model(90, d=5700, compartment_number=0)  
+```
+
+Параметр magic_coefficient может быть задан None,
+в таком случае он будет подвергнут оптимизации, в таком 
+случае он будет браться из последнего значения в векторе
+переменных.
+Если оба параметра не заданы, то модель выраздается 
+в простую BaseCompartmentModel.
+
+**5) Модель MagicCompartmentModel** 
+
+Данная модель учитывает поправку на высвобождение
+ЛВ в модель вводятся дополнительные параметры:
+* v_release - Объем гепотетической камеры из которой происходит высвобождение
+* release_parameters -  Параметры функции высвобождения
+* release_compartment - Номер камеры в которую происходит высвобождение
+* release_function - Функция высвобождения по умолчанию f(t,m,b,c) = c0 * c * t ** b / (t ** b + m)
+
+При этом d и c0 теперь везде носят характер параметров камеры,
+из которой происходит высвобождение
+```python
+from PyPharm import ReleaseCompartmentModel
+import matplotlib.pyplot as plt
+
+model = ReleaseCompartmentModel(
+    6.01049235e+00,
+    [4.56683781e-03, 1.36845756e+00, 5.61175978e-01],
+    0,
+    configuration_matrix=[[0, 1.18292665e+01], [3.02373800e-01, 0]],
+    outputs=[5.00000000e+00, 0],
+    volumes=[1.98530383e+01, 3.81007392e+02],
+    numba_option=True
+)
+teoretic_t = [5/60, 0.25, 0.5, 1, 2, 4, 24, 48]
+teoretic_c = [[3558.19,	508.49,	230.95,	52.05,	44.97,	36.52,	17.89,	10.36]]
+d = 5 * 0.02 * 1000000
+res = model(48, d=d)
+plt.plot(teoretic_t, teoretic_c[0], 'r*')
+plt.plot(res.t, res.y[0])
+plt.grid()
+plt.show()
+```
+Параметры release_parameters и v_release могут подвергаться оптимизации
+в таком случае, искомое нужно просто задать как None. Тогда вектор неизвестных это
+x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные), release_parameters(неизвестные), v_release]
+
+

pypharm-1.2.8/PyPharm/__init__.py

@@ -0,0 +1 @@
+from .models import BaseCompartmentModel, MagicCompartmentModel, ReleaseCompartmentModel

{pypharm-1.2.6 → pypharm-1.2.8}/PyPharm/models.py

@@ -1,5 +1,6 @@
 import numpy as np
-from scipy.integrate import solve_ivp
+from scipy.integrate import solve_ivp, RK45
+from scipy.integrate._ivp.rk import rk_step, SAFETY, MAX_FACTOR, MIN_FACTOR
 from scipy.optimize import minimize
 from .country_optimization import CountriesAlgorithm
 from .country_optimization_v2 import CountriesAlgorithm_v2
@@ -125,7 +126,7 @@ class BaseCompartmentModel:
         if self.volumes_target:
             self.volumes[self.volumes_target] = x[self.configuration_matrix_target_count + self.outputs_target_count:self.configuration_matrix_target_count + self.outputs_target_count + self.volumes_target_count]
 
-    def _target_function(self, x, max_step=0.01):
+    def _target_function(self, x, max_step=0.01, metric='R2'):
         """
         Функция расчета значения целевой функции
 
@@ -148,7 +149,13 @@ class BaseCompartmentModel:
             max_step=max_step
         )
         target_results = self.last_result.y[tuple(self.know_compartments), :]
-        return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
+        if metric == 'R2':
+            return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
+        elif metric == 'norm':
+            return np.linalg.norm(target_results - self.teoretic_y)
+        else:
+            return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
+
 
     def load_optimization_data(self, teoretic_x, teoretic_y, know_compartments, w = None, c0=None, d=None, compartment_number=None):
         """
@@ -181,7 +188,7 @@ class BaseCompartmentModel:
             self.c0 = np.array(c0)
         self.w = np.ones(self.teoretic_y.shape) if w is None else np.array(w)
 
-    def optimize(self, method=None, max_step=0.01, **kwargs):
+    def optimize(self, method=None, max_step=0.01, metric='R2', **kwargs):
         """
         Функция оптимизации модели
 
@@ -194,7 +201,7 @@ class BaseCompartmentModel:
             None
         """
         self._optim = True
-        f = lambda x: self._target_function(x, max_step=max_step)
+        f = lambda x: self._target_function(x, max_step=max_step, metric=metric)
         if method == 'country_optimization':
             CA = CountriesAlgorithm(
                 f=f,
@@ -230,7 +237,7 @@ class BaseCompartmentModel:
         return x
 
 
-class MagicCompartmentModelWith(BaseCompartmentModel):
+class MagicCompartmentModel(BaseCompartmentModel):
 
     need_magic_optimization = False
 
@@ -268,49 +275,185 @@ class MagicCompartmentModelWith(BaseCompartmentModel):
 
 class ReleaseCompartmentModel(BaseCompartmentModel):
 
-    def __init__(self, release_parameters, v, *args, **kwargs):
+    need_v_release_optimization = False
+
+    class ReleaseRK45(RK45):
+
+        def __init__(self, fun, t0, y0, t_bound, release_function, compartment_number, c0, max_step=np.inf,
+                     rtol=1e-3, atol=1e-6, vectorized=False,
+                     first_step=None, **extraneous):
+            super().__init__(fun, t0, y0, t_bound, max_step=max_step,
+                     rtol=rtol, atol=atol, vectorized=vectorized,
+                     first_step=first_step, **extraneous)
+            self.release_function = release_function
+            self.compartment_number = compartment_number
+            self.c0 = c0
+            self.old_release_correction = 0
+
+        def _step_impl(self):
+            result = super()._step_impl()
+            release_correction = self.release_function(self.t, self.c0)
+            self.y[self.compartment_number] += release_correction - self.old_release_correction
+            self.old_release_correction = release_correction
+            return result
+
+    def __init__(self, v_release, release_parameters, release_compartment, release_function=None, *args, **kwargs):
+        """
+        Камерная модель с высвобождением для описания фармакокинетики системы
+
+        Неизвестные параметры при необходимости задаются как None
+        например configuration_matrix = [[0, 1], [None, 0]]
+
+        Args:
+            configuration_matrix: Настроечная матрица модели, отображающая константы перехода между матрицами
+            outputs: Вектор констант перехода во вне камер
+            volumes: Объемы камер
+            v_release: Объем гепотетической камеры из которой происходит высвобождение
+            release_parameters: Параметры функции высвобождения
+            release_compartment: Номер камеры в которую происходит высвобождение
+            release_function: Функция высвобождения по умолчанию f(t,m,b,c) = c0 * c * t ** b / (t ** b + m)
+        """
         super().__init__(*args, **kwargs)
         self.release_parameters = np.array(release_parameters)
         self.release_parameters_target_count = 0
         if np.any(self.release_parameters == None):
             self.release_parameters_target = np.where(self.release_parameters == None)
             self.release_parameters_target_count = np.sum(self.release_parameters == None)
-        self.v = v
+        self.v_release = v_release
+        if self.v_release is None:
+            self.need_v_release_optimization = True
+        self.release_compartment = release_compartment
+        self.release_function = release_function
 
-    def _runge_kutta(self, y, x, dx):
-        k1 = dx * self._сompartment_model(x, y)
-        k2 = dx * self._сompartment_model(x + 0.5 * dx, y + 0.5 * k1)
-        k3 = dx * self._сompartment_model(x + 0.5 * dx, y + 0.5 * k2)
-        k4 = dx * self._сompartment_model(x + dx, y + k3)
-        return y + (k1 + 2 * k2 + 2 * k3 + k4) / 6
+    def load_data_from_list(self, x):
+        super().load_data_from_list(x)
+        s = self.configuration_matrix_target_count + self.outputs_target_count + self.volumes_target_count
+        if self.release_parameters_target:
+            self.release_parameters[self.release_parameters_target] = x[s:s + self.release_parameters_target_count]
+        if self.need_v_release_optimization:
+            self.v_release = x[s + self.release_parameters_target_count]
 
-    def release_function(self, t, c0):
+    def _default_release_function(self, t, c0):
         """
         Функция для поправки на высвобождение
         """
-        m, b, c = self.release_parametrs
+        m, b, c = self.release_parameters
         return c0 * c * t ** b / (t ** b + m)
 
-    def __call__(self, t_max, c0=None, d=None, compartment_number=None, max_step=0.01, t_eval=None):
+    def get_release_function(self):
+        if self.release_function is not None:
+            return lambda t, c0: self.release_function(t, c0, *self.release_parameters)
+        else:
+            return self._default_release_function
+
+    def __call__(self, t_max, c0=None, d=None, max_step=0.01, t_eval=None, **kwargs):
+        """
+                Расчет кривых концентраций по фармакокинетической модели
+
+                Args:
+                    t_max: Предельное время расчета
+                    c0: Начальная концентрация в камере из которой высвобождается вещество
+                    d: Вводимая доза
+                    max_step: Максимальный шаг при решении СДУ
+                    t_eval: Временные точки, в которых необходимо молучить решение
+
+                Returns:
+                    Результат работы решателя scipy solve_ivp
+                """
         if not self._optim:
             assert (not any([self.configuration_matrix_target, self.outputs_target, self.volumes_target])), \
                 "It is impossible to make a calculation with unknown parameters"
-        assert any([c0 is not None, d, compartment_number is not None]), "Need to set c0 or d and compartment_number"
+        assert any([c0 is not None, d]), "Need to set c0 or d and compartment_number"
+        if c0 is None:
+            assert d, "Need to set d"
+            c0 = d / self.v_release
+        ts = [0, t_max]
+        y0 = np.zeros(self.outputs.shape)
+        self.last_result = solve_ivp(
+            fun=self._сompartment_model if
+            not self.numba_option
+            else lambda t, c: self._numba_сompartment_model(t, c,
+                                                             self.configuration_matrix.astype(
+                                                                 np.float64),
+                                                             self.outputs.astype(
+                                                                 np.float64),
+                                                             self.volumes.astype(
+                                                     np.float64)),
+            t_span=ts,
+            y0=y0,
+            max_step=max_step,
+            t_eval=t_eval,
+            method=self.ReleaseRK45,
+            release_function=self.get_release_function(),
+            compartment_number=self.release_compartment,
+            c0=c0
+        )
+        return self.last_result
+
+    def _target_function(self, x, max_step=0.01, metric='R2'):
+        """
+        Функция расчета значения целевой функции
+
+        Args:
+            x: Значение искомых параметров модели
+            max_step: Максимальный шаг при решении СДУ
+
+        Returns:
+            Значение целевой функции, характеризующее отклонение от эксперементальных данных
+        """
+        self.load_data_from_list(x)
+        c0 = self.c0
         if c0 is None:
+            c0 = self.d / self.v_release
+        self(
+            t_max=np.max(self.teoretic_x),
+            c0=c0,
+            t_eval=self.teoretic_x,
+            max_step=max_step
+        )
+        target_results = self.last_result.y[tuple(self.know_compartments), :]
+        if metric == 'R2':
+            return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
+        elif metric == 'norm':
+            return np.linalg.norm(target_results - self.teoretic_y)
+        else:
+            return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
+
+    def load_optimization_data(self, teoretic_x, teoretic_y, know_compartments, w = None, c0=None, d=None, compartment_number=None):
+        """
+        Функция загрузки в модель эксперементальных данных
+
+        Args:
+            teoretic_x: Вектор временных точек теоретических значений
+            teoretic_y: Матрица с теоретическими значениями
+            know_compartments: Вектор с номерами камер, по которым есть данные
+            c0: Начальная концентрация в камере из которой высвобождается вещество
+            d: Вводимая доза
+
+        Returns:
+            None
+        """
+        self.teoretic_x = np.array(teoretic_x)
+        self.teoretic_y = np.array(teoretic_y)
+        self.know_compartments = know_compartments
+        self.teoretic_avg = np.average(self.teoretic_y, axis=1)
+        self.teoretic_avg = np.repeat(self.teoretic_avg, self.teoretic_x.size)
+        self.teoretic_avg = np.reshape(self.teoretic_avg, self.teoretic_y.shape)
+        assert any([c0, d, compartment_number is not None]), "Need to set c0 or d and compartment_number"
+        if not c0:
             assert all([d, compartment_number is not None]), "Need to set d and compartment_number"
-            c0 = d / self.v
-        t = 0
-        old_release_correction = 0
-        result_x = np.array([])
-        result_y = np.array([])
-        y = np.zeros(self.outputs.size)
-        while t <= t_max:
-            np.append(result_x, t)
-            np.append(result_y, y)
-            release_correction = self.release_function(t + max_step, c0)
-            y = self._runge_kutta(y, t, max_step)
-            y[compartment_number] += release_correction - old_release_correction
-            #y[0] = breeding_function(dx, t12, y[0])  # делаем поправочку на распад
-            old_release_correction = release_correction
-            t += max_step
-        return result_x, result_y
+            self.d = d
+            self.c0 = None
+        else:
+            self.c0 = np.array(c0)
+        self.w = np.ones(self.teoretic_y.shape) if w is None else np.array(w)
+
+    def optimize(self, method=None, max_step=0.01, **kwargs):
+        x = super().optimize(method, max_step, **kwargs)
+        s = self.configuration_matrix_target_count + self.outputs_target_count + self.volumes_target_count
+        if self.release_parameters_target:
+            self.release_parameters[self.release_parameters_target] = x[s:s + self.release_parameters_target_count]
+        if self.need_v_release_optimization:
+            self.v_release = x[s:s + self.release_parameters_target_count + 1]
+            self.need_v_release_optimization = False
+        return x

pypharm-1.2.8/README.md

@@ -0,0 +1,188 @@
+PyPharm  
+----------  
+  **1) Установка пакета**
+  
+```  
+pip install pypharm  
+```  
+  
+**2) Пример использования пакета для модели, где все параметры известны** 
+
+Задана двухкамерная модель такого вида
+
+```mermaid
+graph LR
+D((Доза D)) --> V1[Камера V1]
+V1 -- k12 --> V2[Камера V2]
+V2 -- k21 --> V1
+V1 -- k10 --> Out(Выведение)
+``` 
+При этом, нам известны параметры модели 
+|  V1|V2  |k12 |K21 | K10
+|--|--|--|--|--|
+|  228| 629 |0.4586|0.1919|0.0309
+
+Создание и расчет модели при помощи пакета PyPharm  
+```python  
+from PyPharm import BaseCompartmentModel  
+  
+model = BaseCompartmentModel([[0, 0.4586], [0.1919, 0]], [0.0309, 0], volumes=[228, 629])  
+  
+res = model(90, d=5700, compartment_number=0)  
+```
+res - Результат работы решателя scipy solve_iv
+
+**3) Пример использования пакета для модели, где все параметры неизвестны** 
+
+Задана многокамерная модель такого вида
+
+```mermaid
+graph LR
+Br(Мозг) --'Kbr-'--> Is[Межклетачное пространство]
+Is --'Kbr+'-->Br
+Is--'Kis-'-->B(Кровь)
+B--'Kis+'-->Is
+B--'Ke'-->Out1((Выведение))
+B--'Ki+'-->I(Печень)
+I--'Ki-'-->Out2((Выведение))
+B--'Kh+'-->H(Сердце)
+H--'Kh-'-->B
+``` 
+При этом, известен лишь параметр Ke=0.077
+
+Создание и расчет модели при помощи пакета PyPharm, используя метод minimize:
+```python  
+from PyPharm import BaseCompartmentModel
+import numpy as np
+matrix = [[0, None, 0, 0, 0],
+[None, 0, None, 0, 0],
+[0, None, 0, None, None],
+[0, 0, 0, 0, 0],
+[0, 0, None, 0, 0]]
+outputs = [0, 0, 0.077, None, 0]
+
+model = BaseCompartmentModel(matrix, outputs)
+
+model.load_optimization_data(
+	teoretic_x=[0.25, 0.5, 1, 4, 8, 24],
+	teoretic_y=[[0, 0, 11.2, 5.3, 5.42, 3.2], [268.5, 783.3, 154.6, 224.2, 92.6, 0], [342, 637, 466, 235, 179, 158]],
+	know_compartments=[0, 3, 4],
+	c0=[0, 0, 20000, 0, 0]
+)
+
+x_min = [1.5, 0.01, 0.5, 0.0001, 0.1, 0.1, 4, 3]
+x_max = [2.5, 0.7, 1.5, 0.05, 0.5, 0.5, 7, 5]
+x0 = np.random.uniform(x_min, x_max)
+bounds = ((1.5, 2.5), (0.01, 0.7), (0.5, 1.5), (0.0001, 0.05), (0.1, 0.5), (0.1, 0.5), (4, 7), (3, 5))
+
+model.optimize(
+	bounds=bounds,
+	x0=x0,
+	options={'disp': True}
+)
+
+print(model.configuration_matrix)
+```
+Или же при помощи алгоритма взаимодействующих стран
+```python
+from PyPharm import BaseCompartmentModel
+import numpy as np
+matrix = [[0, None, 0, 0, 0],
+[None, 0, None, 0, 0],
+[0, None, 0, None, None],
+[0, 0, 0, 0, 0],
+[0, 0, None, 0, 0]]
+outputs = [0, 0, 0.077, None, 0]
+
+model = BaseCompartmentModel(matrix, outputs)
+
+model.load_optimization_data(
+	teoretic_x=[0.25, 0.5, 1, 4, 8, 24],
+	teoretic_y=[[0, 0, 11.2, 5.3, 5.42, 3.2], [268.5, 783.3, 154.6, 224.2, 92.6, 0], [342, 637, 466, 235, 179, 158]],
+	know_compartments=[0, 3, 4],
+	c0=[0, 0, 20000, 0, 0]
+)
+
+model.optimize(
+	method='country_optimization',
+	Xmin=[0.5, 0.001, 0.001, 0.00001, 0.01, 0.01, 1, 1],
+	Xmax=[5, 2, 2.5, 0.3, 1, 1, 10, 10],
+	M=10,
+	N=25,
+	n=[1, 10],
+	p=[0.00001, 2],
+	m=[1, 8],
+	k=8,
+	l=3,
+	ep=[0.2, 0.4],
+	tmax=300,
+	printing=True,
+)
+```
+
+При оптимизации, вектор неизвестных это
+x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные)]
+
+**4) Модель MagicCompartmentModel** 
+
+Данная модель необходима нам для тех случаев, 
+когда мы не знаем как именно стоит переводить входные
+единицы измерения в выходные.
+
+В модель добавляется 2 дополнительных параметра:
+
+* magic_coefficient - множитель преобразования входных единиц в выходные;
+* exclude_compartments - список номеров камер, которые не 
+подвергнутся преобразованию.
+
+```python  
+from PyPharm import MagicCompartmentModel  
+  
+model = MagicCompartmentModel([[0, 0.4586], [0.1919, 0]], [0.0309, 0], volumes=[228, 629], magic_coefficient=None, exclude_compartments=[2])  
+  
+res = model(90, d=5700, compartment_number=0)  
+```
+
+Параметр magic_coefficient может быть задан None,
+в таком случае он будет подвергнут оптимизации, в таком 
+случае он будет браться из последнего значения в векторе
+переменных.
+Если оба параметра не заданы, то модель выраздается 
+в простую BaseCompartmentModel.
+
+**5) Модель MagicCompartmentModel** 
+
+Данная модель учитывает поправку на высвобождение
+ЛВ в модель вводятся дополнительные параметры:
+* v_release - Объем гепотетической камеры из которой происходит высвобождение
+* release_parameters -  Параметры функции высвобождения
+* release_compartment - Номер камеры в которую происходит высвобождение
+* release_function - Функция высвобождения по умолчанию f(t,m,b,c) = c0 * c * t ** b / (t ** b + m)
+
+При этом d и c0 теперь везде носят характер параметров камеры,
+из которой происходит высвобождение
+```python
+from PyPharm import ReleaseCompartmentModel
+import matplotlib.pyplot as plt
+
+model = ReleaseCompartmentModel(
+    6.01049235e+00,
+    [4.56683781e-03, 1.36845756e+00, 5.61175978e-01],
+    0,
+    configuration_matrix=[[0, 1.18292665e+01], [3.02373800e-01, 0]],
+    outputs=[5.00000000e+00, 0],
+    volumes=[1.98530383e+01, 3.81007392e+02],
+    numba_option=True
+)
+teoretic_t = [5/60, 0.25, 0.5, 1, 2, 4, 24, 48]
+teoretic_c = [[3558.19,	508.49,	230.95,	52.05,	44.97,	36.52,	17.89,	10.36]]
+d = 5 * 0.02 * 1000000
+res = model(48, d=d)
+plt.plot(teoretic_t, teoretic_c[0], 'r*')
+plt.plot(res.t, res.y[0])
+plt.grid()
+plt.show()
+```
+Параметры release_parameters и v_release могут подвергаться оптимизации
+в таком случае, искомое нужно просто задать как None. Тогда вектор неизвестных это
+x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные), release_parameters(неизвестные), v_release]

{pypharm-1.2.6 → pypharm-1.2.8}/pypharm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypharm
-Version: 1.2.6
+Version: 1.2.8
 Summary: Module for solving pharmacokinetic problems
 Home-page: https://github.com/Krash13/PyPharm
 Author: Krash13
@@ -136,3 +136,71 @@ model.optimize(
 )
 ```
 
+При оптимизации, вектор неизвестных это
+x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные)]
+
+**4) Модель MagicCompartmentModel** 
+
+Данная модель необходима нам для тех случаев, 
+когда мы не знаем как именно стоит переводить входные
+единицы измерения в выходные.
+
+В модель добавляется 2 дополнительных параметра:
+
+* magic_coefficient - множитель преобразования входных единиц в выходные;
+* exclude_compartments - список номеров камер, которые не 
+подвергнутся преобразованию.
+
+```python  
+from PyPharm import MagicCompartmentModel  
+  
+model = MagicCompartmentModel([[0, 0.4586], [0.1919, 0]], [0.0309, 0], volumes=[228, 629], magic_coefficient=None, exclude_compartments=[2])  
+  
+res = model(90, d=5700, compartment_number=0)  
+```
+
+Параметр magic_coefficient может быть задан None,
+в таком случае он будет подвергнут оптимизации, в таком 
+случае он будет браться из последнего значения в векторе
+переменных.
+Если оба параметра не заданы, то модель выраздается 
+в простую BaseCompartmentModel.
+
+**5) Модель MagicCompartmentModel** 
+
+Данная модель учитывает поправку на высвобождение
+ЛВ в модель вводятся дополнительные параметры:
+* v_release - Объем гепотетической камеры из которой происходит высвобождение
+* release_parameters -  Параметры функции высвобождения
+* release_compartment - Номер камеры в которую происходит высвобождение
+* release_function - Функция высвобождения по умолчанию f(t,m,b,c) = c0 * c * t ** b / (t ** b + m)
+
+При этом d и c0 теперь везде носят характер параметров камеры,
+из которой происходит высвобождение
+```python
+from PyPharm import ReleaseCompartmentModel
+import matplotlib.pyplot as plt
+
+model = ReleaseCompartmentModel(
+    6.01049235e+00,
+    [4.56683781e-03, 1.36845756e+00, 5.61175978e-01],
+    0,
+    configuration_matrix=[[0, 1.18292665e+01], [3.02373800e-01, 0]],
+    outputs=[5.00000000e+00, 0],
+    volumes=[1.98530383e+01, 3.81007392e+02],
+    numba_option=True
+)
+teoretic_t = [5/60, 0.25, 0.5, 1, 2, 4, 24, 48]
+teoretic_c = [[3558.19,	508.49,	230.95,	52.05,	44.97,	36.52,	17.89,	10.36]]
+d = 5 * 0.02 * 1000000
+res = model(48, d=d)
+plt.plot(teoretic_t, teoretic_c[0], 'r*')
+plt.plot(res.t, res.y[0])
+plt.grid()
+plt.show()
+```
+Параметры release_parameters и v_release могут подвергаться оптимизации
+в таком случае, искомое нужно просто задать как None. Тогда вектор неизвестных это
+x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные), release_parameters(неизвестные), v_release]
+
+

{pypharm-1.2.6 → pypharm-1.2.8}/setup.py

@@ -6,7 +6,7 @@ def readme():
 
 setup(
   name='pypharm',
-  version='1.2.6',
+  version='1.2.8',
   author='Krash13',
   author_email='krasheninnikov.r.s@muctr.ru',
   description='Module for solving pharmacokinetic problems',

pypharm-1.2.6/PyPharm/__init__.py

@@ -1 +0,0 @@
-from .models import BaseCompartmentModel, MagicCompartmentModelWith

pypharm-1.2.6/README.md

@@ -1,121 +0,0 @@
-PyPharm  
-----------  
-  **1) Установка пакета**
-  
-```  
-pip install pypharm  
-```  
-  
-**2) Пример использования пакета для модели, где все параметры известны** 
-
-Задана двухкамерная модель такого вида
-
-```mermaid
-graph LR
-D((Доза D)) --> V1[Камера V1]
-V1 -- k12 --> V2[Камера V2]
-V2 -- k21 --> V1
-V1 -- k10 --> Out(Выведение)
-``` 
-При этом, нам известны параметры модели 
-|  V1|V2  |k12 |K21 | K10
-|--|--|--|--|--|
-|  228| 629 |0.4586|0.1919|0.0309
-
-Создание и расчет модели при помощи пакета PyPharm  
-```python  
-from PyPharm import BaseCompartmentModel  
-  
-model = BaseCompartmentModel([[0, 0.4586], [0.1919, 0]], [0.0309, 0], volumes=[228, 629])  
-  
-res = model(90, d=5700, compartment_number=0)  
-```
-res - Результат работы решателя scipy solve_iv
-
-**3) Пример использования пакета для модели, где все параметры неизвестны** 
-
-Задана многокамерная модель такого вида
-
-```mermaid
-graph LR
-Br(Мозг) --'Kbr-'--> Is[Межклетачное пространство]
-Is --'Kbr+'-->Br
-Is--'Kis-'-->B(Кровь)
-B--'Kis+'-->Is
-B--'Ke'-->Out1((Выведение))
-B--'Ki+'-->I(Печень)
-I--'Ki-'-->Out2((Выведение))
-B--'Kh+'-->H(Сердце)
-H--'Kh-'-->B
-``` 
-При этом, известен лишь параметр Ke=0.077
-
-Создание и расчет модели при помощи пакета PyPharm, используя метод minimize:
-```python  
-from PyPharm import BaseCompartmentModel
-import numpy as np
-matrix = [[0, None, 0, 0, 0],
-[None, 0, None, 0, 0],
-[0, None, 0, None, None],
-[0, 0, 0, 0, 0],
-[0, 0, None, 0, 0]]
-outputs = [0, 0, 0.077, None, 0]
-
-model = BaseCompartmentModel(matrix, outputs)
-
-model.load_optimization_data(
-	teoretic_x=[0.25, 0.5, 1, 4, 8, 24],
-	teoretic_y=[[0, 0, 11.2, 5.3, 5.42, 3.2], [268.5, 783.3, 154.6, 224.2, 92.6, 0], [342, 637, 466, 235, 179, 158]],
-	know_compartments=[0, 3, 4],
-	c0=[0, 0, 20000, 0, 0]
-)
-
-x_min = [1.5, 0.01, 0.5, 0.0001, 0.1, 0.1, 4, 3]
-x_max = [2.5, 0.7, 1.5, 0.05, 0.5, 0.5, 7, 5]
-x0 = np.random.uniform(x_min, x_max)
-bounds = ((1.5, 2.5), (0.01, 0.7), (0.5, 1.5), (0.0001, 0.05), (0.1, 0.5), (0.1, 0.5), (4, 7), (3, 5))
-
-model.optimize(
-	bounds=bounds,
-	x0=x0,
-	options={'disp': True}
-)
-
-print(model.configuration_matrix)
-```
-Или же при помощи алгоритма взаимодействующих стран
-```python
-from PyPharm import BaseCompartmentModel
-import numpy as np
-matrix = [[0, None, 0, 0, 0],
-[None, 0, None, 0, 0],
-[0, None, 0, None, None],
-[0, 0, 0, 0, 0],
-[0, 0, None, 0, 0]]
-outputs = [0, 0, 0.077, None, 0]
-
-model = BaseCompartmentModel(matrix, outputs)
-
-model.load_optimization_data(
-	teoretic_x=[0.25, 0.5, 1, 4, 8, 24],
-	teoretic_y=[[0, 0, 11.2, 5.3, 5.42, 3.2], [268.5, 783.3, 154.6, 224.2, 92.6, 0], [342, 637, 466, 235, 179, 158]],
-	know_compartments=[0, 3, 4],
-	c0=[0, 0, 20000, 0, 0]
-)
-
-model.optimize(
-	method='country_optimization',
-	Xmin=[0.5, 0.001, 0.001, 0.00001, 0.01, 0.01, 1, 1],
-	Xmax=[5, 2, 2.5, 0.3, 1, 1, 10, 10],
-	M=10,
-	N=25,
-	n=[1, 10],
-	p=[0.00001, 2],
-	m=[1, 8],
-	k=8,
-	l=3,
-	ep=[0.2, 0.4],
-	tmax=300,
-	printing=True,
-)
-```