pypharm 1.4.2__tar.gz → 1.5.0__tar.gz

{pypharm-1.4.2 → pypharm-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypharm
-Version: 1.4.2
+Version: 1.5.0
 Summary: Module for solving pharmacokinetic problems
 Home-page: https://github.com/Krash13/PyPharm
 Author: Krash13

pypharm-1.5.0/PyPharm/constants.py

@@ -0,0 +1,81 @@
+MODEL_CONST = {
+    'human':{
+                  'adipose': {'V':143, 'Q': 60 * 3.7},
+                  'bone': {'V':124, 'Q': 60 *  3.6} ,
+                  'brain': {'V':20.7, 'Q': 60 *  10} ,
+                  'gut': {'V':23.6, 'Q': 60 *  13} ,
+                  'heart': {'V':3.8, 'Q': 60 *  2.14},
+                  'kidney': {'V':4.4, 'Q': 60 *  15.7} ,
+                  'liver': {'V':24.1, 'Q': 60 *  21} ,
+                  'lung': {'V':16.7, 'Q': 60 *  71} ,
+                  'muscle': {'V':429, 'Q': 60 *  10.7} ,
+                  'pancreas': {'V':1.2, 'Q': 60 *  1.9} ,
+                  'skin': {'V':111, 'Q': 60 *  4.3} ,
+                  'spleen': {'V':2.7, 'Q': 60 *  1.1},
+                  'stomach': {'V':2.2, 'Q': 60 * 0.56},
+                  'teaster': {'V':0.51, 'Q': 60 * 0.04},
+                  'arterial_blood': {'V':25.7} ,
+                  'venous_blood': {'V':51.4}
+               },
+               'rat':{
+                  'adipose': {'V':40, 'Q': 60 * 1.6},
+                  'bone': {'V':53.2, 'Q': 60 *  10.12},
+                  'brain': {'V':6.8, 'Q': 60 *  5.32}  ,
+                  'gut': {'V':40, 'Q': 60 *  52}  ,
+                  'heart': {'V':3.2, 'Q': 60 *  15.68},
+                  'kidney': {'V':9.2, 'Q': 60 *  36.92},
+                  'liver': {'V':41.2, 'Q': 60 *  80}  ,
+                  'lung': {'V':4, 'Q': 60 *  203.2}   ,
+                  'muscle': {'V':487.6, 'Q': 60 *  30} ,
+                  'pancreas': {'V':5.2, 'Q': 60 *  4}  ,
+                  'skin': {'V':160, 'Q': 60 *  20}   ,
+                  'spleen': {'V':2.4, 'Q': 60 *  5}  ,
+                  'stomach': {'V':4.4, 'Q': 60 * 8.2} ,
+                  'teaster': {'V':10, 'Q': 60 * 1.8}   ,
+                  'arterial_blood': {'V':22.4}  ,
+                  # 'arterial_blood': {'V':22.4, 'Q': 60 * 10.8}  ,
+                  'venous_blood': {'V':45.2}
+               },
+                'mouse': {
+                    'adipose': {'V': 1000 * 1e-3 / 0.02, 'Q': 60 * 4e-5 * 1000 / 0.02},
+                    'bone': {'V': 1000 * 1.58e-3 / 0.02, 'Q': 60 * 2.53e-4 * 1000 / 0.02},
+                    'brain': {'V': 1000 * 1.7e-4 / 0.02, 'Q': 60 * 1.3e-4 * 1000 / 0.02},
+                    'gut': {'V': 1000 * 6.27e-4 / 0.02, 'Q': 60 * 5e-4 * 1000 / 0.02},
+                    'heart': {'V': 1000 * 9.5e-5 / 0.02, 'Q': 60 * 2.8e-4 * 1000 / 0.02},
+                    'kidney': {'V': 1000 * 3.4e-4 / 0.02, 'Q': 60 * 1.3e-3 * 1000 / 0.02},
+                    'liver': {'V': 1000 * 1e-3/ 0.02, 'Q' : 60 * 3.5e-4 * 1000 / 0.02},
+                    'lung': {'V': 1000 * 1e-4 / 0.02, 'Q': 60 * 5.47e-3 * 1000 / 0.02},
+                    'muscle': {'V': 1000 * 0.01e-1 / 0.02, 'Q': 60 * 9.1e-4 * 1000 / 0.02},
+                    'pancreas': {'V': 1000 * 1.3e-4 / 0.02, 'Q': 60 * 5.2e-5 * 1000 / 0.02},
+                    'skin': {'V': 1000 * 2.9e-3 / 0.02, 'Q': 60 * 4.1e-4 * 1000 / 0.02},
+                    'spleen': {'V': 1000 * 1e-4 / 0.02, 'Q': 60 * 9e-5 * 1000 / 0.02},
+                    'stomach': {'V': 1000 * 1.1e-4 / 0.02, 'Q': 60 * 1.1e-4 * 1000 / 0.02},
+                    'teaster': {'V': 1, 'Q': 1},
+                    'arterial_blood': {'V': 1000 * 2.28e-4 / 0.02},
+                    # 'arterial_blood': {'V':22.4, 'Q': 60 * 10.8}  ,
+                    'venous_blood': {'V': 1000 * 5.25e-4 / 0.02}
+                }
+}
+
+class ORGAN_NAMES:
+
+    LUNG = 'lung'
+    HEART = 'heart'
+    BRAIN = 'brain'
+    MUSCLE = 'muscle'
+    ADIPOSE = 'adipose'
+    SKIN = 'skin'
+    BONE = 'bone'
+    KIDNEY = 'kidney'
+    LIVER = 'liver'
+    GUT = 'gut'
+    SPLEEN = 'spleen'
+    STOMACH = 'stomach'
+    PANCREAS = 'pancreas'
+    VENOUS = 'venous_blood'
+    ARTERIAL = 'arterial_blood'
+
+class ANIMALS:
+    HUMAN = 'human'
+    RAT = 'rat'
+    MOUSE = 'mouse'

{pypharm-1.4.2 → pypharm-1.5.0}/PyPharm/models/compartment_models.py

@@ -4,9 +4,9 @@ import numpy as np
 from scipy.integrate import solve_ivp, RK45
 from scipy.integrate import simps
 from scipy.optimize import minimize
-from ..algorithms.country_optimization import CountriesAlgorithm
-from ..algorithms.country_optimization_v2 import CountriesAlgorithm_v2
-from ..algorithms.genetic_optimization import GeneticAlgorithm
+from PyPharm.algorithms.country_optimization import CountriesAlgorithm
+from PyPharm.algorithms.country_optimization_v2 import CountriesAlgorithm_v2
+from PyPharm.algorithms.genetic_optimization import GeneticAlgorithm
 from numba import njit
 import matplotlib.pyplot as plt
 
@@ -127,7 +127,8 @@ class BaseCompartmentModel:
             t_span=ts,
             y0=c0,
             max_step=max_step,
-            t_eval=t_eval
+            t_eval=t_eval,
+            method='LSODA'
         )
         return self.last_result
 

pypharm-1.5.0/PyPharm/models/pbpk.py

@@ -0,0 +1,672 @@
+import inspect
+from numbalsoda import lsoda_sig, lsoda
+import numpy as np
+from scipy.integrate import solve_ivp, LSODA
+from scipy.optimize import minimize
+from PyPharm.algorithms.country_optimization import CountriesAlgorithm
+from PyPharm.algorithms.country_optimization_v2 import CountriesAlgorithm_v2
+from PyPharm.algorithms.genetic_optimization import GeneticAlgorithm
+from PyPharm.constants import MODEL_CONST, ORGAN_NAMES, ANIMALS
+from numba import njit, types, cfunc
+from numba.typed import Dict
+import matplotlib.pyplot as plt
+
+
+
+class PBPKmod:
+
+    _organs = ['lung', 'heart', 'brain', 'muscle', 'adipose', 'skin', 'bone', 'kidney',
+                  'liver', 'gut', 'spleen', 'stomach', 'pancreas', 'venous_blood', 'arterial_blood']
+    _cl_organs = ['kidney', 'liver']
+    
+    def __init__(self, know_k=None, know_cl=None, numba_option=False, lsoda_option=False):
+
+        self.know_k = know_k if know_k is not None else {}
+        self.know_cl = know_cl if know_cl is not None else {}
+        self._optim = False
+        self.numba_option = numba_option
+        self.lsoda_option = lsoda_option
+        if numba_option or lsoda_option:
+            self.cnst_v_dict = {}
+            for key in MODEL_CONST:
+                cnst_v = Dict.empty(
+                    key_type=types.unicode_type,
+                    value_type=types.float64
+                )
+                for k, v in MODEL_CONST[key].items():
+                    cnst_v[k] = v['V']
+                self.cnst_v_dict[key] = cnst_v
+            self.cnst_q_dict = {}
+            for key in MODEL_CONST:
+                cnst_q = Dict.empty(
+                    key_type=types.unicode_type,
+                    value_type=types.float64
+                )
+                for k, v in MODEL_CONST[key].items():
+                    if v.get('Q'):
+                        cnst_q[k] = v['Q']
+                self.cnst_q_dict[key] = cnst_q
+
+    def load_optimization_data(self, time_exp, dict_c_exp, start_c_in_venous, animal=ANIMALS.MOUSE):
+        self.time_exp = time_exp
+        self.dict_c_exp = dict_c_exp
+        self.start_c_in_venous = start_c_in_venous
+        self.animal = animal
+
+    def _get_sol_difurs(self):
+        return self(max(self.time_exp), self.start_c_in_venous, self.animal)
+
+    def fitness(self, k_cl):
+
+        self.k_cl = k_cl
+
+        sol_difurs = self._get_sol_difurs()
+        # Список для хранения результатов
+        present_organs_indices = []
+
+        # Проверяем, какие ключи из 'organs' есть в 'dict_n'
+        for organ in self._organs:
+            if organ in self.dict_c_exp:
+                index = self._organs.index(organ)  # Получаем индекс органа в списке organs
+                present_organs_indices.append((organ, index))
+
+        rez_err = 0
+        for organ, index in present_organs_indices:
+            mean_y = sum(sol_difurs[index]) / len(sol_difurs[index])
+            a = [(sol_difurs[index][self.time_exp[i]] - self.dict_c_exp[organ][i]) ** 2 for i in range(len(self.dict_c_exp[organ]))]
+            a = sum(a)
+            b = [(mean_y - self.dict_c_exp[organ][i]) ** 2 for i in
+                 range(len(self.dict_c_exp[organ]))]
+            b = sum(b)
+            rez_err += a / b
+            # rez_err += sum([abs(sol_difurs[:, index][self.time_exp[i]] - self.dict_c_exp[organ][i]) for i in
+            #                 range(len(self.dict_c_exp[organ]))])
+
+        return rez_err
+    def _get_result(self, fun, t, max_time, K_CL, animal=ANIMALS.MOUSE):
+        if not self.lsoda_option:
+            return solve_ivp(
+                fun=fun,
+                t_span=[0, max_time],
+                y0=self.y0,
+                t_eval=t,
+                method=LSODA,
+            )
+        else:
+            return lsoda(
+                funcptr=fun,
+                u0=np.array(self.y0, dtype=np.float64),
+                t_eval=np.array(t, dtype=np.float64),
+                data=np.array(K_CL, dtype=np.float64),
+            )
+
+    def _prepare_result(self, t, res):
+        if not self.lsoda_option:
+            self._res = res.y
+        else:
+            res = res.T
+            self._res = res
+        self.last_result = {
+            't': t * 60
+        }
+        if not self.lsoda_option:
+            for organ in self._organs:
+                index = self._organs.index(organ)
+                self.last_result[organ] = res.y[index]
+        else:
+            for organ in self._organs:
+                index = self._organs.index(organ)
+                self.last_result[organ] = res[index]
+
+    def __call__(self, max_time, start_c_in_venous, animal=ANIMALS.MOUSE, step=1.0):
+        self.y0 = [0 for _ in range(15)]  # всего в модели 15 органов
+        self.y0[-2] = start_c_in_venous
+        t = np.linspace(0, max_time, max_time + 1 if self._optim else int(1 / step * max_time) + 1) / 60
+
+        if not hasattr(self, 'k_cl'):
+            self.k_cl = []
+
+        full_k = []
+        i = 0
+        for name in self._organs:
+            know_k = self.know_k.get(name)
+            if know_k is not None:
+                full_k.append(know_k)
+            else:
+                full_k.append(self.k_cl[i])
+                i += 1
+        full_cl = []
+
+        for name in self._cl_organs:
+            know_k = self.know_cl.get(name)
+            if know_k is not None:
+                full_cl.append(know_k)
+            else:
+                full_cl.append(self.k_cl[i])
+                i += 1
+        if not self.numba_option and not self.lsoda_option:
+            res = self._get_result(
+                fun=lambda time, y: self.fullPBPKmodel(y, time, [*full_k, *full_cl], animal),
+                t=t,
+                max_time=max_time,
+                K_CL=[*full_k, *full_cl],
+                animal=animal
+            )
+        elif self.lsoda_option:
+            cnst_v = self.cnst_v_dict[animal]
+            cnst_q = self.cnst_q_dict[animal]
+            res, success = self._get_result(
+                fun=self.lsoda_fullPBPK_for_optimization.address,
+                t=t,
+                max_time=max_time,
+                K_CL=[*full_k, *full_cl, *[cnst_q[key] for key in cnst_q.keys()], *[cnst_v[key] for key in cnst_v.keys()]],
+                animal=animal
+            )
+        else:
+            k_cl = np.array([*full_k, *full_cl])
+            cnst_v = self.cnst_v_dict[animal]
+            cnst_q = self.cnst_q_dict[animal]
+            function = lambda time, c: self.numba_fullPBPK_for_optimization(
+                y=c,
+                t=time,
+                K_CL=k_cl.astype(np.float64),
+                cnst_q=cnst_q,
+                cnst_v=cnst_v
+            )
+            res = self._get_result(
+                fun=function,
+                t=t,
+                max_time=max_time,
+                K_CL=[*full_k, *full_cl],
+                animal=animal
+            )
+        self._prepare_result(t, res)
+        return self._res
+
+    def plot_last_result(self, organ_names=[], left=None, right=None, user_names={}, theoretic_data={}, y_lims={}):
+        if hasattr(self, 'last_result'):
+            for name in organ_names:
+                if theoretic_data.get(name):
+                    plt.plot(theoretic_data[name]['x'], theoretic_data[name]['y'], '*r')
+                plt.plot(
+                    self.last_result['t'],
+                    self.last_result.get(name),
+                )
+                plt.title(user_names.get(name, name))
+                plt.xlim(left=left, right=right)
+                if y_lims.get(name):
+                    plt.ylim(y_lims.get(name))
+                plt.grid()
+                plt.show()
+
+    def optimize(self, method=None, user_method=None, method_is_func=True,
+                 optimization_func_name='__call__', **kwargs):
+        """
+        Функция оптимизации модели
+
+        Args:
+            method: Метод оптимизации, любой доступный minimize + 'country_optimization' и 'country_optimization_v2'
+            max_step: Максимальный шаг при решении СДУ
+            **kwargs: Дополнительные именованные аргументы
+
+        Returns:
+            None
+        """
+        self._optim = True
+        f = lambda x: self.fitness(x)
+        if user_method is not None:
+            if method_is_func:
+                x = user_method(f, **kwargs)
+            else:
+                optimization_obj = user_method(f, **kwargs)
+                x = getattr(optimization_obj, optimization_func_name)()
+        else:
+            if method == 'country_optimization':
+                CA = CountriesAlgorithm(
+                    f=f,
+                    memory_list=getattr(self, 'memory', None),
+                    **kwargs
+                )
+                CA.start()
+                x = CA.countries[0].population[0].x
+            elif method == 'country_optimization_v2':
+                CA = CountriesAlgorithm_v2(
+                    f=f,
+                    **kwargs
+                )
+                CA.start()
+                x = CA.countries[0].population[0].x
+            elif method == 'GA':
+                CA = GeneticAlgorithm(
+                    f=f,
+                    **kwargs
+                )
+                x = CA.start()
+            else:
+                res = minimize(
+                    fun=f,
+                    method=method,
+                    **kwargs
+                )
+                x = res.x
+        self._optim = False
+        return x
+
+    def update_know_params(self, k_cl=None):
+        if k_cl:
+            i = 0
+            for name in self._organs:
+                know_k = self.know_k.get(name)
+                if know_k is None:
+                    self.know_k[name] = k_cl[i]
+                    i += 1
+            for name in self._cl_organs:
+                know_cl = self.know_cl.get(name)
+                if know_cl is None:
+                    self.know_cl[name] = k_cl[i]
+                    i += 1
+
+    def get_unknown_params(self):
+        result = []
+        for name in self._organs:
+            know_k = self.know_k.get(name)
+            if know_k is None:
+                result.append(f"k_{name}")
+        for name in self._cl_organs:
+            know_cl = self.know_cl.get(name)
+            if know_cl is None:
+                result.append(f"cl_{name}")
+        return result
+
+    def fullPBPKmodel(self, y, t, K_CL, animal=ANIMALS.MOUSE):  # V, Q, K, CL):
+        # 15 органов
+        cnst = MODEL_CONST[animal]
+        C_lung, C_heart, C_brain, C_muscle, C_fat, C_skin, C_bone, \
+            C_kidney, C_liver, C_gut, C_spleen, C_stomach, C_pancreas, C_V, C_A = y
+
+        K_lung, K_heart, K_brain, K_muscle, K_fat, K_skin, K_bone, \
+            K_kidney, K_liver, K_gut, K_spleen, K_stomach, K_pancreas, K_liver_cl, K_kidney_cl = K_CL[:15]
+        CL_kidney, CL_liver = K_CL[15:]
+
+        dC_lung_dt = cnst['lung']['Q'] * (C_V - C_lung / K_lung) / cnst['lung']['V']
+        dC_heart_dt = cnst['heart']['Q'] * (C_A - C_heart / K_heart) / cnst['heart']['V']
+        dC_brain_dt = cnst['brain']['Q'] * (C_A - C_brain / K_brain) / cnst['brain']['V']
+        dC_muscle_dt = cnst['muscle']['Q'] * (C_A - C_muscle / K_muscle) / cnst['muscle']['V']
+        dC_fat_dt = cnst['adipose']['Q'] * (C_A - C_fat / K_fat) / cnst['adipose']['V']
+        dC_skin_dt = cnst['skin']['Q'] * (C_A - C_skin / K_skin) / cnst['skin']['V']
+        dC_bone_dt = cnst['bone']['Q'] * (C_A - C_bone / K_bone) / cnst['bone']['V']
+        # Kidney        V(Kidney)*dC(Kidney)/dt = Q(Kidney)*C(A)-Q(Kidney)*CV(Kidney)-CL(Kidney,int)*CV(Kidney,int)?
+        dC_kidney_dt = (cnst['kidney']['Q'] * (C_A - C_kidney / K_kidney) - CL_kidney * C_kidney / K_kidney_cl) / \
+                       cnst['kidney']['V']  # ???
+
+        # Liver         V(Liver)*dC(Liver)/dt = (Q(Liver)-Q(Spleen)-Q(Gut)-Q(Pancreas)-Q(Stomach))*C(A) + Q(Spleen)*CV(Spleen) +
+        #                                     + Q(Gut)*CV(Gut) + Q(Pancreas)*CV(Pancreas) + Q(Stomach)*CV(Stomach) -
+        #                                     - Q(Liver)*CV(Liver) - CL(Liver,int)*CV(Liver,int)? # тут скорее всего нужно вычитать потоки из друг друга дополнительно по крови что бы сохранить массовый баланс
+        Q_liver_in_from_art = cnst['liver']['Q'] - cnst['gut']['Q'] - cnst['spleen']['Q'] - \
+                              cnst['pancreas']['Q'] - cnst['stomach']['Q']
+        dC_liver_dt = (
+                              Q_liver_in_from_art * C_A + cnst['gut']['Q'] * C_gut / K_gut
+                              + cnst['spleen']['Q'] * C_spleen / K_spleen
+                              + cnst['stomach']['Q'] * C_stomach / K_stomach
+                              + cnst['pancreas']['Q'] * C_pancreas / K_pancreas
+                              - cnst['liver']['Q'] * C_liver / K_liver
+                              - CL_liver * C_liver / K_liver_cl  # ???
+                      ) / cnst['liver']['V']
+
+        dC_gut_dt = cnst['gut']['Q'] * (C_A - C_gut / K_gut) / cnst['gut']['V']
+        dC_spleen_dt = cnst['spleen']['Q'] * (C_A - C_spleen / K_spleen) / cnst['spleen']['V']
+        dC_stomach_dt = cnst['stomach']['Q'] * (C_A - C_stomach / K_stomach) / cnst['stomach']['V']
+        dC_pancreas_dt = cnst['pancreas']['Q'] * (C_A - C_pancreas / K_pancreas) / cnst['pancreas']['V']
+
+        dC_venouse_dt = (
+                                cnst['heart']['Q'] * C_heart / K_heart
+                                + cnst['brain']['Q'] * C_brain / K_brain
+                                + cnst['muscle']['Q'] * C_muscle / K_muscle
+                                + cnst['skin']['Q'] * C_skin / K_skin
+                                + cnst['adipose']['Q'] * C_fat / K_fat
+                                + cnst['bone']['Q'] * C_bone / K_bone
+                                + cnst['kidney']['Q'] * C_kidney / K_kidney
+                                + cnst['liver']['Q'] * C_liver / K_liver
+                                - cnst['lung']['Q'] * C_V
+                        ) / cnst['venous_blood']['V']
+
+        dC_arterial_dt = cnst['lung']['Q'] * (C_lung / K_lung - C_A) / cnst['arterial_blood']['V']
+
+        y_new = [dC_lung_dt, dC_heart_dt, dC_brain_dt, dC_muscle_dt, dC_fat_dt, dC_skin_dt, dC_bone_dt, \
+                 dC_kidney_dt, dC_liver_dt, dC_gut_dt, dC_spleen_dt, dC_stomach_dt, dC_pancreas_dt, dC_venouse_dt,
+                 dC_arterial_dt]
+        return y_new
+
+    @staticmethod
+    @njit
+    def numba_fullPBPK_for_optimization(y, t, K_CL, cnst_q, cnst_v):
+        C_lung, C_heart, C_brain, C_muscle, C_fat, C_skin, C_bone, \
+            C_kidney, C_liver, C_gut, C_spleen, C_stomach, C_pancreas, C_V, C_A = y
+
+        K_lung, K_heart, K_brain, K_muscle, K_fat, K_skin, K_bone, \
+            K_kidney, K_liver, K_gut, K_spleen, K_stomach, K_pancreas, K_liver_cl, K_kidney_cl = K_CL[:15]
+        CL_kidney, CL_liver = K_CL[15:]
+
+        dC_lung_dt = cnst_q['lung'] * (C_V - C_lung / K_lung) / cnst_v['lung']
+        dC_heart_dt = cnst_q['heart'] * (C_A - C_heart / K_heart) / cnst_v['heart']
+        dC_brain_dt = cnst_q['brain'] * (C_A - C_brain / K_brain) / cnst_v['brain']
+        dC_muscle_dt = cnst_q['muscle'] * (C_A - C_muscle / K_muscle) / cnst_v['muscle']
+        dC_fat_dt = cnst_q['adipose'] * (C_A - C_fat / K_fat) / cnst_v['adipose']
+        dC_skin_dt = cnst_q['skin'] * (C_A - C_skin / K_skin) / cnst_v['skin']
+        dC_bone_dt = cnst_q['bone'] * (C_A - C_bone / K_bone) / cnst_v['bone']
+        # Kidney        V(Kidney)*dC(Kidney)/dt = Q(Kidney)*C(A)-Q(Kidney)*CV(Kidney)-CL(Kidney,int)*CV(Kidney,int)?
+        dC_kidney_dt = (cnst_q['kidney'] * (C_A - C_kidney / K_kidney) - CL_kidney * C_kidney / K_kidney_cl) / \
+                       cnst_v['kidney']  # ???
+
+        # Liver         V(Liver)*dC(Liver)/dt = (Q(Liver)-Q(Spleen)-Q(Gut)-Q(Pancreas)-Q(Stomach))*C(A) + Q(Spleen)*CV(Spleen) +
+        #                                     + Q(Gut)*CV(Gut) + Q(Pancreas)*CV(Pancreas) + Q(Stomach)*CV(Stomach) -
+        #                                     - Q(Liver)*CV(Liver) - CL(Liver,int)*CV(Liver,int)? # тут скорее всего нужно вычитать потоки из друг друга дополнительно по крови что бы сохранить массовый баланс
+        Q_liver_in_from_art = cnst_q['liver'] - cnst_q['gut'] - cnst_q['spleen'] - \
+                              cnst_q['pancreas'] - cnst_q['stomach']
+        dC_liver_dt = (
+                              Q_liver_in_from_art * C_A + cnst_q['gut'] * C_gut / K_gut
+                              + cnst_q['spleen'] * C_spleen / K_spleen
+                              + cnst_q['stomach'] * C_stomach / K_stomach
+                              + cnst_q['pancreas'] * C_pancreas / K_pancreas
+                              - cnst_q['liver'] * C_liver / K_liver
+                              - CL_liver * C_liver / K_liver_cl  # ???
+                      ) / cnst_v['liver']
+
+        dC_gut_dt = cnst_q['gut'] * (C_A - C_gut / K_gut) / cnst_v['gut']
+        dC_spleen_dt = cnst_q['spleen'] * (C_A - C_spleen / K_spleen) / cnst_v['spleen']
+        dC_stomach_dt = cnst_q['stomach'] * (C_A - C_stomach / K_stomach) / cnst_v['stomach']
+        dC_pancreas_dt = cnst_q['pancreas'] * (C_A - C_pancreas / K_pancreas) / cnst_v['pancreas']
+
+        dC_venouse_dt = (
+                                cnst_q['heart'] * C_heart / K_heart
+                                + cnst_q['brain'] * C_brain / K_brain
+                                + cnst_q['muscle'] * C_muscle / K_muscle
+                                + cnst_q['skin'] * C_skin / K_skin
+                                + cnst_q['adipose'] * C_fat / K_fat
+                                + cnst_q['bone'] * C_bone / K_bone
+                                + cnst_q['kidney'] * C_kidney / K_kidney
+                                + cnst_q['liver'] * C_liver / K_liver
+                                - cnst_q['lung'] * C_V
+                        ) / cnst_v['venous_blood']
+
+        dC_arterial_dt = cnst_q['lung'] * (C_lung / K_lung - C_A) / cnst_v['arterial_blood']
+
+        y_new = np.array([dC_lung_dt, dC_heart_dt, dC_brain_dt, dC_muscle_dt, dC_fat_dt, dC_skin_dt, dC_bone_dt, \
+                 dC_kidney_dt, dC_liver_dt, dC_gut_dt, dC_spleen_dt, dC_stomach_dt, dC_pancreas_dt, dC_venouse_dt,
+                 dC_arterial_dt]).astype(np.float64)
+        return y_new
+
+    @staticmethod
+    @cfunc(lsoda_sig)
+    def lsoda_fullPBPK_for_optimization(t, y, y_new, data):
+
+        C_lung = y[0]
+        C_heart = y[1]
+        C_brain = y[2]
+        C_muscle = y[3]
+        C_fat = y[4]
+        C_skin = y[5]
+        C_bone = y[6]
+        C_kidney = y[7]
+        C_liver = y[8]
+        C_gut = y[9]
+        C_spleen = y[10]
+        C_stomach = y[11]
+        C_pancreas = y[12]
+        C_V = y[13]
+        C_A = y[14]
+
+        K_lung = data[0]
+        K_heart = data[1]
+        K_brain = data[2]
+        K_muscle = data[3]
+        K_fat = data[4]
+        K_skin = data[5]
+        K_bone = data[6]
+        K_kidney = data[7]
+        K_liver = data[8]
+        K_gut = data[9]
+        K_spleen = data[10]
+        K_stomach = data[11]
+        K_pancreas = data[12]
+        K_liver_cl = data[13]
+        K_kidney_cl = data[14]
+        CL_kidney = data[15]
+        CL_liver = data[16]
+
+        cnst_q_adipose = data[17]
+        cnst_q_bone = data[18]
+        cnst_q_brain = data[19]
+        cnst_q_gut = data[20]
+        cnst_q_heart = data[21]
+        cnst_q_kidney = data[22]
+        cnst_q_liver = data[23]
+        cnst_q_lung = data[24]
+        cnst_q_muscle = data[25]
+        cnst_q_pancreas = data[26]
+        cnst_q_skin = data[27]
+        cnst_q_spleen = data[28]
+        cnst_q_stomach = data[29]
+        cnst_q_teaster = data[30]
+
+        cnst_v_adipose = data[31]
+        cnst_v_bone = data[32]
+        cnst_v_brain = data[33]
+        cnst_v_gut = data[34]
+        cnst_v_heart = data[35]
+        cnst_v_kidney = data[36]
+        cnst_v_liver = data[37]
+        cnst_v_lung = data[38]
+        cnst_v_muscle = data[39]
+        cnst_v_pancreas = data[40]
+        cnst_v_skin = data[41]
+        cnst_v_spleen = data[42]
+        cnst_v_stomach = data[43]
+        cnst_v_teaster = data[44]
+        cnst_v_arterial_blood = data[45]
+        cnst_v_venous_blood = data[46]
+
+        dC_lung_dt = cnst_q_lung * (C_V - C_lung / K_lung) / cnst_v_lung
+        dC_heart_dt = cnst_q_heart * (C_A - C_heart / K_heart) / cnst_v_heart
+        dC_brain_dt = cnst_q_brain * (C_A - C_brain / K_brain) / cnst_v_brain
+        dC_muscle_dt = cnst_q_muscle * (C_A - C_muscle / K_muscle) / cnst_v_muscle
+        dC_fat_dt = cnst_q_adipose * (C_A - C_fat / K_fat) / cnst_v_adipose
+        dC_skin_dt = cnst_q_skin * (C_A - C_skin / K_skin) / cnst_v_skin
+        dC_bone_dt = cnst_q_bone * (C_A - C_bone / K_bone) / cnst_v_bone
+        # Kidney        V(Kidney)*dC(Kidney)/dt = Q(Kidney)*C(A)-Q(Kidney)*CV(Kidney)-CL(Kidney,int)*CV(Kidney,int)?
+        dC_kidney_dt = (cnst_q_kidney * (C_A - C_kidney / K_kidney) - CL_kidney * C_kidney / K_kidney_cl) / \
+                       cnst_v_kidney  # ???
+
+        # Liver         V(Liver)*dC(Liver)/dt = (Q(Liver)-Q(Spleen)-Q(Gut)-Q(Pancreas)-Q(Stomach))*C(A) + Q(Spleen)*CV(Spleen) +
+        #                                     + Q(Gut)*CV(Gut) + Q(Pancreas)*CV(Pancreas) + Q(Stomach)*CV(Stomach) -
+        #                                     - Q(Liver)*CV(Liver) - CL(Liver,int)*CV(Liver,int)? # тут скорее всего нужно вычитать потоки из друг друга дополнительно по крови что бы сохранить массовый баланс
+        Q_liver_in_from_art = cnst_q_liver - cnst_q_gut - cnst_q_spleen - \
+                              cnst_q_pancreas - cnst_q_stomach
+        dC_liver_dt = (
+                              Q_liver_in_from_art * C_A + cnst_q_gut * C_gut / K_gut
+                              + cnst_q_spleen * C_spleen / K_spleen
+                              + cnst_q_stomach * C_stomach / K_stomach
+                              + cnst_q_pancreas * C_pancreas / K_pancreas
+                              - cnst_q_liver * C_liver / K_liver
+                              - CL_liver * C_liver / K_liver_cl  # ???
+                      ) / cnst_v_liver
+
+        dC_gut_dt = cnst_q_gut * (C_A - C_gut / K_gut) / cnst_v_gut
+        dC_spleen_dt = cnst_q_spleen * (C_A - C_spleen / K_spleen) / cnst_v_spleen
+        dC_stomach_dt = cnst_q_stomach * (C_A - C_stomach / K_stomach) / cnst_v_stomach
+        dC_pancreas_dt = cnst_q_pancreas * (C_A - C_pancreas / K_pancreas) / cnst_v_pancreas
+
+        dC_venouse_dt = (
+                                cnst_q_heart * C_heart / K_heart
+                                + cnst_q_brain * C_brain / K_brain
+                                + cnst_q_muscle * C_muscle / K_muscle
+                                + cnst_q_skin * C_skin / K_skin
+                                + cnst_q_adipose * C_fat / K_fat
+                                + cnst_q_bone * C_bone / K_bone
+                                + cnst_q_kidney * C_kidney / K_kidney
+                                + cnst_q_liver * C_liver / K_liver
+                                - cnst_q_lung * C_V
+                        ) / cnst_v_venous_blood
+
+        dC_arterial_dt = cnst_q_lung * (C_lung / K_lung - C_A) / cnst_v_arterial_blood
+        y_new[0] = dC_lung_dt
+        y_new[1] = dC_heart_dt
+        y_new[2] = dC_brain_dt
+        y_new[3] = dC_muscle_dt
+        y_new[4] = dC_fat_dt
+        y_new[5] = dC_skin_dt
+        y_new[6] = dC_bone_dt
+        y_new[7] = dC_kidney_dt
+        y_new[8] = dC_liver_dt
+        y_new[9] = dC_gut_dt
+        y_new[10] = dC_spleen_dt
+        y_new[11] = dC_stomach_dt
+        y_new[12] = dC_pancreas_dt
+        y_new[13] = dC_venouse_dt
+        y_new[14] = dC_arterial_dt
+
+        # y_new = [dC_lung_dt, dC_heart_dt, dC_brain_dt, dC_muscle_dt, dC_fat_dt, dC_skin_dt, dC_bone_dt, \
+        #          dC_kidney_dt, dC_liver_dt, dC_gut_dt, dC_spleen_dt, dC_stomach_dt, dC_pancreas_dt, dC_venouse_dt,
+        #          dC_arterial_dt]
+
+
+class ReleasePBPKmod(PBPKmod):
+    
+    @staticmethod
+    def ode_release(solver, t, y0, release_function, d, v, is_lsoda=False):
+        result = []
+        new_y0 = y0
+        old_release_correction = 0
+        for i in range(1, len(t)):
+            if is_lsoda:
+                res, _ = solver(new_y0, t[i - 1], t[i])
+                y = res.T
+            else:
+                res = solver(new_y0, t[i - 1], t[i])
+                y = res.y
+            release_correction = release_function(t[i], d)
+            plus_release = release_correction - old_release_correction
+            all_corrections = plus_release
+            y[-2][1] += all_corrections / v
+            old_release_correction = release_correction
+            if i == 1:
+                result.append([y[i][0] for i in range(y.shape[0])])
+            new_y0 = np.array([y[i][1] for i in range(y.shape[0])])
+            result.append(new_y0)
+        return np.array(result).T
+
+    def __init__(self, release_parameters: dict=None, release_function: callable=None, know_k=None, know_cl=None, numba_option=False, lsoda_option=False):
+        super().__init__(
+            know_k=know_k, know_cl=know_cl, numba_option=numba_option, lsoda_option=lsoda_option
+        )
+        self.release_function = release_function
+        if release_parameters is None:
+            self.release_parameters = {}
+        else:
+            self.release_parameters = release_parameters
+        self.know_release_parameters = set(self.release_parameters.keys())
+
+    @staticmethod
+    def _default_release_function(t, d, m, b, c):
+        """
+        Функция для поправки на высвобождение
+        """
+        return d * c * t ** b / (t ** b + m)
+
+    def get_release_function(self):
+        return lambda t, d: self._get_release_function()(t, d, **self.release_parameters)
+
+    def _get_release_function(self):
+        if self.release_function is not None:
+            return self.release_function
+        else:
+            return self._default_release_function
+
+    @property
+    def _release_parameters_list(self) -> list[str]:
+        method = self._get_release_function()
+        arguments = inspect.getfullargspec(method).args
+        return [arg for arg in arguments if arg not in {'t', 'd'}]
+
+    def get_unknown_params(self):
+        result = super().get_unknown_params()
+        arguments = self._release_parameters_list
+        for arg in arguments:
+            know_arg = self.release_parameters.get(arg)
+            if know_arg is None:
+                result.append(f"release_{arg}")
+        return result
+
+    def update_know_params(self, k_cl=None, release_parameters=None):
+        super().update_know_params(k_cl)
+        if release_parameters is not None:
+            self.release_parameters = release_parameters
+            self.know_release_parameters = set(self.release_parameters.keys())
+
+    def _get_sol_difurs(self):
+        return self(max(self.time_exp), self.d, self.animal)
+
+    def fitness(self, x):
+
+        n = len(self._organs) + len(self._cl_organs) - len(self.know_cl) - len(self.know_k)
+        self.k_cl = x[:n]
+        i = 0
+        for arg in self._release_parameters_list:
+            if not arg in self.know_release_parameters:
+                self.release_parameters[arg] = x[n + i]
+                i += 1
+        return super().fitness(self.k_cl)
+
+    def _get_result(self, fun, t, max_time, K_CL, animal):
+        if not self.lsoda_option:
+            solver = lambda y0, t_left, t_right: solve_ivp(
+                fun=fun,
+                t_span=[t_left, t_right],
+                y0=y0,
+                t_eval=np.array([t_left, t_right]),
+                method=LSODA
+            )
+            return self.ode_release(solver, t, self.y0, d=self.d, v=self.v, release_function=self.get_release_function())
+        else:
+            solver = lambda y0, t_left, t_right: lsoda(
+                funcptr=fun,
+                u0=np.array(y0, dtype=np.float64),
+                t_eval=np.array([t_left, t_right], dtype=np.float64),
+                data=np.array(K_CL, dtype=np.float64),
+            )
+            return self.ode_release(solver, t, self.y0, d=self.d, v=self.v,
+                                    release_function=self.get_release_function(), is_lsoda=True), True
+
+    def _prepare_result(self, t, res):
+        self._res = res
+        self.last_result = {
+            't': t * 60
+        }
+        for organ in self._organs:
+            index = self._organs.index(organ)
+            self.last_result[organ] = res[index]
+
+    def __call__(self, max_time, d, animal=ANIMALS.MOUSE, step=1.0):
+        self.d = d
+        const = MODEL_CONST[animal]
+        self.v = const['venous_blood']['V']
+        return super().__call__(
+            max_time=max_time,
+            start_c_in_venous=0,
+            animal=animal,
+            step=step
+        )
+
+    def optimize(self, method=None, user_method=None, method_is_func=True,
+                 optimization_func_name='__call__', **kwargs):
+
+        return super().optimize(
+            method=method, user_method=user_method, method_is_func=method_is_func,
+            optimization_func_name=optimization_func_name, **kwargs
+        )
+
+    def load_optimization_data(self, time_exp, dict_c_exp, d, animal=ANIMALS.MOUSE):
+        self.time_exp = time_exp
+        self.dict_c_exp = dict_c_exp
+        self.d = d
+        self.animal = animal

{pypharm-1.4.2 → pypharm-1.5.0}/pypharm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypharm
-Version: 1.4.2
+Version: 1.5.0
 Summary: Module for solving pharmacokinetic problems
 Home-page: https://github.com/Krash13/PyPharm
 Author: Krash13

{pypharm-1.4.2 → pypharm-1.5.0}/pypharm.egg-info/requires.txt

@@ -1,5 +1,6 @@
 numpy>=1.22.1
-scipy>=1.8.0
+scipy<=1.13.0
 numba>=0.58.1
 matplotlib>=3.5.1
 graycode>=1.0.5
+numbalsoda>=0.3.4

{pypharm-1.4.2 → pypharm-1.5.0}/setup.py

@@ -6,7 +6,7 @@ def readme():
 
 setup(
   name='pypharm',
-  version='1.4.2',
+  version='1.5.0',
   author='Krash13',
   author_email='krasheninnikov.r.s@muctr.ru',
   description='Module for solving pharmacokinetic problems',
@@ -14,7 +14,8 @@ setup(
   long_description_content_type='text/markdown',
   url='https://github.com/Krash13/PyPharm',
   packages=find_packages(),
-  install_requires=['numpy>=1.22.1', 'scipy>=1.8.0', 'numba>=0.58.1', 'matplotlib>=3.5.1', 'graycode>=1.0.5'],
+  install_requires=['numpy>=1.22.1', 'scipy<=1.13.0', 'numba>=0.58.1',
+                    'matplotlib>=3.5.1', 'graycode>=1.0.5', 'numbalsoda>=0.3.4'],
   classifiers=[
     'Programming Language :: Python :: 3.9',
     'License :: OSI Approved :: BSD License',

pypharm-1.4.2/PyPharm/constants.py

@@ -1,56 +0,0 @@
-MODEL_CONST = {
-    'human':{
-                  'adipose': {'V':143, 'Q':3.7},
-                  'bone': {'V':124, 'Q': 3.6} ,
-                  'brain': {'V':20.7, 'Q': 10} ,
-                  'gut': {'V':23.6, 'Q': 13} ,
-                  'heart': {'V':3.8, 'Q': 2.14},
-                  'kidney': {'V':4.4, 'Q': 15.7} ,
-                  'liver': {'V':24.1, 'Q': 21} ,
-                  'lung': {'V':16.7, 'Q': 71} ,
-                  'muscle': {'V':429, 'Q': 10.7} ,
-                  'pancreas': {'V':1.2, 'Q': 1.9} ,
-                  'skin': {'V':111, 'Q': 4.3} ,
-                  'spleen': {'V':2.7, 'Q': 1.1},
-                  'stomach': {'V':2.2, 'Q':0.56},
-                  'teaster': {'V':0.51, 'Q':0.04},
-                  'arterial_blood': {'V':25.7} ,
-                  'venous_blood': {'V':51.4}
-               },
-               'rat':{
-                  'adipose': {'V':40, 'Q':1.6},
-                  'bone': {'V':53.2, 'Q': 10.12},
-                  'brain': {'V':6.8, 'Q': 5.32}  ,
-                  'gut': {'V':40, 'Q': 52}  ,
-                  'heart': {'V':3.2, 'Q': 15.68},
-                  'kidney': {'V':9.2, 'Q': 36.92},
-                  'liver': {'V':41.2, 'Q': 80}  ,
-                  'lung': {'V':4, 'Q': 203.2}   ,
-                  'muscle': {'V':487.6, 'Q': 30} ,
-                  'pancreas': {'V':5.2, 'Q': 4}  ,
-                  'skin': {'V':160, 'Q': 20}   ,
-                  'spleen': {'V':2.4, 'Q': 5}  ,
-                  'stomach': {'V':4.4, 'Q':8.2} ,
-                  'teaster': {'V':10, 'Q':1.8}   ,
-                  'arterial_blood': {'V':22.4, 'Q':10.8}  ,
-                  'venous_blood': {'V':45.2}
-               }
-}
-
-class ORGAN_NAMES:
-
-    LUNG = 'lung'
-    HEART = 'heart'
-    BRAIN = 'brain'
-    MUSCLE = 'muscle'
-    ADIPOSE = 'adipose'
-    SKIN = 'skin'
-    BONE = 'bone'
-    KIDNEY = 'kidney'
-    LIVER = 'liver'
-    GUT = 'gut'
-    SPLEEN = 'spleen'
-    STOMACH = 'stomach'
-    PANCREAS = 'pancreas'
-    VENOUS = 'venous_blood'
-    ARTERIAL = 'arterial_blood'

pypharm-1.4.2/PyPharm/models/pbpk.py

@@ -1,369 +0,0 @@
-from multiprocessing import shared_memory
-import datetime
-import numpy as np
-from scipy.integrate import solve_ivp, RK45, odeint
-from scipy.integrate import simps
-from scipy.optimize import minimize
-from PyPharm.algorithms.country_optimization import CountriesAlgorithm
-from PyPharm.algorithms.country_optimization_v2 import CountriesAlgorithm_v2
-from PyPharm.algorithms.genetic_optimization import GeneticAlgorithm
-from PyPharm.constants import MODEL_CONST, ORGAN_NAMES
-from numba import njit, types
-from numba.typed import Dict
-import matplotlib.pyplot as plt
-
-cnst_rat = MODEL_CONST['rat']
-cnst_human = MODEL_CONST['human']
-
-
-class PBPKmod:
-
-    _organs = ['lung', 'heart', 'brain', 'muscle', 'adipose', 'skin', 'bone', 'kidney',
-                  'liver', 'gut', 'spleen', 'stomach', 'pancreas', 'venous_blood', 'arterial_blood']
-    _cl_organs = ['kidney', 'liver']
-    
-    def __init__(self, know_k={}, know_cl={}, numba_option=False):
-        self.know_k = know_k
-        self.know_cl = know_cl
-        self._optim = False
-        self.numba_option = numba_option
-        if numba_option:
-            self.cnst_v_rat = Dict.empty(
-                key_type=types.unicode_type,
-                value_type=types.float64
-            )
-            for k, v in cnst_rat.items():
-                self.cnst_v_rat[k] = v['V']
-            self.cnst_v_human = Dict.empty(
-                key_type=types.unicode_type,
-                value_type=types.float64
-            )
-            for k, v in cnst_human.items():
-                self.cnst_v_human[k] = v['V']
-            self.cnst_q_rat = Dict.empty(
-                key_type=types.unicode_type,
-                value_type=types.float64
-            )
-            for k, v in cnst_rat.items():
-                if v.get('Q'):
-                    self.cnst_q_rat[k] = v['Q']
-            self.cnst_q_human = Dict.empty(
-                key_type=types.unicode_type,
-                value_type=types.float64
-            )
-            for k, v in cnst_human.items():
-                if v.get('Q'):
-                    self.cnst_q_human[k] = v['Q']
-
-    def load_optimization_data(self, time_exp, dict_c_exp, start_c_in_venous, is_human=False):
-        self.time_exp = time_exp
-        self.dict_c_exp = dict_c_exp
-        self.start_c_in_venous = start_c_in_venous
-        self.is_human = is_human
-
-    def fitness(self, k_cl):
-
-        self.k_cl = k_cl
-
-        sol_difurs = self(max(self.time_exp), self.start_c_in_venous, self.is_human)
-        # Список для хранения результатов
-        present_organs_indices = []
-
-        # Проверяем, какие ключи из 'organs' есть в 'dict_n'
-        for organ in self._organs:
-            if organ in self.dict_c_exp:
-                index = self._organs.index(organ)  # Получаем индекс органа в списке organs
-                present_organs_indices.append((organ, index))
-
-        rez_err = 0
-        for organ, index in present_organs_indices:
-            mean_y = sum(sol_difurs[:, index]) / len(sol_difurs[:, index])
-            a = [(sol_difurs[:, index][self.time_exp[i]] - self.dict_c_exp[organ][i]) ** 2 for i in range(len(self.dict_c_exp[organ]))]
-            a = sum(a)
-            b = [(mean_y - self.dict_c_exp[organ][i]) ** 2 for i in
-                 range(len(self.dict_c_exp[organ]))]
-            b = sum(b)
-            rez_err += a / b
-            # rez_err += sum([abs(sol_difurs[:, index][self.time_exp[i]] - self.dict_c_exp[organ][i]) for i in
-            #                 range(len(self.dict_c_exp[organ]))])
-
-        return rez_err
-    
-    def __call__(self, max_time, start_c_in_venous, is_human=False, step=1):
-        self.y0 = [0 for _ in range(15)]  # всего в модели 15 органов
-        self.y0[-2] = start_c_in_venous
-        t = np.linspace(0, max_time, max_time + 1 if self._optim else int(1 / step * max_time) + 1)
-        
-        if not hasattr(self, 'k_cl'):
-            self.k_cl = []
-
-        full_k = []
-        i = 0
-        for name in self._organs:
-            know_k = self.know_k.get(name)
-            if know_k is not None:
-                full_k.append(know_k)
-            else:
-                full_k.append(self.k_cl[i])
-                i += 1
-        full_cl = []
-
-        for name in self._cl_organs:
-            know_k = self.know_cl.get(name)
-            if know_k is not None:
-                full_cl.append(know_k)
-            else:
-                full_cl.append(self.k_cl[i])
-                i += 1
-        if not self.numba_option:
-            sol_difurs = odeint(
-                self.fullPBPKmodel,
-                self.y0,
-                t,
-                args=([*full_k, *full_cl], is_human)
-            )
-        else:
-            k_cl = np.array([*full_k, *full_cl])
-            if is_human:
-                cnst_v = self.cnst_v_human
-                cnst_q = self.cnst_q_human
-            else:
-                cnst_v = self.cnst_v_rat
-                cnst_q = self.cnst_q_rat
-            function = lambda c, t: self.numba_fullPBPK_for_optimization(
-                y=c,
-                t=t,
-                K_CL=k_cl.astype(np.float64),
-                cnst_q=cnst_q,
-                cnst_v=cnst_v
-            )
-            sol_difurs = odeint(
-                function,
-                self.y0,
-                t
-            )
-        if self._optim:
-            return sol_difurs
-
-        self.last_result = {
-            't': t
-        }
-        for organ in self._organs:
-            index = self._organs.index(organ)
-            self.last_result[organ] = np.array([sol_difurs[i][index] for i in range(t.size)])
-        return self.last_result
-
-    def plot_last_result(self, organ_names=[], left=None, right=None, user_names={}, theoretic_data={}, y_lims={}):
-        if hasattr(self, 'last_result'):
-            for name in organ_names:
-                if theoretic_data.get(name):
-                    plt.plot(theoretic_data[name]['x'], theoretic_data[name]['y'], '*r')
-                plt.plot(
-                    self.last_result['t'],
-                    self.last_result.get(name),
-                )
-                plt.title(user_names.get(name, name))
-                plt.xlim(left=left, right=right)
-                if y_lims.get(name):
-                    plt.ylim(y_lims.get(name))
-                plt.grid()
-                plt.show()
-
-    def optimize(self, method=None, user_method=None, method_is_func=True,
-                 optimization_func_name='__call__', **kwargs):
-        """
-        Функция оптимизации модели
-
-        Args:
-            method: Метод оптимизации, любой доступный minimize + 'country_optimization' и 'country_optimization_v2'
-            max_step: Максимальный шаг при решении СДУ
-            **kwargs: Дополнительные именованные аргументы
-
-        Returns:
-            None
-        """
-        self._optim = True
-        f = lambda x: self.fitness(x)
-        if user_method is not None:
-            if method_is_func:
-                x = user_method(f, **kwargs)
-            else:
-                optimization_obj = user_method(f, **kwargs)
-                x = getattr(optimization_obj, optimization_func_name)()
-        else:
-            if method == 'country_optimization':
-                CA = CountriesAlgorithm(
-                    f=f,
-                    memory_list=getattr(self, 'memory', None),
-                    **kwargs
-                )
-                CA.start()
-                x = CA.countries[0].population[0].x
-            elif method == 'country_optimization_v2':
-                CA = CountriesAlgorithm_v2(
-                    f=f,
-                    **kwargs
-                )
-                CA.start()
-                x = CA.countries[0].population[0].x
-            elif method == 'GA':
-                CA = GeneticAlgorithm(
-                    f=f,
-                    **kwargs
-                )
-                x = CA.start()
-            else:
-                res = minimize(
-                    fun=f,
-                    method=method,
-                    **kwargs
-                )
-                x = res.x
-        self._optim = False
-        return x
-
-    def update_know_params(self, k_cl):
-        i = 0
-        for name in self._organs:
-            know_k = self.know_k.get(name)
-            if know_k is None:
-                self.know_k[name] = k_cl[i]
-                i += 1
-        for name in self._cl_organs:
-            know_cl = self.know_cl.get(name)
-            if know_cl is None:
-                self.know_cl[name] = k_cl[i]
-                i += 1
-
-    def get_unknown_params(self):
-        result = []
-        for name in self._organs:
-            know_k = self.know_k.get(name)
-            if know_k is None:
-                result.append(f"k_{name}")
-        for name in self._cl_organs:
-            know_cl = self.know_cl.get(name)
-            if know_cl is None:
-                result.append(f"cl_{name}")
-        return result
-
-    def fullPBPKmodel(self, y, t, K_CL, is_human=False):  # V, Q, K, CL):
-        # 15 органов
-        if is_human:
-            cnst = cnst_human
-        else:
-            cnst = cnst_rat
-        C_lung, C_heart, C_brain, C_muscle, C_fat, C_skin, C_bone, \
-            C_kidney, C_liver, C_gut, C_spleen, C_stomach, C_pancreas, C_V, C_A = y
-
-        K_lung, K_heart, K_brain, K_muscle, K_fat, K_skin, K_bone, \
-            K_kidney, K_liver, K_gut, K_spleen, K_stomach, K_pancreas, K_liver_cl, K_kidney_cl = K_CL[:15]
-        CL_kidney, CL_liver = K_CL[15:]
-
-        dC_lung_dt = cnst['lung']['Q'] * (C_V - C_lung / K_lung) / cnst['lung']['V']
-        dC_heart_dt = cnst['heart']['Q'] * (C_A - C_heart / K_heart) / cnst['heart']['V']
-        dC_brain_dt = cnst['brain']['Q'] * (C_A - C_brain / K_brain) / cnst['brain']['V']
-        dC_muscle_dt = cnst['muscle']['Q'] * (C_A - C_muscle / K_muscle) / cnst['muscle']['V']
-        dC_fat_dt = cnst['adipose']['Q'] * (C_A - C_fat / K_fat) / cnst['adipose']['V']
-        dC_skin_dt = cnst['skin']['Q'] * (C_A - C_skin / K_skin) / cnst['skin']['V']
-        dC_bone_dt = cnst['bone']['Q'] * (C_A - C_bone / K_bone) / cnst['bone']['V']
-        # Kidney        V(Kidney)*dC(Kidney)/dt = Q(Kidney)*C(A)-Q(Kidney)*CV(Kidney)-CL(Kidney,int)*CV(Kidney,int)?
-        dC_kidney_dt = (cnst['kidney']['Q'] * (C_A - C_kidney / K_kidney) - CL_kidney * C_kidney / K_kidney_cl) / \
-                       cnst['kidney']['V']  # ???
-
-        # Liver         V(Liver)*dC(Liver)/dt = (Q(Liver)-Q(Spleen)-Q(Gut)-Q(Pancreas)-Q(Stomach))*C(A) + Q(Spleen)*CV(Spleen) +
-        #                                     + Q(Gut)*CV(Gut) + Q(Pancreas)*CV(Pancreas) + Q(Stomach)*CV(Stomach) -
-        #                                     - Q(Liver)*CV(Liver) - CL(Liver,int)*CV(Liver,int)? # тут скорее всего нужно вычитать потоки из друг друга дополнительно по крови что бы сохранить массовый баланс
-        Q_liver_in_from_art = cnst['liver']['Q'] - cnst['gut']['Q'] - cnst['spleen']['Q'] - \
-                              cnst['pancreas']['Q'] - cnst['stomach']['Q']
-        dC_liver_dt = (
-                              Q_liver_in_from_art * C_A + cnst['gut']['Q'] * C_gut / K_gut
-                              + cnst['spleen']['Q'] * C_spleen / K_spleen
-                              + cnst['stomach']['Q'] * C_stomach / K_stomach
-                              + cnst['pancreas']['Q'] * C_pancreas / K_pancreas
-                              - cnst['liver']['Q'] * C_liver / K_liver
-                              - CL_liver * C_liver / K_liver_cl  # ???
-                      ) / cnst['liver']['V']
-
-        dC_gut_dt = cnst['gut']['Q'] * (C_A - C_gut / K_gut) / cnst['gut']['V']
-        dC_spleen_dt = cnst['spleen']['Q'] * (C_A - C_spleen / K_spleen) / cnst['spleen']['V']
-        dC_stomach_dt = cnst['stomach']['Q'] * (C_A - C_stomach / K_stomach) / cnst['stomach']['V']
-        dC_pancreas_dt = cnst['pancreas']['Q'] * (C_A - C_pancreas / K_pancreas) / cnst['pancreas']['V']
-
-        dC_venouse_dt = (
-                                cnst['heart']['Q'] * C_heart / K_heart
-                                + cnst['brain']['Q'] * C_brain / K_brain
-                                + cnst['muscle']['Q'] * C_muscle / K_muscle
-                                + cnst['skin']['Q'] * C_skin / K_skin
-                                + cnst['adipose']['Q'] * C_fat / K_fat
-                                + cnst['bone']['Q'] * C_bone / K_bone
-                                + cnst['kidney']['Q'] * C_kidney / K_kidney
-                                + cnst['liver']['Q'] * C_liver / K_liver
-                                - cnst['lung']['Q'] * C_V
-                        ) / cnst['venous_blood']['V']
-
-        dC_arterial_dt = cnst['lung']['Q'] * (C_lung / K_lung - C_A) / cnst['arterial_blood']['V']
-
-        y_new = [dC_lung_dt, dC_heart_dt, dC_brain_dt, dC_muscle_dt, dC_fat_dt, dC_skin_dt, dC_bone_dt, \
-                 dC_kidney_dt, dC_liver_dt, dC_gut_dt, dC_spleen_dt, dC_stomach_dt, dC_pancreas_dt, dC_venouse_dt,
-                 dC_arterial_dt]
-        return y_new
-
-    @staticmethod
-    @njit
-    def numba_fullPBPK_for_optimization(y, t, K_CL, cnst_q, cnst_v):
-        C_lung, C_heart, C_brain, C_muscle, C_fat, C_skin, C_bone, \
-            C_kidney, C_liver, C_gut, C_spleen, C_stomach, C_pancreas, C_V, C_A = y
-
-        K_lung, K_heart, K_brain, K_muscle, K_fat, K_skin, K_bone, \
-            K_kidney, K_liver, K_gut, K_spleen, K_stomach, K_pancreas, K_liver_cl, K_kidney_cl = K_CL[:15]
-        CL_kidney, CL_liver = K_CL[15:]
-
-        dC_lung_dt = cnst_q['lung'] * (C_V - C_lung / K_lung) / cnst_v['lung']
-        dC_heart_dt = cnst_q['heart'] * (C_A - C_heart / K_heart) / cnst_v['heart']
-        dC_brain_dt = cnst_q['brain'] * (C_A - C_brain / K_brain) / cnst_v['brain']
-        dC_muscle_dt = cnst_q['muscle'] * (C_A - C_muscle / K_muscle) / cnst_v['muscle']
-        dC_fat_dt = cnst_q['adipose'] * (C_A - C_fat / K_fat) / cnst_v['adipose']
-        dC_skin_dt = cnst_q['skin'] * (C_A - C_skin / K_skin) / cnst_v['skin']
-        dC_bone_dt = cnst_q['bone'] * (C_A - C_bone / K_bone) / cnst_v['bone']
-        # Kidney        V(Kidney)*dC(Kidney)/dt = Q(Kidney)*C(A)-Q(Kidney)*CV(Kidney)-CL(Kidney,int)*CV(Kidney,int)?
-        dC_kidney_dt = (cnst_q['kidney'] * (C_A - C_kidney / K_kidney) - CL_kidney * C_kidney / K_kidney_cl) / \
-                       cnst_v['kidney']  # ???
-
-        # Liver         V(Liver)*dC(Liver)/dt = (Q(Liver)-Q(Spleen)-Q(Gut)-Q(Pancreas)-Q(Stomach))*C(A) + Q(Spleen)*CV(Spleen) +
-        #                                     + Q(Gut)*CV(Gut) + Q(Pancreas)*CV(Pancreas) + Q(Stomach)*CV(Stomach) -
-        #                                     - Q(Liver)*CV(Liver) - CL(Liver,int)*CV(Liver,int)? # тут скорее всего нужно вычитать потоки из друг друга дополнительно по крови что бы сохранить массовый баланс
-        Q_liver_in_from_art = cnst_q['liver'] - cnst_q['gut'] - cnst_q['spleen'] - \
-                              cnst_q['pancreas'] - cnst_q['stomach']
-        dC_liver_dt = (
-                              Q_liver_in_from_art * C_A + cnst_q['gut'] * C_gut / K_gut
-                              + cnst_q['spleen'] * C_spleen / K_spleen
-                              + cnst_q['stomach'] * C_stomach / K_stomach
-                              + cnst_q['pancreas'] * C_pancreas / K_pancreas
-                              - cnst_q['liver'] * C_liver / K_liver
-                              - CL_liver * C_liver / K_liver_cl  # ???
-                      ) / cnst_v['liver']
-
-        dC_gut_dt = cnst_q['gut'] * (C_A - C_gut / K_gut) / cnst_v['gut']
-        dC_spleen_dt = cnst_q['spleen'] * (C_A - C_spleen / K_spleen) / cnst_v['spleen']
-        dC_stomach_dt = cnst_q['stomach'] * (C_A - C_stomach / K_stomach) / cnst_v['stomach']
-        dC_pancreas_dt = cnst_q['pancreas'] * (C_A - C_pancreas / K_pancreas) / cnst_v['pancreas']
-
-        dC_venouse_dt = (
-                                cnst_q['heart'] * C_heart / K_heart
-                                + cnst_q['brain'] * C_brain / K_brain
-                                + cnst_q['muscle'] * C_muscle / K_muscle
-                                + cnst_q['skin'] * C_skin / K_skin
-                                + cnst_q['adipose'] * C_fat / K_fat
-                                + cnst_q['bone'] * C_bone / K_bone
-                                + cnst_q['kidney'] * C_kidney / K_kidney
-                                + cnst_q['liver'] * C_liver / K_liver
-                                - cnst_q['lung'] * C_V
-                        ) / cnst_v['venous_blood']
-
-        dC_arterial_dt = cnst_q['lung'] * (C_lung / K_lung - C_A) / cnst_v['arterial_blood']
-
-        y_new = np.array([dC_lung_dt, dC_heart_dt, dC_brain_dt, dC_muscle_dt, dC_fat_dt, dC_skin_dt, dC_bone_dt, \
-                 dC_kidney_dt, dC_liver_dt, dC_gut_dt, dC_spleen_dt, dC_stomach_dt, dC_pancreas_dt, dC_venouse_dt,
-                 dC_arterial_dt]).astype(np.float64)
-        return y_new